signalium 3.0.3 → 4.0.1

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # signalium
 
+## 4.0.1
+
+### Patch Changes
+
+- 4512494: Fix a rejected async reactive turning Ready with no value. Suppose a reactive rejects, one of its awaited dependencies then goes pending, and that dependency resolves to an equal value. The reactive used to leave pending by resolving with its stored value, which cleared the error, set `isReady`, and left `value` `undefined`. It now returns to its rejected state with the error preserved.
+
+## 4.0.0
+
+### Major Changes
+
+- c4449de: Release the React render-path changes as a major version. They change behavior that existing apps can observe:
+
+  - `component()` props are treated as immutable, the same contract as `React.memo`. When every prop is identical (by `Object.is`) to the previous render, the previous props hash is reused, and React element props are hashed by identity. A plain object, array, `Map`, `Set` or `Date` mutated in place and passed again no longer re-renders a `component()` child; pass a new value instead. Freshly created element children (`children={<X />}`) re-render the child on every parent render.
+  - `component()` mounts in one render instead of two.
+  - Watches taken during render are leases. A render React discards (an interrupted transition, a mount that suspends, a StrictMode double render) releases its relays after `renderLeaseTtl` (default 10 s) instead of keeping them active for the rest of the session. `useReactive` and `useReactiveShallow` readers suspended by React 19's `use()` for longer than the TTL lose their lease, so their relays may deactivate and restart when React retries the render.
+
+### Minor Changes
+
+- d96ce16: `component()` no longer walks React element trees when hashing props. A React element is a plain object, so the structural props hash recursed through `props` and every descendant element — for a component taking `children`, that walk dominated each render, and reached into whatever the child elements' own props pointed at. Element-valued props are now hashed by identity: nothing reads through an element, and `hashValue` already hashes by identity any object whose prototype it doesn't recognise — elements only escaped that because they happen to be plain objects.
+
+  Every other prop keeps its structural hash, so a new-but-equivalent object or array still reuses the previous render, and a value whose class has a `registerCustomHash` function (an `Array` subclass included) is still hashed by it. Applies to async `component()` too, which hashed props the same way.
+
+  **Behaviour change:** a freshly-created children tree that is structurally identical to the previous one no longer reuses the memoized render, so such a component re-renders where it used to be skipped. Nothing can go stale as a result — React skips a subtree whose element is referentially identical, so a re-render was never what made an update visible. If a component relied on being skipped for a fresh-but-equal `children` (or other element) prop, hoist the element or memoize it so the same element is passed again.
+
+- c4449de: `component()` no longer hashes its props when every prop is identical (by `Object.is`) to the previous render's — the common case of a parent re-rendering without changing anything — and reuses the previous hash instead. A shallow identity check costs a fraction of the structural hash (6–30x less for typical props in a micro-benchmark).
+
+  **Behaviour change:** props are now treated as immutable, the same contract as `React.memo` and the React Compiler: a plain object, array, `Map`, `Set` or `Date` prop mutated in place and passed again under the same identity no longer re-renders the component (the structural hash used to notice such a mutation). Pass a new object, or read changing data from a signal inside the component. Applies to async `component()` too.
+
+- 1b46c55: Export `snapshotArray`, `snapshotPlainObject` and the `SnapshotFn` type from `signalium/utils`.
+- c4449de: New opt-in `'state'` delivery mode for React readers. By default `component()`, `useReactive` and `useReactiveShallow` reach React through `useSyncExternalStore`, which always renders at SyncLane and throws away any in-progress transition render; with live data ticking underneath, a transition only finishes at React's ~5 s expiry. In `'state'` mode a reader reads its signal directly during render, subscribes on commit (claiming its render lease), and delivers changes with a default-priority `setState`, coalesced per reader and flushed for all readers in one `runBatch` on a microtask (`scheduleReactDelivery`). Default-priority updates wait for an in-progress transition instead of restarting it. A change between render and subscribe, or during a delivered render, is caught by a version check on commit, which first re-validates the signal so a change it missed while unwatched (an expired render lease) is not lost. The subscription lives as long as a `useSyncExternalStore` one would: a Suspense hide (react-freeze) keeps it and its relays, `<Activity mode="hidden">` and unmount release it. A hidden reader is not rendered, unless its own render is what suspended, so it can still recover when a change no longer needs the pending data; when it is revealed (including the first reveal of content prerendered inside a hidden `<Activity>`) it re-validates and, if anything changed since it rendered, renders before that commit paints. A first mount delivers a change between its render and its commit at default priority instead.
+
+  Enable globally with `setConfig({ reactDelivery: 'state' })` (the default stays `'sync'`), or per reader with `component(fn, { delivery })`, `useReactive(fn, { delivery })` and `useReactiveShallow(fn, { delivery })`. The Babel preset memoizes the thunk of a `useReactive` / `useReactiveShallow` / `useReactiveDeep` call that passes options too (it used to skip any call with a second argument, so such a call created a new signal on every render); the options argument is left as written. The mode is fixed when a reader mounts. Trade-off: updates are consistent per delivery batch, but a reader that mounts while a delivery is pending can show a newer value than its already-mounted siblings for one commit; readers whose values must stay correlated keep `'sync'`.
+
+- 98ef30c: React render-time watches are now leases. `component()`, `useReactive` and `useReactiveShallow` watch their signal while rendering so relays read during the render activate, but React can discard a render (an interrupted transition, a mount that suspends, a StrictMode double render) without ever subscribing or running an effect, and the watch — with every relay under it — stayed active for the rest of the session. The render-time watch is now a provisional lease: the store subscription React makes on commit claims it (keeping the relays warm, with no restart), and a lease nobody claims is released after `renderLeaseTtl` (default 10 s, configurable via `setConfig`; a lease lives between one and two TTLs). A render that reads a still-leased signal again extends the lease. A `component()` render that suspends keeps its lease until the thrown thenable settles; one suspended by React 19's `use()` (whose thenable React keeps to itself) keeps it until React retries or commits it, or for 30 TTLs if React abandons it. `useReactive` / `useReactiveShallow` cannot see a `use()` that suspends the component after they return, so their leases follow the TTL. Committed components behave exactly as before.
+
+  `PauseSignalsProvider` pausing is counted per reader. A signal stays watched while any of its subscribers is unpaused, so a `useReactiveShallow` signal shared with readers outside a paused provider keeps updating for them, and an unpaused reader that suspends on such a signal still starts its relays. Readers register on commit, before they subscribe, so un-pausing no longer re-watches a signal from a discarded render; a provider also tracks render leases taken under it, so pausing reaches a mount that suspended before committing.
+
+  New: `retain(fn, { ttl })` keeps `fn`'s relays/queries watched for `ttl` ms (or until the returned release function is called) — an app-level lease for prefetching or keeping a hidden surface warm. The Babel preset transforms async callbacks passed to it. `ttl: Infinity` retains until released, and a `ttl` above 2^31 - 1 ms (the longest timer delay) is clamped to it. `setConfig({ renderLeaseTtl })` clamps values above that limit and ignores non-positive ones, warning in development. `signalium/debug` exports `getRenderLeaseCount()` and `releaseRenderLeases()`, which both include leases pinned for a suspended render.
+
 ## 3.0.3
 
 ### Patch Changes

