@pascal-app/nodes 1.0.4 → 1.0.6

package/dist/shared/run-direction-feedback.js

@@ -1,139 +0,0 @@
-'use client';
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { EDITOR_LAYER } from '@pascal-app/editor';
-import { useThree } from '@react-three/fiber';
-import { useMemo } from 'react';
-import { OrthographicCamera, Quaternion, Vector3 } from 'three';
-const WORLD_DIRECTIONS = Array.from({ length: 8 }, (_, index) => {
-    const angle = (index * Math.PI) / 4;
-    return [Math.cos(angle), 0, Math.sin(angle)];
-});
-function horizontalDirection(direction) {
-    const length = Math.hypot(direction[0], direction[2]);
-    return length < 1e-6 ? null : [direction[0] / length, 0, direction[2] / length];
-}
-function normalizedDirection(direction) {
-    const length = Math.hypot(direction[0], direction[1], direction[2]);
-    if (length < 1e-6)
-        return null;
-    const normalized = direction.map((component) => component / length);
-    return normalized.map((component) => (Math.abs(component) < 1e-12 ? 0 : component));
-}
-function cross(a, b) {
-    return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
-}
-export function run3DDirectionCandidates(sourceDirection) {
-    const source = normalizedDirection(sourceDirection);
-    if (!source)
-        return [];
-    const reference = Math.abs(source[1]) < 0.95 ? [0, 1, 0] : [1, 0, 0];
-    const lateral = normalizedDirection(cross(source, reference));
-    if (!lateral)
-        return [source];
-    const upright = normalizedDirection(cross(lateral, source));
-    if (!upright)
-        return [source];
-    const candidates = [source];
-    for (const perpendicular of [upright, lateral]) {
-        for (const sign of [1, -1]) {
-            const turn = [
-                perpendicular[0] * sign,
-                perpendicular[1] * sign,
-                perpendicular[2] * sign,
-            ].map((component) => (Math.abs(component) < 1e-12 ? 0 : component));
-            candidates.push(turn);
-            const diagonal = normalizedDirection([
-                source[0] + turn[0],
-                source[1] + turn[1],
-                source[2] + turn[2],
-            ]);
-            if (diagonal)
-                candidates.push(diagonal);
-        }
-    }
-    return candidates;
-}
-export function runHorizontalDirectionCandidates(sourceDirection) {
-    if (!sourceDirection)
-        return WORLD_DIRECTIONS;
-    const source = horizontalDirection(sourceDirection);
-    if (!source)
-        return WORLD_DIRECTIONS;
-    const angle = Math.atan2(source[2], source[0]);
-    return [-Math.PI / 2, -Math.PI / 4, 0, Math.PI / 4, Math.PI / 2].map((offset) => [
-        Math.cos(angle + offset),
-        0,
-        Math.sin(angle + offset),
-    ]);
-}
-export function resolveRunDirectionCandidates(start, cursor, sourceDirection, mode) {
-    const delta = [cursor[0] - start[0], cursor[1] - start[1], cursor[2] - start[2]];
-    if (mode === 'vertical') {
-        const activeSign = delta[1] < 0 ? -1 : 1;
-        return [1, -1].map((sign) => ({
-            direction: [0, sign, 0],
-            active: sign === activeSign,
-        }));
-    }
-    const directions = sourceDirection
-        ? run3DDirectionCandidates(sourceDirection)
-        : runHorizontalDirectionCandidates(null);
-    let activeIndex = -1;
-    const pointerDirection = normalizedDirection(delta);
-    if (pointerDirection && mode === 'angle') {
-        let bestDot = Number.NEGATIVE_INFINITY;
-        for (let index = 0; index < directions.length; index++) {
-            const direction = directions[index];
-            const dot = direction[0] * pointerDirection[0] +
-                direction[1] * pointerDirection[1] +
-                direction[2] * pointerDirection[2];
-            if (dot > bestDot) {
-                bestDot = dot;
-                activeIndex = index;
-            }
-        }
-    }
-    return directions.map((direction, index) => ({ direction, active: index === activeIndex }));
-}
-export function RunDirectionFeedback({ start, cursor, sourceDirection, mode, snapped, onDirectionSelect, }) {
-    const candidates = useMemo(() => resolveRunDirectionCandidates(start, cursor, sourceDirection, mode), [cursor, mode, sourceDirection, start]);
-    const distance = Math.hypot(cursor[0] - start[0], cursor[1] - start[1], cursor[2] - start[2]);
-    const candidateLength = Math.min(1.8, Math.max(0.7, distance * 0.7));
-    const activeColor = snapped ? '#22c55e' : '#818cf8';
-    return (_jsxs("group", { children: [candidates.map((candidate, index) => (_jsx(DirectionRay, { active: candidate.active, color: candidate.active ? activeColor : '#818cf8', direction: candidate.direction, length: candidate.active ? Math.max(distance, candidateLength) : candidateLength, origin: start, onDirectionSelect: onDirectionSelect }, `${index}:${candidate.direction.join(':')}`))), distance > 0.01 && mode !== 'angle' && mode !== 'vertical' && (_jsx(DirectionRay, { active: true, color: activeColor, direction: [
-                    (cursor[0] - start[0]) / distance,
-                    (cursor[1] - start[1]) / distance,
-                    (cursor[2] - start[2]) / distance,
-                ], length: distance, origin: start, onDirectionSelect: onDirectionSelect }))] }));
-}
-function DirectionRay({ origin, direction, length, active, color, onDirectionSelect, }) {
-    const { camera } = useThree();
-    const zoomScale = camera instanceof OrthographicCamera ? 1 / camera.zoom : 1;
-    const placement = useMemo(() => {
-        const axis = new Vector3(direction[0], direction[1], direction[2]).normalize();
-        const start = new Vector3(origin[0], origin[1] + 0.015, origin[2]);
-        const end = start.clone().addScaledVector(axis, length);
-        return {
-            midpoint: start.clone().add(end).multiplyScalar(0.5).toArray(),
-            tip: end.toArray(),
-            rotation: new Quaternion().setFromUnitVectors(new Vector3(0, 1, 0), axis),
-        };
-    }, [direction, length, origin]);
-    const radius = (active ? 0.012 : 0.006) * zoomScale;
-    const arrowLength = (active ? 0.1 : 0.07) * zoomScale;
-    const arrowRadius = (active ? 0.04 : 0.025) * zoomScale;
-    const opacity = active ? 0.9 : 0.18;
-    return (_jsxs("group", { children: [_jsxs("mesh", { layers: EDITOR_LAYER, position: placement.midpoint, quaternion: placement.rotation, scale: [radius, length, radius], renderOrder: active ? 4 : 2, onPointerDown: (event) => {
-                    if (!onDirectionSelect)
-                        return;
-                    event.stopPropagation();
-                    event.nativeEvent.stopImmediatePropagation();
-                    onDirectionSelect([...direction]);
-                }, children: [_jsx("cylinderGeometry", { args: [1, 1, 1, 8] }), _jsx("meshBasicMaterial", { color: color, depthTest: false, depthWrite: false, opacity: opacity, transparent: true })] }), _jsxs("mesh", { layers: EDITOR_LAYER, position: placement.tip, quaternion: placement.rotation, scale: [arrowRadius, arrowLength, arrowRadius], renderOrder: active ? 4 : 2, onPointerDown: (event) => {
-                    if (!onDirectionSelect)
-                        return;
-                    event.stopPropagation();
-                    event.nativeEvent.stopImmediatePropagation();
-                    onDirectionSelect([...direction]);
-                }, children: [_jsx("coneGeometry", { args: [1, 1, 10] }), _jsx("meshBasicMaterial", { color: color, depthTest: false, depthWrite: false, opacity: opacity, transparent: true })] })] }));
-}

