@pascal-app/core 1.0.0-beta.3 → 1.0.0-beta.5

package/dist/systems/wall/wall-mitering.js

@@ -52,6 +52,49 @@ function pointOnWallSegment(point, wall, tolerance = TOLERANCE) {
     const dist = Math.sqrt((point.x - projX) ** 2 + (point.y - projY) ** 2);
     return dist < tolerance;
 }
+// --- Uniform grid used to prefilter T-junction candidates --------------------
+// 2 m cells: small enough that a dense imported floor spreads across many
+// buckets, large enough that an ordinary room wall touches only a few.
+const JUNCTION_GRID_CELL = 2.0;
+// A wall whose AABB would touch more than this many cells (a very long diagonal)
+// is kept in a fallback list checked against every junction. Such walls are rare,
+// and a model made only of them is a model with very few walls — where the naive
+// scan was never the problem.
+const JUNCTION_GRID_MAX_CELLS_PER_WALL = 64;
+function cellKey(x, y) {
+    return `${Math.floor(x / JUNCTION_GRID_CELL)},${Math.floor(y / JUNCTION_GRID_CELL)}`;
+}
+function buildJunctionGrid(walls) {
+    const grid = new Map();
+    const oversized = [];
+    for (const wall of walls) {
+        // Pad by TOLERANCE so a point sitting exactly on the AABB edge still lands
+        // in a covered cell.
+        const minX = Math.min(wall.start[0], wall.end[0]) - TOLERANCE;
+        const maxX = Math.max(wall.start[0], wall.end[0]) + TOLERANCE;
+        const minY = Math.min(wall.start[1], wall.end[1]) - TOLERANCE;
+        const maxY = Math.max(wall.start[1], wall.end[1]) + TOLERANCE;
+        const cx0 = Math.floor(minX / JUNCTION_GRID_CELL);
+        const cx1 = Math.floor(maxX / JUNCTION_GRID_CELL);
+        const cy0 = Math.floor(minY / JUNCTION_GRID_CELL);
+        const cy1 = Math.floor(maxY / JUNCTION_GRID_CELL);
+        if ((cx1 - cx0 + 1) * (cy1 - cy0 + 1) > JUNCTION_GRID_MAX_CELLS_PER_WALL) {
+            oversized.push(wall);
+            continue;
+        }
+        for (let cx = cx0; cx <= cx1; cx++) {
+            for (let cy = cy0; cy <= cy1; cy++) {
+                const key = `${cx},${cy}`;
+                const bucket = grid.get(key);
+                if (bucket)
+                    bucket.push(wall);
+                else
+                    grid.set(key, [wall]);
+            }
+        }
+    }
+    return { grid, oversized };
+}
 function findJunctions(walls) {
     const junctions = new Map();
     // First pass: group walls by their endpoints
@@ -69,17 +112,47 @@ function findJunctions(walls) {
         }
         junctions.get(keyEnd)?.connectedWalls.push({ wall, endType: 'end' });
     }
-    // Second pass: detect T-junctions (walls passing through junction points)
+    // Second pass: detect T-junctions (walls passing through junction points).
+    //
+    // The naive form of this pass is `for each junction: for each wall` — O(J×N).
+    // On a real imported floor (1081 walls, 2047 endpoint keys) that is ~2.2M
+    // pointOnWallSegment calls and measured 584 ms per findJunctions() call, which
+    // WallSystem then repeats every frame while progressively rebuilding.
+    //
+    // A T-junction can only exist where the junction point lies ON the wall
+    // segment, so it must lie inside the wall's AABB. Bucketing walls by the grid
+    // cells their AABB covers therefore loses nothing: the cell containing the
+    // point is always one of the cells the wall was indexed into. With the input
+    // ordering restored below, the result matches the naive pass exactly; measured
+    // 11 ms on the same geometry.
+    const { grid, oversized } = buildJunctionGrid(walls);
+    const wallOrder = new Map(walls.map((wall, index) => [wall.id, index]));
     for (const [_key, junction] of junctions.entries()) {
-        for (const wall of walls) {
-            // Skip if wall already in this junction
-            if (junction.connectedWalls.some((cw) => cw.wall.id === wall.id))
+        const p = junction.meetingPoint;
+        const cellCandidates = grid.get(cellKey(p.x, p.y));
+        const passthrough = [];
+        for (const bucket of [cellCandidates, oversized]) {
+            if (!bucket || bucket.length === 0)
                 continue;
-            // Check if junction point lies on this wall's segment (not at endpoints)
-            if (pointOnWallSegment(junction.meetingPoint, wall)) {
-                junction.connectedWalls.push({ wall, endType: 'passthrough' });
+            for (const wall of bucket) {
+                // Skip if wall already in this junction
+                if (junction.connectedWalls.some((cw) => cw.wall.id === wall.id))
+                    continue;
+                // Check if junction point lies on this wall's segment (not at endpoints)
+                if (pointOnWallSegment(junction.meetingPoint, wall)) {
+                    passthrough.push(wall);
+                }
             }
         }
+        // Append in input order, not bucket order. Two collinear walls overlapping a
+        // junction tie on angle in `calculateJunctionIntersections`, so its stable
+        // sort leaves them in the order they were appended here — and an oversized
+        // wall would otherwise land after a shorter collinear neighbour it precedes
+        // in `walls`, picking the other wall's thickness for the miter.
+        passthrough.sort((a, b) => (wallOrder.get(a.id) ?? 0) - (wallOrder.get(b.id) ?? 0));
+        for (const wall of passthrough) {
+            junction.connectedWalls.push({ wall, endType: 'passthrough' });
+        }
     }
     // Filter to only junctions with 2+ walls
     const actualJunctions = new Map();
@@ -186,8 +259,14 @@ function calculateJunctionIntersections(junction, getThickness) {
             });
         }
     }
