@pascal-app/core 1.0.1 → 1.0.4

package/dist/lib/setback-envelope.js

@@ -0,0 +1,506 @@
+/**
+ * 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.
+ */
+import { terrainContours } from './terrain-contours.js';
+import { createTerrainField } from './terrain-field.js';
+const EPS = 1e-9;
+function pointInPolygon(points, x, y) {
+    let inside = false;
+    for (let i = 0, j = points.length - 1; i < points.length; j = i++) {
+        const a = points[i];
+        const b = points[j];
+        if (a[1] > y !== b[1] > y && x < ((b[0] - a[0]) * (y - a[1])) / (b[1] - a[1] || 1e-12) + a[0])
+            inside = !inside;
+    }
+    return inside;
+}
+function segDist(px, py, a, b) {
+    const abx = b[0] - a[0];
+    const aby = b[1] - a[1];
+    const l2 = abx * abx + aby * aby;
+    const t = l2 < EPS ? 0 : Math.max(0, Math.min(1, ((px - a[0]) * abx + (py - a[1]) * aby) / l2));
+    return Math.hypot(px - (a[0] + abx * t), py - (a[1] + aby * t));
+}
+function signedArea(points) {
+    let a = 0;
+    for (let i = 0, n = points.length; i < n; i++) {
+        const p = points[i];
+        const q = points[(i + 1) % n];
+        a += p[0] * q[1] - q[0] * p[1];
+    }
+    return a / 2;
+}
+export function polygonAreaAbs(points) {
+    return Math.abs(signedArea(points));
+}
+/**
+ * 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 function arcRuns(points, shortM = 4, turnDeg = 35) {
+    const n = points.length;
+    const dirs = points.map((p, i) => {
+        const q = points[(i + 1) % n];
+        const dx = q[0] - p[0];
+        const dy = q[1] - p[1];
+        const len = Math.hypot(dx, dy) || 1;
+        return { dx: dx / len, dy: dy / len, len };
+    });
+    const turn = Math.cos((turnDeg * Math.PI) / 180);
+    const run = new Array(n).fill(-1);
+    let runs = 0;
+    // start the sweep at a long edge when there is one, so a run never wraps across the sweep's seam
+    const start = dirs.findIndex((d) => d.len >= shortM);
+    const order = Array.from({ length: n }, (_, k) => ((start < 0 ? 0 : start) + k) % n);
+    for (const i of order) {
+        if (run[i] !== -1)
+            continue;
+        const a = dirs[i];
+        if (a.len >= shortM) {
+            run[i] = runs++;
+            continue;
+        }
+        const members = [i];
+        let j = (i + 1) % n;
+        let cur = a;
+        while (j !== i && run[j] === -1) {
+            const b = dirs[j];
+            if (b.len >= shortM || cur.dx * b.dx + cur.dy * b.dy < turn)
+                break;
+            members.push(j);
+            cur = b;
+            j = (j + 1) % n;
+        }
+        for (const m of members)
+            run[m] = runs;
+        runs += 1;
+    }
+    return run;
+}
+/** Douglas–Peucker on an open polyline. */
+function simplifyOpen(pts, tol) {
+    if (pts.length < 3)
+        return pts;
+    const a = pts[0];
+    const b = pts[pts.length - 1];
+    let worst = 0;
+    let worstAt = -1;
+    for (let i = 1; i < pts.length - 1; i++) {
+        const p = pts[i];
+        const d = segDist(p[0], p[1], a, b);
+        if (d > worst) {
+            worst = d;
+            worstAt = i;
+        }
+    }
+    if (worst <= tol || worstAt < 0)
+        return [a, b];
+    const left = simplifyOpen(pts.slice(0, worstAt + 1), tol);
+    const right = simplifyOpen(pts.slice(worstAt), tol);
+    return [...left.slice(0, -1), ...right];
+}
+/** Douglas–Peucker on a closed loop: split at the two farthest-apart vertices. */
+function simplifyLoop(loop, tol) {
+    if (loop.length < 4)
+        return loop;
+    let i0 = 0;
+    let i1 = 0;
+    let best = -1;
+    for (let i = 0; i < loop.length; i++) {
+        for (let j = i + 1; j < loop.length; j++) {
+            const d = Math.hypot(loop[i][0] - loop[j][0], loop[i][1] - loop[j][1]);
+            if (d > best) {
+                best = d;
+                i0 = i;
+                i1 = j;
+            }
+        }
+    }
+    const a = [...loop.slice(i0, i1 + 1)];
+    const b = [...loop.slice(i1), ...loop.slice(0, i0 + 1)];
+    const sa = simplifyOpen(a, tol);
+    const sb = simplifyOpen(b, tol);
+    return [...sa.slice(0, -1), ...sb.slice(0, -1)];
+}
+/**
+ * Marching squares cuts a sharp convex corner with a one-cell chamfer;
+ * where a short edge sits between two long ones, put the corner back at the
+ * long edges' intersection when that point is where the chamfer was.
+ */
+function sharpen(loop, maxChamfer) {
+    const n = loop.length;
+    if (n < 4)
+        return loop;
+    const out = [];
+    const skip = new Set();
+    for (let i = 0; i < n; i++) {
+        if (skip.has(i))
+            continue;
+        const p = loop[i];
+        const q = loop[(i + 1) % n];
+        const len = Math.hypot(q[0] - p[0], q[1] - p[1]);
+        if (len > maxChamfer) {
+            out.push(p);
+            continue;
+        }
+        const o = loop[(i - 1 + n) % n];
+        const r = loop[(i + 2) % n];
+        const d1x = p[0] - o[0];
+        const d1y = p[1] - o[1];
+        const d2x = r[0] - q[0];
+        const d2y = r[1] - q[1];
+        const denom = d1x * d2y - d1y * d2x;
+        if (Math.abs(denom) < EPS) {
+            out.push(p);
+            continue;
+        }
+        const t = ((q[0] - o[0]) * d2y - (q[1] - o[1]) * d2x) / denom;
+        const cx = o[0] + d1x * t;
+        const cy = o[1] + d1y * t;
+        if (Math.hypot(cx - p[0], cy - p[1]) > 1.5 * maxChamfer) {
+            out.push(p);
+            continue;
+        }
+        out.push([cx, cy]);
+        skip.add((i + 1) % n);
+    }
+    return out;
+}
+/**
+ * A convex lot with no radius runs is offset EXACTLY: each edge's offset
+ * line intersected with its neighbours'. Null when the lot is not that
+ * simple, or when the result folds (an edge shorter than its neighbours'
+ * offsets) — the field then does the clipping.
+ */
+function analyticInset(points, ds) {
+    const n = points.length;
+    const runs = arcRuns(points);
+    if (new Set(runs).size !== n)
+        return null;
+    const area = signedArea(points);
+    const sign = area > 0 ? -1 : 1;
+    let turn = 0;
+    const lines = [];
+    for (let i = 0; i < n; i++) {
+        const p = points[i];
+        const q = points[(i + 1) % n];
+        const r = points[(i + 2) % n];
+        const cross = (q[0] - p[0]) * (r[1] - q[1]) - (q[1] - p[1]) * (r[0] - q[0]);
+        if (turn === 0)
+            turn = Math.sign(cross);
+        else if (Math.sign(cross) !== 0 && Math.sign(cross) !== turn)
+            return null; // concave
+        const dx = q[0] - p[0];
+        const dy = q[1] - p[1];
+        const len = Math.hypot(dx, dy);
+        if (len < EPS)
+            return null;
+        const nx = (sign * -dy) / len;
+        const ny = (sign * dx) / len;
+        const d = ds[i];
+        lines.push({ ax: p[0] - nx * d, ay: p[1] - ny * d, dx: dx / len, dy: dy / len });
+    }
+    const out = [];
+    for (let i = 0; i < n; i++) {
+        const prev = lines[(i - 1 + n) % n];
+        const cur = lines[i];
+        const denom = prev.dx * cur.dy - prev.dy * cur.dx;
+        if (Math.abs(denom) < 1e-9) {
+            out.push([cur.ax, cur.ay]);
+            continue;
+        }
+        const t = ((cur.ax - prev.ax) * cur.dy - (cur.ay - prev.ay) * cur.dx) / denom;
+        out.push([prev.ax + prev.dx * t, prev.ay + prev.dy * t]);
+    }
+    // folded: an edge reversed, the ring flipped, or a corner outside the lot
+    for (let i = 0; i < n; i++) {
+        const p = out[i];
+        const q = out[(i + 1) % n];
+        const l = lines[i];
+        if ((q[0] - p[0]) * l.dx + (q[1] - p[1]) * l.dy < -1e-9)
+            return null;
+        if (!pointInPolygon(points, p[0], p[1]) &&
+            ds[i] > 0 &&
+            ds[(i - 1 + n) % n] > 0)
+            return null;
+    }
+    if (polygonAreaAbs(out) < 1e-9)
+        return null;
+    if (signedArea(out) > 0 !== area > 0)
+        return null;
+    if (polygonAreaAbs(out) >= polygonAreaAbs(points))
+        return null;
+    return out;
+}
+export function insetPolygon(points, distances, options = {}) {
+    const n = points.length;
+    if (n < 3 || distances.length !== n)
+        return [];
+    if (!distances.some((d) => Number.isFinite(d) && d > 0))
+        return [];
+    const ds = distances.map((d) => (Number.isFinite(d) && d > 0 ? d : 0));
+    const keepOut = (options.keepOut ?? []).map((k) => {
+        const dx = k.b[0] - k.a[0];
+        const dy = k.b[1] - k.a[1];
+        const len = Math.hypot(dx, dy) || 1;
+        let nx = -dy / len;
+        let ny = dx / len;
+        // the normal points AWAY from the forbidden side
+        if ((k.inside[0] - k.a[0]) * nx + (k.inside[1] - k.a[1]) * ny > 0) {
+            nx = -nx;
+            ny = -ny;
+        }
+        return { ax: k.a[0], ay: k.a[1], nx, ny };
+    });
+    const exact = keepOut.length === 0 ? analyticInset(points, ds) : null;
+    if (exact)
+        return exact;
+    let minX = Number.POSITIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    for (const p of points) {
+        minX = Math.min(minX, p[0]);
+        maxX = Math.max(maxX, p[0]);
+        minY = Math.min(minY, p[1]);
+        maxY = Math.max(maxY, p[1]);
+    }
+    const diag = Math.hypot(maxX - minX, maxY - minY);
+    if (!(diag > 0))
+        return [];
+    const h = options.resolution ?? Math.max(0.08, Math.min(0.4, diag / 320));
+    const cols = Math.ceil((maxX - minX) / h) + 4;
+    const rows = Math.ceil((maxY - minY) / h) + 4;
+    if (cols * rows > 4_000_000)
+        return [];
+    const origin = [minX - 2 * h, minY - 2 * h];
+    const step = 0.001;
+    const base = createTerrainField({ origin, spacing: h, cols, rows, step });
+    const heights = new Int16Array(base.heights);
+    const CAP = 20;
+    for (let row = 0; row < rows; row++) {
+        for (let col = 0; col < cols; col++) {
+            const x = origin[0] + col * h;
+            const y = origin[1] + row * h;
+            let f;
+            if (!pointInPolygon(points, x, y)) {
+                // outside: the signed distance continues through the lot line, so a
+                // zero-setback edge's contour lands exactly on the line
+                f = Number.POSITIVE_INFINITY;
+                for (let i = 0; i < n; i++)
+                    f = Math.min(f, segDist(x, y, points[i], points[(i + 1) % n]));
+                f = -Math.max(f, 1e-4);
+            }
+            else {
+                f = Number.POSITIVE_INFINITY;
+                for (let i = 0; i < n; i++) {
+                    const v = segDist(x, y, points[i], points[(i + 1) % n]) - ds[i];
+                    if (v < f)
+                        f = v;
+                }
+                for (const k of keepOut) {
+                    const v = (x - k.ax) * k.nx + (y - k.ay) * k.ny;
+                    if (v < f)
+                        f = v;
+                }
+            }
+            f = Math.max(-CAP, Math.min(CAP, f));
+            heights[row * cols + col] = Math.round(f / step);
+        }
+    }
+    const field = { ...base, heights };
+    // one level only: zero (the interval is past every value in the field)
+    const contours = terrainContours(field, CAP + 1, points);
+    let best = null;
+    let bestArea = 0;
+    for (const c of contours) {
+        if (c.points.length < 3)
+            continue;
+        const loop = c.points;
+        const a = polygonAreaAbs(loop);
+        if (a > bestArea) {
+            bestArea = a;
+            best = loop;
+        }
+    }
+    if (!best || bestArea < 1e-3)
+        return [];
+    // drop a duplicated closing vertex
+    const first = best[0];
+    const last = best[best.length - 1];
+    if (Math.hypot(first[0] - last[0], first[1] - last[1]) < 1e-6)
+        best = best.slice(0, -1);
+    let loop = simplifyLoop(best, options.simplifyM ?? 0.03);
+    loop = sharpen(loop, 1.6 * h);
+    if (loop.length < 3)
+        return [];
+    // the lot's winding, starting near the lot's first vertex
+    if (signedArea(loop) > 0 !== signedArea(points) > 0)
+        loop = [...loop].reverse();
+    const p0 = points[0];
+    let startAt = 0;
+    let startD = Number.POSITIVE_INFINITY;
+    loop.forEach((p, i) => {
+        const d = Math.hypot(p[0] - p0[0], p[1] - p0[1]);
+        if (d < startD) {
+            startD = d;
+            startAt = i;
+        }
+    });
+    loop = [...loop.slice(startAt), ...loop.slice(0, startAt)];
+    return loop.map((p) => [Math.round(p[0] * 1e4) / 1e4, Math.round(p[1] * 1e4) / 1e4]);
+}
+/**
+ * Which envelope edge is the one behind the lot's front line: the longest
+ * envelope edge running parallel to it (within 25°) with its midpoint
+ * nearest that line; failing that, the envelope edge whose midpoint is
+ * nearest the lot front's midpoint (a pie lot's curved frontage has no
+ * single parallel — its longest arc chord fronts the house).
+ */
+export function envelopeFrontEdge(lot, frontIndex, envelope) {
+    const n = lot.length;
+    const m = envelope.length;
+    if (n < 2 || m < 2)
+        return 0;
+    const fi = ((frontIndex % n) + n) % n;
+    const a = lot[fi];
+    const b = lot[(fi + 1) % n];
+    const fx = b[0] - a[0];
+    const fy = b[1] - a[1];
+    const fl = Math.hypot(fx, fy) || 1;
+    const ux = fx / fl;
+    const uy = fy / fl;
+    const fmid = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
+    let bestI = -1;
+    let bestScore = Number.NEGATIVE_INFINITY;
+    for (let i = 0; i < m; i++) {
+        const p = envelope[i];
+        const q = envelope[(i + 1) % m];
+        const ex = q[0] - p[0];
+        const ey = q[1] - p[1];
+        const el = Math.hypot(ex, ey);
+        if (el < 1e-6)
+            continue;
+        const par = Math.abs((ex * ux + ey * uy) / el);
+        if (par < Math.cos((25 * Math.PI) / 180))
+            continue;
+        const mid = [(p[0] + q[0]) / 2, (p[1] + q[1]) / 2];
+        const dist = segDist(mid[0], mid[1], a, b);
+        // long and close wins: the front's offset is one lot-front length away by the setback
+        const score = el - 2 * dist;
+        if (score > bestScore) {
+            bestScore = score;
+            bestI = i;
+        }
+    }
+    if (bestI >= 0)
+        return bestI;
+    let nearest = 0;
+    let nd = Number.POSITIVE_INFINITY;
+    for (let i = 0; i < m; i++) {
+        const p = envelope[i];
+        const q = envelope[(i + 1) % m];
+        const d = Math.hypot((p[0] + q[0]) / 2 - fmid[0], (p[1] + q[1]) / 2 - fmid[1]);
+        if (d < nd) {
+            nd = d;
+            nearest = i;
+        }
+    }
+    return nearest;
+}
+/**
+ * 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 function sightTriangle(points, edgeA, edgeB, legM) {
+    const n = points.length;
+    const line = (i) => {
+        const p = points[((i % n) + n) % n];
+        const q = points[(((i + 1) % n) + n) % n];
+        const dx = q[0] - p[0];
+        const dy = q[1] - p[1];
+        const len = Math.hypot(dx, dy) || 1;
+        return { p, q, dx: dx / len, dy: dy / len, len };
+    };
+    const A = line(edgeA);
+    const B = line(edgeB);
+    const denom = A.dx * B.dy - A.dy * B.dx;
+    if (Math.abs(denom) < 1e-6)
+        return null;
+    const t = ((B.p[0] - A.p[0]) * B.dy - (B.p[1] - A.p[1]) * B.dx) / denom;
+    const corner = [A.p[0] + A.dx * t, A.p[1] + A.dy * t];
+    // along each line from the corner toward that edge's far end
+    const away = (L) => {
+        const mid = [(L.p[0] + L.q[0]) / 2, (L.p[1] + L.q[1]) / 2];
+        const s = (mid[0] - corner[0]) * L.dx + (mid[1] - corner[1]) * L.dy >= 0 ? 1 : -1;
+        return [corner[0] + s * L.dx * legM, corner[1] + s * L.dy * legM];
+    };
+    const dA = segDist(corner[0], corner[1], A.p, A.q);
+    const dB = segDist(corner[0], corner[1], B.p, B.q);
+    if (dA > 30 || dB > 30)
+        return null;
+    return { corner, a: away(A), b: away(B) };
+}
+/**
+ * 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 function streetCorners(points, streetEdges) {
+    const n = points.length;
+    if (n < 3 || streetEdges.length < 2)
+        return [];
+    const street = new Set(streetEdges.map((i) => ((i % n) + n) % n));
+    const runs = arcRuns(points);
+    const dir = (i) => {
+        const p = points[i];
+        const q = points[(i + 1) % n];
+        const l = Math.hypot(q[0] - p[0], q[1] - p[1]) || 1;
+        return [(q[0] - p[0]) / l, (q[1] - p[1]) / l];
+    };
+    const out = [];
+    for (const i of street) {
+        // walk forward past a curb-return run of short edges to the next long edge
+        let j = (i + 1) % n;
+        let steps = 0;
+        while (j !== i && steps < n) {
+            const same = runs[j] === runs[i];
+            const short = Math.hypot(points[(j + 1) % n][0] - points[j][0], points[(j + 1) % n][1] - points[j][1]) < 4;
+            if (!same && !short)
+                break;
+            j = (j + 1) % n;
+            steps += 1;
+        }
+        if (j === i || !street.has(j))
+            continue;
+        const a = dir(i);
+        const b = dir(j);
+        const cosTurn = a[0] * b[0] + a[1] * b[1];
+        if (cosTurn > Math.cos((40 * Math.PI) / 180))
+            continue;
+        out.push([i, j]);
+    }
+    return out;
+}

package/dist/lib/slab-polygon.d.ts.map

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

package/dist/lib/slab-polygon.js

@@ -1,10 +1,11 @@
-import { isCurvedWall, sampleWallCenterline } from '../systems/wall/wall-curve.js';
-import { getWallThickness } from '../systems/wall/wall-footprint.js';
+import { DEFAULT_SLAB_ELEVATION } from '../schema/nodes/slab.js';
+import { getWallCurveFrameAt, isCurvedWall, sampleWallCenterline } from '../systems/wall/wall-curve.js';
+import { getWallBodyCenterOffset, getWallBodyLine, getWallFaceOffsets, } from '../systems/wall/wall-frame.js';
 /**
  * Render-time slab polygon rules.
  *
- * Slab nodes store the wall-centerline polygon (auto slabs) or the drawn
- * polygon (manual slabs) — render offsets are NEVER stored in node data.
+ * Auto plates store their full footprint and render unchanged. Manual slabs
+ * keep the drawn polygon and adopt wall faces at render time.
  * At geometry build time each polygon edge is SPLIT at the clipped span
  * boundaries of every overlapping candidate (sibling slab edges and wall
  * centerlines in the adoption band) and each sub-edge is classified
@@ -76,7 +77,6 @@ const MIN_SUBEDGE_LENGTH = 0.05;
 const WALL_LATERAL_TIE_EPSILON = 0.02;
 const CURVED_WALL_SAMPLE_SEGMENTS = 32;
 const SLAB_SEAM_ELEVATION_EPSILON = 1e-4;
-const DEFAULT_SLAB_ELEVATION = 0.05;
 const DEFAULT_SLAB_THICKNESS = 0.05;
 /**
  * A non-recessed slab whose underside (`elevation − thickness`) rises
@@ -137,6 +137,8 @@ export function slabPolygonContextForLevel(parent, resolve, fallbackSlabs = [])
 }
 export function getRenderableSlabPolygon(slabNode, context) {
     const polygon = slabNode.polygon;
+    if (slabNode.boundary === 'auto')
+        return polygon;
     if (polygon.length < 3 || isFloatingSlab(slabNode)) {
         return polygon.map(([x, z]) => [x, z]);
     }
@@ -179,9 +181,16 @@ function clipCollinearSegment(ax, az, dirX, dirZ, edgeLength, px, pz, qx, qz, la
 }
 function wallCenterlineSegments(wall) {
     if (!isCurvedWall(wall)) {
-        return [[wall.start[0], wall.start[1], wall.end[0], wall.end[1]]];
+        const { start, end } = getWallBodyLine(wall);
+        return [[start.x, start.y, end.x, end.y]];
     }
-    const points = sampleWallCenterline(wall, CURVED_WALL_SAMPLE_SEGMENTS);
+    const centerOffset = getWallBodyCenterOffset(wall);
+    const points = sampleWallCenterline(wall, CURVED_WALL_SAMPLE_SEGMENTS).map((point, index) => {
+        if (centerOffset === 0)
+            return point;
+        const { normal } = getWallCurveFrameAt(wall, index / CURVED_WALL_SAMPLE_SEGMENTS);
+        return { x: point.x + normal.x * centerOffset, y: point.y + normal.y * centerOffset };
+    });
     const segments = [];
     for (let index = 0; index < points.length - 1; index += 1) {
         const from = points[index];
@@ -245,15 +254,22 @@ export function snapSlabEdgeToWallBand(a, b, walls, options) {
     const candidates = walls.map((wall) => ({
         wall,
         segments: wallCenterlineSegments(wall),
-        halfThickness: getWallThickness(wall) / 2,
+        halfThickness: getWallFaceOffsets(wall).a - getWallBodyCenterOffset(wall),
     }));
     const match = matchEdgeWallBand(a[0], a[1], dirX, dirZ, edgeLength, requiredOverlap, candidates);
     if (!match)
         return null;
     if (options?.maxLateral !== undefined && Math.abs(match.lateral) > options.maxLateral)
         return null;
-    const nx = dirZ * match.lateral;
-    const nz = -dirX * match.lateral;
+    const wallDx = match.wall.end[0] - match.wall.start[0];
+    const wallDz = match.wall.end[1] - match.wall.start[1];
+    const wallLength = Math.hypot(wallDx, wallDz);
+    const centerOffset = getWallBodyCenterOffset(match.wall);
+    const lateral = centerOffset === 0 || wallLength < 1e-9
+        ? match.lateral
+        : match.lateral + (centerOffset * (wallDx * dirX + wallDz * dirZ)) / wallLength;
+    const nx = dirZ * lateral;
+    const nz = -dirX * lateral;
     return {
         wallId: match.wall.id,
         edge: [
@@ -263,7 +279,12 @@ export function snapSlabEdgeToWallBand(a, b, walls, options) {
     };
 }
 function polygonBounds(polygon) {
-    const bounds = [Infinity, Infinity, -Infinity, -Infinity];
+    const bounds = [
+        Number.POSITIVE_INFINITY,
+        Number.POSITIVE_INFINITY,
+        Number.NEGATIVE_INFINITY,
+        Number.NEGATIVE_INFINITY,
+    ];
     for (const [x, z] of polygon) {
         bounds[0] = Math.min(bounds[0], x);
         bounds[1] = Math.min(bounds[1], z);
@@ -374,7 +395,7 @@ export function prepareSlabPolygonContext(context, previous) {
         const candidate = {
             wall,
             segments,
-            halfThickness: getWallThickness(wall) / 2,
+            halfThickness: getWallFaceOffsets(wall).a - getWallBodyCenterOffset(wall),
             bounds: polygonBounds(segments.flatMap(([ax, az, bx, bz]) => [
                 [ax, az],
                 [bx, bz],

package/dist/lib/slots.d.ts

@@ -1,3 +1,5 @@
+import type { MaterialSchema } from '../schema/material.js';
+import type { SceneMaterial, SceneMaterialId } from '../schema/scene-material.js';
 export declare const SLOT_MATERIAL_PREFIX = "slot_";
 /** A glTF material name marks a paintable slot when it starts with `slot_` (case-insensitive). */
 export declare function isSlotMaterialName(name: string): boolean;
