@pascal-app/mcp 1.0.3 → 1.0.5

package/dist/tools/add-object.js

@@ -0,0 +1,187 @@
+import { isScriptedNode, scriptedObjectMeta } from '@pascal-app/core';
+import { achievedChanges, addObject, authoredObject, editedScriptLanguage, editedScriptParams, furnishingRefusal, readableScript, readSourceResult, requireAddObjectReason, } from '@pascal-app/core/agent-operations';
+import { addObjectTool, CATALOG_SOURCE, getSourceTool, isAgentRefusal, refuse, } from '@pascal-app/core/agent-tools';
+import { GEOMETRY_SCRIPT_MIME_TYPES, GeometryArtifactMetadata, GeometryReuseFields, generateId, } from '@pascal-app/core/schema';
+import { z } from 'zod';
+import { DESTRUCTIVE_TOOL_ANNOTATIONS, READ_ONLY_TOOL_ANNOTATIONS } from './annotations.js';
+import { refusalResult, toolError } from './errors.js';
+import { persistencePayload, publishLiveSceneSnapshot } from './live-sync.js';
+import { briefInForce, toPatches } from './shared-tools.js';
+/** The kind an artifact records; a room's floor finish and a wall face's are none of the node kinds. */
+const ARTIFACT_KIND = {
+    object: 'item',
+    window: 'window',
+    door: 'door',
+    column: 'column',
+    floor: undefined,
+    'wall-face': undefined,
+};
+/** Compiles a module on the host and stores its GLB and text for the scene: the step every scripted tool shares. */
+export async function compileAndStore(host, sceneId, { code, language, params, inputs, }, kind, context = {}) {
+    const nodeId = context.nodeId ?? generateId(ARTIFACT_KIND[kind] ?? 'item');
+    const metadata = GeometryArtifactMetadata.parse({
+        ...context.metadata,
+        kind: ARTIFACT_KIND[kind],
+    });
+    if (host.build)
+        return {
+            ...(await host.build({ sceneId, code, language, params, inputs, kind, nodeId, metadata })),
+            nodeId,
+        };
+    const { glb, ...compiled } = await host.compile({ code, language, params, inputs });
+    metadata.mount = compiled.mount;
+    const [sha256] = await Promise.all([
+        host.storeArtifact({
+            sceneId,
+            nodeId,
+            metadata,
+            sha256: compiled.sha256,
+            bytes: glb,
+            mimeType: 'model/gltf-binary',
+        }),
+        host.storeArtifact({
+            sceneId,
+            nodeId,
+            metadata,
+            sha256: compiled.script,
+            bytes: new TextEncoder().encode(code),
+            mimeType: GEOMETRY_SCRIPT_MIME_TYPES[language],
+        }),
+    ]);
+    return { ...compiled, sha256, nodeId };
+}
+async function scriptText(host, sceneId, node) {
+    const bytes = await host.readArtifact({ sceneId, sha256: node.source.script });
+    if (!bytes)
+        throw new Error(`The script of ${node.id} could not be read`);
+    return new TextDecoder().decode(bytes);
+}
+export function readScript(host, sceneId, bridge, nodeId) {
+    return scriptText(host, sceneId, authoredObject(bridge.getNodes(), nodeId));
+}
+/**
+ * One object's module compiled and stored by the host: a new one from its code, an edit from its
+ * code or its stored script, with the params it keeps. The step a lone add_object and each
+ * add_object of a run_batch share.
+ */
+export async function compileObject(host, sceneId, bridge, args) {
+    const code = args.code ??
+        (args.nodeId ? await readScript(host, sceneId, bridge, args.nodeId) : refuseMissingCode());
+    const nodes = bridge.getNodes();
+    const previous = args.nodeId ? nodes[args.nodeId] : undefined;
+    const language = editedScriptLanguage(previous, args);
+    const params = editedScriptParams(previous, args.params);
+    return compileAndStore(host, sceneId, { code, language, params }, 'object', {
+        nodeId: args.nodeId,
+        metadata: {
+            ...(isScriptedNode(previous) ? scriptedObjectMeta(previous) : {}),
+            ...GeometryReuseFields.parse(args),
+        },
+    });
+}
+/** What a batch's add_object builds with: the host's compile, on the scene open now. */
+export async function compileObjectOnHost(host, bridge, args) {
+    if (!host)
+        refuse('scripts_unavailable', 'This Pascal server cannot run geometry scripts.');
+    const scene = bridge.getActiveScene();
+    if (!scene)
+        refuse('no_active_scene', 'Open or save a scene first: authored objects are stored with a scene.');
+    return compileObject(host, scene.id, bridge, args);
+}
+/** `add_object` on the MCP: the shared contract and operation, with the host's compile in front. */
+export function registerAddObject(server, bridge, host) {
+    server.registerTool(addObjectTool.name, {
+        title: addObjectTool.title,
+        description: addObjectTool.description,
+        inputSchema: z.object(addObjectTool.input),
+        annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
+    }, async (input) => {
+        const brief = briefInForce(bridge);
+        if (brief !== undefined) {
+            const refusal = furnishingRefusal(addObjectTool.name, input, brief);
+            if (refusal)
+                return refusalResult(refusal);
+        }
+        if (!host) {
+            return toolError('This Pascal server cannot run geometry scripts.', {
+                code: 'scripts_unavailable',
+            });
+        }
+        const scene = bridge.getActiveScene();
+        if (!scene) {
+            return toolError('Open or save a scene first: authored objects are stored with a scene.', {
+                code: 'no_active_scene',
+            });
+        }
+        const args = input;
+        let compiled;
+        try {
+            requireAddObjectReason(args);
+            compiled = await compileObject(host, scene.id, bridge, args);
+        }
+        catch (error) {
+            if (isAgentRefusal(error))
+                return refusalResult(error);
+            return toolError(`${error instanceof Error ? error.message : String(error)} ${CATALOG_SOURCE}`, { code: 'script_failed' });
+        }
+        // A copy: the hosted bridge writes its map in place, and a "before" that grows with the call
+        // reads every creation as unchanged.
+        const before = { ...bridge.getNodes() };
+        let outcome;
+        try {
+            outcome = addObject(before, { ...args, compiled }, { activeLevelId: bridge.activeLevelId?.() ?? null });
+        }
+        catch (error) {
+            return refusalResult(error);
+        }
+        const patches = outcome.changes ? toPatches(outcome.changes) : [];
+        if (patches.length)
+            bridge.applyPatch(patches);
+        const payload = {
+            ...outcome.result,
+            // What the scene holds now, as every write answers.
+            achieved: achievedChanges(before, outcome.changes ?? {}),
+            ...persistencePayload(await publishLiveSceneSnapshot(bridge, addObjectTool.name)),
+        };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(payload) }],
+            structuredContent: payload,
+        };
+    });
+}
+function refuseMissingCode() {
+    refuse('code_required', 'Pass code to build a new object; params alone rebuild an existing one (nodeId).');
+}
+/** `get_source` on the MCP: the object's module text, read back through the host's store. */
+export function registerGetSource(server, bridge, host) {
+    server.registerTool(getSourceTool.name, {
+        title: getSourceTool.title,
+        description: getSourceTool.description,
+        inputSchema: z.object(getSourceTool.input),
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+    }, async ({ nodeId, face }) => {
+        if (!host) {
+            return toolError('This Pascal server cannot read geometry scripts.', {
+                code: 'scripts_unavailable',
+            });
+        }
+        const scene = bridge.getActiveScene();
+        if (!scene)
+            return toolError('Open a scene first.', { code: 'no_active_scene' });
+        try {
+            const node = readableScript(bridge.getNodes(), nodeId, face);
+            const payload = readSourceResult(node, await scriptText(host, scene.id, node));
+            return {
+                content: [{ type: 'text', text: JSON.stringify(payload) }],
+                structuredContent: payload,
+            };
+        }
+        catch (error) {
+            if (isAgentRefusal(error))
+                return refusalResult(error);
+            return toolError(error instanceof Error ? error.message : String(error), {
+                code: 'script_unreadable',
+            });
+        }
+    });
+}

