@pascal-app/nodes 1.0.7 → 1.1.1

package/dist/item/definition.render.js

@@ -0,0 +1,132 @@
+import { getScaledDimensions } from '@pascal-app/core';
+import { itemMechanism } from '../shared/item-interactions.js';
+import { itemBatchable } from '../shared/node-batch/batchable.js';
+import { authoredItemFaceHost } from './authored-face-host.js';
+import { buildItemFloorplan } from './floorplan.js';
+import { ItemNode } from './schema.js';
+export const itemRenderDefinition = {
+    kind: 'item',
+    schemaVersion: 2,
+    schema: ItemNode,
+    category: 'furnish',
+    surfaceRole: 'furnishing',
+    // Defaults shape is cast: the schema requires a fully-typed `asset`
+    // field, but in practice items are always created from the catalog
+    // (the asset is supplied at placement time). `createNode` re-parses
+    // through the schema, so any missing zod defaults fill at runtime.
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        children: [],
+        position: [0, 0, 0],
+        rotation: [0, 0, 0],
+        scale: [1, 1, 1],
+        asset: {
+            id: 'placeholder',
+            category: 'misc',
+            name: 'Item',
+            thumbnail: '',
+            src: 'asset:placeholder',
+            dimensions: [1, 1, 1],
+            source: 'library',
+        },
+    }),
+    capabilities: {
+        reveal: { phase: 'furnishing', style: 'drop', height: 0.3 },
+        revealOnEdit: ['scale'],
+        batchable: itemBatchable,
+        selectable: { hitVolume: 'bbox' },
+        // Authored objects host ceiling items on their undersides; catalog items do not.
+        faceHost: authoredItemFaceHost,
+        surfaces: {
+            top: {
+                height: (node) => {
+                    const item = node;
+                    return (item.asset.surface?.height ?? item.asset.dimensions[1]) * item.scale[1];
+                },
+            },
+        },
+        duplicable: { subtree: 'with-children' },
+        deletable: true,
+        mechanism: itemMechanism,
+        // Items participate in compositions — e.g. "table-with-plants",
+        // "shelf-with-books-on-top" — so they're presettable in their own
+        // right (and as descendants of presettable parents). The GLB-kind
+        // catalog still exists alongside; preset-flavoured items become
+        // siblings of GLB items inside the unified `items` table.
+        //
+        // Items can be hosted on walls (assets with `attachTo: 'wall'`)
+        // via `wallId` + `wallT`, or on a roof-segment wall face via
+        // `roofSegmentId`. When a composition that includes a wall-hosted
+        // item is saved as a preset (a sconce, a hanging shelf, etc.), the
+        // host app strips these via `getHostRefFields(def)` so the
+        // descendant re-attaches against the new host geometry at
+        // placement time.
+        hostRefFields: ['wallId', 'wallT', 'roofSegmentId', 'roofFace', 'blockFaceId'],
+        // Floor items get lifted by slabs underneath via the generic
+        // `<FloorElevationSystem>`. Wall- / ceiling-attached items live in
+        // their parent's local frame and skip the lift via `applies`.
+        floorPlaced: {
+            footprint: (node) => {
+                const item = node;
+                return { dimensions: getScaledDimensions(item), rotation: item.rotation };
+            },
+            applies: (node) => !node.asset.attachTo,
+            collides: true,
+        },
+        // Recessed ceiling fixtures cut a hole in their host ceiling. The viewer's
+        // CeilingSystem queries this capability on each child of a ceiling so it
+        // never needs to branch on `node.type`.
+        ceilingCut: {
+            buildCeilingHole(rawNode) {
+                const node = rawNode;
+                if (!node.asset.recessed || node.asset.attachTo !== 'ceiling')
+                    return null;
+                // Inset slightly so the fixture's trim (widest part, sitting in the
+                // ceiling plane) overlaps the solid ceiling around the opening and hides
+                // the cut edge. Same constant the old ceiling-system used.
+                const INSET = 0.82;
+                const [width, , depth] = getScaledDimensions(node);
+                const halfW = (width / 2) * INSET;
+                const halfD = (depth / 2) * INSET;
+                const cx = node.position[0];
+                const cz = node.position[2];
+                const yaw = node.rotation?.[1] ?? 0;
+                const cos = Math.cos(yaw);
+                const sin = Math.sin(yaw);
+                // Rotate the (inset) footprint corners about Y and translate to the
+                // item's plan position. Y-rotation of (dx, dz): (dx·cos + dz·sin, −dx·sin + dz·cos).
+                return [
+                    [-halfW, -halfD],
+                    [halfW, -halfD],
+                    [halfW, halfD],
+                    [-halfW, halfD],
+                ].map(([dx, dz]) => [cx + dx * cos + dz * sin, cz - dx * sin + dz * cos]);
+            },
+        },
+    },
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    system: {
+        module: () => import('./system.js'),
+        // Same priority as the legacy ItemSystem.
+        priority: 2,
+    },
+    // Stage C: floor-plan polygon. ctx.resolve walks the parent chain
+    // (wall / nested item / level) to compute the world-space transform.
+    floorplan: buildItemFloorplan,
+    presentation: {
+        label: 'Item',
+        description: 'A catalog-backed item (furniture, fixtures, decorations).',
+        icon: { kind: 'url', src: '/icons/item.webp' },
+        paletteSection: 'furnish',
+        paletteOrder: 10,
+    },
+    mcp: {
+        description: 'A catalog-backed item with asset reference, transforms, and optional attachTo for wall/ceiling mounting.',
+    },
+};

