@pascal-app/mcp 1.0.3 → 1.0.5

package/dist/tools/node-world-point.js

@@ -0,0 +1,457 @@
+import { computeSegmentTransforms, getFenceCenterlineFrameAt, getLevelElevations, getWallCurveFrameAt, measurementCentroid, nodeRegistry, } from '@pascal-app/core';
+import { composeFrames, frame, IDENTITY_FRAME, nodeLevelFrame, transformPoint, } from '@pascal-app/core/procedural-items';
+import { AnyNode, getRoofSegmentSurfaceY, nodeKindOf, } from '@pascal-app/core/schema';
+function isVec3(value) {
+    return (Array.isArray(value) &&
+        value.length >= 3 &&
+        value.slice(0, 3).every((v) => typeof v === 'number' && Number.isFinite(v)));
+}
+function boundsCentre(points) {
+    if (points.length === 0)
+        return null;
+    const min = [Infinity, Infinity, Infinity];
+    const max = [-Infinity, -Infinity, -Infinity];
+    for (const p of points) {
+        for (let i = 0; i < 3; i++) {
+            min[i] = Math.min(min[i], p[i]);
+            max[i] = Math.max(max[i], p[i]);
+        }
+    }
+    return [(min[0] + max[0]) / 2, (min[1] + max[1]) / 2, (min[2] + max[2]) / 2];
+}
+/** Area centroid of a plan polygon at height `y`; the vertex average when degenerate. */
+function polygonCentre(polygon, y) {
+    if (!Array.isArray(polygon) || polygon.length === 0)
+        return null;
+    const points = polygon.map(([x, z]) => [x, y, z]);
+    const centroid = measurementCentroid(points);
+    if (centroid)
+        return centroid;
+    let cx = 0;
+    let cz = 0;
+    for (const [x, , z] of points) {
+        cx += x;
+        cz += z;
+    }
+    return [cx / points.length, y, cz / points.length];
+}
+function geometryContext(node, nodes) {
+    const lookup = (id) => nodes[id];
+    const childIds = (n) => 'children' in n && Array.isArray(n.children) ? n.children : [];
+    const parent = node.parentId ? (lookup(node.parentId) ?? null) : null;
+    return {
+        resolve: ((id) => lookup(id)),
+        parent,
+        children: childIds(node)
+            .map(lookup)
+            .filter((child) => child !== undefined),
+        siblings: parent
+            ? childIds(parent)
+                .map(lookup)
+                .filter((s) => s !== undefined && s.type === node.type)
+            : [],
+    };
+}
+/** The point at parameter `t` (default 0.5) along a feature, by arc length. */
+function featurePoint(feature, reference) {
+    const t = typeof reference.parameters?.t === 'number' ? reference.parameters.t : 0.5;
+    const geometry = feature.geometry;
+    if (geometry.kind === 'point')
+        return geometry.point;
+    const points = geometry.kind === 'segment' ? [geometry.start, geometry.end] : geometry.points;
+    const closed = geometry.kind === 'polygon' || (geometry.kind === 'path' && geometry.closed === true);
+    if (points.length === 0)
+        return null;
+    const count = closed ? points.length : points.length - 1;
+    const lengths = Array.from({ length: Math.max(0, count) }, (_, i) => {
+        const a = points[i];
+        const b = points[(i + 1) % points.length];
+        return Math.hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
+    });
+    const total = lengths.reduce((sum, length) => sum + length, 0);
+    if (total <= 1e-9)
+        return points[0];
+    let remaining = Math.max(0, Math.min(1, t)) * total;
+    for (let i = 0; i < count; i++) {
+        const length = lengths[i];
+        if (remaining <= length || i === count - 1) {
+            const a = points[i];
+            const b = points[(i + 1) % points.length];
+            const u = length <= 1e-9 ? 0 : remaining / length;
+            return [a[0] + (b[0] - a[0]) * u, a[1] + (b[1] - a[1]) * u, a[2] + (b[2] - a[2]) * u];
+        }
+        remaining -= length;
+    }
+    return points[points.length - 1];
+}
+/**
+ * A measurement or dimension anchor as the viewer resolves it: a tuple is a
+ * free point; a feature anchor follows its referenced node through that kind's
+ * registered measurement contribution, and falls back to its stored point when
+ * the node or the contribution is missing (`fallback: true`).
+ */
+function resolveAnchor(anchor, nodes) {
+    if (isVec3(anchor))
+        return { point: anchor, fallback: false };
+    const feature = anchor;
+    if (!(feature?.reference && isVec3(feature.fallback)))
+        return null;
+    const reference = feature.reference;
+    const referenced = nodes[reference.nodeId];
+    const contribution = referenced ? nodeRegistry.get(referenced.type)?.measurement : undefined;
+    if (referenced && contribution) {
+        const context = geometryContext(referenced, nodes);
+        const resolved = contribution.resolve?.(referenced, context, reference) ??
+            contribution.features(referenced, context).find((c) => c.id === reference.featureId);
+        const point = resolved ? featurePoint(resolved, reference) : null;
+        if (point)
+            return { point, fallback: false };
+    }
+    return { point: feature.fallback, fallback: true };
+}
+/** The anchors a measurement or construction dimension draws from. */
+function anchorSet(node) {
+    if (node.type === 'construction-dimension')
+        return { anchors: node.anchors, shape: 'points' };
+    if (node.type !== 'measurement')
+        return null;
+    const m = node.measurement;
+    if (m.kind === 'distance' || m.kind === 'angle')
+        return { anchors: m.points ?? [], shape: 'points' };
+    if (m.kind === 'volume' && isVec3(m.extrusion)) {
+        return { anchors: m.base ?? [], shape: 'volume', extrusion: m.extrusion };
+    }
+    return { anchors: m.base ?? [], shape: 'area' };
+}
+/** Centre of a measurement or dimension: its points' centre, a base's area centroid, a prism's centre. */
+function anchorCentre(set, nodes) {
+    const points = set.anchors
+        .map((anchor) => resolveAnchor(anchor, nodes)?.point)
+        .filter((p) => p !== undefined);
+    if (set.shape === 'points')
+        return boundsCentre(points);
+    const base = measurementCentroid(points) ?? boundsCentre(points);
+    if (!base || set.shape === 'area' || !set.extrusion)
+        return base;
+    return [
+        base[0] + set.extrusion[0] / 2,
+        base[1] + set.extrusion[1] / 2,
+        base[2] + set.extrusion[2] / 2,
+    ];
+}
+/**
+ * Centre of the geometry a node stores in its own frame, before its transform:
+ * mesh vertices, a segment, a path, a polygon or measurement anchors.
+ */
+function ownGeometryCentre(node, nodes) {
+    const n = node;
+    if (node.type === 'block') {
+        return boundsCentre(node.topology.vertices.map((v) => v.position));
+    }
+    if (node.type === 'imported-mesh') {
+        const points = [];
+        for (const primitive of node.primitives) {
+            for (let i = 0; i + 2 < primitive.positions.length; i += 3) {
+                points.push([
+                    primitive.positions[i],
+                    primitive.positions[i + 1],
+                    primitive.positions[i + 2],
+                ]);
+            }
+        }
+        return boundsCentre(points);
+    }
+    if (node.type === 'slab')
+        return polygonCentre(node.polygon, node.elevation ?? 0);
+    if (node.type === 'site')
+        return polygonCentre(node.polygon?.points, 0);
+    if (Array.isArray(n.polygon))
+        return polygonCentre(n.polygon, 0);
+    if (Array.isArray(n.start) && Array.isArray(n.end)) {
+        const [x1, z1] = n.start;
+        const [x2, z2] = n.end;
+        return [(x1 + x2) / 2, 0, (z1 + z2) / 2];
+    }
+    if (Array.isArray(n.path))
+        return boundsCentre(n.path.filter(isVec3));
+    const anchors = anchorSet(node);
+    return anchors ? anchorCentre(anchors, nodes) : null;
+}
+/**
+ * Stair segments render at the attachment chain, not at their stored
+ * `position`, so resolve them from the stair frame like the stair system does.
+ */
+function stairSegmentFrame(node, nodes) {
+    const stair = node.parentId ? nodes[node.parentId] : undefined;
+    if (stair?.type !== 'stair')
+        return null;
+    const segments = (stair.children ?? [])
+        .map((id) => nodes[id])
+        .filter((n) => n?.type === 'stair-segment');
+    const index = segments.findIndex((segment) => segment.id === node.id);
+    const transform = computeSegmentTransforms(segments)[index];
+    if (!transform)
+        return null;
+    return composeFrames(nodeLevelFrame(stair.id, nodes), frame(transform.position, [0, transform.rotation, 0]));
+}
+/**
+ * Built-in kinds the viewer lifts onto the slab under them through the
+ * `floorPlaced` capability of their registered definition, and whose footprint
+ * core cannot derive without it (core derives item, shelf and procedural-item
+ * footprints from the node itself). Headless MCP does not load
+ * `@pascal-app/nodes`, so their lift is unresolved and flagged, not guessed. A
+ * test keeps this list in step with the definitions.
+ */
+export const HEADLESS_UNRESOLVED_FLOOR_LIFT_KINDS = [
+    'block',
+    'cabinet',
+    'cabinet-module',
+    'column',
+    'duct-terminal',
+    'hvac-equipment',
+    'spawn',
+    'stair',
+];
+const UNRESOLVED_FLOOR_LIFT = new Set(HEADLESS_UNRESOLVED_FLOOR_LIFT_KINDS);
+const CORE_KINDS = new Set(AnyNode.options.map(nodeKindOf));
+const FLOOR_LIFT_UNRESOLVED = 'floor-lift-unresolved-headless: the viewer lifts this onto the slab or ground under it through a node definition this runtime has not registered; the point is on the level plane';
+/**
+ * The node on a level that carries `node`'s floor lift (itself or the host it
+ * sits on), when that lift is resolved by a definition this runtime lacks: a
+ * built-in floor-placed kind or a plugin kind, unregistered.
+ */
+function unresolvedFloorLiftHost(node, nodes) {
+    const seen = new Set();
+    let current = node;
+    while (current && !seen.has(current.id)) {
+        seen.add(current.id);
+        const parent = current.parentId ? nodes[current.parentId] : undefined;
+        if (parent?.type === 'level') {
+            if (nodeRegistry.get(current.type))
+                return undefined;
+            const unresolved = UNRESOLVED_FLOOR_LIFT.has(current.type) ||
+                (!CORE_KINDS.has(current.type) && 'position' in current);
+            return unresolved ? current : undefined;
+        }
+        current = parent;
+    }
+    return undefined;
+}
+/**
+ * Why a node's point is not where its renderer draws it: kinds whose renderer
+ * derives the pose from data this resolver does not model, and floor lifts
+ * owned by definitions not registered here. The point is then the stored
+ * placement in its host's frame.
+ */
+function approximationReason(node, nodes) {
+    if (unresolvedFloorLiftHost(node, nodes))
+        return FLOOR_LIFT_UNRESOLVED;
+    const anchors = anchorSet(node);
+    if (anchors?.anchors.some((anchor) => resolveAnchor(anchor, nodes)?.fallback)) {
+        return 'anchor-fallback: an anchor follows a referenced node whose measurement features are not registered here (or the node is gone); its stored fallback point is used';
+    }
+    const parent = node.parentId ? nodes[node.parentId] : undefined;
+    switch (node.type) {
+        case 'downspout':
+            return 'rendered at its gutter outlet below the eave; the point is its gutter or host placement';
+        case 'gutter':
+            return 'rendered at the roof segment eave height, not its stored height';
+        case 'ridge-vent':
+            return 'rendered along its roof segment ridge; the point is its stored placement';
+        case 'fence':
+            return 'floor-lift-unresolved-headless: the fence renderer lifts it onto its host slab or the ground; the point is on the level plane';
+        case 'solar-panel':
+        case 'skylight':
+            return parent?.type === 'roof-segment'
+                ? 'roof-surface: the viewer seats it on the finished outer roof surface (deck and shingles); the point is on the structural roof surface'
+                : undefined;
+        case 'door':
+        case 'window':
+            if (node.roofSegmentId || (node.type === 'window' && node.dormerId)) {
+                return 'hosted on a roof-segment or dormer wall face; the point ignores the face frame';
+            }
+            return undefined;
+        case 'lean-to-extension':
+            return parent?.type === 'wall'
+                ? 'placed along its host wall centreline; the point uses a straight wall frame'
+                : undefined;
+        case 'item':
+            return node.asset.attachTo === 'wall-side'
+                ? 'rendered on the wall face (± half the wall thickness); the point is on the wall centreline'
+                : undefined;
+        default:
+            return undefined;
+    }
+}
+/**
+ * The node's reference point in its level's frame (or in world space when it
+ * has no level ancestor), or null for a container with no geometry of its own.
+ */
+function levelLocalPoint(node, nodes) {
+    if (node.type === 'wall') {
+        const { point } = getWallCurveFrameAt(node, 0.5);
+        return [point.x, nodeLevelFrame(node.id, nodes).position[1], point.y];
+    }
+    if (node.type === 'fence') {
+        // Arc or spline midpoint on the level plane; its lift is flagged.
+        const { point } = getFenceCenterlineFrameAt(node, 0.5);
+        return [point.x, 0, point.y];
+    }
+    if (node.type === 'stair-segment') {
+        const segmentFrame = stairSegmentFrame(node, nodes);
+        if (segmentFrame)
+            return segmentFrame.position;
+    }
+    const parent = node.parentId ? nodes[node.parentId] : undefined;
+    if (node.type === 'downspout' && node.gutterId && nodes[node.gutterId]?.type === 'gutter') {
+        return levelLocalPoint(nodes[node.gutterId], nodes);
+    }
+    if (node.type === 'chimney' && parent?.type === 'roof-segment') {
+        // The renderer ignores the stored Y and stands the chimney on the segment base.
+        const [x, , z] = node.position;
+        return transformPoint(nodeLevelFrame(parent.id, nodes), [x, 0, z]);
+    }
+    if ((node.type === 'solar-panel' || node.type === 'skylight') &&
+        parent?.type === 'roof-segment') {
+        // Both renderers ignore the stored Y and sit on the roof surface; the
+        // finished surface (deck and shingles) is the viewer's, so this is flagged.
+        const [x, , z] = node.position;
+        return transformPoint(nodeLevelFrame(parent.id, nodes), [
+            x,
+            getRoofSegmentSurfaceY(parent, x, z),
+            z,
+        ]);
+    }
+    const own = nodeLevelFrame(node.id, nodes);
+    const geometry = ownGeometryCentre(node, nodes);
+    if (geometry)
+        return transformPoint(own, geometry);
+    if (isVec3(node.position))
+        return own.position;
+    return null;
+}
+function nearestLevelId(node, nodes) {
+    const seen = new Set();
+    let current = node;
+    while (current && !seen.has(current.id)) {
+        if (current.type === 'level')
+            return current.id;
+        seen.add(current.id);
+        current = current.parentId ? nodes[current.parentId] : undefined;
+    }
+    return null;
+}
+function hostOf(id, nodes) {
+    const node = nodes[id];
+    if (node?.parentId)
+        return nodes[node.parentId];
+    // The default scene links site → building → level through `children` only.
+    return Object.values(nodes).find((candidate) => 'children' in candidate &&
+        Array.isArray(candidate.children) &&
+        candidate.children.some((child) => child === id || child?.id === id));
+}
+/** A level's frame in world space: its building's transform, then its stacked base Y. */
+function levelWorldFrame(levelId, nodes) {
+    const baseY = getLevelElevations(nodes).get(levelId)?.baseY ?? 0;
+    const host = hostOf(levelId, nodes);
+    const hostFrame = host ? nodeLevelFrame(host.id, nodes) : IDENTITY_FRAME;
+    return composeFrames(hostFrame, frame([0, baseY, 0]));
+}
+function childIdsOf(id, nodes) {
+    const node = nodes[id];
+    const ids = new Set();
+    if (node && 'children' in node && Array.isArray(node.children)) {
+        for (const child of node.children) {
+            const childId = typeof child === 'string' ? child : child?.id;
+            if (typeof childId === 'string')
+                ids.add(childId);
+        }
+    }
+    if (node?.type === 'unit')
+        for (const member of node.members)
+            ids.add(member);
+    for (const candidate of Object.values(nodes)) {
+        if (candidate.parentId === id)
+            ids.add(candidate.id);
+    }
+    return [...ids].filter((childId) => nodes[childId]);
+}
+export function resolveNodeWorldPoint(id, nodes) {
+    const linked = withParentIds(nodes);
+    const point = worldPoint(id, linked, 0);
+    if (!point)
+        return null;
+    const approximate = approximationReason(linked[id], linked);
+    return approximate ? { point, approximate } : { point };
+}
+/**
+ * `nodes` with every missing `parentId` filled from the parent's `children`
+ * array. The frame walk follows `parentId`, but scenes may link a subtree only
+ * through `children` (the default site → building → level assembly does), as
+ * SceneBridge's ancestry allows. Returns `nodes` itself when nothing is missing.
+ */
+function withParentIds(nodes) {
+    const parentOf = new Map();
+    for (const node of Object.values(nodes)) {
+        if (!('children' in node) || !Array.isArray(node.children))
+            continue;
+        for (const child of node.children) {
+            const childId = typeof child === 'string' ? child : child?.id;
+            if (typeof childId === 'string' && !parentOf.has(childId))
+                parentOf.set(childId, node.id);
+        }
+    }
+    let linked = null;
+    for (const node of Object.values(nodes)) {
+        const parentId = parentOf.get(node.id);
+        if (node.parentId || !parentId)
+            continue;
+        linked ??= { ...nodes };
+        linked[node.id] = { ...node, parentId };
+    }
+    return linked ?? nodes;
+}
+function worldPoint(id, nodes, depth) {
+    const node = nodes[id];
+    if (!node || depth > 32)
+        return null;
+    if (node.type === 'level') {
+        return transformPoint(levelWorldFrame(node.id, nodes), levelPlanCentre(node.id, nodes));
+    }
+    const levelId = nearestLevelId(node, nodes);
+    const toWorld = (point) => levelId ? transformPoint(levelWorldFrame(levelId, nodes), point) : point;
+    const local = levelLocalPoint(node, nodes);
+    if (local)
+        return toWorld(local);
+    const points = childIdsOf(id, nodes)
+        .map((childId) => worldPoint(childId, nodes, depth + 1))
+        .filter((p) => p !== null);
+    if (points.length > 0)
+        return boundsCentre(points);
+    return toWorld(nodeLevelFrame(node.id, nodes).position);
+}
+/**
+ * A level's plan centre on its base plane: the centre of its direct children's
+ * level-local points. Read from their stored geometry and own transform only,
+ * because resolving every wall's slab support makes a large level take seconds.
+ */
+function levelPlanCentre(levelId, nodes) {
+    const points = [];
+    for (const childId of childIdsOf(levelId, nodes)) {
+        const child = nodes[childId];
+        const transform = child;
+        const position = isVec3(transform.position) ? transform.position : [0, 0, 0];
+        const rotation = typeof transform.rotation === 'number'
+            ? [0, transform.rotation, 0]
+            : isVec3(transform.rotation)
+                ? transform.rotation
+                : [0, 0, 0];
+        const geometry = ownGeometryCentre(child, nodes);
+        if (geometry)
+            points.push(transformPoint(frame(position, rotation), geometry));
+        else if (isVec3(transform.position))
+            points.push(position);
+    }
+    const centre = boundsCentre(points);
+    return centre ? [centre[0], 0, centre[2]] : [0, 0, 0];
+}

