@intentius/chant 0.57.0 → 0.59.0

package/src/cli/handlers/op-progress.test.ts

@@ -1,268 +0,0 @@
-import { describe, test, expect } from "vitest";
-import { extractStepRecords, extractIndexedStepRecords, stepRecordEmitter, countActivities, queryGateState } from "./op-progress";
-import type { StepRecord } from "../../op/local-executor";
-import type { OpConfig } from "../../op/types";
-import type { EffectReceiptRef } from "../../op/receipt-store";
-import type { WorkflowHistoryRaw, HistoryEvent } from "./run-client";
-
-// Minimal history-event builders. Field shapes match what `fetchNormalizedHistory`
-// produces: short PascalCase `eventType`, decimal-string `eventId`/`scheduledEventId`.
-function scheduled(eventId: string, fn: string, at: Date): HistoryEvent {
-  return {
-    eventId,
-    eventType: "ActivityTaskScheduled",
-    eventTime: at,
-    activityTaskScheduledEventAttributes: { activityId: eventId, activityType: { name: fn } },
-  };
-}
-function completed(scheduledEventId: string, at: Date): HistoryEvent {
-  return {
-    eventType: "ActivityTaskCompleted",
-    eventTime: at,
-    activityTaskCompletedEventAttributes: { scheduledEventId },
-  };
-}
-function failed(scheduledEventId: string, at: Date, message = "boom"): HistoryEvent {
-  return {
-    eventType: "ActivityTaskFailed",
-    eventTime: at,
-    activityTaskFailedEventAttributes: { scheduledEventId, failure: { message } },
-  };
-}
-
-const T0 = new Date("2026-05-01T00:00:00Z");
-const sec = (n: number) => new Date(T0.getTime() + n * 1000);
-
-describe("extractStepRecords", () => {
-  test("joins two phases' activities to their declared phase, in order", () => {
-    const config: OpConfig = {
-      name: "op", overview: "o",
-      phases: [
-        { name: "Build", steps: [{ kind: "activity", fn: "build" }] },
-        { name: "Deploy", steps: [{ kind: "activity", fn: "deploy" }] },
-      ],
-    };
-    const history: WorkflowHistoryRaw = {
-      events: [
-        scheduled("1", "build", sec(0)),
-        completed("1", sec(1)),
-        scheduled("2", "deploy", sec(2)),
-        completed("2", sec(4)),
-      ],
-    };
-    const records = extractStepRecords(config, history);
-    expect(records).toEqual([
-      { phase: "Build", fn: "build", status: "ok", durationMs: 1000 },
-      { phase: "Deploy", fn: "deploy", status: "ok", durationMs: 2000 },
-    ]);
-  });
-
-  test("two steps calling the same activity each get their own scheduled event (no last-wins collision)", () => {
-    const config: OpConfig = {
-      name: "op", overview: "o",
-      phases: [{ name: "P1", steps: [{ kind: "activity", fn: "dup" }, { kind: "activity", fn: "dup" }] }],
-    };
-    const history: WorkflowHistoryRaw = {
-      events: [
-        scheduled("1", "dup", sec(0)),
-        completed("1", sec(1)), // first "dup": 1000ms, ok
-        scheduled("2", "dup", sec(1)),
-        failed("2", sec(1.5), "second dup failed"), // second "dup": fails
-      ],
-    };
-    const records = extractStepRecords(config, history);
-    expect(records).toEqual([
-      { phase: "P1", fn: "dup", status: "ok", durationMs: 1000 },
-      { phase: "P1", fn: "dup", status: "fail", durationMs: 500, error: "second dup failed" },
-    ]);
-  });
-
-  test("a step not yet scheduled produces no record unless final", () => {
-    const config: OpConfig = {
-      name: "op", overview: "o",
-      phases: [
-        { name: "P1", steps: [{ kind: "activity", fn: "a" }] },
-        { name: "P2", steps: [{ kind: "activity", fn: "b" }] },
-      ],
-    };
-    const history: WorkflowHistoryRaw = { events: [scheduled("1", "a", sec(0)), completed("1", sec(1))] };
-
-    expect(extractStepRecords(config, history)).toEqual([
-      { phase: "P1", fn: "a", status: "ok", durationMs: 1000 },
-    ]);
-    expect(extractStepRecords(config, history, { final: true })).toEqual([
-      { phase: "P1", fn: "a", status: "ok", durationMs: 1000 },
-      { phase: "P2", fn: "b", status: "skipped", durationMs: 0 },
-    ]);
-  });
-
-  test("a scheduled-but-not-yet-settled step produces no record", () => {
-    const config: OpConfig = {
-      name: "op", overview: "o",
-      phases: [{ name: "P1", steps: [{ kind: "activity", fn: "a" }] }],
-    };
-    const history: WorkflowHistoryRaw = { events: [scheduled("1", "a", sec(0))] };
-    expect(extractStepRecords(config, history)).toEqual([]);
-  });
-
-  test("a retried activity resolves to its last outcome (Failed attempt then eventual Completed)", () => {
-    const config: OpConfig = {
-      name: "op", overview: "o",
-      phases: [{ name: "P1", steps: [{ kind: "activity", fn: "flaky" }] }],
-    };
-    const history: WorkflowHistoryRaw = {
-      events: [
-        scheduled("1", "flaky", sec(0)),
-        failed("1", sec(1), "attempt 1 failed"),
-        completed("1", sec(3)), // eventual success
-      ],
-    };
-    expect(extractStepRecords(config, history)).toEqual([
-      { phase: "P1", fn: "flaky", status: "ok", durationMs: 3000 },
-    ]);
-  });
-
-  test("effect step: matched receipt — only receiptRead settles; nested + receiptWrite are skipped only when final", () => {
-    const receipt: EffectReceiptRef = { name: "r", effect: "e", flavor: "existence", inputs: {} };
-    const config: OpConfig = {
-      name: "op", overview: "o",
-      phases: [{
-        name: "Effect",
-        steps: [{ kind: "effect", receipt, steps: [{ kind: "activity", fn: "applyIt" }] }],
-      }],
-    };
-    const history: WorkflowHistoryRaw = {
-      events: [scheduled("1", "receiptRead", sec(0)), completed("1", sec(1))],
-    };
-    expect(extractStepRecords(config, history)).toEqual([
-      { phase: "Effect", fn: "receiptRead", status: "ok", durationMs: 1000 },
-    ]);
-    expect(extractStepRecords(config, history, { final: true })).toEqual([
-      { phase: "Effect", fn: "receiptRead", status: "ok", durationMs: 1000 },
-      { phase: "Effect", fn: "applyIt", status: "skipped", durationMs: 0 },
-      { phase: "Effect", fn: "receiptWrite", status: "skipped", durationMs: 0 },
-    ]);
-  });
-
-  test("onFailure phases are matched in reverse declared order, matching how the workflow actually runs them", () => {
-    const config: OpConfig = {
-      name: "op", overview: "o",
-      phases: [{ name: "Main", steps: [{ kind: "activity", fn: "boom" }] }],
-      onFailure: [
-        { name: "C1", steps: [{ kind: "activity", fn: "comp1" }] },
-        { name: "C2", steps: [{ kind: "activity", fn: "comp2" }] },
-      ],
-    };
-    const history: WorkflowHistoryRaw = {
-      events: [
-        scheduled("1", "boom", sec(0)),
-        failed("1", sec(1), "boom"),
-        // Compensation runs C2 then C1 (reverse of declared order).
-        scheduled("2", "comp2", sec(2)),
-        completed("2", sec(3)),
-        scheduled("3", "comp1", sec(3)),
-        completed("3", sec(4)),
-      ],
-    };
-    expect(extractStepRecords(config, history)).toEqual([
-      { phase: "Main", fn: "boom", status: "fail", durationMs: 1000, error: "boom" },
-      { phase: "C2", fn: "comp2", status: "ok", durationMs: 1000 },
-      { phase: "C1", fn: "comp1", status: "ok", durationMs: 1000 },
-    ]);
-  });
-});
-
-describe("stepRecordEmitter", () => {
-  // chant #2032. Declared order is main phases then `onFailure` reversed, so an
-  // unreached main phase sits *before* an `onFailure` phase that ran. The live
-  // poll therefore returns [Main(fail), Comp(ok)] and the terminal `final: true`
-  // pass returns [Main(fail), Never(skipped), Comp(ok)] — an insertion, not an
-  // append. The old emitted-count watermark sliced at 2 and re-shipped Comp
-  // while dropping Never entirely. The #1676 coverage above misses this because
-  // in those configs the skipped record lands last, where insert and append are
-  // the same operation.
-  const config: OpConfig = {
-    name: "op", overview: "o",
-    phases: [
-      { name: "Main", steps: [{ kind: "activity", fn: "boom" }] },
-      { name: "Never", steps: [{ kind: "activity", fn: "never" }] },
-    ],
-    onFailure: [{ name: "Comp", steps: [{ kind: "activity", fn: "comp" }] }],
-  };
-  // Main fails, Never is never reached, compensation runs and succeeds.
-  const history: WorkflowHistoryRaw = {
-    events: [
-      scheduled("1", "boom", sec(0)),
-      failed("1", sec(1), "boom"),
-      scheduled("2", "comp", sec(2)),
-      completed("2", sec(3)),
-    ],
-  };
-
-  const MAIN: StepRecord = { phase: "Main", fn: "boom", status: "fail", durationMs: 1000, error: "boom" };
-  const NEVER: StepRecord = { phase: "Never", fn: "never", status: "skipped", durationMs: 0 };
-  const COMP: StepRecord = { phase: "Comp", fn: "comp", status: "ok", durationMs: 1000 };
-
-  test("the final pass inserts rather than appends, so list position is not an identity", () => {
-    expect(extractIndexedStepRecords(config, history)).toEqual([
-      { index: 0, record: MAIN },
-      { index: 2, record: COMP },
-    ]);
-    expect(extractIndexedStepRecords(config, history, { final: true })).toEqual([
-      { index: 0, record: MAIN },
-      { index: 1, record: NEVER },
-      { index: 2, record: COMP },
-    ]);
-  });
-
-  test("each record ships exactly once across the poll passes and the final pass", () => {
-    const emitted: StepRecord[] = [];
-    const emit = stepRecordEmitter((r) => emitted.push(r));
-
-    emit(extractIndexedStepRecords(config, history)); // a poll while the workflow closes
-    emit(extractIndexedStepRecords(config, history)); // an identical re-poll adds nothing
-    emit(extractIndexedStepRecords(config, history, { final: true }));
-
-    expect(emitted).toEqual([MAIN, COMP, NEVER]);
-  });
-
-  test("an empty first poll does not shift what a later pass ships", () => {
-    const emitted: StepRecord[] = [];
-    const emit = stepRecordEmitter((r) => emitted.push(r));
-
-    emit(extractIndexedStepRecords(config, { events: [] }));
-    expect(emitted).toEqual([]);
-    emit(extractIndexedStepRecords(config, history, { final: true }));
-    expect(emitted).toEqual([MAIN, NEVER, COMP]);
-  });
-});
-
-describe("countActivities", () => {
-  test("counts scheduled and completed events", () => {
-    const history: WorkflowHistoryRaw = {
-      events: [scheduled("1", "a", sec(0)), scheduled("2", "b", sec(0)), completed("1", sec(1))],
-    };
-    expect(countActivities(history)).toEqual({ completed: 1, scheduled: 2 });
-  });
-
-  test("empty history", () => {
-    expect(countActivities({})).toEqual({ completed: 0, scheduled: 0 });
-  });
-});
-
-describe("queryGateState", () => {
-  test("returns the query result when the handle supports it", async () => {
-    const handle = { query: async () => ({ signalName: "g", since: "t" }) } as unknown as Parameters<typeof queryGateState>[0];
-    expect(await queryGateState(handle)).toEqual({ signalName: "g", since: "t" });
-  });
-
-  test("returns null when the workflow reports no pending gate", async () => {
-    const handle = { query: async () => null } as unknown as Parameters<typeof queryGateState>[0];
-    expect(await queryGateState(handle)).toBeNull();
-  });
-
-  test("returns undefined (not an error) when the query isn't registered — e.g. an Op with no gates", async () => {
-    const handle = { query: async () => { throw new Error("unregistered query"); } } as unknown as Parameters<typeof queryGateState>[0];
-    expect(await queryGateState(handle)).toBeUndefined();
-  });
-});

