@pascal-app/core 1.0.3 → 1.0.5

package/dist/lib/room-zone-adoption.js

@@ -0,0 +1,150 @@
+import { area, containsPoint, intersection } from './polygon-boolean.js';
+/**
+ * Which existing zone becomes the room of an enclosed face. Shared by the M3 load
+ * migration and the structure kernel so both load paths and live edits agree.
+ *
+ * Hand-drawn zones are loose: drawn to wall centre lines, inner or outer faces,
+ * tens of centimetres off, sometimes spanning a closet or a second space behind a
+ * wall. A zone is its face's room when the face holds most of the zone and the zone
+ * covers most of the face's clear floor, or when the two simply match (IoU).
+ */
+export const ROOM_MATCH_IOU = 0.9;
+/** Part of the face's clear floor the zone must cover. */
+export const ROOM_ADOPT_COVER = 0.5;
+/** Part of the zone that must lie in the face (its dominant face). */
+export const ROOM_ADOPT_SHARE = 0.5;
+const EPSILON = 1e-9;
+function bounds(rings) {
+    let minX = Number.POSITIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    for (const ring of rings)
+        for (const [x, y] of ring) {
+            minX = Math.min(minX, x);
+            minY = Math.min(minY, y);
+            maxX = Math.max(maxX, x);
+            maxY = Math.max(maxY, y);
+        }
+    return { minX, minY, maxX, maxY };
+}
+function overlaps(a, b) {
+    return a.minX < b.maxX && b.minX < a.maxX && a.minY < b.maxY && b.minY < a.maxY;
+}
+/** Every face the zone overlaps, with its fit numbers, in face order. */
+export function zoneFaceFits(zone, faces) {
+    const polygon = { outer: zone.polygon, holes: zone.holes ?? [] };
+    const zoneArea = area([polygon]);
+    if (!(zoneArea > EPSILON))
+        return [];
+    const box = bounds([zone.polygon]);
+    const fits = [];
+    faces.forEach((face, index) => {
+        if (!overlaps(box, bounds([face.polygon.outer])))
+            return;
+        const overlap = area(intersection(polygon, face.polygon));
+        if (!(overlap > EPSILON))
+            return;
+        const faceArea = area([face.polygon]);
+        const clearArea = face.clear.outer.length >= 3 ? area([face.clear]) : 0;
+        const clearOverlap = clearArea > EPSILON ? area(intersection(polygon, face.clear)) : overlap;
+        fits.push({
+            face: index,
+            key: face.key,
+            share: overlap / zoneArea,
+            cover: clearOverlap / (clearArea > EPSILON ? clearArea : faceArea),
+            iou: Math.max(overlap / (zoneArea + faceArea - overlap), clearArea > EPSILON ? clearOverlap / (zoneArea + clearArea - clearOverlap) : 0),
+        });
+    });
+    return fits;
+}
+/** The face holding most of the zone, when the zone is that face's room. */
+export function adoptableFace(fits) {
+    let best;
+    for (const fit of fits)
+        if (!best ||
+            fit.share > best.share + EPSILON ||
+            (Math.abs(fit.share - best.share) <= EPSILON &&
+                (fit.cover > best.cover + EPSILON ||
+                    (Math.abs(fit.cover - best.cover) <= EPSILON && fit.key < best.key))))
+            best = fit;
+    if (!best)
+        return;
+    return best.iou >= ROOM_MATCH_IOU ||
+        (best.cover >= ROOM_ADOPT_COVER && best.share >= ROOM_ADOPT_SHARE)
+        ? best
+        : undefined;
+}
+/** Orders two candidates for one face: the zone covering more of it wins. */
+export function compareAdoptionFits(a, b) {
+    return (b.fit.cover - a.fit.cover || b.fit.iou - a.fit.iou || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+}
+/** Face index → adopted zone id; at most one zone per face, one face per zone. */
+export function electAdoptedZones(faces, zones) {
+    const candidates = new Map();
+    for (const zone of zones) {
+        const fit = adoptableFace(zoneFaceFits(zone, faces));
+        if (!fit)
+            continue;
+        const list = candidates.get(fit.face) ?? [];
+        list.push({ id: zone.id, fit });
+        candidates.set(fit.face, list);
+    }
+    const elected = new Map();
+    for (const [face, list] of candidates)
+        elected.set(face, list.sort(compareAdoptionFits)[0].id);
+    return elected;
+}
+function iou(a, b) {
+    const overlap = area(intersection(a, b));
+    const combined = area([a]) + area([b]) - overlap;
+    return combined > 0 ? overlap / combined : 0;
+}
+const boundaryKey = (walls = [], separators = []) => JSON.stringify([[...walls].sort(), [...separators].sort()]);
+/**
+ * The face an existing room keeps: the face with exactly its boundaries (nothing
+ * about it changed, even where degenerate faces overlap), then the outer face when
+ * its separators just carved an island, then the face holding its seed, then the
+ * largest overlap.
+ * Shared by the load migration and the structure kernel, so a reload never trades an
+ * existing room for a newly created one.
+ */
+export function existingRoomFace(room, faces, overlaps = faces.map((face) => iou({ outer: room.polygon, holes: room.holes ?? [] }, face.polygon))) {
+    const holes = room.holes ?? [];
+    const separators = room.boundarySeparatorIds ?? [];
+    const own = boundaryKey(room.boundaryWallIds, separators);
+    return faces
+        .map((face, index) => ({
+        index,
+        key: face.key,
+        exact: own !== boundaryKey() &&
+            boundaryKey(face.boundaryWallIds, face.boundarySeparatorIds) === own,
+        overlap: overlaps[index],
+        seed: !!room.seed && containsPoint([face.polygon], room.seed),
+        // A new separator island takes area from the room, never its identity,
+        // even when the old seed lies inside the new island.
+        islandOuter: face.polygon.holes.length > holes.length &&
+            face.boundarySeparatorIds.some((id) => !separators.includes(id)) &&
+            iou({ outer: room.polygon, holes: [] }, { outer: face.polygon.outer, holes: [] }) >
+                1 - 1e-6,
+    }))
+        .filter(({ overlap, seed }) => seed || overlap > 0)
+        .sort((a, b) => Number(b.exact) - Number(a.exact) ||
+        Number(b.islandOuter) - Number(a.islandOuter) ||
+        Number(b.seed) - Number(a.seed) ||
+        b.overlap - a.overlap ||
+        (a.key < b.key ? -1 : a.key > b.key ? 1 : 0))[0]?.index;
+}
+/** Among existing rooms keeping one face, the one covering most of it survives. */
+export function compareExistingRooms(face) {
+    const covered = new Map();
+    const cover = (room) => {
+        let value = covered.get(room.id);
+        if (value === undefined) {
+            value = area(intersection({ outer: room.polygon, holes: room.holes ?? [] }, face.polygon));
+            covered.set(room.id, value);
+        }
+        return value;
+    };
+    return (a, b) => cover(b) - cover(a) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+}

package/dist/lib/script-inputs-key.d.ts

@@ -0,0 +1,3 @@
+/** The key a finish script keeps of what it was built for, from its inputs' text. */
+export declare function scriptInputsKey(text: string): string;
+//# sourceMappingURL=script-inputs-key.d.ts.map

package/dist/lib/script-inputs-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"script-inputs-key.d.ts","sourceRoot":"","sources":["../../src/lib/script-inputs-key.ts"],"names":[],"mappings":"AAUA,qFAAqF;AACrF,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEpD"}

