fix(fusion-ts): ComputedState.value rethrows stored error instead of masking it (S2)

ComputedState overrode `value` and `valueOrUndefined` to fall back to the
last non-error computed on an error output, diverging from the base State
class (and C# State.Value) and producing a contradictory state where
`hasValue` is false while `value` returns a value. Callers of a state whose
computer starts failing kept receiving the last good value with no signal
anything was wrong.

Remove both overrides so `value` / `valueOrUndefined` / `output` inherit the
base-class (C# State.Value / ValueOrDefault) semantics: `value` rethrows the
stored error, `valueOrUndefined` returns undefined on error, `output` reflects
the error result. Stale-value access stays available only through the explicit
`lastNonErrorValue` getter (C# State.Value vs LastNonErrorValue split).

The useComputedState hook already reads `valueOrUndefined` and exposes `error`
separately, so its documented `{ value, error }` shape is unchanged and now
matches useMutableState: `value` is undefined on error.

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

@@ -270,6 +270,8 @@ Confidence: confirmed.
 
 ### S2. `ComputedState.value` silently masks errors by falling back to `lastNonErrorValue`
 
+Status: **closed** — fixed 2026-07-15 (batch s2fix — the one item the campaign's batching initially missed): `value`/`valueOrUndefined`/`output` inherit the base-class behavior (throw / undefined / error result); stale access only via the explicit `lastNonErrorValue` (C# `Value` vs `ValueOrDefault` vs `LastNonErrorValue` parity). The React hook was already reading `valueOrUndefined`, so its `value` is now `undefined` on error, matching its documented shape.
+
 Confidence: confirmed.
 
 - TS: `computed-state.ts:72-79` — when `_computed.hasError`, `value` returns `_lastNonErrorValue` instead of throwing; `valueOrUndefined` (`computed-state.ts:86-89`) likewise. Base `State.value` and `MutableState` *do* throw on error (`state.ts:33-35`) — the port is internally inconsistent too.

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

@@ -54,18 +54,6 @@ export class ComputedState<T> extends State<T> {
         void this._updateCycle();
     }
 
-    override get value(): T {
-        if (this._computed.hasValue) return this._computed.value;
-        if (this._lastNonErrorComputed !== undefined)
-            return this._lastNonErrorComputed.value;
-        throw new Error('ComputedState has no value yet.');
-    }
-
-    override get valueOrUndefined(): T | undefined {
-        if (this._computed.hasValue) return this._computed.value;
-        return this._lastNonErrorComputed?.value;
-    }
-
     dispose(): void {
         if (this.isDisposed)
             return;

ts/packages/fusion/tests/computed-state.test.ts

@@ -232,4 +232,65 @@ describe('ComputedState audit fixes', () => {
         const computed = await updated;
         expect(computed.value).toBe(5);
     });
+
+    it('S2: an error output rethrows through value / reflects in output, no masking', async () => {
+        const boom = new Error('transient');
+        let counter = 0;
+        const state = new ComputedState<number>(
+            () => {
+                counter++;
+                if (counter === 2) throw boom;
+                return counter;
+            },
+            { updateDelayer: FixedDelayer.zero }
+        );
+
+        await state.whenFirstTimeUpdated();
+        expect(state.value).toBe(1);
+
+        state.computed.invalidate();
+        await delay(20);
+
+        expect(state.hasValue).toBe(false);
+        expect(state.hasError).toBe(true);
+        // value rethrows the stored error instead of masking it with the stale value.
+        expect(() => state.value).toThrow(boom);
+        // valueOrUndefined stays base-consistent (error -> undefined, C# ValueOrDefault).
+        expect(state.valueOrUndefined).toBeUndefined();
+        expect(state.output.hasError).toBe(true);
+        expect(state.output.error).toBe(boom);
+        // The stale value is reachable only through the explicit getter.
+        expect(state.lastNonErrorValue).toBe(1);
+    });
+
+    it('S2: a first computation that errors has no masking source', async () => {
+        const boom = new Error('boom');
+        const state = new ComputedState<number>(
+            () => {
+                throw boom;
+            },
+            { updateDelayer: FixedDelayer.zero }
+        );
+
+        await state.whenFirstTimeUpdated();
+        expect(state.hasValue).toBe(false);
+        expect(state.hasError).toBe(true);
+        expect(() => state.value).toThrow(boom);
+        expect(state.valueOrUndefined).toBeUndefined();
+        // The pre-invalidated initial computed is the last non-error computed,
+        // so lastNonErrorValue is the placeholder — C# default(T) / initialValue parity.
+        expect(state.lastNonErrorValue).toBeUndefined();
+
+        const withInitial = new ComputedState<number>(
+            () => {
+                throw boom;
+            },
+            { initialValue: 7, updateDelayer: FixedDelayer.zero }
+        );
+
+        await withInitial.whenFirstTimeUpdated();
+        expect(() => withInitial.value).toThrow(boom);
+        expect(withInitial.valueOrUndefined).toBeUndefined();
+        expect(withInitial.lastNonErrorValue).toBe(7);
+    });
 });

ts/packages/fusion/tests/last-non-error-value.test.ts

@@ -36,9 +36,10 @@ describe('lastNonErrorValue with undefined values (S12)', () => {
         await delay(20);
         expect(state.hasError).toBe(true);
 
-        // Raw-value storage read this as "no value yet" and threw; the computed
-        // reference distinguishes an actual `undefined` from an absent value.
-        expect(state.value).toBeUndefined();
+        // value rethrows the stored error (base-class parity, S2); the last non-error
+        // value stays reachable only through the explicit lastNonErrorValue getter, and
+        // here it is a legitimate `undefined` distinguished from "no non-error value yet".
+        expect(() => state.value).toThrow('boom');
         expect(state.valueOrUndefined).toBeUndefined();
         expect(state.lastNonErrorValue).toBeUndefined();
     });