package/src/cli/handlers/op-progress.ts

@@ -1,248 +0,0 @@
-/**
- * Per-phase progress reconstructed from a Temporal Op workflow's history
- * (chant #1676) — the durable-path counterpart to the local executor's
- * `StepRecord[]` (op/local-executor.ts), so `chant run <name> --temporal
- * --progress-json` and `op-status` can report the same shape `chant run
- * <name> --json` already does for the local path, instead of the two raw
- * `ActivityTaskScheduled`/`ActivityTaskCompleted` counts.
- *
- * A step is joined to its declared (phase, fn) by position, not by name: the
- * declared step list (`declaredStepOrder`, mirroring the serializer's own
- * `collectActivitySteps` traversal — main phases, then `onFailure` phases
- * *reversed*, matching how the generated workflow actually runs them) is
- * walked in order, and each step consumes the next not-yet-consumed
- * `ActivityTaskScheduled` event whose activity type matches its `fn` — a
- * per-fn FIFO queue, not a global "does this name appear anywhere" scan.
- * Two steps calling the same activity therefore each get their own
- * scheduled event instead of the later one overwriting the earlier
- * (the collision the prior `run-report.ts` join had). A step whose queue is
- * empty never ran this execution — an untaken effect branch, or an
- * `onFailure` phase on a run that succeeded.
- */
-
-import type { OpConfig, PhaseDefinition } from "../../op/types";
-import type { StepRecord } from "../../op/local-executor";
-import type { WorkflowHistoryRaw, HistoryEvent, WorkflowHandleRaw } from "./run-client";
-
-// Synthesized step names an effect step's read-compare-run-write compiles
-// to (lexicons/temporal/src/op/serializer.ts's RECEIPT_READ_STEP/
-// RECEIPT_WRITE_STEP) — duplicated here rather than imported so this module
-// stays lexicon-free, same constraint as op/local-executor.ts.
-const RECEIPT_READ_FN = "receiptRead";
-const RECEIPT_WRITE_FN = "receiptWrite";
-
-interface DeclaredStep {
-  phase: string;
-  fn: string;
-}
-
-function flattenPhases(phases: PhaseDefinition[]): DeclaredStep[] {
-  const out: DeclaredStep[] = [];
-  for (const phase of phases) {
-    for (const step of phase.steps) {
-      if (step.kind === "activity") {
-        out.push({ phase: phase.name, fn: step.fn });
-      } else if (step.kind === "effect") {
-        out.push({ phase: phase.name, fn: RECEIPT_READ_FN });
-        for (const nested of step.steps) {
-          if (nested.kind === "activity") out.push({ phase: phase.name, fn: nested.fn });
-        }
-        out.push({ phase: phase.name, fn: RECEIPT_WRITE_FN });
-      }
-      // Gate steps schedule no activity — nothing to join them to.
-    }
-  }
-  return out;
-}
-
-/** Declared order matching actual scheduling order: main phases, then `onFailure` reversed (compensation runs last-declared-first — serializer.ts's `renderPhases([...config.onFailure].reverse())`). */
-function declaredStepOrder(config: OpConfig): DeclaredStep[] {
-  return [...flattenPhases(config.phases), ...flattenPhases([...(config.onFailure ?? [])].reverse())];
-}
-
-interface ScheduledEntry {
-  scheduledEventId: string;
-  scheduledAt?: Date;
-}
-
-/** Every `ActivityTaskScheduled` event, grouped by activity type name, in chronological order. */
-function scheduledQueues(events: HistoryEvent[]): Map<string, ScheduledEntry[]> {
-  const byFn = new Map<string, ScheduledEntry[]>();
-  for (const e of events) {
-    if (e.eventType !== "ActivityTaskScheduled") continue;
-    const attrs = e.activityTaskScheduledEventAttributes;
-    if (!attrs) continue;
-    const fn = attrs.activityType?.name ?? "unknown";
-    if (!byFn.has(fn)) byFn.set(fn, []);
-    byFn.get(fn)!.push({ scheduledEventId: e.eventId ?? "", scheduledAt: e.eventTime });
-  }
-  return byFn;
-}
-
-interface TerminalOutcome {
-  status: "ok" | "fail";
-  at?: Date;
-  error?: string;
-}
-
-/**
- * The terminal outcome of each scheduled activity, keyed by the scheduling
- * event's own id. A retried activity emits one `ActivityTaskFailed` per
- * attempt under the same `scheduledEventId`; walking events in order and
- * always overwriting on a later event leaves whichever came last —
- * `ActivityTaskCompleted` on an eventual success, otherwise the final
- * attempt's failure.
- */
-function terminalOutcomes(events: HistoryEvent[]): Map<string, TerminalOutcome> {
-  const out = new Map<string, TerminalOutcome>();
-  for (const e of events) {
-    if (e.eventType === "ActivityTaskCompleted" && e.activityTaskCompletedEventAttributes) {
-      const id = e.activityTaskCompletedEventAttributes.scheduledEventId;
-      if (id) out.set(id, { status: "ok", at: e.eventTime });
-    } else if (e.eventType === "ActivityTaskFailed" && e.activityTaskFailedEventAttributes) {
-      const id = e.activityTaskFailedEventAttributes.scheduledEventId;
-      if (id) {
-        out.set(id, {
-          status: "fail",
-          at: e.eventTime,
-          error: e.activityTaskFailedEventAttributes.failure?.message ?? "unknown error",
-        });
-      }
-    }
-  }
-  return out;
-}
-
-/**
- * A step record paired with the position of the declared step it came from.
- *
- * `index` is an offset into `declaredStepOrder(config)`, which depends only
- * on the Op config — not on the history — so it is the record's identity
- * and is stable across polls. The record *list* is not: a mid-run poll omits
- * every step that hasn't settled yet, and the terminal `final: true` pass
- * inserts a `"skipped"` record at each such step's declared position, which
- * shifts every later record's list offset (chant #2032). Anything tracking
- * what it has already seen must key on `index`, never on how many records
- * the previous call returned.
- */
-export interface IndexedStepRecord {
-  index: number;
-  record: StepRecord;
-}
-
-/**
- * Reconstruct per-step progress records from a workflow's history, in
- * declared order, each tagged with its declared-step `index`. Only settled
- * steps (matched to a scheduled event that has since completed or failed)
- * produce a record — a step that hasn't been scheduled yet simply isn't in
- * the result. Pass `final: true` once the workflow has reached a terminal
- * status to also emit a `"skipped"` record for every declared step that
- * never got a matching scheduled event (an untaken effect branch, or an
- * `onFailure` phase on a run that succeeded) — never before, or a
- * still-running Op would show its not-yet-reached steps as skipped.
- */
-export function extractIndexedStepRecords(
-  config: OpConfig,
-  history: WorkflowHistoryRaw,
-  opts: { final?: boolean } = {},
-): IndexedStepRecord[] {
-  const events = history.events ?? [];
-  const queues = scheduledQueues(events);
-  const terminals = terminalOutcomes(events);
-  const nextIndex = new Map<string, number>();
-
-  const records: IndexedStepRecord[] = [];
-  const declared = declaredStepOrder(config);
-  for (let index = 0; index < declared.length; index++) {
-    const step = declared[index];
-    const queue = queues.get(step.fn);
-    const idx = nextIndex.get(step.fn) ?? 0;
-    const entry = queue?.[idx];
-    if (!entry) {
-      if (opts.final) {
-        records.push({ index, record: { phase: step.phase, fn: step.fn, status: "skipped", durationMs: 0 } });
-      }
-      continue;
-    }
-    nextIndex.set(step.fn, idx + 1);
-
-    const terminal = terminals.get(entry.scheduledEventId);
-    if (!terminal) continue; // scheduled but not yet settled
-
-    const durationMs =
-      entry.scheduledAt && terminal.at ? terminal.at.getTime() - entry.scheduledAt.getTime() : 0;
-    records.push({
-      index,
-      record: {
-        phase: step.phase,
-        fn: step.fn,
-        status: terminal.status,
-        durationMs,
-        ...(terminal.error ? { error: terminal.error } : {}),
-      },
-    });
-  }
-  return records;
-}
-
-/** `extractIndexedStepRecords` without the indices — the plain declared-order record list. */
-export function extractStepRecords(
-  config: OpConfig,
-  history: WorkflowHistoryRaw,
-  opts: { final?: boolean } = {},
-): StepRecord[] {
-  return extractIndexedStepRecords(config, history, opts).map((r) => r.record);
-}
-
-/**
- * A sink that forwards each declared step's record exactly once, however many
- * times the poll loop re-derives the list.
- *
- * `--progress-json` calls this per poll with the whole list so far, plus once
- * more with the terminal `final: true` list. Deduplicating by declared-step
- * `index` is what makes that safe: an emitted-count watermark assumed the list
- * was append-only, and the `final` pass's inserted `"skipped"` records break
- * that assumption — with an unreached phase declared before an `onFailure`
- * phase that ran, the insertion shifted the tail, so the last record shipped
- * twice and the skipped one never shipped at all (chant #2032).
- */
-export function stepRecordEmitter(emit: (record: StepRecord) => void): (records: IndexedStepRecord[]) => void {
-  const seen = new Set<number>();
-  return (records) => {
-    for (const { index, record } of records) {
-      if (seen.has(index)) continue;
-      seen.add(index);
-      emit(record);
-    }
-  };
-}
-
-/** `{completed, scheduled}` activity counts for the summary line `chant run status`/`op-status` show alongside the full record list. */
-export function countActivities(history: WorkflowHistoryRaw): { completed: number; scheduled: number } {
-  const events = history.events ?? [];
-  return {
-    completed: events.filter((e) => e.eventType === "ActivityTaskCompleted").length,
-    scheduled: events.filter((e) => e.eventType === "ActivityTaskScheduled").length,
-  };
-}
-
-/** The `gateState` workflow query's result (op/serializer.ts's `emitGate`) — the gate currently blocking the workflow, or `null` when none is pending. */
-export interface GateQueryResult {
-  signalName: string;
-  description?: string;
-  since: string;
-}
-
-/**
- * Best-effort `gateState` query. `undefined` (as opposed to `null`) means
- * the query itself failed — an Op with no gate steps never registers a
- * `gateState` handler, so querying it is expected to fail, not an error
- * worth surfacing.
- */
-export async function queryGateState(handle: WorkflowHandleRaw): Promise<GateQueryResult | null | undefined> {
-  try {
-    return await handle.query<GateQueryResult | null>("gateState");
-  } catch {
-    return undefined;
-  }
-}

