@volynets/reflex-store 0.0.0-stage → 0.0.2

package/dist/chunks/createStore-DHj16Ehk.js

@@ -0,0 +1,12 @@
+/**
+ * Declares a compile-time store shape for the compiled-store transform.
+ *
+ * Data properties become leaf cells; methods become batched actions; getters
+ * become lazy computed values. leaf() and opaque() mark object values as
+ * replaceable leaves. If this function executes at runtime, the transform did
+ * not run.
+ */ function createStore(_shape, _options) {
+    throw new Error("createStore() is a compile-time API and must be erased by a transform before runtime.");
+}
+
+export { createStore as c };

package/dist/chunks/hydrate-DMnHCI5q.js

@@ -0,0 +1,138 @@
+import { d as createDerivedProjection } from './keyed-CQKtL8a7.js';
+import { i as isPlain, h as getStoreControl, j as depthOf } from './values-DCB6zyMz.js';
+import { untracked } from '@volynets/reflex-runtime/internal';
+import { t as transaction } from './collections-yHy0wH0f.js';
+
+/** Marks one compiled store value as a replaceable leaf. */ function leaf(value) {
+    return value;
+}
+
+/**
+ * Creates a lazy, read-only structured projection from a pure-return callback.
+ * Return a plain object; use reactiveMap for state with dynamic keys.
+ */ function derive(compute, options = {}) {
+    return createDerivedProjection(()=>{
+        const value = compute();
+        if (!isPlain(value) || Array.isArray(value)) throw new TypeError("derive() must return a plain object");
+        return value;
+    }, options);
+}
+
+/** Wrap one synchronous logical state change, preserving arguments and receiver. */ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+function action(callback) {
+    if (Object.prototype.toString.call(callback) === "[object AsyncFunction]") throw new TypeError("action() requires a synchronous callback");
+    let receiver;
+    let arguments_;
+    // Reuse executors; save/restore the frame for recursion and eager re-entry.
+    const invoke = ()=>{
+        const result = callback.apply(receiver, arguments_);
+        if (result && typeof result.then === "function") throw new TypeError("action() cannot return a promise");
+        return result;
+    };
+    const execute = ()=>transaction(invoke);
+    return function(...args) {
+        const previousReceiver = receiver;
+        const previousArguments = arguments_;
+        // Reuse one executor frame while preserving receiver across recursive actions.
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        receiver = this;
+        arguments_ = args;
+        try {
+            return untracked(execute);
+        } finally{
+            receiver = previousReceiver;
+            arguments_ = previousArguments;
+        }
+    };
+}
+
+const hydrationShapes = new WeakMap();
+function hydrationShape(control) {
+    const cached = hydrationShapes.get(control);
+    if (cached) return cached;
+    const branches = control.branches.map((path)=>({
+            path,
+            keys: new Set()
+        }));
+    const parents = new Map(branches.map((branch)=>[
+            JSON.stringify(branch.path),
+            branch
+        ]));
+    for (const candidates of [
+        control.paths,
+        control.branches
+    ]){
+        for (const path of candidates){
+            if (path.length === 0) continue;
+            parents.get(JSON.stringify(path.slice(0, -1)))?.keys.add(path[path.length - 1]);
+        }
+    }
+    hydrationShapes.set(control, branches);
+    return branches;
+}
+/** Restore all compiled data fields after validating the complete static schema. */ function hydrate(store, data) {
+    const control = getStoreControl(store);
+    if (!control?.hydrate || !control.paths || !control.branches) throw new TypeError("hydrate() requires a compiled store");
+    untracked(()=>{
+        for (const { path, keys } of hydrationShape(control)){
+            const branch = readPath(data, path);
+            if (!isPlain(branch) || Array.isArray(branch)) throw new TypeError("Invalid hydration branch: " + path.join("."));
+            const actual = Reflect.ownKeys(branch);
+            if (actual.length !== keys.size) throw new TypeError("Hydration data does not match the compiled store shape");
+            for (const key of actual)if (typeof key !== "string" || !keys.has(key)) throw new TypeError("Hydration data does not match the compiled store shape");
+        }
+        const seen = new Map();
+        const paths = control.paths;
+        const ordered = new Array(paths.length);
+        for(let i = 0; i < paths.length; i++)ordered[i] = restoreValue(readPath(data, paths[i]), seen);
+        transaction(()=>control.hydrate(ordered));
+    });
+}
+function restoreValue(value, seen) {
+    if (value === null || typeof value !== "object" || depthOf(value) === "opaque") return value;
+    const cached = seen.get(value);
+    if (cached !== undefined) return cached;
+    if (value instanceof Map) {
+        const result = new Map();
+        seen.set(value, result);
+        for (const [key, item] of value)result.set(key, restoreValue(item, seen));
+        return result;
+    }
+    if (value instanceof Set) {
+        const result = new Set(value);
+        seen.set(value, result);
+        return result;
+    }
+    if (!isPlain(value)) return value;
+    const array = Array.isArray(value);
+    const result = array ? [] : Object.create(Object.getPrototypeOf(value));
+    seen.set(value, result);
+    const output = {
+        configurable: true,
+        writable: true,
+        enumerable: true,
+        value: undefined
+    };
+    for (const key of Reflect.ownKeys(value)){
+        if (array && key === "length") continue;
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!("value" in descriptor)) throw new TypeError("Hydration values must contain data properties");
+        output.enumerable = descriptor.enumerable;
+        output.value = restoreValue(descriptor.value, seen);
+        Object.defineProperty(result, key, output);
+    }
+    if (array) result.length = value.length;
+    return result;
+}
+function readPath(data, path) {
+    let value = data;
+    for (const key of path){
+        if (value === null || typeof value !== "object") throw new TypeError("Missing hydration field: " + path.join("."));
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!descriptor || !("value" in descriptor)) throw new TypeError("Hydration fields must be own data properties: " + path.join("."));
+        value = descriptor.value;
+    }
+    return value;
+}
+
+export { action as a, derive as d, hydrate as h, leaf as l };

