@actuallab/fusion 13.0.25 → 13.0.167

package/dist/index.cjs

@@ -23,6 +23,7 @@ __export(index_exports, {
   ComputeContext: () => ComputeContext,
   ComputeFunction: () => ComputeFunction,
   Computed: () => Computed,
+  ComputedOptions: () => ComputedOptions,
   ComputedRegistry: () => ComputedRegistry,
   ComputedState: () => ComputedState,
   ConsistencyState: () => ConsistencyState,
@@ -93,6 +94,11 @@ var ComputedRegistry = class _ComputedRegistry {
   }
   static register(computed) {
     const key = computed.input;
+    const displaced = _ComputedRegistry._entries.get(key)?.deref();
+    if (displaced === computed)
+      return;
+    if (displaced !== void 0 && displaced.state !== 2 /* Invalidated */)
+      displaced.invalidate();
     _ComputedRegistry._entries.set(key, new WeakRef(computed));
     _ComputedRegistry._finalization.register(computed, key, computed);
   }
@@ -108,19 +114,36 @@ var import_core2 = require("@actuallab/core");
 var computeContextKey = new import_core2.AsyncContextKey("ComputeContext", void 0);
 var ComputeContext = class {
   computed;
+  parent;
   _isCapturing = true;
-  constructor(computed) {
+  _captured;
+  constructor(computed, parent) {
     this.computed = computed;
+    this.parent = parent;
   }
   get isCapturing() {
     return this._isCapturing;
   }
+  get captured() {
+    return this._captured;
+  }
   stopCapturing() {
     this._isCapturing = false;
   }
   captureDependency(dependency) {
     if (!this._isCapturing) return;
-    this.computed.addDependency(dependency);
+    this._captured = dependency;
+    this.computed?.addDependency(dependency);
+  }
+  // Walks the caller chain for a computation still in progress under the same key —
+  // C# AsyncLockSet(LockReentryMode.CheckedFail) analog, used to fail fast on reentry.
+  // Only Computing ancestors count: a context leaked past its finished computation
+  // (e.g. via AsyncLocalStorage into a later callback) must not fail later calls.
+  hasKeyInChain(key) {
+    const computed = this.computed;
+    if (computed?.isComputing === true && computed.input === key)
+      return true;
+    return this.parent?.hasKeyInChain(key) ?? false;
   }
   /** Resolve ComputeContext from an AsyncContext (or current). */
   static from(ctx) {
@@ -128,7 +151,20 @@ var ComputeContext = class {
   }
 };
 
+// src/computed-options.ts
+var ComputedOptions = class _ComputedOptions {
+  static default = new _ComputedOptions();
+  static mutableStateDefault = new _ComputedOptions({
+    errorAutoInvalidateDelay: Infinity
+  });
+  errorAutoInvalidateDelay;
+  constructor(overrides) {
+    this.errorAutoInvalidateDelay = overrides?.errorAutoInvalidateDelay ?? 1e3;
+  }
+};
+
 // src/computed.ts
+var { errorLog } = getLogs("Computed");
 var _nextVersion = 0;
 var ConsistencyState = /* @__PURE__ */ ((ConsistencyState2) => {
   ConsistencyState2[ConsistencyState2["Computing"] = 0] = "Computing";
@@ -136,36 +172,44 @@ var ConsistencyState = /* @__PURE__ */ ((ConsistencyState2) => {
   ConsistencyState2[ConsistencyState2["Invalidated"] = 2] = "Invalidated";
   return ConsistencyState2;
 })(ConsistencyState || {});
-var Computed = class _Computed {
-  /** Delay before auto-invalidating a Computed that holds an error result. 0 = disabled. */
-  static errorAutoInvalidateDelay = 1e3;
+var Computed = class {
   /** Capture the Computed backing a computation — works with both local and RPC compute methods. */
   static async capture(fn) {
-    const captureComputed = new _Computed("__capture__");
-    const captureCtx = new ComputeContext(captureComputed);
-    const asyncCtx = import_core3.AsyncContext.getOrCreate().with(
-      computeContextKey,
-      captureCtx
+    const currentCtx = import_core3.AsyncContext.getOrCreate();
+    const captureCtx = new ComputeContext(
+      void 0,
+      currentCtx.get(computeContextKey)
     );
-    await asyncCtx.run(fn);
-    const deps = captureComputed.dependencies;
-    if (deps.size === 0)
+    const asyncCtx = currentCtx.with(computeContextKey, captureCtx);
+    try {
+      await asyncCtx.run(fn);
+    } catch (e) {
+      if ((0, import_core3.isCancellation)(e)) throw e;
+      const captured2 = captureCtx.captured;
+      if (captured2?.hasError) return captured2;
+      throw e;
+    }
+    const captured = captureCtx.captured;
+    if (captured === void 0)
       throw new Error(
         "No Computed was captured \u2014 fn must call a compute function."
       );
-    return deps.values().next().value;
+    return captured;
   }
   input;
+  options;
   _version;
   _state;
   _output;
   _invalidatePending = false;
+  _errorTimer;
   _dependencies = /* @__PURE__ */ new Set();
   _dependants = /* @__PURE__ */ new Map();
-  onInvalidated = new import_core3.EventHandlerSet();
+  _onInvalidated = new import_core3.EventHandlerSet();
   _renewer;
-  constructor(input, renewer) {
+  constructor(input, renewer, options = ComputedOptions.default) {
     this.input = input;
+    this.options = options;
     this._renewer = renewer;
     this._version = ++_nextVersion;
     this._state = 0 /* Computing */;
@@ -199,6 +243,9 @@ var Computed = class _Computed {
   get isConsistent() {
     return this._state === 1 /* Consistent */;
   }
+  get isComputing() {
+    return this._state === 0 /* Computing */;
+  }
   get dependencies() {
     return this._dependencies;
   }
@@ -206,7 +253,14 @@ var Computed = class _Computed {
     if (this._state === 1 /* Consistent */) return this;
     const latest = this._latest();
     if (latest?.isConsistent) return latest;
-    if (this._renewer !== void 0) return this._renewer();
+    if (this._renewer !== void 0) {
+      const renewer = this._renewer;
+      const isolated = (import_core3.AsyncContext.current ?? import_core3.AsyncContext.empty).with(
+        computeContextKey,
+        void 0
+      );
+      return isolated.run(renewer);
+    }
     throw new Error(
       "Cannot recompute: Computed is invalidated and has no renewer."
     );
@@ -243,11 +297,11 @@ var Computed = class _Computed {
       this.invalidate();
       return;
     }
-    if (this._output.hasError && _Computed.errorAutoInvalidateDelay > 0)
-      setTimeout(
-        () => this.invalidate(),
-        _Computed.errorAutoInvalidateDelay
-      );
+    const delay = this.options.errorAutoInvalidateDelay;
+    if (this._output.hasError && delay !== Infinity && delay > 0) {
+      this._errorTimer = setTimeout(() => this.invalidate(), delay);
+      this._errorTimer.unref?.();
+    }
   }
   _register() {
     ComputedRegistry.register(this);
@@ -255,6 +309,8 @@ var Computed = class _Computed {
   _unregister() {
     ComputedRegistry.unregister(this);
   }
+  // Never throws — mirrors .NET Computed.Invalidate: own handlers fire first
+  // (each isolated), then dependants propagate unconditionally, then unregister.
   invalidate() {
     if (this._state === 2 /* Invalidated */)
       return;
@@ -263,35 +319,74 @@ var Computed = class _Computed {
       return;
     }
     this._state = 2 /* Invalidated */;
-    this._dependencies.clear();
-    for (const [, ref] of this._dependants) {
-      const dependant = ref.deref();
-      if (dependant != null) dependant.invalidate();
+    if (this._errorTimer !== void 0) {
+      clearTimeout(this._errorTimer);
+      this._errorTimer = void 0;
+    }
+    try {
+      this._onInvalidated.triggerSafe(
+        void 0,
+        (e) => errorLog?.log("onInvalidated handler failed", e)
+      );
+      this._onInvalidated.clear();
+    } finally {
+      for (const dependency of this._dependencies)
+        dependency._dependants.delete(this._version);
+      this._dependencies.clear();
+      for (const [, ref] of this._dependants) {
+        const dependant = ref.deref();
+        if (dependant != null) {
+          try {
+            dependant.invalidate();
+          } catch (e) {
+            errorLog?.log("Error while invalidating dependant", e);
+          }
+        }
+      }
+      this._dependants.clear();
+      this._unregister();
     }
-    this._dependants.clear();
-    this.onInvalidated.trigger();
-    this.onInvalidated.clear();
-    this._unregister();
+  }
+  onInvalidated(handler) {
+    if (this._state === 2 /* Invalidated */) {
+      handler();
+      return;
+    }
+    this._onInvalidated.add(handler);
   }
   whenInvalidated(abortSignal) {
     if (this._state === 2 /* Invalidated */)
       return Promise.resolve();
-    const ps = new import_core3.PromiseSource();
-    const handler = () => ps.resolve(void 0);
-    this.onInvalidated.add(handler);
-    if (abortSignal !== void 0 && !abortSignal.aborted) {
-      abortSignal.addEventListener(
-        "abort",
-        () => {
-          this.onInvalidated.remove(handler);
-          ps.reject(abortSignal.reason);
-        },
-        { once: true }
+    if (abortSignal?.aborted)
+      return Promise.reject(
+        abortSignal.reason ?? new Error("Operation cancelled.")
       );
+    const ps = new import_core3.PromiseSource();
+    let onAbort;
+    const onInvalidated = () => {
+      if (onAbort !== void 0)
+        abortSignal.removeEventListener("abort", onAbort);
+      ps.resolve(void 0);
+    };
+    this._onInvalidated.add(onInvalidated);
+    if (abortSignal !== void 0) {
+      onAbort = () => {
+        this._onInvalidated.remove(onInvalidated);
+        ps.reject(
+          abortSignal.reason ?? new Error("Operation cancelled.")
+        );
+      };
+      abortSignal.addEventListener("abort", onAbort, { once: true });
     }
     return ps;
   }
   addDependency(dependency) {
+    if (this._state !== 0 /* Computing */)
+      return;
+    if (dependency._state === 2 /* Invalidated */) {
+      this.invalidate();
+      return;
+    }
     this._dependencies.add(dependency);
     dependency._dependants.set(
       this._version,
@@ -300,6 +395,9 @@ var Computed = class _Computed {
   }
 };
 var StateBoundComputed = class extends Computed {
+  constructor(input, renewer, options = ComputedOptions.mutableStateDefault) {
+    super(input, renewer, options);
+  }
   _latest() {
     return this.input.computed;
   }
@@ -313,19 +411,21 @@ var StateBoundComputed = class extends Computed {
 var import_core4 = require("@actuallab/core");
 var RS = "";
 function defaultArgToString(arg) {
-  return JSON.stringify(arg) ?? "undefined";
+  return JSON.stringify(arg) ?? "";
 }
 var _nextFunctionId = 0;
 var ComputeFunction = class {
   methodName;
   id;
+  options;
   argToString = defaultArgToString;
   _impl;
   _locks = /* @__PURE__ */ new Map();
-  constructor(methodName, impl) {
+  constructor(methodName, impl, options = ComputedOptions.default) {
     this.methodName = methodName;
     this.id = `${methodName}[${++_nextFunctionId}]`;
     this._impl = impl;
+    this.options = options;
   }
   /** Build a string key for the given instance and arguments. */
   buildKey(instance, args) {
@@ -335,7 +435,7 @@ var ComputeFunction = class {
     }
     return key;
   }
-  async invoke(instance, args, prevComputed) {
+  async invoke(instance, args) {
     const asyncCtx = import_core4.AsyncContext.fromArgs(args);
     const callerComputeCtx = asyncCtx?.get(computeContextKey);
     const argsWithoutCtx = asyncCtx?.stripFromArgs(args) ?? args;
@@ -345,6 +445,8 @@ var ComputeFunction = class {
       callerComputeCtx?.captureDependency(existing);
       return existing;
     }
+    if (callerComputeCtx?.hasKeyInChain(key))
+      throw new Error(`Reentrant compute call detected for key "${key}".`);
     let lock = this._locks.get(key);
     if (lock === void 0) {
       lock = new import_core4.AsyncLock();
@@ -353,10 +455,17 @@ var ComputeFunction = class {
     const computed = await lock.run(async () => {
       const cached = ComputedRegistry.get(key);
       if (cached?.isConsistent) return cached;
-      let newComputed;
-      const renewer = prevComputed?._renewer ?? (() => this.invoke(instance, argsWithoutCtx, newComputed));
-      newComputed = new Computed(key, renewer);
-      const childComputeCtx = new ComputeContext(newComputed);
+      const renewer = () => this.invoke(instance, argsWithoutCtx);
+      const newComputed = new Computed(
+        key,
+        renewer,
+        this.options
+      );
+      ComputedRegistry.register(newComputed);
+      const childComputeCtx = new ComputeContext(
+        newComputed,
+        callerComputeCtx
+      );
       const childAsyncCtx = (asyncCtx ?? import_core4.AsyncContext.empty).with(
         computeContextKey,
         childComputeCtx
@@ -364,7 +473,7 @@ var ComputeFunction = class {
       let fnResult;
       try {
         const value = childAsyncCtx.run(
-          () => this._impl.call(instance, ...argsWithoutCtx)
+          () => this._impl.call(instance, ...argsWithoutCtx, childAsyncCtx)
         );
         const resolved = value instanceof Promise ? await value : value;
         fnResult = (0, import_core4.result)(resolved);
@@ -372,27 +481,38 @@ var ComputeFunction = class {
         fnResult = (0, import_core4.errorResult)(e);
       }
       newComputed.setOutput(fnResult);
+      if (fnResult.hasError && (0, import_core4.isCancellation)(fnResult.error))
+        newComputed.invalidate();
       return newComputed;
     });
+    if (!lock.isLocked && this._locks.get(key) === lock)
+      this._locks.delete(key);
     callerComputeCtx?.captureDependency(computed);
     return computed;
   }
 };
 
 // src/compute-method.ts
+var import_core5 = require("@actuallab/core");
 var METHODS_META = /* @__PURE__ */ Symbol.for("actuallab.methods");
 function getMethodsMeta(cls) {
   return cls[Symbol.metadata]?.[METHODS_META];
 }
-function computeMethod(target, context) {
+function computeMethod(targetOrOptions, context) {
+  if (typeof targetOrOptions === "function")
+    return computeMethodImpl(targetOrOptions, context, {});
+  const options = targetOrOptions ?? {};
+  return (target, ctx) => computeMethodImpl(target, ctx, options);
+}
+function computeMethodImpl(target, context, options) {
   const methodName = String(context.name);
-  const methods = context.metadata[METHODS_META] ??= {};
+  const methods = (0, import_core5.ownMetadata)(context.metadata, METHODS_META);
   methods[methodName] = {
     ...methods[methodName],
     compute: true,
-    argCount: target.length
+    argCount: (0, import_core5.resolveArgCount)(target, options.argCount, methodName)
   };
-  const cf = new ComputeFunction(methodName, target);
+  const cf = new ComputeFunction(methodName, target, new ComputedOptions(options));
   const replacement = function(...allArgs) {
     return cf.invoke(this, allArgs).then((c) => c.value);
   };
@@ -424,11 +544,20 @@ function wrapComputeMethod(fn) {
 }
 
 // src/update-delayer.ts
+var import_core6 = require("@actuallab/core");
+var defaultRetryDelays = import_core6.RetryDelaySeq.exp(1e3, 6e4);
+var defaultMinDelayMs = 32;
+function computeUpdateDelay(retryCount, updateDelayMs, retryDelays, minDelayMs) {
+  const min = retryCount === 0 ? minDelayMs : retryDelays.min;
+  const raw = retryCount > 0 ? retryDelays.getDelay(retryCount) : updateDelayMs;
+  return Math.max(min, raw);
+}
 var FixedDelayer = class _FixedDelayer {
   static zero = () => Promise.resolve();
   static _cache = /* @__PURE__ */ new Map();
+  // Floors ms at minDelay like C# FixedDelayer.Get — a zero delayer requires the explicit .zero.
   static get(ms) {
-    if (ms <= 0) return _FixedDelayer.zero;
+    ms = Math.max(ms, defaultMinDelayMs);
     let delayer = _FixedDelayer._cache.get(ms);
     if (delayer === void 0) {
       delayer = new _FixedDelayer(ms).delay;
@@ -437,42 +566,57 @@ var FixedDelayer = class _FixedDelayer {
     return delayer;
   }
   ms;
+  retryDelays;
+  minDelay;
   delay;
-  constructor(ms) {
+  constructor(ms, retryDelays = defaultRetryDelays, minDelay = defaultMinDelayMs) {
     this.ms = ms;
-    this.delay = ms > 1e4 ? (abortSignal) => new Promise((resolve, reject) => {
-      const timer = setTimeout(resolve, this.ms);
-      if (abortSignal === void 0) return;
-      if (abortSignal.aborted) {
-        clearTimeout(timer);
-        reject(abortSignal.reason instanceof Error ? abortSignal.reason : new Error(String(abortSignal.reason)));
-        return;
-      }
-      abortSignal.addEventListener(
-        "abort",
-        () => {
-          clearTimeout(timer);
-          reject(abortSignal.reason instanceof Error ? abortSignal.reason : new Error(String(abortSignal.reason)));
-        },
-        { once: true }
+    this.retryDelays = retryDelays;
+    this.minDelay = minDelay;
+    this.delay = (retryCount, abortSignal) => {
+      const delayMs = computeUpdateDelay(
+        retryCount,
+        this.ms,
+        this.retryDelays,
+        this.minDelay
       );
-    }) : () => new Promise(
-      (resolve) => setTimeout(resolve, this.ms)
-    );
+      if (delayMs <= 0) return Promise.resolve();
+      return (0, import_core6.awaitWithCleanup)(abortSignal, "resolve", (complete, addCleanup) => {
+        const timer = setTimeout(complete, delayMs);
+        addCleanup(() => clearTimeout(timer));
+      });
+    };
   }
 };
 var defaultUpdateDelayer = FixedDelayer.get(1e3 / 60);
 
+// src/ui-update-delayer.ts
+var import_core8 = require("@actuallab/core");
+
 // src/ui-action-tracker.ts
-var import_core5 = require("@actuallab/core");
-var { errorLog } = getLogs("UIActionTracker");
+var import_core7 = require("@actuallab/core");
+var { errorLog: errorLog2 } = getLogs("UIActionTracker");
 var UIActionTracker = class {
   _activeCount = 0;
-  changed = new import_core5.EventHandlerSet();
+  _lastResultAt = 0;
+  _errorTimes = [];
+  changed = new import_core7.EventHandlerSet();
   errors = [];
+  // C# UIActionTracker.Options.InstantUpdatePeriod / UIActionFailureTracker MaxDuplicateRecency.
+  instantUpdatePeriod = 300;
+  maxDuplicateRecency = 1e3;
+  maxErrors = 100;
   get isActive() {
     return this._activeCount > 0;
   }
+  // C# UIActionTracker.AreInstantUpdatesEnabled — active, or within instantUpdatePeriod of the last result.
+  areInstantUpdatesEnabled() {
+    if (this._activeCount > 0)
+      return true;
+    if (this._lastResultAt === 0)
+      return false;
+    return this._lastResultAt + this.instantUpdatePeriod >= Date.now();
+  }
   /** Run a command silently — errors are added to the error list but not thrown. */
   async run(fn) {
     this._activeCount++;
@@ -480,12 +624,10 @@ var UIActionTracker = class {
     try {
       await fn();
     } catch (e) {
-      errorLog?.log("UI action failed", e);
-      this.errors.push(e);
+      errorLog2?.log("UI action failed", e);
+      this._addError(e);
     } finally {
-      this._activeCount--;
-      await new Promise((r) => setTimeout(r, 50));
-      this.changed.trigger();
+      this._onCompleted();
     }
   }
   /** Call a command and return the result — errors are added to the error list AND thrown. */
@@ -495,80 +637,127 @@ var UIActionTracker = class {
     try {
       return await fn();
     } catch (e) {
-      errorLog?.log("UI action failed", e);
-      this.errors.push(e);
+      errorLog2?.log("UI action failed", e);
+      this._addError(e);
       throw e;
     } finally {
-      this._activeCount--;
-      await new Promise((r) => setTimeout(r, 50));
-      this.changed.trigger();
+      this._onCompleted();
     }
   }
   dismissError(index) {
     if (index >= 0 && index < this.errors.length) {
       this.errors.splice(index, 1);
+      this._errorTimes.splice(index, 1);
       this.changed.trigger();
     }
   }
+  // Private methods
+  _onCompleted() {
+    this._activeCount--;
+    this._lastResultAt = Date.now();
+    this.changed.trigger();
+  }
+  // C# UIActionFailureTracker.TryAddFailure — drop a same-name/same-message error seen within
+  // maxDuplicateRecency; a size cap is the backstop against unbounded growth.
+  _addError(e) {
+    const now = Date.now();
+    const { name, message } = errorInfo(e);
+    const minAt = now - this.maxDuplicateRecency;
+    for (let i = 0; i < this.errors.length; i++) {
+      if (this._errorTimes[i] < minAt)
+        continue;
+      const prev = errorInfo(this.errors[i]);
+      if (prev.name === name && prev.message === message)
+        return;
+    }
+    this.errors.push(e);
+    this._errorTimes.push(now);
+    while (this.errors.length > this.maxErrors) {
+      this.errors.shift();
+      this._errorTimes.shift();
+    }
+    this.changed.trigger();
+  }
 };
+function errorInfo(e) {
+  if (e instanceof Error)
+    return { name: e.name, message: e.message };
+  return { name: "", message: String(e) };
+}
 var uiActions = new UIActionTracker();
 
 // src/ui-update-delayer.ts
 var UIUpdateDelayer = class _UIUpdateDelayer {
   static _cache = /* @__PURE__ */ new Map();
+  // Floors ms at minDelay like C# FixedDelayer.Get — a zero delayer requires FixedDelayer.zero.
   static get(ms) {
-    if (ms <= 0) return FixedDelayer.zero;
+    ms = Math.max(ms, defaultMinDelayMs);
     let delayer = _UIUpdateDelayer._cache.get(ms);
     if (delayer !== void 0) return delayer;
+    delayer = new _UIUpdateDelayer(ms).delay;
+    _UIUpdateDelayer._cache.set(ms, delayer);
+    return delayer;
+  }
+  ms;
+  retryDelays;
+  minDelay;
+  delay;
+  constructor(ms, retryDelays = defaultRetryDelays, minDelay = defaultMinDelayMs) {
+    this.ms = ms;
+    this.retryDelays = retryDelays;
+    this.minDelay = minDelay;
+    this.delay = this._delay.bind(this);
+  }
+  // Private methods
+  // Mirrors C# UpdateDelayer.Delay: race the instant-updates window against the full delay,
+  // then enforce minDelay measured from delay start so instant updates never hot-loop the CPU.
+  async _delay(retryCount, abortSignal) {
     const t = uiActions;
-    delayer = (abortSignal) => {
-      if (t.isActive) return Promise.resolve();
-      return new Promise((resolve, reject) => {
-        const timer = setTimeout(resolve, ms);
+    const minDelay = retryCount === 0 ? this.minDelay : this.retryDelays.min;
+    const delayMs = computeUpdateDelay(retryCount, this.ms, this.retryDelays, this.minDelay);
+    if (delayMs <= 0)
+      return;
+    const startedAt = Date.now();
+    if (!t.areInstantUpdatesEnabled())
+      await (0, import_core8.awaitWithCleanup)(abortSignal, "resolve", (complete, addCleanup) => {
+        const timer = setTimeout(complete, delayMs);
+        addCleanup(() => clearTimeout(timer));
         const onChanged = () => {
-          if (t.isActive) {
-            clearTimeout(timer);
-            t.changed.remove(onChanged);
-            resolve();
-          }
+          if (t.areInstantUpdatesEnabled())
+            complete();
         };
         t.changed.add(onChanged);
-        if (abortSignal !== void 0) {
-          if (abortSignal.aborted) {
-            clearTimeout(timer);
-            t.changed.remove(onChanged);
-            reject(abortSignal.reason instanceof Error ? abortSignal.reason : new Error(String(abortSignal.reason)));
-            return;
-          }
-          abortSignal.addEventListener(
-            "abort",
-            () => {
-              clearTimeout(timer);
-              t.changed.remove(onChanged);
-              reject(abortSignal.reason instanceof Error ? abortSignal.reason : new Error(String(abortSignal.reason)));
-            },
-            { once: true }
-          );
-        }
+        addCleanup(() => t.changed.remove(onChanged));
+      });
+    if (abortSignal?.aborted)
+      return;
+    const remaining = minDelay - (Date.now() - startedAt);
+    if (remaining > 0)
+      await (0, import_core8.awaitWithCleanup)(abortSignal, "resolve", (complete, addCleanup) => {
+        const timer = setTimeout(complete, remaining);
+        addCleanup(() => clearTimeout(timer));
       });
-    };
-    _UIUpdateDelayer._cache.set(ms, delayer);
-    return delayer;
   }
 };
 
 // src/state.ts
-var import_core6 = require("@actuallab/core");
-var State = class {
+var import_core9 = require("@actuallab/core");
+var State = class _State {
   _computed;
   _updateIndex = 0;
-  _lastNonErrorValue;
+  // Reference to the last non-error computed, not its raw value, so an actual
+  // `undefined` value is distinguishable from "no non-error value yet" (S12).
+  _lastNonErrorComputed;
   _whenUpdatedSource = null;
+  _isDisposed = false;
   get updateIndex() {
     return this._updateIndex;
   }
+  get isDisposed() {
+    return this._isDisposed;
+  }
   get lastNonErrorValue() {
-    return this._lastNonErrorValue;
+    return this._lastNonErrorComputed?.value;
   }
   get hasValue() {
     return this._computed.hasValue;
@@ -607,152 +796,153 @@ var State = class {
   whenInvalidated() {
     return this._computed.whenInvalidated();
   }
-  whenUpdated() {
-    return this._whenUpdatedSource ??= new import_core6.PromiseSource();
+  // Versioned wait: resolves at once when a newer generation than sinceIndex
+  // already landed (no lost wakeup), rejects once disposed (C# StateSnapshot.WhenUpdated).
+  whenUpdated(sinceIndex = this._updateIndex) {
+    if (this._isDisposed)
+      return Promise.reject(_State._disposedError());
+    if (this._updateIndex > sinceIndex)
+      return import_core9.resolvedVoidPromise;
+    return this._whenUpdatedSource ??= new import_core9.PromiseSource();
   }
   whenFirstTimeUpdated() {
-    return this._updateIndex > 0 ? import_core6.resolvedVoidPromise : this.whenUpdated();
+    return this.whenUpdated(0);
   }
   _initialize(output, renewer) {
-    this._computed = new StateBoundComputed(this, renewer);
+    this._computed = this._createComputed(renewer);
     this._computed.setOutput(output);
-    this._lastNonErrorValue = this._computed.valueOrUndefined;
+    if (this._computed.hasValue) this._lastNonErrorComputed = this._computed;
+  }
+  _createComputed(renewer) {
+    return new StateBoundComputed(this, renewer);
   }
   _update(computed, output) {
+    const replaced = this._computed;
     computed.setOutput(output);
     this._computed = computed;
-    if (computed.hasValue) this._lastNonErrorValue = computed.value;
+    if (replaced?.isConsistent) replaced.invalidate();
+    if (computed.hasValue) this._lastNonErrorComputed = computed;
     this._updateIndex++;
     this._whenUpdatedSource?.resolve(void 0);
     this._whenUpdatedSource = null;
   }
+  _onDisposed() {
+    if (this._isDisposed)
+      return;
+    this._isDisposed = true;
+    this._whenUpdatedSource?.reject(_State._disposedError());
+    this._whenUpdatedSource = null;
+  }
+  static _disposedError() {
+    return new Error("State is disposed.");
+  }
 };
 
 // src/computed-state.ts
-var import_core7 = require("@actuallab/core");
-var { errorLog: errorLog2 } = getLogs("ComputedState");
+var import_core10 = require("@actuallab/core");
+var { errorLog: errorLog3 } = getLogs("ComputedState");
 var ComputedState = class extends State {
   _computer;
   _updateDelayer;
   _disposeController;
-  _cancelDelaySource = new import_core7.PromiseSource();
+  _cancelDelaySource = new import_core10.PromiseSource();
   _renewer;
-  _hasOutput = false;
   constructor(computer, options) {
     super();
     this._computer = computer;
     this._updateDelayer = options?.updateDelayer ?? defaultUpdateDelayer;
     this._disposeController = new AbortController();
     this._renewer = async () => {
-      const whenUpdated = this.whenUpdated();
+      const sinceIndex = this._updateIndex;
       this._cancelDelaySource.resolve(void 0);
-      await whenUpdated;
+      await this.whenUpdated(sinceIndex);
       return this._computed;
     };
-    if (options?.initialOutput !== void 0 || options?.initialValue !== void 0) {
-      this._initialize(
-        options.initialOutput ?? options.initialValue,
-        this._renewer
-      );
-      this._hasOutput = true;
-    }
+    this._initialize(
+      options?.initialOutput ?? options?.initialValue,
+      this._renewer
+    );
+    this._computed.invalidate();
     void this._updateCycle();
   }
-  get hasValue() {
-    if (!this._hasOutput && this._updateIndex === 0) return false;
-    return this._computed.hasValue;
-  }
-  get hasError() {
-    if (!this._hasOutput && this._updateIndex === 0) return false;
-    return this._computed.hasError;
-  }
-  get value() {
-    if (!this._hasOutput && this._updateIndex === 0)
-      throw new Error("ComputedState has no value yet.");
-    if (this._computed.hasValue) return this._computed.value;
-    if (this._lastNonErrorValue !== void 0)
-      return this._lastNonErrorValue;
-    throw new Error("ComputedState has no value yet.");
-  }
-  get error() {
-    if (!this._hasOutput && this._updateIndex === 0) return void 0;
-    return this._computed.error;
-  }
-  get valueOrUndefined() {
-    if (!this._hasOutput && this._updateIndex === 0) return void 0;
-    return this._computed.valueOrUndefined ?? this._lastNonErrorValue;
-  }
-  get output() {
-    if (!this._hasOutput && this._updateIndex === 0)
-      throw new Error("ComputedState has no output yet.");
-    return this._computed.output;
-  }
-  get computed() {
-    if (!this._hasOutput && this._updateIndex === 0)
-      throw new Error("ComputedState has not been computed yet.");
-    return this._computed;
-  }
-  get isDisposed() {
-    return this._disposeController.signal.aborted;
-  }
   dispose() {
-    if (!this.isDisposed) this._disposeController.abort();
+    if (this.isDisposed)
+      return;
+    this._onDisposed();
+    this._disposeController.abort();
   }
   async _updateCycle() {
     const disposeSignal = this._disposeController.signal;
+    let retryCount = 0;
     try {
       while (!disposeSignal.aborted) {
         const computed = new StateBoundComputed(this, this._renewer);
         const computeCtx = new ComputeContext(
           computed
         );
-        const asyncCtx = (import_core7.AsyncContext.current ?? import_core7.AsyncContext.empty).with(computeContextKey, computeCtx);
+        const asyncCtx = (import_core10.AsyncContext.current ?? import_core10.AsyncContext.empty).with(computeContextKey, computeCtx);
         let output;
         try {
           const value = asyncCtx.run(() => this._computer());
           const resolved = value instanceof Promise ? await value : value;
-          output = (0, import_core7.result)(resolved);
+          output = (0, import_core10.result)(resolved);
         } catch (e) {
-          output = (0, import_core7.errorResult)(e);
+          output = (0, import_core10.errorResult)(e);
         }
+        if (this.isDisposed)
+          return;
         this._update(computed, output);
+        retryCount = output.hasError ? retryCount + 1 : 0;
         if (this._cancelDelaySource.isCompleted)
-          this._cancelDelaySource = new import_core7.PromiseSource();
+          this._cancelDelaySource = new import_core10.PromiseSource();
         try {
           await computed.whenInvalidated(disposeSignal);
         } catch {
           return;
         }
         await Promise.race([
-          this._updateDelayer(disposeSignal),
+          this._updateDelayer(retryCount, disposeSignal),
           this._cancelDelaySource
         ]);
       }
     } catch (e) {
       if (!disposeSignal.aborted)
-        errorLog2?.log("UpdateCycle() failed and stopped", e);
+        errorLog3?.log("UpdateCycle() failed and stopped", e);
     }
   }
 };
 
 // src/mutable-state.ts
-var import_core8 = require("@actuallab/core");
+var import_core11 = require("@actuallab/core");
 var MutableState = class extends State {
+  _nextOutput;
   _renewer = () => {
-    const computed = new StateBoundComputed(this, this._renewer);
-    this._update(computed, this._computed.output);
+    const computed = this._createComputed(this._renewer);
+    this._update(computed, this._nextOutput);
+    this._wireRenewal(computed);
     return computed;
   };
   constructor(initialOutput) {
     super();
-    this._initialize(initialOutput, this._renewer);
+    this._nextOutput = initialOutput instanceof import_core11.Result ? initialOutput : (0, import_core11.result)(initialOutput);
+    this._initialize(this._nextOutput, this._renewer);
+    this._wireRenewal(this._computed);
   }
   use(asyncContext) {
     return this._computed.use(asyncContext);
   }
   set(output) {
+    const next = output instanceof import_core11.Result ? output : (0, import_core11.result)(output);
+    if (this._nextOutput.equals(next))
+      return;
+    this._nextOutput = next;
     this._computed.invalidate();
-    this._update(new StateBoundComputed(this, this._renewer), output);
+  }
+  // Private methods
+  // Renew synchronously on invalidation so a MutableState is never observed invalidated.
+  // update() de-dupes: if the computed was already renewed, it returns the latest instead.
+  _wireRenewal(computed) {
+    computed.onInvalidated(() => void computed.update());
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
@@ -760,6 +950,7 @@ var MutableState = class extends State {
   ComputeContext,
   ComputeFunction,
   Computed,
+  ComputedOptions,
   ComputedRegistry,
   ComputedState,
   ConsistencyState,