package/dist/tools/annotations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"annotations.d.ts","sourceRoot":"","sources":["../../src/tools/annotations.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,0BAA0B;;;;;CAK7B,CAAA;AAEV,eAAO,MAAM,qCAAqC;;;;;CAKxC,CAAA;AAEV,eAAO,MAAM,yBAAyB;;;;CAI5B,CAAA;AAEV,eAAO,MAAM,4BAA4B;;;;CAI/B,CAAA;AAEV,eAAO,MAAM,uCAAuC;;;;CAI1C,CAAA"}
+{"version":3,"file":"annotations.d.ts","sourceRoot":"","sources":["../../src/tools/annotations.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,0BAA0B;aACrC,YAAY;aACZ,eAAe;aACf,cAAc;aACd,aAAa;CACL,CAAA;AAEV,eAAO,MAAM,qCAAqC;aAChD,YAAY;aACZ,eAAe;aACf,cAAc;aACd,aAAa;CACL,CAAA;AAEV,eAAO,MAAM,yBAAyB;aACpC,YAAY;aACZ,eAAe;aACf,aAAa;CACL,CAAA;AAEV,eAAO,MAAM,4BAA4B;aACvC,YAAY;aACZ,eAAe;aACf,aAAa;CACL,CAAA;AAEV,eAAO,MAAM,uCAAuC;aAClD,YAAY;aACZ,eAAe;aACf,aAAa;CACL,CAAA"}

package/dist/tools/apply-patch.d.ts

@@ -1,6 +1,9 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 import { z } from 'zod';
 import type { SceneOperations } from '../operations/index.js';
+import './honest-patch-guard.js';
+import './level-height-guard.js';
+import './roof-level-guard.js';
 export declare const applyPatchInput: {
     patches: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         op: z.ZodLiteral<"create">;
@@ -17,16 +20,20 @@ export declare const applyPatchInput: {
     }, z.core.$strip>], "op">>;
 };
 export declare const applyPatchOutput: {
+    project: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    unsaved: z.ZodOptional<z.ZodString>;
     persistence: z.ZodOptional<z.ZodObject<{
         status: z.ZodEnum<{
-            unbound: "unbound";
             events_unsupported: "events_unsupported";
+            unbound: "unbound";
         }>;
         warning: z.ZodString;
     }, z.core.$strip>>;
     appliedOps: z.ZodNumber;
     deletedIds: z.ZodArray<z.ZodString>;
     createdIds: z.ZodArray<z.ZodString>;
+    /** What the server changed in the patch before writing it, one line each. */
+    notes: z.ZodOptional<z.ZodArray<z.ZodString>>;
 };
 export declare function registerApplyPatch(server: McpServer, bridge: SceneOperations): void;
 //# sourceMappingURL=apply-patch.d.ts.map