package/dist/chunks/keyed-CQKtL8a7.js

@@ -0,0 +1,383 @@
+import { setCurrentConsumer, currentConsumer, createConsumer, readConsumerLazy, disposeNode, untracked, unlinkAllSources, CONSUMER_INITIAL_STATE, createProducer, disposeWatcher, createWatcher, runWatcher, Both, readProducer, writeProducer } from '@volynets/reflex-runtime/internal';
+import { f as cloneValue, g as storeControls, j as depthOf, k as isStructural } from './values-DCB6zyMz.js';
+import { a as storeName, s as setStoreName } from './names-Cx4YcvsH.js';
+import { readProjectionPath } from '../selectors/shared.js';
+import { t as transaction } from './collections-yHy0wH0f.js';
+
+/** A memo with owner-controlled suspension; no node exists until its first read. */ class Demand {
+    constructor(compute){
+        this.compute = compute;
+        this.disposed = false;
+    }
+    read() {
+        if (this.disposed) throw new Error("Cannot read a disposed store derivation");
+        const node = this.node ??= createConsumer(this.compute);
+        return readConsumerLazy.call(node);
+    }
+    peek() {
+        return untracked(()=>this.read());
+    }
+    collect() {
+        const node = this.node;
+        if (!node || node.firstOut !== null) return;
+        unlinkAllSources(node);
+        node.state = CONSUMER_INITIAL_STATE;
+        node.payload = undefined;
+    }
+    dispose() {
+        this.disposed = true;
+        if (this.node) disposeNode(this.node);
+        this.node = undefined;
+    }
+}
+/** Retain tracked semantic locations until their owner's next collection boundary. */ class Observations {
+    constructor(compute, equals = Object.is, keyEquals){
+        this.compute = compute;
+        this.equals = equals;
+        this.keyEquals = keyEquals;
+    }
+    read(key) {
+        if (this.keyEquals && this.entries) {
+            const previous = currentConsumer;
+            setCurrentConsumer(null);
+            try {
+                for (const known of this.entries.keys()){
+                    if (this.keyEquals(known, key)) {
+                        key = known;
+                        break;
+                    }
+                }
+            } finally{
+                setCurrentConsumer(previous);
+            }
+        }
+        let node = this.entries?.get(key);
+        if (!node) {
+            if (currentConsumer === null) return this.compute(key);
+            let initialized = false;
+            let previous;
+            node = createConsumer(()=>{
+                const next = this.compute(key);
+                if (!initialized || !(this.equals === Object.is ? Object.is(previous, next) : untracked(()=>this.equals(previous, next)))) previous = next;
+                initialized = true;
+                return previous;
+            });
+            (this.entries ??= new Map()).set(key, node);
+        }
+        return readConsumerLazy.call(node);
+    }
+    collect() {
+        if (!this.entries) return;
+        for (const [key, node] of this.entries){
+            if (node.firstOut !== null) continue;
+            this.entries.delete(key);
+            disposeNode(node);
+        }
+    }
+    dispose() {
+        if (!this.entries) return;
+        for (const node of this.entries.values())disposeNode(node);
+        this.entries = undefined;
+    }
+}
+
+const sameKeys = (a, b)=>{
+    if (a.length !== b.length) return false;
+    for(let i = 0; i < a.length; i++)if (a[i] !== b[i]) return false;
+    return true;
+};
+class Projection {
+    constructor(fn, seed, options, returnsValue = false){
+        this.options = options;
+        this.views = new Set();
+        this.disposed = false;
+        const clone = options.clone ?? cloneValue;
+        let initialSeed = seed;
+        let current;
+        let initialized = false;
+        this.state = new Demand(()=>{
+            const draft = returnsValue ? undefined : untracked(()=>clone(initialized ? current : initialSeed));
+            const result = fn(draft);
+            const next = result === undefined ? draft : untracked(()=>clone(result));
+            const equals = options.equals;
+            if (!initialized || !(equals === undefined || equals === Object.is ? Object.is(current, next) : untracked(()=>equals(current, next)))) current = next;
+            initialSeed = undefined;
+            initialized = true;
+            return current;
+        });
+    }
+    view(path, array) {
+        const view = new View(this, path, array);
+        this.views.add(new WeakRef(view));
+        return view;
+    }
+    read(path) {
+        if (this.disposed) throw new Error("Cannot read a disposed store projection");
+        const value = this.state.read();
+        return path.length === 0 ? value : readProjectionPath(value, path);
+    }
+    collect() {
+        for (const ref of this.views){
+            const view = ref.deref();
+            if (view) view.collect();
+            else this.views.delete(ref);
+        }
+        this.state.collect();
+    }
+    dispose() {
+        this.disposed = true;
+        for (const ref of this.views)ref.deref()?.dispose();
+        this.views.clear();
+        this.state.dispose();
+    }
+}
+class View {
+    constructor(owner, path, array){
+        this.owner = owner;
+        this.path = path;
+        this.children = new Map();
+        const read = ()=>owner.read(path);
+        const parent = ()=>{
+            const value = read();
+            return typeof value === "object" && value !== null ? value : undefined;
+        };
+        const get = (key)=>{
+            const value = parent();
+            return value === undefined ? undefined : Reflect.get(value, key);
+        };
+        const valueAt = (key)=>{
+            const value = parent();
+            return this.wrap(key, value === undefined ? undefined : Reflect.get(value, key), value);
+        };
+        const existsAt = (key)=>{
+            const value = parent();
+            return value !== undefined && key in value;
+        };
+        const descriptorAt = (key)=>{
+            const value = parent();
+            return value === undefined ? undefined : Object.getOwnPropertyDescriptor(value, key)?.enumerable;
+        };
+        const keysAt = ()=>{
+            const value = parent();
+            return value === undefined ? [] : Reflect.ownKeys(value);
+        };
+        const dispose = ()=>owner.dispose();
+        this.proxy = new Proxy(array ? [] : Object.create(null), {
+            get: (_target, key)=>{
+                if (key === storeName) return owner.options.name;
+                if (key === Symbol.dispose) return dispose;
+                // Inspect one parent snapshot without subscribing to structural identity.
+                const previous = currentConsumer;
+                let container;
+                let value;
+                setCurrentConsumer(null);
+                try {
+                    container = parent();
+                    value = container === undefined ? undefined : Reflect.get(container, key);
+                } finally{
+                    setCurrentConsumer(previous);
+                }
+                if (this.shouldWrap(value, container)) return this.child(key, Array.isArray(value));
+                return (this.values ??= new Observations(valueAt)).read(key);
+            },
+            has: (_target, key)=>(this.exists ??= new Observations(existsAt)).read(key),
+            ownKeys: ()=>{
+                const keys = (this.keys ??= new Observations(keysAt, sameKeys)).read(undefined);
+                return array && !keys.includes("length") ? [
+                    ...keys,
+                    "length"
+                ] : [
+                    ...keys
+                ];
+            },
+            getOwnPropertyDescriptor: (_target, key)=>{
+                const enumerable = (this.descriptors ??= new Observations(descriptorAt)).read(key);
+                if (array && key === "length") return {
+                    configurable: false,
+                    enumerable: false,
+                    writable: true,
+                    value: untracked(()=>get(key)) ?? 0
+                };
+                if (enumerable === undefined) return undefined;
+                return {
+                    configurable: true,
+                    enumerable,
+                    writable: false,
+                    value: untracked(()=>get(key))
+                };
+            },
+            set: ()=>false,
+            deleteProperty: ()=>false,
+            defineProperty: ()=>false,
+            setPrototypeOf: ()=>false,
+            preventExtensions: ()=>false
+        });
+        storeControls.set(this.proxy, {
+            raw: read,
+            collect: ()=>owner.collect(),
+            dispose
+        });
+    }
+    shouldWrap(value, parent) {
+        return this.owner.options.depth !== "shallow" && (parent === undefined || depthOf(parent) !== "shallow") && isStructural(value);
+    }
+    wrap(key, value, parent) {
+        return this.shouldWrap(value, parent) ? this.child(key, Array.isArray(value)) : value;
+    }
+    child(key, array) {
+        const existing = this.children.get(key);
+        const cached = existing?.view.deref();
+        if (cached && existing.array === array) return cached.proxy;
+        const view = this.owner.view([
+            ...this.path,
+            key
+        ], array);
+        this.children.set(key, {
+            array,
+            view: new WeakRef(view)
+        });
+        return view.proxy;
+    }
+    collect() {
+        this.values?.collect();
+        this.exists?.collect();
+        this.descriptors?.collect();
+        this.keys?.collect();
+        for (const [key, entry] of this.children)if (!entry.view.deref()) this.children.delete(key);
+    }
+    dispose() {
+        this.values?.dispose();
+        this.exists?.dispose();
+        this.descriptors?.dispose();
+        this.keys?.dispose();
+        this.children.clear();
+    }
+}
+function createStoreProjection(fn, seed, options = {}) {
+    const owner = new Projection(fn, seed, options);
+    return owner.view([], Array.isArray(seed)).proxy;
+}
+/** Pure-return derivations never consume a mutable draft of their previous state. */ function createDerivedProjection(compute, options) {
+    const owner = new Projection(compute, {}, options, true);
+    return owner.view([], false).proxy;
+}
+
+function createSignalNode(payload) {
+    return createProducer(payload);
+}
+
+/// <reference lib="esnext.disposable" />
+function withDispose(resource, name) {
+    setStoreName(resource, name);
+    Object.defineProperty(resource, Symbol.dispose, {
+        configurable: true,
+        value: ()=>resource.dispose()
+    });
+    return resource;
+}
+
+// Map uses SameValueZero. Preserve Object.is semantics for signed zero.
+const negativeZero = Symbol("negative zero");
+function identityKey(key) {
+    return key === 0 && 1 / key === -Infinity ? negativeZero : key;
+}
+function createSelector(source, options = {}) {
+    const equals = options.equals ?? Object.is;
+    const identityEquality = equals === Object.is;
+    const entries = new Map();
+    let watcher;
+    let current;
+    let initialized = false;
+    let disposed = false;
+    const lookup = (key)=>{
+        if (identityEquality) return entries.get(identityKey(key));
+        return untracked(()=>{
+            for (const entry of entries.values())if (equals(entry.key, key)) return entry;
+            return undefined;
+        });
+    };
+    const sync = (next)=>{
+        if (initialized && (identityEquality ? Object.is(current, next) : untracked(()=>equals(current, next)))) return;
+        const previous = initialized ? lookup(current) : undefined;
+        current = next;
+        initialized = true;
+        const selected = lookup(next);
+        if (!previous && !selected) return;
+        transaction(()=>{
+            if (previous) writeProducer(previous.node, false);
+            if (selected) writeProducer(selected.node, true);
+        });
+    };
+    const read = (key)=>{
+        if (disposed) throw new Error("Cannot read a disposed selector");
+        if (currentConsumer === null) return identityEquality ? Object.is(source(), key) : untracked(()=>equals(source(), key));
+        if (!watcher) {
+            watcher = createWatcher(()=>sync(source()));
+            try {
+                runWatcher(watcher);
+            } catch (error) {
+                disposeWatcher(watcher);
+                watcher = undefined;
+                throw error;
+            }
+        } else if ((watcher.state & Both) !== 0) {
+            sync(untracked(source));
+        }
+        let entry = lookup(key);
+        if (!entry) {
+            entry = {
+                key,
+                node: createSignalNode(identityEquality ? Object.is(current, key) : untracked(()=>equals(current, key)))
+            };
+            entries.set(identityKey(key), entry);
+        }
+        return readProducer(entry.node);
+    };
+    return withDispose(Object.assign(read, {
+        collect () {
+            for (const [key, entry] of entries){
+                if (entry.node.firstOut !== null) continue;
+                entries.delete(key);
+                disposeNode(entry.node);
+            }
+            if (entries.size === 0 && watcher) {
+                disposeWatcher(watcher);
+                watcher = undefined;
+                initialized = false;
+            }
+        },
+        dispose () {
+            disposed = true;
+            if (watcher) disposeWatcher(watcher);
+            watcher = undefined;
+            for (const entry of entries.values())disposeNode(entry.node);
+            entries.clear();
+        }
+    }), options.name);
+}
+function createKeyedProjection(source, keyOf, project, options = {}) {
+    const keyEquals = options.keyEquals ?? Object.is;
+    const valueEquals = options.equals ?? Object.is;
+    const sourceValue = new Demand(source);
+    const projected = new Demand(()=>project(sourceValue.read()));
+    const keys = new Observations((key)=>{
+        const activeKey = keyOf(sourceValue.read());
+        const requestedKey = key === negativeZero ? -0 : key;
+        const matches = keyEquals === Object.is ? Object.is(activeKey, requestedKey) : untracked(()=>keyEquals(activeKey, requestedKey));
+        return matches ? projected.read() : options.fallback;
+    }, valueEquals === Object.is ? Object.is : (a, b)=>a === undefined || b === undefined ? Object.is(a, b) : valueEquals(a, b), options.keyEquals ? (a, b)=>keyEquals(a === negativeZero ? -0 : a, b === negativeZero ? -0 : b) : undefined);
+    return withDispose(Object.assign((key)=>keys.read(identityKey(key)), {
+        collect () {
+            keys.collect();
+            projected.collect();
+            sourceValue.collect();
+        },
+        dispose () {
+            keys.dispose();
+            projected.dispose();
+            sourceValue.dispose();
+        }
+    }), options.name);
+}
+
+export { createKeyedProjection as a, createStoreProjection as b, createSelector as c, createDerivedProjection as d };