package/dist/cjs/development/{component-shared-DzjqSRY-.js → component-shared-CU7qN_Ks.js}

@@ -1,5 +1,5 @@
 "use strict";
-const debug = require("./debug-CDy1L3Id.js");
+const debug = require("./debug-BS6RdX4D.js");
 function isGeneratorFunction(fn) {
   return typeof fn === "function" && fn.constructor?.name === "GeneratorFunction";
 }
@@ -30,4 +30,4 @@ exports.createServerAsyncComponentWrapper = createServerAsyncComponentWrapper;
 exports.createServerSyncComponentWrapper = createServerSyncComponentWrapper;
 exports.isAsyncFunctionWithoutTransform = isAsyncFunctionWithoutTransform;
 exports.isGeneratorFunction = isGeneratorFunction;
-//# sourceMappingURL=component-shared-DzjqSRY-.js.map
+//# sourceMappingURL=component-shared-CU7qN_Ks.js.map

package/dist/cjs/development/{component-shared-DzjqSRY-.js.map → component-shared-CU7qN_Ks.js.map}

@@ -1 +1 @@
-{"version":3,"file":"component-shared-DzjqSRY-.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":["getCurrentScope","createReactiveSignal","generatorResultToPromiseWithConsumer","getCurrentConsumer","setCurrentConsumer"],"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,QAAQA,MAAAA,gBAAe;AAC7B,UAAM,QAAQC,MAAAA,qBAAqB,EAAE,SAAS,MAAM,MAAM,QAAQ,MAAM,MAAM,SAAS,OAAO,QAAQ,OAAS,GAAI,CAAA,GAAI,QAAW,KAAK;AACvI,WAAOC,2CAAqC,GAAG,KAAK,GAAG,KAAK;AAAA,EAChE;AACJ;AAKO,SAAS,iCAAiC,IAAI;AACjD,SAAO,SAAU,OAAO;AACpB,UAAM,QAAQF,MAAAA,gBAAe;AAC7B,UAAM,QAAQC,MAAAA,qBAAqB,EAAE,SAAS,MAAM,MAAM,QAAQ,MAAM,MAAM,SAAS,OAAO,QAAQ,OAAS,GAAI,CAAA,GAAI,QAAW,KAAK;AACvI,UAAM,eAAeE,MAAAA,mBAAkB;AACvC,QAAI;AACAC,YAAAA,mBAAmB,KAAK;AACxB,aAAO,GAAG,KAAK;AAAA,IACnB,UACR;AACYA,YAAAA,mBAAmB,YAAY;AAAA,IACnC;AAAA,EACJ;AACJ;;;;;"}
+{"version":3,"file":"component-shared-CU7qN_Ks.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":["getCurrentScope","createReactiveSignal","generatorResultToPromiseWithConsumer","getCurrentConsumer","setCurrentConsumer"],"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,QAAQA,MAAAA,gBAAe;AAC7B,UAAM,QAAQC,MAAAA,qBAAqB,EAAE,SAAS,MAAM,MAAM,QAAQ,MAAM,MAAM,SAAS,OAAO,QAAQ,OAAS,GAAI,CAAA,GAAI,QAAW,KAAK;AACvI,WAAOC,2CAAqC,GAAG,KAAK,GAAG,KAAK;AAAA,EAChE;AACJ;AAKO,SAAS,iCAAiC,IAAI;AACjD,SAAO,SAAU,OAAO;AACpB,UAAM,QAAQF,MAAAA,gBAAe;AAC7B,UAAM,QAAQC,MAAAA,qBAAqB,EAAE,SAAS,MAAM,MAAM,QAAQ,MAAM,MAAM,SAAS,OAAO,QAAQ,OAAS,GAAI,CAAA,GAAI,QAAW,KAAK;AACvI,UAAM,eAAeE,MAAAA,mBAAkB;AACvC,QAAI;AACAC,YAAAA,mBAAmB,KAAK;AACxB,aAAO,GAAG,KAAK;AAAA,IACnB,UACR;AACYA,YAAAA,mBAAmB,YAAY;AAAA,IACnC;AAAA,EACJ;AACJ;;;;;"}

