signalium 3.0.1 → 3.0.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # signalium
 
+## 3.0.2
+
+### Patch Changes
+
+- 20767d3: Fix `useReactive` snapshots of `ReactiveTask` to carry over the `run` method. Previously, when a task was read through `useReactive`, the deep-snapshot returned a plain object with `value`/`error`/`isPending`/etc. but no `run`, so consumers couldn't invoke `result.run(...)` against the underlying task. The snapshot now includes `run`, and its identity is included in the structural-equality short-circuit so reference stability across pending → resolved transitions is preserved.
+
 ## 3.0.1
 
 ### Patch Changes

package/dist/cjs/development/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const snapshot = require("./snapshot-BfP4w3lC.js");
+const snapshot = require("./snapshot-CbZ6IH3B.js");
 const debug = require("./debug-C46WDxhL.js");
 const utils = require("./utils.js");
 exports.reactive = snapshot.reactive;

package/dist/cjs/development/react/index.js

@@ -4,7 +4,7 @@ const jsxRuntime = require("react/jsx-runtime");
 const React = require("react");
 const debug = require("../debug-C46WDxhL.js");
 const componentShared = require("../component-shared-Cug2Y5YZ.js");
-const snapshot = require("../snapshot-BfP4w3lC.js");
+const snapshot = require("../snapshot-CbZ6IH3B.js");
 function _interopNamespaceDefault(e) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
   if (e) {

package/dist/cjs/development/{snapshot-BfP4w3lC.js → snapshot-CbZ6IH3B.js}

@@ -81,10 +81,11 @@ function snapshotReactivePromise(current, prev, snap) {
   const isResolved = current.isResolved;
   const isReady = current.isReady;
   const isSettled = current.isSettled;
-  if (prevObj && value === prevObj.value && error === prevObj.error && isPending === prevObj.isPending && isRejected === prevObj.isRejected && isResolved === prevObj.isResolved && isReady === prevObj.isReady && isSettled === prevObj.isSettled) {
+  const run = current.run;
+  if (prevObj && value === prevObj.value && error === prevObj.error && isPending === prevObj.isPending && isRejected === prevObj.isRejected && isResolved === prevObj.isResolved && isReady === prevObj.isReady && isSettled === prevObj.isSettled && run === prevObj.run) {
     return prevObj;
   }
-  return { value, error, isPending, isRejected, isResolved, isReady, isSettled };
+  return { value, error, isPending, isRejected, isResolved, isReady, isSettled, run };
 }
 function snapshotMap(current, prev, snap) {
   const prevMap = prev instanceof Map ? prev : void 0;
@@ -154,4 +155,4 @@ exports.relay = relay;
 exports.snapshot = snapshot;
 exports.task = task;
 exports.watcher = watcher;
-//# sourceMappingURL=snapshot-BfP4w3lC.js.map
+//# sourceMappingURL=snapshot-CbZ6IH3B.js.map

package/dist/cjs/development/snapshot-CbZ6IH3B.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-CbZ6IH3B.js","sources":["../../../.tsc-out/internals/core-api.js","../../../.tsc-out/internals/utils/snapshot.js"],"sourcesContent":["import { getCurrentScope, getScopeOwner, SignalScope } from './contexts.js';\nimport { createReactiveDefinition, createReactiveSignal, } from './reactive.js';\nimport { createRelay, createTask } from './async.js';\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\nexport const DERIVED_DEFINITION_MAP = new WeakMap();\nexport function getReactiveFnAndDefinition(fn, opts) {\n    let fnAndDef = DERIVED_DEFINITION_MAP.get(fn);\n    if (!fnAndDef) {\n        const def = createReactiveDefinition(opts?.id, opts?.desc, fn, opts?.equals, false, opts?.paramKey, undefined);\n        const defScope = getCurrentScope();\n        const reactiveFn = (...args) => {\n            const scope = getCurrentScope(defScope);\n            const signal = scope.get(def, args);\n            return signal.value;\n        };\n        fnAndDef = [reactiveFn, def];\n        DERIVED_DEFINITION_MAP.set(fn, fnAndDef);\n    }\n    return fnAndDef;\n}\nexport function reactive(fn, opts) {\n    return getReactiveFnAndDefinition(fn, opts)[0];\n}\nexport const reactiveMethod = (owner, fn, opts) => {\n    const def = createReactiveDefinition(opts?.id, opts?.desc, fn, opts?.equals, false, opts?.paramKey, undefined);\n    const reactiveFn = (...args) => {\n        return getScopeOwner(owner).get(def, args).value;\n    };\n    DERIVED_DEFINITION_MAP.set(reactiveFn, [reactiveFn, def]);\n    return reactiveFn;\n};\nexport function relay(activate, opts) {\n    const scope = getCurrentScope();\n    return createRelay(activate, scope, opts);\n}\nexport const task = (fn, opts) => {\n    const scope = getCurrentScope();\n    return createTask(fn, scope, opts);\n};\nexport function watcher(fn, opts) {\n    const def = createReactiveDefinition(opts?.id, opts?.desc, fn, opts?.equals, false, undefined, opts?.tracer);\n    const scope = opts?.isolate ? new SignalScope([]) : getCurrentScope();\n    return createReactiveSignal(def, undefined, undefined, scope);\n}\n/**\n * Creates a reactive signal from a compute function. This is useful for when you\n * want to create a signal that does not receive parameters, but is still reactive.\n *\n * @param compute\n * @param opts\n * @returns\n */\nexport const reactiveSignal = (compute, opts) => {\n    const def = createReactiveDefinition(opts?.id, opts?.desc, compute, opts?.equals, false, undefined, undefined);\n    const scope = opts?.isolate ? new SignalScope([]) : getCurrentScope();\n    return createReactiveSignal(def, undefined, undefined, scope);\n};\n","import { isReactivePromise } from '../async.js';\nconst getProto = Object.getPrototypeOf;\nfunction snapshotArray(current, prev, snap) {\n    const prevArr = Array.isArray(prev) ? prev : undefined;\n    let changed = !prevArr || prevArr.length !== current.length;\n    const result = new Array(current.length);\n    for (let i = 0; i < current.length; i++) {\n        result[i] = snap(current[i], prevArr?.[i]);\n        if (!changed && result[i] !== prevArr[i]) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevArr;\n}\nfunction snapshotPlainObject(current, prev, snap) {\n    const prevObj = prev !== null && prev !== undefined && typeof prev === 'object' && !Array.isArray(prev)\n        ? prev\n        : undefined;\n    const keys = Object.keys(current);\n    let changed = !prevObj || Object.keys(prevObj).length !== keys.length;\n    const result = {};\n    for (let i = 0; i < keys.length; i++) {\n        const key = keys[i];\n        result[key] = snap(current[key], prevObj?.[key]);\n        if (!changed && result[key] !== prevObj[key]) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevObj;\n}\nfunction snapshotReactivePromise(current, prev, snap) {\n    const prevObj = prev !== null && prev !== undefined && typeof prev === 'object' ? prev : undefined;\n    const value = snap(current.value, prevObj?.value);\n    const error = current.error;\n    const isPending = current.isPending;\n    const isRejected = current.isRejected;\n    const isResolved = current.isResolved;\n    const isReady = current.isReady;\n    const isSettled = current.isSettled;\n    // `run` is set once in the task constructor and never mutated, so its identity\n    // is stable for the lifetime of the underlying ReactivePromiseImpl. Carrying\n    // it on the snapshot lets consumers (e.g. React components reading a task via\n    // `useReactive`) invoke `result.run(...)` against the live task. For non-task\n    // promises this is `undefined`; we still assign the slot so the resulting\n    // object's hidden class is stable across task and non-task snapshots.\n    const run = current.run;\n    if (prevObj &&\n        value === prevObj.value &&\n        error === prevObj.error &&\n        isPending === prevObj.isPending &&\n        isRejected === prevObj.isRejected &&\n        isResolved === prevObj.isResolved &&\n        isReady === prevObj.isReady &&\n        isSettled === prevObj.isSettled &&\n        run === prevObj.run) {\n        return prevObj;\n    }\n    return { value, error, isPending, isRejected, isResolved, isReady, isSettled, run };\n}\nfunction snapshotMap(current, prev, snap) {\n    const prevMap = prev instanceof Map ? prev : undefined;\n    let changed = !prevMap || prevMap.size !== current.size;\n    const result = new Map();\n    for (const [key, val] of current) {\n        const snapped = snap(val, prevMap?.get(key));\n        result.set(key, snapped);\n        if (!changed && snapped !== prevMap.get(key)) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevMap;\n}\nfunction snapshotSet(current, prev, _snap) {\n    const prevSet = prev instanceof Set ? prev : undefined;\n    let changed = !prevSet || prevSet.size !== current.size;\n    const result = new Set();\n    for (const val of current) {\n        const snapped = snapshot(val, prevSet?.has(val) ? val : undefined);\n        result.add(snapped);\n        if (!changed && !prevSet.has(snapped)) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevSet;\n}\n/**\n * Built-in handlers for plain structural types. Matched by exact prototype\n * only — subclasses of `Object` / `Array` / `Map` / `Set` are NOT routed\n * through these handlers (they fall through and, if no custom ancestor is\n * registered, are returned as-is). We use a Map here rather than installing\n * a symbol property on the built-in prototypes, because mutating built-in\n * prototypes (even with a symbol key) changes their hidden class and\n * invalidates V8's fast-path inline caches for every plain object / array\n * in the program.\n */\nconst BUILTIN_PROTO_TO_SNAPSHOT = new Map([\n    [Object.prototype, snapshotPlainObject],\n    [Array.prototype, snapshotArray],\n    [Map.prototype, snapshotMap],\n    [Set.prototype, snapshotSet],\n    [null, snapshotPlainObject],\n]);\n/**\n * Custom registrations are stored as a non-enumerable symbol property on the\n * class prototype. JS prototype lookup walks the chain natively, so subclass\n * inheritance and override-by-redefinition are free — no resolver, no cache,\n * no invalidation. The symbol is module-private (created with `Symbol()`,\n * not `Symbol.for()`), so it cannot collide with anything else and cannot\n * be addressed by user code.\n */\nconst SNAPSHOT_HANDLER = Symbol('signalium.snapshot.handler');\n/**\n * Register a custom snapshot function for instances of a class.\n * The function receives the current value, the previous snapshot (or undefined),\n * and the recursive `snapshot` function for snapshotting nested values.\n *\n * Subclasses inherit the handler automatically via prototype lookup, so\n * registering once on a base class applies to all descendants. A descendant\n * can override by registering its own handler.\n *\n * Return `prev` when nothing has changed to preserve reference stability.\n *\n * @example\n * ```ts\n * registerCustomSnapshot(MyEntity, (current, prev, snapshot) => {\n *   const name = snapshot(current.name, prev?.name);\n *   const age = current.age;\n *   if (prev && name === prev.name && age === prev.age) return prev;\n *   return { name, age };\n * });\n * ```\n */\nexport const registerCustomSnapshot = (ctor, snapshotFn) => {\n    // Use defineProperty so the handler is non-enumerable (it shouldn't show up\n    // in `Reflect.ownKeys` walks any more than necessary) and so re-registration\n    // overwrites cleanly even if a subclass has shadowed it.\n    Object.defineProperty(ctor.prototype, SNAPSHOT_HANDLER, {\n        value: snapshotFn,\n        writable: true,\n        configurable: true,\n        enumerable: false,\n    });\n};\n/**\n * Recursively snapshot a value with structural sharing.\n *\n * - Plain objects and arrays are deep-cloned; unchanged subtrees keep the same reference.\n * - ReactivePromise instances are read (establishing deps) and flattened to a plain object.\n * - Class instances are returned as-is unless a custom handler is registered\n *   for the class or any of its ancestors via `registerCustomSnapshot`.\n * - Primitives are returned directly.\n */\nexport function snapshot(currentValue, prevValue) {\n    if (currentValue === null || typeof currentValue !== 'object') {\n        return currentValue;\n    }\n    if (isReactivePromise(currentValue)) {\n        return snapshotReactivePromise(currentValue, prevValue, snapshot);\n    }\n    // Custom registrations check first: native prototype lookup walks the chain\n    // for us, so subclasses inherit their ancestor's handler with no extra work.\n    const customHandler = currentValue[SNAPSHOT_HANDLER];\n    if (customHandler !== undefined) {\n        return customHandler(currentValue, prevValue, snapshot);\n    }\n    // Built-in handlers are looked up by exact prototype only.\n    const builtIn = BUILTIN_PROTO_TO_SNAPSHOT.get(getProto(currentValue));\n    if (builtIn !== undefined) {\n        return builtIn(currentValue, prevValue, snapshot);\n    }\n    return currentValue;\n}\n"],"names":["createReactiveDefinition","getCurrentScope","getScopeOwner","createRelay","createTask","SignalScope","createReactiveSignal","isReactivePromise"],"mappings":"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"}

package/dist/cjs/development/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const snapshot = require("./snapshot-BfP4w3lC.js");
+const snapshot = require("./snapshot-CbZ6IH3B.js");
 const debug = require("./debug-C46WDxhL.js");
 function watchOnce(fn) {
   const signal = snapshot.watcher(fn);

package/dist/cjs/production/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const snapshot = require("./snapshot-DnzyLNij.js");
+const snapshot = require("./snapshot-DWwH7_9y.js");
 const contexts = require("./contexts-CM3QLfV8.js");
 const utils = require("./utils.js");
 exports.reactive = snapshot.reactive;

package/dist/cjs/production/react/index.js

@@ -4,7 +4,7 @@ const jsxRuntime = require("react/jsx-runtime");
 const React = require("react");
 const contexts = require("../contexts-CM3QLfV8.js");
 const componentShared = require("../component-shared-D0J85PUi.js");
-const snapshot = require("../snapshot-DnzyLNij.js");
+const snapshot = require("../snapshot-DWwH7_9y.js");
 function _interopNamespaceDefault(e) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
   if (e) {

package/dist/cjs/production/{snapshot-DnzyLNij.js → snapshot-DWwH7_9y.js}

@@ -81,10 +81,11 @@ function snapshotReactivePromise(current, prev, snap) {
   const isResolved = current.isResolved;
   const isReady = current.isReady;
   const isSettled = current.isSettled;
-  if (prevObj && value === prevObj.value && error === prevObj.error && isPending === prevObj.isPending && isRejected === prevObj.isRejected && isResolved === prevObj.isResolved && isReady === prevObj.isReady && isSettled === prevObj.isSettled) {
+  const run = current.run;
+  if (prevObj && value === prevObj.value && error === prevObj.error && isPending === prevObj.isPending && isRejected === prevObj.isRejected && isResolved === prevObj.isResolved && isReady === prevObj.isReady && isSettled === prevObj.isSettled && run === prevObj.run) {
     return prevObj;
   }
-  return { value, error, isPending, isRejected, isResolved, isReady, isSettled };
+  return { value, error, isPending, isRejected, isResolved, isReady, isSettled, run };
 }
 function snapshotMap(current, prev, snap) {
   const prevMap = prev instanceof Map ? prev : void 0;
@@ -154,4 +155,4 @@ exports.relay = relay;
 exports.snapshot = snapshot;
 exports.task = task;
 exports.watcher = watcher;
-//# sourceMappingURL=snapshot-DnzyLNij.js.map
+//# sourceMappingURL=snapshot-DWwH7_9y.js.map

package/dist/cjs/production/snapshot-DWwH7_9y.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-DWwH7_9y.js","sources":["../../../.tsc-out/internals/core-api.js","../../../.tsc-out/internals/utils/snapshot.js"],"sourcesContent":["import { getCurrentScope, getScopeOwner, SignalScope } from './contexts.js';\nimport { createReactiveDefinition, createReactiveSignal, } from './reactive.js';\nimport { createRelay, createTask } from './async.js';\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\nexport const DERIVED_DEFINITION_MAP = new WeakMap();\nexport function getReactiveFnAndDefinition(fn, opts) {\n    let fnAndDef = DERIVED_DEFINITION_MAP.get(fn);\n    if (!fnAndDef) {\n        const def = createReactiveDefinition(opts?.id, opts?.desc, fn, opts?.equals, false, opts?.paramKey, undefined);\n        const defScope = getCurrentScope();\n        const reactiveFn = (...args) => {\n            const scope = getCurrentScope(defScope);\n            const signal = scope.get(def, args);\n            return signal.value;\n        };\n        fnAndDef = [reactiveFn, def];\n        DERIVED_DEFINITION_MAP.set(fn, fnAndDef);\n    }\n    return fnAndDef;\n}\nexport function reactive(fn, opts) {\n    return getReactiveFnAndDefinition(fn, opts)[0];\n}\nexport const reactiveMethod = (owner, fn, opts) => {\n    const def = createReactiveDefinition(opts?.id, opts?.desc, fn, opts?.equals, false, opts?.paramKey, undefined);\n    const reactiveFn = (...args) => {\n        return getScopeOwner(owner).get(def, args).value;\n    };\n    DERIVED_DEFINITION_MAP.set(reactiveFn, [reactiveFn, def]);\n    return reactiveFn;\n};\nexport function relay(activate, opts) {\n    const scope = getCurrentScope();\n    return createRelay(activate, scope, opts);\n}\nexport const task = (fn, opts) => {\n    const scope = getCurrentScope();\n    return createTask(fn, scope, opts);\n};\nexport function watcher(fn, opts) {\n    const def = createReactiveDefinition(opts?.id, opts?.desc, fn, opts?.equals, false, undefined, opts?.tracer);\n    const scope = opts?.isolate ? new SignalScope([]) : getCurrentScope();\n    return createReactiveSignal(def, undefined, undefined, scope);\n}\n/**\n * Creates a reactive signal from a compute function. This is useful for when you\n * want to create a signal that does not receive parameters, but is still reactive.\n *\n * @param compute\n * @param opts\n * @returns\n */\nexport const reactiveSignal = (compute, opts) => {\n    const def = createReactiveDefinition(opts?.id, opts?.desc, compute, opts?.equals, false, undefined, undefined);\n    const scope = opts?.isolate ? new SignalScope([]) : getCurrentScope();\n    return createReactiveSignal(def, undefined, undefined, scope);\n};\n","import { isReactivePromise } from '../async.js';\nconst getProto = Object.getPrototypeOf;\nfunction snapshotArray(current, prev, snap) {\n    const prevArr = Array.isArray(prev) ? prev : undefined;\n    let changed = !prevArr || prevArr.length !== current.length;\n    const result = new Array(current.length);\n    for (let i = 0; i < current.length; i++) {\n        result[i] = snap(current[i], prevArr?.[i]);\n        if (!changed && result[i] !== prevArr[i]) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevArr;\n}\nfunction snapshotPlainObject(current, prev, snap) {\n    const prevObj = prev !== null && prev !== undefined && typeof prev === 'object' && !Array.isArray(prev)\n        ? prev\n        : undefined;\n    const keys = Object.keys(current);\n    let changed = !prevObj || Object.keys(prevObj).length !== keys.length;\n    const result = {};\n    for (let i = 0; i < keys.length; i++) {\n        const key = keys[i];\n        result[key] = snap(current[key], prevObj?.[key]);\n        if (!changed && result[key] !== prevObj[key]) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevObj;\n}\nfunction snapshotReactivePromise(current, prev, snap) {\n    const prevObj = prev !== null && prev !== undefined && typeof prev === 'object' ? prev : undefined;\n    const value = snap(current.value, prevObj?.value);\n    const error = current.error;\n    const isPending = current.isPending;\n    const isRejected = current.isRejected;\n    const isResolved = current.isResolved;\n    const isReady = current.isReady;\n    const isSettled = current.isSettled;\n    // `run` is set once in the task constructor and never mutated, so its identity\n    // is stable for the lifetime of the underlying ReactivePromiseImpl. Carrying\n    // it on the snapshot lets consumers (e.g. React components reading a task via\n    // `useReactive`) invoke `result.run(...)` against the live task. For non-task\n    // promises this is `undefined`; we still assign the slot so the resulting\n    // object's hidden class is stable across task and non-task snapshots.\n    const run = current.run;\n    if (prevObj &&\n        value === prevObj.value &&\n        error === prevObj.error &&\n        isPending === prevObj.isPending &&\n        isRejected === prevObj.isRejected &&\n        isResolved === prevObj.isResolved &&\n        isReady === prevObj.isReady &&\n        isSettled === prevObj.isSettled &&\n        run === prevObj.run) {\n        return prevObj;\n    }\n    return { value, error, isPending, isRejected, isResolved, isReady, isSettled, run };\n}\nfunction snapshotMap(current, prev, snap) {\n    const prevMap = prev instanceof Map ? prev : undefined;\n    let changed = !prevMap || prevMap.size !== current.size;\n    const result = new Map();\n    for (const [key, val] of current) {\n        const snapped = snap(val, prevMap?.get(key));\n        result.set(key, snapped);\n        if (!changed && snapped !== prevMap.get(key)) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevMap;\n}\nfunction snapshotSet(current, prev, _snap) {\n    const prevSet = prev instanceof Set ? prev : undefined;\n    let changed = !prevSet || prevSet.size !== current.size;\n    const result = new Set();\n    for (const val of current) {\n        const snapped = snapshot(val, prevSet?.has(val) ? val : undefined);\n        result.add(snapped);\n        if (!changed && !prevSet.has(snapped)) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevSet;\n}\n/**\n * Built-in handlers for plain structural types. Matched by exact prototype\n * only — subclasses of `Object` / `Array` / `Map` / `Set` are NOT routed\n * through these handlers (they fall through and, if no custom ancestor is\n * registered, are returned as-is). We use a Map here rather than installing\n * a symbol property on the built-in prototypes, because mutating built-in\n * prototypes (even with a symbol key) changes their hidden class and\n * invalidates V8's fast-path inline caches for every plain object / array\n * in the program.\n */\nconst BUILTIN_PROTO_TO_SNAPSHOT = new Map([\n    [Object.prototype, snapshotPlainObject],\n    [Array.prototype, snapshotArray],\n    [Map.prototype, snapshotMap],\n    [Set.prototype, snapshotSet],\n    [null, snapshotPlainObject],\n]);\n/**\n * Custom registrations are stored as a non-enumerable symbol property on the\n * class prototype. JS prototype lookup walks the chain natively, so subclass\n * inheritance and override-by-redefinition are free — no resolver, no cache,\n * no invalidation. The symbol is module-private (created with `Symbol()`,\n * not `Symbol.for()`), so it cannot collide with anything else and cannot\n * be addressed by user code.\n */\nconst SNAPSHOT_HANDLER = Symbol('signalium.snapshot.handler');\n/**\n * Register a custom snapshot function for instances of a class.\n * The function receives the current value, the previous snapshot (or undefined),\n * and the recursive `snapshot` function for snapshotting nested values.\n *\n * Subclasses inherit the handler automatically via prototype lookup, so\n * registering once on a base class applies to all descendants. A descendant\n * can override by registering its own handler.\n *\n * Return `prev` when nothing has changed to preserve reference stability.\n *\n * @example\n * ```ts\n * registerCustomSnapshot(MyEntity, (current, prev, snapshot) => {\n *   const name = snapshot(current.name, prev?.name);\n *   const age = current.age;\n *   if (prev && name === prev.name && age === prev.age) return prev;\n *   return { name, age };\n * });\n * ```\n */\nexport const registerCustomSnapshot = (ctor, snapshotFn) => {\n    // Use defineProperty so the handler is non-enumerable (it shouldn't show up\n    // in `Reflect.ownKeys` walks any more than necessary) and so re-registration\n    // overwrites cleanly even if a subclass has shadowed it.\n    Object.defineProperty(ctor.prototype, SNAPSHOT_HANDLER, {\n        value: snapshotFn,\n        writable: true,\n        configurable: true,\n        enumerable: false,\n    });\n};\n/**\n * Recursively snapshot a value with structural sharing.\n *\n * - Plain objects and arrays are deep-cloned; unchanged subtrees keep the same reference.\n * - ReactivePromise instances are read (establishing deps) and flattened to a plain object.\n * - Class instances are returned as-is unless a custom handler is registered\n *   for the class or any of its ancestors via `registerCustomSnapshot`.\n * - Primitives are returned directly.\n */\nexport function snapshot(currentValue, prevValue) {\n    if (currentValue === null || typeof currentValue !== 'object') {\n        return currentValue;\n    }\n    if (isReactivePromise(currentValue)) {\n        return snapshotReactivePromise(currentValue, prevValue, snapshot);\n    }\n    // Custom registrations check first: native prototype lookup walks the chain\n    // for us, so subclasses inherit their ancestor's handler with no extra work.\n    const customHandler = currentValue[SNAPSHOT_HANDLER];\n    if (customHandler !== undefined) {\n        return customHandler(currentValue, prevValue, snapshot);\n    }\n    // Built-in handlers are looked up by exact prototype only.\n    const builtIn = BUILTIN_PROTO_TO_SNAPSHOT.get(getProto(currentValue));\n    if (builtIn !== undefined) {\n        return builtIn(currentValue, prevValue, snapshot);\n    }\n    return currentValue;\n}\n"],"names":["createReactiveDefinition","getCurrentScope","getScopeOwner","createRelay","createTask","SignalScope","createReactiveSignal","isReactivePromise"],"mappings":"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"}

package/dist/cjs/production/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const snapshot = require("./snapshot-DnzyLNij.js");
+const snapshot = require("./snapshot-DWwH7_9y.js");
 const contexts = require("./contexts-CM3QLfV8.js");
 function watchOnce(fn) {
   const signal = snapshot.watcher(fn);

package/dist/esm/development/index.js

@@ -1,4 +1,4 @@
-import { b, c, r, d, t, w } from "./snapshot-DbLBnoC8.js";
+import { b, c, r, d, t, w } from "./snapshot-CkndI4Hh.js";
 import { R, z, F, B, C, y, x, E, d as d2, G, A, p, D } from "./debug-BTLbgTPK.js";
 import { forwardRelay, watchOnce } from "./utils.js";
 export {

package/dist/esm/development/react/index.js

@@ -3,7 +3,7 @@ import * as React from "react";
 import React__default, { createContext, useContext as useContext$1, useMemo, useRef, useEffect, useSyncExternalStore } from "react";
 import { b as getCurrentConsumer, k as getGlobalScope, S as SignalScope, l as hashValue, u as unwatchSignal, w as watchSignal, m as schedulePull, s as setCurrentConsumer, j as isReactivePromise, n as isPromise, o as isThennable, c as createReactiveSignal, r as runSignal, d as setRequestScopeGetter, p as signal } from "../debug-BTLbgTPK.js";
 import { i as isAsyncFunctionWithoutTransform, a as isGeneratorFunction, c as createServerAsyncComponentWrapper } from "../component-shared-CLSmdnGU.js";
-import { g as getReactiveFnAndDefinition, r as reactiveSignal, s as snapshot } from "../snapshot-DbLBnoC8.js";
+import { g as getReactiveFnAndDefinition, r as reactiveSignal, s as snapshot } from "../snapshot-CkndI4Hh.js";
 const ScopeContext = createContext(void 0);
 function useScope() {
   return useContext$1(ScopeContext);

package/dist/esm/development/{snapshot-DbLBnoC8.js → snapshot-CkndI4Hh.js}

@@ -80,10 +80,11 @@ function snapshotReactivePromise(current, prev, snap) {
   const isResolved = current.isResolved;
   const isReady = current.isReady;
   const isSettled = current.isSettled;
-  if (prevObj && value === prevObj.value && error === prevObj.error && isPending === prevObj.isPending && isRejected === prevObj.isRejected && isResolved === prevObj.isResolved && isReady === prevObj.isReady && isSettled === prevObj.isSettled) {
+  const run = current.run;
+  if (prevObj && value === prevObj.value && error === prevObj.error && isPending === prevObj.isPending && isRejected === prevObj.isRejected && isResolved === prevObj.isResolved && isReady === prevObj.isReady && isSettled === prevObj.isSettled && run === prevObj.run) {
     return prevObj;
   }
-  return { value, error, isPending, isRejected, isResolved, isReady, isSettled };
+  return { value, error, isPending, isRejected, isResolved, isReady, isSettled, run };
 }
 function snapshotMap(current, prev, snap) {
   const prevMap = prev instanceof Map ? prev : void 0;
@@ -155,4 +156,4 @@ export {
   task as t,
   watcher as w
 };
-//# sourceMappingURL=snapshot-DbLBnoC8.js.map
+//# sourceMappingURL=snapshot-CkndI4Hh.js.map

package/dist/esm/development/snapshot-CkndI4Hh.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-CkndI4Hh.js","sources":["../../../.tsc-out/internals/core-api.js","../../../.tsc-out/internals/utils/snapshot.js"],"sourcesContent":["import { getCurrentScope, getScopeOwner, SignalScope } from './contexts.js';\nimport { createReactiveDefinition, createReactiveSignal, } from './reactive.js';\nimport { createRelay, createTask } from './async.js';\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\nexport const DERIVED_DEFINITION_MAP = new WeakMap();\nexport function getReactiveFnAndDefinition(fn, opts) {\n    let fnAndDef = DERIVED_DEFINITION_MAP.get(fn);\n    if (!fnAndDef) {\n        const def = createReactiveDefinition(opts?.id, opts?.desc, fn, opts?.equals, false, opts?.paramKey, undefined);\n        const defScope = getCurrentScope();\n        const reactiveFn = (...args) => {\n            const scope = getCurrentScope(defScope);\n            const signal = scope.get(def, args);\n            return signal.value;\n        };\n        fnAndDef = [reactiveFn, def];\n        DERIVED_DEFINITION_MAP.set(fn, fnAndDef);\n    }\n    return fnAndDef;\n}\nexport function reactive(fn, opts) {\n    return getReactiveFnAndDefinition(fn, opts)[0];\n}\nexport const reactiveMethod = (owner, fn, opts) => {\n    const def = createReactiveDefinition(opts?.id, opts?.desc, fn, opts?.equals, false, opts?.paramKey, undefined);\n    const reactiveFn = (...args) => {\n        return getScopeOwner(owner).get(def, args).value;\n    };\n    DERIVED_DEFINITION_MAP.set(reactiveFn, [reactiveFn, def]);\n    return reactiveFn;\n};\nexport function relay(activate, opts) {\n    const scope = getCurrentScope();\n    return createRelay(activate, scope, opts);\n}\nexport const task = (fn, opts) => {\n    const scope = getCurrentScope();\n    return createTask(fn, scope, opts);\n};\nexport function watcher(fn, opts) {\n    const def = createReactiveDefinition(opts?.id, opts?.desc, fn, opts?.equals, false, undefined, opts?.tracer);\n    const scope = opts?.isolate ? new SignalScope([]) : getCurrentScope();\n    return createReactiveSignal(def, undefined, undefined, scope);\n}\n/**\n * Creates a reactive signal from a compute function. This is useful for when you\n * want to create a signal that does not receive parameters, but is still reactive.\n *\n * @param compute\n * @param opts\n * @returns\n */\nexport const reactiveSignal = (compute, opts) => {\n    const def = createReactiveDefinition(opts?.id, opts?.desc, compute, opts?.equals, false, undefined, undefined);\n    const scope = opts?.isolate ? new SignalScope([]) : getCurrentScope();\n    return createReactiveSignal(def, undefined, undefined, scope);\n};\n","import { isReactivePromise } from '../async.js';\nconst getProto = Object.getPrototypeOf;\nfunction snapshotArray(current, prev, snap) {\n    const prevArr = Array.isArray(prev) ? prev : undefined;\n    let changed = !prevArr || prevArr.length !== current.length;\n    const result = new Array(current.length);\n    for (let i = 0; i < current.length; i++) {\n        result[i] = snap(current[i], prevArr?.[i]);\n        if (!changed && result[i] !== prevArr[i]) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevArr;\n}\nfunction snapshotPlainObject(current, prev, snap) {\n    const prevObj = prev !== null && prev !== undefined && typeof prev === 'object' && !Array.isArray(prev)\n        ? prev\n        : undefined;\n    const keys = Object.keys(current);\n    let changed = !prevObj || Object.keys(prevObj).length !== keys.length;\n    const result = {};\n    for (let i = 0; i < keys.length; i++) {\n        const key = keys[i];\n        result[key] = snap(current[key], prevObj?.[key]);\n        if (!changed && result[key] !== prevObj[key]) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevObj;\n}\nfunction snapshotReactivePromise(current, prev, snap) {\n    const prevObj = prev !== null && prev !== undefined && typeof prev === 'object' ? prev : undefined;\n    const value = snap(current.value, prevObj?.value);\n    const error = current.error;\n    const isPending = current.isPending;\n    const isRejected = current.isRejected;\n    const isResolved = current.isResolved;\n    const isReady = current.isReady;\n    const isSettled = current.isSettled;\n    // `run` is set once in the task constructor and never mutated, so its identity\n    // is stable for the lifetime of the underlying ReactivePromiseImpl. Carrying\n    // it on the snapshot lets consumers (e.g. React components reading a task via\n    // `useReactive`) invoke `result.run(...)` against the live task. For non-task\n    // promises this is `undefined`; we still assign the slot so the resulting\n    // object's hidden class is stable across task and non-task snapshots.\n    const run = current.run;\n    if (prevObj &&\n        value === prevObj.value &&\n        error === prevObj.error &&\n        isPending === prevObj.isPending &&\n        isRejected === prevObj.isRejected &&\n        isResolved === prevObj.isResolved &&\n        isReady === prevObj.isReady &&\n        isSettled === prevObj.isSettled &&\n        run === prevObj.run) {\n        return prevObj;\n    }\n    return { value, error, isPending, isRejected, isResolved, isReady, isSettled, run };\n}\nfunction snapshotMap(current, prev, snap) {\n    const prevMap = prev instanceof Map ? prev : undefined;\n    let changed = !prevMap || prevMap.size !== current.size;\n    const result = new Map();\n    for (const [key, val] of current) {\n        const snapped = snap(val, prevMap?.get(key));\n        result.set(key, snapped);\n        if (!changed && snapped !== prevMap.get(key)) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevMap;\n}\nfunction snapshotSet(current, prev, _snap) {\n    const prevSet = prev instanceof Set ? prev : undefined;\n    let changed = !prevSet || prevSet.size !== current.size;\n    const result = new Set();\n    for (const val of current) {\n        const snapped = snapshot(val, prevSet?.has(val) ? val : undefined);\n        result.add(snapped);\n        if (!changed && !prevSet.has(snapped)) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevSet;\n}\n/**\n * Built-in handlers for plain structural types. Matched by exact prototype\n * only — subclasses of `Object` / `Array` / `Map` / `Set` are NOT routed\n * through these handlers (they fall through and, if no custom ancestor is\n * registered, are returned as-is). We use a Map here rather than installing\n * a symbol property on the built-in prototypes, because mutating built-in\n * prototypes (even with a symbol key) changes their hidden class and\n * invalidates V8's fast-path inline caches for every plain object / array\n * in the program.\n */\nconst BUILTIN_PROTO_TO_SNAPSHOT = new Map([\n    [Object.prototype, snapshotPlainObject],\n    [Array.prototype, snapshotArray],\n    [Map.prototype, snapshotMap],\n    [Set.prototype, snapshotSet],\n    [null, snapshotPlainObject],\n]);\n/**\n * Custom registrations are stored as a non-enumerable symbol property on the\n * class prototype. JS prototype lookup walks the chain natively, so subclass\n * inheritance and override-by-redefinition are free — no resolver, no cache,\n * no invalidation. The symbol is module-private (created with `Symbol()`,\n * not `Symbol.for()`), so it cannot collide with anything else and cannot\n * be addressed by user code.\n */\nconst SNAPSHOT_HANDLER = Symbol('signalium.snapshot.handler');\n/**\n * Register a custom snapshot function for instances of a class.\n * The function receives the current value, the previous snapshot (or undefined),\n * and the recursive `snapshot` function for snapshotting nested values.\n *\n * Subclasses inherit the handler automatically via prototype lookup, so\n * registering once on a base class applies to all descendants. A descendant\n * can override by registering its own handler.\n *\n * Return `prev` when nothing has changed to preserve reference stability.\n *\n * @example\n * ```ts\n * registerCustomSnapshot(MyEntity, (current, prev, snapshot) => {\n *   const name = snapshot(current.name, prev?.name);\n *   const age = current.age;\n *   if (prev && name === prev.name && age === prev.age) return prev;\n *   return { name, age };\n * });\n * ```\n */\nexport const registerCustomSnapshot = (ctor, snapshotFn) => {\n    // Use defineProperty so the handler is non-enumerable (it shouldn't show up\n    // in `Reflect.ownKeys` walks any more than necessary) and so re-registration\n    // overwrites cleanly even if a subclass has shadowed it.\n    Object.defineProperty(ctor.prototype, SNAPSHOT_HANDLER, {\n        value: snapshotFn,\n        writable: true,\n        configurable: true,\n        enumerable: false,\n    });\n};\n/**\n * Recursively snapshot a value with structural sharing.\n *\n * - Plain objects and arrays are deep-cloned; unchanged subtrees keep the same reference.\n * - ReactivePromise instances are read (establishing deps) and flattened to a plain object.\n * - Class instances are returned as-is unless a custom handler is registered\n *   for the class or any of its ancestors via `registerCustomSnapshot`.\n * - Primitives are returned directly.\n */\nexport function snapshot(currentValue, prevValue) {\n    if (currentValue === null || typeof currentValue !== 'object') {\n        return currentValue;\n    }\n    if (isReactivePromise(currentValue)) {\n        return snapshotReactivePromise(currentValue, prevValue, snapshot);\n    }\n    // Custom registrations check first: native prototype lookup walks the chain\n    // for us, so subclasses inherit their ancestor's handler with no extra work.\n    const customHandler = currentValue[SNAPSHOT_HANDLER];\n    if (customHandler !== undefined) {\n        return customHandler(currentValue, prevValue, snapshot);\n    }\n    // Built-in handlers are looked up by exact prototype only.\n    const builtIn = BUILTIN_PROTO_TO_SNAPSHOT.get(getProto(currentValue));\n    if (builtIn !== undefined) {\n        return builtIn(currentValue, prevValue, snapshot);\n    }\n    return currentValue;\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/development/utils.js

@@ -1,5 +1,5 @@
-import { w as watcher } from "./snapshot-DbLBnoC8.js";
-import { a, s } from "./snapshot-DbLBnoC8.js";
+import { w as watcher } from "./snapshot-CkndI4Hh.js";
+import { a, s } from "./snapshot-CkndI4Hh.js";
 import { w as watchSignal, q as getSignal, j as isReactivePromise, n as isPromise, u as unwatchSignal } from "./debug-BTLbgTPK.js";
 import { l, t, v } from "./debug-BTLbgTPK.js";
 function watchOnce(fn) {

package/dist/esm/internals/utils/snapshot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"snapshot.d.ts","sourceRoot":"","sources":["../../../../src/internals/utils/snapshot.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC;AAyItE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,sBAAsB,GAAI,CAAC,SAAS,MAAM,QAC/C,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,cACnB,CAAC,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,SAAS,EAAE,QAAQ,EAAE,UAAU,KAAK,CAAC,KACvE,IAUF,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,YAAY,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,GAAG,OAAO,CAuB3E"}
+{"version":3,"file":"snapshot.d.ts","sourceRoot":"","sources":["../../../../src/internals/utils/snapshot.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC;AAkJtE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,sBAAsB,GAAI,CAAC,SAAS,MAAM,QAC/C,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,cACnB,CAAC,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,SAAS,EAAE,QAAQ,EAAE,UAAU,KAAK,CAAC,KACvE,IAUF,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,YAAY,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,GAAG,OAAO,CAuB3E"}

package/dist/esm/production/index.js

@@ -1,4 +1,4 @@
-import { b, c, r, d, t, w } from "./snapshot-DzqbjLXg.js";
+import { b, c, r, d, t, w } from "./snapshot-CdCaJJ0L.js";
 import { R, A, G, C, D, z, y, F, e, H, B, q, E } from "./contexts-FxCndlvf.js";
 import { forwardRelay, watchOnce } from "./utils.js";
 export {

package/dist/esm/production/react/index.js

@@ -3,7 +3,7 @@ import * as React from "react";
 import React__default, { createContext, useContext as useContext$1, useMemo, useRef, useEffect, useSyncExternalStore } from "react";
 import { d as getCurrentConsumer, l as getGlobalScope, S as SignalScope, m as hashValue, u as unwatchSignal, w as watchSignal, n as schedulePull, b as setCurrentConsumer, k as isReactivePromise, o as isPromise, p as isThennable, c as createReactiveSignal, r as runSignal, e as setRequestScopeGetter, q as signal } from "../contexts-FxCndlvf.js";
 import { i as isAsyncFunctionWithoutTransform, a as isGeneratorFunction, c as createServerAsyncComponentWrapper } from "../component-shared-Dva0S5e3.js";
-import { g as getReactiveFnAndDefinition, r as reactiveSignal, s as snapshot } from "../snapshot-DzqbjLXg.js";
+import { g as getReactiveFnAndDefinition, r as reactiveSignal, s as snapshot } from "../snapshot-CdCaJJ0L.js";
 const ScopeContext = createContext(void 0);
 function useScope() {
   return useContext$1(ScopeContext);

package/dist/esm/production/{snapshot-DzqbjLXg.js → snapshot-CdCaJJ0L.js}

@@ -80,10 +80,11 @@ function snapshotReactivePromise(current, prev, snap) {
   const isResolved = current.isResolved;
   const isReady = current.isReady;
   const isSettled = current.isSettled;
-  if (prevObj && value === prevObj.value && error === prevObj.error && isPending === prevObj.isPending && isRejected === prevObj.isRejected && isResolved === prevObj.isResolved && isReady === prevObj.isReady && isSettled === prevObj.isSettled) {
+  const run = current.run;
+  if (prevObj && value === prevObj.value && error === prevObj.error && isPending === prevObj.isPending && isRejected === prevObj.isRejected && isResolved === prevObj.isResolved && isReady === prevObj.isReady && isSettled === prevObj.isSettled && run === prevObj.run) {
     return prevObj;
   }
-  return { value, error, isPending, isRejected, isResolved, isReady, isSettled };
+  return { value, error, isPending, isRejected, isResolved, isReady, isSettled, run };
 }
 function snapshotMap(current, prev, snap) {
   const prevMap = prev instanceof Map ? prev : void 0;
@@ -155,4 +156,4 @@ export {
   task as t,
   watcher as w
 };
-//# sourceMappingURL=snapshot-DzqbjLXg.js.map
+//# sourceMappingURL=snapshot-CdCaJJ0L.js.map

package/dist/esm/production/snapshot-CdCaJJ0L.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-CdCaJJ0L.js","sources":["../../../.tsc-out/internals/core-api.js","../../../.tsc-out/internals/utils/snapshot.js"],"sourcesContent":["import { getCurrentScope, getScopeOwner, SignalScope } from './contexts.js';\nimport { createReactiveDefinition, createReactiveSignal, } from './reactive.js';\nimport { createRelay, createTask } from './async.js';\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\nexport const DERIVED_DEFINITION_MAP = new WeakMap();\nexport function getReactiveFnAndDefinition(fn, opts) {\n    let fnAndDef = DERIVED_DEFINITION_MAP.get(fn);\n    if (!fnAndDef) {\n        const def = createReactiveDefinition(opts?.id, opts?.desc, fn, opts?.equals, false, opts?.paramKey, undefined);\n        const defScope = getCurrentScope();\n        const reactiveFn = (...args) => {\n            const scope = getCurrentScope(defScope);\n            const signal = scope.get(def, args);\n            return signal.value;\n        };\n        fnAndDef = [reactiveFn, def];\n        DERIVED_DEFINITION_MAP.set(fn, fnAndDef);\n    }\n    return fnAndDef;\n}\nexport function reactive(fn, opts) {\n    return getReactiveFnAndDefinition(fn, opts)[0];\n}\nexport const reactiveMethod = (owner, fn, opts) => {\n    const def = createReactiveDefinition(opts?.id, opts?.desc, fn, opts?.equals, false, opts?.paramKey, undefined);\n    const reactiveFn = (...args) => {\n        return getScopeOwner(owner).get(def, args).value;\n    };\n    DERIVED_DEFINITION_MAP.set(reactiveFn, [reactiveFn, def]);\n    return reactiveFn;\n};\nexport function relay(activate, opts) {\n    const scope = getCurrentScope();\n    return createRelay(activate, scope, opts);\n}\nexport const task = (fn, opts) => {\n    const scope = getCurrentScope();\n    return createTask(fn, scope, opts);\n};\nexport function watcher(fn, opts) {\n    const def = createReactiveDefinition(opts?.id, opts?.desc, fn, opts?.equals, false, undefined, opts?.tracer);\n    const scope = opts?.isolate ? new SignalScope([]) : getCurrentScope();\n    return createReactiveSignal(def, undefined, undefined, scope);\n}\n/**\n * Creates a reactive signal from a compute function. This is useful for when you\n * want to create a signal that does not receive parameters, but is still reactive.\n *\n * @param compute\n * @param opts\n * @returns\n */\nexport const reactiveSignal = (compute, opts) => {\n    const def = createReactiveDefinition(opts?.id, opts?.desc, compute, opts?.equals, false, undefined, undefined);\n    const scope = opts?.isolate ? new SignalScope([]) : getCurrentScope();\n    return createReactiveSignal(def, undefined, undefined, scope);\n};\n","import { isReactivePromise } from '../async.js';\nconst getProto = Object.getPrototypeOf;\nfunction snapshotArray(current, prev, snap) {\n    const prevArr = Array.isArray(prev) ? prev : undefined;\n    let changed = !prevArr || prevArr.length !== current.length;\n    const result = new Array(current.length);\n    for (let i = 0; i < current.length; i++) {\n        result[i] = snap(current[i], prevArr?.[i]);\n        if (!changed && result[i] !== prevArr[i]) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevArr;\n}\nfunction snapshotPlainObject(current, prev, snap) {\n    const prevObj = prev !== null && prev !== undefined && typeof prev === 'object' && !Array.isArray(prev)\n        ? prev\n        : undefined;\n    const keys = Object.keys(current);\n    let changed = !prevObj || Object.keys(prevObj).length !== keys.length;\n    const result = {};\n    for (let i = 0; i < keys.length; i++) {\n        const key = keys[i];\n        result[key] = snap(current[key], prevObj?.[key]);\n        if (!changed && result[key] !== prevObj[key]) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevObj;\n}\nfunction snapshotReactivePromise(current, prev, snap) {\n    const prevObj = prev !== null && prev !== undefined && typeof prev === 'object' ? prev : undefined;\n    const value = snap(current.value, prevObj?.value);\n    const error = current.error;\n    const isPending = current.isPending;\n    const isRejected = current.isRejected;\n    const isResolved = current.isResolved;\n    const isReady = current.isReady;\n    const isSettled = current.isSettled;\n    // `run` is set once in the task constructor and never mutated, so its identity\n    // is stable for the lifetime of the underlying ReactivePromiseImpl. Carrying\n    // it on the snapshot lets consumers (e.g. React components reading a task via\n    // `useReactive`) invoke `result.run(...)` against the live task. For non-task\n    // promises this is `undefined`; we still assign the slot so the resulting\n    // object's hidden class is stable across task and non-task snapshots.\n    const run = current.run;\n    if (prevObj &&\n        value === prevObj.value &&\n        error === prevObj.error &&\n        isPending === prevObj.isPending &&\n        isRejected === prevObj.isRejected &&\n        isResolved === prevObj.isResolved &&\n        isReady === prevObj.isReady &&\n        isSettled === prevObj.isSettled &&\n        run === prevObj.run) {\n        return prevObj;\n    }\n    return { value, error, isPending, isRejected, isResolved, isReady, isSettled, run };\n}\nfunction snapshotMap(current, prev, snap) {\n    const prevMap = prev instanceof Map ? prev : undefined;\n    let changed = !prevMap || prevMap.size !== current.size;\n    const result = new Map();\n    for (const [key, val] of current) {\n        const snapped = snap(val, prevMap?.get(key));\n        result.set(key, snapped);\n        if (!changed && snapped !== prevMap.get(key)) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevMap;\n}\nfunction snapshotSet(current, prev, _snap) {\n    const prevSet = prev instanceof Set ? prev : undefined;\n    let changed = !prevSet || prevSet.size !== current.size;\n    const result = new Set();\n    for (const val of current) {\n        const snapped = snapshot(val, prevSet?.has(val) ? val : undefined);\n        result.add(snapped);\n        if (!changed && !prevSet.has(snapped)) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevSet;\n}\n/**\n * Built-in handlers for plain structural types. Matched by exact prototype\n * only — subclasses of `Object` / `Array` / `Map` / `Set` are NOT routed\n * through these handlers (they fall through and, if no custom ancestor is\n * registered, are returned as-is). We use a Map here rather than installing\n * a symbol property on the built-in prototypes, because mutating built-in\n * prototypes (even with a symbol key) changes their hidden class and\n * invalidates V8's fast-path inline caches for every plain object / array\n * in the program.\n */\nconst BUILTIN_PROTO_TO_SNAPSHOT = new Map([\n    [Object.prototype, snapshotPlainObject],\n    [Array.prototype, snapshotArray],\n    [Map.prototype, snapshotMap],\n    [Set.prototype, snapshotSet],\n    [null, snapshotPlainObject],\n]);\n/**\n * Custom registrations are stored as a non-enumerable symbol property on the\n * class prototype. JS prototype lookup walks the chain natively, so subclass\n * inheritance and override-by-redefinition are free — no resolver, no cache,\n * no invalidation. The symbol is module-private (created with `Symbol()`,\n * not `Symbol.for()`), so it cannot collide with anything else and cannot\n * be addressed by user code.\n */\nconst SNAPSHOT_HANDLER = Symbol('signalium.snapshot.handler');\n/**\n * Register a custom snapshot function for instances of a class.\n * The function receives the current value, the previous snapshot (or undefined),\n * and the recursive `snapshot` function for snapshotting nested values.\n *\n * Subclasses inherit the handler automatically via prototype lookup, so\n * registering once on a base class applies to all descendants. A descendant\n * can override by registering its own handler.\n *\n * Return `prev` when nothing has changed to preserve reference stability.\n *\n * @example\n * ```ts\n * registerCustomSnapshot(MyEntity, (current, prev, snapshot) => {\n *   const name = snapshot(current.name, prev?.name);\n *   const age = current.age;\n *   if (prev && name === prev.name && age === prev.age) return prev;\n *   return { name, age };\n * });\n * ```\n */\nexport const registerCustomSnapshot = (ctor, snapshotFn) => {\n    // Use defineProperty so the handler is non-enumerable (it shouldn't show up\n    // in `Reflect.ownKeys` walks any more than necessary) and so re-registration\n    // overwrites cleanly even if a subclass has shadowed it.\n    Object.defineProperty(ctor.prototype, SNAPSHOT_HANDLER, {\n        value: snapshotFn,\n        writable: true,\n        configurable: true,\n        enumerable: false,\n    });\n};\n/**\n * Recursively snapshot a value with structural sharing.\n *\n * - Plain objects and arrays are deep-cloned; unchanged subtrees keep the same reference.\n * - ReactivePromise instances are read (establishing deps) and flattened to a plain object.\n * - Class instances are returned as-is unless a custom handler is registered\n *   for the class or any of its ancestors via `registerCustomSnapshot`.\n * - Primitives are returned directly.\n */\nexport function snapshot(currentValue, prevValue) {\n    if (currentValue === null || typeof currentValue !== 'object') {\n        return currentValue;\n    }\n    if (isReactivePromise(currentValue)) {\n        return snapshotReactivePromise(currentValue, prevValue, snapshot);\n    }\n    // Custom registrations check first: native prototype lookup walks the chain\n    // for us, so subclasses inherit their ancestor's handler with no extra work.\n    const customHandler = currentValue[SNAPSHOT_HANDLER];\n    if (customHandler !== undefined) {\n        return customHandler(currentValue, prevValue, snapshot);\n    }\n    // Built-in handlers are looked up by exact prototype only.\n    const builtIn = BUILTIN_PROTO_TO_SNAPSHOT.get(getProto(currentValue));\n    if (builtIn !== undefined) {\n        return builtIn(currentValue, prevValue, snapshot);\n    }\n    return currentValue;\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/production/utils.js

@@ -1,5 +1,5 @@
-import { w as watcher } from "./snapshot-DzqbjLXg.js";
-import { a, s } from "./snapshot-DzqbjLXg.js";
+import { w as watcher } from "./snapshot-CdCaJJ0L.js";
+import { a, s } from "./snapshot-CdCaJJ0L.js";
 import { w as watchSignal, t as getSignal, k as isReactivePromise, o as isPromise, u as unwatchSignal } from "./contexts-FxCndlvf.js";
 import { m, v, x } from "./contexts-FxCndlvf.js";
 function watchOnce(fn) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalium",
-  "version": "3.0.1",
+  "version": "3.0.2",
   "type": "module",
   "repository": {
     "type": "git",

package/dist/cjs/development/snapshot-BfP4w3lC.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"snapshot-BfP4w3lC.js","sources":["../../../.tsc-out/internals/core-api.js","../../../.tsc-out/internals/utils/snapshot.js"],"sourcesContent":["import { getCurrentScope, getScopeOwner, SignalScope } from './contexts.js';\nimport { createReactiveDefinition, createReactiveSignal, } from './reactive.js';\nimport { createRelay, createTask } from './async.js';\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\nexport const DERIVED_DEFINITION_MAP = new WeakMap();\nexport function getReactiveFnAndDefinition(fn, opts) {\n    let fnAndDef = DERIVED_DEFINITION_MAP.get(fn);\n    if (!fnAndDef) {\n        const def = createReactiveDefinition(opts?.id, opts?.desc, fn, opts?.equals, false, opts?.paramKey, undefined);\n        const defScope = getCurrentScope();\n        const reactiveFn = (...args) => {\n            const scope = getCurrentScope(defScope);\n            const signal = scope.get(def, args);\n            return signal.value;\n        };\n        fnAndDef = [reactiveFn, def];\n        DERIVED_DEFINITION_MAP.set(fn, fnAndDef);\n    }\n    return fnAndDef;\n}\nexport function reactive(fn, opts) {\n    return getReactiveFnAndDefinition(fn, opts)[0];\n}\nexport const reactiveMethod = (owner, fn, opts) => {\n    const def = createReactiveDefinition(opts?.id, opts?.desc, fn, opts?.equals, false, opts?.paramKey, undefined);\n    const reactiveFn = (...args) => {\n        return getScopeOwner(owner).get(def, args).value;\n    };\n    DERIVED_DEFINITION_MAP.set(reactiveFn, [reactiveFn, def]);\n    return reactiveFn;\n};\nexport function relay(activate, opts) {\n    const scope = getCurrentScope();\n    return createRelay(activate, scope, opts);\n}\nexport const task = (fn, opts) => {\n    const scope = getCurrentScope();\n    return createTask(fn, scope, opts);\n};\nexport function watcher(fn, opts) {\n    const def = createReactiveDefinition(opts?.id, opts?.desc, fn, opts?.equals, false, undefined, opts?.tracer);\n    const scope = opts?.isolate ? new SignalScope([]) : getCurrentScope();\n    return createReactiveSignal(def, undefined, undefined, scope);\n}\n/**\n * Creates a reactive signal from a compute function. This is useful for when you\n * want to create a signal that does not receive parameters, but is still reactive.\n *\n * @param compute\n * @param opts\n * @returns\n */\nexport const reactiveSignal = (compute, opts) => {\n    const def = createReactiveDefinition(opts?.id, opts?.desc, compute, opts?.equals, false, undefined, undefined);\n    const scope = opts?.isolate ? new SignalScope([]) : getCurrentScope();\n    return createReactiveSignal(def, undefined, undefined, scope);\n};\n","import { isReactivePromise } from '../async.js';\nconst getProto = Object.getPrototypeOf;\nfunction snapshotArray(current, prev, snap) {\n    const prevArr = Array.isArray(prev) ? prev : undefined;\n    let changed = !prevArr || prevArr.length !== current.length;\n    const result = new Array(current.length);\n    for (let i = 0; i < current.length; i++) {\n        result[i] = snap(current[i], prevArr?.[i]);\n        if (!changed && result[i] !== prevArr[i]) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevArr;\n}\nfunction snapshotPlainObject(current, prev, snap) {\n    const prevObj = prev !== null && prev !== undefined && typeof prev === 'object' && !Array.isArray(prev)\n        ? prev\n        : undefined;\n    const keys = Object.keys(current);\n    let changed = !prevObj || Object.keys(prevObj).length !== keys.length;\n    const result = {};\n    for (let i = 0; i < keys.length; i++) {\n        const key = keys[i];\n        result[key] = snap(current[key], prevObj?.[key]);\n        if (!changed && result[key] !== prevObj[key]) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevObj;\n}\nfunction snapshotReactivePromise(current, prev, snap) {\n    const prevObj = prev !== null && prev !== undefined && typeof prev === 'object' ? prev : undefined;\n    const value = snap(current.value, prevObj?.value);\n    const error = current.error;\n    const isPending = current.isPending;\n    const isRejected = current.isRejected;\n    const isResolved = current.isResolved;\n    const isReady = current.isReady;\n    const isSettled = current.isSettled;\n    if (prevObj &&\n        value === prevObj.value &&\n        error === prevObj.error &&\n        isPending === prevObj.isPending &&\n        isRejected === prevObj.isRejected &&\n        isResolved === prevObj.isResolved &&\n        isReady === prevObj.isReady &&\n        isSettled === prevObj.isSettled) {\n        return prevObj;\n    }\n    return { value, error, isPending, isRejected, isResolved, isReady, isSettled };\n}\nfunction snapshotMap(current, prev, snap) {\n    const prevMap = prev instanceof Map ? prev : undefined;\n    let changed = !prevMap || prevMap.size !== current.size;\n    const result = new Map();\n    for (const [key, val] of current) {\n        const snapped = snap(val, prevMap?.get(key));\n        result.set(key, snapped);\n        if (!changed && snapped !== prevMap.get(key)) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevMap;\n}\nfunction snapshotSet(current, prev, _snap) {\n    const prevSet = prev instanceof Set ? prev : undefined;\n    let changed = !prevSet || prevSet.size !== current.size;\n    const result = new Set();\n    for (const val of current) {\n        const snapped = snapshot(val, prevSet?.has(val) ? val : undefined);\n        result.add(snapped);\n        if (!changed && !prevSet.has(snapped)) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevSet;\n}\n/**\n * Built-in handlers for plain structural types. Matched by exact prototype\n * only — subclasses of `Object` / `Array` / `Map` / `Set` are NOT routed\n * through these handlers (they fall through and, if no custom ancestor is\n * registered, are returned as-is). We use a Map here rather than installing\n * a symbol property on the built-in prototypes, because mutating built-in\n * prototypes (even with a symbol key) changes their hidden class and\n * invalidates V8's fast-path inline caches for every plain object / array\n * in the program.\n */\nconst BUILTIN_PROTO_TO_SNAPSHOT = new Map([\n    [Object.prototype, snapshotPlainObject],\n    [Array.prototype, snapshotArray],\n    [Map.prototype, snapshotMap],\n    [Set.prototype, snapshotSet],\n    [null, snapshotPlainObject],\n]);\n/**\n * Custom registrations are stored as a non-enumerable symbol property on the\n * class prototype. JS prototype lookup walks the chain natively, so subclass\n * inheritance and override-by-redefinition are free — no resolver, no cache,\n * no invalidation. The symbol is module-private (created with `Symbol()`,\n * not `Symbol.for()`), so it cannot collide with anything else and cannot\n * be addressed by user code.\n */\nconst SNAPSHOT_HANDLER = Symbol('signalium.snapshot.handler');\n/**\n * Register a custom snapshot function for instances of a class.\n * The function receives the current value, the previous snapshot (or undefined),\n * and the recursive `snapshot` function for snapshotting nested values.\n *\n * Subclasses inherit the handler automatically via prototype lookup, so\n * registering once on a base class applies to all descendants. A descendant\n * can override by registering its own handler.\n *\n * Return `prev` when nothing has changed to preserve reference stability.\n *\n * @example\n * ```ts\n * registerCustomSnapshot(MyEntity, (current, prev, snapshot) => {\n *   const name = snapshot(current.name, prev?.name);\n *   const age = current.age;\n *   if (prev && name === prev.name && age === prev.age) return prev;\n *   return { name, age };\n * });\n * ```\n */\nexport const registerCustomSnapshot = (ctor, snapshotFn) => {\n    // Use defineProperty so the handler is non-enumerable (it shouldn't show up\n    // in `Reflect.ownKeys` walks any more than necessary) and so re-registration\n    // overwrites cleanly even if a subclass has shadowed it.\n    Object.defineProperty(ctor.prototype, SNAPSHOT_HANDLER, {\n        value: snapshotFn,\n        writable: true,\n        configurable: true,\n        enumerable: false,\n    });\n};\n/**\n * Recursively snapshot a value with structural sharing.\n *\n * - Plain objects and arrays are deep-cloned; unchanged subtrees keep the same reference.\n * - ReactivePromise instances are read (establishing deps) and flattened to a plain object.\n * - Class instances are returned as-is unless a custom handler is registered\n *   for the class or any of its ancestors via `registerCustomSnapshot`.\n * - Primitives are returned directly.\n */\nexport function snapshot(currentValue, prevValue) {\n    if (currentValue === null || typeof currentValue !== 'object') {\n        return currentValue;\n    }\n    if (isReactivePromise(currentValue)) {\n        return snapshotReactivePromise(currentValue, prevValue, snapshot);\n    }\n    // Custom registrations check first: native prototype lookup walks the chain\n    // for us, so subclasses inherit their ancestor's handler with no extra work.\n    const customHandler = currentValue[SNAPSHOT_HANDLER];\n    if (customHandler !== undefined) {\n        return customHandler(currentValue, prevValue, snapshot);\n    }\n    // Built-in handlers are looked up by exact prototype only.\n    const builtIn = BUILTIN_PROTO_TO_SNAPSHOT.get(getProto(currentValue));\n    if (builtIn !== undefined) {\n        return builtIn(currentValue, prevValue, snapshot);\n    }\n    return currentValue;\n}\n"],"names":["createReactiveDefinition","getCurrentScope","getScopeOwner","createRelay","createTask","SignalScope","createReactiveSignal","isReactivePromise"],"mappings":"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"}

package/dist/cjs/production/snapshot-DnzyLNij.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"snapshot-DnzyLNij.js","sources":["../../../.tsc-out/internals/core-api.js","../../../.tsc-out/internals/utils/snapshot.js"],"sourcesContent":["import { getCurrentScope, getScopeOwner, SignalScope } from './contexts.js';\nimport { createReactiveDefinition, createReactiveSignal, } from './reactive.js';\nimport { createRelay, createTask } from './async.js';\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\nexport const DERIVED_DEFINITION_MAP = new WeakMap();\nexport function getReactiveFnAndDefinition(fn, opts) {\n    let fnAndDef = DERIVED_DEFINITION_MAP.get(fn);\n    if (!fnAndDef) {\n        const def = createReactiveDefinition(opts?.id, opts?.desc, fn, opts?.equals, false, opts?.paramKey, undefined);\n        const defScope = getCurrentScope();\n        const reactiveFn = (...args) => {\n            const scope = getCurrentScope(defScope);\n            const signal = scope.get(def, args);\n            return signal.value;\n        };\n        fnAndDef = [reactiveFn, def];\n        DERIVED_DEFINITION_MAP.set(fn, fnAndDef);\n    }\n    return fnAndDef;\n}\nexport function reactive(fn, opts) {\n    return getReactiveFnAndDefinition(fn, opts)[0];\n}\nexport const reactiveMethod = (owner, fn, opts) => {\n    const def = createReactiveDefinition(opts?.id, opts?.desc, fn, opts?.equals, false, opts?.paramKey, undefined);\n    const reactiveFn = (...args) => {\n        return getScopeOwner(owner).get(def, args).value;\n    };\n    DERIVED_DEFINITION_MAP.set(reactiveFn, [reactiveFn, def]);\n    return reactiveFn;\n};\nexport function relay(activate, opts) {\n    const scope = getCurrentScope();\n    return createRelay(activate, scope, opts);\n}\nexport const task = (fn, opts) => {\n    const scope = getCurrentScope();\n    return createTask(fn, scope, opts);\n};\nexport function watcher(fn, opts) {\n    const def = createReactiveDefinition(opts?.id, opts?.desc, fn, opts?.equals, false, undefined, opts?.tracer);\n    const scope = opts?.isolate ? new SignalScope([]) : getCurrentScope();\n    return createReactiveSignal(def, undefined, undefined, scope);\n}\n/**\n * Creates a reactive signal from a compute function. This is useful for when you\n * want to create a signal that does not receive parameters, but is still reactive.\n *\n * @param compute\n * @param opts\n * @returns\n */\nexport const reactiveSignal = (compute, opts) => {\n    const def = createReactiveDefinition(opts?.id, opts?.desc, compute, opts?.equals, false, undefined, undefined);\n    const scope = opts?.isolate ? new SignalScope([]) : getCurrentScope();\n    return createReactiveSignal(def, undefined, undefined, scope);\n};\n","import { isReactivePromise } from '../async.js';\nconst getProto = Object.getPrototypeOf;\nfunction snapshotArray(current, prev, snap) {\n    const prevArr = Array.isArray(prev) ? prev : undefined;\n    let changed = !prevArr || prevArr.length !== current.length;\n    const result = new Array(current.length);\n    for (let i = 0; i < current.length; i++) {\n        result[i] = snap(current[i], prevArr?.[i]);\n        if (!changed && result[i] !== prevArr[i]) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevArr;\n}\nfunction snapshotPlainObject(current, prev, snap) {\n    const prevObj = prev !== null && prev !== undefined && typeof prev === 'object' && !Array.isArray(prev)\n        ? prev\n        : undefined;\n    const keys = Object.keys(current);\n    let changed = !prevObj || Object.keys(prevObj).length !== keys.length;\n    const result = {};\n    for (let i = 0; i < keys.length; i++) {\n        const key = keys[i];\n        result[key] = snap(current[key], prevObj?.[key]);\n        if (!changed && result[key] !== prevObj[key]) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevObj;\n}\nfunction snapshotReactivePromise(current, prev, snap) {\n    const prevObj = prev !== null && prev !== undefined && typeof prev === 'object' ? prev : undefined;\n    const value = snap(current.value, prevObj?.value);\n    const error = current.error;\n    const isPending = current.isPending;\n    const isRejected = current.isRejected;\n    const isResolved = current.isResolved;\n    const isReady = current.isReady;\n    const isSettled = current.isSettled;\n    if (prevObj &&\n        value === prevObj.value &&\n        error === prevObj.error &&\n        isPending === prevObj.isPending &&\n        isRejected === prevObj.isRejected &&\n        isResolved === prevObj.isResolved &&\n        isReady === prevObj.isReady &&\n        isSettled === prevObj.isSettled) {\n        return prevObj;\n    }\n    return { value, error, isPending, isRejected, isResolved, isReady, isSettled };\n}\nfunction snapshotMap(current, prev, snap) {\n    const prevMap = prev instanceof Map ? prev : undefined;\n    let changed = !prevMap || prevMap.size !== current.size;\n    const result = new Map();\n    for (const [key, val] of current) {\n        const snapped = snap(val, prevMap?.get(key));\n        result.set(key, snapped);\n        if (!changed && snapped !== prevMap.get(key)) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevMap;\n}\nfunction snapshotSet(current, prev, _snap) {\n    const prevSet = prev instanceof Set ? prev : undefined;\n    let changed = !prevSet || prevSet.size !== current.size;\n    const result = new Set();\n    for (const val of current) {\n        const snapped = snapshot(val, prevSet?.has(val) ? val : undefined);\n        result.add(snapped);\n        if (!changed && !prevSet.has(snapped)) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevSet;\n}\n/**\n * Built-in handlers for plain structural types. Matched by exact prototype\n * only — subclasses of `Object` / `Array` / `Map` / `Set` are NOT routed\n * through these handlers (they fall through and, if no custom ancestor is\n * registered, are returned as-is). We use a Map here rather than installing\n * a symbol property on the built-in prototypes, because mutating built-in\n * prototypes (even with a symbol key) changes their hidden class and\n * invalidates V8's fast-path inline caches for every plain object / array\n * in the program.\n */\nconst BUILTIN_PROTO_TO_SNAPSHOT = new Map([\n    [Object.prototype, snapshotPlainObject],\n    [Array.prototype, snapshotArray],\n    [Map.prototype, snapshotMap],\n    [Set.prototype, snapshotSet],\n    [null, snapshotPlainObject],\n]);\n/**\n * Custom registrations are stored as a non-enumerable symbol property on the\n * class prototype. JS prototype lookup walks the chain natively, so subclass\n * inheritance and override-by-redefinition are free — no resolver, no cache,\n * no invalidation. The symbol is module-private (created with `Symbol()`,\n * not `Symbol.for()`), so it cannot collide with anything else and cannot\n * be addressed by user code.\n */\nconst SNAPSHOT_HANDLER = Symbol('signalium.snapshot.handler');\n/**\n * Register a custom snapshot function for instances of a class.\n * The function receives the current value, the previous snapshot (or undefined),\n * and the recursive `snapshot` function for snapshotting nested values.\n *\n * Subclasses inherit the handler automatically via prototype lookup, so\n * registering once on a base class applies to all descendants. A descendant\n * can override by registering its own handler.\n *\n * Return `prev` when nothing has changed to preserve reference stability.\n *\n * @example\n * ```ts\n * registerCustomSnapshot(MyEntity, (current, prev, snapshot) => {\n *   const name = snapshot(current.name, prev?.name);\n *   const age = current.age;\n *   if (prev && name === prev.name && age === prev.age) return prev;\n *   return { name, age };\n * });\n * ```\n */\nexport const registerCustomSnapshot = (ctor, snapshotFn) => {\n    // Use defineProperty so the handler is non-enumerable (it shouldn't show up\n    // in `Reflect.ownKeys` walks any more than necessary) and so re-registration\n    // overwrites cleanly even if a subclass has shadowed it.\n    Object.defineProperty(ctor.prototype, SNAPSHOT_HANDLER, {\n        value: snapshotFn,\n        writable: true,\n        configurable: true,\n        enumerable: false,\n    });\n};\n/**\n * Recursively snapshot a value with structural sharing.\n *\n * - Plain objects and arrays are deep-cloned; unchanged subtrees keep the same reference.\n * - ReactivePromise instances are read (establishing deps) and flattened to a plain object.\n * - Class instances are returned as-is unless a custom handler is registered\n *   for the class or any of its ancestors via `registerCustomSnapshot`.\n * - Primitives are returned directly.\n */\nexport function snapshot(currentValue, prevValue) {\n    if (currentValue === null || typeof currentValue !== 'object') {\n        return currentValue;\n    }\n    if (isReactivePromise(currentValue)) {\n        return snapshotReactivePromise(currentValue, prevValue, snapshot);\n    }\n    // Custom registrations check first: native prototype lookup walks the chain\n    // for us, so subclasses inherit their ancestor's handler with no extra work.\n    const customHandler = currentValue[SNAPSHOT_HANDLER];\n    if (customHandler !== undefined) {\n        return customHandler(currentValue, prevValue, snapshot);\n    }\n    // Built-in handlers are looked up by exact prototype only.\n    const builtIn = BUILTIN_PROTO_TO_SNAPSHOT.get(getProto(currentValue));\n    if (builtIn !== undefined) {\n        return builtIn(currentValue, prevValue, snapshot);\n    }\n    return currentValue;\n}\n"],"names":["createReactiveDefinition","getCurrentScope","getScopeOwner","createRelay","createTask","SignalScope","createReactiveSignal","isReactivePromise"],"mappings":"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"}

package/dist/esm/development/snapshot-DbLBnoC8.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"snapshot-DbLBnoC8.js","sources":["../../../.tsc-out/internals/core-api.js","../../../.tsc-out/internals/utils/snapshot.js"],"sourcesContent":["import { getCurrentScope, getScopeOwner, SignalScope } from './contexts.js';\nimport { createReactiveDefinition, createReactiveSignal, } from './reactive.js';\nimport { createRelay, createTask } from './async.js';\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\nexport const DERIVED_DEFINITION_MAP = new WeakMap();\nexport function getReactiveFnAndDefinition(fn, opts) {\n    let fnAndDef = DERIVED_DEFINITION_MAP.get(fn);\n    if (!fnAndDef) {\n        const def = createReactiveDefinition(opts?.id, opts?.desc, fn, opts?.equals, false, opts?.paramKey, undefined);\n        const defScope = getCurrentScope();\n        const reactiveFn = (...args) => {\n            const scope = getCurrentScope(defScope);\n            const signal = scope.get(def, args);\n            return signal.value;\n        };\n        fnAndDef = [reactiveFn, def];\n        DERIVED_DEFINITION_MAP.set(fn, fnAndDef);\n    }\n    return fnAndDef;\n}\nexport function reactive(fn, opts) {\n    return getReactiveFnAndDefinition(fn, opts)[0];\n}\nexport const reactiveMethod = (owner, fn, opts) => {\n    const def = createReactiveDefinition(opts?.id, opts?.desc, fn, opts?.equals, false, opts?.paramKey, undefined);\n    const reactiveFn = (...args) => {\n        return getScopeOwner(owner).get(def, args).value;\n    };\n    DERIVED_DEFINITION_MAP.set(reactiveFn, [reactiveFn, def]);\n    return reactiveFn;\n};\nexport function relay(activate, opts) {\n    const scope = getCurrentScope();\n    return createRelay(activate, scope, opts);\n}\nexport const task = (fn, opts) => {\n    const scope = getCurrentScope();\n    return createTask(fn, scope, opts);\n};\nexport function watcher(fn, opts) {\n    const def = createReactiveDefinition(opts?.id, opts?.desc, fn, opts?.equals, false, undefined, opts?.tracer);\n    const scope = opts?.isolate ? new SignalScope([]) : getCurrentScope();\n    return createReactiveSignal(def, undefined, undefined, scope);\n}\n/**\n * Creates a reactive signal from a compute function. This is useful for when you\n * want to create a signal that does not receive parameters, but is still reactive.\n *\n * @param compute\n * @param opts\n * @returns\n */\nexport const reactiveSignal = (compute, opts) => {\n    const def = createReactiveDefinition(opts?.id, opts?.desc, compute, opts?.equals, false, undefined, undefined);\n    const scope = opts?.isolate ? new SignalScope([]) : getCurrentScope();\n    return createReactiveSignal(def, undefined, undefined, scope);\n};\n","import { isReactivePromise } from '../async.js';\nconst getProto = Object.getPrototypeOf;\nfunction snapshotArray(current, prev, snap) {\n    const prevArr = Array.isArray(prev) ? prev : undefined;\n    let changed = !prevArr || prevArr.length !== current.length;\n    const result = new Array(current.length);\n    for (let i = 0; i < current.length; i++) {\n        result[i] = snap(current[i], prevArr?.[i]);\n        if (!changed && result[i] !== prevArr[i]) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevArr;\n}\nfunction snapshotPlainObject(current, prev, snap) {\n    const prevObj = prev !== null && prev !== undefined && typeof prev === 'object' && !Array.isArray(prev)\n        ? prev\n        : undefined;\n    const keys = Object.keys(current);\n    let changed = !prevObj || Object.keys(prevObj).length !== keys.length;\n    const result = {};\n    for (let i = 0; i < keys.length; i++) {\n        const key = keys[i];\n        result[key] = snap(current[key], prevObj?.[key]);\n        if (!changed && result[key] !== prevObj[key]) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevObj;\n}\nfunction snapshotReactivePromise(current, prev, snap) {\n    const prevObj = prev !== null && prev !== undefined && typeof prev === 'object' ? prev : undefined;\n    const value = snap(current.value, prevObj?.value);\n    const error = current.error;\n    const isPending = current.isPending;\n    const isRejected = current.isRejected;\n    const isResolved = current.isResolved;\n    const isReady = current.isReady;\n    const isSettled = current.isSettled;\n    if (prevObj &&\n        value === prevObj.value &&\n        error === prevObj.error &&\n        isPending === prevObj.isPending &&\n        isRejected === prevObj.isRejected &&\n        isResolved === prevObj.isResolved &&\n        isReady === prevObj.isReady &&\n        isSettled === prevObj.isSettled) {\n        return prevObj;\n    }\n    return { value, error, isPending, isRejected, isResolved, isReady, isSettled };\n}\nfunction snapshotMap(current, prev, snap) {\n    const prevMap = prev instanceof Map ? prev : undefined;\n    let changed = !prevMap || prevMap.size !== current.size;\n    const result = new Map();\n    for (const [key, val] of current) {\n        const snapped = snap(val, prevMap?.get(key));\n        result.set(key, snapped);\n        if (!changed && snapped !== prevMap.get(key)) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevMap;\n}\nfunction snapshotSet(current, prev, _snap) {\n    const prevSet = prev instanceof Set ? prev : undefined;\n    let changed = !prevSet || prevSet.size !== current.size;\n    const result = new Set();\n    for (const val of current) {\n        const snapped = snapshot(val, prevSet?.has(val) ? val : undefined);\n        result.add(snapped);\n        if (!changed && !prevSet.has(snapped)) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevSet;\n}\n/**\n * Built-in handlers for plain structural types. Matched by exact prototype\n * only — subclasses of `Object` / `Array` / `Map` / `Set` are NOT routed\n * through these handlers (they fall through and, if no custom ancestor is\n * registered, are returned as-is). We use a Map here rather than installing\n * a symbol property on the built-in prototypes, because mutating built-in\n * prototypes (even with a symbol key) changes their hidden class and\n * invalidates V8's fast-path inline caches for every plain object / array\n * in the program.\n */\nconst BUILTIN_PROTO_TO_SNAPSHOT = new Map([\n    [Object.prototype, snapshotPlainObject],\n    [Array.prototype, snapshotArray],\n    [Map.prototype, snapshotMap],\n    [Set.prototype, snapshotSet],\n    [null, snapshotPlainObject],\n]);\n/**\n * Custom registrations are stored as a non-enumerable symbol property on the\n * class prototype. JS prototype lookup walks the chain natively, so subclass\n * inheritance and override-by-redefinition are free — no resolver, no cache,\n * no invalidation. The symbol is module-private (created with `Symbol()`,\n * not `Symbol.for()`), so it cannot collide with anything else and cannot\n * be addressed by user code.\n */\nconst SNAPSHOT_HANDLER = Symbol('signalium.snapshot.handler');\n/**\n * Register a custom snapshot function for instances of a class.\n * The function receives the current value, the previous snapshot (or undefined),\n * and the recursive `snapshot` function for snapshotting nested values.\n *\n * Subclasses inherit the handler automatically via prototype lookup, so\n * registering once on a base class applies to all descendants. A descendant\n * can override by registering its own handler.\n *\n * Return `prev` when nothing has changed to preserve reference stability.\n *\n * @example\n * ```ts\n * registerCustomSnapshot(MyEntity, (current, prev, snapshot) => {\n *   const name = snapshot(current.name, prev?.name);\n *   const age = current.age;\n *   if (prev && name === prev.name && age === prev.age) return prev;\n *   return { name, age };\n * });\n * ```\n */\nexport const registerCustomSnapshot = (ctor, snapshotFn) => {\n    // Use defineProperty so the handler is non-enumerable (it shouldn't show up\n    // in `Reflect.ownKeys` walks any more than necessary) and so re-registration\n    // overwrites cleanly even if a subclass has shadowed it.\n    Object.defineProperty(ctor.prototype, SNAPSHOT_HANDLER, {\n        value: snapshotFn,\n        writable: true,\n        configurable: true,\n        enumerable: false,\n    });\n};\n/**\n * Recursively snapshot a value with structural sharing.\n *\n * - Plain objects and arrays are deep-cloned; unchanged subtrees keep the same reference.\n * - ReactivePromise instances are read (establishing deps) and flattened to a plain object.\n * - Class instances are returned as-is unless a custom handler is registered\n *   for the class or any of its ancestors via `registerCustomSnapshot`.\n * - Primitives are returned directly.\n */\nexport function snapshot(currentValue, prevValue) {\n    if (currentValue === null || typeof currentValue !== 'object') {\n        return currentValue;\n    }\n    if (isReactivePromise(currentValue)) {\n        return snapshotReactivePromise(currentValue, prevValue, snapshot);\n    }\n    // Custom registrations check first: native prototype lookup walks the chain\n    // for us, so subclasses inherit their ancestor's handler with no extra work.\n    const customHandler = currentValue[SNAPSHOT_HANDLER];\n    if (customHandler !== undefined) {\n        return customHandler(currentValue, prevValue, snapshot);\n    }\n    // Built-in handlers are looked up by exact prototype only.\n    const builtIn = BUILTIN_PROTO_TO_SNAPSHOT.get(getProto(currentValue));\n    if (builtIn !== undefined) {\n        return builtIn(currentValue, prevValue, snapshot);\n    }\n    return currentValue;\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/production/snapshot-DzqbjLXg.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"snapshot-DzqbjLXg.js","sources":["../../../.tsc-out/internals/core-api.js","../../../.tsc-out/internals/utils/snapshot.js"],"sourcesContent":["import { getCurrentScope, getScopeOwner, SignalScope } from './contexts.js';\nimport { createReactiveDefinition, createReactiveSignal, } from './reactive.js';\nimport { createRelay, createTask } from './async.js';\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\nexport const DERIVED_DEFINITION_MAP = new WeakMap();\nexport function getReactiveFnAndDefinition(fn, opts) {\n    let fnAndDef = DERIVED_DEFINITION_MAP.get(fn);\n    if (!fnAndDef) {\n        const def = createReactiveDefinition(opts?.id, opts?.desc, fn, opts?.equals, false, opts?.paramKey, undefined);\n        const defScope = getCurrentScope();\n        const reactiveFn = (...args) => {\n            const scope = getCurrentScope(defScope);\n            const signal = scope.get(def, args);\n            return signal.value;\n        };\n        fnAndDef = [reactiveFn, def];\n        DERIVED_DEFINITION_MAP.set(fn, fnAndDef);\n    }\n    return fnAndDef;\n}\nexport function reactive(fn, opts) {\n    return getReactiveFnAndDefinition(fn, opts)[0];\n}\nexport const reactiveMethod = (owner, fn, opts) => {\n    const def = createReactiveDefinition(opts?.id, opts?.desc, fn, opts?.equals, false, opts?.paramKey, undefined);\n    const reactiveFn = (...args) => {\n        return getScopeOwner(owner).get(def, args).value;\n    };\n    DERIVED_DEFINITION_MAP.set(reactiveFn, [reactiveFn, def]);\n    return reactiveFn;\n};\nexport function relay(activate, opts) {\n    const scope = getCurrentScope();\n    return createRelay(activate, scope, opts);\n}\nexport const task = (fn, opts) => {\n    const scope = getCurrentScope();\n    return createTask(fn, scope, opts);\n};\nexport function watcher(fn, opts) {\n    const def = createReactiveDefinition(opts?.id, opts?.desc, fn, opts?.equals, false, undefined, opts?.tracer);\n    const scope = opts?.isolate ? new SignalScope([]) : getCurrentScope();\n    return createReactiveSignal(def, undefined, undefined, scope);\n}\n/**\n * Creates a reactive signal from a compute function. This is useful for when you\n * want to create a signal that does not receive parameters, but is still reactive.\n *\n * @param compute\n * @param opts\n * @returns\n */\nexport const reactiveSignal = (compute, opts) => {\n    const def = createReactiveDefinition(opts?.id, opts?.desc, compute, opts?.equals, false, undefined, undefined);\n    const scope = opts?.isolate ? new SignalScope([]) : getCurrentScope();\n    return createReactiveSignal(def, undefined, undefined, scope);\n};\n","import { isReactivePromise } from '../async.js';\nconst getProto = Object.getPrototypeOf;\nfunction snapshotArray(current, prev, snap) {\n    const prevArr = Array.isArray(prev) ? prev : undefined;\n    let changed = !prevArr || prevArr.length !== current.length;\n    const result = new Array(current.length);\n    for (let i = 0; i < current.length; i++) {\n        result[i] = snap(current[i], prevArr?.[i]);\n        if (!changed && result[i] !== prevArr[i]) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevArr;\n}\nfunction snapshotPlainObject(current, prev, snap) {\n    const prevObj = prev !== null && prev !== undefined && typeof prev === 'object' && !Array.isArray(prev)\n        ? prev\n        : undefined;\n    const keys = Object.keys(current);\n    let changed = !prevObj || Object.keys(prevObj).length !== keys.length;\n    const result = {};\n    for (let i = 0; i < keys.length; i++) {\n        const key = keys[i];\n        result[key] = snap(current[key], prevObj?.[key]);\n        if (!changed && result[key] !== prevObj[key]) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevObj;\n}\nfunction snapshotReactivePromise(current, prev, snap) {\n    const prevObj = prev !== null && prev !== undefined && typeof prev === 'object' ? prev : undefined;\n    const value = snap(current.value, prevObj?.value);\n    const error = current.error;\n    const isPending = current.isPending;\n    const isRejected = current.isRejected;\n    const isResolved = current.isResolved;\n    const isReady = current.isReady;\n    const isSettled = current.isSettled;\n    if (prevObj &&\n        value === prevObj.value &&\n        error === prevObj.error &&\n        isPending === prevObj.isPending &&\n        isRejected === prevObj.isRejected &&\n        isResolved === prevObj.isResolved &&\n        isReady === prevObj.isReady &&\n        isSettled === prevObj.isSettled) {\n        return prevObj;\n    }\n    return { value, error, isPending, isRejected, isResolved, isReady, isSettled };\n}\nfunction snapshotMap(current, prev, snap) {\n    const prevMap = prev instanceof Map ? prev : undefined;\n    let changed = !prevMap || prevMap.size !== current.size;\n    const result = new Map();\n    for (const [key, val] of current) {\n        const snapped = snap(val, prevMap?.get(key));\n        result.set(key, snapped);\n        if (!changed && snapped !== prevMap.get(key)) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevMap;\n}\nfunction snapshotSet(current, prev, _snap) {\n    const prevSet = prev instanceof Set ? prev : undefined;\n    let changed = !prevSet || prevSet.size !== current.size;\n    const result = new Set();\n    for (const val of current) {\n        const snapped = snapshot(val, prevSet?.has(val) ? val : undefined);\n        result.add(snapped);\n        if (!changed && !prevSet.has(snapped)) {\n            changed = true;\n        }\n    }\n    return changed ? result : prevSet;\n}\n/**\n * Built-in handlers for plain structural types. Matched by exact prototype\n * only — subclasses of `Object` / `Array` / `Map` / `Set` are NOT routed\n * through these handlers (they fall through and, if no custom ancestor is\n * registered, are returned as-is). We use a Map here rather than installing\n * a symbol property on the built-in prototypes, because mutating built-in\n * prototypes (even with a symbol key) changes their hidden class and\n * invalidates V8's fast-path inline caches for every plain object / array\n * in the program.\n */\nconst BUILTIN_PROTO_TO_SNAPSHOT = new Map([\n    [Object.prototype, snapshotPlainObject],\n    [Array.prototype, snapshotArray],\n    [Map.prototype, snapshotMap],\n    [Set.prototype, snapshotSet],\n    [null, snapshotPlainObject],\n]);\n/**\n * Custom registrations are stored as a non-enumerable symbol property on the\n * class prototype. JS prototype lookup walks the chain natively, so subclass\n * inheritance and override-by-redefinition are free — no resolver, no cache,\n * no invalidation. The symbol is module-private (created with `Symbol()`,\n * not `Symbol.for()`), so it cannot collide with anything else and cannot\n * be addressed by user code.\n */\nconst SNAPSHOT_HANDLER = Symbol('signalium.snapshot.handler');\n/**\n * Register a custom snapshot function for instances of a class.\n * The function receives the current value, the previous snapshot (or undefined),\n * and the recursive `snapshot` function for snapshotting nested values.\n *\n * Subclasses inherit the handler automatically via prototype lookup, so\n * registering once on a base class applies to all descendants. A descendant\n * can override by registering its own handler.\n *\n * Return `prev` when nothing has changed to preserve reference stability.\n *\n * @example\n * ```ts\n * registerCustomSnapshot(MyEntity, (current, prev, snapshot) => {\n *   const name = snapshot(current.name, prev?.name);\n *   const age = current.age;\n *   if (prev && name === prev.name && age === prev.age) return prev;\n *   return { name, age };\n * });\n * ```\n */\nexport const registerCustomSnapshot = (ctor, snapshotFn) => {\n    // Use defineProperty so the handler is non-enumerable (it shouldn't show up\n    // in `Reflect.ownKeys` walks any more than necessary) and so re-registration\n    // overwrites cleanly even if a subclass has shadowed it.\n    Object.defineProperty(ctor.prototype, SNAPSHOT_HANDLER, {\n        value: snapshotFn,\n        writable: true,\n        configurable: true,\n        enumerable: false,\n    });\n};\n/**\n * Recursively snapshot a value with structural sharing.\n *\n * - Plain objects and arrays are deep-cloned; unchanged subtrees keep the same reference.\n * - ReactivePromise instances are read (establishing deps) and flattened to a plain object.\n * - Class instances are returned as-is unless a custom handler is registered\n *   for the class or any of its ancestors via `registerCustomSnapshot`.\n * - Primitives are returned directly.\n */\nexport function snapshot(currentValue, prevValue) {\n    if (currentValue === null || typeof currentValue !== 'object') {\n        return currentValue;\n    }\n    if (isReactivePromise(currentValue)) {\n        return snapshotReactivePromise(currentValue, prevValue, snapshot);\n    }\n    // Custom registrations check first: native prototype lookup walks the chain\n    // for us, so subclasses inherit their ancestor's handler with no extra work.\n    const customHandler = currentValue[SNAPSHOT_HANDLER];\n    if (customHandler !== undefined) {\n        return customHandler(currentValue, prevValue, snapshot);\n    }\n    // Built-in handlers are looked up by exact prototype only.\n    const builtIn = BUILTIN_PROTO_TO_SNAPSHOT.get(getProto(currentValue));\n    if (builtIn !== undefined) {\n        return builtIn(currentValue, prevValue, snapshot);\n    }\n    return currentValue;\n}\n"],"names":[],"mappings":";AAIO,MAAM,yBAAyB,oBAAI,QAAO;AAC1C,SAAS,2BAA2B,IAAI,MAAM;AACjD,MAAI,WAAW,uBAAuB,IAAI,EAAE;AAC5C,MAAI,CAAC,UAAU;AACX,UAAM,MAAM,yBAAyB,MAAM,IAAI,MAAM,MAAM,IAAI,MAAM,QAAQ,OAAO,MAAM,QAAmB;AAC7G,UAAM,WAAW,gBAAe;AAChC,UAAM,aAAa,IAAI,SAAS;AAC5B,YAAM,QAAQ,gBAAgB,QAAQ;AACtC,YAAM,SAAS,MAAM,IAAI,KAAK,IAAI;AAClC,aAAO,OAAO;AAAA,IAClB;AACA,eAAW,CAAC,YAAY,GAAG;AAC3B,2BAAuB,IAAI,IAAI,QAAQ;AAAA,EAC3C;AACA,SAAO;AACX;AACO,SAAS,SAAS,IAAI,MAAM;AAC/B,SAAO,2BAA2B,IAAI,IAAI,EAAE,CAAC;AACjD;AACY,MAAC,iBAAiB,CAAC,OAAO,IAAI,SAAS;AAC/C,QAAM,MAAM,yBAAyB,MAAM,IAAI,MAAM,MAAM,IAAI,MAAM,QAAQ,OAAO,MAAM,QAAmB;AAC7G,QAAM,aAAa,IAAI,SAAS;AAC5B,WAAO,cAAc,KAAK,EAAE,IAAI,KAAK,IAAI,EAAE;AAAA,EAC/C;AACA,yBAAuB,IAAI,YAAY,CAAC,YAAY,GAAG,CAAC;AACxD,SAAO;AACX;AACO,SAAS,MAAM,UAAU,MAAM;AAClC,QAAM,QAAQ,gBAAe;AAC7B,SAAO,YAAY,UAAU,OAAO,IAAI;AAC5C;AACY,MAAC,OAAO,CAAC,IAAI,SAAS;AAC9B,QAAM,QAAQ,gBAAe;AAC7B,SAAO,WAAW,IAAI,OAAO,IAAI;AACrC;AACO,SAAS,QAAQ,IAAI,MAAM;AAC9B,QAAM,MAAM,yBAAyB,MAAM,IAAI,MAAM,MAAM,IAAI,MAAM,QAAQ,OAAO,QAAW,MAAM,MAAM;AAC3G,QAAM,QAAQ,MAAM,UAAU,IAAI,YAAY,CAAA,CAAE,IAAI,gBAAe;AACnE,SAAO,qBAAqB,KAAK,QAAW,QAAW,KAAK;AAChE;AASY,MAAC,iBAAiB,CAAC,SAAS,SAAS;AAC7C,QAAM,MAAM,yBAAyB,MAAM,IAAI,MAAM,MAAM,SAAS,MAAM,QAAQ,OAAO,MAAoB;AAC7G,QAAM,QAAQ,MAAM,UAAU,IAAI,YAAY,CAAA,CAAE,IAAI,gBAAe;AACnE,SAAO,qBAAqB,KAAK,QAAW,QAAW,KAAK;AAChE;ACvDA,MAAM,WAAW,OAAO;AACxB,SAAS,cAAc,SAAS,MAAM,MAAM;AACxC,QAAM,UAAU,MAAM,QAAQ,IAAI,IAAI,OAAO;AAC7C,MAAI,UAAU,CAAC,WAAW,QAAQ,WAAW,QAAQ;AACrD,QAAM,SAAS,IAAI,MAAM,QAAQ,MAAM;AACvC,WAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACrC,WAAO,CAAC,IAAI,KAAK,QAAQ,CAAC,GAAG,UAAU,CAAC,CAAC;AACzC,QAAI,CAAC,WAAW,OAAO,CAAC,MAAM,QAAQ,CAAC,GAAG;AACtC,gBAAU;AAAA,IACd;AAAA,EACJ;AACA,SAAO,UAAU,SAAS;AAC9B;AACA,SAAS,oBAAoB,SAAS,MAAM,MAAM;AAC9C,QAAM,UAAU,SAAS,QAAQ,SAAS,UAAa,OAAO,SAAS,YAAY,CAAC,MAAM,QAAQ,IAAI,IAChG,OACA;AACN,QAAM,OAAO,OAAO,KAAK,OAAO;AAChC,MAAI,UAAU,CAAC,WAAW,OAAO,KAAK,OAAO,EAAE,WAAW,KAAK;AAC/D,QAAM,SAAS,CAAA;AACf,WAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AAClC,UAAM,MAAM,KAAK,CAAC;AAClB,WAAO,GAAG,IAAI,KAAK,QAAQ,GAAG,GAAG,UAAU,GAAG,CAAC;AAC/C,QAAI,CAAC,WAAW,OAAO,GAAG,MAAM,QAAQ,GAAG,GAAG;AAC1C,gBAAU;AAAA,IACd;AAAA,EACJ;AACA,SAAO,UAAU,SAAS;AAC9B;AACA,SAAS,wBAAwB,SAAS,MAAM,MAAM;AAClD,QAAM,UAAU,SAAS,QAAQ,SAAS,UAAa,OAAO,SAAS,WAAW,OAAO;AACzF,QAAM,QAAQ,KAAK,QAAQ,OAAO,SAAS,KAAK;AAChD,QAAM,QAAQ,QAAQ;AACtB,QAAM,YAAY,QAAQ;AAC1B,QAAM,aAAa,QAAQ;AAC3B,QAAM,aAAa,QAAQ;AAC3B,QAAM,UAAU,QAAQ;AACxB,QAAM,YAAY,QAAQ;AAC1B,MAAI,WACA,UAAU,QAAQ,SAClB,UAAU,QAAQ,SAClB,cAAc,QAAQ,aACtB,eAAe,QAAQ,cACvB,eAAe,QAAQ,cACvB,YAAY,QAAQ,WACpB,cAAc,QAAQ,WAAW;AACjC,WAAO;AAAA,EACX;AACA,SAAO,EAAE,OAAO,OAAO,WAAW,YAAY,YAAY,SAAS,UAAS;AAChF;AACA,SAAS,YAAY,SAAS,MAAM,MAAM;AACtC,QAAM,UAAU,gBAAgB,MAAM,OAAO;AAC7C,MAAI,UAAU,CAAC,WAAW,QAAQ,SAAS,QAAQ;AACnD,QAAM,SAAS,oBAAI,IAAG;AACtB,aAAW,CAAC,KAAK,GAAG,KAAK,SAAS;AAC9B,UAAM,UAAU,KAAK,KAAK,SAAS,IAAI,GAAG,CAAC;AAC3C,WAAO,IAAI,KAAK,OAAO;AACvB,QAAI,CAAC,WAAW,YAAY,QAAQ,IAAI,GAAG,GAAG;AAC1C,gBAAU;AAAA,IACd;AAAA,EACJ;AACA,SAAO,UAAU,SAAS;AAC9B;AACA,SAAS,YAAY,SAAS,MAAM,OAAO;AACvC,QAAM,UAAU,gBAAgB,MAAM,OAAO;AAC7C,MAAI,UAAU,CAAC,WAAW,QAAQ,SAAS,QAAQ;AACnD,QAAM,SAAS,oBAAI,IAAG;AACtB,aAAW,OAAO,SAAS;AACvB,UAAM,UAAU,SAAS,KAAK,SAAS,IAAI,GAAG,IAAI,MAAM,MAAS;AACjE,WAAO,IAAI,OAAO;AAClB,QAAI,CAAC,WAAW,CAAC,QAAQ,IAAI,OAAO,GAAG;AACnC,gBAAU;AAAA,IACd;AAAA,EACJ;AACA,SAAO,UAAU,SAAS;AAC9B;AAWA,MAAM,4BAA4B,oBAAI,IAAI;AAAA,EACtC,CAAC,OAAO,WAAW,mBAAmB;AAAA,EACtC,CAAC,MAAM,WAAW,aAAa;AAAA,EAC/B,CAAC,IAAI,WAAW,WAAW;AAAA,EAC3B,CAAC,IAAI,WAAW,WAAW;AAAA,EAC3B,CAAC,MAAM,mBAAmB;AAC9B,CAAC;AASD,MAAM,mBAAmB,uBAAO,4BAA4B;AAsBhD,MAAC,yBAAyB,CAAC,MAAM,eAAe;AAIxD,SAAO,eAAe,KAAK,WAAW,kBAAkB;AAAA,IACpD,OAAO;AAAA,IACP,UAAU;AAAA,IACV,cAAc;AAAA,IACd,YAAY;AAAA,EACpB,CAAK;AACL;AAUO,SAAS,SAAS,cAAc,WAAW;AAC9C,MAAI,iBAAiB,QAAQ,OAAO,iBAAiB,UAAU;AAC3D,WAAO;AAAA,EACX;AACA,MAAI,kBAAkB,YAAY,GAAG;AACjC,WAAO,wBAAwB,cAAc,WAAW,QAAQ;AAAA,EACpE;AAGA,QAAM,gBAAgB,aAAa,gBAAgB;AACnD,MAAI,kBAAkB,QAAW;AAC7B,WAAO,cAAc,cAAc,WAAW,QAAQ;AAAA,EAC1D;AAEA,QAAM,UAAU,0BAA0B,IAAI,SAAS,YAAY,CAAC;AACpE,MAAI,YAAY,QAAW;AACvB,WAAO,QAAQ,cAAc,WAAW,QAAQ;AAAA,EACpD;AACA,SAAO;AACX;"}