@cad0p/pi-steering 0.1.0

package/src/evaluator-internals/speculative-synthesis.test.ts

@@ -0,0 +1,411 @@
+// SPDX-License-Identifier: MIT
+// Part of pi-steering.
+
+/**
+ * Unit tests for {@link synthesizeSpeculativeEntries}.
+ *
+ * Table-driven across (watch, joiner) shapes per PR #5 spec. These
+ * tests pin the behaviour the evaluator relies on when threading the
+ * synthesis output into `walkerState.events`; the integration-level
+ * `&&`-chain tests in `evaluator.test.ts` still drive end-to-end
+ * behaviour through the built-in `happened` predicate.
+ */
+
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import {
+  type CommandRef,
+  expandWrapperCommands,
+  extractAllCommandsFromAST,
+  parse as parseBash,
+} from "@cad0p/unbash-walker";
+import type { Observer } from "../schema.ts";
+import {
+  SPECULATIVE_BASELINE,
+  type SyntheticEntry,
+  synthesizeSpeculativeEntries,
+} from "./speculative-synthesis.ts";
+
+function refsFor(command: string): readonly CommandRef[] {
+  const script = parseBash(command);
+  const extracted = extractAllCommandsFromAST(script, command);
+  return expandWrapperCommands(extracted).commands;
+}
+
+const SYNC_DONE = "sync-done" as const;
+const UPSTREAM_FAILED = "upstream-failed" as const;
+
+function syncObserver(overrides: Partial<Observer> = {}): Observer {
+  return {
+    name: "sync-tracker",
+    writes: [SYNC_DONE],
+    watch: {
+      toolName: "bash",
+      inputMatches: { command: /^sync\b/ },
+      exitCode: "success",
+    },
+    onResult: () => {},
+    ...overrides,
+  };
+}
+
+describe("synthesizeSpeculativeEntries: joiner reachability", () => {
+  it("empty refs → empty result", () => {
+    const out = synthesizeSpeculativeEntries([], [syncObserver()]);
+    assert.equal(out.size, 0);
+  });
+
+  it("`sync && cr` — cr sees sync's synthetic entry", () => {
+    const refs = refsFor("sync && cr --review");
+    const out = synthesizeSpeculativeEntries(refs, [syncObserver()]);
+    const syncView = out.get(refs[0]!);
+    const crView = out.get(refs[1]!);
+    assert.deepEqual(syncView, {}, "first ref sees empty chain");
+    assert.ok(crView?.[SYNC_DONE], "cr sees sync's synthetic entry");
+    assert.equal(crView[SYNC_DONE].length, 1);
+    assert.deepEqual(crView[SYNC_DONE][0], {
+      data: {},
+      timestamp: SPECULATIVE_BASELINE + 1, // baseline + 1 + ref index 0
+      speculative: true,
+    });
+  });
+
+  it("`cr && sync` — cr has no prior && producer", () => {
+    const refs = refsFor("cr --review && sync");
+    const out = synthesizeSpeculativeEntries(refs, [syncObserver()]);
+    assert.deepEqual(out.get(refs[0]!), {}, "cr sees empty");
+    // sync is after cr in source order, so sync sees whatever cr
+    // produced — but cr doesn't match the observer, so sync sees empty.
+    assert.deepEqual(out.get(refs[1]!), {});
+  });
+
+  it("`sync ; cr` — `;` does NOT propagate synthesis across", () => {
+    const refs = refsFor("sync ; cr --review");
+    const out = synthesizeSpeculativeEntries(refs, [syncObserver()]);
+    assert.deepEqual(out.get(refs[1]!), {}, "cr after `;` sees no chain");
+  });
+
+  it("`sync || cr` — `||` breaks the chain", () => {
+    const refs = refsFor("sync || cr --review");
+    const out = synthesizeSpeculativeEntries(refs, [syncObserver()]);
+    assert.deepEqual(out.get(refs[1]!), {});
+  });
+
+  it("`lint || sync && cr` — `||` early kills reachability", () => {
+    // lint.joiner=||, sync.joiner=&&, cr.joiner=undef. Because
+    // `lint` is followed by `||`, reachability clears. `sync`'s
+    // `&&` happens on an unreachable segment → sync is not an
+    // eligible producer for cr.
+    const refs = refsFor("lint || sync && cr --review");
+    const out = synthesizeSpeculativeEntries(refs, [syncObserver()]);
+    assert.deepEqual(out.get(refs[2]!), {});
+  });
+
+  it("`cd /x ; sync && cr` — `;` restores reachability", () => {
+    const refs = refsFor("cd /x ; sync && cr --review");
+    const out = synthesizeSpeculativeEntries(refs, [syncObserver()]);
+    const crView = out.get(refs[refs.length - 1]!);
+    assert.ok(
+      crView?.[SYNC_DONE],
+      "after `;`, sync && cr grants a synthetic entry for cr",
+    );
+  });
+
+  it("`echo foo && sync && cr` — transitive chain", () => {
+    const refs = refsFor("echo foo && sync && cr --review");
+    const out = synthesizeSpeculativeEntries(refs, [syncObserver()]);
+    const crView = out.get(refs[2]!);
+    assert.ok(crView?.[SYNC_DONE], "cr inherits the && chain");
+  });
+});
+
+describe("synthesizeSpeculativeEntries: observer watch gating", () => {
+  it("observer without inputMatches.command → no synthesis", () => {
+    const looseObs: Observer = {
+      name: "loose",
+      writes: [SYNC_DONE],
+      watch: { toolName: "bash" },
+      onResult: () => {},
+    };
+    const refs = refsFor("sync && cr --review");
+    const out = synthesizeSpeculativeEntries(refs, [looseObs]);
+    assert.deepEqual(out.get(refs[1]!), {});
+  });
+
+  it("observer with non-bash toolName → no synthesis", () => {
+    const readObs: Observer = {
+      name: "read-obs",
+      writes: [SYNC_DONE],
+      watch: {
+        toolName: "read",
+        inputMatches: { command: /^sync\b/ },
+      },
+      onResult: () => {},
+    };
+    const refs = refsFor("sync && cr --review");
+    const out = synthesizeSpeculativeEntries(refs, [readObs]);
+    assert.deepEqual(out.get(refs[1]!), {});
+  });
+
+  it("observer gated on exitCode: 'failure' → no synthesis (success event)", () => {
+    // The synthesized event is `exitCode: 0`; a watch demanding
+    // failure rejects it via `matchesWatch`. Delegation to
+    // matchesWatch — no subset re-impl here.
+    const failObs = syncObserver({
+      name: "fail-gated",
+      watch: {
+        toolName: "bash",
+        inputMatches: { command: /^sync\b/ },
+        exitCode: "failure",
+      },
+    });
+    const refs = refsFor("sync && cr --review");
+    const out = synthesizeSpeculativeEntries(refs, [failObs]);
+    assert.deepEqual(out.get(refs[1]!), {});
+  });
+
+  it("observer with inputMatches pattern not hitting the ref → no synthesis", () => {
+    const tightObs = syncObserver({
+      watch: {
+        toolName: "bash",
+        inputMatches: { command: /^sync --lock\b/ },
+        exitCode: "success",
+      },
+    });
+    const refs = refsFor("sync && cr --review");
+    const out = synthesizeSpeculativeEntries(refs, [tightObs]);
+    assert.deepEqual(out.get(refs[1]!), {});
+  });
+
+  it("observer without writes[] → no synthesis", () => {
+    const noWritesObs: Observer = {
+      name: "no-writes",
+      watch: {
+        toolName: "bash",
+        inputMatches: { command: /^sync\b/ },
+      },
+      onResult: () => {},
+    };
+    const refs = refsFor("sync && cr --review");
+    const out = synthesizeSpeculativeEntries(refs, [noWritesObs]);
+    assert.deepEqual(out.get(refs[1]!), {});
+  });
+
+  it("multiple observers on same type — first match wins, no duplicate entries", () => {
+    const obsA = syncObserver({
+      name: "obs-a",
+      watch: {
+        toolName: "bash",
+        inputMatches: { command: /^never-match\b/ },
+      },
+    });
+    const obsB = syncObserver({
+      name: "obs-b",
+      watch: {
+        toolName: "bash",
+        inputMatches: { command: /^sync\b/ },
+      },
+    });
+    const refs = refsFor("sync && cr --review");
+    const out = synthesizeSpeculativeEntries(refs, [obsA, obsB]);
+    const crView = out.get(refs[1]!);
+    assert.equal(
+      crView?.[SYNC_DONE]?.length,
+      1,
+      "one synthetic entry per (ref, customType) — dedup across observers",
+    );
+  });
+});
+
+describe("synthesizeSpeculativeEntries: timestamp convention", () => {
+  it("speculative timestamp uses fixed reserved baseline + 1 + astIndex", () => {
+    const refs = refsFor("sync && cr --review");
+    const out = synthesizeSpeculativeEntries(refs, [syncObserver()]);
+    const entry = out.get(refs[1]!)?.[SYNC_DONE]?.[0];
+    // sync is at index 0, baseline + 1 + 0
+    assert.equal(entry?.timestamp, SPECULATIVE_BASELINE + 1);
+  });
+
+  it("baseline is strictly greater than any realistic epoch-ms timestamp", () => {
+    // Date.now() is < 2^48 for any date through ~year 10,890 AD. Our
+    // baseline is 2^52. The gap is the headroom that makes
+    // speculative > real trivially.
+    assert.ok(SPECULATIVE_BASELINE > Date.now() * 100);
+  });
+
+  it("AST-order monotonic — later ref has later speculative timestamp", () => {
+    // `echo foo && sync && cr`: echo.idx=0, sync.idx=1. Only sync
+    // matches the observer. Its timestamp: baseline + 1 + 1.
+    const refs = refsFor("echo foo && sync && cr --review");
+    const out = synthesizeSpeculativeEntries(refs, [syncObserver()]);
+    const entry = out.get(refs[2]!)?.[SYNC_DONE]?.[0];
+    assert.equal(entry?.timestamp, SPECULATIVE_BASELINE + 2);
+  });
+
+  it("two speculative writes in same chain — later ref has later timestamp", () => {
+    // `A && B && cr` where A writes X and B writes Y. AST order:
+    // A.idx=0, B.idx=1. Timestamps: X=SPECULATIVE_BASELINE+1, Y=SPECULATIVE_BASELINE+2.
+    // Downstream `when.happened: { event: X, since: Y }` reads X
+    // as stale — the two-speculative-writes-with-since-invalidator
+    // correctness case.
+    const EVENT_X = "event-x";
+    const EVENT_Y = "event-y";
+    const obsA: Observer = {
+      name: "a-tracker",
+      writes: [EVENT_X],
+      watch: {
+        toolName: "bash",
+        inputMatches: { command: /^a\b/ },
+      },
+      onResult: () => {},
+    };
+    const obsB: Observer = {
+      name: "b-tracker",
+      writes: [EVENT_Y],
+      watch: {
+        toolName: "bash",
+        inputMatches: { command: /^b\b/ },
+      },
+      onResult: () => {},
+    };
+    const refs = refsFor("a && b && cr --review");
+    const out = synthesizeSpeculativeEntries(refs, [obsA, obsB]);
+    const crView = out.get(refs[2]!);
+    assert.equal(
+      crView?.[EVENT_X]?.[0]?.timestamp,
+      SPECULATIVE_BASELINE + 1,
+      "X ts = baseline + 1 + 0",
+    );
+    assert.equal(
+      crView?.[EVENT_Y]?.[0]?.timestamp,
+      SPECULATIVE_BASELINE + 2,
+      "Y ts = baseline + 1 + 1",
+    );
+    // Invariant: X older than Y in the speculative timeline.
+    assert.ok(
+      crView![EVENT_X]![0]!.timestamp < crView![EVENT_Y]![0]!.timestamp,
+      "AST order preserved among speculatives",
+    );
+  });
+});
+
+describe("synthesizeSpeculativeEntries: flag + identity", () => {
+  it("all synthetic entries carry `speculative: true`", () => {
+    const refs = refsFor("sync && cr --review");
+    const out = synthesizeSpeculativeEntries(refs, [syncObserver()]);
+    const entry = out.get(refs[1]!)?.[SYNC_DONE]?.[0];
+    assert.equal(entry?.speculative, true);
+  });
+
+  it("output is keyed by ref identity, not index", () => {
+    const refs = refsFor("sync && cr --review");
+    const out = synthesizeSpeculativeEntries(refs, [syncObserver()]);
+    for (const ref of refs) {
+      assert.ok(out.has(ref), `result has ref ${ref.node.name?.text ?? ""}`);
+    }
+  });
+
+  it("single ref with no joiner → empty view", () => {
+    const refs = refsFor("cr --review");
+    const out = synthesizeSpeculativeEntries(refs, [syncObserver()]);
+    assert.deepEqual(out.get(refs[0]!), {});
+  });
+});
+
+describe("synthesizeSpeculativeEntries: subshell coverage", () => {
+  it("`(sync) && cr` — subshell refs participate in the chain", () => {
+    const refs = refsFor("(sync) && cr --review");
+    const out = synthesizeSpeculativeEntries(refs, [syncObserver()]);
+    // cr is the last ref; sync's synthetic entry must be visible.
+    const crView = out.get(refs[refs.length - 1]!);
+    assert.ok(crView?.[SYNC_DONE], "subshell sync feeds cr's chain");
+  });
+
+  it("`(echo hi && sync) && cr` — multi-ref subshell", () => {
+    // GAP-01 regression fence. Both refs inside `(...)` participate
+    // in cr's prior chain; sync matches the observer.
+    const refs = refsFor("(echo hi && sync) && cr --review");
+    const out = synthesizeSpeculativeEntries(refs, [syncObserver()]);
+    const crView = out.get(refs[refs.length - 1]!);
+    assert.ok(crView?.[SYNC_DONE], "multi-ref subshell: sync feeds cr");
+  });
+
+  it("`foo && (bar ; sync) && cr` — `;` inside subshell clears chain", () => {
+    // GAP-02 conservative-under fence. After the `;`, only sync is
+    // in cr's prior chain; foo is dropped. Observer matches ONLY
+    // foo → no synthesis for cr.
+    const fooObs = syncObserver({
+      name: "foo-only",
+      watch: {
+        toolName: "bash",
+        inputMatches: { command: /^foo\b/ },
+        exitCode: "success",
+      },
+    });
+    const refs = refsFor("foo && (bar ; sync) && cr --review");
+    const out = synthesizeSpeculativeEntries(refs, [fooObs]);
+    const crView = out.get(refs[refs.length - 1]!);
+    assert.deepEqual(
+      crView,
+      {},
+      "conservative-under: foo dropped from cr's chain by `;`",
+    );
+  });
+});
+
+describe("synthesizeSpeculativeEntries: per-ref isolation", () => {
+  it("earlier refs do not see later producers", () => {
+    // Load-bearing safety property. `sync && cr`: sync (idx 0)
+    // must NOT see its own synthetic entry. Only cr (idx 1) does.
+    const refs = refsFor("sync && cr --review");
+    const out = synthesizeSpeculativeEntries(refs, [syncObserver()]);
+    assert.deepEqual(
+      out.get(refs[0]!),
+      {},
+      "sync cannot see entries it (would) produce",
+    );
+  });
+
+  it("map entries are distinct per ref (no cross-ref mutation)", () => {
+    const refs = refsFor("echo foo && sync && cr --review");
+    const out = synthesizeSpeculativeEntries(refs, [syncObserver()]);
+    const echoView = out.get(refs[0]!);
+    const syncView = out.get(refs[1]!);
+    const crView = out.get(refs[2]!);
+    // echo, sync should both see empty (sync hasn't produced yet
+    // for itself). cr should see sync's entry.
+    assert.deepEqual(echoView, {});
+    assert.deepEqual(syncView, {});
+    assert.ok(crView?.[SYNC_DONE]);
+  });
+});
+
+describe("synthesizeSpeculativeEntries: multi-type coexistence", () => {
+  it("writes by distinct observers for different customTypes coexist", () => {
+    const OTHER = "other-event";
+    const otherObs: Observer = {
+      name: "other",
+      writes: [OTHER],
+      watch: {
+        toolName: "bash",
+        inputMatches: { command: /^sync\b/ },
+      },
+      onResult: () => {},
+    };
+    const refs = refsFor("sync && cr --review");
+    const out = synthesizeSpeculativeEntries(refs, [syncObserver(), otherObs]);
+    const crView = out.get(refs[1]!);
+    assert.ok(crView?.[SYNC_DONE]);
+    assert.ok(crView?.[OTHER]);
+  });
+
+  it("custom type with no observers remains unrepresented", () => {
+    const refs = refsFor("sync && cr --review");
+    const out = synthesizeSpeculativeEntries(refs, [syncObserver()]);
+    const crView = out.get(refs[1]!) as Record<
+      string,
+      readonly SyntheticEntry[]
+    >;
+    assert.equal(crView[UPSTREAM_FAILED], undefined);
+  });
+});

