@pascal-app/core 0.8.0 → 0.9.2

package/dist/store/history-control.js

@@ -20,3 +20,36 @@ export function getSceneHistoryPauseDepth() {
 export function resetSceneHistoryPauseDepth() {
     sceneHistoryPauseDepth = 0;
 }
+function retainedPastStateCount(before, after) {
+    for (let start = 0; start < before.length; start += 1) {
+        const retained = before.length - start;
+        if (retained > after.length)
+            continue;
+        let matches = true;
+        for (let index = 0; index < retained; index += 1) {
+            if (before[start + index] !== after[index]) {
+                matches = false;
+                break;
+            }
+        }
+        if (matches)
+            return retained;
+    }
+    return 0;
+}
+export function runAsSingleSceneHistoryStep(sceneStore, run) {
+    const beforePastStates = sceneStore.temporal.getState().pastStates;
+    const result = run();
+    const afterPastStates = sceneStore.temporal.getState().pastStates;
+    const retainedCount = retainedPastStateCount(beforePastStates, afterPastStates);
+    const addedCount = afterPastStates.length - retainedCount;
+    if (addedCount > 1) {
+        const firstAddedState = afterPastStates[retainedCount];
+        if (firstAddedState !== undefined) {
+            sceneStore.temporal.setState({
+                pastStates: [...afterPastStates.slice(0, retainedCount), firstAddedState],
+            });
+        }
+    }
+    return result;
+}

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

@@ -27,12 +27,37 @@ export type WindowAnimationState = {
     durationMs: number;
     persist: boolean;
 };
+export type SkylightInteractiveState = {
+    operationState?: number;
+};
+export type SkylightAnimationState = {
+    field: keyof SkylightInteractiveState;
+    from: number;
+    to: number;
+    startedAt: number | null;
+    durationMs: number;
+    persist: boolean;
+};
+export type ElevatorPhase = 'idle' | 'closing' | 'moving' | 'opening' | 'open';
+export type ElevatorInteractiveState = {
+    currentLevelId: AnyNodeId | null;
+    targetLevelId: AnyNodeId | null;
+    carY: number;
+    doorOpen: number;
+    phase: ElevatorPhase;
+    phaseStartedAt: number | null;
+    queue: AnyNodeId[];
+    requestedStops: AnyNodeId[];
+};
 type InteractiveStore = {
     items: Record<AnyNodeId, ItemInteractiveState>;
     doors: Record<AnyNodeId, DoorInteractiveState>;
     doorAnimations: Record<AnyNodeId, DoorAnimationState>;
     windows: Record<AnyNodeId, WindowInteractiveState>;
     windowAnimations: Record<AnyNodeId, WindowAnimationState>;
+    skylights: Record<AnyNodeId, SkylightInteractiveState>;
+    skylightAnimations: Record<AnyNodeId, SkylightAnimationState>;
+    elevators: Record<AnyNodeId, ElevatorInteractiveState>;
     /** Initialize a node's interactive state from its asset definition (idempotent) */
     initItem: (itemId: AnyNodeId, interactive: Interactive) => void;
     /** Set a single control value */
@@ -55,6 +80,20 @@ type InteractiveStore = {
     startWindowAnimation: (windowId: AnyNodeId, value: WindowAnimationState) => void;
     /** Cancel a queued window animation */
     cancelWindowAnimation: (windowId: AnyNodeId) => void;
+    /** Set transient skylight open state without committing it to the scene node */
+    setSkylightOpenState: (skylightId: AnyNodeId, value: SkylightInteractiveState) => void;
+    /** Clear transient skylight open state */
+    removeSkylightOpenState: (skylightId: AnyNodeId) => void;
+    /** Queue a skylight animation for the viewer frame loop */
+    startSkylightAnimation: (skylightId: AnyNodeId, value: SkylightAnimationState) => void;
+    /** Cancel a queued skylight animation */
+    cancelSkylightAnimation: (skylightId: AnyNodeId) => void;
+    /** Initialize an elevator's runtime state from its default served level. */
+    initElevator: (elevatorId: AnyNodeId, levelId: AnyNodeId, carY: number) => void;
+    /** Merge runtime elevator state. */
+    setElevatorState: (elevatorId: AnyNodeId, value: Partial<ElevatorInteractiveState>) => void;
+    /** Remove elevator runtime state when its renderer unmounts. */
+    removeElevator: (elevatorId: 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,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"}
+{"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,MAAM,MAAM,wBAAwB,GAAG;IACrC,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,KAAK,EAAE,MAAM,wBAAwB,CAAA;IACrC,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,aAAa,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,CAAA;AAE9E,MAAM,MAAM,wBAAwB,GAAG;IACrC,cAAc,EAAE,SAAS,GAAG,IAAI,CAAA;IAChC,aAAa,EAAE,SAAS,GAAG,IAAI,CAAA;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,aAAa,CAAA;IACpB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,KAAK,EAAE,SAAS,EAAE,CAAA;IAClB,cAAc,EAAE,SAAS,EAAE,CAAA;CAC5B,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;IACzD,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,wBAAwB,CAAC,CAAA;IACtD,kBAAkB,EAAE,MAAM,CAAC,SAAS,EAAE,sBAAsB,CAAC,CAAA;IAC7D,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,wBAAwB,CAAC,CAAA;IAEtD,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;IAEpD,gFAAgF;IAChF,oBAAoB,EAAE,CAAC,UAAU,EAAE,SAAS,EAAE,KAAK,EAAE,wBAAwB,KAAK,IAAI,CAAA;IAEtF,0CAA0C;IAC1C,uBAAuB,EAAE,CAAC,UAAU,EAAE,SAAS,KAAK,IAAI,CAAA;IAExD,2DAA2D;IAC3D,sBAAsB,EAAE,CAAC,UAAU,EAAE,SAAS,EAAE,KAAK,EAAE,sBAAsB,KAAK,IAAI,CAAA;IAEtF,yCAAyC;IACzC,uBAAuB,EAAE,CAAC,UAAU,EAAE,SAAS,KAAK,IAAI,CAAA;IAExD,4EAA4E;IAC5E,YAAY,EAAE,CAAC,UAAU,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IAE/E,oCAAoC;IACpC,gBAAgB,EAAE,CAAC,UAAU,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,CAAC,wBAAwB,CAAC,KAAK,IAAI,CAAA;IAE3F,gEAAgE;IAChE,cAAc,EAAE,CAAC,UAAU,EAAE,SAAS,KAAK,IAAI,CAAA;CAChD,CAAA;AAeD,eAAO,MAAM,cAAc,+EAgMxB,CAAA"}

package/dist/store/use-interactive.js

@@ -19,6 +19,9 @@ export const useInteractive = create((set, get) => ({
     doorAnimations: {},
     windows: {},
     windowAnimations: {},
+    skylights: {},
+    skylightAnimations: {},
+    elevators: {},
     initItem: (itemId, interactive) => {
         const { controls } = interactive;
         if (controls.length === 0)
@@ -113,4 +116,76 @@ export const useInteractive = create((set, get) => ({
             return { windowAnimations: rest };
         });
     },
+    setSkylightOpenState: (skylightId, value) => {
+        set((state) => ({
+            skylights: {
+                ...state.skylights,
+                [skylightId]: {
+                    ...state.skylights[skylightId],
+                    ...value,
+                },
+            },
+        }));
+    },
+    removeSkylightOpenState: (skylightId) => {
+        set((state) => {
+            const { [skylightId]: _, ...rest } = state.skylights;
+            return { skylights: rest };
+        });
+    },
+    startSkylightAnimation: (skylightId, value) => {
+        set((state) => ({
+            skylightAnimations: {
+                ...state.skylightAnimations,
+                [skylightId]: value,
+            },
+        }));
+    },
+    cancelSkylightAnimation: (skylightId) => {
+        set((state) => {
+            const { [skylightId]: _, ...rest } = state.skylightAnimations;
+            return { skylightAnimations: rest };
+        });
+    },
+    initElevator: (elevatorId, levelId, carY) => {
+        if (get().elevators[elevatorId])
+            return;
+        set((state) => ({
+            elevators: {
+                ...state.elevators,
+                [elevatorId]: {
+                    currentLevelId: levelId,
+                    targetLevelId: null,
+                    carY,
+                    doorOpen: 0,
+                    phase: 'idle',
+                    phaseStartedAt: null,
+                    queue: [],
+                    requestedStops: [],
+                },
+            },
+        }));
+    },
+    setElevatorState: (elevatorId, value) => {
+        set((state) => {
+            const current = state.elevators[elevatorId];
+            if (!current)
+                return state;
+            return {
+                elevators: {
+                    ...state.elevators,
+                    [elevatorId]: {
+                        ...current,
+                        ...value,
+                    },
+                },
+            };
+        });
+    },
+    removeElevator: (elevatorId) => {
+        set((state) => {
+            const { [elevatorId]: _, ...rest } = state.elevators;
+            return { elevators: rest };
+        });
+    },
 }));

package/dist/store/use-live-node-overrides.d.ts

@@ -0,0 +1,22 @@
+export type LiveNodeOverrides = Record<string, unknown>;
+type LiveNodeOverrideState = {
+    overrides: Map<string, LiveNodeOverrides>;
+    set(nodeId: string, values: LiveNodeOverrides): void;
+    setMany(entries: ReadonlyArray<readonly [string, LiveNodeOverrides]>): void;
+    get(nodeId: string): LiveNodeOverrides | undefined;
+    clear(nodeId: string): void;
+    clearFields(nodeId: string, keys: readonly string[]): void;
+    clearAll(): void;
+};
+declare const useLiveNodeOverrides: import("zustand").UseBoundStore<import("zustand").StoreApi<LiveNodeOverrideState>>;
+/**
+ * Merge any live override for `node` into a fresh copy. Spread semantics —
+ * override fields win, untouched fields stay. Returns the input unchanged
+ * when no override exists, so the caller can use the result directly
+ * without an extra "did anything change" check.
+ */
+export declare function getEffectiveNode<T extends {
+    id: string;
+}>(node: T): T;
+export default useLiveNodeOverrides;
+//# sourceMappingURL=use-live-node-overrides.d.ts.map

package/dist/store/use-live-node-overrides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-live-node-overrides.d.ts","sourceRoot":"","sources":["../../src/store/use-live-node-overrides.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAEvD,KAAK,qBAAqB,GAAG;IAC3B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;IACzC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,GAAG,IAAI,CAAA;IACpD,OAAO,CAAC,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,GAAG,IAAI,CAAA;IAC3E,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS,CAAA;IAClD,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAAA;IAC1D,QAAQ,IAAI,IAAI,CAAA;CACjB,CAAA;AAED,QAAA,MAAM,oBAAoB,oFA+CvB,CAAA;AAEH;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,CAIrE;AAED,eAAe,oBAAoB,CAAA"}

package/dist/store/use-live-node-overrides.js

@@ -0,0 +1,59 @@
+import { create } from 'zustand';
+const useLiveNodeOverrides = create((set, get) => ({
+    overrides: new Map(),
+    set: (nodeId, values) => set((state) => {
+        const next = new Map(state.overrides);
+        next.set(nodeId, { ...(next.get(nodeId) ?? {}), ...values });
+        return { overrides: next };
+    }),
+    // Batch update — one Map clone + one zustand notification regardless
+    // of entry count, so a drag publishing to N linked walls re-renders
+    // subscribers (WallSystem, FloorplanRegistryLayer) once per tick
+    // instead of N+1 times.
+    setMany: (entries) => set((state) => {
+        if (entries.length === 0)
+            return state;
+        const next = new Map(state.overrides);
+        for (const [nodeId, values] of entries) {
+            next.set(nodeId, { ...(next.get(nodeId) ?? {}), ...values });
+        }
+        return { overrides: next };
+    }),
+    get: (nodeId) => get().overrides.get(nodeId),
+    clear: (nodeId) => set((state) => {
+        const next = new Map(state.overrides);
+        next.delete(nodeId);
+        return { overrides: next };
+    }),
+    clearFields: (nodeId, keys) => set((state) => {
+        const current = state.overrides.get(nodeId);
+        if (!current)
+            return state;
+        const nextValues = { ...current };
+        for (const key of keys) {
+            delete nextValues[key];
+        }
+        const next = new Map(state.overrides);
+        if (Object.keys(nextValues).length === 0) {
+            next.delete(nodeId);
+        }
+        else {
+            next.set(nodeId, nextValues);
+        }
+        return { overrides: next };
+    }),
+    clearAll: () => set({ overrides: new Map() }),
+}));
+/**
+ * Merge any live override for `node` into a fresh copy. Spread semantics —
+ * override fields win, untouched fields stay. Returns the input unchanged
+ * when no override exists, so the caller can use the result directly
+ * without an extra "did anything change" check.
+ */
+export function getEffectiveNode(node) {
+    const override = useLiveNodeOverrides.getState().overrides.get(node.id);
+    if (!override || Object.keys(override).length === 0)
+        return node;
+    return { ...node, ...override };
+}
+export default useLiveNodeOverrides;

package/dist/store/use-scene-dirty-tracking.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=use-scene-dirty-tracking.test.d.ts.map

package/dist/store/use-scene-dirty-tracking.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-scene-dirty-tracking.test.d.ts","sourceRoot":"","sources":["../../src/store/use-scene-dirty-tracking.test.ts"],"names":[],"mappings":""}

package/dist/store/use-scene-dirty-tracking.test.js

@@ -0,0 +1,68 @@
+import { beforeEach, describe, expect, test } from 'bun:test';
+import { nodeRegistry } from '../registry/registry';
+import useScene from './use-scene';
+const untrackedDef = {
+    kind: 'test-untracked',
+    schemaVersion: 1,
+    schema: {},
+    category: 'furnishing',
+    defaults: () => ({}),
+    capabilities: {},
+    dirtyTracking: false,
+};
+const trackedDef = {
+    ...untrackedDef,
+    kind: 'test-tracked',
+    dirtyTracking: undefined,
+};
+const UNTRACKED = 'item_untracked';
+const TRACKED = 'item_tracked';
+const UNREGISTERED = 'item_unregistered';
+const makeNode = (id, type) => ({
+    object: 'node',
+    id,
+    type,
+    parentId: null,
+    visible: true,
+    metadata: {},
+    children: [],
+});
+describe('dirty tracking', () => {
+    beforeEach(() => {
+        if (!nodeRegistry.has(untrackedDef.kind))
+            nodeRegistry._register(untrackedDef);
+        if (!nodeRegistry.has(trackedDef.kind))
+            nodeRegistry._register(trackedDef);
+        useScene.setState({
+            nodes: {
+                [UNTRACKED]: makeNode(UNTRACKED, 'test-untracked'),
+                [TRACKED]: makeNode(TRACKED, 'test-tracked'),
+                [UNREGISTERED]: makeNode(UNREGISTERED, 'unregistered-kind'),
+            },
+            rootNodeIds: [UNTRACKED, TRACKED, UNREGISTERED],
+            dirtyNodes: new Set(),
+            collections: {},
+        });
+        useScene.temporal.getState().clear();
+    });
+    // Membership asserts (not set size/equality): the scene store is a module
+    // singleton, and subscribers leaked by other test files can add their own
+    // dirty marks when `setState` fires.
+    test('markDirty skips kinds whose definition opts out', () => {
+        useScene.getState().markDirty(UNTRACKED);
+        expect(useScene.getState().dirtyNodes.has(UNTRACKED)).toBe(false);
+    });
+    test('markDirty tracks kinds without the opt-out, registered or not', () => {
+        useScene.getState().markDirty(TRACKED);
+        useScene.getState().markDirty(UNREGISTERED);
+        expect(useScene.getState().dirtyNodes.has(TRACKED)).toBe(true);
+        expect(useScene.getState().dirtyNodes.has(UNREGISTERED)).toBe(true);
+    });
+    test('deleteNodes removes deleted ids from the dirty set', () => {
+        useScene.getState().markDirty(TRACKED);
+        expect(useScene.getState().dirtyNodes.has(TRACKED)).toBe(true);
+        useScene.getState().deleteNodes([TRACKED]);
+        expect(useScene.getState().nodes[TRACKED]).toBeUndefined();
+        expect(useScene.getState().dirtyNodes.has(TRACKED)).toBe(false);
+    });
+});

package/dist/store/use-scene-elevator-migration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=use-scene-elevator-migration.test.d.ts.map

package/dist/store/use-scene-elevator-migration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-scene-elevator-migration.test.d.ts","sourceRoot":"","sources":["../../src/store/use-scene-elevator-migration.test.ts"],"names":[],"mappings":""}

package/dist/store/use-scene-elevator-migration.test.js

@@ -0,0 +1,109 @@
+import { beforeEach, describe, expect, test } from 'bun:test';
+import useScene from './use-scene';
+describe('scene elevator migrations', () => {
+    beforeEach(() => {
+        useScene.setState({
+            nodes: {},
+            rootNodeIds: [],
+            dirtyNodes: new Set(),
+            collections: {},
+        });
+        useScene.temporal.getState().clear();
+    });
+    test('normalizes legacy level-parented elevators into building-scoped nodes', () => {
+        useScene.getState().setScene({
+            site_test: {
+                object: 'node',
+                id: 'site_test',
+                type: 'site',
+                parentId: null,
+                visible: true,
+                metadata: {},
+                children: ['building_test'],
+            },
+            building_test: {
+                object: 'node',
+                id: 'building_test',
+                type: 'building',
+                parentId: 'site_test',
+                visible: true,
+                metadata: {},
+                children: ['level_test'],
+            },
+            level_test: {
+                object: 'node',
+                id: 'level_test',
+                type: 'level',
+                parentId: 'building_test',
+                visible: true,
+                metadata: {},
+                children: ['elevator_test'],
+                level: 0,
+            },
+            elevator_test: {
+                object: 'node',
+                id: 'elevator_test',
+                type: 'elevator',
+                parentId: 'level_test',
+                visible: true,
+                metadata: {},
+            },
+        }, ['site_test']);
+        const nodes = useScene.getState().nodes;
+        const elevator = nodes.elevator_test;
+        const level = nodes.level_test;
+        const building = nodes.building_test;
+        expect(elevator.parentId).toBe('building_test');
+        expect(elevator.position).toEqual([0, 0, 0]);
+        expect(elevator.rotation).toBe(0);
+        expect(level.children).not.toContain('elevator_test');
+        expect(building.children).toContain('elevator_test');
+    });
+    test('migrates level-parented elevators when the level parentId is missing', () => {
+        useScene.getState().setScene({
+            site_test: {
+                object: 'node',
+                id: 'site_test',
+                type: 'site',
+                parentId: null,
+                visible: true,
+                metadata: {},
+                children: ['building_test'],
+            },
+            building_test: {
+                object: 'node',
+                id: 'building_test',
+                type: 'building',
+                parentId: 'site_test',
+                visible: true,
+                metadata: {},
+                children: ['level_test'],
+            },
+            level_test: {
+                object: 'node',
+                id: 'level_test',
+                type: 'level',
+                parentId: null,
+                visible: true,
+                metadata: {},
+                children: ['elevator_test'],
+                level: 0,
+            },
+            elevator_test: {
+                object: 'node',
+                id: 'elevator_test',
+                type: 'elevator',
+                parentId: 'level_test',
+                visible: true,
+                metadata: {},
+            },
+        }, ['site_test']);
+        const nodes = useScene.getState().nodes;
+        const elevator = nodes.elevator_test;
+        const level = nodes.level_test;
+        const building = nodes.building_test;
+        expect(elevator.parentId).toBe('building_test');
+        expect(level.children).not.toContain('elevator_test');
+        expect(building.children).toContain('elevator_test');
+    });
+});

package/dist/store/use-scene-measurement-roundtrip.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=use-scene-measurement-roundtrip.test.d.ts.map

package/dist/store/use-scene-measurement-roundtrip.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-scene-measurement-roundtrip.test.d.ts","sourceRoot":"","sources":["../../src/store/use-scene-measurement-roundtrip.test.ts"],"names":[],"mappings":""}

package/dist/store/use-scene-measurement-roundtrip.test.js

@@ -0,0 +1,97 @@
+import { beforeEach, describe, expect, test } from 'bun:test';
+import { AnyNode, BuildingNode, LevelNode, MeasurementNode, SiteNode, } from '../schema';
+import useScene from './use-scene';
+describe('scene measurement round-trip', () => {
+    beforeEach(() => {
+        useScene.setState({
+            nodes: {},
+            rootNodeIds: [],
+            dirtyNodes: new Set(),
+            collections: {},
+            materials: {},
+            readOnly: false,
+        });
+        useScene.temporal.getState().clear();
+    });
+    test('preserves a complete measurement graph across JSON and setScene', () => {
+        const distance = MeasurementNode.parse({
+            id: 'measurement_distance',
+            parentId: 'level_ground',
+            visible: false,
+            measurement: {
+                kind: 'distance',
+                points: [
+                    [0.25, 0.5, 0.75],
+                    [4.5, 2.25, 1.5],
+                ],
+            },
+        });
+        const area = MeasurementNode.parse({
+            id: 'measurement_area',
+            parentId: 'level_ground',
+            visible: true,
+            measurement: {
+                kind: 'area',
+                base: [
+                    [0, 0, 0],
+                    [3, 0, 0],
+                    [3, 0, 2],
+                    [0, 0, 2],
+                ],
+            },
+        });
+        const volume = MeasurementNode.parse({
+            id: 'measurement_volume',
+            parentId: 'level_ground',
+            visible: false,
+            measurement: {
+                kind: 'volume',
+                base: [
+                    [1, 0, 1],
+                    [3, 0, 1],
+                    [3, 0, 4],
+                    [1, 0, 4],
+                ],
+                extrusion: [0.5, 2.5, 0],
+            },
+        });
+        const level = LevelNode.parse({
+            id: 'level_ground',
+            parentId: 'building_main',
+            level: 0,
+            children: [distance.id, area.id, volume.id],
+        });
+        const building = BuildingNode.parse({
+            id: 'building_main',
+            parentId: 'site_measurements',
+            children: [level.id],
+        });
+        const site = SiteNode.parse({
+            id: 'site_measurements',
+            children: [building.id],
+        });
+        const nodes = Object.fromEntries([site, building, level, distance, area, volume].map((node) => [node.id, node]));
+        const serialized = JSON.stringify({ nodes, rootNodeIds: [site.id] });
+        const decoded = JSON.parse(serialized);
+        const parsedNodes = Object.fromEntries(Object.entries(decoded.nodes).map(([id, node]) => [id, AnyNode.parse(node)]));
+        useScene.getState().setScene(parsedNodes, decoded.rootNodeIds);
+        const reloaded = useScene.getState();
+        const reloadedSite = SiteNode.parse(reloaded.nodes[site.id]);
+        const reloadedBuilding = BuildingNode.parse(reloaded.nodes[building.id]);
+        const reloadedLevel = LevelNode.parse(reloaded.nodes[level.id]);
+        const reloadedMeasurements = [distance.id, area.id, volume.id].map((id) => MeasurementNode.parse(AnyNode.parse(reloaded.nodes[id])));
+        expect(reloaded.rootNodeIds).toEqual([site.id]);
+        expect(reloadedSite.children).toEqual([building.id]);
+        expect(reloadedBuilding.children).toEqual([level.id]);
+        expect(reloadedLevel.children).toEqual([distance.id, area.id, volume.id]);
+        expect(reloadedMeasurements.map((node) => ({
+            id: node.id,
+            visible: node.visible,
+            measurement: node.measurement,
+        }))).toEqual([
+            { id: distance.id, visible: false, measurement: distance.measurement },
+            { id: area.id, visible: true, measurement: area.measurement },
+            { id: volume.id, visible: false, measurement: volume.measurement },
+        ]);
+    });
+});

package/dist/store/use-scene-plugins.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=use-scene-plugins.test.d.ts.map

package/dist/store/use-scene-plugins.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-scene-plugins.test.d.ts","sourceRoot":"","sources":["../../src/store/use-scene-plugins.test.ts"],"names":[],"mappings":""}

package/dist/store/use-scene-plugins.test.js

@@ -0,0 +1,51 @@
+import { beforeEach, describe, expect, test } from 'bun:test';
+import { z } from 'zod';
+import { loadPlugin, nodeRegistry } from '../registry';
+import useScene from './use-scene';
+describe('scene plugin installation state', () => {
+    beforeEach(() => {
+        nodeRegistry._reset();
+        useScene.getState().setReadOnly(false);
+        useScene.getState().unloadScene();
+    });
+    test('loads an explicit installed plugin list with the scene', () => {
+        useScene.getState().setScene({}, [], {
+            installedPlugins: ['pascal:trees'],
+            hasExplicitPluginInstallState: true,
+        });
+        expect(useScene.getState().installedPlugins).toEqual(['pascal:trees']);
+        expect(useScene.getState().hasExplicitPluginInstallState).toBe(true);
+    });
+    test('install changes are de-duplicated and become explicit', () => {
+        useScene.getState().setInstalledPlugins(['pascal:trees', 'pascal:trees'], { explicit: true });
+        expect(useScene.getState().installedPlugins).toEqual(['pascal:trees']);
+        expect(useScene.getState().hasExplicitPluginInstallState).toBe(true);
+    });
+    test('clearing geometry preserves project plugin installs', () => {
+        useScene.getState().setInstalledPlugins(['pascal:trees'], { explicit: true });
+        useScene.getState().clearScene();
+        expect(useScene.getState().installedPlugins).toEqual(['pascal:trees']);
+        expect(useScene.getState().hasExplicitPluginInstallState).toBe(true);
+    });
+    test('uninstall clears plugin build work and reinstall schedules it again', async () => {
+        const kind = 'test:plugin-node';
+        const definition = {
+            kind,
+            schemaVersion: 1,
+            schema: z.object({ id: z.string(), type: z.literal(kind) }),
+            category: 'utility',
+            defaults: () => ({}),
+            capabilities: {},
+        };
+        await loadPlugin({ id: 'test:plugin', apiVersion: 1, nodes: [definition] });
+        const nodeId = 'plugin_node';
+        useScene.getState().setScene({
+            [nodeId]: { id: nodeId, type: kind },
+        }, [nodeId], { installedPlugins: ['test:plugin'], hasExplicitPluginInstallState: true });
+        expect(useScene.getState().dirtyNodes.has(nodeId)).toBe(true);
+        useScene.getState().setInstalledPlugins([], { explicit: true });
+        expect(useScene.getState().dirtyNodes.has(nodeId)).toBe(false);
+        useScene.getState().setInstalledPlugins(['test:plugin'], { explicit: true });
+        expect(useScene.getState().dirtyNodes.has(nodeId)).toBe(true);
+    });
+});

package/dist/store/use-scene-wall-slot-migration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=use-scene-wall-slot-migration.test.d.ts.map

package/dist/store/use-scene-wall-slot-migration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-scene-wall-slot-migration.test.d.ts","sourceRoot":"","sources":["../../src/store/use-scene-wall-slot-migration.test.ts"],"names":[],"mappings":""}