package/dist/tools/normalize-schema-dialect.d.ts

@@ -1,3 +1,3 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 export declare function normalizeToolSchemaDialect(server: McpServer): void;
 //# sourceMappingURL=normalize-schema-dialect.d.ts.map

package/dist/tools/normalize-schema-dialect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"normalize-schema-dialect.d.ts","sourceRoot":"","sources":["../../src/tools/normalize-schema-dialect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAuBxE,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAWlE"}
+{"version":3,"file":"normalize-schema-dialect.d.ts","sourceRoot":"","sources":["../../src/tools/normalize-schema-dialect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmB,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAyC9E,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAWlE"}

package/dist/tools/normalize-schema-dialect.js

@@ -1,5 +1,22 @@
-import { ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 const DIALECT_2020_12 = 'https://json-schema.org/draft/2020-12/schema';
+/**
+ * A tuple of one item schema, `items: [A, A]` (draft-07), as 2020-12 writes an array of that length:
+ * `items: A` with minItems and maxItems. Clients reading 2020-12 refuse the list form, and Claude
+ * Code left out 9 tools over it (2026-10-03). The tools still validate with their own tuples.
+ */
+function untuple(record, key) {
+    const list = record[key];
+    if (!(Array.isArray(list) && list.length > 0))
+        return;
+    const first = JSON.stringify(list[0]);
+    if (!list.every((entry) => JSON.stringify(entry) === first))
+        return;
+    delete record.prefixItems;
+    delete record.additionalItems;
+    record.items = list[0];
+    record.minItems ??= list.length;
+    record.maxItems ??= list.length;
+}
 function retargetDialect(value) {
     if (Array.isArray(value)) {
         for (const item of value)
@@ -10,6 +27,8 @@ function retargetDialect(value) {
         const record = value;
         if (typeof record.$schema === 'string')
             record.$schema = DIALECT_2020_12;
+        untuple(record, 'items');
+        untuple(record, 'prefixItems');
         for (const key of Object.keys(record))
             retargetDialect(record[key]);
     }
@@ -20,8 +39,8 @@ export function normalizeToolSchemaDialect(server) {
     if (!original)
         return;
     server.server.removeRequestHandler('tools/list');
-    server.server.setRequestHandler(ListToolsRequestSchema, async (request, extra) => {
-        const result = (await original(request, extra));
+    server.server.setRequestHandler('tools/list', async (request, ctx) => {
+        const result = (await original(request, ctx));
         retargetDialect(result.tools);
         return result;
     });

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

@@ -0,0 +1,60 @@
+import { type NodeDeletionPlan, type NodeDeletionScene } from '@pascal-app/core';
+import { AnyNode, type AnyNodeId } from '@pascal-app/core/schema';
+import type { Patch } from '../bridge/scene-bridge.js';
+export type PatchRefusalCode = 'node_exists' | 'identity_change' | 'immutable_field' | 'invalid_parent' | 'invalid_update' | 'regenerated_default' | 'scripted_field' | 'unknown_field' | 'unknown_material' | 'field_required' | 'shadowed_field' | 'roof_level' | 'roof_level_holds_storey' | 'roof_level_on_top';
+/**
+ * A check apply_patch runs over the whole patch before applying it, registered by the module that
+ * owns what it protects, so a feature brings its own check (the honest-update check is the
+ * first). It may rewrite an update's data (the cleaned data is what is written) and
+ * refuses by throwing: a PatchRefusedError comes back as `{ code, patchIndex, id, message }`, an
+ * ProtocolError as it is. What it changed in the patch it says in notes, which the answer carries.
+ * Lower `order` runs first.
+ */
+export type PatchGuard = {
+    name: string;
+    order: number;
+    run(patches: Patch[], nodes: Readonly<Record<string, AnyNode>>): string[] | void;
+};
+/** Runs a guard on every apply_patch from now on; registering a guard again replaces it. */
+export declare function registerPatchGuard(guard: PatchGuard): void;
+/** Runs every guard in order; the notes are what the guards changed in the patch. */
+export declare function runPatchGuards(patches: Patch[], nodes: Readonly<Record<string, AnyNode>>): string[];
+/**
+ * A patch op refused because it would break node identity, the hierarchy or
+ * the node's schema. apply_patch returns it as a tool error whose text is
+ * JSON `{ code, patchIndex, id, message }`.
+ */
+export declare class PatchRefusedError extends Error {
+    readonly code: PatchRefusalCode;
+    readonly patchIndex: number;
+    readonly nodeId: string;
+    constructor(code: PatchRefusalCode, patchIndex: number, nodeId: string, detail: string);
+}
+/**
+ * Dry-runs a patch against the scene as each op leaves it and refuses:
+ * - a create whose id is already present (`node_exists`): a silent replace
+ *   orphans the old node's children;
+ * - an update that changes `id`, `type`, `object` or `children`
+ *   (`immutable_field`); restating the current value passes;
+ * - an update whose merged node has schema issues the node did not have
+ *   before (`invalid_update`); kinds without a schema in this runtime pass;
+ * - an update writing a material preset the catalog does not know
+ *   (`invalid_update`; a create is rejected like other invalid creates): it
+ *   would render as the default finish;
+ * - an update of what a node's script owns, its `source` or the size it
+ *   built (`scripted_field`): only a rebuild keeps them and the geometry in step;
+ * - any op on a node an earlier delete in the patch removed, or on a default
+ *   gutter or downspout that delete regenerates, and any update of the roof
+ *   segment holding them (`regenerated_default`).
+ *
+ * Deletes run through the bridge's own deletion preview (`planDeletion`; the
+ * local bridge uses core's store planner), one call per run of consecutive
+ * deletes as the bridge batches them, so cascades and wall merges are seen as
+ * that bridge applies them. A bridge without a preview gets a stricter rule:
+ * a create may not reuse any id present at the start of the patch.
+ * An update of a roof segment unsettles the default gutters its refresh may
+ * regenerate, as a delete does.
+ * Lives in the tool layer so every bridge behind `apply_patch` inherits it.
+ */
+export declare function assertPatchKeepsIdentity(patches: readonly Patch[], nodes: Readonly<Record<string, AnyNode>>, rootNodeIds: readonly AnyNodeId[], planDeletion?: (scene: NodeDeletionScene, ids: AnyNodeId[]) => NodeDeletionPlan): void;
+//# sourceMappingURL=patch-guards.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"patch-guards.d.ts","sourceRoot":"","sources":["../../src/tools/patch-guards.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EAKvB,MAAM,kBAAkB,CAAA;AAKzB,OAAO,EAAE,OAAO,EAAE,KAAK,SAAS,EAAyB,MAAM,yBAAyB,CAAA;AACxF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAA;AAEnD,MAAM,MAAM,gBAAgB,GACxB,aAAa,GACb,iBAAiB,GACjB,iBAAiB,GACjB,gBAAgB,GAChB,gBAAgB,GAChB,qBAAqB,GACrB,gBAAgB,GAEhB,eAAe,GACf,kBAAkB,GAClB,gBAAgB,GAChB,gBAAgB,GAEhB,YAAY,GACZ,yBAAyB,GACzB,mBAAmB,CAAA;AAEvB;;;;;;;GAOG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,GAAG,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,MAAM,EAAE,GAAG,IAAI,CAAA;CACjF,CAAA;AAID,4FAA4F;AAC5F,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,QAKnD;AAED,qFAAqF;AACrF,wBAAgB,cAAc,CAC5B,OAAO,EAAE,KAAK,EAAE,EAChB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,MAAM,EAAE,CAKV;AAED;;;;GAIG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;IAExC,QAAQ,CAAC,IAAI,EAAE,gBAAgB;IAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM;IAHzB,YACW,IAAI,EAAE,gBAAgB,EACtB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,EACvB,MAAM,EAAE,MAAM,EAIf;CACF;AAkDD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,SAAS,KAAK,EAAE,EACzB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,WAAW,EAAE,SAAS,SAAS,EAAE,EACjC,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,EAAE,GAAG,EAAE,SAAS,EAAE,KAAK,gBAAgB,GAC9E,IAAI,CA+KN"}