package/dist/shared/run-port-snap.d.ts

@@ -1,11 +0,0 @@
-import type { ScenePort } from './ports';
-export type PortScreenPoint = {
-    x: number;
-    y: number;
-    depth: number;
-};
-export declare function findScreenPort(ports: readonly ScenePort[], pointer: readonly [number, number], project: (point: ScenePort['position']) => PortScreenPoint | null, source: Pick<ScenePort, 'nodeId' | 'id'> | null, radius?: number): {
-    port: ScenePort;
-    screen: PortScreenPoint;
-} | null;
-//# sourceMappingURL=run-port-snap.d.ts.map

package/dist/shared/run-port-snap.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"run-port-snap.d.ts","sourceRoot":"","sources":["../../src/shared/run-port-snap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAExC,MAAM,MAAM,eAAe,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAErE,wBAAgB,cAAc,CAC5B,KAAK,EAAE,SAAS,SAAS,EAAE,EAC3B,OAAO,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EAClC,OAAO,EAAE,CAAC,KAAK,EAAE,SAAS,CAAC,UAAU,CAAC,KAAK,eAAe,GAAG,IAAI,EACjE,MAAM,EAAE,IAAI,CAAC,SAAS,EAAE,QAAQ,GAAG,IAAI,CAAC,GAAG,IAAI,EAC/C,MAAM,SAAK,GACV;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,eAAe,CAAA;CAAE,GAAG,IAAI,CAcrD"}