package/dist/lib/script-inputs-key.js

@@ -0,0 +1,13 @@
+/** 32-bit FNV-1a: a change detector for a script's inputs, not a content address. */
+function fnv1a(text, seed) {
+    let hash = seed;
+    for (let index = 0; index < text.length; index += 1) {
+        hash ^= text.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return (hash >>> 0).toString(16).padStart(8, '0');
+}
+/** The key a finish script keeps of what it was built for, from its inputs' text. */
+export function scriptInputsKey(text) {
+    return fnv1a(text, 0x811c9dc5) + fnv1a(text, 0x050c5d1f);
+}

package/dist/lib/setback-envelope.d.ts

@@ -0,0 +1,163 @@
+/**
+ * The BUILDABLE ENVELOPE as the zoning officer draws it: every lot line
+ * pushed inward by its own required yard, measured perpendicular to that
+ * line, the offsets clipped against each other where they meet. A curved
+ * (radius) lot line — a cul-de-sac frontage, a rounded corner — offsets to
+ * a CONCENTRIC curve, never a chord — the industry-standard setback for pie
+ * shapes, radius corners and odd lots.
+ *
+ * Built as a distance field rather than by intersecting offset lines: a
+ * point is buildable when its distance to EVERY lot line is at least that
+ * line's setback. The zero contour of `min_i(dist(p, line_i) − d_i)` over
+ * the lot is exactly the variable-distance inward offset — straight where
+ * the lot is straight, concentric round a radius, clipped where offsets
+ * cross, and rounded round a reflex notch — for convex, pie-shaped,
+ * L-shaped and radius-cornered lots alike. The contour is traced by the
+ * same marching squares the site plan draws terrain with, then simplified
+ * so a rectangle comes back as four corners and an arc keeps its vertices.
+ */
+export type Pt = readonly [number, number];
+export declare function polygonAreaAbs(points: readonly Pt[]): number;
+/**
+ * Which edges belong to the same ARC RUN: consecutive short edges (under
+ * `shortM`) turning gently (under `turnDeg` per vertex) — the county
+ * fabric's way of drawing a radius. A long edge is its own run. Returns
+ * the run id per edge.
+ */
+export declare function arcRuns(points: readonly Pt[], shortM?: number, turnDeg?: number): number[];
+/**
+ * The polygon `points` offset INWARD by `distances[i]` along edge i (edge i
+ * runs from points[i] to points[i + 1]). Empty when nothing buildable
+ * remains. The result starts near the lot's first vertex and winds the
+ * lot's way.
+ */
+/** A half-plane the envelope may not enter: the line a→b, `inside` a point on the forbidden side (a sight triangle's hypotenuse, the corner inside). */
+export type KeepOut = {
+    a: Pt;
+    b: Pt;
+    inside: Pt;
+};
+export declare function insetPolygon(points: readonly Pt[], distances: readonly number[], options?: {
+    resolution?: number;
+    simplifyM?: number;
+    keepOut?: readonly KeepOut[];
+}): Pt[];
+/**
+ * Which envelope edge is the one behind the lot's front line: the longest
+ * envelope edge facing the same way (within 25°) with its midpoint nearest
+ * that line. Facing, not only parallel: on a lot that widens away from its
+ * street the rear edge is parallel too, and longer. Null when no edge faces
+ * the street: side setbacks wider than a narrow frontage take the whole
+ * front, and a side is no front.
+ */
+export declare function envelopeFrontEdge(lot: readonly Pt[], frontIndex: number, envelope: readonly Pt[]): number | null;
+/**
+ * The CORNER SIGHT TRIANGLE at a street intersection (the clear-vision /
+ * visibility triangle): from the point where the two street lines meet —
+ * the right-of-way lines extended through the curb return — `legM` along
+ * each, the hypotenuse joining them; nothing over the code's height (30
+ * in typically) stands inside it. The leg is the ordinance's (25 ft is the
+ * common residential figure; FDOT and the Greenbook size it by speed) —
+ * verify locally. `edgeA` and `edgeB` are the two street edges; null when
+ * their lines are parallel or the corner lies far from both.
+ */
+export declare function sightTriangle(points: readonly Pt[], edgeA: number, edgeB: number, legM: number): {
+    corner: Pt;
+    a: Pt;
+    b: Pt;
+} | null;
+/**
+ * The street corners of a lot: pairs of street edges that meet at a real
+ * turn (40° or more) directly or across a curb-return run of short edges.
+ */
+export declare function streetCorners(points: readonly Pt[], streetEdges: readonly number[]): [number, number][];
+export interface SetbackInputs {
+    front: number;
+    side: number;
+    rear: number;
+    left?: number;
+    right?: number;
+    /** A corner lot's second street side; absent = the front setback. */
+    streetSide?: number;
+}
+/** Per-edge classification of a lot polygon relative to its front edge. */
+export type EdgeRole = 'front' | 'rear' | 'left' | 'right' | 'street';
+/** Unit normal of edge `i` pointing OUT of the polygon, winding-agnostic. */
+export declare function outwardNormal(points: readonly Pt[], i: number): Pt;
+/**
+ * Compass heading of edge `i`'s outward normal, in DEGREES clockwise from
+ * north, where `northRotation` (radians, clockwise) is true north's offset
+ * from plan up (−y). This is the direction the edge faces.
+ */
+export declare function edgeHeadingDeg(points: readonly Pt[], i: number, northRotation?: number): number;
+/** Length of edge `i`, metres. */
+export declare function edgeLength(points: readonly Pt[], i: number): number;
+/**
+ * Fallback front edge: the edge whose outward normal points closest to true
+ * north. Ties break toward the longer edge — the street frontage of a typical
+ * lot is one of its long sides.
+ */
+export declare function mostNorthFacingEdge(points: readonly Pt[], northRotation?: number): number;
+/** `frontEdge` if it indexes a real edge, else the most north-facing edge. */
+export declare function resolveFrontEdge(points: readonly Pt[], frontEdge: number | undefined, northRotation?: number): number;
+/**
+ * Classify every edge as front / rear / left / right.
+ *
+ * - front = `frontIndex`.
+ * - rear  = the edge whose outward normal is most anti-parallel to the front's.
+ * - the rest are sides. LEFT / RIGHT are defined along the FRONT EDGE
+ *   DIRECTION (`points[front] → points[front + 1]`): an edge whose midpoint
+ *   projects behind the front-edge midpoint on that axis is `left`, ahead of
+ *   it is `right`. Deterministic and independent of winding.
+ */
+export declare function classifyEdges(points: readonly Pt[], frontIndex: number, streetEdges?: readonly number[]): EdgeRole[];
+/** Required setback distance (metres) for each edge role. */
+export declare function setbackForRole(setbacks: SetbackInputs, role: EdgeRole): number;
+/**
+ * Buildable envelope — every lot edge pushed INWARD by its own setback
+ * (`insetPolygon`): straight where the lot is straight, concentric round a
+ * radius, clipped where the offsets cross. On a concave lot a reflex corner
+ * can self-intersect, in which case the caller still gets a ring but it is
+ * advisory, not a legal envelope.
+ *
+ * Returns `[]` when the polygon has fewer than 3 points, when a setback is
+ * not a distance, or when nothing buildable remains (setbacks larger than
+ * the lot).
+ */
+export declare function setbackEnvelope(points: readonly Pt[], setbacks: SetbackInputs, frontIndex: number, options?: {
+    streetEdges?: readonly number[];
+    sightTriangleM?: number;
+}): Pt[];
+/**
+ * Distance from `origin` along unit direction `(dx, dy)` to the first crossing
+ * of the polygon boundary. `null` when the ray never hits (origin outside, or
+ * a degenerate ring).
+ */
+export declare function rayToPolygon(points: readonly Pt[], origin: Pt, dx: number, dy: number): {
+    distance: number;
+    point: Pt;
+} | null;
+/** Yard sides in the order the site-plan dimensions are cast. */
+export type YardSide = 'north' | 'south' | 'east' | 'west';
+export interface YardDimension {
+    side: YardSide;
+    /** Bounding-box edge midpoint the dimension starts at. */
+    from: Pt;
+    /** Where the cast ray meets the lot line. */
+    to: Pt;
+    /** Metres. */
+    distance: number;
+}
+/**
+ * Yard dimensions for a building TURNED on its lot. The footprint's bounds
+ * are taken in the building's own frame (`yaw`, the building node's Y
+ * rotation), and the four edge midpoints cast square to the house's faces
+ * out to the lot line — the yards a plan checker measures. With a house
+ * square to a diagonal lot the axis-aligned bbox sticks out past the real
+ * corners and reads a front yard inches short of the setback it actually
+ * meets (Land Park, 2026-09-06). `side` is the compass direction nearest the
+ * cast, so labels keep reading N / S / E / W. Sides whose ray misses the lot
+ * line (footprint outside the lot) are omitted rather than faked.
+ */
+export declare function castYardDimensionsOriented(lot: readonly Pt[], footprintLoops: readonly (readonly Pt[])[], yaw: number): YardDimension[];
+//# sourceMappingURL=setback-envelope.d.ts.map

package/dist/lib/setback-envelope.d.ts.map

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