@pascal-app/core 1.0.1 → 1.0.4

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

@@ -0,0 +1,162 @@
+import { getWallArcData } from './wall-curve.js';
+export function getWallFaceOffsets(wall) {
+    const thickness = wall.thickness ?? 0.1;
+    if (wall.justification === 'a')
+        return { a: thickness, b: 0 };
+    if (wall.justification === 'b')
+        return { a: 0, b: -thickness };
+    return { a: thickness / 2, b: -thickness / 2 };
+}
+export function getWallBodyCenterOffset(wall) {
+    const { a, b } = getWallFaceOffsets(wall);
+    return (a + b) / 2;
+}
+function offsetLine(wall, offset) {
+    const start = { x: wall.start[0], y: wall.start[1] };
+    const end = { x: wall.end[0], y: wall.end[1] };
+    const dx = end.x - start.x;
+    const dy = end.y - start.y;
+    const length = Math.hypot(dx, dy);
+    if (offset === 0 || length < 1e-9)
+        return { start, end };
+    const nx = (-dy / length) * offset;
+    const ny = (dx / length) * offset;
+    return {
+        start: { x: start.x + nx, y: start.y + ny },
+        end: { x: end.x + nx, y: end.y + ny },
+    };
+}
+export function getWallBodyLine(wall) {
+    return offsetLine(wall, getWallBodyCenterOffset(wall));
+}
+export function getWallFaceLine(wall, face) {
+    return offsetLine(wall, getWallFaceOffsets(wall)[face]);
+}
+export function getWallLocalFaceZ(wall, face) {
+    // The viewer rotates XZ by -atan2(dy, dx), mapping the left normal to +z.
+    return getWallFaceOffsets(wall)[face];
+}
+/**
+ * Which physical face a point on the wall mesh lies on, from wall-local
+ * coordinates (x along the chord, z toward its left) — never from the material
+ * a face happens to draw with. Curved walls use the arc's own frame, so a point
+ * near an arc end is judged against the curve, not the chord. Returns null for
+ * caps and tops (the surface normal is not across the wall) and for points too
+ * close to the body centre to call.
+ */
+export function getWallFaceAtLocalPoint(wall, localPosition, localNormal) {
+    const dx = wall.end[0] - wall.start[0];
+    const dz = wall.end[1] - wall.start[1];
+    const length = Math.hypot(dx, dz);
+    if (length < 1e-9)
+        return null;
+    const tangent = { x: dx / length, y: dz / length };
+    const left = { x: -tangent.y, y: tangent.x };
+    const toWorld = (x, z) => ({
+        x: tangent.x * x + left.x * z,
+        y: tangent.y * x + left.y * z,
+    });
+    const [localX, , localZ] = localPosition;
+    let across = localZ;
+    let faceNormal = left;
+    const arc = getWallArcData(wall);
+    if (arc) {
+        const offset = toWorld(localX, localZ);
+        const px = wall.start[0] + offset.x - arc.center.x;
+        const py = wall.start[1] + offset.y - arc.center.y;
+        const radius = Math.hypot(px, py);
+        if (radius < 1e-9)
+            return null;
+        // Left of a counter-clockwise arc points at its centre.
+        const inward = arc.direction > 0;
+        across = inward ? arc.radius - radius : radius - arc.radius;
+        faceNormal = inward ? { x: -px / radius, y: -py / radius } : { x: px / radius, y: py / radius };
+    }
+    if (localNormal) {
+        const normal = toWorld(localNormal[0], localNormal[2]);
+        if (Math.abs(normal.x * faceNormal.x + normal.y * faceNormal.y) < 0.65)
+            return null;
+    }
+    const fromCentre = across - getWallBodyCenterOffset(wall);
+    const thickness = wall.thickness ?? 0.1;
+    if (Math.abs(fromCentre) < Math.max(thickness * 0.2, 0.01))
+        return null;
+    return fromCentre >= 0 ? 'a' : 'b';
+}
+export function faceOnLine(wall) {
+    return wall.justification === 'a' ? 'b' : wall.justification === 'b' ? 'a' : 'center';
+}
+export function justificationForFaceOnLine(face) {
+    return face === 'a' ? 'b' : face === 'b' ? 'a' : undefined;
+}
+export function buildWallJustificationPatch(justification) {
+    return { justification };
+}
+const swapFace = (face) => (face === 'a' ? 'b' : 'a');
+function swapFaceSlotKey(key) {
+    if (key === 'a' || key === 'b')
+        return swapFace(key);
+    const match = /^([ab])([A-Z].*)$/.exec(key);
+    return match ? `${swapFace(match[1])}${match[2]}` : key;
+}
+// Legacy semantic sides draw on their canonical face (interior → a), so they turn too.
+const TRIM_FACE = { a: 'a', interior: 'a', b: 'b', exterior: 'b' };
+function reverseTrim(trim) {
+    const face = trim?.sides ? TRIM_FACE[trim.sides] : undefined;
+    if (!(trim && face))
+        return trim;
+    return { ...trim, sides: swapFace(face) };
+}
+/**
+ * Turns a wall around. Face `a` becomes `b`, so everything keyed by face swaps
+ * with it, and region stations are re-measured from the new start. Zone
+ * `wallOverrides` live on zones; callers reversing a wall swap those too.
+ */
+export function reverseWallDirection(wall) {
+    const length = Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
+    const legacy = wall.legacyFaceMaterials;
+    return {
+        start: wall.end,
+        end: wall.start,
+        frontSide: wall.backSide,
+        backSide: wall.frontSide,
+        ...(wall.justification === undefined
+            ? {}
+            : { justification: wall.justification === 'a' ? 'b' : 'a' }),
+        ...(wall.curveOffset === undefined ? {} : { curveOffset: -wall.curveOffset }),
+        ...(wall.slots === undefined
+            ? {}
+            : {
+                slots: Object.fromEntries(Object.entries(wall.slots).map(([key, value]) => [swapFaceSlotKey(key), value])),
+            }),
+        ...(legacy === undefined
+            ? {}
+            : {
+                legacyFaceMaterials: {
+                    ...(legacy.b === undefined ? {} : { a: legacy.b }),
+                    ...(legacy.a === undefined ? {} : { b: legacy.a }),
+                },
+            }),
+        ...(wall.faceRegions === undefined
+            ? {}
+            : {
+                faceRegions: wall.faceRegions.map(({ u0, u1, ...region }) => ({
+                    ...region,
+                    face: swapFace(region.face),
+                    ...(u1 === undefined ? {} : { u0: length - u1 }),
+                    ...(u0 === undefined ? {} : { u1: length - u0 }),
+                })),
+            }),
+        ...(wall.skirting === undefined ? {} : { skirting: reverseTrim(wall.skirting) }),
+        ...(wall.crown === undefined ? {} : { crown: reverseTrim(wall.crown) }),
+        ...(wall.chairRail === undefined ? {} : { chairRail: reverseTrim(wall.chairRail) }),
+    };
+}
+export function planWallJustification(nodes, wallId, justification) {
+    const wall = nodes[wallId];
+    if (wall?.type !== 'wall')
+        throw Error('Select a wall.');
+    if (wall.justification === justification)
+        return [];
+    return [{ id: wall.id, data: buildWallJustificationPatch(justification) }];
+}

