signalium 3.0.2 → 4.0.0

package/dist/esm/internals/utils/hash.d.ts

@@ -1,3 +1,10 @@
+/** One MurmurHash3 block round: mixes the 32-bit block `k` into `h`. */
+export declare function mixHash(h: number, k: number): number;
+/** MurmurHash3 finalization over `length` blocks. */
+export declare function finalizeHash(h: number, length: number): number;
+/** `hashObject` over keys the caller already has; `obj` must be on `seen`. */
+export declare function hashObjectKeys(obj: object, keys: string[], seen: unknown[]): number;
+export declare const ARRAY_SEED: number;
 export declare const registerCustomHash: <T>(ctor: new (...args: any[]) => T, hashFn: (obj: T) => number) => void;
 export declare function hashValue(node: unknown, seen?: unknown[]): number;
 export declare function getObjectHash(obj: object): number;

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

@@ -1 +1 @@
-{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../../../src/internals/utils/hash.ts"],"names":[],"mappings":"AAyLA,eAAO,MAAM,kBAAkB,GAAI,CAAC,QAAQ,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC,KAAK,MAAM,SAEhG,CAAC;AAEF,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,GAAE,OAAO,EAAO,UAsC5D;AAKD,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAOjD;AAKD,wBAAgB,cAAc,CAAC,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,UAW3D"}
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../../../src/internals/utils/hash.ts"],"names":[],"mappings":"AA+EA,wEAAwE;AACxE,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,UAc3C;AAED,qDAAqD;AACrD,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,UAYrD;AAgBD,8EAA8E;AAC9E,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,UAS1E;AAqDD,eAAO,MAAM,UAAU,QAAmC,CAAC;AAgB3D,eAAO,MAAM,kBAAkB,GAAI,CAAC,QAAQ,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC,KAAK,MAAM,SAEhG,CAAC;AAEF,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,GAAE,OAAO,EAAO,UAsC5D;AAKD,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAOjD;AAKD,wBAAgB,cAAc,CAAC,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,UAW3D"}

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

@@ -1,4 +1,6 @@
 export type SnapshotFn = (current: unknown, prev: unknown) => unknown;
+export declare function snapshotArray(current: unknown[], prev: unknown, snap: SnapshotFn): unknown[];
+export declare function snapshotPlainObject(current: Record<string, unknown>, prev: unknown, snap: SnapshotFn): Record<string, unknown>;
 /**
  * Register a custom snapshot function for instances of a class.
  * The function receives the current value, the previous snapshot (or undefined),

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;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"}
+{"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;AAMtE,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,EAAE,CAa5F;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,UAAU,GACf,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAmBzB;AAsGD;;;;;;;;;;;;;;;;;;;;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/internals/watch.d.ts

@@ -1,6 +1,7 @@
 import { ReactiveSignal } from './reactive.js';
+import type { DeactivateOptions } from '../types.js';
 export declare function watchSignal(signal: ReactiveSignal<any, any>): void;
-export declare function unwatchSignal(signal: ReactiveSignal<any, any>): void;
+export declare function unwatchSignal(signal: ReactiveSignal<any, any>, options?: DeactivateOptions): void;
 export declare function activateSignal(signal: ReactiveSignal<any, any>): void;
-export declare function deactivateSignal(signal: ReactiveSignal<any, any>): void;
+export declare function deactivateSignal(signal: ReactiveSignal<any, any>, options?: DeactivateOptions): void;
 //# sourceMappingURL=watch.d.ts.map

package/dist/esm/internals/watch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../../../src/internals/watch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAW,MAAM,eAAe,CAAC;AAIxD,wBAAgB,WAAW,CAAC,MAAM,EAAE,cAAc,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,IAAI,CAelE;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,cAAc,CAAC,GAAG,EAAE,GAAG,CAAC,QAS7D;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,cAAc,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,IAAI,CAQrE;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,cAAc,CAAC,GAAG,EAAE,GAAG,CAAC,QAehE"}
+{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../../../src/internals/watch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAW,MAAM,eAAe,CAAC;AACxD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAIrD,wBAAgB,WAAW,CAAC,MAAM,EAAE,cAAc,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,IAAI,CAelE;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,cAAc,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,OAAO,GAAE,iBAAsB,QAS9F;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,cAAc,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,IAAI,CAQrE;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,cAAc,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,OAAO,GAAE,iBAAsB,QAejG"}

package/dist/esm/production/{component-shared-Dva0S5e3.js → component-shared-CycOXiis.js}

@@ -1,4 +1,4 @@
-import { g as getCurrentScope, c as createReactiveSignal, a as generatorResultToPromiseWithConsumer, b as setCurrentConsumer, d as getCurrentConsumer } from "./contexts-FxCndlvf.js";
+import { a as getCurrentScope, c as createReactiveSignal, b as generatorResultToPromiseWithConsumer, d as setCurrentConsumer, e as getCurrentConsumer } from "./contexts-ry5lvNSx.js";
 function isGeneratorFunction(fn) {
   return typeof fn === "function" && fn.constructor?.name === "GeneratorFunction";
 }
@@ -31,4 +31,4 @@ export {
   createServerAsyncComponentWrapper as c,
   isAsyncFunctionWithoutTransform as i
 };
-//# sourceMappingURL=component-shared-Dva0S5e3.js.map
+//# sourceMappingURL=component-shared-CycOXiis.js.map

package/dist/esm/production/{component-shared-Dva0S5e3.js.map → component-shared-CycOXiis.js.map}

@@ -1 +1 @@
-{"version":3,"file":"component-shared-Dva0S5e3.js","sources":["../../../.tsc-out/react/component-shared.js"],"sourcesContent":["import { getCurrentConsumer, setCurrentConsumer } from '../internals/consumer.js';\nimport { getCurrentScope } from '../internals/contexts.js';\nimport { createReactiveSignal } from '../internals/reactive.js';\nimport { generatorResultToPromiseWithConsumer } from '../internals/generators.js';\nexport function isGeneratorFunction(fn) {\n    return (typeof fn === 'function' && fn.constructor?.name === 'GeneratorFunction');\n}\nexport function isAsyncFunctionWithoutTransform(fn) {\n    return typeof fn === 'function' && fn.constructor?.name === 'AsyncFunction';\n}\n/**\n * Wrap a Babel-transformed async generator in a real `async function` that drives it\n * with {@link generatorResultToPromiseWithConsumer}. Used on the server (RSC + SSR)\n * where hooks-based Suspense replay is not appropriate.\n */\nexport function createServerAsyncComponentWrapper(fn) {\n    return async function (props) {\n        const scope = getCurrentScope();\n        const owned = createReactiveSignal({ compute: () => null, equals: () => true, isRelay: false, tracer: undefined }, [], undefined, scope);\n        return generatorResultToPromiseWithConsumer(fn(props), owned);\n    };\n}\n/**\n * Wrap a sync render function with consumer/scope tracking. Used by the server\n * `component()` for non-generator definitions.\n */\nexport function createServerSyncComponentWrapper(fn) {\n    return function (props) {\n        const scope = getCurrentScope();\n        const owned = createReactiveSignal({ compute: () => null, equals: () => true, isRelay: false, tracer: undefined }, [], undefined, scope);\n        const prevConsumer = getCurrentConsumer();\n        try {\n            setCurrentConsumer(owned);\n            return fn(props);\n        }\n        finally {\n            setCurrentConsumer(prevConsumer);\n        }\n    };\n}\n"],"names":[],"mappings":";AAIO,SAAS,oBAAoB,IAAI;AACpC,SAAQ,OAAO,OAAO,cAAc,GAAG,aAAa,SAAS;AACjE;AACO,SAAS,gCAAgC,IAAI;AAChD,SAAO,OAAO,OAAO,cAAc,GAAG,aAAa,SAAS;AAChE;AAMO,SAAS,kCAAkC,IAAI;AAClD,SAAO,eAAgB,OAAO;AAC1B,UAAM,QAAQ,gBAAe;AAC7B,UAAM,QAAQ,qBAAqB,EAAE,SAAS,MAAM,MAAM,QAAQ,MAAM,MAAM,SAAS,OAAO,QAAQ,OAAS,GAAI,CAAA,GAAI,QAAW,KAAK;AACvI,WAAO,qCAAqC,GAAG,KAAK,GAAG,KAAK;AAAA,EAChE;AACJ;AAKO,SAAS,iCAAiC,IAAI;AACjD,SAAO,SAAU,OAAO;AACpB,UAAM,QAAQ,gBAAe;AAC7B,UAAM,QAAQ,qBAAqB,EAAE,SAAS,MAAM,MAAM,QAAQ,MAAM,MAAM,SAAS,OAAO,QAAQ,OAAS,GAAI,CAAA,GAAI,QAAW,KAAK;AACvI,UAAM,eAAe,mBAAkB;AACvC,QAAI;AACA,yBAAmB,KAAK;AACxB,aAAO,GAAG,KAAK;AAAA,IACnB,UACR;AACY,yBAAmB,YAAY;AAAA,IACnC;AAAA,EACJ;AACJ;"}
+{"version":3,"file":"component-shared-CycOXiis.js","sources":["../../../.tsc-out/react/component-shared.js"],"sourcesContent":["import { getCurrentConsumer, setCurrentConsumer } from '../internals/consumer.js';\nimport { getCurrentScope } from '../internals/contexts.js';\nimport { createReactiveSignal } from '../internals/reactive.js';\nimport { generatorResultToPromiseWithConsumer } from '../internals/generators.js';\nexport function isGeneratorFunction(fn) {\n    return (typeof fn === 'function' && fn.constructor?.name === 'GeneratorFunction');\n}\nexport function isAsyncFunctionWithoutTransform(fn) {\n    return typeof fn === 'function' && fn.constructor?.name === 'AsyncFunction';\n}\n/**\n * Wrap a Babel-transformed async generator in a real `async function` that drives it\n * with {@link generatorResultToPromiseWithConsumer}. Used on the server (RSC + SSR)\n * where hooks-based Suspense replay is not appropriate.\n */\nexport function createServerAsyncComponentWrapper(fn) {\n    return async function (props) {\n        const scope = getCurrentScope();\n        const owned = createReactiveSignal({ compute: () => null, equals: () => true, isRelay: false, tracer: undefined }, [], undefined, scope);\n        return generatorResultToPromiseWithConsumer(fn(props), owned);\n    };\n}\n/**\n * Wrap a sync render function with consumer/scope tracking. Used by the server\n * `component()` for non-generator definitions.\n */\nexport function createServerSyncComponentWrapper(fn) {\n    return function (props) {\n        const scope = getCurrentScope();\n        const owned = createReactiveSignal({ compute: () => null, equals: () => true, isRelay: false, tracer: undefined }, [], undefined, scope);\n        const prevConsumer = getCurrentConsumer();\n        try {\n            setCurrentConsumer(owned);\n            return fn(props);\n        }\n        finally {\n            setCurrentConsumer(prevConsumer);\n        }\n    };\n}\n"],"names":[],"mappings":";AAIO,SAAS,oBAAoB,IAAI;AACpC,SAAQ,OAAO,OAAO,cAAc,GAAG,aAAa,SAAS;AACjE;AACO,SAAS,gCAAgC,IAAI;AAChD,SAAO,OAAO,OAAO,cAAc,GAAG,aAAa,SAAS;AAChE;AAMO,SAAS,kCAAkC,IAAI;AAClD,SAAO,eAAgB,OAAO;AAC1B,UAAM,QAAQ,gBAAe;AAC7B,UAAM,QAAQ,qBAAqB,EAAE,SAAS,MAAM,MAAM,QAAQ,MAAM,MAAM,SAAS,OAAO,QAAQ,OAAS,GAAI,CAAA,GAAI,QAAW,KAAK;AACvI,WAAO,qCAAqC,GAAG,KAAK,GAAG,KAAK;AAAA,EAChE;AACJ;AAKO,SAAS,iCAAiC,IAAI;AACjD,SAAO,SAAU,OAAO;AACpB,UAAM,QAAQ,gBAAe;AAC7B,UAAM,QAAQ,qBAAqB,EAAE,SAAS,MAAM,MAAM,QAAQ,MAAM,MAAM,SAAS,OAAO,QAAQ,OAAS,GAAI,CAAA,GAAI,QAAW,KAAK;AACvI,UAAM,eAAe,mBAAkB;AACvC,QAAI;AACA,yBAAmB,KAAK;AACxB,aAAO,GAAG,KAAK;AAAA,IACnB,UACR;AACY,yBAAmB,YAAY;AAAA,IACnC;AAAA,EACJ;AACJ;"}

package/dist/esm/production/config-BhtwQYAN.js

@@ -0,0 +1,53 @@
+let _scheduleFlush = (flushWatchers) => {
+  setTimeout(() => {
+    flushWatchers();
+  }, 0);
+};
+let _runBatch = (fn) => fn();
+const DEFAULT_RENDER_LEASE_TTL = 1e4;
+let _renderLeaseTtl = DEFAULT_RENDER_LEASE_TTL;
+const MAX_TIMEOUT = 2 ** 31 - 1;
+function validateRenderLeaseTtl(ttl) {
+  if (typeof ttl !== "number" || Number.isNaN(ttl) || ttl <= 0) {
+    return _renderLeaseTtl;
+  }
+  if (ttl > MAX_TIMEOUT) {
+    return MAX_TIMEOUT;
+  }
+  return ttl;
+}
+let _reactDelivery = "sync";
+const resolvedPromise = Promise.resolve();
+let _scheduleReactDelivery = (fn) => {
+  resolvedPromise.then(fn);
+};
+function setConfig(cfg) {
+  _scheduleFlush = cfg.scheduleFlush ?? _scheduleFlush;
+  _runBatch = cfg.runBatch ?? _runBatch;
+  if (cfg.renderLeaseTtl !== void 0) {
+    _renderLeaseTtl = validateRenderLeaseTtl(cfg.renderLeaseTtl);
+  }
+  _reactDelivery = cfg.reactDelivery ?? _reactDelivery;
+  _scheduleReactDelivery = cfg.scheduleReactDelivery ?? _scheduleReactDelivery;
+}
+const scheduleFlush = (fn) => {
+  _scheduleFlush(fn);
+};
+const runBatch = (fn) => {
+  _runBatch(fn);
+};
+const getRenderLeaseTtl = () => _renderLeaseTtl;
+const getReactDelivery = () => _reactDelivery;
+const scheduleReactDelivery = (fn) => {
+  _scheduleReactDelivery(fn);
+};
+export {
+  MAX_TIMEOUT as M,
+  scheduleFlush as a,
+  getRenderLeaseTtl as b,
+  setConfig as c,
+  getReactDelivery as g,
+  runBatch as r,
+  scheduleReactDelivery as s
+};
+//# sourceMappingURL=config-BhtwQYAN.js.map

package/dist/esm/production/config-BhtwQYAN.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-BhtwQYAN.js","sources":["../../../.tsc-out/internals/config.js"],"sourcesContent":["let _scheduleFlush = flushWatchers => {\n    setTimeout(() => {\n        flushWatchers();\n    }, 0);\n};\nlet _runBatch = fn => fn();\n/** Default render lease TTL (ms). It must outlive a transition render, which React caps at 5 s. */\nexport const DEFAULT_RENDER_LEASE_TTL = 10_000;\nlet _renderLeaseTtl = DEFAULT_RENDER_LEASE_TTL;\n/** The longest `setTimeout` delay (2^31 - 1 ms); longer ones fire immediately. */\nexport const MAX_TIMEOUT = 2 ** 31 - 1;\nfunction validateRenderLeaseTtl(ttl) {\n    if (typeof ttl !== 'number' || Number.isNaN(ttl) || ttl <= 0) {\n        if (IS_DEV) {\n            console.warn(`signalium: setConfig({ renderLeaseTtl: ${String(ttl)} }) ignored; it must be a positive number of milliseconds.`);\n        }\n        return _renderLeaseTtl;\n    }\n    if (ttl > MAX_TIMEOUT) {\n        if (IS_DEV) {\n            console.warn(`signalium: setConfig({ renderLeaseTtl: ${String(ttl)} }) clamped to ${MAX_TIMEOUT} ms, the longest timer delay.`);\n        }\n        return MAX_TIMEOUT;\n    }\n    return ttl;\n}\nlet _reactDelivery = 'sync';\nconst resolvedPromise = Promise.resolve();\nlet _scheduleReactDelivery = fn => {\n    resolvedPromise.then(fn);\n};\nexport function setConfig(cfg) {\n    _scheduleFlush = cfg.scheduleFlush ?? _scheduleFlush;\n    _runBatch = cfg.runBatch ?? _runBatch;\n    if (cfg.renderLeaseTtl !== undefined) {\n        _renderLeaseTtl = validateRenderLeaseTtl(cfg.renderLeaseTtl);\n    }\n    _reactDelivery = cfg.reactDelivery ?? _reactDelivery;\n    _scheduleReactDelivery = cfg.scheduleReactDelivery ?? _scheduleReactDelivery;\n}\nexport const scheduleFlush = (fn) => {\n    _scheduleFlush(fn);\n};\nexport const runBatch = (fn) => {\n    _runBatch(fn);\n};\nexport const getRenderLeaseTtl = () => _renderLeaseTtl;\nexport const getReactDelivery = () => _reactDelivery;\nexport const scheduleReactDelivery = (fn) => {\n    _scheduleReactDelivery(fn);\n};\n"],"names":[],"mappings":"AAAA,IAAI,iBAAiB,CAAA,kBAAiB;AAClC,aAAW,MAAM;AACb,kBAAA;AAAA,EACJ,GAAG,CAAC;AACR;AACA,IAAI,YAAY,QAAM,GAAA;AAEf,MAAM,2BAA2B;AACxC,IAAI,kBAAkB;AAEf,MAAM,cAAc,KAAK,KAAK;AACrC,SAAS,uBAAuB,KAAK;AACjC,MAAI,OAAO,QAAQ,YAAY,OAAO,MAAM,GAAG,KAAK,OAAO,GAAG;AAI1D,WAAO;AAAA,EACX;AACA,MAAI,MAAM,aAAa;AAInB,WAAO;AAAA,EACX;AACA,SAAO;AACX;AACA,IAAI,iBAAiB;AACrB,MAAM,kBAAkB,QAAQ,QAAA;AAChC,IAAI,yBAAyB,CAAA,OAAM;AAC/B,kBAAgB,KAAK,EAAE;AAC3B;AACO,SAAS,UAAU,KAAK;AAC3B,mBAAiB,IAAI,iBAAiB;AACtC,cAAY,IAAI,YAAY;AAC5B,MAAI,IAAI,mBAAmB,QAAW;AAClC,sBAAkB,uBAAuB,IAAI,cAAc;AAAA,EAC/D;AACA,mBAAiB,IAAI,iBAAiB;AACtC,2BAAyB,IAAI,yBAAyB;AAC1D;AACO,MAAM,gBAAgB,CAAC,OAAO;AACjC,iBAAe,EAAE;AACrB;AACO,MAAM,WAAW,CAAC,OAAO;AAC5B,YAAU,EAAE;AAChB;AACO,MAAM,oBAAoB,MAAM;AAChC,MAAM,mBAAmB,MAAM;AAC/B,MAAM,wBAAwB,CAAC,OAAO;AACzC,yBAAuB,EAAE;AAC7B;"}

package/dist/esm/production/config.js

@@ -1,5 +1,5 @@
-import { a } from "./config-CPQL7hX-.js";
+import { c } from "./config-BhtwQYAN.js";
 export {
-  a as setConfig
+  c as setConfig
 };
 //# sourceMappingURL=config.js.map

package/dist/esm/production/{contexts-FxCndlvf.js → contexts-ry5lvNSx.js}

@@ -1,4 +1,4 @@
-import { s as scheduleFlush$1, r as runBatch } from "./config-CPQL7hX-.js";
+import { a as scheduleFlush$1, r as runBatch, b as getRenderLeaseTtl, M as MAX_TIMEOUT } from "./config-BhtwQYAN.js";
 let CURRENT_CONSUMER;
 const setCurrentConsumer = (consumer) => {
   CURRENT_CONSUMER = consumer;
@@ -99,12 +99,12 @@ function watchSignal(signal2) {
   }
   activateSignal(signal2);
 }
-function unwatchSignal(signal2) {
+function unwatchSignal(signal2, options = {}) {
   const { watchCount } = signal2;
   const newWatchCount = Math.max(watchCount - 1, 0);
   signal2.watchCount = newWatchCount;
   if (newWatchCount === 0) {
-    scheduleDeactivate(signal2);
+    scheduleDeactivate(signal2, options);
   }
 }
 function activateSignal(signal2) {
@@ -114,22 +114,22 @@ function activateSignal(signal2) {
     checkSignal(signal2);
   }
 }
-function deactivateSignal(signal2) {
+function deactivateSignal(signal2, options = {}) {
   signal2._isActive = false;
   for (const dep of signal2.deps.keys()) {
     const newWatchCount = Math.max(dep.watchCount - 1, 0);
     dep.watchCount = newWatchCount;
     if (newWatchCount === 0) {
-      deactivateSignal(dep);
+      deactivateSignal(dep, options);
     }
   }
   if (isRelay(signal2)) {
-    signal2._value?.();
+    signal2._value?.(options);
   }
 }
 let PENDING_PULLS = /* @__PURE__ */ new Set();
 let PENDING_ASYNC_PULLS = [];
-let PENDING_DEACTIVE = /* @__PURE__ */ new Set();
+let PENDING_DEACTIVE = /* @__PURE__ */ new Map();
 let PENDING_LISTENERS = [];
 const microtask = () => Promise.resolve();
 let currentFlush = null;
@@ -152,8 +152,9 @@ const scheduleAsyncPull = (signal2) => {
   PENDING_ASYNC_PULLS.push(signal2);
   scheduleFlush();
 };
-const scheduleDeactivate = (signal2) => {
-  PENDING_DEACTIVE.add(signal2);
+const scheduleDeactivate = (signal2, options = {}) => {
+  const existing = PENDING_DEACTIVE.get(signal2);
+  PENDING_DEACTIVE.set(signal2, existing === void 0 ? options : { isPausing: Boolean(existing.isPausing && options.isPausing) });
   scheduleFlush();
 };
 const cancelDeactivate = (signal2) => {
@@ -184,8 +185,8 @@ const flushWatchers = async () => {
   }
   currentFlush = null;
   runBatch(() => {
-    for (const signal2 of PENDING_DEACTIVE) {
-      deactivateSignal(signal2);
+    for (const [signal2, options] of PENDING_DEACTIVE) {
+      deactivateSignal(signal2, options);
     }
     PENDING_DEACTIVE.clear();
     for (const signal2 of PENDING_LISTENERS) {
@@ -927,11 +928,11 @@ function createRelay(activate, scope, opts) {
   const p = new ReactivePromiseImpl();
   let active = false;
   let currentSub;
-  const unsubscribe = () => {
+  const unsubscribe = (options) => {
     if (typeof currentSub === "function") {
       currentSub();
     } else if (currentSub !== void 0) {
-      currentSub.deactivate?.();
+      currentSub.deactivate?.(options);
     }
     const signal2 = p["_signal"];
     signal2.subs = /* @__PURE__ */ new Map();
@@ -1203,32 +1204,43 @@ function hashNumber(num, seed = 0) {
   h ^= h >>> 16;
   return h >>> 0;
 }
-function hashArray(arr, seen) {
-  let h = ARRAY;
+function mixHash(h, k) {
   const c1 = 3432918353;
   const c2 = 461845907;
-  for (const item of arr) {
-    let k = hashValue(item, seen);
-    k = imul(k, c1);
-    k = k << 15 | k >>> 17;
-    k = imul(k, c2);
-    h ^= k;
-    h = h << 13 | h >>> 19;
-    h = imul(h, 5) + 3864292196;
-  }
-  h ^= arr.length;
+  const n = 3864292196;
+  k = imul(k, c1);
+  k = k << 15 | k >>> 17;
+  k = imul(k, c2);
+  h ^= k;
+  h = h << 13 | h >>> 19;
+  return imul(h, 5) + n | 0;
+}
+function finalizeHash(h, length) {
+  const fmix1 = 2246822507;
+  const fmix2 = 3266489909;
+  h ^= length;
   h ^= h >>> 16;
-  h = imul(h, 2246822507);
+  h = imul(h, fmix1);
   h ^= h >>> 13;
-  h = imul(h, 3266489909);
+  h = imul(h, fmix2);
   h ^= h >>> 16;
   return h >>> 0;
 }
+function hashArray(arr, seen) {
+  let h = ARRAY_SEED;
+  for (const item of arr) {
+    h = mixHash(h, hashValue(item, seen));
+  }
+  return finalizeHash(h, arr.length);
+}
 function hashObject(obj, seen) {
+  return hashObjectKeys(obj, Object.keys(obj), seen);
+}
+function hashObjectKeys(obj, keys, seen) {
+  const keyMultiplier = 2654435769;
   let sum = OBJECT;
-  const keys = Object.keys(obj);
   for (const key of keys) {
-    sum += imul(hashValue(key, seen), 2654435769) ^ hashValue(obj[key], seen);
+    sum += imul(hashValue(key, seen), keyMultiplier) ^ hashValue(obj[key], seen);
   }
   return sum >>> 0;
 }
@@ -1240,9 +1252,10 @@ function hashSet(set, seen) {
   return sum >>> 0;
 }
 function hashMap(map, seen) {
+  const keyMultiplier = 2654435769;
   let sum = MAP;
   for (const [key, value] of map) {
-    sum += imul(hashValue(key, seen), 2654435769) ^ hashValue(value, seen);
+    sum += imul(hashValue(key, seen), keyMultiplier) ^ hashValue(value, seen);
   }
   return sum >>> 0;
 }
@@ -1281,7 +1294,7 @@ const FALSE = hashStr(
   3
   /* HashType.FALSE */
 );
-const ARRAY = hashStr(
+const ARRAY_SEED = hashStr(
   "array",
   7
   /* HashType.ARRAY */
@@ -1393,6 +1406,95 @@ function hashReactiveFn(fn, args) {
   h = h << 13 | h >>> 19;
   return imul(h, 5) + 3864292196 >>> 0;
 }
+let young = /* @__PURE__ */ new Set();
+let old = /* @__PURE__ */ new Set();
+let timer;
+const pinned = /* @__PURE__ */ new Map();
+const SUSPENDED_LEASE_HOLD_TTLS = 30;
+function armTimer() {
+  timer = setTimeout(sweepLeases, getRenderLeaseTtl());
+  timer.unref?.();
+}
+function sweepLeases() {
+  timer = void 0;
+  const expired = old;
+  for (const signal2 of expired) {
+    signal2._releaseLease();
+  }
+  expired.clear();
+  old = young;
+  young = expired;
+  if (old.size > 0) {
+    armTimer();
+  }
+}
+function addLease(signal2) {
+  if (!pinned.delete(signal2)) {
+    old.delete(signal2);
+  }
+  young.add(signal2);
+  if (timer === void 0) {
+    armTimer();
+  }
+}
+function removeLease(signal2) {
+  if (!young.delete(signal2) && !old.delete(signal2)) {
+    pinned.delete(signal2);
+  }
+}
+function pinLease(signal2) {
+  if (!signal2._isLeased) {
+    return void 0;
+  }
+  young.delete(signal2);
+  old.delete(signal2);
+  const token = {};
+  pinned.set(signal2, token);
+  return token;
+}
+function unpinLease(signal2, token) {
+  if (pinned.get(signal2) === token && signal2._isLeased) {
+    addLease(signal2);
+  }
+}
+function holdLeaseUntilSettled(signal2, thenable) {
+  const token = pinLease(signal2);
+  if (token === void 0) {
+    return;
+  }
+  const renew = () => unpinLease(signal2, token);
+  thenable.then(renew, renew);
+}
+function holdSuspendedLease(signal2) {
+  const token = pinLease(signal2);
+  if (token === void 0) {
+    return;
+  }
+  const hold = setTimeout(() => unpinLease(signal2, token), Math.min(getRenderLeaseTtl() * SUSPENDED_LEASE_HOLD_TTLS, MAX_TIMEOUT));
+  hold.unref?.();
+}
+function releaseAbandonedAttempt(signal2) {
+  const token = pinned.get(signal2);
+  if (token !== void 0) {
+    unpinLease(signal2, token);
+  }
+}
+function releaseRenderLeases() {
+  if (timer !== void 0) {
+    clearTimeout(timer);
+    timer = void 0;
+  }
+  const leases = [...old, ...young, ...pinned.keys()];
+  old = /* @__PURE__ */ new Set();
+  young = /* @__PURE__ */ new Set();
+  pinned.clear();
+  for (const signal2 of leases) {
+    signal2._releaseLease();
+  }
+}
+function getRenderLeaseCount() {
+  return young.size + old.size + pinned.size;
+}
 let ID = 0;
 function createReactiveDefinition(id, desc, compute, equals, isRelay2, paramKey, tracer) {
   const def = {
@@ -1452,6 +1554,9 @@ class ReactiveSignal {
       this.flags &= -33;
     }
   }
+  get _isLeased() {
+    return (this.flags & 128) !== 0;
+  }
   get _isLazy() {
     return (this.flags & 64) !== 0;
   }
@@ -1466,6 +1571,7 @@ class ReactiveSignal {
     return this._listeners ?? (this._listeners = {
       updatedAt: 0,
       current: /* @__PURE__ */ new Map(),
+      pausedReaders: 0,
       cachedBoundAdd: this.addListener.bind(this)
     });
   }
@@ -1473,7 +1579,8 @@ class ReactiveSignal {
     return getSignal(this);
   }
   addListener(listener, opts) {
-    const { current } = this.listeners;
+    const meta = this.listeners;
+    const { current } = meta;
     if (!current.has(listener)) {
       let effective = listener;
       if (opts?.skipInitial) {
@@ -1486,23 +1593,39 @@ class ReactiveSignal {
           listener();
         };
       }
-      if (!this._isListener) {
-        watchSignal(this);
-        this.flags |= 16;
+      const flags = this.flags;
+      current.set(listener, effective);
+      const unpaused = meta.pausedReaders < current.size;
+      if ((flags & 16) === 0) {
+        this.flags = flags | 16;
+      } else if ((flags & 128) !== 0 && (unpaused || (flags & 256) === 0)) {
+        this.flags = flags & -129;
+        removeLease(this);
+      }
+      if (unpaused) {
+        this._takeListenerWatch();
+      } else {
+        this._pauseListenerWatch();
       }
       if (this.watchCount > 0) {
         schedulePull(this);
       }
-      current.set(listener, effective);
     }
     return () => {
       if (current.has(listener)) {
         current.delete(listener);
         if (current.size === 0) {
+          const flags = this.flags;
+          if ((flags & 128) !== 0)
+            return;
           cancelPull(this);
-          unwatchSignal(this);
-          this.flags &= -17;
-          this.listeners.updatedAt = 0;
+          this.flags = flags & -273;
+          if ((flags & 256) !== 0) {
+            unwatchSignal(this);
+          }
+          meta.updatedAt = 0;
+        } else if (meta.pausedReaders >= current.size) {
+          this._pauseListenerWatch();
         }
       }
     };
@@ -1510,15 +1633,99 @@ class ReactiveSignal {
   // This method is used in React hooks specifically. It returns a bound add method
   // that is cached to avoid creating a new one on each call, and it eagerly sets
   // the listener as watched so that relays that are accessed will be activated.
+  //
+  // The eager watch is a lease (see `lease.ts`): the commit's subscription claims it, and a
+  // discarded render's lease expires. Each render of a still-leased signal extends it.
   addListenerLazy(watch = true) {
-    if (!this._isListener) {
+    const flags = this.flags;
+    if ((flags & 16) === 0) {
       if (watch) {
         watchSignal(this);
+        this.flags |= 16 | 128 | 256;
+      } else {
+        this.flags |= 16 | 128;
       }
-      this.flags |= 16;
+      addLease(this);
+    } else if ((flags & 128) !== 0 || watch && (flags & 256) === 0) {
+      if (watch && (flags & 256) === 0) {
+        watchSignal(this);
+        this.flags |= 256;
+      }
+      this.flags |= 128;
+      addLease(this);
     }
     return this.listeners.cachedBoundAdd;
   }
+  /** Drops the listener watch; listeners stay subscribed. */
+  _pauseWatch() {
+    const flags = this.flags;
+    if ((flags & 256) !== 0) {
+      this.flags = flags & -257;
+      unwatchSignal(this, { isPausing: true });
+    }
+  }
+  /** Retakes the listener watch, pulling changes missed while unwatched. */
+  _resumeWatch() {
+    if ((this.flags & 16) !== 0 && this._takeListenerWatch()) {
+      schedulePull(this);
+    }
+  }
+  _takeListenerWatch() {
+    if ((this.flags & 256) !== 0) {
+      return false;
+    }
+    watchSignal(this);
+    this.flags |= 256;
+    return true;
+  }
+  /** `deferred` reconciles in a microtask, for a reader that unregisters before it unsubscribes. */
+  _addPausedReaders(delta, deferred = false) {
+    this.listeners.pausedReaders += delta;
+    if (deferred) {
+      queueMicrotask(() => this._reconcilePausedReaders());
+    } else {
+      this._reconcilePausedReaders();
+    }
+  }
+  _reconcilePausedReaders() {
+    const { current, pausedReaders } = this.listeners;
+    if (current.size === 0)
+      return;
+    if (pausedReaders < current.size) {
+      this._resumeWatch();
+    } else {
+      this._pauseListenerWatch();
+    }
+  }
+  /** Pauses for the listeners' sake; an unclaimed render lease's watch belongs to its render. */
+  _pauseListenerWatch() {
+    if ((this.flags & 128) === 0) {
+      this._pauseWatch();
+    }
+  }
+  /** Releases an unclaimed render lease; a no-op once claimed. */
+  _releaseLease() {
+    const flags = this.flags;
+    if ((flags & 128) === 0) {
+      return;
+    }
+    const meta = this._listeners;
+    if (meta !== null && meta.current.size > 0) {
+      this.flags = flags & -129;
+      if (meta.pausedReaders >= meta.current.size) {
+        this._pauseWatch();
+      }
+      return;
+    }
+    this.flags = flags & -401;
+    if (meta !== null) {
+      meta.updatedAt = 0;
+    }
+    cancelPull(this);
+    if ((flags & 256) !== 0) {
+      unwatchSignal(this);
+    }
+  }
 }
 const runListeners = (signal2) => {
   const { listeners } = signal2;
@@ -1659,41 +1866,51 @@ const getScopeOwner = (obj) => {
   return scope;
 };
 export {
-  callback as A,
-  settled as B,
-  context as C,
-  getContext as D,
-  withContexts as E,
-  setGlobalContexts as F,
-  clearGlobalContexts as G,
-  setScopeOwner as H,
+  ARRAY_SEED as A,
+  releaseAbandonedAttempt as B,
+  signal as C,
+  watchSignal as D,
+  getSignal as E,
+  unwatchSignal as F,
+  registerCustomHash as G,
+  setReactivePromise as H,
+  notifier as I,
+  isSignal as J,
+  callback as K,
+  settled as L,
+  context as M,
+  getContext as N,
+  withContexts as O,
+  setGlobalContexts as P,
+  clearGlobalContexts as Q,
   ReactivePromise as R,
   SignalScope as S,
-  generatorResultToPromiseWithConsumer as a,
-  setCurrentConsumer as b,
+  setScopeOwner as T,
+  getCurrentScope as a,
+  generatorResultToPromiseWithConsumer as b,
   createReactiveSignal as c,
-  getCurrentConsumer as d,
-  setRequestScopeGetter as e,
-  createReactiveDefinition as f,
-  getCurrentScope as g,
-  createTask as h,
-  createRelay as i,
-  getScopeOwner as j,
-  isReactivePromise as k,
-  getGlobalScope as l,
-  hashValue as m,
-  schedulePull as n,
-  isPromise as o,
-  isThennable as p,
-  signal as q,
-  runSignal as r,
+  setCurrentConsumer as d,
+  getCurrentConsumer as e,
+  setRequestScopeGetter as f,
+  getRenderLeaseCount as g,
+  createReactiveDefinition as h,
+  createTask as i,
+  createRelay as j,
+  getScopeOwner as k,
+  isReactivePromise as l,
+  getGlobalScope as m,
+  hashValue as n,
+  getObjectHash as o,
+  hashObjectKeys as p,
+  mixHash as q,
+  releaseRenderLeases as r,
   scheduleTracer as s,
-  getSignal as t,
-  unwatchSignal as u,
-  registerCustomHash as v,
-  watchSignal as w,
-  setReactivePromise as x,
-  notifier as y,
-  isSignal as z
+  finalizeHash as t,
+  checkSignal as u,
+  isPromise as v,
+  isThennable as w,
+  runSignal as x,
+  holdLeaseUntilSettled as y,
+  holdSuspendedLease as z
 };
-//# sourceMappingURL=contexts-FxCndlvf.js.map
+//# sourceMappingURL=contexts-ry5lvNSx.js.map