-    // Sort by outgoing angle
-    processedWalls.sort((a, b) => a.angle - b.angle);
+    // Sort by outgoing angle, then by wall ID so equal-angle walls produce the
+    // same pairing regardless of scene iteration order.
+    processedWalls.sort((a, b) => {
+        const angleOrder = a.angle - b.angle;
+        if (angleOrder !== 0)
+            return angleOrder;
+        return a.wallId < b.wallId ? -1 : a.wallId > b.wallId ? 1 : 0;
+    });
     const wallIntersections = new Map();
     const n = processedWalls.length;
     if (n < 2)

package/dist/systems/wall/wall-topology.d.ts

@@ -0,0 +1,53 @@
+import { type AnyNode, type AnyNodeId, type WallNode } from '../../schema';
+import type { WallPlanPoint } from './wall-move';
+export type WallTopologyChanges = {
+    create: Array<{
+        node: AnyNode;
+        parentId?: AnyNodeId;
+    }>;
+    update: Array<{
+        id: AnyNodeId;
+        data: Partial<AnyNode>;
+    }>;
+    delete: AnyNodeId[];
+};
+export type WallInsertionPlan = {
+    changes: WallTopologyChanges;
+    insertedWalls: WallNode[];
+    terminalWallId: WallNode['id'];
+    resolvedStart: WallPlanPoint;
+    resolvedEnd: WallPlanPoint;
+};
+export type WallTopologyRejection = {
+    ok: false;
+    reason: 'covered-existing-wall' | 'segment-too-short';
+};
+export type WallInsertionResult = {
+    ok: true;
+    plan: WallInsertionPlan;
+} | WallTopologyRejection;
+export type WallPointSplitPlan = {
+    changes: WallTopologyChanges;
+    point: WallPlanPoint;
+};
+export type WallPointSplitResult = {
+    ok: true;
+    plan: WallPointSplitPlan;
+} | {
+    ok: false;
+    reason: 'no-host';
+};
+export declare function planWallSplitAtPoint(nodes: Record<AnyNodeId, AnyNode>, args: {
+    levelId: AnyNodeId | null;
+    point: WallPlanPoint;
+    radius: number;
+    ignoreWallIds?: readonly string[];
+}): WallPointSplitResult;
+export declare function planWallInsertion(nodes: Record<AnyNodeId, AnyNode>, args: {
+    levelId: AnyNodeId;
+    start: WallPlanPoint;
+    end: WallPlanPoint;
+    joinRadius: number;
+    wallDefaults?: Partial<WallNode>;
+}): WallInsertionResult;
+//# sourceMappingURL=wall-topology.d.ts.map