package/dist/systems/wall/wall-layer-bands.d.ts

@@ -0,0 +1,38 @@
+import { type ResolvedAssembly } from '../../lib/assembly-stack.js';
+import type { Assembly, WallNode } from '../../schema/index.js';
+import { type Point2D, type WallMiterData } from './wall-mitering.js';
+/**
+ * One assembly layer's share of a wall's plan footprint (F2 band math).
+ * `back` and `front` are the band's faces as signed offsets from the wall
+ * centreline along the front normal (+n), so `back < front` and the front
+ * face of the wall is at +thickness/2.
+ */
+export type WallLayerBand = {
+    layerId: string;
+    back: number;
+    front: number;
+    /** The mitred footprint ∩ the band's offset strip, as counter-clockwise plan rings. */
+    polygons: Point2D[][];
+};
+export type WallLayerBands = ResolvedAssembly & {
+    bands: WallLayerBand[];
+};
+/**
+ * Slices a wall's mitred plan footprint into the bands of an assembly's layers
+ * (F2 band math). Pure: nothing reads it yet (WL-02 extrudes the bands).
+ *
+ * The stack sets the body, so the bands tile exactly the footprint that
+ * mitering, rooms and 2D already use once `thickness` holds the layer sum. A
+ * wall whose stored thickness disagrees gets the `assembly.thickness-mismatch`
+ * diagnostic and no bands: it keeps its plain body until a writer re-derives
+ * the thickness. Layers stack from the front face (+n), or from the exterior
+ * face with `face: 'exterior'` (`resolveWallExteriorSide`, back as fallback).
+ *
+ * Straight walls intersect the footprint with half-plane strips through the
+ * core polygon booleans, which handles the junction vertex a mitred end cap
+ * may carry. A curved footprint's end caps are single segments, so its bands
+ * resample the footprint's own arcs at the band offsets and interpolate along
+ * each cap.
+ */
+export declare function getWallLayerBands(wall: WallNode, assembly: Assembly, miterData: WallMiterData): WallLayerBands;
+//# sourceMappingURL=wall-layer-bands.d.ts.map