package/dist/chunks/names-Cx4YcvsH.js

@@ -0,0 +1,11 @@
+const storeName = Symbol.for("@volynets/reflex-store/name");
+function getStoreName(resource) {
+    return resource[storeName];
+}
+function setStoreName(resource, name) {
+    if (name !== undefined) Object.defineProperty(resource, storeName, {
+        value: name
+    });
+}
+
+export { storeName as a, getStoreName as g, setStoreName as s };

package/dist/chunks/values-DCB6zyMz.js

@@ -0,0 +1,142 @@
+import { untracked } from '@volynets/reflex-runtime/internal';
+
+const depths = new WeakMap();
+function mark(value, depth) {
+    depths.set(value, depth);
+    return value;
+}
+const deep = (value)=>mark(value, "deep");
+const shallow = (value)=>mark(value, "shallow");
+const ref = (value)=>mark(value, "ref");
+const opaque = (value)=>mark(value, "opaque");
+function depthOf(value) {
+    return depths.get(value) ?? "deep";
+}
+function isPlain(value) {
+    if (typeof value !== "object" || value === null) return false;
+    const proto = Object.getPrototypeOf(value);
+    return Array.isArray(value) || proto === Object.prototype || proto === null;
+}
+function isStructural(value) {
+    return isPlain(value) && isStructuralDepth(depthOf(value));
+}
+function isStructuralDepth(depth) {
+    return depth !== "ref" && depth !== "opaque";
+}
+/** Copy structural data, retaining explicit reference boundaries and foreign objects. */ function cloneValue(value, seen = new Map()) {
+    if (!isPlain(value)) return value;
+    const depth = depthOf(value);
+    if (!isStructuralDepth(depth)) return value;
+    if (seen.has(value)) return seen.get(value);
+    const array = Array.isArray(value);
+    const result = array ? [] : Object.create(Object.getPrototypeOf(value));
+    seen.set(value, result);
+    if (depth !== "deep") depths.set(result, depth);
+    const output = {
+        configurable: true,
+        enumerable: true,
+        writable: true,
+        value: undefined
+    };
+    for (const key of Reflect.ownKeys(value)){
+        if (array && key === "length") continue;
+        output.enumerable = Object.getOwnPropertyDescriptor(value, key).enumerable;
+        output.value = depth === "shallow" ? value[key] : cloneValue(value[key], seen);
+        Object.defineProperty(result, key, output);
+    }
+    if (array) result.length = value.length;
+    return result;
+}
+function getStoreControl(store) {
+    return storeControls.get(store) ?? store[Symbol.for("@volynets/reflex-store/data/1")];
+}
+const storeControls = new WeakMap();
+function raw(store) {
+    return untracked(()=>{
+        const control = typeof store === "object" && store !== null ? getStoreControl(store) : undefined;
+        return control ? control.raw() : store;
+    });
+}
+function snapshot(store) {
+    // Snapshot copies shallow/ref plain data too; opaque data cannot be serialized generically.
+    const seen = new Map();
+    const copy = (value)=>{
+        if (typeof value === "object" && value !== null && depthOf(value) === "opaque") return value;
+        if (value instanceof Set) {
+            if (seen.has(value)) return seen.get(value);
+            const result = new Set(value);
+            seen.set(value, result);
+            const immutable = ()=>{
+                throw new TypeError("Cannot mutate a snapshot");
+            };
+            Object.defineProperties(result, {
+                add: {
+                    value: immutable
+                },
+                delete: {
+                    value: immutable
+                },
+                clear: {
+                    value: immutable
+                }
+            });
+            return Object.freeze(result);
+        }
+        if (value instanceof Map) {
+            if (seen.has(value)) return seen.get(value);
+            const result = new Map();
+            seen.set(value, result);
+            for (const [key, item] of value)result.set(key, copy(item));
+            const immutable = ()=>{
+                throw new TypeError("Cannot mutate a snapshot");
+            };
+            Object.defineProperties(result, {
+                set: {
+                    value: immutable
+                },
+                delete: {
+                    value: immutable
+                },
+                clear: {
+                    value: immutable
+                }
+            });
+            return Object.freeze(result);
+        }
+        if (!isPlain(value) || depthOf(value) === "opaque") return value;
+        if (seen.has(value)) return seen.get(value);
+        const array = Array.isArray(value);
+        const result = array ? [] : Object.create(Object.getPrototypeOf(value));
+        seen.set(value, result);
+        const output = {
+            enumerable: true,
+            value: undefined
+        };
+        for (const key of Reflect.ownKeys(value)){
+            if (array && key === "length") continue;
+            output.enumerable = Object.getOwnPropertyDescriptor(value, key).enumerable;
+            output.value = copy(value[key]);
+            Object.defineProperty(result, key, output);
+        }
+        if (array) result.length = value.length;
+        return Object.freeze(result);
+    };
+    return untracked(()=>{
+        const control = typeof store === "object" && store !== null ? getStoreControl(store) : undefined;
+        // Capture every cell before cloning user values, preserving point-in-time reads.
+        const data = control ? control.raw() : store;
+        return control?.snapshot ? control.snapshot(data, copy) : copy(data);
+    });
+}
+function disposeStore(store) {
+    const control = getStoreControl(store);
+    if (!control) throw new TypeError("Expected a runtime store or projection");
+    control.dispose();
+}
+/** Reclaim locations with no consumers at an explicit owner lifecycle boundary. */ function collectStore(store) {
+    const control = getStoreControl(store);
+    if (!control) throw new TypeError("Expected a runtime store or projection");
+    control.collect();
+}
+
+export { disposeStore as a, ref as b, collectStore as c, deep as d, shallow as e, cloneValue as f, storeControls as g, getStoreControl as h, isPlain as i, depthOf as j, isStructural as k, opaque as o, raw as r, snapshot as s };

package/dist/compiled-store.d.ts

@@ -0,0 +1,4 @@
+/// <reference lib="esnext.disposable" />
+export { C as CompiledStore, b as StoreShape, c as createStore } from './types/createStore-BJ66-pfq.js';
+export { b as CompiledStoreDiagnostic, c as CompiledStoreLoweringTarget, d as CompiledStoreLoweringTargetOptions, e as CompiledStorePathContext, f as CompiledStoreTemporaryContext, g as CompiledStoreTransformError, C as CompiledStoreTransformOptions, a as CompiledStoreTransformResult } from './types/contracts-BCsRPdQb.js';
+export { compileStore, transformCompiledStore } from './store.js';