package/dist/item/floorplan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/item/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAOpB,KAAK,QAAQ,EAKd,MAAM,kBAAkB,CAAA;AASzB;;;;;;;;;;;;;;GAcG;AACH,KAAK,SAAS,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAA;AA2D3D,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,EACpB,KAAK,sxCAAyC,GAC7C,SAAS,GAAG,IAAI,CAyKlB;AAED,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CA+C1B;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CA+HjG"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/item/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,iBAAiB,EAGtB,KAAK,eAAe,EAOpB,KAAK,QAAQ,EAOd,MAAM,kBAAkB,CAAA;AAIzB;;;;;;;;;;;;;;GAcG;AACH,KAAK,SAAS,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAA;AA2D3D,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,EACpB,KAAK,sxCAAyC,GAC7C,SAAS,GAAG,IAAI,CAyKlB;AAED,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CA+C1B;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CA+HjG"}

package/dist/item/floorplan.js

@@ -1,5 +1,4 @@
-import { getBlockFaceFrame, getEffectiveNode, getRoofWallFaceFrame, getScaledDimensions, getWallBodyCenterOffset, getWallLocalFaceZ, roofFacePointToSegment, scriptImages, useLiveTransforms, } from '@pascal-app/core';
-import { formatLinearMeasurement, readFloorplanContext, readFloorplanMetricNotationOverride, } from '@pascal-app/editor';
+import { formatLinearMeasurement, getBlockFaceFrame, getEffectiveNode, getRoofWallFaceFrame, getScaledDimensions, getWallBodyCenterOffset, getWallLocalFaceZ, readFloorplanContext, readFloorplanMetricNotationOverride, roofFacePointToSegment, scriptImages, useLiveTransforms, } from '@pascal-app/core';
 import { restingNodePlanFrame } from '../shared/resting-surface-plan.js';
 import { buildPlanItemSymbol, classifyPlanItem, PLAN_SYMBOL_METADATA_KEY } from './plan-symbols.js';
 // Plan-space rotation convention used by the legacy `rotatePlanVector`

package/dist/item/plan-symbols.js

