signalium 3.0.2 → 4.0.0

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # signalium
 
+## 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
+
+- bad3258: `RelayHooks.deactivate` now receives a `DeactivateOptions` object with an `isPausing` flag, distinguishing a temporary pause (e.g. `PauseSignalsProvider`) from a genuine cleanup. Relays can use it to skip destructive work like garbage collection while pausing. `DeactivateOptions` is exported.
+
 ## 3.0.2
 
 ### Patch Changes

package/dist/cjs/development/{component-shared-Cug2Y5YZ.js → component-shared-BjwFh5Jq.js}

@@ -1,5 +1,5 @@
 "use strict";
-const debug = require("./debug-C46WDxhL.js");
+const debug = require("./debug-CbAX7VeM.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-Cug2Y5YZ.js.map
+//# sourceMappingURL=component-shared-BjwFh5Jq.js.map

package/dist/cjs/development/{component-shared-Cug2Y5YZ.js.map → component-shared-BjwFh5Jq.js.map}

@@ -1 +1 @@
-{"version":3,"file":"component-shared-Cug2Y5YZ.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-BjwFh5Jq.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-C46WDxhL.js → debug-CbAX7VeM.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) {
@@ -428,12 +428,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) {
@@ -443,22 +443,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 = [];
 let PENDING_TRACERS = [];
 const microtask = () => Promise.resolve();
@@ -482,8 +482,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) => {
@@ -518,8 +519,8 @@ const flushWatchers = async () => {
   }
   currentFlush = null;
   config.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) {
@@ -1299,11 +1300,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();
@@ -1603,32 +1604,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;
 }
@@ -1640,9 +1652,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;
 }
@@ -1681,7 +1694,7 @@ const FALSE = hashStr(
   3
   /* HashType.FALSE */
 );
-const ARRAY = hashStr(
+const ARRAY_SEED = hashStr(
   "array",
   7
   /* HashType.ARRAY */
@@ -1845,6 +1858,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 = {
@@ -1917,6 +2019,9 @@ class ReactiveSignal {
       this.flags &= -33;
     }
   }
+  get _isLeased() {
+    return (this.flags & 128) !== 0;
+  }
   get _isLazy() {
     return (this.flags & 64) !== 0;
   }
@@ -1931,6 +2036,7 @@ class ReactiveSignal {
     return this._listeners ?? (this._listeners = {
       updatedAt: 0,
       current: /* @__PURE__ */ new Map(),
+      pausedReaders: 0,
       cachedBoundAdd: this.addListener.bind(this)
     });
   }
@@ -1938,7 +2044,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) {
@@ -1951,23 +2058,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();
         }
       }
     };
@@ -1975,15 +2098,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;
@@ -2123,11 +2330,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;
@@ -2136,24 +2345,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;
@@ -2166,4 +2383,4 @@ exports.signal = signal;
 exports.unwatchSignal = unwatchSignal;
 exports.watchSignal = watchSignal;
 exports.withContexts = withContexts;
-//# sourceMappingURL=debug-C46WDxhL.js.map
+//# sourceMappingURL=debug-CbAX7VeM.js.map