package/dist/shared/run-port-snap.js

@@ -1,19 +0,0 @@
-export function findScreenPort(ports, pointer, project, source, radius = 16) {
-    let best = null;
-    let distance = radius;
-    for (const port of ports) {
-        if (source?.nodeId === port.nodeId && source.id === port.id)
-            continue;
-        const screen = project(port.position);
-        if (!screen)
-            continue;
-        const nextDistance = Math.hypot(screen.x - pointer[0], screen.y - pointer[1]);
-        if (!Number.isFinite(nextDistance) || nextDistance > distance)
-            continue;
-        if (best && nextDistance === distance && screen.depth >= best.screen.depth)
-            continue;
-        best = { port, screen };
-        distance = nextDistance;
-    }
-    return best;
-}

package/dist/shared/run-screen-direction.d.ts

@@ -1,5 +0,0 @@
-type Point2 = readonly [number, number];
-export declare function screenDirectionScore(origin: Point2, tip: Point2, pointer: Point2): number;
-export declare function chooseScreenDirection(scores: readonly number[], previous: number): number;
-export {};
-//# sourceMappingURL=run-screen-direction.d.ts.map

package/dist/shared/run-screen-direction.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"run-screen-direction.d.ts","sourceRoot":"","sources":["../../src/shared/run-screen-direction.ts"],"names":[],"mappings":"AAAA,KAAK,MAAM,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAEvC,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAYzF;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAazF"}

package/dist/shared/run-screen-direction.js

@@ -1,24 +0,0 @@
-export function screenDirectionScore(origin, tip, pointer) {
-    const dx = tip[0] - origin[0], dy = tip[1] - origin[1];
-    const length = Math.hypot(dx, dy);
-    if (length < 2)
-        return Infinity;
-    const px = pointer[0] - origin[0], py = pointer[1] - origin[1];
-    const distance = Math.hypot(px, py);
-    if (px * dx + py * dy <= 0 || distance < 4)
-        return Infinity;
-    return (Math.hypot(px / distance - dx / length, py / distance - dy / length) * Math.min(distance, 100));
-}
-export function chooseScreenDirection(scores, previous) {
-    let best = -1;
-    for (let i = 0; i < scores.length; i++) {
-        if (Number.isFinite(scores[i]) && (best < 0 || scores[i] < scores[best]))
-            best = i;
-    }
-    if (best >= 0 &&
-        previous >= 0 &&
-        Number.isFinite(scores[previous]) &&
-        scores[previous] <= scores[best] + 4)
-        return previous;
-    return best;
-}

