fix(ts/fusion): state+UI robustness parity (S8, S9, S10, S17, S18)

S8: UpdateDelayer signature is now (retryCount, abortSignal); ComputedState
._updateCycle tracks a consecutive-error counter (reset on success) and the
default delayers apply RetryDelaySeq (1 s -> 1 min) backoff for retryCount > 0
plus a 32 ms minDelay floor -- C# UpdateDelayer/FixedDelayer parity.
FixedDelayer.get / UIUpdateDelayer.get floor the requested delay at minDelay
like C# FixedDelayer.Get -- get(0) no longer silently returns the zero delayer
(a truly zero delayer requires the explicit FixedDelayer.zero escape hatch).

S9: UIActionTracker tracks lastResultAt and exposes areInstantUpdatesEnabled()
(active OR within a 300 ms instant-update window after the last completion);
run/call decrement + timestamp + trigger `changed` immediately, dropping the
artificial 50 ms sleep. UIUpdateDelayer consults the new predicate.

S10: UIUpdateDelayer enforces minDelay (~32 ms), measured from delay start,
on every short-circuit path including the S9 instant-updates path -- mirrors
C# UpdateDelayer.Delay (race the instant predicate against the delay, never
return before minDelay).

S17: useMutableState returns { value, error, set, state } (valueOrUndefined +
error) so an error result renders instead of throwing.