package/src/evaluator-internals/speculative-synthesis.ts

@@ -0,0 +1,199 @@
+// SPDX-License-Identifier: MIT
+// Part of pi-steering.
+
+/**
+ * Unified speculative-entry synthesis for `when.happened`'s tool_call-
+ * scope speculative allow.
+ *
+ * Replaces the pre-PR-5 specialized speculative-allow path (a pair of
+ * helpers on the evaluator that matched observers against prior `&&`
+ * refs on a per-call boolean basis). For every bash command
+ * ref in an unconditionally-`&&`-reachable segment, for every observer
+ * writing an event AND matching the ref via the shared
+ * {@link matchesWatch} contract, we produce a synthetic entry that
+ * later `happened` evaluations merge with real entries via timestamp
+ * ordering.
+ *
+ * Pure function of `(refs, observers)`. The evaluator wires the
+ * output into per-ref `walkerState.events` before running predicates.
+ *
+ * ## Timestamp convention
+ *
+ *   speculativeTimestamp(ref_j) = SPECULATIVE_BASELINE + 1 + j
+ *
+ * where `SPECULATIVE_BASELINE = 2^52` — a literal chosen far above
+ * any epoch-ms timestamp pi writes on real entries (`Date.now()`
+ * returns < 2^48 for any date through ~year 10,890 AD). The speculative
+ * timestamp is thus strictly greater than ANY real entry's timestamp,
+ * regardless of type or scope. So a speculative `sync-done` at ts
+ * `2^52 + 1` beats a real `upstream-failed` at ts `Date.now()` in
+ * the since-invalidator comparison.
+ *
+ * Two properties follow (see the `unification-reconsider` review's
+ * "Timestamp reframing" section for the full walk-through):
+ *
+ *   1. **Strictly newer than every real entry across all types and
+ *      scopes.** The reserved-range literal sidesteps a per-type
+ *      max-plus-one approach — which would fail on a two-writes
+ *      scenario where the since-invalidator's latest real entry is
+ *      newer than the event type's latest real entry. A speculative
+ *      entry newer than ALL real entries is newer than any subset.
+ *
+ *   2. **Relative ordering among multiple speculative writes follows
+ *      AST order.** Ref at index `j` gets `BASELINE + 1 + j`; a later
+ *      ref at `k > j` gets `BASELINE + 1 + k`. So
+ *      `when.happened: { event: X, since: Y }` correctly reads X as
+ *      stale when Y is written later — the two-speculative-writes-
+ *      with-since-invalidator correctness case pinned by the
+ *      `A && B && cr` test in this commit pack.
+ *
+ * ## Safety
+ *
+ * **Chain reachability**: only refs with joiner `&&` in an
+ * unconditionally-reached segment qualify as eligible producers. The
+ * `&&` short-circuit guarantees any later ref that runs saw the
+ * producer complete successfully first.
+ *
+ * **Observer eligibility**: observers must declare
+ * `watch.inputMatches.command`. Any-bash-event observers would grant
+ * allow for every `foo && cr` regardless of what `foo` does. Non-bash
+ * `toolName` watches are rejected early (prior `&&` refs always
+ * originate from bash). Other filter fields are delegated to
+ * {@link matchesWatch} against a synthesized success event — the
+ * single-source-of-truth filter contract gates future new `watch`
+ * fields automatically.
+ *
+ * @internal — not part of the public pi-steering surface.
+ */
+
+import type { CommandRef } from "@cad0p/unbash-walker";
+import { refToText } from "../internal/ref-text.ts";
+import { matchesWatch } from "../internal/watch-matcher.ts";
+import type { Observer } from "../schema.ts";
+
+/**
+ * Speculative baseline timestamp. All synthetic entries carry
+ * `SPECULATIVE_BASELINE + 1 + astIndex` so they order strictly above
+ * any real entry's `timestamp` (real entries are epoch-ms from
+ * `Date.now()`, well under `2^48` for any realistic date). See the
+ * file-level JSDoc's "Timestamp convention" section for the full
+ * rationale and the acknowledged numerical-convention caveat.
+ *
+ * @internal
+ */
+export const SPECULATIVE_BASELINE = 2 ** 52;
+
+/**
+ * Speculative session entry. Structurally a superset of real entries
+ * (`{ data, timestamp }`) plus a `speculative: true` marker so the
+ * built-in `happened` predicate and plugin filters over
+ * `walkerState.events` can distinguish synthetic writes from real
+ * ones. Default direction (include speculative) matches what
+ * `happened` wants; plugins wanting pure historical semantics filter
+ * with `.filter(e => !e.speculative)`.
+ */
+export interface SyntheticEntry<T = unknown> {
+  readonly data: T;
+  readonly timestamp: number;
+  readonly speculative: true;
+}
+
+/** Per-ref view: `walkerState.events[customType] → SyntheticEntry[]`. */
+type SyntheticEventsByType = Readonly<
+  Record<string, readonly SyntheticEntry[]>
+>;
+
+/** Per-ref output keyed by {@link CommandRef} identity. */
+export type SpeculativeEventsByRef = ReadonlyMap<
+  CommandRef,
+  SyntheticEventsByType
+>;
+
+/**
+ * Compute per-ref speculative events. See file-level JSDoc for the
+ * timestamp convention, reachability model, and observer eligibility.
+ */
+export function synthesizeSpeculativeEntries(
+  refs: readonly CommandRef[],
+  observers: readonly Observer[],
+): SpeculativeEventsByRef {
+  const result = new Map<CommandRef, SyntheticEventsByType>();
+
+  // Reverse index `customType -> observers writing it`, pre-filtered
+  // to eligible observers. Stricter than `matchesWatch` on purpose —
+  // layered on top, not a reimplementation.
+  const observersByWrite = new Map<string, Observer[]>();
+  for (const obs of observers) {
+    const watch = obs.watch;
+    if (!obs.writes || !watch) continue;
+    if (watch.toolName !== undefined && watch.toolName !== "bash") continue;
+    if (watch.inputMatches?.["command"] === undefined) continue;
+    for (const event of obs.writes) {
+      const bucket = observersByWrite.get(event);
+      if (bucket) bucket.push(obs);
+      else observersByWrite.set(event, [obs]);
+    }
+  }
+
+  // Fast path: no producing observers → every ref gets empty events.
+  if (observersByWrite.size === 0) {
+    for (const ref of refs) result.set(ref, EMPTY_EVENTS);
+    return result;
+  }
+
+  // Single left-to-right walk. Each ref sees the active `&&`-chain's
+  // speculative events; the switch below carries the joiner semantics.
+  let chainEvents: Record<string, readonly SyntheticEntry[]> = {};
+  let reachable = true;
+  for (let i = 0; i < refs.length; i++) {
+    const ref = refs[i]!;
+    result.set(
+      ref,
+      Object.keys(chainEvents).length === 0 ? EMPTY_EVENTS : chainEvents,
+    );
+
+    if (ref.joiner === ";") {
+      chainEvents = {};
+      reachable = true;
+      continue;
+    }
+    if (ref.joiner !== "&&" || !reachable) {
+      chainEvents = {};
+      reachable = false;
+      continue;
+    }
+
+    // Eligible producer: test every (customType, observer) against
+    // the shared `matchesWatch` with a synthesized success event.
+    // First matching observer per customType wins — a second match
+    // is redundant for `happened`'s presence + latest-timestamp
+    // verdict. Clone the chain before extending: earlier consumer
+    // refs hold frozen references to the old map.
+    const refText = refToText(ref);
+    let next: Record<string, readonly SyntheticEntry[]> | null = null;
+    for (const [customType, observersForType] of observersByWrite) {
+      for (const obs of observersForType) {
+        const matched = matchesWatch(obs.watch, {
+          toolName: "bash",
+          input: { command: refText },
+          output: undefined,
+          exitCode: 0,
+        });
+        if (!matched) continue;
+        if (next === null) next = { ...chainEvents };
+        const entry: SyntheticEntry = {
+          data: {},
+          timestamp: SPECULATIVE_BASELINE + 1 + i,
+          speculative: true,
+        };
+        const existing = next[customType];
+        next[customType] = existing ? [...existing, entry] : [entry];
+        break;
+      }
+    }
+    if (next !== null) chainEvents = next;
+  }
+  return result;
+}
+
+const EMPTY_EVENTS: SyntheticEventsByType = Object.freeze({});