package/dist/systems/wall/wall-topology.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-topology.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-topology.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAId,KAAK,QAAQ,EAGd,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAMhD,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;KAAE,CAAC,CAAA;IACtD,MAAM,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,CAAC,CAAA;IACxD,MAAM,EAAE,SAAS,EAAE,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,mBAAmB,CAAA;IAC5B,aAAa,EAAE,QAAQ,EAAE,CAAA;IACzB,cAAc,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;IAC9B,aAAa,EAAE,aAAa,CAAA;IAC5B,WAAW,EAAE,aAAa,CAAA;CAC3B,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,EAAE,EAAE,KAAK,CAAA;IACT,MAAM,EAAE,uBAAuB,GAAG,mBAAmB,CAAA;CACtD,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,iBAAiB,CAAA;CAAE,GAAG,qBAAqB,CAAA;AAE/F,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,EAAE,mBAAmB,CAAA;IAC5B,KAAK,EAAE,aAAa,CAAA;CACrB,CAAA;AAED,MAAM,MAAM,oBAAoB,GAC5B;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,kBAAkB,CAAA;CAAE,GACtC;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,SAAS,CAAA;CAAE,CAAA;AA8GpC,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,IAAI,EAAE;IACJ,OAAO,EAAE,SAAS,GAAG,IAAI,CAAA;IACzB,KAAK,EAAE,aAAa,CAAA;IACpB,MAAM,EAAE,MAAM,CAAA;IACd,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAClC,GACA,oBAAoB,CAqCtB;AA4OD,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,IAAI,EAAE;IACJ,OAAO,EAAE,SAAS,CAAA;IAClB,KAAK,EAAE,aAAa,CAAA;IACpB,GAAG,EAAE,aAAa,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,YAAY,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAA;CACjC,GACA,mBAAmB,CAiGrB"}

package/dist/systems/wall/wall-topology.js