package/dist/site/setbacks.d.ts

@@ -1,33 +0,0 @@
-/**
- * The setback envelope in the 3D site — the same rules the site plan draws
- * (packages/editor/src/lib/floorplan/site-plan/geometry.ts: front edge,
- * edge roles, per-role setbacks, offset-line intersections), ported here
- * because the nodes package cannot import the editor. Pure. When the site
- * has setbacks, the 3D view draws them black and dashed.
- */
-export type Pt = readonly [number, number];
-export type EdgeRole = 'front' | 'rear' | 'left' | 'right' | 'street';
-export type SetbackInputs = {
-    front: number;
-    side: number;
-    rear: number;
-    left?: number;
-    right?: number;
-    /** A corner lot's second street side; absent = the front setback. */
-    streetSide?: number;
-};
-export declare function polygonArea(points: readonly Pt[]): number;
-export declare function isCounterClockwise(points: readonly Pt[]): boolean;
-/** Unit normal of edge i pointing OUT of the polygon (away from its centroid). */
-export declare function outwardNormal(points: readonly Pt[], i: number): Pt;
-/** The most north-facing edge (plan up = −z = north, turned by `northRotation`). */
-export declare function mostNorthFacingEdge(points: readonly Pt[], northRotation?: number): number;
-export declare function resolveFrontEdge(points: readonly Pt[], frontEdge: number | undefined, northRotation?: number): number;
-export declare function classifyEdges(points: readonly Pt[], frontIndex: number, streetEdges?: readonly number[]): EdgeRole[];
-export declare function setbackForRole(setbacks: SetbackInputs, role: EdgeRole): number;
-/** The buildable envelope: every edge pushed inward by its role's setback (see the editor's copy for the rules). */
-export declare function setbackEnvelope(points: readonly Pt[], setbacks: SetbackInputs, frontIndex: number, options?: {
-    streetEdges?: readonly number[];
-    sightTriangleM?: number;
-}): Pt[];
-//# sourceMappingURL=setbacks.d.ts.map

package/dist/site/setbacks.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"setbacks.d.ts","sourceRoot":"","sources":["../../src/site/setbacks.ts"],"names":[],"mappings":"AACA;;;;;;GAMG;AACH,MAAM,MAAM,EAAE,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAC1C,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAA;AACrE,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,qEAAqE;IACrE,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAID,wBAAgB,WAAW,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,GAAG,MAAM,CAQzD;AAYD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,GAAG,OAAO,CAEjE;AAED,kFAAkF;AAClF,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,EAAE,CAwBlE;AAED,oFAAoF;AACpF,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,aAAa,SAAI,GAAG,MAAM,CAcpF;AAED,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,SAAS,EAAE,EAAE,EACrB,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,aAAa,SAAI,GAChB,MAAM,CASR;AAED,wBAAgB,aAAa,CAC3B,MAAM,EAAE,SAAS,EAAE,EAAE,EACrB,UAAU,EAAE,MAAM,EAClB,WAAW,GAAE,SAAS,MAAM,EAAO,GAClC,QAAQ,EAAE,CAmDZ;AAED,wBAAgB,cAAc,CAAC,QAAQ,EAAE,aAAa,EAAE,IAAI,EAAE,QAAQ,GAAG,MAAM,CAa9E;AAED,oHAAoH;AACpH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,SAAS,EAAE,EAAE,EACrB,QAAQ,EAAE,aAAa,EACvB,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE;IAAE,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CAAO,GACzE,EAAE,EAAE,CAwDN"}

package/dist/site/setbacks.js

