@pascal-app/core 1.0.1 → 1.0.3

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

@@ -0,0 +1,240 @@
+import { getWallEffectiveHeightForNodes } from '../../hooks/spatial-grid/spatial-grid-manager.js';
+import { getEffectiveWallSurfaceMaterial, getWallSurfaceMaterialSignature, } from '../../schema/index.js';
+function pointsEqual(a, b, tolerance = 1e-6) {
+    const dx = a[0] - b[0];
+    const dz = a[1] - b[1];
+    return dx * dx + dz * dz <= tolerance * tolerance;
+}
+function wallLength(wall) {
+    return Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
+}
+export function getWallEndpointAtPoint(wall, point) {
+    if (pointsEqual(wall.start, point))
+        return 'start';
+    if (pointsEqual(wall.end, point))
+        return 'end';
+    return null;
+}
+function getWallFreeEndpoint(wall, sharedPoint) {
+    return pointsEqual(wall.start, sharedPoint) ? wall.end : wall.start;
+}
+/**
+ * The first thing two walls disagree on (for the merge's explanation), or null.
+ * The delete heal is strict: room sides must match, and a wall following the
+ * storey never joins one with an explicit height. An explicit merge compares
+ * what is visible instead — `heightOf` resolves each wall's actual height — and
+ * leaves the sides to room detection, which reclassifies the merged wall.
+ */
+export function wallStyleMismatch(a, b, options) {
+    if ((a.parentId ?? null) !== (b.parentId ?? null))
+        return 'floor';
+    if (Math.abs((a.curveOffset ?? 0) - (b.curveOffset ?? 0)) > 1e-6)
+        return 'curve';
+    if (Math.abs((a.thickness ?? 0.2) - (b.thickness ?? 0.2)) > 1e-6)
+        return 'thickness';
+    const { heightOf } = options;
+    if (heightOf
+        ? Math.abs(heightOf(a) - heightOf(b)) > 1e-6
+        : (a.height == null) !== (b.height == null) ||
+            Math.abs((a.height ?? 0) - (b.height ?? 0)) > 1e-6)
+        return 'height';
+    for (const side of ['interior', 'exterior']) {
+        if (getWallSurfaceMaterialSignature(getEffectiveWallSurfaceMaterial(a, side)) !==
+            getWallSurfaceMaterialSignature(getEffectiveWallSurfaceMaterial(b, side)))
+            return `${side} finish`;
+    }
+    if (options.sides && (a.frontSide !== b.frontSide || a.backSide !== b.backSide))
+        return 'room sides';
+    if (a.visible !== b.visible)
+        return 'visibility';
+    return null;
+}
+export function areWallStylesCompatible(a, b) {
+    return wallStyleMismatch(a, b, { sides: true }) === null;
+}
+export function areWallsCollinearAcrossPoint(a, b, sharedPoint) {
+    const freeA = getWallFreeEndpoint(a, sharedPoint);
+    const freeB = getWallFreeEndpoint(b, sharedPoint);
+    const ax = freeA[0] - sharedPoint[0];
+    const az = freeA[1] - sharedPoint[1];
+    const bx = freeB[0] - sharedPoint[0];
+    const bz = freeB[1] - sharedPoint[1];
+    const lenA = Math.hypot(ax, az);
+    const lenB = Math.hypot(bx, bz);
+    if (lenA < 1e-6 || lenB < 1e-6)
+        return false;
+    const cross = (ax * bz - az * bx) / (lenA * lenB);
+    const dot = (ax * bx + az * bz) / (lenA * lenB);
+    return Math.abs(cross) <= 1e-4 && dot < -0.999;
+}
+export function resolveMergedWallEndpoints(primary, secondary, sharedPoint) {
+    const primaryEndpoint = getWallEndpointAtPoint(primary, sharedPoint);
+    const secondaryEndpoint = getWallEndpointAtPoint(secondary, sharedPoint);
+    if (primaryEndpoint === 'end' && secondaryEndpoint === 'start') {
+        return { start: primary.start, end: secondary.end };
+    }
+    if (primaryEndpoint === 'start' && secondaryEndpoint === 'end') {
+        return { start: secondary.start, end: primary.end };
+    }
+    // The kept wall never turns around: its sides, finishes and hosted faces stay
+    // where they are. Meeting start-to-start or end-to-end, the absorbed wall is
+    // the one read backwards.
+    if (primaryEndpoint === 'start' && secondaryEndpoint === 'start') {
+        return { start: secondary.end, end: primary.end };
+    }
+    return { start: primary.start, end: secondary.start };
+}
+/**
+ * Hosted nodes live in the wall's local frame (+X along it, +Z its front, yaw
+ * 0 front / π back). A wall read backwards turns that frame by 180° about Y,
+ * so the face and the yaw swap and the caller mirrors depth. Hinges, handles
+ * and swing hang off the node's own yaw (the plan symbol flips them from it),
+ * so they stay as stored.
+ */
+function reversedWallChildPatch(child) {
+    const patch = {};
+    if ('side' in child && (child.side === 'front' || child.side === 'back')) {
+        patch.side = child.side === 'front' ? 'back' : 'front';
+    }
+    if ('rotation' in child && Array.isArray(child.rotation)) {
+        const yaw = child.rotation[1] + Math.PI;
+        patch.rotation = [
+            child.rotation[0],
+            Math.atan2(Math.sin(yaw), Math.cos(yaw)),
+            child.rotation[2],
+        ];
+    }
+    return patch;
+}
+export function buildMergedWallAttachmentUpdates(primary, secondary, mergedWallId, mergedStart, mergedEnd, nodes) {
+    const mergedLength = Math.max(Math.hypot(mergedEnd[0] - mergedStart[0], mergedEnd[1] - mergedStart[1]), 1e-6);
+    const tangentX = (mergedEnd[0] - mergedStart[0]) / mergedLength;
+    const tangentZ = (mergedEnd[1] - mergedStart[1]) / mergedLength;
+    const updates = [];
+    const wallChildren = [...(primary.children ?? []), ...(secondary.children ?? [])];
+    for (const childId of wallChildren) {
+        const child = nodes[childId];
+        if (!child)
+            continue;
+        // Every child moves to the kept wall: deleting the absorbed wall would
+        // otherwise take a child left on it along. Only positioned ones re-place.
+        const rehost = { parentId: mergedWallId, wallId: mergedWallId };
+        if (!('position' in child && Array.isArray(child.position))) {
+            updates.push({ id: childId, data: rehost });
+            continue;
+        }
+        const sourceWall = child.parentId === secondary.id ? secondary : primary;
+        const sourceLength = Math.max(wallLength(sourceWall), 1e-6);
+        const reversed = (sourceWall.end[0] - sourceWall.start[0]) * tangentX +
+            (sourceWall.end[1] - sourceWall.start[1]) * tangentZ <
+            0;
+        const mirrored = reversed ? reversedWallChildPatch(child) : {};
+        const localX = typeof child.position[0] === 'number' ? child.position[0] : 0;
+        const worldX = sourceWall.start[0] + ((sourceWall.end[0] - sourceWall.start[0]) * localX) / sourceLength;
+        const worldZ = sourceWall.start[1] + ((sourceWall.end[1] - sourceWall.start[1]) * localX) / sourceLength;
+        const nextLocalX = Math.max(0, Math.min(mergedLength, (worldX - mergedStart[0]) * tangentX + (worldZ - mergedStart[1]) * tangentZ));
+        updates.push({
+            id: childId,
+            data: {
+                ...rehost,
+                ...mirrored,
+                position: [
+                    nextLocalX,
+                    child.position[1],
+                    reversed ? -child.position[2] : child.position[2],
+                ],
+                ...('wallT' in child ? { wallT: nextLocalX / mergedLength } : {}),
+            },
+        });
+    }
+    return updates;
+}
+/**
+ * Merges a straight run of adjoining walls into one — the inverse of a split.
+ * Every joint must hold exactly these walls (a T or a cross stays split), and
+ * neighbours must continue in line and look alike (`wallStyleMismatch`: same
+ * thickness, visible height and finish). The wall with the most attachments
+ * keeps its id and height mode; openings and wall items keep their world
+ * position on it.
+ */
+export function planWallMerge(nodes, wallIds) {
+    const walls = [...new Set(wallIds)]
+        .map((id) => nodes[id])
+        .filter((node) => node?.type === 'wall');
+    if (walls.length < 2 || walls.length !== new Set(wallIds).size)
+        throw Error('Select two or more walls to merge.');
+    if (walls.some((wall) => (wall.curveOffset ?? 0) !== 0))
+        throw Error('Only straight walls can be merged.');
+    const levelId = walls[0].parentId ?? null;
+    if (walls.some((wall) => (wall.parentId ?? null) !== levelId))
+        throw Error('Merge walls on the same floor.');
+    const virtual = { ...nodes };
+    const [primary, ...rest] = [...walls].sort((a, b) => (b.children?.length ?? 0) - (a.children?.length ?? 0) || a.id.localeCompare(b.id));
+    let merged = primary;
+    let remaining = rest;
+    while (remaining.length > 0) {
+        let next;
+        let joint;
+        for (const wall of remaining) {
+            joint = [merged.start, merged.end].find((end) => getWallEndpointAtPoint(wall, end) !== null);
+            if (joint) {
+                next = wall;
+                break;
+            }
+        }
+        if (!(next && joint))
+            throw Error('Merge walls that touch end to end.');
+        const atJoint = Object.values(virtual).filter((node) => node?.type === 'wall' &&
+            (node.parentId ?? null) === levelId &&
+            getWallEndpointAtPoint(node, joint) !== null);
+        if (atJoint.length !== 2)
+            throw Error('Another wall meets this joint, so merging would disconnect it.');
+        if (!areWallsCollinearAcrossPoint(merged, next, joint))
+            throw Error('Merge walls that continue in a straight line.');
+        const mismatch = wallStyleMismatch(merged, next, {
+            sides: false,
+            heightOf: (wall) => getWallEffectiveHeightForNodes(wall, virtual),
+        });
+        if (mismatch)
+            throw Error(`These walls have a different ${mismatch}.`);
+        const { start, end } = resolveMergedWallEndpoints(merged, next, joint);
+        for (const update of buildMergedWallAttachmentUpdates(merged, next, merged.id, start, end, virtual)) {
+            virtual[update.id] = { ...virtual[update.id], ...update.data };
+        }
+        merged = {
+            ...merged,
+            start,
+            end,
+            // Ids without a node are dropped rather than carried onto the kept wall.
+            children: [
+                ...new Set([
+                    ...(merged.children ?? []),
+                    ...(next.children ?? []).filter((id) => virtual[id]),
+                ]),
+            ],
+        };
+        virtual[merged.id] = merged;
+        delete virtual[next.id];
+        for (const node of Object.values(virtual)) {
+            if (node?.type !== 'zone' || !node.boundaryWallIds?.includes(next.id))
+                continue;
+            virtual[node.id] = {
+                ...node,
+                boundaryWallIds: [
+                    ...new Set(node.boundaryWallIds.map((id) => (id === next.id ? merged.id : id))),
+                ],
+            };
+        }
+        remaining = remaining.filter((wall) => wall !== next);
+    }
+    return {
+        changes: {
+            create: [],
+            update: Object.values(virtual)
+                .filter((node) => nodes[node.id] && node !== nodes[node.id])
+                .map((node) => ({ id: node.id, data: node })),
+            delete: walls.filter((wall) => !virtual[wall.id]).map((wall) => wall.id),
+        },
+        wallId: merged.id,
+    };
+}

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