package/dist/cjs/development/config-D6wyrhrW.js

@@ -0,0 +1,58 @@
+"use strict";
+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) {
+    {
+      console.warn(`signalium: setConfig({ renderLeaseTtl: ${String(ttl)} }) ignored; it must be a positive number of milliseconds.`);
+    }
+    return _renderLeaseTtl;
+  }
+  if (ttl > MAX_TIMEOUT) {
+    {
+      console.warn(`signalium: setConfig({ renderLeaseTtl: ${String(ttl)} }) clamped to ${MAX_TIMEOUT} ms, the longest timer delay.`);
+    }
+    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);
+};
+exports.MAX_TIMEOUT = MAX_TIMEOUT;
+exports.getReactDelivery = getReactDelivery;
+exports.getRenderLeaseTtl = getRenderLeaseTtl;
+exports.runBatch = runBatch;
+exports.scheduleFlush = scheduleFlush;
+exports.scheduleReactDelivery = scheduleReactDelivery;
+exports.setConfig = setConfig;
+//# sourceMappingURL=config-D6wyrhrW.js.map

package/dist/cjs/development/config-D6wyrhrW.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-D6wyrhrW.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;AAC9C;AACR,cAAQ,KAAK,0CAA0C,OAAO,GAAG,CAAC,4DAA4D;AAAA,IAClI;AACA,WAAO;AAAA,EACX;AACA,MAAI,MAAM,aAAa;AACP;AACR,cAAQ,KAAK,0CAA0C,OAAO,GAAG,CAAC,kBAAkB,WAAW,+BAA+B;AAAA,IAClI;AACA,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/cjs/development/config.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const config = require("./config-B0MtLBgx.js");
+const config = require("./config-D6wyrhrW.js");
 exports.setConfig = config.setConfig;
 //# sourceMappingURL=config.js.map

package/dist/cjs/development/{debug-CDy1L3Id.js → debug-BS6RdX4D.js}

@@ -1,5 +1,5 @@
 "use strict";
-const config = require("./config-B0MtLBgx.js");
+const config = require("./config-D6wyrhrW.js");
 let UNKNOWN_SIGNAL_ID = 0;
 const UNKNOWN_SIGNAL_NAMES = /* @__PURE__ */ new Map();
 function getUnknownSignalFnName(fn) {
@@ -1070,7 +1070,11 @@ class ReactivePromiseImpl {
     return this._awaitSubs = /* @__PURE__ */ new Map();
   }
   _clearPending() {
-    this._setValue(this._value);
+    if ((this._flags & 2) !== 0) {
+      this._setError(this._error);
+    } else {
+      this._setValue(this._value);
+    }
   }
   async _setPromise(promise) {
     this._promise = promise;
@@ -1604,32 +1608,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;
 }
@@ -1641,9 +1656,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;
 }