package/src/cli/handlers/run-client.test.ts

@@ -1,82 +0,0 @@
-import { describe, test, expect } from "vitest";
-import { fetchNormalizedHistory, type WorkflowHandleRaw } from "./run-client";
-
-/**
- * `@temporalio/client`'s `WorkflowHandle.fetchHistory()` returns the raw
- * Temporal wire proto: `eventType` a numeric enum, `eventId`/
- * `scheduledEventId` protobuf `Long` instances, `eventTime` a
- * `{seconds, nanos}` Timestamp. What turns those into the friendly
- * `"EVENT_TYPE_ACTIVITY_TASK_SCHEDULED"` string / decimal strings is the
- * proto message's own `toJSON()` — confirmed against a real
- * `TestWorkflowEnvironment` run (Temporal SDK 1.17.2) during development.
- * These fixtures simulate exactly that: plain values by default, but with a
- * `toJSON()` on the fields that have one on the wire, so a JSON round-trip
- * behaves the same way it does against a real server.
- */
-function fakeLong(n: number) {
-  return { low: n, high: 0, unsigned: false, toJSON: () => String(n) };
-}
-
-function fakeTimestamp(seconds: number, nanos = 0) {
-  return { seconds: fakeLong(seconds), nanos };
-}
-
-function makeHandle(events: unknown[]): WorkflowHandleRaw {
-  return {
-    workflowId: "wf",
-    async fetchHistory() {
-      return { events } as never;
-    },
-  } as unknown as WorkflowHandleRaw;
-}
-
-describe("fetchNormalizedHistory", () => {
-  test("converts the raw wire shape to short eventType, decimal eventId, and a real Date", async () => {
-    const raw = {
-      eventId: fakeLong(7),
-      eventTime: fakeTimestamp(1_788_000_000, 500_000_000),
-      eventType: "EVENT_TYPE_ACTIVITY_TASK_SCHEDULED",
-      activityTaskScheduledEventAttributes: {
-        activityId: "1",
-        activityType: { name: "dup" },
-      },
-    };
-    const history = await fetchNormalizedHistory(makeHandle([raw]));
-    const event = history.events?.[0];
-    expect(event?.eventType).toBe("ActivityTaskScheduled");
-    expect(event?.eventId).toBe("7");
-    expect(event?.eventTime).toBeInstanceOf(Date);
-    expect(event?.eventTime?.getTime()).toBe(1_788_000_000_500);
-    expect(event?.activityTaskScheduledEventAttributes).toEqual({ activityId: "1", activityType: { name: "dup" } });
-  });
-
-  test("ActivityTaskCompleted's scheduledEventId round-trips to a decimal string, joinable against eventId", async () => {
-    const scheduled = {
-      eventId: fakeLong(7),
-      eventType: "EVENT_TYPE_ACTIVITY_TASK_SCHEDULED",
-      activityTaskScheduledEventAttributes: { activityId: "1", activityType: { name: "dup" } },
-    };
-    const completedEvent = {
-      eventId: fakeLong(9),
-      eventType: "EVENT_TYPE_ACTIVITY_TASK_COMPLETED",
-      activityTaskCompletedEventAttributes: { scheduledEventId: fakeLong(7) },
-    };
-    const history = await fetchNormalizedHistory(makeHandle([scheduled, completedEvent]));
-    expect(history.events?.[0].eventId).toBe(history.events?.[1].activityTaskCompletedEventAttributes?.scheduledEventId);
-  });
-
-  test("a short PascalCase eventType (already-normalized test fixture data) passes through unchanged", async () => {
-    const history = await fetchNormalizedHistory(makeHandle([{ eventType: "ActivityTaskScheduled" }]));
-    expect(history.events?.[0].eventType).toBe("ActivityTaskScheduled");
-  });
-
-  test("an ISO eventTime string (already-normalized data) round-trips to the same instant", async () => {
-    const history = await fetchNormalizedHistory(makeHandle([{ eventTime: "2026-05-01T00:00:00.000Z" }]));
-    expect(history.events?.[0].eventTime?.toISOString()).toBe("2026-05-01T00:00:00.000Z");
-  });
-
-  test("no events → empty array, not an error", async () => {
-    const history = await fetchNormalizedHistory(makeHandle([]));
-    expect(history.events).toEqual([]);
-  });
-});