@pascal-app/core 1.0.0-beta.5 → 1.0.0

package/dist/schema/nodes/gutter.js

@@ -2,6 +2,13 @@ import dedent from 'dedent';
 import { z } from 'zod';
 import { BaseNode, nodeType, objectId } from '../base';
 import { MaterialSchema } from '../material';
+import { normalizeRoofSegmentTrim } from './roof-segment';
+import { getRoofShapeEaveSides } from './roof-segment-shape';
+const MIN_DEFAULT_GUTTER_LENGTH_M = 0.2;
+const DEFAULT_GUTTER_GENERATOR = 'default-gutter';
+const AUTO_GUTTER_METADATA_KEY = 'autoGutter';
+export const GUTTER_EAVE_TUCK_INWARD = 0.04;
+export const GUTTER_EAVE_TUCK_UP = 0.04;
 // A single drop outlet drilled in the gutter floor. A gutter can carry
 // several so a long run can split between multiple downspouts (each
 // downspout links to one outlet via its `outletId`).
@@ -15,11 +22,13 @@ export const GutterOutlet = z.object({
     // Bore diameter of this drop. Default 0.07 m ≈ 3″. The cross-section
     // SHAPE (round vs rectangular) follows the gutter's profile, not this.
     diameter: z.number().default(0.07),
+    generatedBy: z.literal('default-downspout').optional(),
 });
 export const GutterNode = BaseNode.extend({
     id: objectId('gutter'),
     type: nodeType('gutter'),
     material: MaterialSchema.optional(),
+    slots: z.record(z.string(), z.string()).optional(),
     // White preset by default — matches the rest of the roof accessory
     // family (box-vent / ridge-vent) so the paint inspector reads as
     // "White" instead of "no material" on a freshly-placed gutter.
@@ -35,8 +44,19 @@ export const GutterNode = BaseNode.extend({
     // direction (segment-local +X) — but exposed in case the user wants
     // to tilt for a custom run.
     rotation: z.number().default(0),
-    // Length along the eave (gutter-local +X).
+    // Length along the eave (gutter-local +X). For a curved eave this is the
+    // arc length of the run.
     length: z.number().default(2.0),
+    // Concentric-arc descriptor for a run that follows a curved eave, in
+    // gutter-mesh-local coordinates (center + true radius). Absent for a straight
+    // gutter.
+    arc: z
+        .object({
+        centerX: z.number(),
+        centerZ: z.number(),
+        radius: z.number(),
+    })
+        .optional(),
     // Profile size — the vertical drop of the U-channel below the eave
     // line. 5″ (0.127 m) is the most common residential gutter size; 6″
     // (0.152 m) is the common commercial / heavy-duty size. Default
@@ -74,3 +94,290 @@ export const GutterNode = BaseNode.extend({
   - hangerStyle / hangerSpacing: visible metal straps across the rim
   - outlets: drop-tube outlets (id + along-length offset + bore diameter)
   `);
+function metadataRecord(metadata) {
+    if (typeof metadata === 'object' && metadata !== null && !Array.isArray(metadata)) {
+        return metadata;
+    }
+    return {};
+}
+export function computeGutterEaveY(segment) {
+    const wallHeight = segment.wallHeight ?? 0;
+    if ((segment.roofType ?? 'gable') === 'flat')
+        return wallHeight;
+    const pitchRad = ((segment.pitch ?? 0) * Math.PI) / 180;
+    return wallHeight - (segment.overhang ?? 0) * Math.tan(pitchRad) + GUTTER_EAVE_TUCK_UP;
+}
+function getDefaultGutterSides(segment) {
+    return getRoofShapeEaveSides(segment.roofType);
+}
+function getGutterEnvelope(segment) {
+    const halfW = Math.max(0, segment.width) / 2;
+    const halfD = Math.max(0, segment.depth) / 2;
+    const overhang = Math.max(0, segment.overhang ?? 0);
+    const outerHalfW = Math.max(halfW, halfW + overhang - GUTTER_EAVE_TUCK_INWARD);
+    const outerHalfD = Math.max(halfD, halfD + overhang - GUTTER_EAVE_TUCK_INWARD);
+    const trim = normalizeRoofSegmentTrim(segment);
+    const minX = trim.left > 0 ? -halfW + trim.left : -outerHalfW;
+    const maxX = trim.right > 0 ? halfW - trim.right : outerHalfW;
+    const minZ = trim.back > 0 ? -halfD + trim.back : -outerHalfD;
+    const maxZ = trim.front > 0 ? halfD - trim.front : outerHalfD;
+    return { minX, maxX, minZ, maxZ, outerHalfW, outerHalfD, trim };
+}
+function getGutterEnvelopePolygon(segment) {
+    const { minX, maxX, minZ, maxZ, trim } = getGutterEnvelope(segment);
+    return [
+        [minX + trim.backLeftX, minZ],
+        [maxX - trim.backRightX, minZ],
+        [maxX, minZ + trim.backRightZ],
+        [maxX, maxZ - trim.frontRightZ],
+        [maxX - trim.frontRightX, maxZ],
+        [minX + trim.frontLeftX, maxZ],
+        [minX, maxZ - trim.frontLeftZ],
+        [minX, minZ + trim.backLeftZ],
+    ];
+}
+function segmentLocalToRoof(segment, point) {
+    const rotation = segment.rotation ?? 0;
+    const cos = Math.cos(rotation);
+    const sin = Math.sin(rotation);
+    return [
+        (segment.position?.[0] ?? 0) + point[0] * cos + point[1] * sin,
+        (segment.position?.[2] ?? 0) - point[0] * sin + point[1] * cos,
+    ];
+}
+function pointOnSegment(point, a, b) {
+    const lengthSq = (b[0] - a[0]) ** 2 + (b[1] - a[1]) ** 2;
+    if (lengthSq <= 1e-14) {
+        return (point[0] - a[0]) ** 2 + (point[1] - a[1]) ** 2 <= 1e-14;
+    }
+    const cross = (point[0] - a[0]) * (b[1] - a[1]) - (point[1] - a[1]) * (b[0] - a[0]);
+    if (Math.abs(cross) > 1e-7)
+        return false;
+    const dot = (point[0] - a[0]) * (b[0] - a[0]) + (point[1] - a[1]) * (b[1] - a[1]);
+    if (dot < -1e-7)
+        return false;
+    return dot <= lengthSq + 1e-7;
+}
+function pointStrictlyInsidePolygon(point, polygon) {
+    let inside = false;
+    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+        const a = polygon[j];
+        const b = polygon[i];
+        if (pointOnSegment(point, a, b))
+            return false;
+        if (a[1] > point[1] !== b[1] > point[1] &&
+            point[0] < ((b[0] - a[0]) * (point[1] - a[1])) / (b[1] - a[1]) + a[0]) {
+            inside = !inside;
+        }
+    }
+    return inside;
+}
+function segmentCrossingT(start, end, a, b) {
+    const rx = end[0] - start[0];
+    const rz = end[1] - start[1];
+    const sx = b[0] - a[0];
+    const sz = b[1] - a[1];
+    const denominator = rx * sz - rz * sx;
+    if (Math.abs(denominator) < 1e-10)
+        return null;
+    const dx = a[0] - start[0];
+    const dz = a[1] - start[1];
+    const t = (dx * sz - dz * sx) / denominator;
+    const u = (dx * rz - dz * rx) / denominator;
+    if (t < -1e-8 || t > 1 + 1e-8 || u < -1e-8 || u > 1 + 1e-8)
+        return null;
+    return Math.max(0, Math.min(1, t));
+}
+function coveredIntervals(start, end, polygon) {
+    const splits = [0, 1];
+    for (let i = 0; i < polygon.length; i++) {
+        const t = segmentCrossingT(start, end, polygon[i], polygon[(i + 1) % polygon.length]);
+        if (t !== null)
+            splits.push(t);
+    }
+    splits.sort((a, b) => a - b);
+    const unique = splits.filter((value, index) => index === 0 || value - splits[index - 1] > 1e-7);
+    const intervals = [];
+    for (let i = 0; i < unique.length - 1; i++) {
+        const from = unique[i];
+        const to = unique[i + 1];
+        if (to - from <= 1e-7)
+            continue;
+        const middle = (from + to) / 2;
+        const point = [
+            start[0] + (end[0] - start[0]) * middle,
+            start[1] + (end[1] - start[1]) * middle,
+        ];
+        if (pointStrictlyInsidePolygon(point, polygon))
+            intervals.push([from, to]);
+    }
+    return intervals;
+}
+function subtractInterval(visible, covered) {
+    const next = [];
+    for (const [from, to] of visible) {
+        if (covered[1] <= from + 1e-7 || covered[0] >= to - 1e-7) {
+            next.push([from, to]);
+            continue;
+        }
+        if (covered[0] > from + 1e-7)
+            next.push([from, Math.min(to, covered[0])]);
+        if (covered[1] < to - 1e-7)
+            next.push([Math.max(from, covered[1]), to]);
+    }
+    return next;
+}
+function clipRunAgainstSegments(run, segment, roofSegments) {
+    const direction = [Math.cos(run.rotation), -Math.sin(run.rotation)];
+    const localStart = [
+        run.position[0] - direction[0] * (run.length / 2),
+        run.position[2] - direction[1] * (run.length / 2),
+    ];
+    const localEnd = [
+        run.position[0] + direction[0] * (run.length / 2),
+        run.position[2] + direction[1] * (run.length / 2),
+    ];
+    const roofStart = segmentLocalToRoof(segment, localStart);
+    const roofEnd = segmentLocalToRoof(segment, localEnd);
+    let visible = [[0, 1]];
+    for (const sibling of roofSegments) {
+        if (sibling.id === segment.id)
+            continue;
+        const polygon = getGutterEnvelopePolygon(sibling).map((point) => segmentLocalToRoof(sibling, point));
+        for (const covered of coveredIntervals(roofStart, roofEnd, polygon)) {
+            visible = subtractInterval(visible, covered);
+        }
+        if (visible.length === 0)
+            break;
+    }
+    return visible
+        .map(([from, to]) => {
+        const length = run.length * (to - from);
+        const middle = (from + to) / 2;
+        return {
+            ...run,
+            position: [
+                localStart[0] + (localEnd[0] - localStart[0]) * middle,
+                run.position[1],
+                localStart[1] + (localEnd[1] - localStart[1]) * middle,
+            ],
+            length,
+        };
+    })
+        .filter((candidate) => candidate.length >= MIN_DEFAULT_GUTTER_LENGTH_M);
+}
+function clipRunAgainstExclusions(run, exclusions) {
+    let visible = [[0, 1]];
+    for (const exclusion of exclusions) {
+        if (exclusion.side !== run.side)
+            continue;
+        const from = Math.max(0, Math.min(1, Math.min(exclusion.from, exclusion.to)));
+        const to = Math.max(0, Math.min(1, Math.max(exclusion.from, exclusion.to)));
+        visible = subtractInterval(visible, [from, to]);
+        if (visible.length === 0)
+            break;
+    }
+    const direction = [Math.cos(run.rotation), -Math.sin(run.rotation)];
+    const start = [
+        run.position[0] - direction[0] * (run.length / 2),
+        run.position[2] - direction[1] * (run.length / 2),
+    ];
+    return visible
+        .map(([from, to]) => {
+        const length = run.length * (to - from);
+        const middle = (from + to) / 2;
+        return {
+            ...run,
+            position: [
+                start[0] + direction[0] * run.length * middle,
+                run.position[1],
+                start[1] + direction[1] * run.length * middle,
+            ],
+            length,
+        };
+    })
+        .filter((candidate) => candidate.length >= MIN_DEFAULT_GUTTER_LENGTH_M);
+}
+export function getGutterRunsForSegment(segment, roofSegments = [], exclusions = []) {
+    const { minX, maxX, minZ, maxZ, outerHalfW, outerHalfD, trim } = getGutterEnvelope(segment);
+    const eaveY = computeGutterEaveY(segment);
+    const runs = {
+        '+Z': trim.front > 0
+            ? null
+            : {
+                side: '+Z',
+                position: [(minX + maxX) / 2, eaveY, outerHalfD],
+                rotation: 0,
+                length: maxX - minX,
+            },
+        '-Z': trim.back > 0
+            ? null
+            : {
+                side: '-Z',
+                position: [(minX + maxX) / 2, eaveY, -outerHalfD],
+                rotation: Math.PI,
+                length: maxX - minX,
+            },
+        '+X': trim.right > 0
+            ? null
+            : {
+                side: '+X',
+                position: [outerHalfW, eaveY, (minZ + maxZ) / 2],
+                rotation: Math.PI / 2,
+                length: maxZ - minZ,
+            },
+        '-X': trim.left > 0
+            ? null
+            : {
+                side: '-X',
+                position: [-outerHalfW, eaveY, (minZ + maxZ) / 2],
+                rotation: -Math.PI / 2,
+                length: maxZ - minZ,
+            },
+    };
+    const candidates = getDefaultGutterSides(segment)
+        .map((side) => runs[side])
+        .filter((run) => run !== null && run.length >= MIN_DEFAULT_GUTTER_LENGTH_M);
+    return candidates
+        .flatMap((run) => clipRunAgainstExclusions(run, exclusions))
+        .flatMap((run) => clipRunAgainstSegments(run, segment, roofSegments));
+}
+export function createDefaultGuttersForSegment(segment, roofSegments = [], exclusions = []) {
+    return getGutterRunsForSegment(segment, roofSegments, exclusions).map((run) => GutterNode.parse({
+        name: 'Gutter',
+        roofSegmentId: segment.id,
+        position: run.position,
+        rotation: run.rotation,
+        length: run.length,
+        metadata: {
+            generatedBy: DEFAULT_GUTTER_GENERATOR,
+            autoGutterSide: run.side,
+        },
+    }));
+}
+export function getDefaultGutterSide(node, roofSegmentId) {
+    const parsed = GutterNode.safeParse(node);
+    if (!parsed.success)
+        return null;
+    if (roofSegmentId && parsed.data.roofSegmentId !== roofSegmentId)
+        return null;
+    const metadata = metadataRecord(parsed.data.metadata);
+    if (metadata.generatedBy !== DEFAULT_GUTTER_GENERATOR)
+        return null;
+    const side = metadata.autoGutterSide;
+    return side === '+X' || side === '-X' || side === '+Z' || side === '-Z' ? side : null;
+}
+export function isDefaultGutterNode(node, roofSegmentId) {
+    return getDefaultGutterSide(node, roofSegmentId) !== null;
+}
+export function hasAutoGutterMetadata(segment) {
+    return typeof metadataRecord(segment.metadata)[AUTO_GUTTER_METADATA_KEY] === 'boolean';
+}
+export function isAutoGutterEnabled(segment, nodes) {
+    const metadataValue = metadataRecord(segment.metadata)[AUTO_GUTTER_METADATA_KEY];
+    if (typeof metadataValue === 'boolean')
+        return metadataValue;
+    if (!nodes)
+        return false;
+    return (segment.children ?? []).some((childId) => isDefaultGutterNode(nodes[childId], segment.id));
+}

package/dist/schema/nodes/hanger-overrides.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+export declare const HangerOverrides: z.ZodRecord<z.ZodString, z.ZodObject<{
+    fraction: z.ZodOptional<z.ZodNumber>;
+    skipped: z.ZodOptional<z.ZodBoolean>;
+    hostId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+//# sourceMappingURL=hanger-overrides.d.ts.map

package/dist/schema/nodes/hanger-overrides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hanger-overrides.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/hanger-overrides.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,eAAe;;;;kBAO3B,CAAA"}

package/dist/schema/nodes/hanger-overrides.js

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export const HangerOverrides = z.record(z.string(), z.object({
+    fraction: z.number().finite().min(0).max(1).optional(),
+    skipped: z.boolean().optional(),
+    hostId: z.string().optional(),
+}));

package/dist/schema/nodes/hvac-equipment.d.ts

@@ -28,7 +28,7 @@ export declare const HvacEquipmentNode: z.ZodObject<{
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
-    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`hvac-equipment_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"hvac-equipment">>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;

package/dist/schema/nodes/item.d.ts

@@ -154,8 +154,8 @@ declare const assetSchema: z.ZodObject<{
     dimensions: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     attachTo: z.ZodOptional<z.ZodEnum<{
         wall: "wall";
-        ceiling: "ceiling";
         "wall-side": "wall-side";
+        ceiling: "ceiling";
     }>>;
     recessed: z.ZodOptional<z.ZodBoolean>;
     tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -228,7 +228,7 @@ export declare const ItemNode: z.ZodObject<{
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
-    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`item_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"item">>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
@@ -248,6 +248,7 @@ export declare const ItemNode: z.ZodObject<{
         right: "right";
         left: "left";
     }>>;
+    blockFaceId: z.ZodOptional<z.ZodString>;
     supportSlabId: z.ZodOptional<z.ZodString>;
     collectionIds: z.ZodOptional<z.ZodArray<z.ZodCustom<`collection_${string}`, `collection_${string}`>>>;
     slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -267,8 +268,8 @@ export declare const ItemNode: z.ZodObject<{
         dimensions: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
         attachTo: z.ZodOptional<z.ZodEnum<{
             wall: "wall";
-            ceiling: "ceiling";
             "wall-side": "wall-side";
+            ceiling: "ceiling";
         }>>;
         recessed: z.ZodOptional<z.ZodBoolean>;
         tags: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/dist/schema/nodes/item.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"item.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/item.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAOvB,QAAA,MAAM,mBAAmB;;;;iBAIvB,CAAA;AAEF,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;iBASvB,CAAA;AAEF,QAAA,MAAM,wBAAwB;;;;;;;;;;iBAO5B,CAAA;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAIjB,CAAA;AAIF,QAAA,MAAM,qBAAqB;;;;;;;iBAOzB,CAAA;AAEF,QAAA,MAAM,iBAAiB;;;;;;iBAMrB,CAAA;AAEF,QAAA,MAAM,YAAY;;;;;;;;;;;;;2BAA2E,CAAA;AAI7F,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGrB,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AACzE,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AACnD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AACnE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAC3D,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AACjD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2Cf,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AACpD,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAE/C,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuDnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA;AAE/C,eAAO,MAAM,mCAAmC,MAAM,CAAA;AAEtD;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAM/D;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAI5E"}
+{"version":3,"file":"item.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/item.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAOvB,QAAA,MAAM,mBAAmB;;;;iBAIvB,CAAA;AAEF,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;iBASvB,CAAA;AAEF,QAAA,MAAM,wBAAwB;;;;;;;;;;iBAO5B,CAAA;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAIjB,CAAA;AAIF,QAAA,MAAM,qBAAqB;;;;;;;iBAOzB,CAAA;AAEF,QAAA,MAAM,iBAAiB;;;;;;iBAMrB,CAAA;AAEF,QAAA,MAAM,YAAY;;;;;;;;;;;;;2BAA2E,CAAA;AAI7F,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGrB,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AACzE,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AACnD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AACnE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAC3D,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AACjD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2Cf,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AACpD,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAE/C,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4DnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA;AAE/C,eAAO,MAAM,mCAAmC,MAAM,CAAA;AAEtD;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAM/D;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAI5E"}

package/dist/schema/nodes/item.js

@@ -115,6 +115,11 @@ export const ItemNode = BaseNode.extend({
     // mounts the node inside the face frame (`getRoofWallFaceFrame`).
     roofSegmentId: z.string().optional(),
     roofFace: z.enum(['front', 'back', 'right', 'left']).optional(),
+    // Alternative wall-like host: a planar block face. Position is
+    // FACE-LOCAL [u, v, normal offset], relative to the live face centroid.
+    // The renderer rebuilds the frame from the face normal so the item follows
+    // later edits that translate or slope the face.
+    blockFaceId: z.string().optional(),
     // Persisted floor-support host (canonical doc — the same field on other
     // floor-placed kinds and walls follows these rules). Written at
     // placement/commit ONLY when overlapping slabs disagree on elevation

package/dist/schema/nodes/lean-to-extension.d.ts

@@ -0,0 +1,212 @@
+import { z } from 'zod';
+export declare const LeanToConnectionMode: z.ZodEnum<{
+    manual: "manual";
+    auto: "auto";
+}>;
+export declare const LeanToCanopyForm: z.ZodEnum<{
+    gable: "gable";
+    mono: "mono";
+    butterfly: "butterfly";
+}>;
+export declare const LeanToHostKind: z.ZodEnum<{
+    wall: "wall";
+    "slab-edge": "slab-edge";
+    freestanding: "freestanding";
+    "conical-roof": "conical-roof";
+}>;
+export declare const LeanToRoofEdge: z.ZodEnum<{
+    "+X": "+X";
+    "-X": "-X";
+    "+Z": "+Z";
+    "-Z": "-Z";
+}>;
+export declare const LeanToResizeLock: z.ZodEnum<{
+    "preserve-high-edge": "preserve-high-edge";
+    "preserve-low-edge": "preserve-low-edge";
+    "preserve-pitch": "preserve-pitch";
+}>;
+export declare const LeanToEndCondition: z.ZodEnum<{
+    open: "open";
+    "wall-abutment": "wall-abutment";
+    joined: "joined";
+}>;
+export declare const LeanToFramingStrategy: z.ZodEnum<{
+    hidden: "hidden";
+    rafters: "rafters";
+    purlins: "purlins";
+    "covering-specific": "covering-specific";
+}>;
+export declare const LeanToHighSideMode: z.ZodEnum<{
+    "wall-ledger": "wall-ledger";
+    "independent-high-beam": "independent-high-beam";
+}>;
+export declare const LeanToPostLayoutMode: z.ZodEnum<{
+    count: "count";
+    "target-spacing": "target-spacing";
+}>;
+export declare const LeanToFootingStyle: z.ZodEnum<{
+    none: "none";
+    "base-plate": "base-plate";
+    "concrete-pad": "concrete-pad";
+}>;
+export declare const LeanToCoveringType: z.ZodEnum<{
+    generic: "generic";
+    shingle: "shingle";
+    "metal-panel": "metal-panel";
+}>;
+export type LeanToConnectionMode = z.infer<typeof LeanToConnectionMode>;
+export type LeanToCanopyForm = z.infer<typeof LeanToCanopyForm>;
+export type LeanToRoofEdge = z.infer<typeof LeanToRoofEdge>;
+export declare const LeanToExtensionNode: z.ZodObject<{
+    object: z.ZodDefault<z.ZodLiteral<"node">>;
+    name: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    visible: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    camera: z.ZodOptional<z.ZodObject<{
+        position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        target: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            perspective: "perspective";
+            orthographic: "orthographic";
+        }>>;
+        fov: z.ZodOptional<z.ZodNumber>;
+        zoom: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`leanto_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"lean-to-extension">>;
+    position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    rotation: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    children: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodDefault<z.ZodTemplateLiteral<`column_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`roof_${string}`>>]>>>;
+    canopyForm: z.ZodDefault<z.ZodEnum<{
+        gable: "gable";
+        mono: "mono";
+        butterfly: "butterfly";
+    }>>;
+    hostKind: z.ZodDefault<z.ZodEnum<{
+        wall: "wall";
+        "slab-edge": "slab-edge";
+        freestanding: "freestanding";
+        "conical-roof": "conical-roof";
+    }>>;
+    hostHeightOffset: z.ZodDefault<z.ZodNumber>;
+    hostSlabId: z.ZodOptional<z.ZodDefault<z.ZodTemplateLiteral<`slab_${string}`>>>;
+    hostSlabEdgeIndex: z.ZodOptional<z.ZodNumber>;
+    hostSlabEdgeT: z.ZodOptional<z.ZodNumber>;
+    span: z.ZodDefault<z.ZodNumber>;
+    autoSpan: z.ZodDefault<z.ZodBoolean>;
+    projection: z.ZodDefault<z.ZodNumber>;
+    spanArcCenterZ: z.ZodOptional<z.ZodNumber>;
+    spanArcRadius: z.ZodOptional<z.ZodNumber>;
+    highEdgeHeight: z.ZodDefault<z.ZodNumber>;
+    lowEdgeHeight: z.ZodDefault<z.ZodNumber>;
+    pitch: z.ZodDefault<z.ZodNumber>;
+    resizeLock: z.ZodDefault<z.ZodEnum<{
+        "preserve-high-edge": "preserve-high-edge";
+        "preserve-low-edge": "preserve-low-edge";
+        "preserve-pitch": "preserve-pitch";
+    }>>;
+    leftEndCondition: z.ZodDefault<z.ZodEnum<{
+        open: "open";
+        "wall-abutment": "wall-abutment";
+        joined: "joined";
+    }>>;
+    rightEndCondition: z.ZodDefault<z.ZodEnum<{
+        open: "open";
+        "wall-abutment": "wall-abutment";
+        joined: "joined";
+    }>>;
+    autoMiterCorners: z.ZodDefault<z.ZodBoolean>;
+    sideFlashing: z.ZodDefault<z.ZodBoolean>;
+    flashingProjection: z.ZodDefault<z.ZodNumber>;
+    flashingHeight: z.ZodDefault<z.ZodNumber>;
+    slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    highSideMode: z.ZodDefault<z.ZodEnum<{
+        "wall-ledger": "wall-ledger";
+        "independent-high-beam": "independent-high-beam";
+    }>>;
+    ledgerVerticalOffset: z.ZodDefault<z.ZodNumber>;
+    lowBeamInset: z.ZodDefault<z.ZodNumber>;
+    gutterEnabled: z.ZodDefault<z.ZodBoolean>;
+    gutterProfile: z.ZodDefault<z.ZodEnum<{
+        box: "box";
+        "k-style": "k-style";
+        "half-round": "half-round";
+    }>>;
+    gutterSize: z.ZodDefault<z.ZodNumber>;
+    downspoutEnabled: z.ZodDefault<z.ZodBoolean>;
+    downspoutPosition: z.ZodDefault<z.ZodNumber>;
+    connectionMode: z.ZodDefault<z.ZodEnum<{
+        manual: "manual";
+        auto: "auto";
+    }>>;
+    hostRoofId: z.ZodOptional<z.ZodDefault<z.ZodTemplateLiteral<`roof_${string}`>>>;
+    hostRoofSegmentId: z.ZodOptional<z.ZodString>;
+    hostRoofEdge: z.ZodOptional<z.ZodEnum<{
+        "+X": "+X";
+        "-X": "-X";
+        "+Z": "+Z";
+        "-Z": "-Z";
+    }>>;
+    hostRoofEdgeRange: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    connectionOffset: z.ZodDefault<z.ZodNumber>;
+    connectionInset: z.ZodDefault<z.ZodNumber>;
+    matchHostRoofMaterial: z.ZodDefault<z.ZodBoolean>;
+    matchHostRoofStructure: z.ZodDefault<z.ZodBoolean>;
+    roofThickness: z.ZodDefault<z.ZodNumber>;
+    shingleThickness: z.ZodDefault<z.ZodNumber>;
+    highOverhang: z.ZodDefault<z.ZodNumber>;
+    lowOverhang: z.ZodDefault<z.ZodNumber>;
+    leftOverhang: z.ZodDefault<z.ZodNumber>;
+    rightOverhang: z.ZodDefault<z.ZodNumber>;
+    coveringType: z.ZodDefault<z.ZodEnum<{
+        generic: "generic";
+        shingle: "shingle";
+        "metal-panel": "metal-panel";
+    }>>;
+    beamWidth: z.ZodDefault<z.ZodNumber>;
+    beamHeight: z.ZodDefault<z.ZodNumber>;
+    ledgerDepth: z.ZodDefault<z.ZodNumber>;
+    ledgerHeight: z.ZodDefault<z.ZodNumber>;
+    rafterWidth: z.ZodDefault<z.ZodNumber>;
+    rafterHeight: z.ZodDefault<z.ZodNumber>;
+    rafterSpacing: z.ZodDefault<z.ZodNumber>;
+    rafterEndInset: z.ZodDefault<z.ZodNumber>;
+    framingStrategy: z.ZodDefault<z.ZodEnum<{
+        hidden: "hidden";
+        rafters: "rafters";
+        purlins: "purlins";
+        "covering-specific": "covering-specific";
+    }>>;
+    purlinWidth: z.ZodDefault<z.ZodNumber>;
+    purlinHeight: z.ZodDefault<z.ZodNumber>;
+    purlinSpacing: z.ZodDefault<z.ZodNumber>;
+    postWidth: z.ZodDefault<z.ZodNumber>;
+    postDepth: z.ZodDefault<z.ZodNumber>;
+    postCount: z.ZodDefault<z.ZodNumber>;
+    postLayoutMode: z.ZodDefault<z.ZodEnum<{
+        count: "count";
+        "target-spacing": "target-spacing";
+    }>>;
+    postSpacing: z.ZodDefault<z.ZodNumber>;
+    postInset: z.ZodDefault<z.ZodNumber>;
+    omittedPostSlots: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        side: z.ZodEnum<{
+            low: "low";
+            high: "high";
+        }>;
+        index: z.ZodNumber;
+        layoutCount: z.ZodNumber;
+    }, z.core.$strip>>>;
+    postBracing: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        knee: "knee";
+    }>>;
+    footingStyle: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        "base-plate": "base-plate";
+        "concrete-pad": "concrete-pad";
+    }>>;
+}, z.core.$strip>;
+export type LeanToExtensionNode = z.infer<typeof LeanToExtensionNode>;
+//# sourceMappingURL=lean-to-extension.d.ts.map

package/dist/schema/nodes/lean-to-extension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lean-to-extension.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/lean-to-extension.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,eAAO,MAAM,oBAAoB;;;EAA6B,CAAA;AAC9D,eAAO,MAAM,gBAAgB;;;;EAAyC,CAAA;AACtE,eAAO,MAAM,cAAc;;;;;EAAgE,CAAA;AAC3F,eAAO,MAAM,cAAc;;;;;EAAmC,CAAA;AAC9D,eAAO,MAAM,gBAAgB;;;;EAI3B,CAAA;AACF,eAAO,MAAM,kBAAkB;;;;EAA8C,CAAA;AAC7E,eAAO,MAAM,qBAAqB;;;;;EAAgE,CAAA;AAClG,eAAO,MAAM,kBAAkB;;;EAAmD,CAAA;AAClF,eAAO,MAAM,oBAAoB;;;EAAsC,CAAA;AACvE,eAAO,MAAM,kBAAkB;;;;EAAiD,CAAA;AAChF,eAAO,MAAM,kBAAkB;;;;EAAgD,CAAA;AAQ/E,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACvE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAC/D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAE3D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgG/B,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA"}