@@ -0,0 +1,28 @@
+import type { AnyNode, AnyNodeId, WallNode } from '../../schema/index.js';
+import type { WallPlanPoint } from './wall-move.js';
+import { type WallTopologyChanges } from './wall-topology.js';
+export declare function wallRectangleCorners(a: WallPlanPoint, b: WallPlanPoint): WallPlanPoint[];
+/** Plan against a scratch graph so four sides commit atomically, including junction splits. */
+export declare function planWallRectangle(nodes: Record<AnyNodeId, AnyNode>, args: {
+    levelId: AnyNodeId;
+    start: WallPlanPoint;
+    end: WallPlanPoint;
+    wallDefaults?: Partial<WallNode>;
+}): {
+    changes: WallTopologyChanges;
+    walls: WallNode[];
+};
+/** Explicit split keeps the first wall's identity and reuses the junction planner's host migration. */
+export declare function planWallDivision(nodes: Record<AnyNodeId, AnyNode>, wallId: WallNode['id'], distance: number): {
+    changes: WallTopologyChanges;
+    point: WallPlanPoint;
+};
+/**
+ * Several cuts as one edit. Cutting farthest first keeps the first wall's
+ * identity at every step, so the nearer distances stay valid on it.
+ */
+export declare function planWallDivisions(nodes: Record<AnyNodeId, AnyNode>, wallId: WallNode['id'], distances: readonly number[]): {
+    changes: WallTopologyChanges;
+    points: WallPlanPoint[];
+};
+//# sourceMappingURL=wall-operations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wall-operations.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-operations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAEhE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAChD,OAAO,EAIL,KAAK,mBAAmB,EACzB,MAAM,iBAAiB,CAAA;AAExB,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,GAAG,aAAa,EAAE,CAiBxF;AAED,+FAA+F;AAC/F,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,YAAY,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAA;CACjC,GACA;IAAE,OAAO,EAAE,mBAAmB,CAAC;IAAC,KAAK,EAAE,QAAQ,EAAE,CAAA;CAAE,CAyCrD;AAED,uGAAuG;AACvG,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,EACtB,QAAQ,EAAE,MAAM;;WAsD+B,aAAa;EAC7D;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,EACtB,SAAS,EAAE,SAAS,MAAM,EAAE,GAC3B;IAAE,OAAO,EAAE,mBAAmB,CAAC;IAAC,MAAM,EAAE,aAAa,EAAE,CAAA;CAAE,CAyB3D"}

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