package/dist/tools/apply-patch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"apply-patch.d.ts","sourceRoot":"","sources":["../../src/tools/apply-patch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAExE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAMpD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;CAE3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;;;CAK5B,CAAA;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAqDnF"}
+{"version":3,"file":"apply-patch.d.ts","sourceRoot":"","sources":["../../src/tools/apply-patch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAG7D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAGpD,OAAO,sBAAsB,CAAA;AAC7B,OAAO,sBAAsB,CAAA;AAC7B,OAAO,oBAAoB,CAAA;AAK3B,eAAO,MAAM,eAAe;IAC1B,OAAO;;;;;;;;;;;;;CACR,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;IAI3B,6EAA6E;;CAG9E,CAAA;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAgFnF"}

package/dist/tools/apply-patch.js

@@ -1,7 +1,12 @@
+import { isAgentRefusal } from '@pascal-app/core/agent-tools';
 import { z } from 'zod';
 import { DESTRUCTIVE_TOOL_ANNOTATIONS } from './annotations.js';
-import { ErrorCode, throwMcpError } from './errors.js';
+import { ProtocolError, ProtocolErrorCode, refusalResult, throwMcpError } from './errors.js';
+import './honest-patch-guard.js';
+import './level-height-guard.js';
+import './roof-level-guard.js';
 import { liveSyncOutput, persistencePayload, publishLiveSceneSnapshot } from './live-sync.js';
+import { assertPatchKeepsIdentity, PatchRefusedError, runPatchGuards } from './patch-guards.js';
 import { PatchSchema } from './schemas.js';
 export const applyPatchInput = {
     patches: z.array(PatchSchema),
@@ -10,14 +15,16 @@ export const applyPatchOutput = {
     appliedOps: z.number(),
     deletedIds: z.array(z.string()),
     createdIds: z.array(z.string()),
+    /** What the server changed in the patch before writing it, one line each. */
+    notes: z.array(z.string()).optional(),
     ...liveSyncOutput,
 };
 export function registerApplyPatch(server, bridge) {
     server.registerTool('apply_patch', {
         title: 'Apply patch',
-        description: 'Apply a batch of create/update/delete operations atomically. All patches are validated before any are applied; the entire batch forms a single undo step. Batch-first is the default: prefer one apply_patch call containing all create/update/delete ops for a build step, in stable order so later ops can reference ids created by earlier ops. A single call is atomic (all or nothing) and pays the snapshot and save cost once; do not loop one-op calls.',
-        inputSchema: applyPatchInput,
-        outputSchema: applyPatchOutput,
+        description: "Apply a batch of create/update/delete operations atomically. All patches are validated before any are applied; the entire batch forms a single undo step. Batch-first is the default: prefer one apply_patch call containing all create/update/delete ops for a build step, in stable order so later ops can reference ids created by earlier ops. A single call is atomic (all or nothing) and pays the snapshot and save cost once; do not loop one-op calls. A create whose id already exists fails the whole patch with node_exists; to replace a node, delete it earlier in the same patch. An update cannot change id or type (identity_change) or object or children (immutable_field); restating the current value is fine. A parentId change must name an existing node that holds children (invalid_parent). An update cannot add schema issues to a node (invalid_update). After a delete or a roof update that regenerates a roof's default gutters, those gutters and their downspouts are addressable only in a later call (regenerated_default). A roof created or moved onto the storey whose walls carry it goes to the level above them (the roof level over a top storey), said in notes; storey content (walls, zones, slabs, ceilings, items, stairs) on a roof level (roof_level), a walled level declared the roof level (roof_level_holds_storey) and floor indexes putting a roof level under a storey (roof_level_on_top) are refused. Refusals come back as a tool error whose text is JSON {code, patchIndex, id, message}.",
+        inputSchema: z.object(applyPatchInput),
+        outputSchema: z.object(applyPatchOutput),
         annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
     }, async ({ patches }) => {
         const bridgePatches = patches.map((p) => {
@@ -42,12 +49,17 @@ export function registerApplyPatch(server, bridge) {
             };
         });
         try {
+            const notes = runPatchGuards(bridgePatches, bridge.getNodes());
+            const planDeletion = bridge
+                .planDeletion;
+            assertPatchKeepsIdentity(bridgePatches, bridge.getNodes(), bridge.getRootNodeIds(), typeof planDeletion === 'function' ? planDeletion.bind(bridge) : undefined);
             const result = bridge.applyPatch(bridgePatches);
             const persistence = await publishLiveSceneSnapshot(bridge, 'apply_patch');
             const payload = {
                 appliedOps: result.appliedOps,
                 deletedIds: result.deletedIds,
                 createdIds: result.createdIds,
+                ...(notes.length ? { notes } : {}),
                 ...persistencePayload(persistence),
             };
             return {
@@ -56,8 +68,27 @@ export function registerApplyPatch(server, bridge) {
             };
         }
         catch (err) {
+            if (err instanceof PatchRefusedError) {
+                // A tool error, not an ProtocolError: the SDK keeps only an ProtocolError's
+                // message, and clients need the code, index and id to act on it.
+                const refusal = {
+                    code: err.code,
+                    patchIndex: err.patchIndex,
+                    id: err.nodeId,
+                    message: err.message,
+                };
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(refusal) }],
+                    isError: true,
+                };
+            }
+            // A refusal the store made (an accidental wipe) answers with its code, as the shared tools'.
+            if (isAgentRefusal(err))
+                return refusalResult(err);
+            if (err instanceof ProtocolError)
+                throw err;
             const msg = err instanceof Error ? err.message : String(err);
-            throwMcpError(ErrorCode.InvalidParams, msg);
+            throwMcpError(ProtocolErrorCode.InvalidParams, msg);
         }
     });
 }

