MotrixSimWeb/scripts/verify-real-backend-editing.mjs
2026-06-25 15:54:32 +08:00

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;