package/dist/systems/wall/wall-layer-bands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-layer-bands.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-layer-bands.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAAwB,MAAM,0BAA0B,CAAA;AAEtF,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAQtD,OAAO,EAA8B,KAAK,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAI9F;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,uFAAuF;IACvF,QAAQ,EAAE,OAAO,EAAE,EAAE,CAAA;CACtB,CAAA;AAED,MAAM,MAAM,cAAc,GAAG,gBAAgB,GAAG;IAAE,KAAK,EAAE,aAAa,EAAE,CAAA;CAAE,CAAA;AAE1E;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,QAAQ,EAClB,SAAS,EAAE,aAAa,GACvB,cAAc,CA6BhB"}

package/dist/systems/wall/wall-layer-bands.js

@@ -0,0 +1,109 @@
+import { resolveAssemblyStack } from '../../lib/assembly-stack.js';
+import { subtractPolygonsFromPolygon } from '../../lib/polygon-union.js';
+import { resolveWallExteriorSide } from './wall-assembly.js';
+import { getWallCurveFrameAt, isCurvedWall } from './wall-curve.js';
+import { CURVED_WALL_SURFACE_SEGMENTS, getWallPlanFootprint, getWallThickness, } from './wall-footprint.js';
+import { getWallMiterBoundaryPoints } from './wall-mitering.js';
+const EPSILON = 1e-9;
+/**
+ * Slices a wall's mitred plan footprint into the bands of an assembly's layers
+ * (F2 band math). Pure: nothing reads it yet (WL-02 extrudes the bands).
+ *
+ * The stack sets the body, so the bands tile exactly the footprint that
+ * mitering, rooms and 2D already use once `thickness` holds the layer sum. A
+ * wall whose stored thickness disagrees gets the `assembly.thickness-mismatch`
+ * diagnostic and no bands: it keeps its plain body until a writer re-derives
+ * the thickness. Layers stack from the front face (+n), or from the exterior
+ * face with `face: 'exterior'` (`resolveWallExteriorSide`, back as fallback).
+ *
+ * Straight walls intersect the footprint with half-plane strips through the
+ * core polygon booleans, which handles the junction vertex a mitred end cap
+ * may carry. A curved footprint's end caps are single segments, so its bands
+ * resample the footprint's own arcs at the band offsets and interpolate along
+ * each cap.
+ */
+export function getWallLayerBands(wall, assembly, miterData) {
+    const thickness = getWallThickness(wall);
+    // Walls store the body as `thickness` and take no backing.
+    const stack = resolveAssemblyStack(assembly, { body: thickness });
+    if (stack.diagnostics.some((d) => d.code === 'assembly.thickness-mismatch')) {
+        return { ...stack, bands: [] };
+    }
+    const half = thickness / 2;
+    // +1 when the first listed layer is on the front face, −1 when it is on the back.
+    const sign = assembly.face === 'exterior' ? (resolveWallExteriorSide(wall) ?? -1) : 1;
+    const footprint = getWallPlanFootprint(wall, miterData);
+    const curved = isCurvedWall(wall);
+    const bands = [];
+    for (const layer of stack.layers) {
+        if (layer.thickness <= EPSILON)
+            continue;
+        const outer = sign * (half - layer.depth);
+        const inner = sign * (half - layer.depth - layer.thickness);
+        const back = Math.min(outer, inner);
+        const front = Math.max(outer, inner);
+        let polygons = [];
+        if (footprint.length >= 3) {
+            polygons = curved
+                ? curvedBand(wall, miterData, thickness, back, front)
+                : straightBand(wall, footprint, half, back, front);
+        }
+        bands.push({ layerId: layer.id, back, front, polygons });
+    }
+    return { ...stack, bands };
+}
+function straightBand(wall, footprint, half, back, front) {
+    const [sx, sy] = wall.start;
+    const dx = wall.end[0] - sx;
+    const dy = wall.end[1] - sy;
+    const length = Math.hypot(dx, dy);
+    const ux = dx / length;
+    const uy = dy / length;
+    const nx = -uy;
+    const ny = ux;
+    // Past every footprint point, mitre tips included.
+    const reach = 1 + Math.max(...footprint.map((point) => Math.hypot(point.x - sx, point.y - sy)));
+    const at = (along, offset) => [
+        sx + ux * along + nx * offset,
+        sy + uy * along + ny * offset,
+    ];
+    // Each cutter is the half-plane beyond one band face, clipped to a rectangle
+    // that contains the whole footprint. A face on the wall's own face needs none.
+    const strip = (from, to) => [
+        at(-reach, from),
+        at(length + reach, from),
+        at(length + reach, to),
+        at(-reach, to),
+    ];
+    const cutters = [];
+    if (front < half - EPSILON)
+        cutters.push(strip(front, half + reach));
+    if (back > -half + EPSILON)
+        cutters.push(strip(-half - reach, back));
+    const subject = footprint.map((point) => [point.x, point.y]);
+    return subtractPolygonsFromPolygon(subject, cutters).map((ring) => ring.map(([x, y]) => ({ x, y })));
+}
+function curvedBand(wall, miterData, thickness, back, front) {
+    const caps = getWallMiterBoundaryPoints(wall, miterData);
+    if (!caps)
+        return [];
+    const half = thickness / 2;
+    const along = (offset) => {
+        const points = [];
+        for (let index = 0; index <= CURVED_WALL_SURFACE_SEGMENTS; index++) {
+            const frame = getWallCurveFrameAt(wall, index / CURVED_WALL_SURFACE_SEGMENTS);
+            points.push({
+                x: frame.point.x + frame.normal.x * offset,
+                y: frame.point.y + frame.normal.y * offset,
+            });
+        }
+        const t = (offset + half) / thickness;
+        points[0] = lerp(caps.startRight, caps.startLeft, t);
+        points[points.length - 1] = lerp(caps.endRight, caps.endLeft, t);
+        return points;
+    };
+    return [[...along(back), ...along(front).reverse()]];
+}
+function lerp(a, b, t) {
+    return { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t };
+}

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

