@pascal-app/core 1.0.6 → 1.0.7

package/dist/agent-operations/scene-queries.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scene-queries.d.ts","sourceRoot":"","sources":["../../src/agent-operations/scene-queries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAExC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzC,MAAM,MAAM,SAAS,GAAG,UAAU,GAAG,MAAM,GAAG,SAAS,CAAA;AACvD,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAOD,gDAAgD;AAChD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,UAAU,GAAG,CAAC,OAAO,GAAG;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC,EAAE,CAI3E;AAED,qFAAqF;AACrF,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAStE;AAED,kGAAkG;AAClG,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,EAAE,CAetE;AAED,6EAA6E;AAC7E,eAAO,MAAM,YAAY,UAAW,UAAU,WAAW,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAkC,CAAA;AAEjG,wBAAgB,aAAa,CAAC,OAAO,EAAE,SAAS,OAAO,EAAE,GAAG,aAAa,CAexE;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO;;;;EAY1D"}
+{"version":3,"file":"scene-queries.d.ts","sourceRoot":"","sources":["../../src/agent-operations/scene-queries.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAExC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzC,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AAErE,MAAM,MAAM,SAAS,GAAG,UAAU,GAAG,MAAM,GAAG,SAAS,CAAA;AACvD,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAOD,gDAAgD;AAChD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,UAAU,GAAG,CAAC,OAAO,GAAG;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC,EAAE,CAI3E;AAED,qFAAqF;AACrF,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAStE;AAED,kGAAkG;AAClG,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,EAAE,CAetE;AAED,6EAA6E;AAC7E,eAAO,MAAM,YAAY,UAAW,UAAU,WAAW,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAkC,CAAA;AAEjG,wBAAgB,aAAa,CAAC,OAAO,EAAE,SAAS,OAAO,EAAE,GAAG,aAAa,CAexE;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO;;;;EAY1D"}

package/dist/agent-operations/scene-queries.js

@@ -1,13 +1,13 @@
+import { queryNodes } from '../runtime/node-queries.js';
 import { isCeilingGeometry, isRoofGeometry, servesAsRoofLevel } from '../services/roof-level.js';
+export { orderedChildIds, queryNodes } from '../runtime/node-queries.js';
 const metadataString = (node, key) => {
     const value = node.metadata?.[key];
     return typeof value === 'string' ? value : undefined;
 };
 /** Every level, in floor order (ties by id). */
 export function levelsOf(nodes) {
-    return Object.values(nodes)
-        .filter((node) => node.type === 'level')
-        .sort((a, b) => a.level - b.level || a.id.localeCompare(b.id));
+    return queryNodes(nodes, { type: 'level' }).sort((a, b) => a.level - b.level || a.id.localeCompare(b.id));
 }
 /** The level a node sits on, walking up its parents (a level resolves to itself). */
 export function levelIdOf(nodes, id) {

package/dist/agent-operations/scene-review.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scene-review.d.ts","sourceRoot":"","sources":["../../src/agent-operations/scene-review.ts"],"names":[],"mappings":"AAGA,OAAO,EAAsB,KAAK,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAC3E,OAAO,EAAgB,KAAK,wBAAwB,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAEjG,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAOzC,MAAM,MAAM,WAAW,GAAG;IACxB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,GAAG,EAAE;QAAE,OAAO,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,CAAA;IAChE,oDAAoD;IACpD,IAAI,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,YAAY,CAAC;QAAC,SAAS,EAAE,EAAE,CAAA;KAAE,CAAA;CAC7D,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,yBAAyB,GAAG,2BAA2B,CAAA;CAC9D,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAA;IAC7D,MAAM,EAAE,WAAW,EAAE,CAAA;IACrB,iEAAiE;IACjE,IAAI,EAAE,WAAW,EAAE,CAAA;IACnB,mFAAmF;IACnF,MAAM,CAAC,EAAE;QAAE,OAAO,EAAE,aAAa,EAAE,CAAC;QAAC,MAAM,EAAE,wBAAwB,EAAE,CAAA;KAAE,CAAA;CAC1E,CAAA;AAUD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,WAAW,CAiGhG"}
+{"version":3,"file":"scene-review.d.ts","sourceRoot":"","sources":["../../src/agent-operations/scene-review.ts"],"names":[],"mappings":"AAEA,OAAO,EAAsB,KAAK,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAC3E,OAAO,EAAgB,KAAK,wBAAwB,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAEjG,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAOzC,MAAM,MAAM,WAAW,GAAG;IACxB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,GAAG,EAAE;QAAE,OAAO,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,CAAA;IAChE,oDAAoD;IACpD,IAAI,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,YAAY,CAAC;QAAC,SAAS,EAAE,EAAE,CAAA;KAAE,CAAA;CAC7D,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,yBAAyB,GAAG,2BAA2B,CAAA;CAC9D,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAA;IAC7D,MAAM,EAAE,WAAW,EAAE,CAAA;IACrB,iEAAiE;IACjE,IAAI,EAAE,WAAW,EAAE,CAAA;IACnB,mFAAmF;IACnF,MAAM,CAAC,EAAE;QAAE,OAAO,EAAE,aAAa,EAAE,CAAC;QAAC,MAAM,EAAE,wBAAwB,EAAE,CAAA;KAAE,CAAA;CAC1E,CAAA;AAUD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,WAAW,CAkGhG"}

package/dist/agent-operations/scene-review.js

@@ -2,7 +2,7 @@ import { refuse } from '../agent-tools/refusal.js';
 import { getLevelDisplayName } from '../lib/level-name.js';
 import { hashNode as hashOf } from './scene-checkpoint.js';
 import { changesSince } from './scene-measure.js';
-import { levelIdOf, levelsOf } from './scene-queries.js';
+import { levelIdOf, levelsOf, queryNodes } from './scene-queries.js';
 /** A node of these kinds can be the target of a view_scene; the others are seen through their level. */
 const VIEWABLE = new Set(['wall', 'zone', 'door', 'window', 'item']);
 /** A group lists this many ids of each kind; the counts are exact. */
@@ -38,6 +38,7 @@ export function reviewSince(session, name, nodes) {
             return getLevelDisplayName(level);
         return checkpoint.nodes[levelId]?.name ?? levelId;
     };
+    // biome-ignore lint/plugin: a review compares every node with the checkpoint
     for (const node of Object.values(nodes)) {
         const was = checkpoint.nodes[node.id];
         const levelId = levelIdOf(nodes, node.id);
@@ -103,4 +104,4 @@ export function reviewSince(session, name, nodes) {
         ...(places.changes.length ? { places } : {}),
     };
 }
-const firstBuilding = (nodes) => Object.values(nodes).find((node) => node.type === 'building')?.id;
+const firstBuilding = (nodes) => queryNodes(nodes, { type: 'building' })[0]?.id;

package/dist/agent-operations/scene-view.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scene-view.d.ts","sourceRoot":"","sources":["../../src/agent-operations/scene-view.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"scene-view.d.ts","sourceRoot":"","sources":["../../src/agent-operations/scene-view.ts"],"names":[],"mappings":"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"}

package/dist/agent-operations/scene-view.js

@@ -7,8 +7,11 @@ import { buildingStreet } from '../lib/site-placement.js';
 import { getActiveRoofHeight } from '../schema/index.js';
 import { isCeilingGeometry, isRoofGeometry } from '../services/roof-level.js';
 import { EXPLODED_GAP, getLevelElevations } from '../services/storey.js';
+import { stairFootprintAABB } from '../systems/stair/stair-footprint.js';
 import { resolveWallExteriorSide } from '../systems/wall/wall-assembly.js';
+import { itemLevelHeightRange, itemPlanAabbInLevel } from './item-space.js';
 import { pointInPolygon } from './plan-geometry.js';
+import { queryNodes } from './scene-queries.js';
 /** Validate against the scene being rendered as well as the scene used to request the view. */
 export function sceneViewPresentationLevel(nodes, presentation) {
     if (presentation?.mode !== 'solo')
@@ -67,6 +70,7 @@ export function sceneViewInterior(nodes, levelId) {
                 target: node.id,
             });
     }