@@ -1,4 +1,4 @@
-import { floorplanGeometryMetadata } from '@pascal-app/editor';
+import { floorplanGeometryMetadata } from '@pascal-app/core';
 /**
  * PERMIT-SET PLAN SYMBOLS for items — what a sheet draws instead of the
  * asset's raster sprite: real fixtures (sinks …) with fixture labels, as a

package/dist/item/renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/item/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAML,KAAK,QAAQ,EAad,MAAM,kBAAkB,CAAA;AA2azB,eAAO,MAAM,YAAY,wBAAyB;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAmEnE,CAAA;AA+CD,eAAO,MAAM,WAAW,aAAc;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAUvD,CAAA;AA6VD;;;;;GAKG;AACH,eAAO,MAAM,aAAa,0BAGvB;IACD,IAAI,EAAE,QAAQ,CAAA;IACd,UAAU,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;CACrC,gCAA+F,CAAA;eAEjF,YAAY"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/item/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAML,KAAK,QAAQ,EAad,MAAM,kBAAkB,CAAA;AA4azB,eAAO,MAAM,YAAY,wBAAyB;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAmEnE,CAAA;AA+CD,eAAO,MAAM,WAAW,aAAc;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAUvD,CAAA;AA6VD;;;;;GAKG;AACH,eAAO,MAAM,aAAa,0BAGvB;IACD,IAAI,EAAE,QAAQ,CAAA;IACd,UAAU,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;CACrC,gCAA+F,CAAA;eAEjF,YAAY"}

package/dist/item/renderer.js

@@ -1,7 +1,7 @@
 'use client';
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { deriveSlotId, getScaledDimensions, isCutterName, isSlotMaterialName, itemClipRegistry, LIBRARY_MATERIAL_REF_PREFIX, SCENE_MATERIAL_REF_PREFIX, sceneRegistry, toLibraryMaterialRef, useInteractive, useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
-import { catalogLightSource, configureKtx2Support, createDefaultMaterial, createSurfaceRoleMaterial, ErrorBoundary, glassMaterial, materialCastsShadow, NodeRenderer, resolveCdnUrl, resolveMaterialRef, ScriptedClips, stampPascalTextureRef, useClipActions, useItemLightPool, useNodeEvents, useViewer, } from '@pascal-app/viewer';
+import { catalogLightSource, configureKtx2Support, createDefaultMaterial, createSurfaceRoleMaterial, ErrorBoundary, getViewerConfig, glassMaterial, materialCastsShadow, NodeRenderer, resolveCdnUrl, resolveMaterialRef, ScriptedClips, stampPascalTextureRef, useClipActions, useItemLightPool, useNodeEvents, useViewer, } from '@pascal-app/viewer';
 import { useAnimations } from '@react-three/drei';
 import { Clone } from '@react-three/drei/core/Clone';
 import { useFrame, useLoader, useThree } from '@react-three/fiber';
@@ -114,8 +114,8 @@ const configureItemModelLoader = (loader, renderer) => {
     configureKtx2Support(loader, renderer);
     if (!itemDracoLoader) {
         itemDracoLoader = new DRACOLoader(loader.manager);
-        itemDracoLoader.setDecoderPath('https://www.gstatic.com/draco/versioned/decoders/1.5.5/');
     }
+    itemDracoLoader.setDecoderPath(getViewerConfig().decoders.dracoPath);
     loader.setDRACOLoader(itemDracoLoader);
 };
 const ITEM_TEXTURE_SLOTS = [

package/dist/lean-to-extension/definition.d.ts

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

package/dist/lean-to-extension/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/lean-to-extension/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,cAAc,EAIpB,MAAM,kBAAkB,CAAA;AAqBzB,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAuZ9C,eAAO,MAAM,yBAAyB,EAAE,cAAc,CAAC,OAAO,mBAAmB,CAuEhF,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/lean-to-extension/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAGrC,CAAA"}

package/dist/lean-to-extension/definition.edit.d.ts

@@ -0,0 +1,4 @@
+import type { LeanToExtensionNode } from './schema.js';
+import type { NodeEditContribution } from '../definition-contributions.js';
+export declare const leanToExtensionEditContribution: NodeEditContribution<typeof LeanToExtensionNode>;
+//# sourceMappingURL=definition.edit.d.ts.map

package/dist/lean-to-extension/definition.edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/lean-to-extension/definition.edit.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAuZnD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AACvE,eAAO,MAAM,+BAA+B,EAAE,oBAAoB,CAAC,OAAO,mBAAmB,CA6B5F,CAAA"}