@@ -0,0 +1,145 @@
+import { getWallCurveFrameAt, getWallCurveLength } from './wall-curve.js';
+import { planWallInsertion, planWallSplitAtPoint, uncoveredWallSegments, } from './wall-topology.js';
+export function wallRectangleCorners(a, b) {
+    if (![...a, ...b].every(Number.isFinite) ||
+        Math.abs(a[0] - b[0]) < 0.05 ||
+        Math.abs(a[1] - b[1]) < 0.05)
+        return [];
+    const x = Math.min(a[0], b[0]);
+    const z = Math.min(a[1], b[1]);
+    const right = Math.max(a[0], b[0]);
+    const top = Math.max(a[1], b[1]);
+    return [
+        [x, z],
+        [right, z],
+        [right, top],
+        [x, top],
+    ];
+}
+/** Plan against a scratch graph so four sides commit atomically, including junction splits. */
+export function planWallRectangle(nodes, args) {
+    if (nodes[args.levelId]?.type !== 'level')
+        throw Error('Select an editable floor.');
+    const corners = wallRectangleCorners(args.start, args.end);
+    if (!corners.length)
+        throw Error('Both rectangle dimensions must be at least 5 cm.');
+    const virtual = { ...nodes };
+    const added = new Set();
+    for (let i = 0; i < 4; i++) {
+        // A side that runs along existing walls only adds what they don't cover,
+        // so snapping to a wall and dragging past its end reuses it rather than
+        // doubling it.
+        const levelWalls = Object.values(virtual).filter((node) => node.type === 'wall' && node.parentId === args.levelId);
+        for (const [start, end] of uncoveredWallSegments(corners[i], corners[(i + 1) % 4], levelWalls)) {
+            const result = planWallInsertion(virtual, { ...args, start, end, joinRadius: 0 });
+            if (!result.ok)
+                throw Error('The rectangle cannot be drawn here.');
+            for (const id of result.plan.changes.delete)
+                delete virtual[id];
+            for (const { node, parentId } of result.plan.changes.create) {
+                virtual[node.id] = { ...node, ...(parentId ? { parentId } : {}) };
+            }
+            for (const wall of result.plan.insertedWalls)
+                added.add(wall.id);
+            for (const { id, data } of result.plan.changes.update) {
+                if (virtual[id])
+                    virtual[id] = { ...virtual[id], ...data };
+            }
+        }
+    }
+    const created = Object.values(virtual).filter((n) => !nodes[n.id]);
+    return {
+        changes: {
+            create: created.map((node) => ({ node, parentId: node.parentId })),
+            update: Object.values(virtual)
+                .filter((n) => nodes[n.id] && n !== nodes[n.id])
+                .map((n) => ({ id: n.id, data: n })),
+            delete: Object.keys(nodes).filter((id) => !virtual[id]),
+        },
+        walls: created.filter((n) => n.type === 'wall' && added.has(n.id)),
+    };
+}
+/** Explicit split keeps the first wall's identity and reuses the junction planner's host migration. */
+export function planWallDivision(nodes, wallId, distance) {
+    const wall = nodes[wallId];
+    if (wall?.type !== 'wall' || !wall.parentId)
+        throw Error('Select a wall.');
+    const length = getWallCurveLength(wall);
+    if (!Number.isFinite(distance) || distance < 0.05 || distance > length - 0.05)
+        throw Error('Keep at least 5 cm on each side of the split.');
+    const point = getWallCurveFrameAt(wall, distance / length).point;
+    const result = planWallSplitAtPoint(nodes, {
+        levelId: wall.parentId,
+        point: [point.x, point.y],
+        radius: 0.001,
+        ignoreWallIds: Object.values(nodes)
+            .filter((n) => n.type === 'wall' && n.id !== wallId)
+            .map((n) => n.id),
+    });
+    if (!result.ok || result.plan.changes.create.length !== 2)
+        throw Error('Move the split away from doors, windows and mounted objects.');
+    const [first, second] = result.plan.changes.create;
+    const firstId = first.node.id;
+    const changes = {
+        create: [second],
+        delete: [],
+        update: [
+            {
+                id: wallId,
+                data: { ...first.node, id: wallId, parentId: wall.parentId },
+            },
+            ...result.plan.changes.update.map((op) => ({
+                ...op,
+                data: {
+                    ...op.data,
+                    ...(op.data.parentId === firstId ? { parentId: wallId } : {}),
+                    ...('wallId' in op.data && op.data.wallId === firstId ? { wallId } : {}),
+                },
+            })),
+        ],
+    };
+    for (const node of Object.values(nodes)) {
+        if (node.type === 'zone' &&
+            node.parentId === wall.parentId &&
+            node.boundaryWallIds?.includes(wallId)) {
+            changes.update.push({
+                id: node.id,
+                data: {
+                    boundaryWallIds: node.boundaryWallIds.flatMap((id) => id === wallId ? [wallId, second.node.id] : [id]),
+                },
+            });
+        }
+    }
+    return { changes, point: [point.x, point.y] };
+}
+/**
+ * Several cuts as one edit. Cutting farthest first keeps the first wall's
+ * identity at every step, so the nearer distances stay valid on it.
+ */
+export function planWallDivisions(nodes, wallId, distances) {
+    const virtual = { ...nodes };
+    const points = [];
+    for (const distance of [...distances].sort((a, b) => b - a)) {
+        const plan = planWallDivision(virtual, wallId, distance);
+        for (const { node, parentId } of plan.changes.create) {
+            virtual[node.id] = { ...node, ...(parentId ? { parentId } : {}) };
+        }
+        for (const { id, data } of plan.changes.update) {
+            if (virtual[id])
+                virtual[id] = { ...virtual[id], ...data };
+        }
+        points.push(plan.point);
+    }
+    return {
+        changes: {
+            create: Object.values(virtual)
+                .filter((n) => !nodes[n.id])
+                .map((node) => ({ node, parentId: node.parentId })),
+            update: Object.values(virtual)
+                .filter((n) => nodes[n.id] && n !== nodes[n.id])
+                .map((n) => ({ id: n.id, data: n })),
+            delete: [],
+        },
+        points: points.reverse(),
+    };
+}

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