@@ -1682,7 +1698,7 @@ const FALSE = hashStr(
   3
   /* HashType.FALSE */
 );
-const ARRAY = hashStr(
+const ARRAY_SEED = hashStr(
   "array",
   7
   /* HashType.ARRAY */
@@ -1846,6 +1862,95 @@ function stringifyValue(value) {
       return getObjectId(value);
   }
 }
+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, config.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(config.getRenderLeaseTtl() * SUSPENDED_LEASE_HOLD_TTLS, config.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 = {
@@ -1918,6 +2023,9 @@ class ReactiveSignal {
       this.flags &= -33;
     }
   }
+  get _isLeased() {
+    return (this.flags & 128) !== 0;
+  }
   get _isLazy() {
     return (this.flags & 64) !== 0;
   }
@@ -1932,6 +2040,7 @@ class ReactiveSignal {
     return this._listeners ?? (this._listeners = {
       updatedAt: 0,
       current: /* @__PURE__ */ new Map(),
+      pausedReaders: 0,
       cachedBoundAdd: this.addListener.bind(this)
     });
   }
@@ -1939,7 +2048,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) {
@@ -1952,23 +2062,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();
         }
       }
     };
@@ -1976,15 +2102,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;
+      }
+      addLease(this);
+    } else if ((flags & 128) !== 0 || watch && (flags & 256) === 0) {
+      if (watch && (flags & 256) === 0) {
+        watchSignal(this);
+        this.flags |= 256;
       }
-      this.flags |= 16;
+      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;
@@ -2124,11 +2334,13 @@ const getScopeOwner = (obj) => {
   }
   return scope;
 };
+exports.ARRAY_SEED = ARRAY_SEED;
 exports.ReactivePromise = ReactivePromise;
 exports.SignalScope = SignalScope;
 exports.Tracer = Tracer;
 exports.VisualizerNode = VisualizerNode;
 exports.callback = callback;
+exports.checkSignal = checkSignal;
 exports.clearGlobalContexts = clearGlobalContexts;
 exports.context = context;
 exports.createReactiveDefinition = createReactiveDefinition;
@@ -2137,24 +2349,32 @@ exports.createRelay = createRelay;
 exports.createTask = createTask;
 exports.createTracer = createTracer;
 exports.createTracerFromId = createTracerFromId;
+exports.finalizeHash = finalizeHash;
 exports.generatorResultToPromiseWithConsumer = generatorResultToPromiseWithConsumer;
 exports.getContext = getContext;
 exports.getCurrentConsumer = getCurrentConsumer;
 exports.getCurrentScope = getCurrentScope;
 exports.getGlobalScope = getGlobalScope;
+exports.getObjectHash = getObjectHash;
+exports.getRenderLeaseCount = getRenderLeaseCount;
 exports.getScopeOwner = getScopeOwner;
 exports.getSignal = getSignal;
 exports.getTracerProxy = getTracerProxy;
+exports.hashObjectKeys = hashObjectKeys;
 exports.hashValue = hashValue;
+exports.holdLeaseUntilSettled = holdLeaseUntilSettled;
+exports.holdSuspendedLease = holdSuspendedLease;
 exports.isPromise = isPromise;
 exports.isReactivePromise = isReactivePromise;
 exports.isSignal = isSignal;
 exports.isThennable = isThennable;
+exports.mixHash = mixHash;
 exports.notifier = notifier;
 exports.registerCustomHash = registerCustomHash;
+exports.releaseAbandonedAttempt = releaseAbandonedAttempt;
+exports.releaseRenderLeases = releaseRenderLeases;
 exports.removeTracer = removeTracer;
 exports.runSignal = runSignal;
-exports.schedulePull = schedulePull;
 exports.scheduleTracer = scheduleTracer;
 exports.setCurrentConsumer = setCurrentConsumer;
 exports.setGlobalContexts = setGlobalContexts;
@@ -2167,4 +2387,4 @@ exports.signal = signal;
 exports.unwatchSignal = unwatchSignal;
 exports.watchSignal = watchSignal;
 exports.withContexts = withContexts;
-//# sourceMappingURL=debug-CDy1L3Id.js.map
+//# sourceMappingURL=debug-BS6RdX4D.js.map