@@ -0,0 +1,57 @@
+import { type AnyNode, type AnyNodeId, type WallFaceRegion, type WallNode, type ZoneNode } from '../../schema/index.js';
+import type { WallTopologyChanges } from './wall-topology.js';
+export type WallAttachmentUpdate = {
+    id: AnyNodeId;
+    data: Partial<AnyNode>;
+};
+export declare function getWallEndpointAtPoint(wall: Pick<WallNode, 'start' | 'end'>, point: [number, number]): 'start' | 'end' | null;
+/**
+ * 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 declare function wallStyleMismatch(a: WallNode, b: WallNode, options: {
+    sides: boolean;
+    heightOf?: (wall: WallNode) => number;
+}): string | null;
+/**
+ * Both walls' paint regions in the merged wall's coordinates: faces read in its
+ * direction, stations measured from its start, each region clipped to the stretch
+ * its own wall covered (an open bound stays open only at a merged-wall end), and
+ * matching regions that meet at the joint joined into one. Null when a face would
+ * exceed the region limit.
+ */
+export declare function mergeWallFaceRegions(walls: readonly WallNode[], mergedStart: [number, number], mergedEnd: [number, number]): WallFaceRegion[] | null;
+/**
+ * Zone references after `secondary` is absorbed into `primary` (which spans
+ * `mergedStart → mergedEnd`): boundary ids follow the kept wall, and override
+ * entries move onto it with their face read in its direction. Null when the two
+ * walls disagree on a room's override for a face they both border — joining
+ * would repaint part of that room.
+ */
+export declare function planMergedZoneReferences(nodes: Record<AnyNodeId, AnyNode>, primary: WallNode, secondary: WallNode, mergedStart: [number, number], mergedEnd: [number, number]): Array<{
+    id: AnyNodeId;
+    data: Partial<ZoneNode>;
+}> | null;
+export declare function areWallStylesCompatible(a: WallNode, b: WallNode): boolean;
+export declare function areWallsCollinearAcrossPoint(a: WallNode, b: WallNode, sharedPoint: [number, number]): boolean;
+export declare function resolveMergedWallEndpoints(primary: WallNode, secondary: WallNode, sharedPoint: [number, number]): {
+    start: [number, number];
+    end: [number, number];
+};
+export declare function buildMergedWallAttachmentUpdates(primary: WallNode, secondary: WallNode, mergedWallId: AnyNodeId, mergedStart: [number, number], mergedEnd: [number, number], nodes: Record<AnyNodeId, AnyNode>): WallAttachmentUpdate[];
+/**
+ * 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 declare function planWallMerge(nodes: Record<AnyNodeId, AnyNode>, wallIds: readonly AnyNodeId[]): {
+    changes: WallTopologyChanges;
+    wallId: WallNode['id'];
+};
+//# sourceMappingURL=wall-merge.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wall-merge.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-merge.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAMd,KAAK,cAAc,EACnB,KAAK,QAAQ,EACb,KAAK,QAAQ,EACd,MAAM,cAAc,CAAA;AAGrB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAK1D,MAAM,MAAM,oBAAoB,GAAG;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAA;AAY5E,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAC,EACrC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GACtB,OAAO,GAAG,KAAK,GAAG,IAAI,CAIxB;AAMD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,CAAC,EAAE,QAAQ,EACX,CAAC,EAAE,QAAQ,EACX,OAAO,EAAE;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,MAAM,CAAA;CAAE,GACjE,MAAM,GAAG,IAAI,CA+Bf;AA4CD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAC7B,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAC1B,cAAc,EAAE,GAAG,IAAI,CAqEzB;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,QAAQ,EACjB,SAAS,EAAE,QAAQ,EACnB,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAC7B,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAC1B,KAAK,CAAC;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAA;CAAE,CAAC,GAAG,IAAI,CA+C1D;AAED,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,WAE/D;AAED,wBAAgB,4BAA4B,CAC1C,CAAC,EAAE,QAAQ,EACX,CAAC,EAAE,QAAQ,EACX,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,WAgB9B;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,QAAQ,EACjB,SAAS,EAAE,QAAQ,EACnB,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAC5B;IAAE,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAkBpD;AAyBD,wBAAgB,gCAAgC,CAC9C,OAAO,EAAE,QAAQ,EACjB,SAAS,EAAE,QAAQ,EACnB,YAAY,EAAE,SAAS,EACvB,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAC7B,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAC3B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAChC,oBAAoB,EAAE,CAyDxB;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,SAAS,SAAS,EAAE,GAC5B;IAAE,OAAO,EAAE,mBAAmB,CAAC;IAAC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;CAAE,CA8F1D"}