@@ -0,0 +1,414 @@
+import { GROUND_SUPPORT_ID } from '../../hooks/spatial-grid/support-host-id';
+import { terrainSupportLift } from '../../lib/terrain-support';
+import { getScaledDimensions, WallNode as WallSchema, } from '../../schema';
+import { getWallArcData, getWallCurveFrameAt, getWallCurveLength, isCurvedWall } from './wall-curve';
+const WALL_MIN_LENGTH = 0.01;
+const WALL_SPLIT_ENDPOINT_EPSILON = 0.02;
+const WALL_INTERSECTION_EPSILON = 1e-6;
+function distanceSquared(a, b) {
+    const dx = a[0] - b[0];
+    const dz = a[1] - b[1];
+    return dx * dx + dz * dz;
+}
+function isSegmentLongEnough(start, end) {
+    return distanceSquared(start, end) >= WALL_MIN_LENGTH * WALL_MIN_LENGTH;
+}
+function wallSegmentsCoverSegment(start, end, walls) {
+    const dx = end[0] - start[0];
+    const dz = end[1] - start[1];
+    const lengthSquared = dx * dx + dz * dz;
+    if (lengthSquared <= WALL_INTERSECTION_EPSILON * WALL_INTERSECTION_EPSILON)
+        return false;
+    const length = Math.sqrt(lengthSquared);
+    const intervals = [];
+    for (const wall of walls) {
+        if (Math.abs(wall.curveOffset ?? 0) > WALL_INTERSECTION_EPSILON)
+            continue;
+        const startDistance = Math.abs((wall.start[0] - start[0]) * dz - (wall.start[1] - start[1]) * dx) / length;
+        const endDistance = Math.abs((wall.end[0] - start[0]) * dz - (wall.end[1] - start[1]) * dx) / length;
+        if (startDistance > WALL_INTERSECTION_EPSILON || endDistance > WALL_INTERSECTION_EPSILON) {
+            continue;
+        }
+        const wallStartT = ((wall.start[0] - start[0]) * dx + (wall.start[1] - start[1]) * dz) / lengthSquared;
+        const wallEndT = ((wall.end[0] - start[0]) * dx + (wall.end[1] - start[1]) * dz) / lengthSquared;
+        const intervalStart = Math.max(0, Math.min(wallStartT, wallEndT));
+        const intervalEnd = Math.min(1, Math.max(wallStartT, wallEndT));
+        if (intervalEnd >= intervalStart)
+            intervals.push([intervalStart, intervalEnd]);
+    }
+    intervals.sort((left, right) => left[0] - right[0]);
+    const parameterTolerance = WALL_INTERSECTION_EPSILON / length;
+    let coveredUntil = 0;
+    for (const [intervalStart, intervalEnd] of intervals) {
+        if (intervalStart > coveredUntil + parameterTolerance)
+            return false;
+        coveredUntil = Math.max(coveredUntil, intervalEnd);
+        if (coveredUntil >= 1 - parameterTolerance)
+            return true;
+    }
+    return false;
+}
+function projectPointOntoWallCenterline(point, wall) {
+    if (isCurvedWall(wall)) {
+        const arc = getWallArcData(wall);
+        if (!arc)
+            return null;
+        const pointAngle = Math.atan2(point[1] - arc.center.y, point[0] - arc.center.x);
+        let directedAngle = (pointAngle - arc.startAngle) * arc.direction;
+        while (directedAngle < 0)
+            directedAngle += Math.PI * 2;
+        const wallT = directedAngle / Math.abs(arc.delta);
+        if (wallT <= 0 || wallT >= 1)
+            return null;
+        return { point: wallPointAt(wall, wallT), wallT };
+    }
+    const dx = wall.end[0] - wall.start[0];
+    const dz = wall.end[1] - wall.start[1];
+    const lengthSquared = dx * dx + dz * dz;
+    if (lengthSquared < 1e-9)
+        return null;
+    const wallT = ((point[0] - wall.start[0]) * dx + (point[1] - wall.start[1]) * dz) / lengthSquared;
+    if (wallT <= 0 || wallT >= 1)
+        return null;
+    return {
+        point: [wall.start[0] + dx * wallT, wall.start[1] + dz * wallT],
+        wallT,
+    };
+}
+function nearestWallProjection(point, walls, radius, ignoreWallIds = new Set()) {
+    let best = null;
+    let bestDistance = Number.POSITIVE_INFINITY;
+    for (const wall of walls) {
+        if (ignoreWallIds.has(wall.id))
+            continue;
+        const projection = projectPointOntoWallCenterline(point, wall);
+        if (!projection)
+            continue;
+        const candidateDistance = distanceSquared(point, projection.point);
+        if (candidateDistance > radius * radius || candidateDistance >= bestDistance)
+            continue;
+        const corner = [wall.start, wall.end].find((candidate) => distanceSquared(projection.point, candidate) <=
+            WALL_SPLIT_ENDPOINT_EPSILON * WALL_SPLIT_ENDPOINT_EPSILON);
+        best = corner
+            ? { wall: null, point: [corner[0], corner[1]], wallT: projection.wallT }
+            : { wall, ...projection };
+        bestDistance = candidateDistance;
+    }
+    return best;
+}
+export function planWallSplitAtPoint(nodes, args) {
+    if (!args.levelId)
+        return { ok: false, reason: 'no-host' };
+    const walls = Object.values(nodes).filter((node) => node.type === 'wall' && node.parentId === args.levelId);
+    const projection = nearestWallProjection(args.point, walls, args.radius, new Set(args.ignoreWallIds ?? []));
+    if (!projection)
+        return { ok: false, reason: 'no-host' };
+    if (!projection.wall) {
+        return {
+            ok: true,
+            plan: { point: projection.point, changes: { create: [], update: [], delete: [] } },
+        };
+    }
+    const split = splitWall(projection.wall, [projection.wallT], nodes);
+    if (!split) {
+        return {
+            ok: true,
+            plan: { point: projection.point, changes: { create: [], update: [], delete: [] } },
+        };
+    }
+    return {
+        ok: true,
+        plan: {
+            point: projection.point,
+            changes: {
+                create: split.create.map((node) => ({ node, parentId: args.levelId ?? undefined })),
+                update: split.update,
+                delete: [projection.wall.id],
+            },
+        },
+    };
+}
+function straightSegmentIntersection(start, end, wall) {
+    const rx = end[0] - start[0];
+    const rz = end[1] - start[1];
+    const sx = wall.end[0] - wall.start[0];
+    const sz = wall.end[1] - wall.start[1];
+    const denominator = rx * sz - rz * sx;
+    if (Math.abs(denominator) < 1e-9)
+        return null;
+    const offsetX = wall.start[0] - start[0];
+    const offsetZ = wall.start[1] - start[1];
+    const draftT = (offsetX * sz - offsetZ * sx) / denominator;
+    const wallT = (offsetX * rz - offsetZ * rx) / denominator;
+    if (draftT <= 0 || draftT >= 1 || wallT < 0 || wallT > 1)
+        return null;
+    return {
+        wallId: wall.id,
+        point: [start[0] + draftT * rx, start[1] + draftT * rz],
+        draftT,
+        wallT,
+    };
+}
+function curvedSegmentIntersections(start, end, wall) {
+    const arc = getWallArcData(wall);
+    if (!arc)
+        return [];
+    const dx = end[0] - start[0];
+    const dz = end[1] - start[1];
+    const offsetX = start[0] - arc.center.x;
+    const offsetZ = start[1] - arc.center.y;
+    const a = dx * dx + dz * dz;
+    if (a < 1e-12)
+        return [];
+    const b = 2 * (offsetX * dx + offsetZ * dz);
+    const c = offsetX * offsetX + offsetZ * offsetZ - arc.radius * arc.radius;
+    const discriminant = b * b - 4 * a * c;
+    if (discriminant < -1e-9)
+        return [];
+    const root = Math.sqrt(Math.max(0, discriminant));
+    const results = [];
+    for (const rawDraftT of [(-b - root) / (2 * a), (-b + root) / (2 * a)]) {
+        if (rawDraftT < -1e-9 || rawDraftT > 1 + 1e-9)
+            continue;
+        const point = [start[0] + rawDraftT * dx, start[1] + rawDraftT * dz];
+        const angle = Math.atan2(point[1] - arc.center.y, point[0] - arc.center.x);
+        let directedAngle = (angle - arc.startAngle) * arc.direction;
+        while (directedAngle < 0)
+            directedAngle += Math.PI * 2;
+        const rawWallT = directedAngle / Math.abs(arc.delta);
+        if (rawWallT < -1e-9 || rawWallT > 1 + 1e-9)
+            continue;
+        if (results.some((candidate) => distanceSquared(candidate.point, point) < 1e-12))
+            continue;
+        results.push({
+            wallId: wall.id,
+            point,
+            draftT: Math.max(0, Math.min(1, rawDraftT)),
+            wallT: Math.max(0, Math.min(1, rawWallT)),
+        });
+    }
+    return results;
+}
+function joinCrossingAtNearbyWallEndpoint(crossing, walls) {
+    const wall = walls.find((candidate) => candidate.id === crossing.wallId);
+    if (!wall)
+        return crossing;
+    const endpointIndex = [wall.start, wall.end].findIndex((endpoint) => distanceSquared(crossing.point, endpoint) <=
+        WALL_SPLIT_ENDPOINT_EPSILON * WALL_SPLIT_ENDPOINT_EPSILON);
+    if (endpointIndex < 0)
+        return crossing;
+    const endpoint = endpointIndex === 0 ? wall.start : wall.end;
+    return { ...crossing, point: [endpoint[0], endpoint[1]], wallT: endpointIndex };
+}
+function wallLength(wall) {
+    return isCurvedWall(wall)
+        ? getWallCurveLength(wall)
+        : Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
+}
+function wallPointAt(wall, wallT) {
+    if (wallT <= WALL_INTERSECTION_EPSILON)
+        return wall.start;
+    if (wallT >= 1 - WALL_INTERSECTION_EPSILON)
+        return wall.end;
+    const frame = getWallCurveFrameAt(wall, wallT);
+    return [frame.point.x, frame.point.y];
+}
+function segmentCurveOffset(wall, startT, endT) {
+    const arc = getWallArcData(wall);
+    if (!arc)
+        return wall.curveOffset;
+    const angle = Math.abs(arc.delta) * (endT - startT);
+    return arc.direction * arc.radius * (1 - Math.cos(angle / 2));
+}
+function attachmentSpan(node) {
+    if (node.type === 'door') {
+        const door = node;
+        return {
+            min: door.position[0] - door.width / 2,
+            max: door.position[0] + door.width / 2,
+            center: door.position[0],
+        };
+    }
+    if (node.type === 'window') {
+        const window = node;
+        return {
+            min: window.position[0] - window.width / 2,
+            max: window.position[0] + window.width / 2,
+            center: window.position[0],
+        };
+    }
+    if (node.type === 'item') {
+        const item = node;
+        if (item.asset.attachTo !== 'wall' && item.asset.attachTo !== 'wall-side')
+            return null;
+        const [width] = getScaledDimensions(item);
+        return {
+            min: item.position[0] - width / 2,
+            max: item.position[0] + width / 2,
+            center: item.position[0],
+        };
+    }
+    return null;
+}
+function wallAttachments(wall, nodes) {
+    const ids = new Set((wall.children ?? []));
+    for (const node of Object.values(nodes)) {
+        if (node.parentId === wall.id ||
+            ('wallId' in node && typeof node.wallId === 'string' && node.wallId === wall.id)) {
+            ids.add(node.id);
+        }
+    }
+    return [...ids].flatMap((id) => {
+        const node = nodes[id];
+        return node ? [node] : [];
+    });
+}
+function remapAttachment(node, wall, nextLocalX) {
+    if (!(node.type === 'door' || node.type === 'window' || node.type === 'item'))
+        return null;
+    const nextLength = wallLength(wall);
+    const clampedX = Math.max(0, Math.min(nextLength, nextLocalX));
+    return {
+        parentId: wall.id,
+        wallId: wall.id,
+        position: [clampedX, node.position[1], node.position[2]],
+        ...(node.type === 'item' ? { wallT: nextLength > 1e-6 ? clampedX / nextLength : 0 } : {}),
+    };
+}
+function splitWall(wall, splitParameters, nodes) {
+    const parameters = [
+        0,
+        ...splitParameters
+            .filter((wallT) => wallT > WALL_INTERSECTION_EPSILON && wallT < 1 - WALL_INTERSECTION_EPSILON)
+            .sort((left, right) => left - right),
+        1,
+    ];
+    const { id: _id, parentId: _parentId, children: _children, ...properties } = wall;
+    const parsedSegments = parameters.slice(0, -1).map((startT, index) => {
+        const endT = parameters[index + 1];
+        return WallSchema.parse({
+            ...properties,
+            start: wallPointAt(wall, startT),
+            end: wallPointAt(wall, endT),
+            curveOffset: segmentCurveOffset(wall, startT, endT),
+            children: [],
+        });
+    });
+    const originalElevation = wall.supportSlabId === GROUND_SUPPORT_ID && wall.parentId
+        ? (terrainSupportLift(nodes, wall.parentId, wall.start[0], wall.start[1]) ?? 0) +
+            (wall.supportOffset ?? 0)
+        : null;
+    const segments = parsedSegments.map((segment) => {
+        if (originalElevation === null || !wall.parentId)
+            return segment;
+        const terrainElevation = terrainSupportLift(nodes, wall.parentId, segment.start[0], segment.start[1]) ?? 0;
+        const supportOffset = originalElevation - terrainElevation;
+        return {
+            ...segment,
+            supportOffset: Math.abs(supportOffset) > 1e-6 ? supportOffset : undefined,
+        };
+    });
+    const totalLength = wallLength(wall);
+    const segmentChildren = segments.map(() => []);
+    const updates = [];
+    for (const attachment of wallAttachments(wall, nodes)) {
+        const span = attachmentSpan(attachment);
+        if (!span)
+            return null;
+        const segmentIndex = parameters.slice(0, -1).findIndex((startT, index) => {
+            const endT = parameters[index + 1];
+            return span.min >= totalLength * startT - 1e-4 && span.max <= totalLength * endT + 1e-4;
+        });
+        if (segmentIndex < 0)
+            return null;
+        const segment = segments[segmentIndex];
+        const update = remapAttachment(attachment, segment, span.center - totalLength * parameters[segmentIndex]);
+        if (!update)
+            return null;
+        segmentChildren[segmentIndex].push(attachment.id);
+        updates.push({ id: attachment.id, data: update });
+    }
+    return {
+        create: segments.map((segment, index) => WallSchema.parse({ ...segment, children: segmentChildren[index] })),
+        update: updates,
+    };
+}
+export function planWallInsertion(nodes, args) {
+    const walls = Object.values(nodes).filter((node) => node.type === 'wall' && node.parentId === args.levelId);
+    const endProjection = nearestWallProjection(args.end, walls, args.joinRadius);
+    const startProjection = nearestWallProjection(args.start, walls, args.joinRadius);
+    const resolvedStart = startProjection?.point ?? args.start;
+    const resolvedEnd = endProjection?.point ?? args.end;
+    if (wallSegmentsCoverSegment(resolvedStart, resolvedEnd, walls)) {
+        return { ok: false, reason: 'covered-existing-wall' };
+    }
+    const crossings = walls
+        .flatMap((wall) => isCurvedWall(wall)
+        ? curvedSegmentIntersections(resolvedStart, resolvedEnd, wall)
+        : [straightSegmentIntersection(resolvedStart, resolvedEnd, wall)].filter((crossing) => crossing !== null))
+        .map((crossing) => joinCrossingAtNearbyWallEndpoint(crossing, walls))
+        .filter(({ draftT }) => draftT > WALL_INTERSECTION_EPSILON && draftT < 1 - WALL_INTERSECTION_EPSILON)
+        .sort((left, right) => left.draftT - right.draftT);
+    const splitPoints = crossings.reduce((points, crossing) => {
+        if (!points.some((point) => distanceSquared(point, crossing.point) <= 1e-12)) {
+            points.push(crossing.point);
+        }
+        return points;
+    }, []);
+    const vertices = [resolvedStart, ...splitPoints, resolvedEnd];
+    if (vertices.some((start, index) => index < vertices.length - 1 && !isSegmentLongEnough(start, vertices[index + 1]))) {
+        return { ok: false, reason: 'segment-too-short' };
+    }
+    const wallProperties = { ...(args.wallDefaults ?? {}) };
+    delete wallProperties.id;
+    delete wallProperties.parentId;
+    delete wallProperties.children;
+    const existingWallCount = Object.values(nodes).filter((node) => node.type === 'wall').length;
+    const insertedWalls = vertices.slice(0, -1).map((start, index) => WallSchema.parse({
+        ...wallProperties,
+        name: `Wall ${existingWallCount + index + 1}`,
+        start,
+        end: vertices[index + 1],
+    }));
+    const splitWalls = new Map();
+    const addSplitParameter = (wallId, wallT) => {
+        const parameters = splitWalls.get(wallId) ?? [];
+        if (!parameters.some((candidate) => Math.abs(candidate - wallT) <= WALL_INTERSECTION_EPSILON)) {
+            parameters.push(wallT);
+        }
+        splitWalls.set(wallId, parameters);
+    };
+    for (const projection of [startProjection, endProjection]) {
+        if (projection?.wall) {
+            addSplitParameter(projection.wall.id, projection.wallT);
+        }
+    }
+    for (const crossing of crossings) {
+        if (crossing.wallT <= WALL_INTERSECTION_EPSILON ||
+            crossing.wallT >= 1 - WALL_INTERSECTION_EPSILON) {
+            continue;
+        }
+        addSplitParameter(crossing.wallId, crossing.wallT);
+    }
+    const splitPlans = [...splitWalls].flatMap(([wallId, parameters]) => {
+        const wall = walls.find((candidate) => candidate.id === wallId);
+        const split = wall ? splitWall(wall, parameters, nodes) : null;
+        return split ? [[wallId, split]] : [];
+    });
+    const replacementWalls = splitPlans.flatMap(([, split]) => split.create);
+    const plan = {
+        changes: {
+            create: [...replacementWalls, ...insertedWalls].map((node) => ({
+                node,
+                parentId: args.levelId,
+            })),
+            update: splitPlans.flatMap(([, split]) => split.update),
+            delete: splitPlans.map(([wallId]) => wallId),
+        },
+        insertedWalls,
+        terminalWallId: insertedWalls.at(-1).id,
+        resolvedStart,
+        resolvedEnd,
+    };
+    return { ok: true, plan };
+}

