Add flush-queue consistency test (#247) + scope-throw behavioral probe (#246) (#12)

#247 (conformance): After an effect throws during flush, writing to an
unrelated signal must not trigger effects that were skipped from the
halted flush. Tests that the flush queue state is properly reset after
an error, per the scenario in alien-signals#97.

#246 (behavioral): Records whether each framework disposes child effects
when a run/scope body throws before returning. This is a design choice
(not a correctness requirement) — most frameworks keep children alive.

Author: johnsoncodehk

src/behaviorDifferences.ts

@@ -458,6 +458,35 @@ export const cases: Record<string, (fw: ReactiveFramework) => any> = {
     return runs <= 1 ? "batched" : `unbatched (${runs} runs)`;
   },
 
+  /**
+   *  run{ E(child ─→ S(source)); throw }
+   *
+   * A scope/root body creates a child effect then throws before
+   * returning. Checks whether the framework disposes child
+   * effects created before the throw or leaves them alive.
+   * Returns "disposes children" or "children survive".
+   */
+  "#246 throwing run body child effect cleanup"(fw: ReactiveFramework) {
+    const source = fw.signal(0);
+    let childRuns = 0;
+
+    try {
+      fw.run(() => {
+        fw.effect(() => {
+          childRuns++;
+          source.read();
+        });
+        throw new Error("scope setup failed");
+      });
+    } catch {}
+
+    childRuns = 0;
+    try {
+      source.write(1);
+    } catch {}
+    return childRuns === 0 ? "disposes children" : "children survive";
+  },
+
   /**
    *  E_outer{ E_inner1, E_inner2, E_inner3 } → dispose
    *

src/errorHandling.ts

@@ -321,6 +321,52 @@ export const cases: Record<string, (fw: ReactiveFramework) => any> = {
     expect(c.read()).toBe(4);
   },
 
+  /**
+   *  S(a) ← E(e1)
+   *  S(a) ← E(e2 ⚡ throws when a===1)
+   *  S(a) ← E(e3)
+   *  S(b) ← E(e4)
+   *
+   * e2 throws during propagation of a(1), which may halt the
+   * flush. On a subsequent write to unrelated signal b, only
+   * b-dependent effects must run — a-dependent effects skipped
+   * by the earlier halt must NOT leak into the new flush.
+   */
+  "#247 flush queue consistent after effect throw"(
+    fw: ReactiveFramework
+  ) {
+    const a = fw.signal(0);
+    const b = fw.signal(0);
+    let e3Runs = 0;
+
+    fw.effect(() => {
+      a.read();
+    });
+    try {
+      fw.effect(() => {
+        if (a.read() === 1) throw new Error("e2 error");
+      });
+    } catch {}
+    fw.effect(() => {
+      a.read();
+      e3Runs++;
+    });
+    fw.effect(() => {
+      b.read();
+    });
+
+    e3Runs = 0;
+    try {
+      a.write(1);
+    } catch {}
+    e3Runs = 0;
+
+    try {
+      b.write(1);
+    } catch {}
+    expect(e3Runs).toBe(0);
+  },
+
   /**
    *  S(a) → C(b) ⚡ throws when a is true
    *