@@ -1,204 +0,0 @@
-import { arcRuns, insetPolygon, sightTriangle, streetCorners } from '@pascal-app/core';
-const EPS = 1e-9;
-export function polygonArea(points) {
-    let a = 0;
-    for (let i = 0; i < points.length; i++) {
-        const p = points[i];
-        const q = points[(i + 1) % points.length];
-        a += p[0] * q[1] - q[0] * p[1];
-    }
-    return Math.abs(a) / 2;
-}
-function signedArea(points) {
-    let a = 0;
-    for (let i = 0; i < points.length; i++) {
-        const p = points[i];
-        const q = points[(i + 1) % points.length];
-        a += p[0] * q[1] - q[0] * p[1];
-    }
-    return a / 2;
-}
-export function isCounterClockwise(points) {
-    return signedArea(points) > 0;
-}
-/** Unit normal of edge i pointing OUT of the polygon (away from its centroid). */
-export function outwardNormal(points, i) {
-    const n = points.length;
-    const p = points[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;
-    let nx = -dy / len;
-    let ny = dx / len;
-    let cx = 0;
-    let cy = 0;
-    for (const pt of points) {
-        cx += pt[0];
-        cy += pt[1];
-    }
-    cx /= n;
-    cy /= n;
-    const mx = (p[0] + q[0]) / 2;
-    const my = (p[1] + q[1]) / 2;
-    if ((mx - cx) * nx + (my - cy) * ny < 0) {
-        nx = -nx;
-        ny = -ny;
-    }
-    return [nx, ny];
-}
-/** The most north-facing edge (plan up = −z = north, turned by `northRotation`). */
-export function mostNorthFacingEdge(points, northRotation = 0) {
-    let best = 0;
-    let bestScore = Number.POSITIVE_INFINITY;
-    for (let i = 0; i < points.length; i++) {
-        const [nx, ny] = outwardNormal(points, i);
-        // heading of the outward normal, degrees clockwise from north
-        const heading = (((Math.atan2(nx, -ny) - northRotation) * 180) / Math.PI + 360) % 360;
-        const off = Math.min(heading, 360 - heading);
-        if (off < bestScore) {
-            bestScore = off;
-            best = i;
-        }
-    }
-    return best;
-}
-export function resolveFrontEdge(points, frontEdge, northRotation = 0) {
-    if (typeof frontEdge === 'number' &&
-        Number.isInteger(frontEdge) &&
-        frontEdge >= 0 &&
-        frontEdge < points.length)
-        return frontEdge;
-    return mostNorthFacingEdge(points, northRotation);
-}
-export function classifyEdges(points, frontIndex, streetEdges = []) {
-    const n = points.length;
-    const roles = new Array(n).fill('left');
-    if (n === 0)
-        return roles;
-    const front = ((frontIndex % n) + n) % n;
-    const fn = outwardNormal(points, front);
-    // a corner lot's other street edges (the parcel fabric's frontage) are
-    // 'street' — they take the street-side setback, never a side yard, and
-    // the rear is never one of them
-    const street = new Set(streetEdges.map((i) => ((i % n) + n) % n));
-    street.delete(front);
-    let rear = -1;
-    let rearDot = Number.POSITIVE_INFINITY;
-    for (let i = 0; i < n; i++) {
-        if (i === front || street.has(i))
-            continue;
-        const ni = outwardNormal(points, i);
-        const dot = fn[0] * ni[0] + fn[1] * ni[1];
-        if (dot < rearDot) {
-            rearDot = dot;
-            rear = i;
-        }
-    }
-    const fp = points[front];
-    const fq = points[(front + 1) % n];
-    const dx = fq[0] - fp[0];
-    const dy = fq[1] - fp[1];
-    const len = Math.hypot(dx, dy) || 1;
-    const ux = dx / len;
-    const uy = dy / len;
-    const fmx = (fp[0] + fq[0]) / 2;
-    const fmy = (fp[1] + fq[1]) / 2;
-    for (let i = 0; i < n; i++) {
-        if (i === front) {
-            roles[i] = 'front';
-            continue;
-        }
-        if (street.has(i)) {
-            roles[i] = 'street';
-            continue;
-        }
-        if (i === rear) {
-            roles[i] = 'rear';
-            continue;
-        }
-        const p = points[i];
-        const q = points[(i + 1) % n];
-        const mx = (p[0] + q[0]) / 2 - fmx;
-        const my = (p[1] + q[1]) / 2 - fmy;
-        roles[i] = mx * ux + my * uy < 0 ? 'left' : 'right';
-    }
-    return roles;
-}
-export function setbackForRole(setbacks, role) {
-    switch (role) {
-        case 'front':
-            return setbacks.front;
-        case 'street':
-            return setbacks.streetSide ?? setbacks.front;
-        case 'rear':
-            return setbacks.rear;
-        case 'left':
-            return setbacks.left ?? setbacks.side;
-        case 'right':
-            return setbacks.right ?? setbacks.side;
-    }
-}
-/** The buildable envelope: every edge pushed inward by its role's setback (see the editor's copy for the rules). */
-export function setbackEnvelope(points, setbacks, frontIndex, options = {}) {
-    const n = points.length;
-    if (n < 3)
-        return [];
-    const streetEdges = options.streetEdges ?? [];
-    const roles = classifyEdges(points, frontIndex, streetEdges);
-    // A radius drawn as a run of short edges takes ONE role. A curb return
-    // is street frontage: a run carrying, or touching, a front / street edge
-    // is front / street all along (otherwise the last sliver of the return
-    // became a side yard, and the envelope jutted out toward the corner); a
-    // run carrying the rear is rear; else each sliver keeps its own side.
-    const runs = arcRuns(points);
-    const runRole = new Map();
-    const streetLike = (r) => r === 'front' || r === 'street';
-    for (let i = 0; i < n; i++) {
-        const r = roles[i];
-        const g = runs[i];
-        const have = runRole.get(g);
-        if (streetLike(r) || (r === 'rear' && !(have && streetLike(have))))
-            runRole.set(g, r);
-        else if (!have)
-            runRole.set(g, r);
-    }
-    for (let i = 0; i < n; i++) {
-        const g = runs[i];
-        const have = runRole.get(g);
-        if (streetLike(have))
-            continue;
-        const before = roles[(i - 1 + n) % n];
-        const after = roles[(i + 1) % n];
-        const members = runs.filter((x) => x === g).length;
-        if (members > 1) {
-            if (runs[(i - 1 + n) % n] !== g && streetLike(before))
-                runRole.set(g, before);
-            else if (runs[(i + 1) % n] !== g && streetLike(after))
-                runRole.set(g, after);
-        }
-    }
-    const distances = [];
-    for (let i = 0; i < n; i++) {
-        const role = runRole.get(runs[i]) ?? roles[i];
-        const d = setbackForRole(setbacks, role === 'left' || role === 'right' ? roles[i] : role);
-        if (!Number.isFinite(d) || d < 0)
-            return [];
-        distances.push(d);
-    }
-    // the corner sight triangles keep the envelope out of the clear-vision
-    // zone at each street intersection (the hypotenuse is a half-plane)
-    const keepOut = [];
-    if (options.sightTriangleM && options.sightTriangleM > 0) {
-        for (const [a, b] of streetCorners(points, [frontIndex, ...streetEdges])) {
-            const tri = sightTriangle(points, a, b, options.sightTriangleM);
-            if (tri)
-                keepOut.push({ a: tri.a, b: tri.b, inside: tri.corner });
-        }
-    }
-    // the true inward offset (core setback-envelope.ts): straight where the
-    // lot is straight, concentric round a radius, clipped where the offsets
-    // cross — the industry-standard setback for pie shapes, radius corners
-    // and odd lots
-    return insetPolygon(points, distances, { keepOut });
-}