@montra-interactive/deepstate 0.1.0

package/dist/deepstate.js

@@ -0,0 +1,881 @@
+/**
+ * deepstate v2 - Nested BehaviorSubjects Architecture
+ *
+ * Each property has its own observable that emits standalone.
+ * Parent notifications flow upward automatically via RxJS subscriptions.
+ * Siblings are never notified.
+ *
+ * Architecture:
+ * - Leaves (primitives): BehaviorSubject is source of truth
+ * - Objects: combineLatest(children) derives the observable, children are source of truth
+ * - Arrays: BehaviorSubject<T[]> is source of truth, children are projections
+ */
+import { BehaviorSubject, combineLatest, of } from "rxjs";
+import { map, distinctUntilChanged, shareReplay, take, filter, } from "rxjs/operators";
+// =============================================================================
+// Counters for performance comparison
+// =============================================================================
+export let distinctCallCount = 0;
+export function resetDistinctCallCount() {
+    distinctCallCount = 0;
+}
+// Wrap distinctUntilChanged to count calls
+function countedDistinctUntilChanged(compareFn) {
+    return distinctUntilChanged((a, b) => {
+        distinctCallCount++;
+        if (compareFn)
+            return compareFn(a, b);
+        return a === b;
+    });
+}
+// =============================================================================
+// Deep Freeze
+// =============================================================================
+function deepFreeze(obj) {
+    if (obj === null || typeof obj !== "object")
+        return obj;
+    if (Object.isFrozen(obj))
+        return obj;
+    Object.freeze(obj);
+    if (Array.isArray(obj)) {
+        obj.forEach((item) => deepFreeze(item));
+    }
+    else {
+        Object.keys(obj).forEach((key) => {
+            deepFreeze(obj[key]);
+        });
+    }
+    return obj;
+}
+// Symbols for internal access
+const NODE = Symbol("node");
+// =============================================================================
+// Node Creation
+// =============================================================================
+function createLeafNode(value) {
+    const subject$ = new BehaviorSubject(value);
+    // Use distinctUntilChanged to prevent duplicate emissions for same value
+    const distinct$ = subject$.pipe(distinctUntilChanged(), shareReplay(1));
+    // Keep hot
+    distinct$.subscribe();
+    return {
+        $: distinct$,
+        get: () => subject$.getValue(),
+        set: (v) => subject$.next(v),
+        subscribeOnce: (callback) => {
+            return distinct$.pipe(take(1)).subscribe(callback);
+        },
+    };
+}
+function createObjectNode(value) {
+    const keys = Object.keys(value);
+    const children = new Map();
+    // Create child nodes for each property
+    // Pass maybeNullable: true so null values get NullableNodeCore
+    // which can be upgraded to objects later
+    for (const key of keys) {
+        children.set(key, createNodeForValue(value[key], true));
+    }
+    // Helper to get current value from children
+    const getCurrentValue = () => {
+        const result = {};
+        for (const [key, child] of children) {
+            result[key] = child.get();
+        }
+        return result;
+    };
+    // Handle empty objects
+    if (keys.length === 0) {
+        const empty$ = of(value).pipe(shareReplay(1));
+        return {
+            $: empty$,
+            children: children,
+            get: () => ({}),
+            set: () => { }, // No-op for empty objects
+            lock: () => { }, // No-op for empty objects
+            unlock: () => { }, // No-op for empty objects
+        };
+    }
+    // Lock for batching updates - when false, emissions are filtered out
+    const lock$ = new BehaviorSubject(true);
+    // Derive observable from children + lock using combineLatest
+    const childObservables = keys.map((key) => children.get(key).$);
+    const $ = combineLatest([...childObservables, lock$]).pipe(
+    // Only emit when unlocked (lock is last element)
+    filter((values) => values[values.length - 1] === true), 
+    // Remove lock value from output, reconstruct object
+    map((values) => {
+        const result = {};
+        keys.forEach((key, i) => {
+            result[key] = values[i];
+        });
+        return result;
+    }), shareReplay(1));
+    // Force subscription to make it hot (so emissions work even before external subscribers)
+    $.subscribe();
+    // Create a version that freezes on emission
+    const frozen$ = $.pipe(map(deepFreeze));
+    return {
+        $: frozen$,
+        children: children,
+        get: () => deepFreeze(getCurrentValue()),
+        set: (v) => {
+            for (const [key, child] of children) {
+                child.set(v[key]);
+            }
+        },
+        lock: () => lock$.next(false),
+        unlock: () => lock$.next(true),
+        // Note: update() is implemented in wrapWithProxy since it needs the proxy reference
+        subscribeOnce: (callback) => {
+            return frozen$.pipe(take(1)).subscribe(callback);
+        },
+    };
+}
+function createArrayNode(value) {
+    const subject$ = new BehaviorSubject([...value]);
+    const childCache = new Map();
+    const createChildProjection = (index) => {
+        const currentValue = subject$.getValue()[index];
+        // If the element is an object, we need nested access
+        // Create a "projection node" that reads/writes through the parent array
+        if (currentValue !== null && typeof currentValue === "object") {
+            return createArrayElementObjectNode(subject$, index, currentValue);
+        }
+        // Primitive element - simple projection
+        const element$ = subject$.pipe(map((arr) => arr[index]), countedDistinctUntilChanged(), shareReplay(1));
+        // Force hot
+        element$.subscribe();
+        return {
+            $: element$,
+            get: () => subject$.getValue()[index],
+            set: (v) => {
+                const arr = [...subject$.getValue()];
+                arr[index] = v;
+                subject$.next(arr);
+            },
+            subscribeOnce: (callback) => {
+                return element$.pipe(take(1)).subscribe(callback);
+            },
+        };
+    };
+    // Lock for batching updates - when false, emissions are filtered out
+    const lock$ = new BehaviorSubject(true);
+    // Create observable that respects lock
+    const locked$ = combineLatest([subject$, lock$]).pipe(filter(([_, unlocked]) => unlocked), map(([arr, _]) => arr), map(deepFreeze), shareReplay(1));
+    locked$.subscribe(); // Keep hot
+    // Length observable (also respects lock)
+    const length$ = locked$.pipe(map((arr) => arr.length), distinctUntilChanged(), shareReplay(1));
+    length$.subscribe(); // Keep hot
+    const lengthWithGet = Object.assign(length$, {
+        get: () => subject$.getValue().length,
+    });
+    return {
+        $: locked$,
+        childCache,
+        get: () => deepFreeze([...subject$.getValue()]),
+        set: (v) => {
+            // Clear child cache when array is replaced
+            childCache.clear();
+            subject$.next([...v]);
+        },
+        subscribeOnce: (callback) => {
+            return locked$.pipe(take(1)).subscribe(callback);
+        },
+        at: (index) => {
+            const arr = subject$.getValue();
+            if (index < 0 || index >= arr.length)
+                return undefined;
+            if (!childCache.has(index)) {
+                childCache.set(index, createChildProjection(index));
+            }
+            return childCache.get(index);
+        },
+        length$: lengthWithGet,
+        push: (...items) => {
+            const current = subject$.getValue();
+            const newArr = [...current, ...items];
+            subject$.next(newArr);
+            return newArr.length;
+        },
+        pop: () => {
+            const current = subject$.getValue();
+            if (current.length === 0)
+                return undefined;
+            const last = current[current.length - 1];
+            // Clear cached node for popped index
+            childCache.delete(current.length - 1);
+            subject$.next(current.slice(0, -1));
+            return deepFreeze(last);
+        },
+        mapItems: (fn) => {
+            return subject$.getValue().map((item, i) => fn(deepFreeze(item), i));
+        },
+        filterItems: (fn) => {
+            return deepFreeze(subject$.getValue().filter((item, i) => fn(deepFreeze(item), i)));
+        },
+        lock: () => lock$.next(false),
+        unlock: () => lock$.next(true),
+        // Note: update() is implemented in wrapWithProxy since it needs the proxy reference
+    };
+}
+// Symbol to mark nullable nodes
+const NULLABLE_NODE = Symbol("nullableNode");
+/**
+ * Creates a node for nullable object types like `{ name: string } | null`
+ *
+ * When value is null: no children exist, child access returns undefined
+ * When value is set to object: children are created lazily from the object's keys
+ */
+function createNullableObjectNode(initialValue) {
+    // Subject holds the raw value (null or object)
+    const subject$ = new BehaviorSubject(initialValue);
+    // Children are created lazily when we have an actual object
+    let children = null;
+    // Pending children - created for deep subscription before parent has a value
+    // These are "projection" nodes that derive from the parent observable
+    const pendingChildren = new Map();
+    // Lock for batching updates
+    const lock$ = new BehaviorSubject(true);
+    // Build/rebuild children from an object value
+    const buildChildren = (obj) => {
+        const keys = Object.keys(obj);
+        children = new Map();
+        for (const key of keys) {
+            children.set(key, createNodeForValue(obj[key]));
+        }
+    };
+    // Initialize children if starting with an object
+    if (initialValue !== null && initialValue !== undefined && typeof initialValue === "object") {
+        buildChildren(initialValue);
+    }
+    // Helper to get current value
+    const getCurrentValue = () => {
+        const raw = subject$.getValue();
+        if (raw === null || raw === undefined || !children) {
+            return raw;
+        }
+        // Build value from children
+        const result = {};
+        for (const [key, child] of children) {
+            result[key] = child.get();
+        }
+        return result;
+    };
+    // Observable that emits the current value, respecting lock
+    const $ = combineLatest([subject$, lock$]).pipe(filter(([_, unlocked]) => unlocked), map(([value, _]) => {
+        if (value === null || value === undefined || !children) {
+            return value;
+        }
+        // Build from children for consistency
+        const result = {};
+        for (const [key, child] of children) {
+            result[key] = child.get();
+        }
+        return result;
+    }), distinctUntilChanged((a, b) => {
+        if (a === null || a === undefined)
+            return a === b;
+        if (b === null || b === undefined)
+            return false;
+        return JSON.stringify(a) === JSON.stringify(b);
+    }), map(deepFreeze), shareReplay(1));
+    $.subscribe(); // Keep hot
+    // Create a stable reference object that we can update
+    const nodeState = { children };
+    // Wrapper to update the children reference
+    const updateChildrenRef = () => {
+        nodeState.children = children;
+    };
+    // Override buildChildren to update the reference and connect pending children
+    const buildChildrenAndUpdate = (obj) => {
+        const keys = Object.keys(obj);
+        children = new Map();
+        for (const key of keys) {
+            // Pass maybeNullable: true so nested nulls also become nullable nodes
+            children.set(key, createNodeForValue(obj[key], true));
+        }
+        updateChildrenRef();
+        // Connect pending children to their real counterparts
+        for (const [key, pendingNode] of pendingChildren) {
+            if (children.has(key) && '_subscribeToRealChild' in pendingNode) {
+                pendingNode._subscribeToRealChild();
+            }
+        }
+    };
+    // Re-initialize if starting with object (using updated builder)
+    if (initialValue !== null && initialValue !== undefined && typeof initialValue === "object") {
+        children = null; // Reset
+        buildChildrenAndUpdate(initialValue);
+    }
+    return {
+        [NULLABLE_NODE]: true,
+        $,
+        get children() { return nodeState.children; },
+        get: () => deepFreeze(getCurrentValue()),
+        set: (value) => {
+            if (value === null || value === undefined) {
+                // Setting to null - keep children structure for potential reuse but emit null
+                subject$.next(value);
+            }
+            else if (typeof value === "object") {
+                // Setting to object
+                if (!children) {
+                    // First time setting an object - create children
+                    buildChildrenAndUpdate(value);
+                }
+                else {
+                    // Update existing children + handle new/removed keys
+                    const newKeys = new Set(Object.keys(value));
+                    const existingKeys = new Set(children.keys());
+                    // Update existing children
+                    for (const [key, child] of children) {
+                        if (newKeys.has(key)) {
+                            child.set(value[key]);
+                        }
+                    }
+                    // Add new keys
+                    for (const key of newKeys) {
+                        if (!existingKeys.has(key)) {
+                            children.set(key, createNodeForValue(value[key], true));
+                        }
+                    }
+                    // Note: We don't remove keys that are no longer present
+                    // This maintains reactivity for subscribers to those keys
+                }
+                subject$.next(value);
+            }
+        },
+        getChild: (key) => {
+            // Return undefined if null or no children
+            const value = subject$.getValue();
+            if (value === null || value === undefined || !children) {
+                return undefined;
+            }
+            return children.get(key);
+        },
+        getOrCreateChild: (key) => {
+            // If we have real children and the key exists, return the real child
+            if (children && children.has(key)) {
+                return children.get(key);
+            }
+            // Check pendingChildren for already-created pending nodes
+            if (pendingChildren.has(key)) {
+                // Even though we have a pending node, if children now exist, return the real child
+                // This handles the case where parent was set after pending node was created
+                if (children && children.has(key)) {
+                    return children.get(key);
+                }
+                return pendingChildren.get(key);
+            }
+            // Create a "pending" child node that derives its value dynamically
+            // When parent is null: emits undefined
+            // When parent has value and real children exist: delegates to real child's observable
+            // When parent has value but real children don't exist yet: extracts from parent value
+            // We use a BehaviorSubject that we manually keep in sync
+            const pendingSubject$ = new BehaviorSubject(undefined);
+            // Subscribe to parent changes to update pending subject
+            const parentSubscription = subject$.subscribe((parentValue) => {
+                if (parentValue === null || parentValue === undefined) {
+                    pendingSubject$.next(undefined);
+                }
+                else if (children && children.has(key)) {
+                    // Real child exists - get its current value
+                    pendingSubject$.next(children.get(key).get());
+                }
+                else {
+                    // Extract from parent value
+                    pendingSubject$.next(parentValue[key]);
+                }
+            });
+            // Also, we need to subscribe to real child changes when it exists
+            // We'll do this by tracking when children are created and subscribing
+            let realChildSubscription = null;
+            const child$ = pendingSubject$.pipe(distinctUntilChanged(), shareReplay(1));
+            child$.subscribe(); // Keep hot
+            const pendingNode = {
+                $: child$,
+                get: () => {
+                    const parentValue = subject$.getValue();
+                    if (parentValue === null || parentValue === undefined) {
+                        return undefined;
+                    }
+                    // If real children exist now, delegate to them
+                    if (children && children.has(key)) {
+                        return children.get(key).get();
+                    }
+                    return parentValue[key];
+                },
+                set: (value) => {
+                    const parentValue = subject$.getValue();
+                    if (parentValue === null || parentValue === undefined) {
+                        // Can't set on null parent - this is a no-op
+                        return;
+                    }
+                    // If real children exist, delegate to them
+                    if (children && children.has(key)) {
+                        children.get(key).set(value);
+                        return;
+                    }
+                    // Otherwise update the parent directly
+                    const newParent = { ...parentValue, [key]: value };
+                    subject$.next(newParent);
+                },
+                _subscribeToRealChild: () => {
+                    // Called when real children are created to subscribe to child changes
+                    if (children && children.has(key) && !realChildSubscription) {
+                        realChildSubscription = children.get(key).$.subscribe((value) => {
+                            pendingSubject$.next(value);
+                        });
+                    }
+                },
+            };
+            pendingChildren.set(key, pendingNode);
+            return pendingNode;
+        },
+        isNull: () => {
+            const value = subject$.getValue();
+            return value === null || value === undefined;
+        },
+        lock: () => lock$.next(false),
+        unlock: () => lock$.next(true),
+        subscribeOnce: (callback) => {
+            return $.pipe(take(1)).subscribe(callback);
+        },
+    };
+}
+// Type guard for nullable nodes
+function isNullableNode(node) {
+    return NULLABLE_NODE in node;
+}
+// Special node for object elements within arrays
+// These project from the parent array but support nested property access
+function createArrayElementObjectNode(parentArray$, index, initialValue) {
+    const keys = Object.keys(initialValue);
+    const children = new Map();
+    // Create child nodes that project through the array
+    for (const key of keys) {
+        children.set(key, createArrayElementPropertyNode(parentArray$, index, key, initialValue[key]));
+    }
+    // Handle empty objects
+    if (keys.length === 0) {
+        const element$ = parentArray$.pipe(map((arr) => arr[index]), countedDistinctUntilChanged(), shareReplay(1));
+        element$.subscribe();
+        return {
+            $: element$,
+            children,
+            get: () => parentArray$.getValue()[index],
+            set: (v) => {
+                const arr = [...parentArray$.getValue()];
+                arr[index] = v;
+                parentArray$.next(arr);
+            },
+        };
+    }
+    // Derive from children
+    const childObservables = keys.map((key) => children.get(key).$);
+    const $ = combineLatest(childObservables).pipe(map((values) => {
+        const result = {};
+        keys.forEach((key, i) => {
+            result[key] = values[i];
+        });
+        return result;
+    }), countedDistinctUntilChanged((a, b) => JSON.stringify(a) === JSON.stringify(b)), shareReplay(1));
+    $.subscribe();
+    return {
+        $,
+        children,
+        get: () => {
+            const result = {};
+            for (const [key, child] of children) {
+                result[key] = child.get();
+            }
+            return result;
+        },
+        set: (v) => {
+            // Update parent array directly
+            const arr = [...parentArray$.getValue()];
+            arr[index] = v;
+            parentArray$.next(arr);
+            // Note: This causes children to be out of sync until they re-read from parent
+            // For simplicity, we update children too
+            for (const [key, child] of children) {
+                child.set(v[key]);
+            }
+        },
+    };
+}
+// Node for a property of an object inside an array
+function createArrayElementPropertyNode(parentArray$, index, key, initialValue) {
+    // If nested object/array, recurse
+    if (initialValue !== null && typeof initialValue === "object") {
+        if (Array.isArray(initialValue)) {
+            // Nested array inside array element - create projection
+            return createNestedArrayProjection(parentArray$, index, key, initialValue);
+        }
+        // Nested object inside array element
+        return createNestedObjectProjection(parentArray$, index, key, initialValue);
+    }
+    // Primitive property
+    const prop$ = parentArray$.pipe(map((arr) => arr[index]?.[key]), countedDistinctUntilChanged(), shareReplay(1));
+    prop$.subscribe();
+    return {
+        $: prop$,
+        get: () => {
+            const arr = parentArray$.getValue();
+            return arr[index]?.[key];
+        },
+        set: (v) => {
+            const arr = [...parentArray$.getValue()];
+            arr[index] = { ...arr[index], [key]: v };
+            parentArray$.next(arr);
+        },
+    };
+}
+// Nested object projection (object property inside array element)
+function createNestedObjectProjection(parentArray$, index, key, initialValue) {
+    const keys = Object.keys(initialValue);
+    const children = new Map();
+    // For each property of the nested object
+    for (const nestedKey of keys) {
+        // Create a projection for this nested property
+        const nested$ = parentArray$.pipe(map((arr) => {
+            const element = arr[index];
+            const obj = element?.[key];
+            return obj?.[nestedKey];
+        }), countedDistinctUntilChanged(), shareReplay(1));
+        nested$.subscribe();
+        children.set(nestedKey, {
+            $: nested$,
+            get: () => {
+                const arr = parentArray$.getValue();
+                const element = arr[index];
+                const obj = element?.[key];
+                return obj?.[nestedKey];
+            },
+            set: (v) => {
+                const arr = [...parentArray$.getValue()];
+                const element = { ...arr[index] };
+                element[key] = { ...element[key], [nestedKey]: v };
+                arr[index] = element;
+                parentArray$.next(arr);
+            },
+        });
+    }
+    // Derive observable from children or parent
+    const obj$ = parentArray$.pipe(map((arr) => arr[index]?.[key]), countedDistinctUntilChanged((a, b) => JSON.stringify(a) === JSON.stringify(b)), shareReplay(1));
+    obj$.subscribe();
+    return {
+        $: obj$,
+        children,
+        get: () => {
+            const arr = parentArray$.getValue();
+            return arr[index]?.[key];
+        },
+        set: (v) => {
+            const arr = [...parentArray$.getValue()];
+            arr[index] = { ...arr[index], [key]: v };
+            parentArray$.next(arr);
+        },
+    };
+}
+// Nested array projection (array property inside array element)
+function createNestedArrayProjection(parentArray$, index, key, initialValue) {
+    const arr$ = parentArray$.pipe(map((arr) => arr[index]?.[key]), countedDistinctUntilChanged((a, b) => JSON.stringify(a) === JSON.stringify(b)), shareReplay(1));
+    arr$.subscribe();
+    return {
+        $: arr$,
+        get: () => {
+            const arr = parentArray$.getValue();
+            return arr[index]?.[key];
+        },
+        set: (v) => {
+            const arr = [...parentArray$.getValue()];
+            arr[index] = { ...arr[index], [key]: v };
+            parentArray$.next(arr);
+        },
+    };
+}
+// Factory to create the right node type
+// When maybeNullable is true and value is null/undefined, creates a NullableNodeCore
+// that can later be upgraded to an object with children
+function createNodeForValue(value, maybeNullable = false) {
+    // Check for nullable marker (from nullable() helper)
+    if (isNullableMarked(value)) {
+        // Remove the marker before creating the node
+        delete value[NULLABLE_MARKER];
+        return createNullableObjectNode(value);
+    }
+    if (value === null || value === undefined) {
+        if (maybeNullable) {
+            // Create nullable node that can be upgraded to object later
+            return createNullableObjectNode(value);
+        }
+        return createLeafNode(value);
+    }
+    if (typeof value !== "object") {
+        return createLeafNode(value);
+    }
+    if (Array.isArray(value)) {
+        return createArrayNode(value);
+    }
+    return createObjectNode(value);
+}
+// =============================================================================
+// Proxy Wrapper
+// =============================================================================
+/**
+ * Wraps a nullable object node with a proxy that:
+ * - Returns undefined for child property access when value is null
+ * - Creates/returns wrapped children when value is non-null
+ * - Provides update() for batched updates
+ */
+function wrapNullableWithProxy(node) {
+    // Create update function
+    const update = (callback) => {
+        node.lock();
+        try {
+            // Build a proxy for the children
+            const childrenProxy = new Proxy({}, {
+                get(_, prop) {
+                    if (typeof prop === "string") {
+                        const child = node.getChild(prop);
+                        if (child) {
+                            return wrapWithProxy(child);
+                        }
+                    }
+                    return undefined;
+                },
+            });
+            callback(childrenProxy);
+        }
+        finally {
+            node.unlock();
+        }
+        return node.get();
+    };
+    const proxy = new Proxy(node.$, {
+        get(target, prop) {
+            // Observable methods
+            if (prop === "subscribe")
+                return node.$.subscribe.bind(node.$);
+            if (prop === "pipe")
+                return node.$.pipe.bind(node.$);
+            if (prop === "forEach")
+                return node.$.forEach?.bind(node.$);
+            // Node methods
+            if (prop === "get")
+                return node.get;
+            if (prop === "set")
+                return node.set;
+            if (prop === "update")
+                return update;
+            if (prop === "subscribeOnce")
+                return node.subscribeOnce;
+            if (prop === NODE)
+                return node;
+            // Symbol.observable for RxJS interop
+            if (prop === Symbol.observable || prop === "@@observable") {
+                return () => node.$;
+            }
+            // Child property access - uses getOrCreateChild for deep subscription support
+            // This means store.user.age.subscribe() works even when user is null
+            if (typeof prop === "string") {
+                const child = node.getOrCreateChild(prop);
+                return wrapWithProxy(child);
+            }
+            // Fallback to observable properties
+            if (prop in target) {
+                const val = target[prop];
+                return typeof val === "function" ? val.bind(target) : val;
+            }
+            return undefined;
+        },
+        has(_, prop) {
+            // When value is non-null and we have children, check if prop exists
+            if (!node.isNull() && node.children && typeof prop === "string") {
+                return node.children.has(prop);
+            }
+            return false;
+        },
+        ownKeys() {
+            if (!node.isNull() && node.children) {
+                return Array.from(node.children.keys());
+            }
+            return [];
+        },
+        getOwnPropertyDescriptor(_, prop) {
+            if (!node.isNull() && node.children && typeof prop === "string" && node.children.has(prop)) {
+                return { enumerable: true, configurable: true };
+            }
+            return undefined;
+        },
+    });
+    return proxy;
+}
+function wrapWithProxy(node) {
+    // Check for nullable node first (before checking value, since value might be null)
+    if (isNullableNode(node)) {
+        return wrapNullableWithProxy(node);
+    }
+    const value = node.get();
+    // Primitive - just attach methods to observable
+    if (value === null || typeof value !== "object") {
+        return Object.assign(node.$, {
+            get: node.get,
+            set: node.set,
+            subscribe: node.$.subscribe.bind(node.$),
+            pipe: node.$.pipe.bind(node.$),
+            subscribeOnce: node.subscribeOnce,
+            [NODE]: node,
+        });
+    }
+    // Array
+    if (Array.isArray(value)) {
+        const arrayNode = node;
+        // Create the wrapped result first so we can reference it in update
+        const wrapped = Object.assign(node.$, {
+            get: node.get,
+            set: node.set,
+            subscribe: node.$.subscribe.bind(node.$),
+            pipe: node.$.pipe.bind(node.$),
+            subscribeOnce: node.subscribeOnce,
+            at: (index) => {
+                const child = arrayNode.at(index);
+                if (!child)
+                    return undefined;
+                return wrapWithProxy(child);
+            },
+            length: arrayNode.length$,
+            push: arrayNode.push,
+            pop: arrayNode.pop,
+            map: arrayNode.mapItems,
+            filter: arrayNode.filterItems,
+            update: (callback) => {
+                arrayNode.lock(); // Lock - suppress emissions
+                try {
+                    callback(wrapped); // Pass wrapped array so user can use .at(), .push(), etc.
+                }
+                finally {
+                    arrayNode.unlock(); // Unlock - emit final state
+                }
+                return node.get();
+            },
+            [NODE]: node,
+        });
+        return wrapped;
+    }
+    // Object - use Proxy for property access
+    const objectNode = node;
+    // Create update function that has access to the proxy (defined after proxy creation)
+    let updateFn;
+    const proxy = new Proxy(node.$, {
+        get(target, prop) {
+            // Observable methods
+            if (prop === "subscribe")
+                return node.$.subscribe.bind(node.$);
+            if (prop === "pipe")
+                return node.$.pipe.bind(node.$);
+            if (prop === "forEach")
+                return node.$.forEach?.bind(node.$);
+            // Node methods
+            if (prop === "get")
+                return node.get;
+            if (prop === "set")
+                return node.set;
+            if (prop === "update")
+                return updateFn;
+            if (prop === "subscribeOnce")
+                return node.subscribeOnce;
+            if (prop === NODE)
+                return node;
+            // Symbol.observable for RxJS interop
+            if (prop === Symbol.observable || prop === "@@observable") {
+                return () => node.$;
+            }
+            // Child property access
+            if (objectNode.children && typeof prop === "string") {
+                const child = objectNode.children.get(prop);
+                if (child) {
+                    return wrapWithProxy(child);
+                }
+            }
+            // Fallback to observable properties
+            if (prop in target) {
+                const val = target[prop];
+                return typeof val === "function" ? val.bind(target) : val;
+            }
+            return undefined;
+        },
+        has(target, prop) {
+            if (objectNode.children && typeof prop === "string") {
+                return objectNode.children.has(prop);
+            }
+            return prop in target;
+        },
+        ownKeys() {
+            if (objectNode.children) {
+                return Array.from(objectNode.children.keys());
+            }
+            return [];
+        },
+        getOwnPropertyDescriptor(target, prop) {
+            if (objectNode.children && typeof prop === "string" && objectNode.children.has(prop)) {
+                return { enumerable: true, configurable: true };
+            }
+            return undefined;
+        },
+    });
+    // Now define update function with access to proxy
+    if (objectNode.lock && objectNode.unlock) {
+        updateFn = (callback) => {
+            objectNode.lock(); // Lock - suppress emissions
+            try {
+                callback(proxy); // Pass the proxy so user can call .set() on children
+            }
+            finally {
+                objectNode.unlock(); // Unlock - emit final state
+            }
+            return node.get();
+        };
+    }
+    return proxy;
+}
+// =============================================================================
+// Public API
+// =============================================================================
+export function state(initialState) {
+    const node = createObjectNode(initialState);
+    return wrapWithProxy(node);
+}
+// Symbol to mark a value as nullable
+const NULLABLE_MARKER = Symbol("nullable");
+/**
+ * Marks a value as nullable, allowing it to transition between null and object.
+ * Use this when you want to start with an object value but later set it to null.
+ *
+ * @example
+ * const store = state({
+ *   // Can start with object and later be set to null
+ *   user: nullable({ name: "Alice", age: 30 }),
+ *   // Can start with null and later be set to object
+ *   profile: nullable<{ bio: string }>(null),
+ * });
+ *
+ * // Use ?. on the nullable property, then access children directly
+ * store.user?.set(null);  // Works!
+ * store.user?.set({ name: "Bob", age: 25 });  // Works!
+ * store.user?.name.set("Charlie");  // After ?. on user, children are directly accessible
+ */
+export function nullable(value) {
+    if (value === null) {
+        return null;
+    }
+    // Mark the object so createNodeForValue knows to use NullableNodeCore
+    return Object.assign(value, { [NULLABLE_MARKER]: true });
+}
+// Check if a value was marked as nullable
+function isNullableMarked(value) {
+    return value !== null && typeof value === "object" && NULLABLE_MARKER in value;
+}
+//# sourceMappingURL=deepstate.js.map