@pascal-app/core 0.6.0 → 0.8.0

package/dist/schema/types.d.ts

@@ -76,6 +76,13 @@ export declare const AnyNode: z.ZodDiscriminatedUnion<[z.ZodObject<{
             category: z.ZodString;
             name: z.ZodString;
             thumbnail: z.ZodString;
+            floorPlanUrl: z.ZodOptional<z.ZodString>;
+            source: z.ZodDefault<z.ZodEnum<{
+                library: "library";
+                community: "community";
+                mine: "mine";
+            }>>;
+            isDraft: z.ZodOptional<z.ZodBoolean>;
             src: z.ZodString;
             dimensions: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
             attachTo: z.ZodOptional<z.ZodEnum<{
@@ -175,8 +182,192 @@ export declare const AnyNode: z.ZodDiscriminatedUnion<[z.ZodObject<{
     metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`level_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"level">>;
-    children: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodDefault<z.ZodTemplateLiteral<`wall_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`fence_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`zone_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`slab_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`ceiling_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`roof_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`stair_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`scan_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`guide_${string}`>>]>>>;
+    children: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodDefault<z.ZodTemplateLiteral<`wall_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`fence_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`column_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`item_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`zone_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`slab_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`ceiling_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`roof_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`stair_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`scan_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`guide_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`spawn_${string}`>>]>>>;
     level: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, 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.ZodJSONSchema>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`column_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"column">>;
+    position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    rotation: z.ZodDefault<z.ZodNumber>;
+    style: z.ZodDefault<z.ZodEnum<{
+        plain: "plain";
+        faceted: "faceted";
+        fluted: "fluted";
+        "lathe-turned": "lathe-turned";
+        "dravidian-carved": "dravidian-carved";
+        cluster: "cluster";
+    }>>;
+    crossSection: z.ZodDefault<z.ZodEnum<{
+        round: "round";
+        square: "square";
+        rectangular: "rectangular";
+        octagonal: "octagonal";
+        "sixteen-sided": "sixteen-sided";
+    }>>;
+    height: z.ZodDefault<z.ZodNumber>;
+    radius: z.ZodDefault<z.ZodNumber>;
+    width: z.ZodDefault<z.ZodNumber>;
+    depth: z.ZodDefault<z.ZodNumber>;
+    edgeSoftness: z.ZodDefault<z.ZodNumber>;
+    baseHeight: z.ZodDefault<z.ZodNumber>;
+    capitalHeight: z.ZodDefault<z.ZodNumber>;
+    shaftProfile: z.ZodDefault<z.ZodEnum<{
+        straight: "straight";
+        tapered: "tapered";
+        bulged: "bulged";
+        baluster: "baluster";
+        hourglass: "hourglass";
+    }>>;
+    shaftTaper: z.ZodDefault<z.ZodNumber>;
+    shaftBulge: z.ZodDefault<z.ZodNumber>;
+    shaftStartScale: z.ZodDefault<z.ZodNumber>;
+    shaftEndScale: z.ZodDefault<z.ZodNumber>;
+    shaftSegmentCount: z.ZodDefault<z.ZodNumber>;
+    shaftTwistStep: z.ZodDefault<z.ZodNumber>;
+    shaftCornerRadius: z.ZodDefault<z.ZodNumber>;
+    shaftDetail: z.ZodDefault<z.ZodEnum<{
+        fluted: "fluted";
+        "lathe-turned": "lathe-turned";
+        none: "none";
+        spiral: "spiral";
+        panelled: "panelled";
+    }>>;
+    baseStyle: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        "simple-square": "simple-square";
+        "round-rings": "round-rings";
+        "square-plinth": "square-plinth";
+        "stepped-square": "stepped-square";
+        lotus: "lotus";
+        "ribbed-lotus": "ribbed-lotus";
+        "panelled-pedestal": "panelled-pedestal";
+    }>>;
+    baseWidthScale: z.ZodDefault<z.ZodNumber>;
+    baseDepthScale: z.ZodDefault<z.ZodNumber>;
+    baseTierCount: z.ZodDefault<z.ZodNumber>;
+    baseStepSpread: z.ZodDefault<z.ZodNumber>;
+    basePlinthHeightRatio: z.ZodDefault<z.ZodNumber>;
+    baseRoundBandScale: z.ZodDefault<z.ZodNumber>;
+    baseNeckScale: z.ZodDefault<z.ZodNumber>;
+    baseRoundBandCount: z.ZodDefault<z.ZodNumber>;
+    baseRibCount: z.ZodDefault<z.ZodNumber>;
+    baseCarvingLevel: z.ZodDefault<z.ZodNumber>;
+    basePanelInset: z.ZodDefault<z.ZodNumber>;
+    capitalStyle: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        simple: "simple";
+        "simple-slab": "simple-slab";
+        rounded: "rounded";
+        stepped: "stepped";
+        doric: "doric";
+        volute: "volute";
+        "ionic-volute": "ionic-volute";
+        "leaf-carved": "leaf-carved";
+        "corinthian-leaf": "corinthian-leaf";
+        "south-indian-bracket": "south-indian-bracket";
+        "wood-bracket": "wood-bracket";
+    }>>;
+    capitalWidthScale: z.ZodDefault<z.ZodNumber>;
+    capitalDepthScale: z.ZodDefault<z.ZodNumber>;
+    capitalTierCount: z.ZodDefault<z.ZodNumber>;
+    capitalStepSpread: z.ZodDefault<z.ZodNumber>;
+    capitalBandCount: z.ZodDefault<z.ZodNumber>;
+    voluteSize: z.ZodDefault<z.ZodNumber>;
+    voluteCount: z.ZodDefault<z.ZodNumber>;
+    leafCount: z.ZodDefault<z.ZodNumber>;
+    leafRows: z.ZodDefault<z.ZodNumber>;
+    bracketDepth: z.ZodDefault<z.ZodNumber>;
+    bracketTierCount: z.ZodDefault<z.ZodNumber>;
+    pendantCount: z.ZodDefault<z.ZodNumber>;
+    capitalCarvingLevel: z.ZodDefault<z.ZodNumber>;
+    ringCount: z.ZodDefault<z.ZodNumber>;
+    ringPlacement: z.ZodDefault<z.ZodEnum<{
+        ends: "ends";
+        even: "even";
+        top: "top";
+        bottom: "bottom";
+    }>>;
+    ringThickness: z.ZodDefault<z.ZodNumber>;
+    ringSpread: z.ZodDefault<z.ZodNumber>;
+    fluteCount: z.ZodDefault<z.ZodNumber>;
+    fluteDepth: z.ZodDefault<z.ZodNumber>;
+    fluteWidth: z.ZodDefault<z.ZodNumber>;
+    spiralTwist: z.ZodDefault<z.ZodNumber>;
+    spiralRibCount: z.ZodDefault<z.ZodNumber>;
+    panelCount: z.ZodDefault<z.ZodNumber>;
+    panelInsetDepth: z.ZodDefault<z.ZodNumber>;
+    panelShape: z.ZodDefault<z.ZodEnum<{
+        rectangle: "rectangle";
+        arched: "arched";
+        diamond: "diamond";
+    }>>;
+    latheRingCount: z.ZodDefault<z.ZodNumber>;
+    latheRingSpacing: z.ZodDefault<z.ZodEnum<{
+        ends: "ends";
+        even: "even";
+        top: "top";
+        bottom: "bottom";
+    }>>;
+    carvingLevel: z.ZodDefault<z.ZodNumber>;
+    carvingPlacement: z.ZodDefault<z.ZodEnum<{
+        shaft: "shaft";
+        base: "base";
+        capital: "capital";
+        all: "all";
+    }>>;
+    lowerBandEnabled: z.ZodDefault<z.ZodBoolean>;
+    lowerBandHeight: z.ZodDefault<z.ZodNumber>;
+    lowerBandCarvingLevel: z.ZodDefault<z.ZodNumber>;
+    dentilCount: z.ZodDefault<z.ZodNumber>;
+    beadCount: z.ZodDefault<z.ZodNumber>;
+    material: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        preset: z.ZodOptional<z.ZodEnum<{
+            custom: "custom";
+            white: "white";
+            brick: "brick";
+            concrete: "concrete";
+            wood: "wood";
+            glass: "glass";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            marble: "marble";
+        }>>;
+        properties: z.ZodOptional<z.ZodObject<{
+            color: z.ZodDefault<z.ZodString>;
+            roughness: z.ZodDefault<z.ZodNumber>;
+            metalness: z.ZodDefault<z.ZodNumber>;
+            opacity: z.ZodDefault<z.ZodNumber>;
+            transparent: z.ZodDefault<z.ZodBoolean>;
+            side: z.ZodDefault<z.ZodEnum<{
+                front: "front";
+                back: "back";
+                double: "double";
+            }>>;
+        }, z.core.$strip>>;
+        texture: z.ZodOptional<z.ZodObject<{
+            url: z.ZodString;
+            repeat: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            scale: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    materialPreset: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
     name: z.ZodOptional<z.ZodString>;
@@ -363,9 +554,9 @@ export declare const AnyNode: z.ZodDiscriminatedUnion<[z.ZodObject<{
     materialPreset: z.ZodOptional<z.ZodString>;
     start: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
     end: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
-    curveOffset: z.ZodOptional<z.ZodNumber>;
     height: z.ZodDefault<z.ZodNumber>;
     thickness: z.ZodDefault<z.ZodNumber>;
+    curveOffset: z.ZodOptional<z.ZodNumber>;
     baseHeight: z.ZodDefault<z.ZodNumber>;
     postSpacing: z.ZodDefault<z.ZodNumber>;
     postSize: z.ZodDefault<z.ZodNumber>;
@@ -416,6 +607,13 @@ export declare const AnyNode: z.ZodDiscriminatedUnion<[z.ZodObject<{
         category: z.ZodString;
         name: z.ZodString;
         thumbnail: z.ZodString;
+        floorPlanUrl: z.ZodOptional<z.ZodString>;
+        source: z.ZodDefault<z.ZodEnum<{
+            library: "library";
+            community: "community";
+            mine: "mine";
+        }>>;
+        isDraft: z.ZodOptional<z.ZodBoolean>;
         src: z.ZodString;
         dimensions: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
         attachTo: z.ZodOptional<z.ZodEnum<{
@@ -827,13 +1025,13 @@ export declare const AnyNode: z.ZodDiscriminatedUnion<[z.ZodObject<{
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     rotation: z.ZodDefault<z.ZodNumber>;
     roofType: z.ZodDefault<z.ZodEnum<{
+        flat: "flat";
         hip: "hip";
         gable: "gable";
         shed: "shed";
         gambrel: "gambrel";
         dutch: "dutch";
         mansard: "mansard";
-        flat: "flat";
     }>>;
     width: z.ZodDefault<z.ZodNumber>;
     depth: z.ZodDefault<z.ZodNumber>;
@@ -997,8 +1195,8 @@ export declare const AnyNode: z.ZodDiscriminatedUnion<[z.ZodObject<{
     rotation: z.ZodDefault<z.ZodNumber>;
     stairType: z.ZodDefault<z.ZodEnum<{
         straight: "straight";
-        curved: "curved";
         spiral: "spiral";
+        curved: "curved";
     }>>;
     fromLevelId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     toLevelId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
@@ -1022,9 +1220,9 @@ export declare const AnyNode: z.ZodDiscriminatedUnion<[z.ZodObject<{
     showCenterColumn: z.ZodDefault<z.ZodBoolean>;
     showStepSupports: z.ZodDefault<z.ZodBoolean>;
     railingMode: z.ZodDefault<z.ZodEnum<{
+        none: "none";
         left: "left";
         right: "right";
-        none: "none";
         both: "both";
     }>>;
     railingHeight: z.ZodDefault<z.ZodNumber>;
@@ -1143,6 +1341,34 @@ export declare const AnyNode: z.ZodDiscriminatedUnion<[z.ZodObject<{
     rotation: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     scale: z.ZodDefault<z.ZodNumber>;
     opacity: z.ZodDefault<z.ZodNumber>;
+    scaleReference: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        start: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        end: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        realLengthMeters: z.ZodNumber;
+        measuredLengthUnits: z.ZodNumber;
+        metersPerUnit: z.ZodNumber;
+        label: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>, 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.ZodJSONSchema>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`spawn_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"spawn">>;
+    position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    rotation: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>, z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
     name: z.ZodOptional<z.ZodString>;
@@ -1202,6 +1428,48 @@ export declare const AnyNode: z.ZodDiscriminatedUnion<[z.ZodObject<{
     wallId: z.ZodOptional<z.ZodString>;
     width: z.ZodDefault<z.ZodNumber>;
     height: z.ZodDefault<z.ZodNumber>;
+    openingKind: z.ZodDefault<z.ZodEnum<{
+        window: "window";
+        opening: "opening";
+    }>>;
+    windowType: z.ZodDefault<z.ZodEnum<{
+        sliding: "sliding";
+        fixed: "fixed";
+        casement: "casement";
+        awning: "awning";
+        hopper: "hopper";
+        "single-hung": "single-hung";
+        "double-hung": "double-hung";
+        bay: "bay";
+        bow: "bow";
+        louvered: "louvered";
+    }>>;
+    operationState: z.ZodDefault<z.ZodNumber>;
+    awningDirection: z.ZodDefault<z.ZodEnum<{
+        up: "up";
+        down: "down";
+    }>>;
+    casementStyle: z.ZodDefault<z.ZodEnum<{
+        french: "french";
+        single: "single";
+    }>>;
+    hingesSide: z.ZodDefault<z.ZodEnum<{
+        left: "left";
+        right: "right";
+    }>>;
+    openingShape: z.ZodDefault<z.ZodEnum<{
+        rectangle: "rectangle";
+        rounded: "rounded";
+        arch: "arch";
+    }>>;
+    openingRadiusMode: z.ZodDefault<z.ZodEnum<{
+        all: "all";
+        individual: "individual";
+    }>>;
+    openingCornerRadii: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    cornerRadius: z.ZodDefault<z.ZodNumber>;
+    archHeight: z.ZodDefault<z.ZodNumber>;
+    openingRevealRadius: z.ZodDefault<z.ZodNumber>;
     frameThickness: z.ZodDefault<z.ZodNumber>;
     frameDepth: z.ZodDefault<z.ZodNumber>;
     columnRatios: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
@@ -1270,6 +1538,52 @@ export declare const AnyNode: z.ZodDiscriminatedUnion<[z.ZodObject<{
     wallId: z.ZodOptional<z.ZodString>;
     width: z.ZodDefault<z.ZodNumber>;
     height: z.ZodDefault<z.ZodNumber>;
+    doorCategory: z.ZodDefault<z.ZodEnum<{
+        interior: "interior";
+        garage: "garage";
+    }>>;
+    doorType: z.ZodDefault<z.ZodEnum<{
+        double: "double";
+        hinged: "hinged";
+        french: "french";
+        folding: "folding";
+        pocket: "pocket";
+        barn: "barn";
+        sliding: "sliding";
+        "garage-sectional": "garage-sectional";
+        "garage-rollup": "garage-rollup";
+        "garage-tiltup": "garage-tiltup";
+    }>>;
+    leafCount: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>]>>;
+    operationState: z.ZodDefault<z.ZodNumber>;
+    slideDirection: z.ZodDefault<z.ZodEnum<{
+        left: "left";
+        right: "right";
+    }>>;
+    trackStyle: z.ZodDefault<z.ZodEnum<{
+        visible: "visible";
+        none: "none";
+        pocket: "pocket";
+        overhead: "overhead";
+    }>>;
+    garagePanelCount: z.ZodDefault<z.ZodNumber>;
+    openingKind: z.ZodDefault<z.ZodEnum<{
+        door: "door";
+        opening: "opening";
+    }>>;
+    openingShape: z.ZodDefault<z.ZodEnum<{
+        rectangle: "rectangle";
+        rounded: "rounded";
+        arch: "arch";
+    }>>;
+    openingRadiusMode: z.ZodDefault<z.ZodEnum<{
+        all: "all";
+        individual: "individual";
+    }>>;
+    openingTopRadii: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    cornerRadius: z.ZodDefault<z.ZodNumber>;
+    archHeight: z.ZodDefault<z.ZodNumber>;
+    openingRevealRadius: z.ZodDefault<z.ZodNumber>;
     frameThickness: z.ZodDefault<z.ZodNumber>;
     frameDepth: z.ZodDefault<z.ZodNumber>;
     threshold: z.ZodDefault<z.ZodBoolean>;
@@ -1282,6 +1596,7 @@ export declare const AnyNode: z.ZodDiscriminatedUnion<[z.ZodObject<{
         inward: "inward";
         outward: "outward";
     }>>;
+    swingAngle: z.ZodDefault<z.ZodNumber>;
     segments: z.ZodDefault<z.ZodArray<z.ZodObject<{
         type: z.ZodEnum<{
             glass: "glass";

package/dist/schema/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/schema/types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAmBnB,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAkBlB,CAAA;AAEF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,CAAA;AAC7C,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;AACzC,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/schema/types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAqBnB,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAoBlB,CAAA;AAEF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,CAAA;AAC7C,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;AACzC,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA"}

package/dist/schema/types.js

@@ -1,6 +1,7 @@
 import z from 'zod';
 import { BuildingNode } from './nodes/building';
 import { CeilingNode } from './nodes/ceiling';
+import { ColumnNode } from './nodes/column';
 import { DoorNode } from './nodes/door';
 import { FenceNode } from './nodes/fence';
 import { GuideNode } from './nodes/guide';
@@ -11,6 +12,7 @@ import { RoofSegmentNode } from './nodes/roof-segment';
 import { ScanNode } from './nodes/scan';
 import { SiteNode } from './nodes/site';
 import { SlabNode } from './nodes/slab';
+import { SpawnNode } from './nodes/spawn';
 import { StairNode } from './nodes/stair';
 import { StairSegmentNode } from './nodes/stair-segment';
 import { WallNode } from './nodes/wall';
@@ -20,6 +22,7 @@ export const AnyNode = z.discriminatedUnion('type', [
     SiteNode,
     BuildingNode,
     LevelNode,
+    ColumnNode,
     WallNode,
     FenceNode,
     ItemNode,
@@ -32,6 +35,7 @@ export const AnyNode = z.discriminatedUnion('type', [
     StairSegmentNode,
     ScanNode,
     GuideNode,
+    SpawnNode,
     WindowNode,
     DoorNode,
 ]);

package/dist/store/actions/node-actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node-actions.d.ts","sourceRoot":"","sources":["../../../src/store/actions/node-actions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAIf,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AA6N9C,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,EAAE,SA4C/C,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,SAAS;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,EAAE,SA+DrD,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK,SAAS,EAAE,SAsGjB,CAAA"}
+{"version":3,"file":"node-actions.d.ts","sourceRoot":"","sources":["../../../src/store/actions/node-actions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAIf,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AA+N9C,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,EAAE,SA+C/C,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,SAAS;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,EAAE,SA+DrD,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK,SAAS,EAAE,SAsGjB,CAAA"}

package/dist/store/actions/node-actions.js

@@ -72,7 +72,7 @@ function buildMergedWallAttachmentUpdates(primary, secondary, mergedWallId, merg
     const wallChildren = [...(primary.children ?? []), ...(secondary.children ?? [])];
     for (const childId of wallChildren) {
         const child = nodes[childId];
-        if (!child || !('position' in child) || !Array.isArray(child.position)) {
+        if (!(child && 'position' in child && Array.isArray(child.position))) {
             continue;
         }
         const sourceWall = child.parentId === secondary.id ? secondary : primary;
@@ -123,10 +123,10 @@ function buildWallMergePlans(nodes, idsToDelete) {
                 return a.id.localeCompare(b.id);
             });
             const [primary, secondary] = sortedCandidates;
-            if (!primary ||
-                !secondary ||
-                !areWallStylesCompatible(primary, secondary) ||
-                !areWallsCollinearAcrossPoint(primary, secondary, junction)) {
+            if (!(primary &&
+                secondary &&
+                areWallStylesCompatible(primary, secondary) &&
+                areWallsCollinearAcrossPoint(primary, secondary, junction))) {
                 continue;
             }
             const { start, end } = resolveMergedWallEndpoints(primary, secondary, junction);
@@ -153,25 +153,26 @@ export const createNodesAction = (set, get, ops) => {
         const nextNodes = { ...state.nodes };
         const nextRootIds = [...state.rootNodeIds];
         for (const { node, parentId } of ops) {
+            const effectiveParentId = parentId ?? node.parentId ?? null;
             // 1. Assign parentId to the child (Safe because BaseNode has parentId)
             const newNode = {
                 ...node,
-                parentId: parentId ?? null,
+                parentId: effectiveParentId,
             };
             nextNodes[newNode.id] = newNode;
             // 2. Update the Parent's children list
-            if (parentId && nextNodes[parentId]) {
-                const parent = nextNodes[parentId];
+            if (effectiveParentId && nextNodes[effectiveParentId]) {
+                const parent = nextNodes[effectiveParentId];
                 // Type Guard: Check if the parent node is a container that supports children
                 if ('children' in parent && Array.isArray(parent.children)) {
-                    nextNodes[parentId] = {
+                    nextNodes[effectiveParentId] = {
                         ...parent,
                         // Use Set to prevent duplicate IDs if createNode is called twice
                         children: Array.from(new Set([...parent.children, newNode.id])), // We don't verify child types here
                     };
                 }
             }
-            else if (!parentId) {
+            else if (!effectiveParentId) {
                 // 3. Handle Root nodes
                 if (!nextRootIds.includes(newNode.id)) {
                     nextRootIds.push(newNode.id);
@@ -185,6 +186,8 @@ export const createNodesAction = (set, get, ops) => {
         get().markDirty(node.id);
         if (parentId)
             get().markDirty(parentId);
+        else if (node.parentId)
+            get().markDirty(node.parentId);
     });
 };
 export const updateNodesAction = (set, get, updates) => {

package/dist/store/use-interactive.d.ts

@@ -4,14 +4,57 @@ export type ControlValue = boolean | number;
 export type ItemInteractiveState = {
     controlValues: ControlValue[];
 };
+export type DoorInteractiveState = {
+    operationState?: number;
+    swingAngle?: number;
+};
+export type DoorAnimationState = {
+    field: keyof DoorInteractiveState;
+    from: number;
+    to: number;
+    startedAt: number | null;
+    durationMs: number;
+    persist: boolean;
+};
+export type WindowInteractiveState = {
+    operationState?: number;
+};
+export type WindowAnimationState = {
+    field: keyof WindowInteractiveState;
+    from: number;
+    to: number;
+    startedAt: number | null;
+    durationMs: number;
+    persist: boolean;
+};
 type InteractiveStore = {
     items: Record<AnyNodeId, ItemInteractiveState>;
+    doors: Record<AnyNodeId, DoorInteractiveState>;
+    doorAnimations: Record<AnyNodeId, DoorAnimationState>;
+    windows: Record<AnyNodeId, WindowInteractiveState>;
+    windowAnimations: Record<AnyNodeId, WindowAnimationState>;
     /** Initialize a node's interactive state from its asset definition (idempotent) */
     initItem: (itemId: AnyNodeId, interactive: Interactive) => void;
     /** Set a single control value */
     setControlValue: (itemId: AnyNodeId, index: number, value: ControlValue) => void;
     /** Remove a node's state (e.g. on unmount) */
     removeItem: (itemId: AnyNodeId) => void;
+    /** Set transient door open state without committing it to the scene node */
+    setDoorOpenState: (doorId: AnyNodeId, value: DoorInteractiveState) => void;
+    /** Clear transient door open state */
+    removeDoorOpenState: (doorId: AnyNodeId) => void;
+    /** Queue a door animation for the viewer frame loop */
+    startDoorAnimation: (doorId: AnyNodeId, value: DoorAnimationState) => void;
+    /** Cancel a queued door animation */
+    cancelDoorAnimation: (doorId: AnyNodeId) => void;
+    /** Set transient window open state without committing it to the scene node */
+    setWindowOpenState: (windowId: AnyNodeId, value: WindowInteractiveState) => void;
+    /** Clear transient window open state */
+    removeWindowOpenState: (windowId: AnyNodeId) => void;
+    /** Queue a window animation for the viewer frame loop */
+    startWindowAnimation: (windowId: AnyNodeId, value: WindowAnimationState) => void;
+    /** Cancel a queued window animation */
+    cancelWindowAnimation: (windowId: AnyNodeId) => void;
 };
 export declare const useInteractive: import("zustand").UseBoundStore<import("zustand").StoreApi<InteractiveStore>>;
 export {};

package/dist/store/use-interactive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-interactive.d.ts","sourceRoot":"","sources":["../../src/store/use-interactive.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAGhD,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,MAAM,CAAA;AAE3C,MAAM,MAAM,oBAAoB,GAAG;IAEjC,aAAa,EAAE,YAAY,EAAE,CAAA;CAC9B,CAAA;AAED,KAAK,gBAAgB,GAAG;IACtB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,oBAAoB,CAAC,CAAA;IAE9C,mFAAmF;IACnF,QAAQ,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,WAAW,KAAK,IAAI,CAAA;IAE/D,iCAAiC;IACjC,eAAe,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,KAAK,IAAI,CAAA;IAEhF,8CAA8C;IAC9C,UAAU,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,IAAI,CAAA;CACxC,CAAA;AAeD,eAAO,MAAM,cAAc,+EAoCxB,CAAA"}
+{"version":3,"file":"use-interactive.d.ts","sourceRoot":"","sources":["../../src/store/use-interactive.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAGhD,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,MAAM,CAAA;AAE3C,MAAM,MAAM,oBAAoB,GAAG;IAEjC,aAAa,EAAE,YAAY,EAAE,CAAA;CAC9B,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,EAAE,MAAM,oBAAoB,CAAA;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,EAAE,EAAE,MAAM,CAAA;IACV,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,OAAO,CAAA;CACjB,CAAA;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,KAAK,EAAE,MAAM,sBAAsB,CAAA;IACnC,IAAI,EAAE,MAAM,CAAA;IACZ,EAAE,EAAE,MAAM,CAAA;IACV,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,OAAO,CAAA;CACjB,CAAA;AAED,KAAK,gBAAgB,GAAG;IACtB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,oBAAoB,CAAC,CAAA;IAC9C,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,oBAAoB,CAAC,CAAA;IAC9C,cAAc,EAAE,MAAM,CAAC,SAAS,EAAE,kBAAkB,CAAC,CAAA;IACrD,OAAO,EAAE,MAAM,CAAC,SAAS,EAAE,sBAAsB,CAAC,CAAA;IAClD,gBAAgB,EAAE,MAAM,CAAC,SAAS,EAAE,oBAAoB,CAAC,CAAA;IAEzD,mFAAmF;IACnF,QAAQ,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,WAAW,KAAK,IAAI,CAAA;IAE/D,iCAAiC;IACjC,eAAe,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,KAAK,IAAI,CAAA;IAEhF,8CAA8C;IAC9C,UAAU,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,IAAI,CAAA;IAEvC,4EAA4E;IAC5E,gBAAgB,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,oBAAoB,KAAK,IAAI,CAAA;IAE1E,sCAAsC;IACtC,mBAAmB,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,IAAI,CAAA;IAEhD,uDAAuD;IACvD,kBAAkB,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,kBAAkB,KAAK,IAAI,CAAA;IAE1E,qCAAqC;IACrC,mBAAmB,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,IAAI,CAAA;IAEhD,8EAA8E;IAC9E,kBAAkB,EAAE,CAAC,QAAQ,EAAE,SAAS,EAAE,KAAK,EAAE,sBAAsB,KAAK,IAAI,CAAA;IAEhF,wCAAwC;IACxC,qBAAqB,EAAE,CAAC,QAAQ,EAAE,SAAS,KAAK,IAAI,CAAA;IAEpD,yDAAyD;IACzD,oBAAoB,EAAE,CAAC,QAAQ,EAAE,SAAS,EAAE,KAAK,EAAE,oBAAoB,KAAK,IAAI,CAAA;IAEhF,uCAAuC;IACvC,qBAAqB,EAAE,CAAC,QAAQ,EAAE,SAAS,KAAK,IAAI,CAAA;CACrD,CAAA;AAeD,eAAO,MAAM,cAAc,+EA8GxB,CAAA"}

package/dist/store/use-interactive.js

@@ -15,6 +15,10 @@ const defaultControlValue = (interactive, index) => {
 };
 export const useInteractive = create((set, get) => ({
     items: {},
+    doors: {},
+    doorAnimations: {},
+    windows: {},
+    windowAnimations: {},
     initItem: (itemId, interactive) => {
         const { controls } = interactive;
         if (controls.length === 0)
@@ -47,4 +51,66 @@ export const useInteractive = create((set, get) => ({
             return { items: rest };
         });
     },
+    setDoorOpenState: (doorId, value) => {
+        set((state) => ({
+            doors: {
+                ...state.doors,
+                [doorId]: {
+                    ...state.doors[doorId],
+                    ...value,
+                },
+            },
+        }));
+    },
+    removeDoorOpenState: (doorId) => {
+        set((state) => {
+            const { [doorId]: _, ...rest } = state.doors;
+            return { doors: rest };
+        });
+    },
+    startDoorAnimation: (doorId, value) => {
+        set((state) => ({
+            doorAnimations: {
+                ...state.doorAnimations,
+                [doorId]: value,
+            },
+        }));
+    },
+    cancelDoorAnimation: (doorId) => {
+        set((state) => {
+            const { [doorId]: _, ...rest } = state.doorAnimations;
+            return { doorAnimations: rest };
+        });
+    },
+    setWindowOpenState: (windowId, value) => {
+        set((state) => ({
+            windows: {
+                ...state.windows,
+                [windowId]: {
+                    ...state.windows[windowId],
+                    ...value,
+                },
+            },
+        }));
+    },
+    removeWindowOpenState: (windowId) => {
+        set((state) => {
+            const { [windowId]: _, ...rest } = state.windows;
+            return { windows: rest };
+        });
+    },
+    startWindowAnimation: (windowId, value) => {
+        set((state) => ({
+            windowAnimations: {
+                ...state.windowAnimations,
+                [windowId]: value,
+            },
+        }));
+    },
+    cancelWindowAnimation: (windowId) => {
+        set((state) => {
+            const { [windowId]: _, ...rest } = state.windowAnimations;
+            return { windowAnimations: rest };
+        });
+    },
 }));