package/dist/utils/clone-scene-graph.d.ts

@@ -1,9 +1,11 @@
 import type { AnyNode, AnyNodeId } from '../schema';
 import type { Collection, CollectionId } from '../schema/collections';
+import type { SceneMaterial, SceneMaterialId } from '../schema/scene-material';
 export type SceneGraph = {
     nodes: Record<AnyNodeId, AnyNode>;
     rootNodeIds: AnyNodeId[];
     collections?: Record<CollectionId, Collection>;
+    materials?: Record<SceneMaterialId, SceneMaterial>;
     installedPlugins?: string[];
 };
 /**

package/dist/utils/clone-scene-graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clone-scene-graph.d.ts","sourceRoot":"","sources":["../../src/utils/clone-scene-graph.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAEnD,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAErE,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,WAAW,EAAE,SAAS,EAAE,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC,YAAY,EAAE,UAAU,CAAC,CAAA;IAC9C,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC5B,CAAA;AAUD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,CAuIlE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,SAAS,GACjB;IAAE,WAAW,EAAE,OAAO,EAAE,CAAC;IAAC,UAAU,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAsG/E;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB,CAAA;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,UAAU,EACtB,OAAO,GAAE,qBAA0B,GAClC,UAAU,CAqEZ"}
+{"version":3,"file":"clone-scene-graph.d.ts","sourceRoot":"","sources":["../../src/utils/clone-scene-graph.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAEnD,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAE9E,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,WAAW,EAAE,SAAS,EAAE,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC,YAAY,EAAE,UAAU,CAAC,CAAA;IAC9C,SAAS,CAAC,EAAE,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,CAAA;IAClD,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC5B,CAAA;AAUD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,CA6IlE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,SAAS,GACjB;IAAE,WAAW,EAAE,OAAO,EAAE,CAAC;IAAC,UAAU,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAsG/E;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB,CAAA;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,UAAU,EACtB,OAAO,GAAE,qBAA0B,GAClC,UAAU,CA0EZ"}

package/dist/utils/clone-scene-graph.js

@@ -18,7 +18,7 @@ function extractIdPrefix(id) {
  * - Multi-scene in-memory scenarios
  */
 export function cloneSceneGraph(sceneGraph) {
-    const { nodes, rootNodeIds, collections, installedPlugins } = sceneGraph;
+    const { nodes, rootNodeIds, collections, materials, installedPlugins } = sceneGraph;
     // Build ID mapping: old ID -> new ID
     const idMap = new Map();
     // Pass 1: Generate new IDs for all nodes
@@ -127,6 +127,12 @@ export function cloneSceneGraph(sceneGraph) {
         nodes: clonedNodes,
         rootNodeIds: clonedRootNodeIds,
         ...(clonedCollections && { collections: clonedCollections }),
+        // Material ids are deliberately *not* remapped. Nodes point at these
+        // through `slots` values shaped `scene:mat_…` — opaque strings that the
+        // node remapping above copies verbatim, since `idMap` only covers node
+        // ids. Minting fresh material ids here would orphan every one of those
+        // refs and the clone would render with default materials.
+        ...(materials && { materials: structuredClone(materials) }),
         ...(installedPlugins && { installedPlugins: [...installedPlugins] }),
     };
 }
