Skip to content

armgit / 67.js

Public Imported from GitHub
0

3D engine that AI agents drive

Answer scene_apply and mesh_edit with a result per operation and an ID diff (issue #651)

Nguyen Xuan Ane324b5318064
diff --git a/changes/651.md b/changes/651.md
new file mode 100644
index 00000000..8bced77f
--- /dev/null
+++ b/changes/651.md
@@ -0,0 +1 @@
+- scene_apply and mesh_edit answer with one entry per operation (index, op, target, what changed, a warning when nothing changed) and a diff of node, material and geometry IDs added, removed and changed; entries past 20 are counted, not listed (#651)
diff --git a/changes/651.size.md b/changes/651.size.md
new file mode 100644
index 00000000..370c24af
--- /dev/null
+++ b/changes/651.size.md
@@ -0,0 +1,4 @@
+- scene:agent-scene: describeApplication is exported from the agent-scene entry so library users get the same per-operation answer as MCP clients (77 bytes gzip).
+- scene:agent-scene+lazy: same export, 88 bytes gzip.
+- goal:agent-scene: the per-operation report saves agents a review call after every batch; it is 77 bytes gzip in the core entry.
+- tool:scene_apply: the description names the new results and diff fields, so an agent reads them instead of re-inspecting the scene (128 bytes).
diff --git a/scripts/agent-preview-browser.js b/scripts/agent-preview-browser.js
index fd1c19e9..b2be53d3 100644
--- a/scripts/agent-preview-browser.js
+++ b/scripts/agent-preview-browser.js
@@ -28,6 +28,7 @@ import { parseCube } from '../src/view-transform.js';
import { weightTracksFromGltfAnimation } from '../src/export-skeleton.js';
import { clipFromGltfAnimation } from '../src/skeleton-pose.js';
import { sessionProblem } from '../src/agent-errors.js';
+import { describeApplication } from '../src/agent-apply-report.js';
import { framingProblems, exposureProblems, lumaShares } from '../src/frame-checks.js';
import { BRANCH_LIMITS, createBranchStore, printableLabel } from '../src/agent-branches.js';
import { agentAssetDecodeOptions, withCatalogLimitAdvice } from '../src/agent-asset-limits.js';
@@ -1007,8 +1008,10 @@ window.__agentPreview = {
if (fogDensity > 0 && !record.renderer.capabilities.hdr) {
throw new Error('Volumetric fog requires HDR support; this preview cannot enable it.');
}
+ const before = typeof record.scene.exportRecipe === 'function' ? record.scene.exportRecipe() : null;
record.scene.apply(operations, { expectedRevision });
- return mutationStatus(record);
+ const report = before ? describeApplication(before, record.scene.exportRecipe(), operations) : {};
+ return { ...mutationStatus(record), ...report };
},
editMesh({ sessionId, expectedRevision, geometry, edits, replace }) {
const record = requireSession(sessionId);
diff --git a/scripts/mcp-server.mjs b/scripts/mcp-server.mjs
index d1723c83..84e23c03 100644
--- a/scripts/mcp-server.mjs
+++ b/scripts/mcp-server.mjs
@@ -839,7 +839,7 @@ export function createAgentMcpServer(runtime, { version = packageMetadata.versio
register('mesh_inspect', 'Check recipe geometries as polygon meshes: vertex, edge and face counts, triangles/quads/n-gons, connected and closed parts, face tags (top, bottom, side, left, right, front, back), bounds, and lint problems (non-manifold, inconsistent winding, inverted, degenerate, open, loose) with a suggested fix each. Also imported asset parts (mesh-0). Read-only and cached per geometry.', z.strictObject({ ...sessionFields, geometry: identifier.optional().describe('One geometry ID to check, as in mesh_edit.'), geometries: z.array(identifier).min(1).max(16).optional().describe('Geometry IDs to check. Omit both to check the first 16 geometries.') }), readOnly, async ({ geometry: geometryId, geometries, ...rest }) => jsonResult(await runtime.inspectMeshes({ ...rest, ...(geometries || geometryId ? { geometries: [...(geometries ?? []), ...(geometryId ? [geometryId] : [])] } : {}) })));
register('mesh_edit', 'Append edits to a recipe mesh geometry or an imported asset part such as mesh-0 (or replace its edit log), atomically like scene_apply: extrude, inset, delete, flip, translate with falloff, tag, loop cut, bevel, mirror, array, solidify, UV unwrap, set_position and displace with field expressions (math, noise, attributes), booleans with a primitive cutter, sculpt brush strokes and shrinkwrap onto a primitive. Edits that select no faces or break limits fail without changing the scene. Returns the new revision, render status and the mesh report with per-edit results.', z.strictObject({ ...sessionFields, expectedRevision, geometry: identifier.describe('ID of a geometry with type mesh, or an imported part such as mesh-0.'), edits: meshEdits.min(1), replace: z.boolean().optional().describe('Replace the whole edit log instead of appending.') }), edit, async argumentsValue => jsonResult(await runtime.editMesh(argumentsValue)));
register('mesh_stack', 'Set the non-destructive modifier stack of a recipe mesh geometry (ops and fields: scene_capabilities meshModifiers), evaluated after its edits, each prefix cached. apply: n moves the first n nodes into the edit log, as Blender\'s Apply modifier. Atomic like scene_apply. Returns the revision, render status and mesh report.', z.strictObject({ ...sessionFields, expectedRevision, geometry: identifier.describe('ID of a geometry with type mesh.'), stack: meshStack.optional().describe('The whole new stack. Omit to keep the current stack (for example with apply).'), apply: z.number().int().min(0).max(16).optional() }), edit, async argumentsValue => jsonResult(await runtime.setMeshStack(argumentsValue)));
- register('scene_apply', 'Atomically edit transforms, look, camera or materials. Procedural scenes support membership and set-motion authoring. Imported assets support set-root, set-asset-node, set-motion and absolute set-animation sampling. Successful batches increment revision once.', z.strictObject({ ...sessionFields, expectedRevision, operations: z.array(relations ? operation : operationWithoutRelations).min(1).max(256).describe('Node/material/camera/root/animation commands use flat fields. Motion, look patches and add commands contain nested records. Backend validates each scene mode before publication.'), ...branchField }), edit, async argumentsValue => jsonResult(await runtime.apply(argumentsValue)));
+ register('scene_apply', 'Atomically edit transforms, look, camera or materials. Procedural scenes support membership and set-motion authoring. Imported assets support set-root, set-asset-node, set-motion and absolute set-animation sampling. Successful batches increment revision once. Returns results (one entry per operation, with a warning when it changed nothing) and a diff of added, removed and changed IDs.', z.strictObject({ ...sessionFields, expectedRevision, operations: z.array(relations ? operation : operationWithoutRelations).min(1).max(256).describe('Node/material/camera/root/animation commands use flat fields. Motion, look patches and add commands contain nested records. Backend validates each scene mode before publication.'), ...branchField }), edit, async argumentsValue => jsonResult(await runtime.apply(argumentsValue)));
register('scene_look', 'Render the active scene as a bounded PNG, optionally with part labels. Optional authored motionTime seeks without changing revision; null restores the authored base pose. Omit to retain the last preview pose.', z.strictObject({ ...sessionFields, motionTime: z.number().min(0).max(3600).nullable().optional(), width: z.number().int().min(64).max(1024).default(768).describe('PNG width in pixels.'), height: z.number().int().min(64).max(1024).default(512).describe('PNG height in pixels.'), labels: labelsFlag }), readOnly, async argumentsValue => {
const { data, mimeType, metadata } = await runtime.look(argumentsValue);
return { content: [{ type: 'image', data, mimeType }, { type: 'text', text: JSON.stringify(metadata) }], structuredContent: metadata };
diff --git a/src/agent-apply-report.js b/src/agent-apply-report.js
new file mode 100644
index 00000000..85b8769b
--- /dev/null
+++ b/src/agent-apply-report.js
@@ -0,0 +1,161 @@
+// A short answer for scene_apply and mesh_edit: one entry per operation (what it did, or a warning that it did nothing)
+// and a compact diff of the node, material and geometry IDs the batch added, removed and changed. Pure recipe data in,
+// plain JSON out, so a library user gets the same answer as an MCP client.
+
+export const APPLY_REPORT_LIMITS = Object.freeze({ maxEntries: 20, maxDiffIds: 8, maxText: 48 });
+
+const COLLECTIONS = Object.freeze({ node: 'nodes', material: 'materials', geometry: 'geometries' });
+const LOOK_SECTIONS = Object.freeze({ 'set-environment': 'environment', 'set-effects': 'effects', 'set-shadow': 'shadow' });
+const OWN_SECTIONS = Object.freeze({
+ 'set-motion': 'motion', 'set-physics': 'physics', 'set-timeline': 'timeline', 'set-cloth': 'cloth',
+ 'set-bake': 'bake', 'set-particles': 'particles', 'set-post-passes': 'postPasses', 'set-armatures': 'armatures',
+});
+
+function isPlainObject(value) {
+ return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function sameValue(left, right) {
+ if (left === right) return true;
+ if (Array.isArray(left) && Array.isArray(right)) {
+ return left.length === right.length && left.every((item, index) => sameValue(item, right[index]));
+ }
+ if (isPlainObject(left) && isPlainObject(right)) {
+ const keys = Object.keys(left);
+ return keys.length === Object.keys(right).length && keys.every(key => Object.hasOwn(right, key) && sameValue(left[key], right[key]));
+ }
+ return false;
+}
+
+// True when every field of the patch already holds in the current value (nested patches merge, arrays compare whole).
+function patchHolds(current, patch) {
+ if (!isPlainObject(patch) || !isPlainObject(current)) {
+ return sameValue(current, patch);
+ }
+ return Object.keys(patch).every(key => patchHolds(current[key], patch[key]));
+}
+
+function mergePatch(current, patch) {
+ if (!isPlainObject(patch) || !isPlainObject(current)) {
+ return structuredClone(patch);
+ }
+ const merged = { ...current };
+ for (const key of Object.keys(patch)) {
+ merged[key] = mergePatch(current[key], patch[key]);
+ }
+ return merged;
+}
+
+function fieldNames(operation, skipped) {
+ return Object.keys(operation).filter(key => !skipped.includes(key));
+}
+
+function shortList(names, maxText) {
+ const text = names.join(', ');
+ return text.length > maxText ? `${text.slice(0, maxText - 1)}…` : text;
+}
+
+function targetOf(operation) {
+ const direct = operation.id ?? operation.geometry;
+ if (typeof direct === 'string') return direct;
+ for (const field of ['node', 'material', 'geometry']) {
+ if (typeof operation[field]?.id === 'string') return operation[field].id;
+ }
+ if (Object.hasOwn(LOOK_SECTIONS, operation.type)) return LOOK_SECTIONS[operation.type];
+ return operation.type === 'set-camera' ? 'camera' : undefined;
+}
+
+// Applies one operation to the working copy and says what it changed. Fields it cannot judge count as changed.
+function describeOperation(working, operation, maxText) {
+ const { type } = operation;
+ const add = /^add-(node|material|geometry)$/.exec(type);
+ if (add) {
+ const [, kind] = add;
+ working[COLLECTIONS[kind]].push(structuredClone(operation[kind]));
+ return { changed: `added ${kind}` };
+ }
+ const remove = /^remove-(node|material|geometry)$/.exec(type);
+ if (remove) {
+ const [, kind] = remove;
+ const collection = working[COLLECTIONS[kind]];
+ const index = collection.findIndex(record => record.id === operation.id);
+ if (index >= 0) collection.splice(index, 1);
+ return { changed: `removed ${kind}` };
+ }
+ const section = LOOK_SECTIONS[type] ?? (type === 'set-camera' ? 'camera' : null);
+ if (section) {
+ const patch = type === 'set-camera' ? Object.fromEntries(fieldNames(operation, ['type']).map(key => [key, operation[key]])) : operation[section];
+ if (patchHolds(working[section], patch)) return { warning: 'no change, values already set' };
+ const names = Object.keys(patch).filter(key => !patchHolds(working[section]?.[key], patch[key]));
+ working[section] = mergePatch(working[section] ?? {}, patch);
+ return { changed: shortList(names, maxText) };
+ }
+ if (type === 'set-node' || type === 'set-material') {
+ const collection = working[type === 'set-node' ? 'nodes' : 'materials'];
+ const target = collection.find(record => record.id === operation.id);
+ const names = fieldNames(operation, ['type', 'id']);
+ if (!target) return { changed: shortList(names, maxText) };
+ const differing = names.filter(name => !sameValue(target[name], operation[name]));
+ if (differing.length === 0) return { warning: 'no change, values already set' };
+ for (const name of differing) target[name] = structuredClone(operation[name]);
+ return { changed: shortList(differing, maxText) };
+ }
+ if (Object.hasOwn(OWN_SECTIONS, type)) {
+ const name = OWN_SECTIONS[type];
+ const next = operation[name] === null ? undefined : operation[name];
+ if (sameValue(working[name], next)) return { warning: 'no change, section already set' };
+ if (next === undefined) delete working[name];
+ else working[name] = structuredClone(next);
+ return { changed: operation[name] === null ? `cleared ${name}` : `set ${name}` };
+ }
+ if (type === 'edit-mesh') {
+ const count = Array.isArray(operation.edits) ? operation.edits.length : 0;
+ if (count === 0 && !operation.replace) return { warning: 'no change, no edits given' };
+ return { changed: `${operation.replace ? 'replaced the log with' : 'appended'} ${count} edit${count === 1 ? '' : 's'}` };
+ }
+ return { changed: shortList(fieldNames(operation, ['type', 'id']), maxText) || 'applied' };
+}
+
+function idDiff(before, after, cap) {
+ const beforeById = new Map(before.map(record => [record.id, record]));
+ const afterIds = new Set(after.map(record => record.id));
+ const added = after.filter(record => !beforeById.has(record.id)).map(record => record.id);
+ const removed = before.filter(record => !afterIds.has(record.id)).map(record => record.id);
+ const changed = after.filter(record => beforeById.has(record.id) && !sameValue(beforeById.get(record.id), record)).map(record => record.id);
+ const result = {};
+ for (const [name, ids] of [['added', added], ['removed', removed], ['changed', changed]]) {
+ if (ids.length > 0) {
+ result[name] = ids.length > cap ? [...ids.slice(0, cap), `+${ids.length - cap} more`] : ids;
+ }
+ }
+ return result;
+}
+
+/**
+ * @param {object} before The recipe before the batch (exportRecipe).
+ * @param {object} after The recipe after it.
+ * @param {object[]} operations The operations that were applied, in order.
+ * @returns {{ results: object[], omittedResults?: number, omittedWarnings?: number, diff: object }}
+ */
+export function describeApplication(before, after, operations, limits = APPLY_REPORT_LIMITS) {
+ const working = structuredClone(before);
+ for (const collection of Object.values(COLLECTIONS)) working[collection] ??= [];
+ const entries = operations.map((operation, index) => {
+ const outcome = describeOperation(working, operation, limits.maxText);
+ const target = targetOf(operation);
+ return { i: index, op: operation.type, ...(target === undefined ? {} : { target }), ...outcome };
+ });
+ const omitted = entries.slice(limits.maxEntries);
+ const omittedWarnings = omitted.filter(entry => entry.warning).length;
+ const diff = {};
+ for (const collection of Object.values(COLLECTIONS)) {
+ const part = idDiff(before[collection] ?? [], after[collection] ?? [], limits.maxDiffIds);
+ if (Object.keys(part).length > 0) diff[collection] = part;
+ }
+ return {
+ results: entries.slice(0, limits.maxEntries),
+ ...(omitted.length > 0 ? { omittedResults: omitted.length } : {}),
+ ...(omittedWarnings > 0 ? { omittedWarnings } : {}),
+ diff,
+ };
+}
diff --git a/src/agent-scene.js b/src/agent-scene.js
index 88906325..792525d8 100644
--- a/src/agent-scene.js
+++ b/src/agent-scene.js
@@ -13,6 +13,7 @@ import { depthLayerOf, MAXIMUM_DEPTH_LAYER } from './depth-layer.js';
import { armatureNodes, bakeRigExport, bindSkins, createSkinStages, normalizeArmatures, publishSkinPoses, restWorldMatrix, rigReport, stageSkinPoses, transformedBounds, withoutArmatureNodes } from './rig.js';
export { AGENT_SCENE_CAPABILITIES, AGENT_SCENE_DEFAULT_LIMITS };
export { normalizeAgentLook, resolveAgentShadow } from './agent-look.js';
+export { describeApplication } from './agent-apply-report.js';
export {
needsMeshBooleans, loadMeshBooleans, meshBooleansLoaded, setManifoldModuleLoader,
needsPhysics, loadPhysicsEngine, physicsEngineLoaded, setPhysicsModuleLoader,
diff --git a/tests/agent-apply-report.test.js b/tests/agent-apply-report.test.js
new file mode 100644
index 00000000..57504a90
--- /dev/null
+++ b/tests/agent-apply-report.test.js
@@ -0,0 +1,87 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { describeApplication } from '../src/agent-apply-report.js';
+
+function recipe() {
+ return {
+ format: '67js.scene', schemaVersion: 1,
+ geometries: [{ id: 'box', type: 'box' }],
+ materials: [{ id: 'paint', color: [0.2, 0.4, 0.6], roughness: 0.5 }],
+ nodes: [{ id: 'cube', geometry: 'box', material: 'paint', translation: [0, 0, 0] }],
+ camera: { position: [0, 1, 5], fov: 45 },
+ environment: { exposure: 1 },
+ };
+}
+
+// The report works on recipes, so each test builds the "after" recipe by hand.
+function report(operations, after) {
+ return describeApplication(recipe(), after, operations);
+}
+
+test('a mixed batch gets one entry per operation and a diff of IDs', () => {
+ const after = recipe();
+ after.nodes[0].translation = [1, 0, 0];
+ after.materials.push({ id: 'glass', color: [1, 1, 1] });
+ after.geometries.length = 0;
+ const result = report([
+ { type: 'set-node', id: 'cube', translation: [1, 0, 0] },
+ { type: 'add-material', material: { id: 'glass', color: [1, 1, 1] } },
+ { type: 'remove-geometry', id: 'box' },
+ { type: 'set-camera', fov: 60 },
+ ], after);
+ assert.deepEqual(result.results, [
+ { i: 0, op: 'set-node', target: 'cube', changed: 'translation' },
+ { i: 1, op: 'add-material', target: 'glass', changed: 'added material' },
+ { i: 2, op: 'remove-geometry', target: 'box', changed: 'removed geometry' },
+ { i: 3, op: 'set-camera', target: 'camera', changed: 'fov' },
+ ]);
+ assert.deepEqual(result.diff, {
+ nodes: { changed: ['cube'] },
+ materials: { added: ['glass'] },
+ geometries: { removed: ['box'] },
+ });
+});
+
+test('an operation that sets the values already there is a warning', () => {
+ const result = report([
+ { type: 'set-material', id: 'paint', color: [0.2, 0.4, 0.6], roughness: 0.5 },
+ { type: 'set-environment', environment: { exposure: 1 } },
+ { type: 'set-material', id: 'paint', roughness: 0.9 },
+ { type: 'set-material', id: 'paint', roughness: 0.9 },
+ ], recipe());
+ assert.equal(result.results[0].warning, 'no change, values already set');
+ assert.equal(result.results[1].warning, 'no change, values already set');
+ assert.equal(result.results[2].changed, 'roughness');
+ assert.equal(result.results[3].warning, 'no change, values already set');
+ assert.deepEqual(result.diff, {});
+});
+
+test('a 20-operation batch stays under 2 KB and a larger one says how many entries were cut', () => {
+ const operations = [];
+ const after = recipe();
+ for (let index = 0; index < 20; index += 1) {
+ operations.push({ type: 'set-node', id: 'cube', translation: [index + 1, 0, 0], rotation: [0, 0, 0, 1], scale: [1, 1, 1] });
+ }
+ after.nodes[0].translation = [20, 0, 0];
+ const twenty = report(operations, after);
+ assert.equal(twenty.results.length, 20);
+ assert.ok(JSON.stringify(twenty).length < 2048, `${JSON.stringify(twenty).length} bytes`);
+
+ const extra = { type: 'set-node', id: 'cube', translation: [20, 0, 0] };
+ const cut = report([...operations, extra, extra], after);
+ assert.equal(cut.results.length, 20);
+ assert.equal(cut.omittedResults, 2);
+ assert.equal(cut.omittedWarnings, 2);
+});
+
+test('the diff caps a long ID list', () => {
+ const after = recipe();
+ const operations = [];
+ for (let index = 0; index < 12; index += 1) {
+ after.nodes.push({ id: `n${index}` });
+ operations.push({ type: 'add-node', node: { id: `n${index}` } });
+ }
+ const result = report(operations, after);
+ assert.equal(result.diff.nodes.added.length, 9);
+ assert.equal(result.diff.nodes.added.at(-1), '+4 more');
+});
diff --git a/tests/agent-apply-results.test.js b/tests/agent-apply-results.test.js
new file mode 100644
index 00000000..c558e362
--- /dev/null
+++ b/tests/agent-apply-results.test.js
@@ -0,0 +1,45 @@
+import './support/load-agent-scene-modules.mjs';
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { previewHarness } from './support/preview-harness.mjs';
+
+const recipe = {
+ format: '67js.scene', schemaVersion: 1,
+ geometries: [{ id: 'cube', type: 'box' }],
+ materials: [{ id: 'blue', color: [0.1, 0.3, 0.8] }],
+ nodes: [{ id: 'mesh', geometry: 'cube', material: 'blue' }],
+};
+
+function createSession(sessionId) {
+ const { preview } = previewHarness();
+ preview.create({ recipe, sessionId, backend: 'cpu', memoryBudgetMiB: 64 });
+ return preview;
+}
+
+test('the preview answers a 3-operation batch with results and a diff, and flags the no-op', () => {
+ const preview = createSession('three');
+ const answer = preview.apply({ sessionId: 'three', expectedRevision: 0, operations: [
+ { type: 'set-node', id: 'mesh', translation: [1, 0, 0] },
+ { type: 'set-material', id: 'blue', color: [0.1, 0.3, 0.8] },
+ { type: 'add-material', material: { id: 'red', color: [1, 0, 0] } },
+ ] });
+ assert.deepEqual(answer.results, [
+ { i: 0, op: 'set-node', target: 'mesh', changed: 'translation' },
+ { i: 1, op: 'set-material', target: 'blue', warning: 'no change, values already set' },
+ { i: 2, op: 'add-material', target: 'red', changed: 'added material' },
+ ]);
+ assert.deepEqual(answer.diff, { nodes: { changed: ['mesh'] }, materials: { added: ['red'] } });
+});
+
+test('a 20-operation batch adds under 2 KB to the answer', () => {
+ const preview = createSession('twenty');
+ const operations = [];
+ for (let index = 0; index < 20; index += 1) {
+ operations.push({ type: 'set-node', id: 'mesh', translation: [index + 1, 0, 0], scale: [1, 1, 1] });
+ }
+ const { results, diff, omittedResults } = preview.apply({ sessionId: 'twenty', expectedRevision: 0, operations });
+ assert.equal(results.length, 20);
+ assert.equal(omittedResults, undefined);
+ const bytes = JSON.stringify({ results, diff }).length;
+ assert.ok(bytes < 2048, `${bytes} bytes`);
+});
diff --git a/tests/support/preview-harness.mjs b/tests/support/preview-harness.mjs
index cf640d81..feb1b93f 100644
--- a/tests/support/preview-harness.mjs
+++ b/tests/support/preview-harness.mjs
@@ -13,6 +13,7 @@ import { hasPatternTextures } from '../../scripts/agent-preview-textures.js';
import { assetCopyKey, recipeAssetNeeds } from '../../src/agent-scene-assets.js';
import { BRANCH_LIMITS, createBranchStore, printableLabel } from '../../src/agent-branches.js';
import { sessionProblem } from '../../src/agent-errors.js';
+import { describeApplication } from '../../src/agent-apply-report.js';
import { framingProblems, exposureProblems, lumaShares } from '../../src/frame-checks.js';
import { agentAssetDecodeOptions, withCatalogLimitAdvice } from '../../src/agent-asset-limits.js';
import { sceneQueryFor, summarizeWalkMap, walkOptionsFor, createQueryOnlyCache } from '../../scripts/agent-walkmap.js';
@@ -81,7 +82,7 @@ export function previewHarness() {
// The harness loads Manifold from node_modules directly, so the preview's served-file loader is ignored.
setManifoldModuleLoader: () => {},
needsPhysics, loadPhysicsEngine, physicsEngineLoaded, setPhysicsModuleLoader: () => {},
- sceneQueryFor, summarizeWalkMap, walkOptionsFor, createQueryOnlyCache, parseGltf, hasPatternTextures, Uint8Array, atob, sessionProblem, framingProblems, exposureProblems, lumaShares, assetCopyKey, recipeAssetNeeds, agentAssetDecodeOptions, withCatalogLimitAdvice,
+ sceneQueryFor, summarizeWalkMap, walkOptionsFor, createQueryOnlyCache, parseGltf, hasPatternTextures, Uint8Array, atob, sessionProblem, describeApplication, framingProblems, exposureProblems, lumaShares, assetCopyKey, recipeAssetNeeds, agentAssetDecodeOptions, withCatalogLimitAdvice,
applyProjection, applyCameraFields, mat4, resolveAgentShadow, agentEnvironmentMap, BRANCH_LIMITS,
// Line art needs a real renderer with render passes, so the fault-injected one gets a no-op install.
agentSceneModule: name => (name === 'lineArt' ? { installLineArt: renderer => renderer } : name === 'userPass' ? { ...agentSceneModule(name), installUserPasses: renderer => renderer } : agentSceneModule(name)), agentSceneModuleLoaded, createBranchStore, printableLabel,