package/dist/tools/asset-catalog.d.ts

@@ -8,9 +8,13 @@ import type { AssetInput } from '@pascal-app/core/schema';
  * common AI-generated residential layouts.
  */
 export declare const MCP_CATALOG_ITEMS: AssetInput[];
-export declare function findCatalogItem(id: string): AssetInput | undefined;
-export declare function searchCatalogItems(args: {
-    query: string;
-    category?: string | undefined;
-}): AssetInput[];
+/**
+ * The items search_assets, place_items and furnish_room draw from. A host passes its own (the hosted
+ * app: its published library, as the chat searches); a standalone server keeps the built-in list.
+ */
+export type AssetCatalog = () => Promise<readonly AssetInput[]>;
+export declare const builtInCatalog: AssetCatalog;
+/** A host's catalog, read once by the first call that needs it; a failed read is tried again. */
+export declare function cachedCatalog(load: AssetCatalog): AssetCatalog;
+export declare function findCatalogItem(items: readonly AssetInput[], id: string): AssetInput | undefined;
 //# sourceMappingURL=asset-catalog.d.ts.map

package/dist/tools/asset-catalog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"asset-catalog.d.ts","sourceRoot":"","sources":["../../src/tools/asset-catalog.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AAEzD;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,EAAE,UAAU,EA6RzC,CAAA;AAED,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAElE;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACvC,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAC9B,GAAG,UAAU,EAAE,CAUf"}
+{"version":3,"file":"asset-catalog.d.ts","sourceRoot":"","sources":["../../src/tools/asset-catalog.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AAEzD;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,EAAE,UAAU,EAoTzC,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,OAAO,CAAC,SAAS,UAAU,EAAE,CAAC,CAAA;AAE/D,eAAO,MAAM,cAAc,EAAE,YAA4C,CAAA;AAEzE,iGAAiG;AACjG,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,YAAY,CAO9D;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,EAAE,EAAE,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAEhG"}

package/dist/tools/asset-catalog.js

@@ -10,6 +10,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'double-bed',
         category: 'furniture',
+        functionTags: ['double-beds'],
         tags: ['floor', 'bedroom'],
         name: 'Double Bed',
         thumbnail: '/items/double-bed/thumbnail.webp',
@@ -22,6 +23,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'single-bed',
         category: 'furniture',
+        functionTags: ['single-beds'],
         tags: ['floor', 'bedroom'],
         name: 'Single Bed',
         thumbnail: '/items/single-bed/thumbnail.webp',
@@ -34,6 +36,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'bedside-table',
         category: 'furniture',
+        functionTags: ['coffee-tables'],
         tags: ['floor', 'bedroom'],
         name: 'Bedside Table',
         thumbnail: '/items/bedside-table/thumbnail.webp',
@@ -47,6 +50,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'dresser',
         category: 'furniture',
+        functionTags: ['dressers'],
         tags: ['floor', 'storage', 'bedroom'],
         name: 'Dresser',
         thumbnail: '/items/dresser/thumbnail.webp',
@@ -60,6 +64,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'closet',
         category: 'furniture',
+        functionTags: ['wardrobes'],
         tags: ['floor', 'storage', 'bedroom'],
         name: 'Closet',
         thumbnail: '/items/closet/thumbnail.webp',
@@ -72,6 +77,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'sofa',
         category: 'furniture',
+        functionTags: ['sofas'],
         tags: ['floor', 'seating', 'living'],
         name: 'Sofa',
         thumbnail: '/items/sofa/thumbnail.webp',
@@ -84,6 +90,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'livingroom-chair',
         category: 'furniture',
+        functionTags: ['armchairs'],
         tags: ['floor', 'seating', 'living'],
         name: 'Livingroom Chair',
         thumbnail: '/items/livingroom-chair/thumbnail.webp',
@@ -96,6 +103,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'coffee-table',
         category: 'furniture',
+        functionTags: ['coffee-tables'],
         tags: ['floor', 'table', 'living'],
         name: 'Coffee Table',
         thumbnail: '/items/coffee-table/thumbnail.webp',
@@ -109,6 +117,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'tv-stand',
         category: 'furniture',
+        functionTags: ['cabinets'],
         tags: ['floor', 'storage', 'living'],
         name: 'TV Stand',
         thumbnail: '/items/tv-stand/thumbnail.webp',
@@ -122,6 +131,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'shelf',
         category: 'furniture',
+        functionTags: ['shelves'],
         tags: ['wall', 'storage'],
         name: 'Shelf',
         thumbnail: '/items/shelf/thumbnail.webp',
@@ -136,6 +146,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'dining-table',
         category: 'furniture',
+        functionTags: ['dining-tables'],
         tags: ['floor', 'table', 'dining'],
         name: 'Dining Table',
         thumbnail: '/items/dining-table/thumbnail.webp',
@@ -149,6 +160,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'dining-chair',
         category: 'furniture',
+        functionTags: ['dining-chairs'],
         tags: ['floor', 'seating', 'dining'],
         name: 'Dining Chair',
         thumbnail: '/items/dining-chair/thumbnail.webp',
@@ -161,6 +173,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'kitchen',
         category: 'kitchen',
+        functionTags: ['cabinets'],
         tags: ['floor', 'large', 'kitchen'],
         name: 'Kitchen',
         thumbnail: '/items/kitchen/thumbnail.webp',
@@ -173,6 +186,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'kitchen-counter',
         category: 'kitchen',
+        functionTags: ['counters'],
         tags: ['floor', 'large', 'storage', 'kitchen'],
         name: 'Kitchen Counter',
         thumbnail: '/items/kitchen-counter/thumbnail.webp',
@@ -186,6 +200,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'stove',
         category: 'kitchen',
+        functionTags: ['kitchen-appliances'],
         tags: ['floor', 'large', 'kitchen'],
         name: 'Stove',
         thumbnail: '/items/stove/thumbnail.webp',
@@ -198,6 +213,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'fridge',
         category: 'kitchen',
+        functionTags: ['kitchen-appliances'],
         tags: ['floor', 'large', 'kitchen'],
         name: 'Fridge',
         thumbnail: '/items/fridge/thumbnail.webp',
@@ -210,6 +226,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'toilet',
         category: 'bathroom',
+        functionTags: ['toilets'],
         tags: ['floor', 'large', 'bathroom'],
         name: 'Toilet',
         thumbnail: '/items/toilet/thumbnail.webp',
@@ -222,6 +239,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'bathroom-sink',
         category: 'bathroom',
+        functionTags: ['sinks'],
         tags: ['floor', 'large', 'bathroom'],
         name: 'Bathroom Sink',
         thumbnail: '/items/bathroom-sink/thumbnail.webp',
@@ -234,6 +252,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'shower-square',
         category: 'bathroom',
+        functionTags: ['showers'],
         tags: ['floor', 'large', 'bathroom'],
         name: 'Squared Shower',
         thumbnail: '/items/shower-square/thumbnail.webp',
@@ -246,6 +265,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'bathtub',
         category: 'bathroom',
+        functionTags: ['bathtubs'],
         tags: ['floor', 'large', 'bathroom'],
         name: 'Bathtub',
         thumbnail: '/items/bathtub/thumbnail.webp',
@@ -258,6 +278,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'washing-machine',
         category: 'bathroom',
+        functionTags: ['laundry-appliances'],
         tags: ['floor', 'large', 'electronics', 'laundry'],
         name: 'Washing Machine',
         thumbnail: '/items/washing-machine/thumbnail.webp',
@@ -270,6 +291,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'drying-rack',
         category: 'bathroom',
+        functionTags: ['laundry-appliances'],
         tags: ['floor', 'laundry'],
         name: 'Drying Rack',
         thumbnail: '/items/drying-rack/thumbnail.webp',
@@ -282,6 +304,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'coat-rack',
         category: 'furniture',
+        functionTags: ['racks'],
         tags: ['floor', 'storage', 'entry'],
         name: 'Coat Rack',
         thumbnail: '/items/coat-rack/thumbnail.webp',
@@ -292,17 +315,15 @@ export const MCP_CATALOG_ITEMS = [
         scale: [1, 1, 1],
     },
 ];
