#!/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;