@@ -11,4 +13,22 @@ export declare function isSlotMaterialName(name: string): boolean;
 export declare function deriveSlotId(materialName: string): string | null;
 /** slot id -> display label: underscores to spaces, sentence case. e.g. 'bed_frame' -> 'Bed frame'. */
 export declare function slotLabelFromId(slotId: string): string;
+/**
+ * A slot's declared `default` as a paint material: a `library:` / `scene:` ref
+ * stays a ref, a `#rrggbb` colour becomes a flat colour. What an unpainted slot
+ * draws, for the eyedropper; null for anything else.
+ */
+export declare function slotDefaultPaintMaterial(value: string | undefined): {
+    material?: MaterialSchema;
+    materialPreset?: string;
+} | null;
+/**
+ * A painted slot value as a paint material — what the eyedropper picks: a
+ * `library:` ref stays a ref, a `scene:` ref gives its scene material, a plain
+ * colour the flat material it renders as. Null when absent or dangling.
+ */
+export declare function slotPaintMaterial(value: string | undefined, sceneMaterials: Record<SceneMaterialId, SceneMaterial>): {
+    material: MaterialSchema | undefined;
+    materialPreset: string | undefined;
+} | null;
 //# sourceMappingURL=slots.d.ts.map

package/dist/lib/slots.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"slots.d.ts","sourceRoot":"","sources":["../../src/lib/slots.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB,UAAU,CAAA;AAE3C,kGAAkG;AAClG,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAExD;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAKhE;AAED,uGAAuG;AACvG,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAItD"}
+{"version":3,"file":"slots.d.ts","sourceRoot":"","sources":["../../src/lib/slots.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAE9E,eAAO,MAAM,oBAAoB,UAAU,CAAA;AAE3C,kGAAkG;AAClG,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAExD;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAKhE;AAED,uGAAuG;AACvG,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAItD;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,MAAM,GAAG,SAAS,GACxB;IAAE,QAAQ,CAAC,EAAE,cAAc,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAiB/D;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,cAAc,EAAE,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,GACrD;IAAE,QAAQ,EAAE,cAAc,GAAG,SAAS,CAAC;IAAC,cAAc,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,GAAG,IAAI,CAQrF"}