S18: UIActionTracker.errors dedups same-name/same-message errors seen within
~1 s (C# MaxDuplicateRecency) with a size cap as a backstop.

Tests: new ts/packages/fusion/tests/stateui.test.ts covers S8 backoff growth
+ reset, the get(0) minDelay floor, S9 in/out-of-window behavior, S10 minDelay
floor, S17 error shape, S18 dedup+cap. delayer-cleanup.test.ts updated to the
(retryCount, abortSignal) delayer signature. Full suite: 695/695 green.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01SDiBQM5rnhyBG1asuP1kDi

Author: alexyakunin

docs/plans/ts-port-audit.md

@@ -336,6 +336,8 @@ Confidence: confirmed.
 
 ### S8. No retry backoff: `UpdateDelayer` has no `retryCount`, no `RetryDelays`, no transient-error tracking
 
+Status: **closed** — fixed 2026-07-15 (batch stateui; delayer signature `(retryCount, abortSignal?)`, `RetryDelaySeq.exp(1 s, 60 s)` backoff, 32 ms min-delay floor incl. `FixedDelayer.get(0)`; all errors treated as transient — TS has no transiency classification).
+
 Confidence: confirmed.
 
 - TS: `UpdateDelayer` is `(abortSignal?) => Promise<void>` (`update-delayer.ts:2`) — the delay cannot depend on failure history. No `StateSnapshot`, so no `RetryCount`/`ErrorCount`. Error recovery relies solely on the global 1 s auto-invalidation (K5) — a constant ~1 s retry loop forever.
@@ -346,6 +348,8 @@ Confidence: confirmed.
 
 ### S9. `UIActionTracker` has no post-action instant-update window; the 50 ms buffer is ineffective and adds latency
 
+Status: **closed** — fixed 2026-07-15 (batch stateui; 300 ms `instantUpdatePeriod`, the 50 ms sleep removed).
+
 Confidence: confirmed.
 
 - TS: `ui-action-tracker.ts:12-14` — `isActive` is true only while `_activeCount > 0`. In `run`/`call` (`ui-action-tracker.ts:27-31, 45-49`) the `finally` decrements first, then waits 50 ms, then triggers `changed`: (a) during the 50 ms "buffer", `isActive` is already false, so a `UIUpdateDelayer` consulted when the post-command invalidation arrives waits the full delay — the buffer buys nothing; (b) `await uiActions.call(fn)` returns 50 ms late.
@@ -356,6 +360,8 @@ Confidence: confirmed.
 
 ### S10. `UIUpdateDelayer` skips the delay entirely (no `MinDelay` floor) while a UI action is active — hot-loop risk
 
+Status: **closed** — fixed 2026-07-15 (batch stateui; minDelay measured from delay start on every path).
+
 Confidence: confirmed.
 
 - TS: `ui-update-delayer.ts:15` — `if (t.isActive) return Promise.resolve();` and the `onChanged` cancel path also resolves with zero residual delay.
@@ -430,13 +436,17 @@ Confidence: confirmed. TS leaves `_computed` invalidated until the next `update(
 
 ### S17. `useMutableState` render throws if the state holds an error result
 
+Status: **closed** — fixed 2026-07-15 (batch stateui; returns `{ value, error, set, state }`).
+
 Confidence: confirmed. `use-mutable-state.ts:41` returns `state.value`, whose getter throws on error output — and the setter accepts `Result<T>`, so `setter(errorResult(e))` is a supported call. Next render of every component using the state throws, unmounting the tree absent an error boundary.
 
 - **Recommended:** return `{ value, error, set }` (the shape `useComputedState` already uses) so error results render instead of throwing.
 - **Alternative:** narrow the setter to plain values (no `Result`) and document that errors can't be stored via this hook. Smaller, but loses parity with `MutableState.set`'s contract.
 
 ### S18. `UIActionTracker.errors` grows unbounded with no dedup
 
+Status: **closed** — fixed 2026-07-15 (batch stateui; 1 s name+message recency dedup + 100-entry cap).
+
 Confidence: confirmed. Every failure is pushed to a plain array; only manual `dismissError` removes entries (`ui-action-tracker.ts:10, 26, 43`). C# dedups same-type/same-message failures within `MaxDuplicateRecency` (1 s) (`UIActionFailureTracker.cs:64-98`). Combined with S8's fixed 1 s retry, an error-toast UI floods and memory grows for the session's lifetime.
 
 - **Recommended:** port the recency-based dedup (same error name + message within ~1 s is dropped) plus a size cap as a backstop.

ts/packages/fusion-react/src/index.ts

@@ -1,5 +1,6 @@
 export { useComputedState } from './use-computed-state.js';
 export type { UseComputedStateResult } from './use-computed-state.js';
 export { useMutableState } from './use-mutable-state.js';
+export type { UseMutableStateResult } from './use-mutable-state.js';
 // Re-export from @actuallab/fusion for convenience
 export { UIActionTracker, uiActions, UIUpdateDelayer } from '@actuallab/fusion';

ts/packages/fusion-react/src/use-mutable-state.ts

@@ -2,13 +2,18 @@ import { useEffect, useReducer, useRef } from 'react';
 import { MutableState } from '@actuallab/fusion';
 import type { Result } from '@actuallab/core';
 
+export interface UseMutableStateResult<T> {
+    value: T | undefined;
+    error: unknown;
+    set: (value: Result<T> | T) => void;
+    state: MutableState<T>;
+}
+
 /**
  * React hook wrapping Fusion's MutableState.
- * Returns [value, setter, state] — re-renders on updates.
+ * Returns { value, error, set, state } so an error result renders instead of throwing.
  */
-export function useMutableState<T>(
-    initial: T
-): [T, (value: Result<T> | T) => void, MutableState<T>] {
+export function useMutableState<T>(initial: T): UseMutableStateResult<T> {
     const [, forceRender] = useReducer(c => c + 1, 0);
     const stateRef = useRef<MutableState<T> | null>(null);
 
@@ -39,5 +44,10 @@ export function useMutableState<T>(
         };
     }, [state]);
 
-    return [state.value, v => state.set(v), state];
+    return {
+        value: state.valueOrUndefined,
+        error: state.error,
+        set: v => state.set(v),
+        state,
+    };
 }

ts/packages/fusion/src/computed-state.ts

@@ -75,6 +75,7 @@ export class ComputedState<T> extends State<T> {
 
     private async _updateCycle(): Promise<void> {
         const disposeSignal = this._disposeController.signal;
+        let retryCount = 0;
         try {
             while (!disposeSignal.aborted) {
                 // Compute
@@ -99,6 +100,7 @@ export class ComputedState<T> extends State<T> {
                     return; // Disposed mid-computation — publish nothing, terminate the cycle.
 
                 this._update(computed, output);
+                retryCount = output.hasError ? retryCount + 1 : 0;
                 if (this._cancelDelaySource.isCompleted)
                     this._cancelDelaySource = new PromiseSource<void>();
 
@@ -109,9 +111,9 @@ export class ComputedState<T> extends State<T> {
                     return; // Cancelled via dispose
                 }
 
-                // Wait for delay (cancellable by renewer)
+                // Wait for delay (cancellable by renewer); retryCount grows the backoff (S8).
                 await Promise.race([
-                    this._updateDelayer(disposeSignal),
+                    this._updateDelayer(retryCount, disposeSignal),
                     this._cancelDelaySource,
                 ]);
             }

ts/packages/fusion/src/ui-action-tracker.ts

@@ -6,13 +6,30 @@ const { errorLog } = getLogs('UIActionTracker');
 /** Singleton tracking active UI commands — mirrors .NET's UIActionTracker. */
 export class UIActionTracker {
     private _activeCount = 0;
+    private _lastResultAt = 0;
+    private _errorTimes: number[] = [];
     readonly changed = new EventHandlerSet<void>();
     readonly errors: unknown[] = [];
 
+    // C# UIActionTracker.Options.InstantUpdatePeriod / UIActionFailureTracker MaxDuplicateRecency.
+    instantUpdatePeriod = 300;
+    maxDuplicateRecency = 1000;
+    maxErrors = 100;
+
     get isActive(): boolean {
         return this._activeCount > 0;
     }
 
+    // C# UIActionTracker.AreInstantUpdatesEnabled — active, or within instantUpdatePeriod of the last result.
+    areInstantUpdatesEnabled(): boolean {
+        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: () => Promise<unknown>): Promise<void> {
         this._activeCount++;
@@ -22,12 +39,9 @@ export class UIActionTracker {
         } catch (e) {
             // Mirrors UIActionTracker.cs:58 — UI action failure.
             errorLog?.log('UI action failed', e);
-            this.errors.push(e);
+            this._addError(e);
         } finally {
-            this._activeCount--;
-            // Buffer 50ms for invalidations to arrive before signaling completion
-            await new Promise<void>(r => setTimeout(r, 50));
-            this.changed.trigger();
+            this._onCompleted();
         }
     }
 
@@ -40,21 +54,59 @@ export class UIActionTracker {
         } catch (e) {
             // Mirrors UIActionTracker.cs:58 — UI action failure.
             errorLog?.log('UI action failed', e);
-            this.errors.push(e);
+            this._addError(e);
             throw e;
         } finally {
-            this._activeCount--;
-            await new Promise<void>(r => setTimeout(r, 50));
-            this.changed.trigger();
+            this._onCompleted();
         }
     }
 
     dismissError(index: number): void {
         if (index >= 0 && index < this.errors.length) {
             this.errors.splice(index, 1);
+            this._errorTimes.splice(index, 1);
             this.changed.trigger();
         }
     }
+
+    // Private methods
+
+    private _onCompleted(): void {
+        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.
+    private _addError(e: unknown): void {
+        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: unknown): { name: string; message: string } {
+    if (e instanceof Error)
+        return { name: e.name, message: e.message };
+
+    return { name: '', message: String(e) };
 }
 
 export const uiActions = new UIActionTracker();

ts/packages/fusion/src/ui-update-delayer.ts

@@ -1,33 +1,75 @@
-import { awaitWithCleanup } from '@actuallab/core';
+import { awaitWithCleanup, type RetryDelaySeq } from '@actuallab/core';
 import { uiActions } from './ui-action-tracker.js';
-import { FixedDelayer, type UpdateDelayer } from './update-delayer.js';
+import {
+    computeUpdateDelay,
+    defaultMinDelayMs,
+    defaultRetryDelays,
+    type UpdateDelayer,
+} from './update-delayer.js';
 
-/** Re-computes after a fixed delay, but skips the delay when UIActionTracker is active. */
+/** Re-computes after a delay, but short-circuits while UIActionTracker enables instant updates. */
 export class UIUpdateDelayer {
     private static _cache = new Map<number, UpdateDelayer>();
 
+    // Floors ms at minDelay like C# FixedDelayer.Get — a zero delayer requires FixedDelayer.zero.
     static get(ms: number): UpdateDelayer {
-        if (ms <= 0) return FixedDelayer.zero;
+        ms = Math.max(ms, defaultMinDelayMs);
         let delayer = UIUpdateDelayer._cache.get(ms);
         if (delayer !== undefined) return delayer;
 
+        delayer = new UIUpdateDelayer(ms).delay;
+        UIUpdateDelayer._cache.set(ms, delayer);
+        return delayer;
+    }
+
+    readonly ms: number;
+    readonly retryDelays: RetryDelaySeq;
+    readonly minDelay: number;
+    readonly delay: UpdateDelayer;
+
+    constructor(
+        ms: number,
+        retryDelays: RetryDelaySeq = defaultRetryDelays,
+        minDelay: number = 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.
+    private async _delay(retryCount: number, abortSignal?: AbortSignal): Promise<void> {
         const t = uiActions;
-        delayer = (abortSignal?: AbortSignal) => {
-            if (t.isActive) return Promise.resolve();
+        const minDelay = retryCount === 0 ? this.minDelay : this.retryDelays.min;
+        const delayMs = computeUpdateDelay(retryCount, this.ms, this.retryDelays, this.minDelay);
+        if (delayMs <= 0)
+            return;
 
-            return awaitWithCleanup(abortSignal, 'resolve', (complete, addCleanup) => {
-                const timer = setTimeout(complete, ms);
+        const startedAt = Date.now();
+        if (!t.areInstantUpdatesEnabled())
+            await awaitWithCleanup(abortSignal, 'resolve', (complete, addCleanup) => {
+                const timer = setTimeout(complete, delayMs);
                 addCleanup(() => clearTimeout(timer));
 
-                // Cancel the delay when the tracker becomes active
                 const onChanged = () => {
-                    if (t.isActive) complete();
+                    if (t.areInstantUpdatesEnabled())
+                        complete();
                 };
                 t.changed.add(onChanged);
                 addCleanup(() => t.changed.remove(onChanged));
             });
-        };
-        UIUpdateDelayer._cache.set(ms, delayer);
-        return delayer;
+        if (abortSignal?.aborted)
+            return;
+
+        const remaining = minDelay - (Date.now() - startedAt);
+        if (remaining > 0)
+            await awaitWithCleanup(abortSignal, 'resolve', (complete, addCleanup) => {
+                const timer = setTimeout(complete, remaining);
+                addCleanup(() => clearTimeout(timer));
+            });
     }
 }

ts/packages/fusion/src/update-delayer.ts

@@ -1,16 +1,39 @@
-import { awaitWithCleanup } from '@actuallab/core';
+import { awaitWithCleanup, RetryDelaySeq } from '@actuallab/core';
 
-/** Controls when state re-computation happens after invalidation. */
-export type UpdateDelayer = (abortSignal?: AbortSignal) => Promise<void>;
+/** Controls when state re-computation happens after invalidation, per consecutive-error retryCount. */
+export type UpdateDelayer = (
+    retryCount: number,
+    abortSignal?: AbortSignal
+) => Promise<void>;
 
-/** Re-computes after a fixed delay in milliseconds. */
+/** 1 s → 1 min exponential backoff — C# FixedDelayer.Defaults.RetryDelays parity. */
+export const defaultRetryDelays = RetryDelaySeq.exp(1000, 60_000);
+
+/** Windows timer period is 15.6 ms, so 32 ms = 2..3 timer ticks — C# FixedDelayer.Defaults.MinDelay. */
+export const defaultMinDelayMs = 32;
+
+// C# UpdateDelayer.GetDelay + minDelay floor: retryCount 0 uses the update delay
+// floored by minDelay; retryCount > 0 uses RetryDelays[retryCount] floored by RetryDelays.Min.
+export function computeUpdateDelay(
+    retryCount: number,
+    updateDelayMs: number,
+    retryDelays: RetryDelaySeq,
+    minDelayMs: number
+): number {
+    const min = retryCount === 0 ? minDelayMs : retryDelays.min;
+    const raw = retryCount > 0 ? retryDelays.getDelay(retryCount) : updateDelayMs;
+    return Math.max(min, raw);
+}
+
+/** Re-computes after a fixed update delay, with RetryDelaySeq backoff for consecutive errors. */
 export class FixedDelayer {
     static readonly zero: UpdateDelayer = () => Promise.resolve();
 
     private static _cache = new Map<number, UpdateDelayer>();
 
+    // Floors ms at minDelay like C# FixedDelayer.Get — a zero delayer requires the explicit .zero.
     static get(ms: number): UpdateDelayer {
-        if (ms <= 0) return FixedDelayer.zero;
+        ms = Math.max(ms, defaultMinDelayMs);
         let delayer = FixedDelayer._cache.get(ms);
         if (delayer === undefined) {
             delayer = new FixedDelayer(ms).delay;
@@ -20,18 +43,35 @@ export class FixedDelayer {
     }
 
     readonly ms: number;
+    readonly retryDelays: RetryDelaySeq;
+    readonly minDelay: number;
     readonly delay: UpdateDelayer;
 
-    constructor(ms: number) {
+    constructor(
+        ms: number,
+        retryDelays: RetryDelaySeq = defaultRetryDelays,
+        minDelay: number = defaultMinDelayMs
+    ) {
         this.ms = ms;
+        this.retryDelays = retryDelays;
+        this.minDelay = minDelay;
         // Abort stops the wait early (resolves, never rejects) so a disposed
         // ComputedState's update loop terminates promptly and the race loser
         // carries no unhandled rejection (C# SuppressCancellationAwait spirit).
-        this.delay = (abortSignal?: AbortSignal) =>
-            awaitWithCleanup(abortSignal, 'resolve', (complete, addCleanup) => {
-                const timer = setTimeout(complete, this.ms);
+        this.delay = (retryCount, abortSignal) => {
+            const delayMs = computeUpdateDelay(
+                retryCount,
+                this.ms,
+                this.retryDelays,
+                this.minDelay
+            );
+            if (delayMs <= 0) return Promise.resolve();
+
+            return awaitWithCleanup(abortSignal, 'resolve', (complete, addCleanup) => {
+                const timer = setTimeout(complete, delayMs);
                 addCleanup(() => clearTimeout(timer));
             });
+        };
     }
 }