-export function findCatalogItem(id) {
-    return MCP_CATALOG_ITEMS.find((item) => item.id === id);
+export const builtInCatalog = async () => MCP_CATALOG_ITEMS;
+/** A host's catalog, read once by the first call that needs it; a failed read is tried again. */
+export function cachedCatalog(load) {
+    let items = null;
+    return () => (items ??= load().catch((error) => {
+        items = null;
+        throw error;
+    }));
 }
-export function searchCatalogItems(args) {
-    const terms = args.query.trim().toLowerCase().split(/\s+/).filter(Boolean);
-    return MCP_CATALOG_ITEMS.filter((item) => {
-        if (args.category && item.category !== args.category)
-            return false;
-        const haystack = [item.id, item.name, item.category, ...(item.tags ?? [])]
-            .join(' ')
-            .toLowerCase();
-        return terms.every((term) => haystack.includes(term));
-    });
+export function findCatalogItem(items, id) {
+    return items.find((item) => item.id === id);
 }

package/dist/tools/author-scene.d.ts

@@ -0,0 +1,10 @@
+import type { McpServer } from '@modelcontextprotocol/server';
+import type { SceneOperations } from '../operations/index.js';
+import { type GeometryScriptHost } from './add-object.js';
+/**
+ * `author_scene` on the MCP: every item's module compiled and stored through the host, the
+ * module and the adapter kept as the scene's provenance, the operation applied, Pascal's checks
+ * run, and the gate report answered. Replay is the same payload through the same operation.
+ */
+export declare function registerAuthorScene(server: McpServer, bridge: SceneOperations, host: GeometryScriptHost | undefined): void;
+//# sourceMappingURL=author-scene.d.ts.map

package/dist/tools/author-scene.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"author-scene.d.ts","sourceRoot":"","sources":["../../src/tools/author-scene.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAe7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AACpD,OAAO,EAAmB,KAAK,kBAAkB,EAAE,MAAM,cAAc,CAAA;AAevE;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,kBAAkB,GAAG,SAAS,GACnC,IAAI,CA0HN"}