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.mdnew file mode 100644index 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.mdnew file mode 100644index 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.jsindex 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.mjsindex d1723c83..84e23c03 100644--- a/scripts/mcp-server.mjs+++ b/scripts/mcp-server.mjs@@ -839,7 +839,7 @@ export function createAgentMcpServer(runtime, { version = packageMetadata.versioregister('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.jsnew file mode 100644index 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.jsindex 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.jsnew file mode 100644index 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.jsnew file mode 100644index 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.mjsindex 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,