726 lines
30 KiB
JavaScript
726 lines
30 KiB
JavaScript
#!/usr/bin/env node
|
|
import { mkdir, writeFile } from "node:fs/promises";
|
|
import path from "node:path";
|
|
|
|
const manifestUrl = new URL(process.argv[2] ?? process.env.MOTRIXSIM_MANIFEST_URL ?? "http://127.0.0.1:18090/manifest");
|
|
const outDir = process.argv[3] ?? "test-results/real-backend-editing";
|
|
const fetchTimeoutMs = Number(process.env.FETCH_TIMEOUT_MS ?? "15000");
|
|
const stateTimeoutMs = Number(process.env.STATE_TIMEOUT_MS ?? "30000");
|
|
const controlTimeoutMs = Number(process.env.CONTROL_TIMEOUT_MS ?? "10000");
|
|
const maxControlLatencyMs = Number(process.env.CONTROL_MAX_MS ?? "3000");
|
|
const composeTimeoutMs = Number(process.env.COMPOSE_TIMEOUT_MS ?? "45000");
|
|
const maxComposeLatencyMs = Number(process.env.COMPOSE_MAX_MS ?? "30000");
|
|
const minEditableGroups = Number(process.env.MIN_EDITABLE_GROUPS ?? "1");
|
|
const minGroupedObjects = Number(process.env.MIN_GROUPED_OBJECTS ?? "2");
|
|
const minAnchors = Number(process.env.MIN_EDITABLE_ANCHORS ?? "1");
|
|
const minMembers = Number(process.env.MIN_EDITABLE_MEMBERS ?? "1");
|
|
const stabilityRunMs = Number(process.env.STABILITY_RUN_MS ?? "2500");
|
|
const maxStaticAnchorDrift = Number(process.env.MAX_STATIC_ANCHOR_DRIFT ?? "0.01");
|
|
const expectedPhysicalRobotPose = [1.85, -0.95, 0];
|
|
const composeObjects = [
|
|
{ id: "product_gate_red_cube", presetId: "red-cube", position: [0.72, -0.48, 0.08] },
|
|
{ id: "product_gate_blue_crate", presetId: "blue-crate", position: [1, -0.48, 0.08] },
|
|
{ id: "product_gate_green_ball", presetId: "green-ball", position: [1.28, -0.48, 0.09] },
|
|
{ id: "product_gate_yellow_capsule", presetId: "yellow-capsule", position: [1.56, -0.48, 0.08] },
|
|
];
|
|
|
|
function vec3Near(left, right, epsilon = 0.05) {
|
|
return Array.isArray(left)
|
|
&& Array.isArray(right)
|
|
&& left.length >= 3
|
|
&& right.length >= 3
|
|
&& left.slice(0, 3).every((value, index) => Math.abs(Number(value) - Number(right[index])) <= epsilon);
|
|
}
|
|
|
|
function nowIso() {
|
|
return new Date().toISOString();
|
|
}
|
|
|
|
async function fetchJson(url, options = {}, timeoutMs = fetchTimeoutMs) {
|
|
const started = performance.now();
|
|
const controller = new AbortController();
|
|
const timeout = setTimeout(() => controller.abort(), timeoutMs);
|
|
try {
|
|
const response = await fetch(url, {
|
|
cache: "no-store",
|
|
...options,
|
|
signal: controller.signal,
|
|
});
|
|
const text = await response.text();
|
|
let json;
|
|
try {
|
|
json = JSON.parse(text);
|
|
} catch {
|
|
throw new Error(`non-JSON response from ${url}: ${text.slice(0, 160)}`);
|
|
}
|
|
return {
|
|
ok: response.ok,
|
|
status: response.status,
|
|
url: response.url,
|
|
elapsedMs: Math.round(performance.now() - started),
|
|
headers: Object.fromEntries(response.headers.entries()),
|
|
json,
|
|
};
|
|
} finally {
|
|
clearTimeout(timeout);
|
|
}
|
|
}
|
|
|
|
async function fetchText(url, options = {}, timeoutMs = fetchTimeoutMs) {
|
|
const started = performance.now();
|
|
const controller = new AbortController();
|
|
const timeout = setTimeout(() => controller.abort(), timeoutMs);
|
|
try {
|
|
const response = await fetch(url, {
|
|
cache: "no-store",
|
|
...options,
|
|
signal: controller.signal,
|
|
});
|
|
return {
|
|
ok: response.ok,
|
|
status: response.status,
|
|
url: response.url,
|
|
elapsedMs: Math.round(performance.now() - started),
|
|
headers: Object.fromEntries(response.headers.entries()),
|
|
text: await response.text(),
|
|
};
|
|
} finally {
|
|
clearTimeout(timeout);
|
|
}
|
|
}
|
|
|
|
async function fetchBinary(url, options = {}, timeoutMs = fetchTimeoutMs) {
|
|
const started = performance.now();
|
|
const controller = new AbortController();
|
|
const timeout = setTimeout(() => controller.abort(), timeoutMs);
|
|
try {
|
|
const response = await fetch(url, {
|
|
cache: "no-store",
|
|
...options,
|
|
signal: controller.signal,
|
|
});
|
|
const body = await response.arrayBuffer();
|
|
return {
|
|
ok: response.ok,
|
|
status: response.status,
|
|
url: response.url,
|
|
elapsedMs: Math.round(performance.now() - started),
|
|
headers: Object.fromEntries(response.headers.entries()),
|
|
byteLength: body.byteLength,
|
|
};
|
|
} finally {
|
|
clearTimeout(timeout);
|
|
}
|
|
}
|
|
|
|
async function postControl(controlUrl, action, payload = {}, timeoutMs = controlTimeoutMs) {
|
|
return fetchJson(controlUrl, {
|
|
method: "POST",
|
|
headers: { "Content-Type": "application/json" },
|
|
body: JSON.stringify({ action, compact: true, ...payload }),
|
|
}, timeoutMs);
|
|
}
|
|
|
|
function check(id, ok, detail, level = "fail") {
|
|
return { id, state: ok ? "pass" : level, detail };
|
|
}
|
|
|
|
function stateHashFromHeaders(headers) {
|
|
const raw = headers?.["x-motrix-state-hash"] ?? headers?.etag;
|
|
if (!raw) {
|
|
return undefined;
|
|
}
|
|
return String(raw).trim().replace(/^W\//, "").replace(/^"|"$/g, "") || undefined;
|
|
}
|
|
|
|
function numberHeader(headers, name) {
|
|
const value = Number(headers?.[name]);
|
|
return Number.isFinite(value) ? value : undefined;
|
|
}
|
|
|
|
function compressedJsonDetail(response) {
|
|
const jsonBytes = numberHeader(response?.headers, "x-motrix-json-bytes");
|
|
const wireBytes = numberHeader(response?.headers, "x-motrix-wire-bytes");
|
|
const encoding = response?.headers?.["x-motrix-encoding"] ?? response?.headers?.["content-encoding"] ?? "missing";
|
|
return {
|
|
encoding,
|
|
jsonBytes,
|
|
wireBytes,
|
|
ratio: jsonBytes && wireBytes ? wireBytes / jsonBytes : undefined,
|
|
ok: encoding === "gzip"
|
|
&& Number.isFinite(jsonBytes)
|
|
&& Number.isFinite(wireBytes)
|
|
&& wireBytes > 0
|
|
&& wireBytes < jsonBytes,
|
|
};
|
|
}
|
|
|
|
function compressedAssetDetail(response) {
|
|
const assetBytes = numberHeader(response?.headers, "x-motrix-asset-bytes");
|
|
const wireBytes = numberHeader(response?.headers, "x-motrix-asset-wire-bytes");
|
|
const encoding = response?.headers?.["x-motrix-asset-encoding"] ?? response?.headers?.["content-encoding"] ?? "missing";
|
|
const cache = response?.headers?.["x-motrix-asset-cache"] ?? "missing";
|
|
return {
|
|
encoding,
|
|
cache,
|
|
assetBytes,
|
|
wireBytes,
|
|
decompressedBytes: response?.byteLength,
|
|
ratio: assetBytes && wireBytes ? wireBytes / assetBytes : undefined,
|
|
ok: encoding === "gzip"
|
|
&& Number.isFinite(assetBytes)
|
|
&& Number.isFinite(wireBytes)
|
|
&& wireBytes > 0
|
|
&& wireBytes < assetBytes,
|
|
};
|
|
}
|
|
|
|
function meshAssetCandidates(sceneManifest) {
|
|
const seen = new Set();
|
|
const compressible = new Set([".dae", ".glb", ".gltf", ".mtl", ".obj", ".stl", ".urdf", ".xml"]);
|
|
const candidates = [];
|
|
for (const object of sceneManifest?.objects ?? []) {
|
|
const url = object?.geometry?.kind === "mesh" ? object.geometry.url : undefined;
|
|
if (!url) {
|
|
continue;
|
|
}
|
|
let absolute;
|
|
try {
|
|
absolute = new URL(url, manifestUrl).href;
|
|
} catch {
|
|
continue;
|
|
}
|
|
if (seen.has(absolute)) {
|
|
continue;
|
|
}
|
|
seen.add(absolute);
|
|
const pathname = new URL(absolute).pathname.toLowerCase();
|
|
const extensionMatch = pathname.match(/\.[a-z0-9]+$/);
|
|
const extension = extensionMatch?.[0] ?? "";
|
|
if (!compressible.has(extension)) {
|
|
continue;
|
|
}
|
|
const priority = [
|
|
extension === ".stl" ? 40 : 0,
|
|
extension === ".obj" ? 30 : 0,
|
|
/torso|pelvis|waist|hand|shelf/i.test(pathname) ? 20 : 0,
|
|
pathname.length,
|
|
].reduce((sum, value) => sum + value, 0);
|
|
candidates.push({
|
|
url: absolute,
|
|
objectId: object.id,
|
|
body: object.body,
|
|
format: object.geometry.format ?? extension.slice(1),
|
|
extension,
|
|
priority,
|
|
});
|
|
}
|
|
return candidates.sort((left, right) => right.priority - left.priority);
|
|
}
|
|
|
|
function bodySet(items) {
|
|
return new Set(items.filter((item) => typeof item === "string" && item.length > 0));
|
|
}
|
|
|
|
function sleep(ms) {
|
|
return new Promise((resolve) => setTimeout(resolve, ms));
|
|
}
|
|
|
|
function vectorDistance(left, right) {
|
|
if (!Array.isArray(left) || !Array.isArray(right)) {
|
|
return Number.POSITIVE_INFINITY;
|
|
}
|
|
const length = Math.min(left.length, right.length);
|
|
let sum = 0;
|
|
for (let index = 0; index < length; index += 1) {
|
|
sum += (Number(left[index]) - Number(right[index])) ** 2;
|
|
}
|
|
return Math.sqrt(sum);
|
|
}
|
|
|
|
function poseForBody(state, body) {
|
|
const pose = state?.bodies?.[body];
|
|
if (!pose?.pos || !pose?.quat) {
|
|
throw new Error(`missing pose for ${body}`);
|
|
}
|
|
return { body, pos: pose.pos, quat: pose.quat };
|
|
}
|
|
|
|
const checks = [];
|
|
let manifest;
|
|
let stateUrl;
|
|
let controlUrl;
|
|
let composeUrl;
|
|
let health;
|
|
let composeResult;
|
|
let composeCacheResult;
|
|
let composeCompression;
|
|
let composeCacheCompression;
|
|
let manifestCompression;
|
|
let assetCompression;
|
|
let assetCompressionResponse;
|
|
let selectedAsset;
|
|
let attemptedAssets = [];
|
|
let initialState;
|
|
let initialStateHash;
|
|
let repeatInitialStateHash;
|
|
let conditionalStateResponse;
|
|
let activeState;
|
|
let activeStateResponse;
|
|
let activeStateHash;
|
|
let finalState;
|
|
let selectedGroup;
|
|
let composedBodyResult;
|
|
let singleMemberResult;
|
|
let resumeResult;
|
|
let pauseResult;
|
|
let staticAnchorMaxDrift;
|
|
let composedBody;
|
|
let liftedComposedPose;
|
|
|
|
try {
|
|
const healthUrl = new URL("/health", manifestUrl).href;
|
|
const healthResponse = await fetchJson(healthUrl, {}, fetchTimeoutMs).catch((error) => ({
|
|
ok: false,
|
|
status: 0,
|
|
elapsedMs: 0,
|
|
json: { error: error.message },
|
|
url: healthUrl,
|
|
}));
|
|
health = healthResponse.json;
|
|
checks.push(check("health", healthResponse.ok && health?.ok === true, `HTTP ${healthResponse.status} in ${healthResponse.elapsedMs}ms`, "warn"));
|
|
composeUrl = health?.compose ? new URL(health.compose, manifestUrl).href : new URL("/compose", manifestUrl).href;
|
|
checks.push(check("compose-url", Boolean(composeUrl), composeUrl ?? "missing"));
|
|
const physicalComposePayload = {
|
|
scene: "g1-store-blocks-physics",
|
|
robot: "g1",
|
|
robotPose: expectedPhysicalRobotPose,
|
|
paused: true,
|
|
reset: true,
|
|
objects: composeObjects,
|
|
};
|
|
|
|
composeResult = await fetchJson(composeUrl, {
|
|
method: "POST",
|
|
headers: { "Content-Type": "application/json" },
|
|
body: JSON.stringify(physicalComposePayload),
|
|
}, composeTimeoutMs);
|
|
const inlineComposeObjects = composeResult.json?.manifest?.objects ?? [];
|
|
const inlineComposeBodies = new Set(inlineComposeObjects.map((object) => object?.body).filter(Boolean));
|
|
checks.push(check(
|
|
"physical-compose",
|
|
composeResult.ok && composeResult.json?.ok === true,
|
|
`${composeResult.elapsedMs}ms objectCount=${composeResult.json?.objectCount}`,
|
|
));
|
|
checks.push(check("physical-compose-latency", composeResult.elapsedMs <= maxComposeLatencyMs, `${composeResult.elapsedMs}ms <= ${maxComposeLatencyMs}ms`, "warn"));
|
|
checks.push(check(
|
|
"physical-compose-reset-applied",
|
|
composeResult.json?.resetApplied === true,
|
|
`resetApplied=${composeResult.json?.resetApplied}`,
|
|
));
|
|
checks.push(check("physical-compose-manifest", inlineComposeObjects.length > 0, `${inlineComposeObjects.length} inline objects`));
|
|
composeCompression = compressedJsonDetail(composeResult);
|
|
checks.push(check(
|
|
"physical-compose-json-gzip",
|
|
composeCompression.ok,
|
|
`${composeCompression.encoding} ${composeCompression.wireBytes ?? "-"} / ${composeCompression.jsonBytes ?? "-"} bytes ratio=${composeCompression.ratio?.toFixed(3) ?? "-"}`,
|
|
));
|
|
checks.push(check(
|
|
"physical-compose-objects",
|
|
composeObjects.every((item) => inlineComposeBodies.has(item.id)),
|
|
`${composeObjects.filter((item) => inlineComposeBodies.has(item.id)).length}/${composeObjects.length} composed bodies in inline manifest`,
|
|
));
|
|
composeCacheResult = await fetchJson(composeUrl, {
|
|
method: "POST",
|
|
headers: { "Content-Type": "application/json" },
|
|
body: JSON.stringify(physicalComposePayload),
|
|
}, composeTimeoutMs);
|
|
checks.push(check(
|
|
"physical-compose-cache",
|
|
composeCacheResult.ok && composeCacheResult.json?.cached === true && composeCacheResult.json?.composeKey === composeResult.json?.composeKey,
|
|
`${composeCacheResult.elapsedMs}ms cached=${composeCacheResult.json?.cached} key=${String(composeCacheResult.json?.composeKey ?? "").slice(0, 12)}`,
|
|
));
|
|
checks.push(check(
|
|
"physical-compose-cache-latency",
|
|
composeCacheResult.elapsedMs <= maxControlLatencyMs,
|
|
`${composeCacheResult.elapsedMs}ms <= ${maxControlLatencyMs}ms`,
|
|
"warn",
|
|
));
|
|
checks.push(check(
|
|
"physical-compose-cache-reset-applied",
|
|
composeCacheResult.json?.resetApplied === true,
|
|
`resetApplied=${composeCacheResult.json?.resetApplied}`,
|
|
));
|
|
composeCacheCompression = compressedJsonDetail(composeCacheResult);
|
|
checks.push(check(
|
|
"physical-compose-cache-json-gzip",
|
|
composeCacheCompression.ok,
|
|
`${composeCacheCompression.encoding} ${composeCacheCompression.wireBytes ?? "-"} / ${composeCacheCompression.jsonBytes ?? "-"} bytes ratio=${composeCacheCompression.ratio?.toFixed(3) ?? "-"}`,
|
|
));
|
|
|
|
const manifestResponse = await fetchJson(manifestUrl.href, {}, fetchTimeoutMs);
|
|
manifest = manifestResponse.json;
|
|
checks.push(check("manifest", manifestResponse.ok && Array.isArray(manifest?.objects), `HTTP ${manifestResponse.status} in ${manifestResponse.elapsedMs}ms`));
|
|
manifestCompression = compressedJsonDetail(manifestResponse);
|
|
checks.push(check(
|
|
"manifest-json-gzip",
|
|
manifestCompression.ok,
|
|
`${manifestCompression.encoding} ${manifestCompression.wireBytes ?? "-"} / ${manifestCompression.jsonBytes ?? "-"} bytes ratio=${manifestCompression.ratio?.toFixed(3) ?? "-"}`,
|
|
));
|
|
const assetCandidates = meshAssetCandidates(manifest).slice(0, 16);
|
|
checks.push(check("mesh-asset-candidates", assetCandidates.length > 0, `${assetCandidates.length} compressible mesh candidates`));
|
|
let bestAssetProbe;
|
|
for (const candidate of assetCandidates) {
|
|
const response = await fetchBinary(candidate.url, {
|
|
method: "HEAD",
|
|
headers: { "Accept-Encoding": "gzip" },
|
|
}, fetchTimeoutMs);
|
|
const detail = compressedAssetDetail(response);
|
|
attemptedAssets.push({
|
|
...candidate,
|
|
method: "HEAD",
|
|
status: response.status,
|
|
elapsedMs: response.elapsedMs,
|
|
compression: detail,
|
|
});
|
|
if (response.ok && detail.ok && (!bestAssetProbe || detail.assetBytes > bestAssetProbe.detail.assetBytes)) {
|
|
bestAssetProbe = { candidate, detail };
|
|
}
|
|
}
|
|
if (bestAssetProbe) {
|
|
const response = await fetchBinary(bestAssetProbe.candidate.url, {
|
|
headers: { "Accept-Encoding": "gzip" },
|
|
}, fetchTimeoutMs);
|
|
const detail = compressedAssetDetail(response);
|
|
attemptedAssets.push({
|
|
...bestAssetProbe.candidate,
|
|
method: "GET",
|
|
status: response.status,
|
|
elapsedMs: response.elapsedMs,
|
|
compression: detail,
|
|
});
|
|
if (response.ok && detail.ok) {
|
|
selectedAsset = bestAssetProbe.candidate;
|
|
assetCompressionResponse = response;
|
|
assetCompression = detail;
|
|
}
|
|
}
|
|
checks.push(check(
|
|
"mesh-asset-gzip",
|
|
Boolean(assetCompression?.ok),
|
|
selectedAsset
|
|
? `${selectedAsset.format} ${assetCompression.encoding} cache=${assetCompression.cache} ${assetCompression.wireBytes ?? "-"} / ${assetCompression.assetBytes ?? "-"} bytes ratio=${assetCompression.ratio?.toFixed(3) ?? "-"} url=${selectedAsset.url}`
|
|
: `no compressed mesh asset; attempted=${attemptedAssets.map((item) => `${item.method}:${item.extension}:${item.compression?.encoding ?? "missing"}`).join(",")}`,
|
|
));
|
|
checks.push(check(
|
|
"mesh-asset-gzip-cache",
|
|
assetCompression?.cache === "hit",
|
|
selectedAsset
|
|
? `${selectedAsset.format} cache=${assetCompression?.cache ?? "missing"} method=HEAD->GET url=${selectedAsset.url}`
|
|
: "no selected compressed mesh asset",
|
|
));
|
|
|
|
stateUrl = manifest?.state?.url ? new URL(manifest.state.url, manifestUrl).href : undefined;
|
|
controlUrl = manifest?.state?.controlUrl
|
|
? new URL(manifest.state.controlUrl, manifestUrl).href
|
|
: stateUrl?.replace(/\/state$/, "/control");
|
|
checks.push(check("state-url", Boolean(stateUrl), stateUrl ?? "missing"));
|
|
checks.push(check("control-url", Boolean(controlUrl), controlUrl ?? "missing"));
|
|
|
|
const groupedObjects = (manifest.objects ?? []).filter((object) => object?.editableGroup);
|
|
const anchors = groupedObjects.filter((object) => object.editableGroupRole === "anchor" && object.body);
|
|
const members = groupedObjects.filter((object) => object.editableGroupRole === "member" && object.body);
|
|
const groupMap = new Map();
|
|
for (const object of groupedObjects) {
|
|
if (!object?.body) {
|
|
continue;
|
|
}
|
|
const record = groupMap.get(object.editableGroup) ?? { id: object.editableGroup, anchors: [], members: [], bodies: [] };
|
|
record.bodies.push(object.body);
|
|
if (object.editableGroupRole === "anchor") {
|
|
record.anchors.push(object.body);
|
|
} else if (object.editableGroupRole === "member") {
|
|
record.members.push(object.body);
|
|
}
|
|
groupMap.set(object.editableGroup, record);
|
|
}
|
|
const groups = [...groupMap.values()]
|
|
.map((group) => ({ ...group, bodies: [...bodySet(group.bodies)] }))
|
|
.sort((left, right) => right.bodies.length - left.bodies.length);
|
|
selectedGroup = groups.find((group) => group.anchors.length > 0 && group.members.length > 0);
|
|
|
|
checks.push(check("editable-groups", groupMap.size >= minEditableGroups, `${groupMap.size} groups`));
|
|
checks.push(check("grouped-objects", groupedObjects.length >= minGroupedObjects, `${groupedObjects.length} grouped objects`));
|
|
checks.push(check("group-anchors", anchors.length >= minAnchors, `${anchors.length} anchors`));
|
|
checks.push(check("group-members", members.length >= minMembers, `${members.length} members`));
|
|
checks.push(check("selected-group", Boolean(selectedGroup), selectedGroup ? `${selectedGroup.id}: ${selectedGroup.bodies.length} bodies` : "no group with anchor and member"));
|
|
|
|
const pauseBeforeState = await postControl(controlUrl, "pause");
|
|
checks.push(check("pause-before-state", pauseBeforeState.ok && pauseBeforeState.json?.paused === true, `${pauseBeforeState.elapsedMs}ms paused=${pauseBeforeState.json?.paused}`));
|
|
checks.push(check("compact-pause-response", !("bodies" in (pauseBeforeState.json ?? {})), "pause response omits full bodies"));
|
|
|
|
const stateResponse = await fetchJson(stateUrl, {}, stateTimeoutMs);
|
|
initialState = stateResponse.json;
|
|
initialStateHash = stateHashFromHeaders(stateResponse.headers);
|
|
const repeatedStateResponse = await fetchJson(stateUrl, {}, stateTimeoutMs);
|
|
repeatInitialStateHash = stateHashFromHeaders(repeatedStateResponse.headers);
|
|
conditionalStateResponse = initialStateHash
|
|
? await fetchText(stateUrl, { headers: { "If-None-Match": `"${initialStateHash}"` } }, stateTimeoutMs)
|
|
: undefined;
|
|
const bodyCount = Object.keys(initialState?.bodies ?? {}).length;
|
|
checks.push(check("state", stateResponse.ok && bodyCount > 0, `${bodyCount} bodies in ${stateResponse.elapsedMs}ms`));
|
|
checks.push(check(
|
|
"state-hash-header",
|
|
Boolean(initialStateHash),
|
|
`hash=${initialStateHash?.slice(0, 12) ?? "missing"} etag=${stateResponse.headers?.etag ?? "missing"}`,
|
|
));
|
|
checks.push(check(
|
|
"paused-state-hash-stable",
|
|
Boolean(initialStateHash) && initialStateHash === repeatInitialStateHash,
|
|
`first=${initialStateHash?.slice(0, 12) ?? "missing"} repeat=${repeatInitialStateHash?.slice(0, 12) ?? "missing"}`,
|
|
));
|
|
checks.push(check(
|
|
"paused-state-not-modified",
|
|
conditionalStateResponse?.status === 304 && conditionalStateResponse.text.length === 0,
|
|
`status=${conditionalStateResponse?.status ?? "missing"} bytes=${conditionalStateResponse?.text.length ?? "-"} hash=${stateHashFromHeaders(conditionalStateResponse?.headers)?.slice(0, 12) ?? "missing"}`,
|
|
));
|
|
checks.push(check("state-paused", initialState?.paused === true, `paused=${initialState?.paused}`));
|
|
const pelvisPose = initialState?.bodies?.pelvis?.pos;
|
|
checks.push(check(
|
|
"robot-safe-initial-pose",
|
|
vec3Near(pelvisPose, [expectedPhysicalRobotPose[0], expectedPhysicalRobotPose[1], 0.793], 0.08),
|
|
`pelvis=${Array.isArray(pelvisPose) ? pelvisPose.map((value) => Number(value).toFixed(3)).join(",") : "missing"}`,
|
|
));
|
|
const activeStateUrl = new URL(stateUrl);
|
|
activeStateUrl.searchParams.set("bodies", "active");
|
|
activeStateResponse = await fetchJson(activeStateUrl.href, {}, stateTimeoutMs);
|
|
activeState = activeStateResponse.json;
|
|
activeStateHash = stateHashFromHeaders(activeStateResponse.headers);
|
|
const activeBodyCount = Object.keys(activeState?.bodies ?? {}).length;
|
|
checks.push(check(
|
|
"active-state",
|
|
activeStateResponse.ok && activeBodyCount > 0,
|
|
`${activeBodyCount} active bodies in ${activeStateResponse.elapsedMs}ms`,
|
|
));
|
|
checks.push(check(
|
|
"active-state-hash-header",
|
|
Boolean(activeStateHash),
|
|
`hash=${activeStateHash?.slice(0, 12) ?? "missing"} etag=${activeStateResponse.headers?.etag ?? "missing"}`,
|
|
));
|
|
checks.push(check(
|
|
"active-state-payload",
|
|
activeState?.bodyPayload?.mode === "active" && activeState?.bodyPayload?.count === activeBodyCount,
|
|
`mode=${activeState?.bodyPayload?.mode}; count=${activeState?.bodyPayload?.count}; total=${activeState?.bodyPayload?.total}`,
|
|
));
|
|
checks.push(check(
|
|
"active-state-reduced",
|
|
activeBodyCount < bodyCount && activeState?.bodyPayload?.total >= bodyCount,
|
|
`${activeBodyCount}/${bodyCount} bodies; filtered=${activeState?.bodyPayload?.filtered}`,
|
|
));
|
|
const fetchedManifestBodies = new Set((manifest.objects ?? []).map((object) => object?.body).filter(Boolean));
|
|
const composedBodiesInState = composeObjects.filter((item) => initialState?.bodies?.[item.id]);
|
|
const composedBodiesInActiveState = composeObjects.filter((item) => activeState?.bodies?.[item.id]);
|
|
checks.push(check(
|
|
"composed-objects-in-manifest",
|
|
composeObjects.every((item) => fetchedManifestBodies.has(item.id)),
|
|
`${composeObjects.filter((item) => fetchedManifestBodies.has(item.id)).length}/${composeObjects.length} composed bodies in fetched manifest`,
|
|
));
|
|
checks.push(check(
|
|
"composed-objects-in-state",
|
|
composedBodiesInState.length === composeObjects.length,
|
|
`${composedBodiesInState.length}/${composeObjects.length} composed bodies in live state`,
|
|
));
|
|
checks.push(check(
|
|
"composed-objects-in-active-state",
|
|
composedBodiesInActiveState.length === composeObjects.length,
|
|
`${composedBodiesInActiveState.length}/${composeObjects.length} composed bodies in active state`,
|
|
));
|
|
|
|
const availableGroupBodies = selectedGroup.bodies.filter((body) => initialState?.bodies?.[body]);
|
|
const missingGroupBodies = selectedGroup.bodies.filter((body) => !initialState?.bodies?.[body]);
|
|
checks.push(check("group-bodies-in-state", availableGroupBodies.length === selectedGroup.bodies.length, `${availableGroupBodies.length}/${selectedGroup.bodies.length} bodies available; missing=${missingGroupBodies.slice(0, 8).join(",")}`));
|
|
|
|
composedBody = composedBodiesInState[0]?.id;
|
|
const composedPose = poseForBody(initialState, composedBody);
|
|
liftedComposedPose = {
|
|
...composedPose,
|
|
pos: [composedPose.pos[0], composedPose.pos[1], composedPose.pos[2] + 0.45],
|
|
};
|
|
composedBodyResult = await postControl(controlUrl, "set_body_pose", liftedComposedPose);
|
|
checks.push(check(
|
|
"composed-object-pose",
|
|
composedBodyResult.ok && composedBodyResult.json?.updated_bodies?.[0] === composedBody,
|
|
`${composedBodyResult.elapsedMs}ms updated=${composedBodyResult.json?.updated_bodies?.join(",")}`,
|
|
));
|
|
checks.push(check("composed-object-latency", composedBodyResult.elapsedMs <= maxControlLatencyMs, `${composedBodyResult.elapsedMs}ms <= ${maxControlLatencyMs}ms`, "warn"));
|
|
|
|
const memberBody = selectedGroup.members.find((body) => initialState?.bodies?.[body]);
|
|
const memberPose = poseForBody(initialState, memberBody);
|
|
singleMemberResult = await postControl(controlUrl, "set_body_pose", memberPose);
|
|
checks.push(check(
|
|
"fixed-inventory-pose-rejected",
|
|
!singleMemberResult.ok && /fixed|cannot be moved|set_body_pose/i.test(singleMemberResult.json?.error ?? ""),
|
|
`${singleMemberResult.elapsedMs}ms status=${singleMemberResult.status} error=${singleMemberResult.json?.error ?? "-"}`,
|
|
));
|
|
checks.push(check("fixed-inventory-reject-latency", singleMemberResult.elapsedMs <= maxControlLatencyMs, `${singleMemberResult.elapsedMs}ms <= ${maxControlLatencyMs}ms`, "warn"));
|
|
|
|
const anchorReference = new Map(
|
|
selectedGroup.anchors
|
|
.filter((body) => initialState?.bodies?.[body])
|
|
.map((body) => [body, poseForBody(initialState, body)]),
|
|
);
|
|
|
|
resumeResult = await postControl(controlUrl, "resume");
|
|
checks.push(check("resume", resumeResult.ok && resumeResult.json?.paused === false, `${resumeResult.elapsedMs}ms paused=${resumeResult.json?.paused}`));
|
|
checks.push(check("resume-latency", resumeResult.elapsedMs <= maxControlLatencyMs, `${resumeResult.elapsedMs}ms <= ${maxControlLatencyMs}ms`, "warn"));
|
|
|
|
await sleep(stabilityRunMs);
|
|
|
|
pauseResult = await postControl(controlUrl, "pause");
|
|
checks.push(check("pause-after-resume", pauseResult.ok && pauseResult.json?.paused === true, `${pauseResult.elapsedMs}ms paused=${pauseResult.json?.paused}`));
|
|
checks.push(check("pause-latency", pauseResult.elapsedMs <= maxControlLatencyMs, `${pauseResult.elapsedMs}ms <= ${maxControlLatencyMs}ms`, "warn"));
|
|
|
|
const finalStateResponse = await fetchJson(stateUrl, {}, stateTimeoutMs);
|
|
finalState = finalStateResponse.json;
|
|
const anchorDrifts = [...anchorReference.entries()].map(([body, before]) => ({
|
|
body,
|
|
drift: vectorDistance(before.pos, finalState?.bodies?.[body]?.pos),
|
|
}));
|
|
staticAnchorMaxDrift = Math.max(0, ...anchorDrifts.map((item) => item.drift));
|
|
checks.push(check(
|
|
"static-shelf-anchor-stability",
|
|
anchorDrifts.length >= minAnchors && staticAnchorMaxDrift <= maxStaticAnchorDrift,
|
|
`${anchorDrifts.length} anchors; max drift ${staticAnchorMaxDrift.toFixed(5)}m after ${stabilityRunMs}ms`,
|
|
));
|
|
const finalComposedPose = finalState?.bodies?.[composedBody];
|
|
const composedDrop = liftedComposedPose && finalComposedPose
|
|
? liftedComposedPose.pos[2] - finalComposedPose.pos?.[2]
|
|
: 0;
|
|
checks.push(check(
|
|
"dynamic-composed-object-drop",
|
|
Number.isFinite(composedDrop) && composedDrop > 0.2,
|
|
`${composedBody ?? "-"} dropped ${composedDrop.toFixed(5)}m after resume`,
|
|
));
|
|
checks.push(check("final-state-paused", finalState?.paused === true, `paused=${finalState?.paused}; state in ${finalStateResponse.elapsedMs}ms`));
|
|
} catch (error) {
|
|
checks.push(check("unexpected-error", false, error?.stack ?? error?.message ?? String(error)));
|
|
}
|
|
|
|
const failed = checks.filter((item) => item.state === "fail").length;
|
|
const warned = checks.filter((item) => item.state === "warn").length;
|
|
const passed = checks.filter((item) => item.state === "pass").length;
|
|
const result = failed > 0 ? "fail" : warned > 0 ? "warn" : "pass";
|
|
const report = {
|
|
schema: "motrixsim-web.real-backend-editing.v1",
|
|
capturedAt: nowIso(),
|
|
manifestUrl: manifestUrl.href,
|
|
stateUrl,
|
|
controlUrl,
|
|
result,
|
|
summary: { passed, warned, failed, total: checks.length },
|
|
thresholds: {
|
|
fetchTimeoutMs,
|
|
stateTimeoutMs,
|
|
controlTimeoutMs,
|
|
composeTimeoutMs,
|
|
maxComposeLatencyMs,
|
|
maxControlLatencyMs,
|
|
stabilityRunMs,
|
|
maxStaticAnchorDrift,
|
|
minEditableGroups,
|
|
minGroupedObjects,
|
|
minAnchors,
|
|
minMembers,
|
|
},
|
|
health,
|
|
compose: composeResult
|
|
? {
|
|
url: composeUrl,
|
|
scene: composeResult.json?.scene,
|
|
cached: composeResult.json?.cached,
|
|
composeKey: composeResult.json?.composeKey,
|
|
objectCount: composeResult.json?.objectCount,
|
|
bodyCount: composeResult.json?.bodyCount,
|
|
jointCount: composeResult.json?.jointCount,
|
|
actuatorCount: composeResult.json?.actuatorCount,
|
|
elapsedMs: composeResult.elapsedMs,
|
|
compression: composeCompression,
|
|
objectIds: composeObjects.map((item) => item.id),
|
|
}
|
|
: undefined,
|
|
composeCache: composeCacheResult
|
|
? {
|
|
elapsedMs: composeCacheResult.elapsedMs,
|
|
cached: composeCacheResult.json?.cached,
|
|
composeKey: composeCacheResult.json?.composeKey,
|
|
objectCount: composeCacheResult.json?.objectCount,
|
|
compression: composeCacheCompression,
|
|
}
|
|
: undefined,
|
|
scene: manifest
|
|
? {
|
|
name: manifest.name,
|
|
objectCount: manifest.objects?.length ?? 0,
|
|
editableGroupCount: new Set((manifest.objects ?? []).map((object) => object.editableGroup).filter(Boolean)).size,
|
|
groupedObjectCount: (manifest.objects ?? []).filter((object) => object.editableGroup).length,
|
|
anchorCount: (manifest.objects ?? []).filter((object) => object.editableGroupRole === "anchor").length,
|
|
memberCount: (manifest.objects ?? []).filter((object) => object.editableGroupRole === "member").length,
|
|
physics: (manifest.objects ?? []).reduce((acc, object) => {
|
|
const role = object.physics ?? (object.body ? "unknown" : "visualOnly");
|
|
acc[role] = (acc[role] ?? 0) + 1;
|
|
return acc;
|
|
}, {}),
|
|
compression: manifestCompression,
|
|
assetCompression: selectedAsset
|
|
? {
|
|
selected: selectedAsset,
|
|
elapsedMs: assetCompressionResponse?.elapsedMs,
|
|
status: assetCompressionResponse?.status,
|
|
compression: assetCompression,
|
|
}
|
|
: undefined,
|
|
attemptedAssetCompression: attemptedAssets,
|
|
}
|
|
: undefined,
|
|
selectedGroup: selectedGroup
|
|
? {
|
|
id: selectedGroup.id,
|
|
bodyCount: selectedGroup.bodies.length,
|
|
anchorCount: selectedGroup.anchors.length,
|
|
memberCount: selectedGroup.members.length,
|
|
firstBodies: selectedGroup.bodies.slice(0, 8),
|
|
}
|
|
: undefined,
|
|
controlTimings: {
|
|
composedBodyMs: composedBodyResult?.elapsedMs,
|
|
fixedInventoryRejectMs: singleMemberResult?.elapsedMs,
|
|
staticAnchorMaxDrift,
|
|
dynamicDrop: liftedComposedPose && finalState?.bodies?.[composedBody]
|
|
? liftedComposedPose.pos[2] - finalState.bodies[composedBody].pos?.[2]
|
|
: undefined,
|
|
resumeMs: resumeResult?.elapsedMs,
|
|
pauseMs: pauseResult?.elapsedMs,
|
|
},
|
|
state: {
|
|
initialStep: initialState?.step,
|
|
initialPaused: initialState?.paused,
|
|
initialStateHash,
|
|
repeatInitialStateHash,
|
|
conditionalStatus: conditionalStateResponse?.status,
|
|
conditionalBytes: conditionalStateResponse?.text.length,
|
|
activeStateHash,
|
|
initialBodyCount: Object.keys(initialState?.bodies ?? {}).length,
|
|
activeBodyCount: Object.keys(activeState?.bodies ?? {}).length,
|
|
activePayload: activeState?.bodyPayload,
|
|
activeElapsedMs: activeStateResponse?.elapsedMs,
|
|
finalStep: finalState?.step,
|
|
finalPaused: finalState?.paused,
|
|
},
|
|
checks,
|
|
};
|
|
|
|
await mkdir(outDir, { recursive: true });
|
|
await writeFile(path.join(outDir, "real-backend-editing-evidence.json"), `${JSON.stringify(report, null, 2)}\n`);
|
|
console.log(JSON.stringify(report, null, 2));
|
|
process.exitCode = failed > 0 ? 1 : 0;
|