+    // biome-ignore lint/plugin: a view hides every level but its own, and what covers it
     const hiddenIds = Object.values(nodes)
         .filter((node) => node.type === 'level'
         ? node.id !== levelId
@@ -160,7 +164,7 @@ function streetDirection(nodes, side, lookedAt) {
 function framedBuilding(nodes, lookedAt) {
     if (lookedAt)
         return ancestry(nodes, lookedAt).find((node) => node.type === 'building') ?? null;
-    const buildings = Object.values(nodes).filter((node) => node.type === 'building');
+    const buildings = queryNodes(nodes, { type: 'building' });
     const sites = new Set(buildings.map((building) => building.parentId ?? null));
     if (sites.size > 1)
         refuse('which_building', `The scene has buildings on ${sites.size} sites, each facing its own street: give the building as target.`, { buildings: buildings.map((building) => building.id) });
@@ -463,6 +467,7 @@ export function sceneViewBounds(nodes, targetId, presentation) {
     const held = [];
     const roofs = [];
     let pluginTop = Number.NEGATIVE_INFINITY;
+    // biome-ignore lint/plugin: a view frames whatever the level holds
     for (const node of Object.values(nodes)) {
         const level = levelOf(node);
         if (level?.type !== 'level')
@@ -735,34 +740,98 @@ function roomMiddle(outline, inRoom) {
         }
     return best;
 }
+/** How far the eye keeps from a tall piece, so it never stands inside one or against its face. */
+const EYE_ITEM_CLEARANCE = 0.3;
+/**
+ * The footprints, on the site and grown by EYE_ITEM_CLEARANCE, of what stands on a floor through a
+ * person's eye height (a wardrobe, a fridge, a bookcase, a stair): an eye inside one, or just behind
+ * one, sees a single flat panel. A bed or a counter under the eye does not block it. Pieces hosted
+ * by a wall or hung from a ceiling keep their own frames and are not read.
+ */
+function eyeObstacles(nodes, levelId, eyeHeight) {
+    const items = queryNodes(nodes, { type: 'item' });
+    const level = nodes[levelId];
+    // An item stands on the level through other items only: what the walk below can reach.
+    const byId = new Map([...items, ...(level ? [level] : [])].map((node) => [node.id, node]));
+    const at = standingOf(nodes, levelId);
+    const m = EYE_ITEM_CLEARANCE;
+    return [...queryNodes(nodes, { type: 'stair', parentId: levelId }), ...items].flatMap((node) => {
+        let box = null;
+        if (node.type === 'stair')
+            box = stairFootprintAABB(node, nodes);
+        else if (node.type === 'item') {
+            let parent = byId.get(node.parentId ?? '');
+            while (parent?.type === 'item')
+                parent = byId.get(parent.parentId ?? '');
+            if (parent?.id !== levelId)
+                return [];
+            const height = itemLevelHeightRange(node, byId);
+            if (!height || height.max < eyeHeight - 0.4 || height.min > eyeHeight + 0.2)
+                return [];
+            box = itemPlanAabbInLevel(node, byId);
+        }
+        if (!box)
+            return [];
+        return [
+            [
+                [box.minX - m, box.minZ - m],
+                [box.maxX + m, box.minZ - m],
+                [box.maxX + m, box.maxZ + m],
+                [box.minX - m, box.maxZ + m],
+            ].map((corner) => onSite(corner, at)),
+        ];
+    });
+}
+/** How far ahead the eye's line toward what it looks at must clear every tall piece. */
+const EYE_SIGHT_REACH = 2;
 /**
  * A person standing in a room, looking across it: the eye a step in from the corner farthest from
  * what it looks at (or, given a side, from the corner on that side), at eye height, aimed at the
- * room's middle or at the target. Everything is on the site, in metres.
+ * room's middle or at the target. A step that lands in a tall piece (`blocked`) goes further in,
+ * else another corner is taken; a corner whose first EYE_SIGHT_REACH metres toward what it looks at
+ * cross one is taken only when no other sees past them. Everything is on the site, in metres.
  */
-function roomEyeView(outline, holes, floorY, { aim, side, eyeHeight = ROOM_EYE_HEIGHT, fov = ROOM_FOV, }) {
+function roomEyeView(outline, holes, floorY, { aim, side, eyeHeight = ROOM_EYE_HEIGHT, fov = ROOM_FOV, blocked = [], }) {
     const inRoom = (point) => pointInPolygon(point, outline, false) && !holes.some((hole) => pointInPolygon(point, hole));
+    const clear = (point) => !blocked.some((footprint) => pointInPolygon(point, footprint));
     const distance = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]);
     const middle = roomMiddle(outline, inRoom);
     const looksAt = aim ? [aim[0], aim[2]] : middle;
-    let eye;
-    let bestScore = Number.NEGATIVE_INFINITY;
-    for (const corner of outline) {
-        const toMiddle = distance(corner, middle) || 1;
-        const inward = [(middle[0] - corner[0]) / toMiddle, (middle[1] - corner[1]) / toMiddle];
-        // A step in from the corner, further in a room too narrow to hold the first.
-        const standing = [0.6, 1, 1.6]
-            .filter((step) => step <= toMiddle * 0.8)
-            .map((step) => [corner[0] + inward[0] * step, corner[1] + inward[1] * step])
-            .find((point) => inRoom(point) && clearanceOf(outline, point) >= 0.25);
-        if (!standing)
-            continue;
-        const score = side
-            ? ((corner[0] - middle[0]) * side[0] + (corner[1] - middle[1]) * side[1]) / toMiddle
-            : distance(standing, looksAt);
-        if (score > bestScore)
-            [eye, bestScore] = [standing, score];
-    }
+    const seesPast = (point) => {
+        const reach = Math.min(EYE_SIGHT_REACH, distance(point, looksAt));
+        const length = distance(point, looksAt) || 1;
+        for (let r = 0.1; r <= reach; r += 0.1) {
+            const t = r / length;
+            if (!clear([point[0] + (looksAt[0] - point[0]) * t, point[1] + (looksAt[1] - point[1]) * t]))
+                return false;
+        }
+        return true;
+    };
+    const stand = (sighted) => {
+        let found;
+        let bestScore = Number.NEGATIVE_INFINITY;
+        for (const corner of outline) {
+            const toMiddle = distance(corner, middle) || 1;
+            const inward = [(middle[0] - corner[0]) / toMiddle, (middle[1] - corner[1]) / toMiddle];
+            // A step in from the corner, further in a room too narrow to hold the first.
+            const standing = [0.6, 1, 1.6, 2.2, 3]
+                .filter((step) => step <= toMiddle * 0.8)
+                .map((step) => [corner[0] + inward[0] * step, corner[1] + inward[1] * step])
+                .find((point) => inRoom(point) &&
+                clearanceOf(outline, point) >= 0.25 &&
+                clear(point) &&
+                (!sighted || seesPast(point)));
+            if (!standing)
+                continue;
+            const score = side
+                ? ((corner[0] - middle[0]) * side[0] + (corner[1] - middle[1]) * side[1]) / toMiddle
+                : distance(standing, looksAt);
+            if (score > bestScore)
+                [found, bestScore] = [standing, score];
+        }
+        return found;
+    };
+    const eye = stand(true) ?? stand(false);
     if (!eye) {
         // A room too small for a corner to stand in: from its middle, toward its farthest corner.
         const far = outline.reduce((a, b) => (distance(b, middle) > distance(a, middle) ? b : a));
@@ -892,6 +961,7 @@ export function sceneViewPlan(nodes, input, { currentCamera } = {}) {
                 side: typeof from === 'string' ? (from === 'above' ? undefined : COMPASS[from]) : from,
                 eyeHeight,
                 fov,
+                blocked: eyeObstacles(nodes, room.parentId, eyeHeight ?? ROOM_EYE_HEIGHT),
             }),
             size: sized(VIEW_SIZE.w, VIEW_SIZE.h, input.maxPx),
             ...extras,

package/dist/agent-operations/search-assets.d.ts

@@ -1,13 +1,17 @@
 import type { AgentOperation } from './types.js';
+type SearchQuery = {
+    query: string;
+    category?: string;
+};
 type SearchAssetsInput = {
-    queries: {
-        query: string;
-        category?: string;
-    }[];
+    queries: SearchQuery[];
+    limit?: number;
 };
 /**
- * `search_assets`: the host's item library, one group of hits per query. A miss names the other
- * sources there are for the need, as a fact.
+ * `search_assets`: the host's item library, one group of hits per query, best first and at most
+ * `limit` per group; `total` counts them all. A list held whole is searched here; a library kept
+ * elsewhere answered each query before the call (`catalogSearches`), ranked by its host. A miss
+ * names the other sources there are for the need, as a fact; a cut group says how to narrow it.
  */
 export declare const searchAssets: AgentOperation<SearchAssetsInput>;
 export {};

package/dist/agent-operations/search-assets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search-assets.d.ts","sourceRoot":"","sources":["../../src/agent-operations/search-assets.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,KAAK,iBAAiB,GAAG;IAAE,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CAAE,CAAA;AAY5E;;;GAGG;AACH,eAAO,MAAM,YAAY,EAAE,cAAc,CAAC,iBAAiB,CA0B1D,CAAA"}
+{"version":3,"file":"search-assets.d.ts","sourceRoot":"","sources":["../../src/agent-operations/search-assets.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,KAAK,WAAW,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AACvD,KAAK,iBAAiB,GAAG;IAAE,OAAO,EAAE,WAAW,EAAE,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAcnE;;;;;GAKG;AACH,eAAO,MAAM,YAAY,EAAE,cAAc,CAAC,iBAAiB,CAqC1D,CAAA"}

package/dist/agent-operations/search-assets.js

@@ -1,43 +1,58 @@
 import { refuse } from '../agent-tools/refusal.js';
 import { OTHER_SOURCES } from '../agent-tools/sources.js';
-function matches(item, { query, category }) {
-    if (category && item.category !== category)
-        return false;
-    const haystack = [item.id, item.name, item.category, ...(item.tags ?? [])].join(' ').toLowerCase();
-    return query
-        .toLowerCase()
-        .split(/\s+/)
-        .filter(Boolean)
-        .every((term) => haystack.includes(term));
+import { assetSearchesOf, assetSearchKey, searchAssetList, } from './asset-catalog.js';
+/** What narrows a query whose matches the limit cut: more words, or one of their categories. */
+function narrowing(query, found, shown) {
+    const categories = (found.categories ?? [])
+        .slice(0, 6)
+        .map(({ name, count }) => `${name} ${count}`);
+    const how = query.category || categories.length < 2
+        ? 'add words to narrow it'
+        : `add words or a category to narrow it (${categories.join(', ')})`;
+    return `"${query.text}" matches ${found.total} items and lists the best ${shown}: ${how}.`;
 }
 /**
- * `search_assets`: the host's item library, one group of hits per query. A miss names the other
- * sources there are for the need, as a fact.
+ * `search_assets`: the host's item library, one group of hits per query, best first and at most
+ * `limit` per group; `total` counts them all. A list held whole is searched here; a library kept
+ * elsewhere answered each query before the call (`catalogSearches`), ranked by its host. A miss
+ * names the other sources there are for the need, as a fact; a cut group says how to narrow it.
  */
-export const searchAssets = (_nodes, { queries }, context) => {
-    const catalog = context.catalog;
-    if (!catalog)
+export const searchAssets = (_nodes, input, context) => {
+    const { catalog, catalogSearches } = context;
+    if (!(catalog || catalogSearches))
         refuse('no_catalog', 'This host has no item library to search; nothing can be placed from one.');
-    const groups = queries.map((entry) => {
-        const results = catalog
-            .filter((item) => matches(item, entry))
-            .map((item) => ({
+    const narrow = [];
+    const groups = assetSearchesOf(input).map((query) => {
+        const found = catalogSearches
+            ? catalogSearches[assetSearchKey(query)]
+            : searchAssetList(catalog ?? [], query);
+        if (!found)
+            throw new Error(`The host did not answer the search "${query.text}" before the call.`);
+        const shown = found.items.slice(0, query.limit);
+        const truncated = found.total > shown.length;
+        if (truncated)
+            narrow.push(narrowing(query, found, shown.length));
+        const results = shown.map((item) => ({
             id: item.id,
             name: item.name,
             category: item.category,
             dimensions: item.dimensions ?? [1, 1, 1],
             attachTo: item.attachTo ?? null,
         }));
-        return { query: entry.query, total: results.length, results };
+        return { query: query.text, total: found.total, truncated, results };
     });
     const missed = groups.filter((group) => group.total === 0).map((group) => `"${group.query}"`);
+    const hint = [
+        ...(missed.length
+            ? [`Nothing in the library matches ${missed.join(', ')}. ${OTHER_SOURCES}`]
+            : []),
+        ...narrow,
+    ].join(' ');
     return {
         result: {
             groups,
             total: groups.reduce((sum, group) => sum + group.total, 0),
-            ...(missed.length && {
-                hint: `Nothing in the library matches ${missed.join(', ')}. ${OTHER_SOURCES}`,
-            }),
+            ...(hint && { hint }),
         },
     };
 };

package/dist/agent-operations/set-checkpoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"set-checkpoint.d.ts","sourceRoot":"","sources":["../../src/agent-operations/set-checkpoint.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C;;;GAGG;AACH,eAAO,MAAM,aAAa,EAAE,cAAc,CAAC;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CA+B1D,CAAA"}
+{"version":3,"file":"set-checkpoint.d.ts","sourceRoot":"","sources":["../../src/agent-operations/set-checkpoint.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C;;;GAGG;AACH,eAAO,MAAM,aAAa,EAAE,cAAc,CAAC;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAgC1D,CAAA"}

package/dist/agent-operations/set-checkpoint.js

@@ -13,6 +13,7 @@ export const setCheckpoint = (nodes, input, context) => {
     const replaced = names.includes(name);
     if (!replaced && names.length >= MAX_CHECKPOINTS)
         refuse('too_many_checkpoints', `A session keeps at most ${MAX_CHECKPOINTS} checkpoints and has ${names.join(', ')}. Use one of those names to replace it.`, { checkpoints: names });
+    // biome-ignore lint/plugin: a checkpoint remembers every node, so its size is the scene's
     const size = Object.keys(nodes).length;
     if (size > MAX_CHECKPOINT_NODES)
         refuse('scene_too_large', `The scene has ${size} nodes; a checkpoint is kept for at most ${MAX_CHECKPOINT_NODES}.`, { nodes: size });

package/dist/agent-operations/set-ground-level.d.ts

@@ -4,7 +4,7 @@ type SetGroundLevelInput = {
 };
 /**
  * `set_ground_level`: the level asked for becomes the building's ground floor — named on the
- * building, its floor the top of the foundation over grade (as the building's region and style seat it), index 0 — the same change the level panel's "Set as ground floor"
+ * building, its floor on grade, index 0 — the same change the level panel's "Set as ground floor"
  * writes (`buildGroundLevelChanges`).
  */
 export declare const setGroundLevel: AgentOperation<SetGroundLevelInput>;

package/dist/agent-operations/set-ground-level.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"set-ground-level.d.ts","sourceRoot":"","sources":["../../src/agent-operations/set-ground-level.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,KAAK,mBAAmB,GAAG;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAAA;AAE9C;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,mBAAmB,CAuD9D,CAAA"}
+{"version":3,"file":"set-ground-level.d.ts","sourceRoot":"","sources":["../../src/agent-operations/set-ground-level.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,KAAK,mBAAmB,GAAG;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAAA;AAE9C;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,mBAAmB,CA4C9D,CAAA"}

package/dist/agent-operations/set-ground-level.js

@@ -4,7 +4,7 @@ import { requireLevel } from './level-target.js';
 import { levelRole } from './scene-queries.js';
 /**
  * `set_ground_level`: the level asked for becomes the building's ground floor — named on the
- * building, its floor the top of the foundation over grade (as the building's region and style seat it), index 0 — the same change the level panel's "Set as ground floor"
+ * building, its floor on grade, index 0 — the same change the level panel's "Set as ground floor"
  * writes (`buildGroundLevelChanges`).
  */
 export const setGroundLevel = (nodes, input) => {
@@ -23,13 +23,6 @@ export const setGroundLevel = (nodes, input) => {
     const { seat, moveBy } = built;
     const floorElevation = Math.round((seat.floorElevation + moveBy) * 1e6) / 1e6;
     const name = level.name ?? level.id;
-    const { aboveGrade, foundation } = seat;
-    const construction = {
-        region: foundation.region,
-        construction: foundation.construction.id,
-        basis: foundation.basis,
-    };
-    const inches = Math.round(aboveGrade / 0.0254);
     if (built.unchanged)
         return {
             result: {
@@ -38,9 +31,7 @@ export const setGroundLevel = (nodes, input) => {
                 levelId: level.id,
                 buildingId: built.buildingId,
                 floorElevation: seat.floorElevation,
-                aboveGrade,
-                foundation: construction,
-                message: `${name} is already the ground floor, its floor ${aboveGrade} m (${inches} in) over grade (${foundation.construction.label} foundation; ${foundation.basis}).`,
+                message: `${name} is already the ground floor, its floor on grade.`,
             },
         };
     return {
@@ -50,11 +41,9 @@ export const setGroundLevel = (nodes, input) => {
             buildingId: built.buildingId,
             floorElevation,
             gradeElevation: seat.gradeElevation,
-            aboveGrade,
-            foundation: construction,
             movedBuildingBy: moveBy,
             renumbered: built.renumbered,
-            message: `${name} is the ground floor: its floor, the top of the foundation where the wood framing starts, stands ${aboveGrade} m (${inches} in) over grade (${floorElevation.toFixed(2)} m over grade ${seat.gradeElevation.toFixed(2)} m), as a ${foundation.construction.label} foundation seats it: ${foundation.construction.seatBasis}; ${foundation.basis}. The levels with a lower index are below grade${moveBy === 0 ? '' : `; the building moved ${moveBy.toFixed(2)} m in height, its plan where it was`}.`,
+            message: `${name} is the ground floor: its floor stands on grade (${floorElevation.toFixed(2)} m). The levels with a lower index are below grade${moveBy === 0 ? '' : `; the building moved ${moveBy.toFixed(2)} m in height, its plan where it was`}.`,
         },
         changes: { update: built.update },
     };

package/dist/agent-operations/site.js

@@ -3,6 +3,7 @@ import { isSiteFlatwork } from '../lib/site-flatwork.js';
 import { describeSiteBrief, placeBuildingPose, roundedSiteBrief, siteBrief, } from '../lib/site-placement.js';
 import { targetBuilding } from './add-level.js';
 import { pointInPolygon } from './plan-geometry.js';
+import { queryNodes } from './scene-queries.js';
 const r2 = (n) => Math.round(n * 100) / 100 || 0;
 /**
  * `get_site`: the site a building stands on, in its level coordinates; a lot no building stands
@@ -19,7 +20,7 @@ export const getSite = (nodes, input, context) => {
                 type: site.type,
             });
     }
-    const anyBuilding = Object.values(nodes).some((node) => node.type === 'building');
+    const anyBuilding = queryNodes(nodes, { type: 'building' }).length > 0;
     const building = input.building || (anyBuilding && !input.site)
         ? targetBuilding(nodes, input.building, context)
         : null;
@@ -57,7 +58,7 @@ function outdoorOnLevels(nodes, buildingId, rings) {
     const levels = new Set(building?.type === 'building' ? building.children : []);
     const outside = (x, z) => !rings.some((ring) => pointInPolygon([x, z], ring));
     const moved = [];
-    for (const node of Object.values(nodes)) {
+    for (const node of queryNodes(nodes, { type: ['fence', 'slab', 'item'] })) {
         if (!(node.parentId && levels.has(node.parentId)))
             continue;
         const flatwork = node.type === 'slab' && isSiteFlatwork(node);

package/dist/agent-operations/slab-surface-script.d.ts

@@ -0,0 +1,25 @@
+import { type FloorScriptInputs } from '../lib/floor-script.js';
+import { type CompiledGeometryScript } from '../schema/index.js';
+import type { AgentOperation } from './types.js';
+export type SetSlabSurfaceScriptInput = {
+    slabId: string;
+    /** The module compiled for `inputs` (`slabSurfaceScriptInputs` of the slab, read before compiling). */
+    compiled: CompiledGeometryScript;
+    inputs: FloorScriptInputs;
+} | {
+    slabId: string;
+    remove: true;
+};
+/**
+ * `setSlabSurfaceScript`: a standalone slab's surface finish (a terrace's decking, a platform's
+ * tiles, a plinth's paving) built by a three.js module, or the module taken off. The host reads the
+ * slab's outline (`slabSurfaceScriptInputs`), compiles the module for it (the module reads
+ * `params.polygon` and `params.holes` in the level's plan x/z, and lays its finish from y = 0, the
+ * slab's top) and stores the artifacts; this writes the result on the slab with the key of the
+ * outline it was built for, and the renderer stands it on the slab. When the slab is reshaped the
+ * script is stale and `refreshFinishScripts` runs it again. The script owns the surface's colours:
+ * paint on it is refused while it is there. A room's floor plate has none: the room's floor script
+ * (`setRoomFloorScript`) builds there.
+ */
+export declare const setSlabSurfaceScript: AgentOperation<SetSlabSurfaceScriptInput>;
+//# sourceMappingURL=slab-surface-script.d.ts.map

package/dist/agent-operations/slab-surface-script.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slab-surface-script.d.ts","sourceRoot":"","sources":["../../src/agent-operations/slab-surface-script.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,iBAAiB,EAGvB,MAAM,qBAAqB,CAAA;AAG5B,OAAO,EAAE,KAAK,sBAAsB,EAAmB,MAAM,WAAW,CAAA;AACxE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,MAAM,MAAM,yBAAyB,GACjC;IACE,MAAM,EAAE,MAAM,CAAA;IACd,uGAAuG;IACvG,QAAQ,EAAE,sBAAsB,CAAA;IAChC,MAAM,EAAE,iBAAiB,CAAA;CAC1B,GACD;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,IAAI,CAAA;CAAE,CAAA;AAIpC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,oBAAoB,EAAE,cAAc,CAAC,yBAAyB,CA6D1E,CAAA"}

package/dist/agent-operations/slab-surface-script.js

@@ -0,0 +1,60 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { floorScriptRecord, slabSurfaceScriptInputs, } from '../lib/floor-script.js';
+import { scriptedSize } from '../lib/geometry-script-node.js';
+import { isFloorPlate } from '../lib/plate-surface.js';
+import { ZoneFloorScript } from '../schema/index.js';
+const round = (value) => Math.round(value * 1000) / 1000;
+/**
+ * `setSlabSurfaceScript`: a standalone slab's surface finish (a terrace's decking, a platform's
+ * tiles, a plinth's paving) built by a three.js module, or the module taken off. The host reads the
+ * slab's outline (`slabSurfaceScriptInputs`), compiles the module for it (the module reads
+ * `params.polygon` and `params.holes` in the level's plan x/z, and lays its finish from y = 0, the
+ * slab's top) and stores the artifacts; this writes the result on the slab with the key of the
+ * outline it was built for, and the renderer stands it on the slab. When the slab is reshaped the
+ * script is stale and `refreshFinishScripts` runs it again. The script owns the surface's colours:
+ * paint on it is refused while it is there. A room's floor plate has none: the room's floor script
+ * (`setRoomFloorScript`) builds there.
+ */
+export const setSlabSurfaceScript = (nodes, input) => {
+    const slab = nodes[input.slabId];
+    if (slab?.type !== 'slab')
+        refuse('target_not_found', `${input.slabId} is not a slab in the scene: nothing was changed.`, {
+            target: input.slabId,
+        });
+    const name = slab.name?.trim() || slab.id;
+    if ('remove' in input) {
+        if (!slab.surfaceScript)
+            return { result: { ok: true, slabId: slab.id, removed: false } };
+        return {
+            result: { ok: true, slabId: slab.id, removed: true },
+            changes: { update: [{ id: slab.id, data: { surfaceScript: undefined } }] },
+        };
+    }
+    const { compiled } = input;
+    if (compiled.language !== 'three')
+        refuse('three_only', `A slab's surface script is a three.js module: it is given the slab's outline, which a Blender build is not. Nothing was changed on ${name}.`, { target: slab.id });
+    if (isFloorPlate(slab)) {
+        const rooms = (slab.zoneIds ?? []).flatMap((id) => {
+            const zone = nodes[id];
+            return zone?.type === 'zone' ? [`${zone.name?.trim() || zone.id} (${zone.id})`] : [];
+        });
+        refuse('room_floor_plate', `${name} is the floor plate Pascal builds under ${rooms.length ? rooms.join(', ') : 'its rooms'}: a room's floor finish is built by that room's floor script, not by the plate. Nothing was changed.`, { target: slab.id, zoneIds: slab.zoneIds ?? [] });
+    }
+    if (!slabSurfaceScriptInputs(nodes, slab.id))
+        refuse('no_surface', `${name} has no surface to build on (its outline has fewer than three corners): nothing was changed.`, { target: slab.id });
+    const { min, max } = compiled.manifest.bounds;
+    if (![...min, ...max].every(Number.isFinite))
+        refuse('unmeasurable_object', `${name}'s surface script built geometry that cannot be measured: a mesh in it has a position, rotation or scale that is not a number. Nothing was changed.`, { target: slab.id });
+    const surfaceScript = ZoneFloorScript.parse(floorScriptRecord(compiled, input.inputs, slab.surfaceScript));
+    return {
+        result: {
+            ok: true,
+            slabId: slab.id,
+            size: scriptedSize(compiled.manifest).map(round),
+            slots: compiled.manifest.slots.map((slot) => slot.id),
+            triangles: compiled.manifest.triangles,
+            note: `The script owns ${name}'s surface colours: painting that surface is refused until the script is removed. It runs again whenever the slab's outline or holes change.`,
+        },
+        changes: { update: [{ id: slab.id, data: { surfaceScript } }] },
+    };
+};

package/dist/agent-operations/stair-plan-footprint.d.ts

@@ -0,0 +1,9 @@
+import type { AnyNode } from '../schema/index.js';
+import type { Vec2 } from './plan-geometry.js';
+import type { SceneNodes } from './types.js';
+export type StairNode = AnyNode & {
+    type: 'stair';
+};
+/** The floor a stair stands on, in its level's plan frame: a straight stair's segments, a curved or spiral stair's turning circle. */
+export declare function stairFootprintPolygons(nodes: SceneNodes, stair: StairNode): Vec2[][];
+//# sourceMappingURL=stair-plan-footprint.d.ts.map

package/dist/agent-operations/stair-plan-footprint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stair-plan-footprint.d.ts","sourceRoot":"","sources":["../../src/agent-operations/stair-plan-footprint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAGxC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzC,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAAA;AAOnD,sIAAsI;AACtI,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,EAAE,EAAE,CA6CpF"}