@@ -37,6 +37,13 @@ export type WallPointSplitResult = {
     ok: false;
     reason: 'no-host';
 };
+/**
+ * The parts of `start→end` that no straight wall already runs along, in order.
+ * A side drawn along an existing wall and past its end yields the overhang
+ * only, so the existing wall is reused instead of doubled. Gaps too short to
+ * be a wall are treated as covered.
+ */
+export declare function uncoveredWallSegments(start: WallPlanPoint, end: WallPlanPoint, walls: WallNode[]): Array<[WallPlanPoint, WallPlanPoint]>;
 export declare function planWallSplitAtPoint(nodes: Record<AnyNodeId, AnyNode>, args: {
     levelId: AnyNodeId | null;
     point: WallPlanPoint;

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

@@ -1 +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"}
+{"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;AAkEpC;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,aAAa,EACpB,GAAG,EAAE,aAAa,EAClB,KAAK,EAAE,QAAQ,EAAE,GAChB,KAAK,CAAC,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC,CAiBvC;AAwDD,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,CAoHrB"}

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

@@ -13,12 +13,13 @@ function distanceSquared(a, b) {
 function isSegmentLongEnough(start, end) {
     return distanceSquared(start, end) >= WALL_MIN_LENGTH * WALL_MIN_LENGTH;
 }
-function wallSegmentsCoverSegment(start, end, walls) {
+/** Where straight walls run along `start→end`, as sorted parameter intervals of it. */
+function collinearWallIntervals(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;
+        return null;
     const length = Math.sqrt(lengthSquared);
     const intervals = [];
     for (const wall of walls) {
@@ -37,9 +38,15 @@ function wallSegmentsCoverSegment(start, end, walls) {
             intervals.push([intervalStart, intervalEnd]);
     }
     intervals.sort((left, right) => left[0] - right[0]);
-    const parameterTolerance = WALL_INTERSECTION_EPSILON / length;
+    return { intervals, length };
+}
+function wallSegmentsCoverSegment(start, end, walls) {
+    const collinear = collinearWallIntervals(start, end, walls);
+    if (!collinear)
+        return false;
+    const parameterTolerance = WALL_INTERSECTION_EPSILON / collinear.length;
     let coveredUntil = 0;
-    for (const [intervalStart, intervalEnd] of intervals) {
+    for (const [intervalStart, intervalEnd] of collinear.intervals) {
         if (intervalStart > coveredUntil + parameterTolerance)
             return false;
         coveredUntil = Math.max(coveredUntil, intervalEnd);
@@ -48,6 +55,32 @@ function wallSegmentsCoverSegment(start, end, walls) {
     }
     return false;
 }
+/**
+ * The parts of `start→end` that no straight wall already runs along, in order.
+ * A side drawn along an existing wall and past its end yields the overhang
+ * only, so the existing wall is reused instead of doubled. Gaps too short to
+ * be a wall are treated as covered.
+ */
+export function uncoveredWallSegments(start, end, walls) {
+    const collinear = collinearWallIntervals(start, end, walls);
+    if (!collinear)
+        return [];
+    const minimumGap = WALL_MIN_LENGTH / collinear.length;
+    const at = (t) => [
+        start[0] + (end[0] - start[0]) * t,
+        start[1] + (end[1] - start[1]) * t,
+    ];
+    const segments = [];
+    let coveredUntil = 0;
+    for (const [intervalStart, intervalEnd] of collinear.intervals) {
+        if (intervalStart > coveredUntil + minimumGap)
+            segments.push([at(coveredUntil), at(intervalStart)]);
+        coveredUntil = Math.max(coveredUntil, intervalEnd);
+    }
+    if (coveredUntil < 1 - minimumGap)
+        segments.push([at(coveredUntil), end]);
+    return segments;
+}
 function projectPointOntoWallCenterline(point, wall) {
     if (isCurvedWall(wall)) {
         const arc = getWallArcData(wall);
@@ -396,13 +429,28 @@ export function planWallInsertion(nodes, args) {
         return split ? [[wallId, split]] : [];
     });
     const replacementWalls = splitPlans.flatMap(([, split]) => split.create);
+    // Rooms name the walls that enclose them; a split wall's replacements take
+    // its place, as they do for an explicit division or a merge.
+    const replacements = new Map(splitPlans.map(([wallId, split]) => [wallId, split.create.map((wall) => wall.id)]));
+    const zoneUpdates = Object.values(nodes).flatMap((node) => node.type === 'zone' &&
+        node.parentId === args.levelId &&
+        node.boundaryWallIds.some((id) => replacements.has(id))
+        ? [
+            {
+                id: node.id,
+                data: {
+                    boundaryWallIds: node.boundaryWallIds.flatMap((id) => replacements.get(id) ?? [id]),
+                },
+            },
+        ]
+        : []);
     const plan = {
         changes: {
             create: [...replacementWalls, ...insertedWalls].map((node) => ({
                 node,
                 parentId: args.levelId,
             })),
-            update: splitPlans.flatMap(([, split]) => split.update),
+            update: [...splitPlans.flatMap(([, split]) => split.update), ...zoneUpdates],
             delete: splitPlans.map(([wallId]) => wallId),
         },
         insertedWalls,

package/dist/validation/validate-build-json.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate-build-json.d.ts","sourceRoot":"","sources":["../../src/validation/validate-build-json.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AACxD,OAAO,EAAW,KAAK,WAAW,EAAc,MAAM,iBAAiB,CAAA;AAGvE,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,SAAS,CAAA;AAEpD,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,kBAAkB,CAAA;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC,CAAA;IAC5C,iFAAiF;IACjF,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACpC,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC3B,iEAAiE;IACjE,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IACzC,yEAAyE;IACzE,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;CACzC,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,EAAE,EAAE,OAAO,CAAA;IACX,MAAM,EAAE,eAAe,GAAG,IAAI,CAAA;IAC9B,KAAK,EAAE,UAAU,CAAA;IACjB,MAAM,EAAE,eAAe,EAAE,CAAA;IACzB,QAAQ,EAAE,eAAe,EAAE,CAAA;IAC3B,YAAY,EAAE,WAAW,EAAE,CAAA;IAC3B,gBAAgB,EAAE,MAAM,CAAA;CACzB,CAAA;AAwCD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,uBAAuB,CA2XzE"}
+{"version":3,"file":"validate-build-json.d.ts","sourceRoot":"","sources":["../../src/validation/validate-build-json.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AACxD,OAAO,EAAW,KAAK,WAAW,EAAc,MAAM,iBAAiB,CAAA;AAGvE,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,SAAS,CAAA;AAEpD,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,kBAAkB,CAAA;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC,CAAA;IAC5C,iFAAiF;IACjF,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACpC,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC3B,iEAAiE;IACjE,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IACzC,yEAAyE;IACzE,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;CACzC,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,EAAE,EAAE,OAAO,CAAA;IACX,MAAM,EAAE,eAAe,GAAG,IAAI,CAAA;IAC9B,KAAK,EAAE,UAAU,CAAA;IACjB,MAAM,EAAE,eAAe,EAAE,CAAA;IACzB,QAAQ,EAAE,eAAe,EAAE,CAAA;IAC3B,YAAY,EAAE,WAAW,EAAE,CAAA;IAC3B,gBAAgB,EAAE,MAAM,CAAA;CACzB,CAAA;AAwCD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,uBAAuB,CAsYzE"}

package/dist/validation/validate-build-json.js

@@ -1,3 +1,4 @@
+import { HIDDEN_SITE_NOTE } from '../lib/node-visibility.js';
 import { nodeRegistry } from '../registry/index.js';
 import { SceneMaterial } from '../schema/scene-material.js';
 import { AnyNode, nodeKindOf } from '../schema/types.js';
@@ -202,6 +203,17 @@ export function validateBuildJson(input) {
             message: '"rootNodeIds" is empty — no entry point into the scene.',
         });
     }
+    // Hand-authored files hide the Site expecting the parcel to disappear; the
+    // flag is accepted but reaches nothing beneath it, so say so at import.
+    for (const [key, value] of Object.entries(nodes)) {
+        if (!isPlainObject(value) || value.type !== 'site' || value.visible !== false)
+            continue;
+        warnings.push({
+            severity: 'warning',
+            code: 'site_hidden',
+            message: `Site "${typeof value.id === 'string' ? value.id : key}" is hidden. ${HIDDEN_SITE_NOTE}`,
+        });
+    }
     // Ids of nodes whose type falls outside the static schema union — plugin
     // kinds (`trees:tree`) or genuinely unknown types. The scene store accepts
     // them on load (they already round-trip through the DB fine) and they're

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pascal-app/core",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Core library for Pascal 3D building editor",
   "type": "module",
   "main": "./dist/index.js",
@@ -118,7 +118,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/pascalorg/editor.git",
+    "url": "git+https://github.com/pascalorg/editor.git",
     "directory": "packages/core"
   },
   "license": "MIT",