@@ -247,7 +253,7 @@ export function forkSceneGraph(sceneGraph, options = {}) {
     if (options.preserveScans) {
         return cloneSceneGraph(sceneGraph);
     }
-    const { nodes, rootNodeIds, collections, installedPlugins } = sceneGraph;
+    const { nodes, rootNodeIds, collections, materials, installedPlugins } = sceneGraph;
     // First, identify scan and guide node IDs to exclude (user-uploaded imagery)
     const excludedNodeIds = new Set();
     for (const [nodeId, node] of Object.entries(nodes)) {
@@ -299,6 +305,11 @@ export function forkSceneGraph(sceneGraph, options = {}) {
         nodes: filteredNodes,
         rootNodeIds: filteredRootNodeIds,
         ...(filteredCollections && { collections: filteredCollections }),
+        // Kept whole rather than filtered to the surviving nodes: a palette entry
+        // is authored content in its own right, and dropping the scan node that
+        // happened to be its only user would silently delete a material the fork's
+        // owner can still pick from the palette.
+        ...(materials && { materials }),
         ...(installedPlugins && { installedPlugins }),
     });
 }

package/dist/utils/heal-scene-graph.d.ts

@@ -9,6 +9,11 @@ export interface HealSceneResult {
      * a different node (stale reparent leftovers), plus same-array duplicates.
      */
     strippedStaleChildRefs: number;
+    /**
+     * Ids of nodes whose null `parentId` was repaired to the one parent that
+     * still claims them via `children`.
+     */
+    repairedParentLinkNodeIds: string[];
 }
 /**
  * Returns a healed copy of a `nodes` map. Pure — does not mutate `input`.

package/dist/utils/heal-scene-graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"heal-scene-graph.d.ts","sourceRoot":"","sources":["../../src/utils/heal-scene-graph.ts"],"names":[],"mappings":"AAqBA,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,kDAAkD;IAClD,cAAc,EAAE,MAAM,EAAE,CAAA;IACxB,sFAAsF;IACtF,iBAAiB,EAAE,MAAM,CAAA;IACzB;;;OAGG;IACH,sBAAsB,EAAE,MAAM,CAAA;CAC/B;AAgBD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,eAAe,CA2E9E"}
+{"version":3,"file":"heal-scene-graph.d.ts","sourceRoot":"","sources":["../../src/utils/heal-scene-graph.ts"],"names":[],"mappings":"AA0BA,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,kDAAkD;IAClD,cAAc,EAAE,MAAM,EAAE,CAAA;IACxB,sFAAsF;IACtF,iBAAiB,EAAE,MAAM,CAAA;IACzB;;;OAGG;IACH,sBAAsB,EAAE,MAAM,CAAA;IAC9B;;;OAGG;IACH,yBAAyB,EAAE,MAAM,EAAE,CAAA;CACpC;AAgBD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,eAAe,CAiH9E"}