@pascal-app/core 1.0.6 → 1.1.0

package/dist/agent-operations/authored-scene-merge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"authored-scene-merge.d.ts","sourceRoot":"","sources":["../../src/agent-operations/authored-scene-merge.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAkDvD,mGAAmG;AACnG,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,UAAU,EACnB,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,UAAU,GACf,YAAY,CAwDd"}
+{"version":3,"file":"authored-scene-merge.d.ts","sourceRoot":"","sources":["../../src/agent-operations/authored-scene-merge.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAwGvD,mGAAmG;AACnG,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,UAAU,EACnB,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,UAAU,GACf,YAAY,CAyEd"}

package/dist/agent-operations/authored-scene-merge.js

@@ -1,4 +1,5 @@
 import { refuse } from '../agent-tools/refusal.js';
+import { isDerivedNode, manualSurfaceHoles, reconcilerOwnedFields, } from '../store/derived-node-guard.js';
 const equal = (a, b) => {
     if (Object.is(a, b))
         return true;
@@ -11,11 +12,57 @@ const equal = (a, b) => {
     return false;
 };
 const record = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+/** What a script's compile produced, against what was asked of it (`GeometryScriptSource`). */
+const COMPILE_OUTPUTS = ['artifact', 'manifest', 'images', 'inputs'];
+const scriptSource = (value) => record(value) && value.kind === 'script' && typeof value.script === 'string';
+const intent = (source) => Object.fromEntries(Object.entries(source).filter(([key]) => !COMPILE_OUTPUTS.includes(key)));
+/**
+ * Between conversions Pascal rebuilds what it derives: the reconciler a derived surface's outline,
+ * holes and openings, a script's compile on its new outline, the order of children. None of it is
+ * a person's edit, so none of it may refuse the design's next revision; a person's cut-out in a
+ * derived surface (`personView`), and any script code or params they changed, still are.
+ */
+const reconcilerOwned = (current) => new Set(isDerivedNode(current) ? reconcilerOwnedFields(current) : []);
+/**
+ * A derived surface's holes never follow the design: the host's reconciler re-cuts the room ones
+ * from the walls the revision did change and re-applies a person's, while its guard refuses a room
+ * hole written by anyone else (the outline it strips silently).
+ */
+const SURFACE_HOLES = new Set(['holes', 'holeMetadata']);
+/** A value as a person edits it: every script in it without its compile. */
+const asEdited = (value) => {
+    if (Array.isArray(value))
+        return value.map(asEdited);
+    if (!record(value))
+        return value;
+    const kept = scriptSource(value) ? intent(value) : value;
+    return Object.fromEntries(Object.entries(kept).map(([key, entry]) => [key, asEdited(entry)]));
+};
+/**
+ * A node as a person edits it: without what Pascal derives on it, its children in any order, and
+ * on a derived surface the holes they cut themselves.
+ */
+function personView(node, owned) {
+    const view = asEdited(Object.fromEntries(Object.entries(node).filter(([key]) => !owned.has(key))));
+    if (Array.isArray(view.children))
+        view.children = [...view.children].sort();
+    if (isDerivedNode(node))
+        view.manualHoles = manualSurfaceHoles(node);
+    return view;
+}
 function merged(base, current, next, path) {
     if (equal(base, next) || equal(current, next))
         return current;
-    if (equal(base, current))
+    // A side that changed nothing but compiles has changed nothing: a compile follows its code.
+    if (equal(asEdited(base), asEdited(current)))
         return next;
+    if (equal(asEdited(base), asEdited(next)))
+        return current;
+    if (scriptSource(base) && scriptSource(current) && scriptSource(next)) {
+        if (equal(intent(current), intent(next)))
+            return next;
+        refuse('authored_edit_conflict', `Both the design and the current scene changed the script at ${path}. Preserve the current edit and resolve this change explicitly.`, { path, mutationApplied: false });
+    }
     if (record(base) && record(current) && record(next)) {
         const result = {};
         for (const key of new Set([
@@ -70,13 +117,24 @@ export function authoredSceneChanges(current, base, next) {
             delete effective[id];
         }
         else if (!desired) {
-            if (!equal(now, old))
+            const owned = reconcilerOwned(now);
+            if (!equal(personView(now, owned), personView(old, owned)))
                 refuse('authored_edit_conflict', `Node ${id} was edited after conversion and cannot be removed by regeneration.`, { mutationApplied: false });
             remove.push(id);
             delete effective[id];
         }
         else {
-            const value = merged(old, now, desired, id);
+            const owned = reconcilerOwned(now);
+            const value = Object.fromEntries([...new Set([...Object.keys(old), ...Object.keys(now), ...Object.keys(desired)])].flatMap((key) => {
+                const [b, c, n] = [old, now, desired].map((node) => node[key]);
+                // What the reconciler owns follows the design where it changed, else stays as derived.
+                const entry = owned.has(key)
+                    ? SURFACE_HOLES.has(key) || equal(b, n)
+                        ? c
+                        : n
+                    : merged(b, c, n, `${id}.${key}`);
+                return entry === undefined ? [] : [[key, entry]];
+            }));
             effective[id] = value;
             if (!equal(now, value)) {
                 const data = {};

package/dist/agent-operations/batch.d.ts

@@ -15,7 +15,7 @@ type Contract = {
  * `run_batch`: shared tools in order, each on the scene the calls before it left, their changes
  * merged into one set — one undo step, one write on either surface. The user: the model spent a
  * round trip per step on what could be serialised (deleting balcony walls one by one, the same
- * build on every floor). Inputs are checked before anything runs.
+ * build on every floor). Pre-check and operation refusals follow the same per-call policy.
  */
 export declare function createBatchOperation(operations: Readonly<Record<string, AgentOperation<never>>>, contracts: readonly Contract[]): AgentOperation<BatchInput>;
 export {};

package/dist/agent-operations/batch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"batch.d.ts","sourceRoot":"","sources":["../../src/agent-operations/batch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAOvB,OAAO,KAAK,EAAE,cAAc,EAAgB,MAAM,SAAS,CAAA;AAE3D,KAAK,UAAU,GAAG;IAChB,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,EAAE,CAAA;IAC1D,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;CAC5B,CAAA;AACD,KAAK,QAAQ,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAA;CAAE,CAAA;AAgBlE;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC,EAC3D,SAAS,EAAE,SAAS,QAAQ,EAAE,GAC7B,cAAc,CAAC,UAAU,CAAC,CAsG5B"}
+{"version":3,"file":"batch.d.ts","sourceRoot":"","sources":["../../src/agent-operations/batch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAOvB,OAAO,KAAK,EAAE,cAAc,EAAgB,MAAM,SAAS,CAAA;AAE3D,KAAK,UAAU,GAAG;IAChB,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,EAAE,CAAA;IAC1D,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;CAC5B,CAAA;AACD,KAAK,QAAQ,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAA;CAAE,CAAA;AA8BlE;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC,EAC3D,SAAS,EAAE,SAAS,QAAQ,EAAE,GAC7B,cAAc,CAAC,UAAU,CAAC,CAoF5B"}

package/dist/agent-operations/batch.js

@@ -1,57 +1,44 @@
 import { z } from 'zod';
 import { INDEPENDENT_BATCH_TOOLS } from '../agent-tools/batch.js';
-import { isAgentRefusal, refuse } from '../agent-tools/refusal.js';
+import { AgentRefusal, isAgentRefusal, refuse } from '../agent-tools/refusal.js';
 import { applySceneChanges, mergeSceneChanges } from './apply-changes.js';
 import { requireFurnishing } from './design-brief.js';
 import { referencedSceneMaterialIds } from './scene-materials.js';
+function prepareCall(call, index, operations, contracts) {
+    const operation = Object.hasOwn(operations, call.tool) ? operations[call.tool] : undefined;
+    const contract = contracts.find((candidate) => candidate.name === call.tool);
+    if (!(operation && contract))
+        refuse('unknown_tool', `The batch's call ${index + 1} names ${call.tool}, which a batch cannot run: call it on its own. A batch runs: ${Object.keys(operations).join(', ')}.`);
+    const parsed = z.object(contract.input).safeParse(call.input ?? {});
+    if (!parsed.success)
+        refuse('invalid_input', `The batch's call ${index + 1} (${call.tool}) has an invalid input: ${parsed.error.issues
+            .map((issue) => `${issue.path.join('.') || 'input'}: ${issue.message}`)
+            .join('; ')}.`);
+    return { operation, input: parsed.data };
+}
 /**
  * `run_batch`: shared tools in order, each on the scene the calls before it left, their changes
  * merged into one set — one undo step, one write on either surface. The user: the model spent a
  * round trip per step on what could be serialised (deleting balcony walls one by one, the same
- * build on every floor). Inputs are checked before anything runs.
+ * build on every floor). Pre-check and operation refusals follow the same per-call policy.
  */
 export function createBatchOperation(operations, contracts) {
-    const names = Object.keys(operations).join(', ');
     return (nodes, { calls, onRefusal = 'stop' }, context) => {
-        const prepared = calls.map((call, index) => {
-            const operation = operations[call.tool];
-            const contract = contracts.find((candidate) => candidate.name === call.tool);
-            if (!(operation && contract))
-                refuse('unknown_tool', `The batch's call ${index + 1} names ${call.tool}, which a batch cannot run: call it on its own. A batch runs: ${names}.`, { index, tool: call.tool });
-            const parsed = z.object(contract.input).safeParse(call.input ?? {});
-            if (!parsed.success) {
-                const message = `The batch's call ${index + 1} (${call.tool}) has an invalid input: ${parsed.error.issues
-                    .map((issue) => `${issue.path.join('.') || 'input'}: ${issue.message}`)
-                    .join('; ')}.`;
-                // An independent call's bad input is its own report; the others still run.
-                if (INDEPENDENT_BATCH_TOOLS.includes(call.tool))
-                    return { index, tool: call.tool, invalid: message };
-                refuse('invalid_input', `${message} Nothing ran.`, { index, tool: call.tool });
-            }
-            return { index, tool: call.tool, operation, input: parsed.data };
-        });
-        // The gate is a fact of the tool, not of the scene: a call it refuses cannot succeed under
-        // either onRefusal, so the batch is refused whole before anything runs.
-        requireFurnishing('run_batch', { calls }, context.designBrief);
         let working = nodes;
         let workingContext = context;
+        let kept;
         const sets = [];
         const reports = [];
-        for (const call of prepared) {
-            if (call.invalid !== undefined) {
-                reports.push({
-                    index: call.index,
-                    tool: call.tool,
-                    status: 'refused',
-                    code: 'invalid_input',
-                    error: call.invalid,
-                });
-                continue;
-            }
+        for (const [index, call] of calls.entries()) {
             try {
-                const { result, changes } = call.operation(working, call.input, {
+                requireFurnishing(call.tool, call.input, context.designBrief, {
+                    session: workingContext.session,
+                    catalog: workingContext.catalog,
+                });
+                const { operation, input } = prepareCall(call, index, operations, contracts);
+                const { result, changes } = operation(working, input, {
                     ...workingContext,
-                    batchCall: call.index,
+                    batchCall: index,
                 });
                 if (changes) {
                     sets.push(changes);
@@ -65,15 +52,26 @@ export function createBatchOperation(operations, contracts) {
                             },
                         };
                 }
-                reports.push({ index: call.index, tool: call.tool, status: 'ok', result });
+                reports.push({ index, tool: call.tool, status: 'ok', result });
             }
             catch (error) {
                 if (!isAgentRefusal(error))
                     throw error;
                 if (onRefusal === 'stop' && !INDEPENDENT_BATCH_TOOLS.includes(call.tool))
-                    refuse('batch_call_refused', `The batch stopped at call ${call.index + 1} (${call.tool}), refused with ${error.code}: ${error.message} Nothing in the batch was applied.`, { index: call.index, tool: call.tool, refusal: error.code, ...error.details });
+                    throw new AgentRefusal('batch_call_refused', `The batch stopped at call ${index + 1} (${call.tool}), refused with ${error.code}: ${error.message} Nothing in the batch was applied.`, { ...error.details, index, tool: call.tool, refusal: error.code }, error.keep);
+                if (error.keep) {
+                    kept = { ...kept, ...error.keep.readings };
+                    if (workingContext.session)
+                        workingContext = {
+                            ...workingContext,
+                            session: {
+                                ...workingContext.session,
+                                readings: { ...workingContext.session.readings, ...error.keep.readings },
+                            },
+                        };
+                }
                 reports.push({
-                    index: call.index,
+                    index,
                     tool: call.tool,
                     status: 'refused',
                     code: error.code,
@@ -99,6 +97,7 @@ export function createBatchOperation(operations, contracts) {
         return {
             result: { status: 'applied', applied, refused: reports.length - applied, calls: reports },
             ...(changed ? { changes: merged } : {}),
+            ...(kept ? { keep: { readings: kept } } : {}),
         };
     };
 }

package/dist/agent-operations/ceiling-object-observations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ceiling-object-observations.d.ts","sourceRoot":"","sources":["../../src/agent-operations/ceiling-object-observations.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAKxC,KAAK,cAAc,GAAG;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,eAAe,EAAE,UAAU,CAAA;IAC3B,MAAM,EAAE;QAAE,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;QAAC,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,CAAA;CACzE,CAAA;AAED,MAAM,MAAM,wBAAwB,GAChC,CAAC,cAAc,GAAG;IAChB,IAAI,EAAE,oBAAoB,CAAA;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,qBAAqB,EAAE,MAAM,CAAA;IAC7B,mBAAmB,EAAE,MAAM,CAAA;CAC5B,CAAC,GACF,CAAC,cAAc,GAAG;IAChB,IAAI,EAAE,4BAA4B,CAAA;IAClC,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,MAAM,CAAA;IAChB,mBAAmB,EAAE,MAAM,CAAA;IAC3B,uBAAuB,EAAE,MAAM,CAAA;CAChC,CAAC,CAAA;AAoBN,uGAAuG;AACvG,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,wBAAwB,EAAE,CAqF5B"}
+{"version":3,"file":"ceiling-object-observations.d.ts","sourceRoot":"","sources":["../../src/agent-operations/ceiling-object-observations.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAsB,MAAM,WAAW,CAAA;AAM5D,KAAK,cAAc,GAAG;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,eAAe,EAAE,UAAU,CAAA;IAC3B,MAAM,EAAE;QAAE,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;QAAC,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,CAAA;CACzE,CAAA;AAED,MAAM,MAAM,wBAAwB,GAChC,CAAC,cAAc,GAAG;IAChB,IAAI,EAAE,oBAAoB,CAAA;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,qBAAqB,EAAE,MAAM,CAAA;IAC7B,mBAAmB,EAAE,MAAM,CAAA;CAC5B,CAAC,GACF,CAAC,cAAc,GAAG;IAChB,IAAI,EAAE,4BAA4B,CAAA;IAClC,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,MAAM,CAAA;IAChB,mBAAmB,EAAE,MAAM,CAAA;IAC3B,uBAAuB,EAAE,MAAM,CAAA;CAChC,CAAC,CAAA;AAoBN,uGAAuG;AACvG,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,wBAAwB,EAAE,CAqF5B"}

package/dist/agent-operations/ceiling-object-observations.js

@@ -5,6 +5,7 @@ import { getRenderableSlabPolygon, slabPolygonContextForLevel } from '../lib/sla
 import { resolveCeilingHeight } from '../services/level-height.js';
 import { CEILING_DRAW_OFFSET, getLevelElevations } from '../services/storey.js';
 import { scriptItemBoundsInLevel } from './layout-clearance.js';
+import { queryNodes } from './scene-queries.js';
 function projectedHull(corners) {
     const sorted = corners
         .map(([x, , z]) => [x, z])
@@ -26,8 +27,8 @@ function projectedHull(corners) {
 export function ceilingObjectObservations(nodes) {
     const observations = [];
     const elevations = getLevelElevations(nodes);
-    for (const item of Object.values(nodes)) {
-        if (item.type !== 'item' || item.asset.attachTo !== 'ceiling')
+    for (const item of queryNodes(nodes, { type: 'item' })) {
+        if (item.asset.attachTo !== 'ceiling')
             continue;
         const ceiling = item.parentId ? nodes[item.parentId] : undefined;
         if (ceiling?.type !== 'ceiling')
@@ -62,8 +63,8 @@ export function ceilingObjectObservations(nodes) {
                 attachmentElevation: attachment,
             });
         const footprint = projectedHull(resolved.corners);
-        for (const original of Object.values(nodes)) {
-            if (original.type !== 'slab' || original.recessed || !original.parentId)
+        for (const original of queryNodes(nodes, { type: 'slab' })) {
+            if (original.recessed || !original.parentId)
                 continue;
             const slabLevel = elevations.get(original.parentId);
             // Unlinked legacy levels are not evidence that two different storeys share a building.

package/dist/agent-operations/circulation-geometry.d.ts

@@ -0,0 +1,14 @@
+import { type CirculationGraph } from './circulation-graph.js';
+import type { SceneNodes } from './types.js';
+export type CirculationGeometryReason = {
+    code: string;
+    message: string;
+    nodeIds: string[];
+};
+/** The same named measurement limits for the Flow note and agent diagnostics. */
+export declare function circulationGeometryReasons(scene: SceneNodes, graph?: CirculationGraph): CirculationGeometryReason[];
+/** Losing a route while excluding geometry is missing coverage, not proof of disconnection. */
+export declare function unmeasuredRouteIds(rawReachable: Iterable<string>, measuredReachable: Iterable<string>): Set<string>;
+/** Exclude uncertain spaces and connectors, not unrelated measured routes. */
+export declare function measuredCirculationGraph(scene: SceneNodes, graph: CirculationGraph, reasons: CirculationGeometryReason[]): CirculationGraph;
+//# sourceMappingURL=circulation-geometry.d.ts.map

package/dist/agent-operations/circulation-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circulation-geometry.d.ts","sourceRoot":"","sources":["../../src/agent-operations/circulation-geometry.ts"],"names":[],"mappings":"AAEA,OAAO,EAAyB,KAAK,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AAElF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzC,MAAM,MAAM,yBAAyB,GAAG;IACtC,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,EAAE,CAAA;CAClB,CAAA;AAsHD,iFAAiF;AACjF,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,UAAU,EACjB,KAAK,GAAE,gBAA+C,GACrD,yBAAyB,EAAE,CAW7B;AAED,+FAA+F;AAC/F,wBAAgB,kBAAkB,CAChC,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,EAC9B,iBAAiB,EAAE,QAAQ,CAAC,MAAM,CAAC,GAClC,GAAG,CAAC,MAAM,CAAC,CAGb;AAED,8EAA8E;AAC9E,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,UAAU,EACjB,KAAK,EAAE,gBAAgB,EACvB,OAAO,EAAE,yBAAyB,EAAE,GACnC,gBAAgB,CAmClB"}

package/dist/agent-operations/circulation-geometry.js

@@ -0,0 +1,151 @@
+import { resolveLevelId } from '../lib/node-ancestry.js';
+import { area, containsPoint, intersection } from '../lib/polygon-boolean.js';
+import { buildCirculationGraph } from './circulation-graph.js';
+import { spaceRegion } from './circulation-spaces.js';
+function floorReasons(scene, graph, add) {
+    for (const floor of graph.floors) {
+        for (const slab of floor.slabs) {
+            const source = scene[slab.id];
+            if (source?.type !== 'slab')
+                continue;
+            // An open-supported floor outside the enclosed footprint on the ground is outdoor ground.
+            if (source.support === 'open') {
+                if (!slab.outdoor)
+                    add('open_supported_floors', slab.id);
+            }
+            else if (!slab.outdoor &&
+                Math.abs(slab.elevation - floor.elevation) > 1e-6 &&
+                (!floor.interior.length ||
+                    area(intersection({ outer: slab.polygon, holes: slab.holes }, floor.interior)) > 1e-6))
+                add('split_interior_floors', slab.id);
+        }
+        for (const zone of floor.zones) {
+            const source = scene[zone.id];
+            if (source?.type !== 'zone')
+                continue;
+            if (zone.outdoor) {
+                const regions = floor.pockets.flatMap((pocket) => intersection({ outer: zone.polygon, holes: zone.holes }, pocket.polygon));
+                if (regions.length > 1)
+                    add('divided_outdoor_spaces', zone.id);
+            }
+            if (source.floor?.support === 'open' && !zone.outdoor)
+                add('open_supported_floors', zone.id);
+            else if (zone.outdoor)
+                continue;
+            else if (source.hasFloor === false)
+                add(floor.ground ? 'floorless_interior_spaces' : 'floorless_upper_spaces', zone.id);
+            else if (source.floor?.elevation !== undefined &&
+                Math.abs(floor.groundElevation + source.floor.elevation - floor.elevation) > 1e-6)
+                add('split_interior_floors', zone.id);
+        }
+    }
+}
+function geometryGroups(scene, graph) {
+    const groups = new Map();
+    const add = (code, ...ids) => {
+        const group = groups.get(code) ?? new Set();
+        for (const id of ids)
+            group.add(id);
+        groups.set(code, group);
+    };
+    const buildings = Object.values(scene).filter((node) => node.type === 'building');
+    if (buildings.length > 1)
+        add('multiple_buildings', ...buildings.map((node) => node.id));
+    for (const node of buildings)
+        if (Math.abs(node.rotation[0]) > 1e-8 || Math.abs(node.rotation[2]) > 1e-8)
+            add('tilted_buildings', node.id);
+    floorReasons(scene, graph, add);
+    if (!graph.floors.some((floor) => floor.slabs.length)) {
+        const inhabited = graph.floors.filter((floor) => floor.zones.length || floor.pockets.length);
+        if (inhabited.length)
+            add('floor_missing', ...inhabited.map((floor) => floor.id));
+    }
+    for (const node of Object.values(scene)) {
+        if (node.type !== 'stair')
+            continue;
+        const host = scene[node.supportSlabId ?? ''];
+        const floor = graph.floors.find((candidate) => candidate.id === (node.fromLevelId ?? resolveLevelId(node, scene)));
+        const surface = floor?.slabs.find((slab) => slab.id === host?.id);
+        const raisedHost = host?.type === 'slab' &&
+            (host.support === 'open' ||
+                (surface &&
+                    !surface.outdoor &&
+                    Math.abs(surface.elevation - (floor?.elevation ?? 0)) > 1e-6));
+        const measuredEntrySteps = graph.entranceFlights.has(node.id) ||
+            (floor?.ground &&
+                !node.toLevelId &&
+                graph.edges.some((edge) => edge.kind === 'stair' && edge.sourceId === node.id));
+        if (!measuredEntrySteps && (node.deckSlabId || Math.abs(node.position[1]) > 1e-6 || raisedHost))
+            add('deck_stairs', node.id);
+    }
+    for (const id of graph.unsupportedIds) {
+        const node = scene[id];
+        add(node?.type === 'stair'
+            ? 'incomplete_stairs'
+            : node?.type === 'door'
+                ? 'unhosted_doors'
+                : 'disconnected_surfaces', id);
+    }
+    return groups;
+}
+const REASONS = {
+    multiple_buildings: (n) => `${n} buildings have separate circulation frames`,
+    tilted_buildings: (n) => `${n} tilted building${n === 1 ? ' has' : 's have'} non-horizontal walking planes`,
+    split_interior_floors: (n) => `${n} interior floor element${n === 1 ? ' has a different walking height' : 's have different walking heights'} on the same level`,
+    open_supported_floors: (n) => `${n} open-supported floor element${n === 1 ? ' forms' : 's form'} stacked walking planes`,
+    floorless_upper_spaces: (n) => `${n} upper-level space${n === 1 ? ' has' : 's have'} no walking floor`,
+    floorless_interior_spaces: (n) => `${n} interior space${n === 1 ? ' has' : 's have'} no walking floor`,
+    deck_stairs: (n) => `${n} stair or deck connection${n === 1 ? '' : 's'} cannot be measured between their walking surfaces`,
+    incomplete_stairs: (n) => `${n} stair${n === 1 ? ' has' : 's have'} an incomplete walking path or a missing destination floor`,
+    unhosted_doors: (n) => `${n} door${n === 1 ? ' has' : 's have'} no wall host`,
+    disconnected_surfaces: (n) => `${n} floor surface${n === 1 ? ' is' : 's are'} split into disconnected walking regions`,
+    floor_missing: (n) => `${n} inhabited level${n === 1 ? ' has' : 's have'} no floor slabs`,
+    divided_outdoor_spaces: (n) => `${n} outdoor space${n === 1 ? ' spans' : 's span'} disconnected or wall-separated walking regions`,
+};
+/** The same named measurement limits for the Flow note and agent diagnostics. */
+export function circulationGeometryReasons(scene, graph = buildCirculationGraph(scene)) {
+    return [...geometryGroups(scene, graph)].map(([code, ids]) => {
+        const nodeIds = [...ids];
+        return {
+            code,
+            nodeIds,
+            message: `${REASONS[code]?.(nodeIds.length) ?? `${nodeIds.length} unsupported elements`}: ${nodeIds
+                .map((id) => scene[id]?.name ?? `Unnamed ${scene[id]?.type ?? 'element'}`)
+                .join(', ')}.`,
+        };
+    });
+}
+/** Losing a route while excluding geometry is missing coverage, not proof of disconnection. */
+export function unmeasuredRouteIds(rawReachable, measuredReachable) {
+    const measured = new Set(measuredReachable);
+    return new Set([...rawReachable].filter((id) => !measured.has(id)));
+}
+/** Exclude uncertain spaces and connectors, not unrelated measured routes. */
+export function measuredCirculationGraph(scene, graph, reasons) {
+    const unsupported = new Set(reasons.flatMap((reason) => reason.nodeIds));
+    const surfaces = [...unsupported].flatMap((id) => {
+        const node = scene[id];
+        return node?.type === 'slab' || node?.type === 'zone' ? [node] : [];
+    });
+    const nodes = new Map([...graph.nodes].filter(([, node]) => {
+        if (node.sourceId && unsupported.has(node.sourceId))
+            return false;
+        return !surfaces.some((surface) => {
+            if (resolveLevelId(surface, scene) !== node.levelId)
+                return false;
+            const region = spaceRegion(scene, graph, node);
+            if (region)
+                return (area(intersection(region, { outer: surface.polygon, holes: surface.holes ?? [] })) >
+                    1e-6);
+            return containsPoint([{ outer: surface.polygon, holes: surface.holes ?? [] }], [node.position[0], node.position[2]]);
+        });
+    }));
+    const edges = graph.edges.filter((edge) => nodes.has(edge.from) &&
+        nodes.has(edge.to) &&
+        (!edge.sourceId || !unsupported.has(edge.sourceId)));
+    return {
+        ...graph,
+        nodes,
+        edges,
+    };
+}

package/dist/agent-operations/circulation-graph.d.ts

@@ -0,0 +1,72 @@
+import { type Floor, type Pt, type Space } from './circulation-spaces.js';
+import type { SceneNodes } from './types.js';
+export type CirculationNode = {
+    id: string;
+    kind: 'room' | 'zone' | 'floor' | 'outdoor' | 'outside' | 'stair-landing' | 'lift-landing';
+    levelId: string | null;
+    sourceId: string | null;
+    name: string;
+    areaM2: number | null;
+    position: [number, number, number];
+    apartment?: string;
+};
+export type CirculationEdge = {
+    id: string;
+    from: string;
+    to: string;
+    kind: 'door' | 'opening' | 'open-edge' | 'stair' | 'lift';
+    sourceId: string | null;
+    widthM: number | null;
+    position: [number, number, number];
+    lengthM: number;
+    stepHeightM?: number;
+    use?: 'vehicle' | 'pedestrian';
+    riseM?: number;
+    runM?: number;
+    maximumSlopePercent?: number;
+    maxSlopePercent?: number;
+    startTransitionM?: number;
+    endTransitionM?: number;
+    path?: [number, number, number][];
+};
+export type CirculationIssue = {
+    type: string;
+    message: string;
+    nodeIds: string[];
+    levelIds?: string[];
+    reasonCode?: string;
+    spaceId?: string;
+};
+/** A space that is not a destination: open air through a floor opening, or an outdoor slab. */
+export type CirculationNonSpace = 'void' | 'outdoor-slab';
+/** A door on a raised level that opens to open air with no modelled ground in reach of its sill. */
+export type UnmeasuredEntrance = {
+    doorId: string;
+    spaceId: string;
+    levelId: string;
+};
+export type CirculationGraph = {
+    nodes: Map<string, CirculationNode>;
+    edges: CirculationEdge[];
+    floors: Floor[];
+    issues: CirculationIssue[];
+    unsupportedIds: string[];
+    unmeasuredEntrances: UnmeasuredEntrance[];
+    /** Stairs with no destination level that are the way in from the outside ground. */
+    entranceFlights: Set<string>;
+    nonSpaces: Map<string, CirculationNonSpace>;
+};
+export declare const nodeName: (nodes: SceneNodes, id: string) => string;
+declare function graphWriter(scene: SceneNodes, graph: CirculationGraph): {
+    note: (floor: Floor, space: Space, point: Pt) => string;
+    link: (from: string, to: string, kind: CirculationEdge['kind'], sourceId: string | null, widthM: number | null, position: CirculationEdge['position'], lengthM?: number, stepHeightM?: number, path?: CirculationEdge['path']) => void;
+};
+export type CirculationWriter = ReturnType<typeof graphWriter>;
+export declare function buildCirculationGraph(scene: SceneNodes): CirculationGraph;
+export declare function circulationLinks(graph: CirculationGraph): Map<string, Set<string>>;
+/** Only outdoor spaces with an actual outdoor route belong to the site's outside. */
+export declare function exteriorSpaceIds(graph: CirculationGraph): Set<string>;
+export declare function exteriorEntranceEdges(graph: CirculationGraph): CirculationEdge[];
+export declare function reachedFrom(links: Map<string, Set<string>>, starts: string[], through?: (id: string) => boolean): Set<string>;
+export {};
+//# sourceMappingURL=circulation-graph.d.ts.map

package/dist/agent-operations/circulation-graph.d.ts.map

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