@actuarial-ts/compliance 0.6.1 → 0.7.0

package/src/diagnosticReplayReader.ts

@@ -0,0 +1,428 @@
+import { iterateDiagnosticIdentityJson, type DiagnosticIdentityDocument } from "@actuarial-ts/core";
+import {
+  runValidatedMetricDiagnosticsCompact,
+  validateDiagnosticRunInputCompact,
+} from "@actuarial-ts/data";
+import { digestDiagnosticArtifactChunks } from "./diagnosticArtifactStream.js";
+import {
+  createCompactDiagnosticRunIdentity,
+  type CompactDiagnosticArtifactEvidence,
+} from "./diagnosticCompactRun.js";
+import { diagnosticByteView } from "./diagnosticByteView.js";
+import { consumeDiagnosticByteSource } from "./diagnosticByteSource.js";
+import {
+  decodeReplayFrames,
+  MAX_REPLAY_READ_BYTES,
+  REPLAY_TEXT_UNITS,
+  type ReplayFrame,
+} from "./diagnosticReplayFrames.js";
+import { ReplayValueBuilder, type ReplayValueLimits } from "./diagnosticReplayValue.js";
+import type {
+  DiagnosticArtifactDigest,
+  DiagnosticPreparationLineage,
+  DiagnosticRunIdentity,
+} from "./diagnosticRun.js";
+import type { DiagnosticReplayByteSource } from "./diagnosticReplayWriter.js";
+import { createSha256 } from "./sha256Stream.js";
+import {
+  REPLAY_FORMAT,
+  REPLAY_VERSION,
+  badReplay,
+  mismatch,
+  replayArray,
+  replayCancellation,
+  replayFrameBytes,
+  replayLimit,
+  replayRecord,
+  replayToken,
+  decodeArtifactChunk,
+} from "./diagnosticReplayProtocol.js";
+
+/** Host resource policy, not a representation of the SDK's tested capacity. */
+export interface DiagnosticReplayReadLimits {
+  readonly maximumEncodedBytes: number;
+  readonly maximumArtifacts: number;
+  readonly maximumRuns: number;
+  readonly maximumArtifactBytes: number;
+  readonly maximumInputDepth: number;
+  readonly maximumInputNodes: number;
+  readonly maximumInputStringUnits: number;
+  readonly maximumInputTotalStringUnits: number;
+}
+export interface VerifyDiagnosticReplayStreamOptions {
+  readonly limits: DiagnosticReplayReadLimits;
+  readonly signal?: AbortSignal;
+}
+declare const verifiedReplayBrand: unique symbol;
+export interface VerifiedDiagnosticReplayStream {
+  readonly [verifiedReplayBrand]: true;
+  readonly format: "diagnostic-replay";
+  readonly version: 1;
+  readonly artifacts: readonly DiagnosticArtifactDigest[];
+  readonly runs: readonly (DiagnosticRunIdentity & { readonly id: string })[];
+  /** SHA-256 of canonical numbered frames before the final trailer; not a signature. */
+  readonly frameDigest: string;
+}
+const verifiedStreams = new WeakSet<object>();
+
+class ReplayCursor {
+  private sequence = 0;
+  private readonly hash = createSha256();
+  constructor(
+    private readonly iterator: AsyncGenerator<ReplayFrame>,
+    private readonly checkCancellation: () => void,
+  ) {}
+  async next(): Promise<ReplayFrame> {
+    this.checkCancellation();
+    const item = await this.iterator.next();
+    this.checkCancellation();
+    if (item.done) badReplay("Replay ended before its required trailer or section boundary");
+    const frame = item.value;
+    if (
+      frame.length < 2 ||
+      frame[0] !== this.sequence ||
+      !Number.isSafeInteger(frame[0]) ||
+      typeof frame[1] !== "string"
+    )
+      badReplay("Replay frame has an invalid sequence or event");
+    this.sequence++;
+    if (frame[1] !== "end") this.hash.update(replayFrameBytes(frame));
+    return frame.slice(1);
+  }
+  digest() {
+    return this.hash.digest();
+  }
+  async requireEof(): Promise<void> {
+    this.checkCancellation();
+    if (!(await this.iterator.next()).done) badReplay("Unexpected frames after the replay trailer");
+    this.checkCancellation();
+  }
+  async close() {
+    await this.iterator.return(undefined);
+  }
+}
+function event(frame: ReplayFrame, name: string, arity: number): void {
+  if (frame[0] !== name || frame.length !== arity)
+    badReplay(`Expected ${name} with exact arity ${arity}`);
+}
+async function readValue(
+  cursor: ReplayCursor,
+  ending: string,
+  limits: ReplayValueLimits,
+): Promise<unknown> {
+  const builder = new ReplayValueBuilder(limits);
+  for (;;) {
+    const frame = await cursor.next();
+    if (frame[0] === ending) {
+      event(frame, ending, 1);
+      return builder.finish();
+    }
+    builder.push(frame);
+  }
+}
+
+/** Compare complete expected canonical text with bounded candidate fragments. */
+async function compareEvidence(
+  cursor: ReplayCursor,
+  channel: "manifest" | "result",
+  document: DiagnosticIdentityDocument,
+): Promise<void> {
+  const expected = iterateDiagnosticIdentityJson(document);
+  let chunk = "",
+    index = 0,
+    position = 0,
+    done = false;
+  function advance(): void {
+    while (!done && index === chunk.length) {
+      const item = expected.next();
+      done = Boolean(item.done);
+      chunk = item.done ? "" : item.value;
+      index = 0;
+    }
+  }
+  try {
+    for (;;) {
+      const frame = await cursor.next();
+      if (frame[0] === `${channel}-end`) {
+        event(frame, `${channel}-end`, 1);
+        advance();
+        if (!done) mismatch(`${channel} evidence is truncated at code-unit offset ${position}`);
+        return;
+      }
+      event(frame, channel, 2);
+      const text = frame[1];
+      if (typeof text !== "string" || text.length === 0 || text.length > REPLAY_TEXT_UNITS)
+        badReplay("Invalid bounded canonical evidence fragment");
+      let start = 0;
+      while (start < text.length) {
+        advance();
+        if (done) mismatch(`${channel} evidence has extra content at code-unit offset ${position}`);
+        const length = Math.min(text.length - start, chunk.length - index);
+        for (let offset = 0; offset < length; offset++)
+          if (text.charCodeAt(start + offset) !== chunk.charCodeAt(index + offset))
+            mismatch(`${channel} evidence differs at code-unit offset ${position + offset}`);
+        start += length;
+        index += length;
+        position += length;
+      }
+    }
+  } finally {
+    expected.return(undefined);
+  }
+}
+
+function artifactMetadata(value: unknown): DiagnosticArtifactDigest {
+  const item = replayRecord(value, [
+    "id",
+    "scope",
+    "assurance",
+    "algorithm",
+    "value",
+    "byteLength",
+  ]);
+  const id = replayToken(item.id);
+  if (item.scope !== "input" && item.scope !== "preparation") badReplay("Invalid artifact scope");
+  const scope = item.scope;
+  if (item.assurance === "caller-declared") {
+    if (Object.hasOwn(item, "byteLength"))
+      badReplay("Declared artifact cannot claim a computed byte length");
+    return Object.freeze({
+      id,
+      scope,
+      assurance: "caller-declared",
+      algorithm: replayToken(item.algorithm),
+      value: replayToken(item.value),
+    });
+  }
+  if (
+    item.assurance !== "sdk-computed" ||
+    item.algorithm !== "sha256" ||
+    typeof item.value !== "string" ||
+    !/^[a-f0-9]{64}$/.test(item.value) ||
+    typeof item.byteLength !== "number" ||
+    !Number.isSafeInteger(item.byteLength) ||
+    item.byteLength < 0
+  )
+    badReplay("Invalid computed artifact digest metadata");
+  return Object.freeze({
+    id,
+    scope,
+    assurance: "sdk-computed",
+    algorithm: "sha256",
+    value: item.value,
+    byteLength: item.byteLength,
+  });
+}
+
+async function readArtifact(
+  cursor: ReplayCursor,
+  inputLimits: ReplayValueLimits,
+  maximumArtifactBytes: number,
+): Promise<CompactDiagnosticArtifactEvidence> {
+  const artifact = artifactMetadata(await readValue(cursor, "artifact-data", inputLimits));
+  if (artifact.assurance === "caller-declared") {
+    event(await cursor.next(), "artifact-end", 1);
+    return artifact;
+  }
+  async function* bytes() {
+    for (;;) {
+      const frame = await cursor.next();
+      if (frame[0] === "artifact-end") {
+        event(frame, "artifact-end", 1);
+        return;
+      }
+      event(frame, "bytes", 2);
+      yield decodeArtifactChunk(frame[1]);
+    }
+  }
+  const computed = await digestDiagnosticArtifactChunks(
+    {
+      id: artifact.id,
+      scope: artifact.scope,
+      expectedByteLength: artifact.byteLength,
+      maximumByteLength: maximumArtifactBytes,
+    },
+    bytes(),
+  );
+  if (computed.value !== artifact.value)
+    mismatch(`Artifact ${artifact.id} bytes do not match its digest`);
+  return computed;
+}
+
+async function readRun(
+  cursor: ReplayCursor,
+  artifacts: ReadonlyMap<string, CompactDiagnosticArtifactEvidence>,
+  used: Set<string>,
+  limits: ReplayValueLimits,
+) {
+  const item = replayRecord(await readValue(cursor, "input-end", limits), [
+    "id",
+    "input",
+    "inputArtifactIds",
+    "preparationArtifactIds",
+    "preparationLineage",
+  ]);
+  const id = replayToken(item.id);
+  function resolve(value: unknown, scope: "input" | "preparation") {
+    const seen = new Set<string>();
+    return replayArray(value).map((key) => {
+      const token = replayToken(key);
+      if (seen.has(token)) badReplay("Duplicate artifact reference in replay run");
+      seen.add(token);
+      const artifact = artifacts.get(token);
+      if (!artifact || artifact.scope !== scope)
+        badReplay("Replay references an absent artifact or the wrong scope");
+      used.add(token);
+      return artifact;
+    });
+  }
+  const inputArtifacts = resolve(item.inputArtifactIds, "input");
+  const preparationArtifacts = resolve(item.preparationArtifactIds, "preparation");
+  // Candidate raw input always crosses the complete SDK schema, ownership,
+  // preparation and execution-policy boundaries. Parsing does not grant trust.
+  const completedRun = runValidatedMetricDiagnosticsCompact(
+    validateDiagnosticRunInputCompact(item.input),
+  );
+  if (completedRun.status !== "completed")
+    mismatch(`Replay run ${id} is blocked at ${completedRun.stage}`);
+  const provenance = createCompactDiagnosticRunIdentity({
+    completedRun,
+    inputArtifacts,
+    preparationArtifacts,
+    preparationLineage: item.preparationLineage as readonly DiagnosticPreparationLineage[],
+  });
+  await compareEvidence(cursor, "manifest", provenance.manifestIdentityDocument);
+  await compareEvidence(cursor, "result", provenance.resultIdentityDocument);
+  const end = await cursor.next();
+  event(end, "run-end", 4);
+  if (
+    end[1] !== provenance.runFingerprint ||
+    end[2] !== provenance.resultFingerprint ||
+    end[3] !== provenance.runResultFingerprint
+  )
+    mismatch("Replayed fingerprint tags do not match the full verified evidence");
+  return Object.freeze({
+    id,
+    runFingerprint: provenance.runFingerprint,
+    resultFingerprint: provenance.resultFingerprint,
+    runResultFingerprint: provenance.runResultFingerprint,
+  });
+}
+
+/**
+ * Verify all bytes/evidence and independently replay every run, sequentially.
+ * Reads must be <=128 KiB. Required resource limits apply before retaining raw
+ * inputs; results/audits are compared as text, never reconstructed from a file.
+ * Only a final receipt is returned after trailer integrity AND EOF. Hosts must
+ * not treat a partially consumed stream as a valid archive. Cancellation is
+ * cooperative between chunks/phases; use the signal for host I/O as well.
+ */
+export function verifyDiagnosticReplayStream(
+  chunks: DiagnosticReplayByteSource,
+  supplied: VerifyDiagnosticReplayStreamOptions,
+): Promise<VerifiedDiagnosticReplayStream> {
+  const options = replayRecord(supplied, ["limits", "signal"]);
+  const fields = [
+    "maximumEncodedBytes",
+    "maximumArtifacts",
+    "maximumRuns",
+    "maximumArtifactBytes",
+    "maximumInputDepth",
+    "maximumInputNodes",
+    "maximumInputStringUnits",
+    "maximumInputTotalStringUnits",
+  ] as const;
+  const raw = replayRecord(options.limits, fields);
+  const limits = Object.fromEntries(
+    fields.map((key) => [key, replayLimit(raw[key], key)]),
+  ) as unknown as DiagnosticReplayReadLimits;
+  const inputLimits: ReplayValueLimits = {
+    maximumDepth: limits.maximumInputDepth,
+    maximumNodes: limits.maximumInputNodes,
+    maximumStringUnits: limits.maximumInputStringUnits,
+    maximumTotalStringUnits: limits.maximumInputTotalStringUnits,
+  };
+  const checkCancellation = replayCancellation(options.signal);
+  checkCancellation();
+  async function* bounded() {
+    let size = 0;
+    for await (const chunk of consumeDiagnosticByteSource(chunks, checkCancellation)) {
+      checkCancellation();
+      const view = diagnosticByteView(chunk);
+      if (view.length > MAX_REPLAY_READ_BYTES) badReplay("Replay reads must be at most 128 KiB");
+      if (view.length > limits.maximumEncodedBytes - size)
+        badReplay("Replay exceeds the encoded byte limit");
+      size += view.length;
+      yield new Uint8Array(view);
+    }
+  }
+  async function verify(): Promise<VerifiedDiagnosticReplayStream> {
+    const cursor = new ReplayCursor(decodeReplayFrames(bounded()), checkCancellation);
+    let failed = false;
+    try {
+      const header = await cursor.next();
+      event(header, REPLAY_FORMAT, 2);
+      if (header[1] !== REPLAY_VERSION) badReplay("Unsupported diagnostic replay version");
+      const artifacts = new Map<string, CompactDiagnosticArtifactEvidence>();
+      let frame = await cursor.next();
+      while (frame[0] === "artifact") {
+        event(frame, "artifact", 1);
+        if (artifacts.size >= limits.maximumArtifacts)
+          badReplay("Replay exceeds its artifact count limit");
+        const artifact = await readArtifact(cursor, inputLimits, limits.maximumArtifactBytes);
+        if (artifacts.has(artifact.id)) badReplay("Duplicate artifact ID in replay archive");
+        artifacts.set(artifact.id, artifact);
+        frame = await cursor.next();
+      }
+      const runs: (DiagnosticRunIdentity & { readonly id: string })[] = [];
+      const runIds = new Set<string>(),
+        used = new Set<string>();
+      while (frame[0] === "run") {
+        event(frame, "run", 1);
+        if (runs.length >= limits.maximumRuns) badReplay("Replay exceeds its run count limit");
+        const run = await readRun(cursor, artifacts, used, inputLimits);
+        if (runIds.has(run.id)) badReplay("Duplicate run ID in replay archive");
+        runIds.add(run.id);
+        runs.push(run);
+        frame = await cursor.next();
+      }
+      event(frame, "end", 4);
+      if (
+        !runs.length ||
+        frame[1] !== artifacts.size ||
+        frame[2] !== runs.length ||
+        used.size !== artifacts.size
+      )
+        badReplay("Replay trailer counts, run presence or artifact ownership are invalid");
+      const frameDigest = cursor.digest();
+      if (frame[3] !== frameDigest) mismatch("Replay frame integrity digest does not match");
+      await cursor.requireEof();
+      const receipt = Object.freeze({
+        format: REPLAY_FORMAT,
+        version: REPLAY_VERSION,
+        artifacts: Object.freeze([...artifacts.values()]),
+        runs: Object.freeze(runs),
+        frameDigest,
+      }) as VerifiedDiagnosticReplayStream;
+      verifiedStreams.add(receipt);
+      return receipt;
+    } catch (error) {
+      failed = true;
+      throw error;
+    } finally {
+      try {
+        await cursor.close();
+      } catch (cleanupError) {
+        if (!failed) throw cleanupError;
+      }
+    }
+  }
+  return verify();
+}
+
+export function assertVerifiedDiagnosticReplayStream(
+  value: unknown,
+): asserts value is VerifiedDiagnosticReplayStream {
+  if (value === null || typeof value !== "object" || !verifiedStreams.has(value))
+    badReplay("Value is not an authentic fully verified replay stream receipt");
+}

package/src/diagnosticReplayValue.ts

@@ -0,0 +1,269 @@
+import { ComplianceError } from "./errors.js";
+import { REPLAY_TEXT_UNITS, type ReplayFrame } from "./diagnosticReplayFrames.js";
+
+export interface ReplayValueLimits {
+  readonly maximumDepth: number;
+  readonly maximumNodes: number;
+  /** Maximum UTF-16 code units in one key or string value. */
+  readonly maximumStringUnits: number;
+  /** Maximum UTF-16 code units across every key and string value in this input. */
+  readonly maximumTotalStringUnits: number;
+}
+function invalid(message: string): never {
+  throw new ComplianceError("BAD_DIAGNOSTIC_RUN", message, "$.replayInput");
+}
+
+function snapshotLimits(limits: ReplayValueLimits): ReplayValueLimits {
+  if (
+    limits === null ||
+    typeof limits !== "object" ||
+    (Object.getPrototypeOf(limits) !== Object.prototype && Object.getPrototypeOf(limits) !== null)
+  )
+    invalid("Replay value limits must be a plain data object");
+  const fields = [
+    "maximumDepth",
+    "maximumNodes",
+    "maximumStringUnits",
+    "maximumTotalStringUnits",
+  ] as const;
+  const descriptors = Object.getOwnPropertyDescriptors(limits);
+  for (const key of Reflect.ownKeys(descriptors))
+    if (typeof key !== "string" || !fields.some((field) => field === key))
+      invalid("Unknown replay value limit");
+  const owned = Object.create(null) as Record<(typeof fields)[number], number>;
+  for (const key of fields) {
+    const field = descriptors[key];
+    if (!field || !field.enumerable || !("value" in field))
+      invalid("Replay value limits require own enumerable data properties");
+    const value: unknown = field.value;
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1)
+      invalid("Replay value limits must be positive safe integers");
+    owned[key] = value;
+  }
+  return Object.freeze(owned);
+}
+type Container =
+  | { kind: "array"; value: unknown[] }
+  | { kind: "object"; value: Record<string, unknown>; lastKey: string | null; key: string | null };
+
+/**
+ * Reconstruct input only, within explicit host resource bounds. Reconstructed
+ * values still require full SDK validation. Never use this for candidate
+ * result/audit identity channels: those must be compared as text streams.
+ */
+export class ReplayValueBuilder {
+  private readonly limits: ReplayValueLimits;
+  private readonly stack: Container[] = [];
+  private nodes = 0;
+  private assigned = false;
+  private root: unknown;
+  private stringParts: string[] | null = null;
+  private stringUnits = 0;
+  private totalStringUnits = 0;
+  private stringKind: "key" | "value" | null = null;
+  private sealed = false;
+
+  constructor(limits: ReplayValueLimits) {
+    this.limits = snapshotLimits(limits);
+  }
+  private attach(value: unknown) {
+    if (++this.nodes > this.limits.maximumNodes) invalid("Replay input exceeds its node limit");
+    const parent = this.stack.at(-1);
+    if (!parent) {
+      if (this.assigned) invalid("Multiple roots in replay input");
+      this.root = value;
+      this.assigned = true;
+    } else if (parent.kind === "array") parent.value.push(value);
+    else {
+      if (parent.key === null) invalid("Object value is missing its key");
+      Object.defineProperty(parent.value, parent.key, {
+        value,
+        enumerable: true,
+        writable: true,
+        configurable: true,
+      });
+      parent.key = null;
+    }
+  }
+  push(frame: ReplayFrame): void {
+    if (this.sealed) invalid("Replay input builder is finalized");
+    try {
+      this.consume(frame);
+    } catch (error) {
+      this.sealed = true;
+      throw error;
+    }
+  }
+  private consume(frame: ReplayFrame): void {
+    if (!Array.isArray(frame)) invalid("Replay value event must be an array");
+    const [event, payload] = frame;
+    const arity = (expected: number) => {
+      if (frame.length !== expected) invalid("Invalid replay value event arity");
+    };
+    if (this.stringParts !== null) {
+      if (event === "text") {
+        arity(2);
+        if (
+          typeof payload !== "string" ||
+          payload.length === 0 ||
+          payload.length > REPLAY_TEXT_UNITS
+        )
+          invalid("Invalid replay text fragment");
+        if (payload.length > this.limits.maximumStringUnits - this.stringUnits)
+          invalid("Replay input exceeds its string limit");
+        if (payload.length > this.limits.maximumTotalStringUnits - this.totalStringUnits)
+          invalid("Replay input exceeds its total string limit");
+        // Check both budgets before retaining this fragment. Key text counts,
+        // and starting another string never resets the whole-input budget.
+        this.stringUnits += payload.length;
+        this.totalStringUnits += payload.length;
+        this.stringParts.push(payload);
+        return;
+      }
+      if (event !== "string-end") invalid("Replay string was not terminated");
+      arity(1);
+      const text = this.stringParts.join("");
+      const kind = this.stringKind;
+      this.stringParts = null;
+      this.stringKind = null;
+      if (kind === "value") this.attach(text);
+      else {
+        const parent = this.stack.at(-1);
+        if (!parent || parent.kind !== "object" || parent.key !== null)
+          invalid("Unexpected replay object key");
+        if (parent.lastKey !== null && text <= parent.lastKey)
+          invalid("Replay object keys must be strictly increasing and unique");
+        parent.lastKey = text;
+        parent.key = text;
+      }
+      return;
+    }
+    if (event === "string-start") {
+      arity(2);
+      if (payload !== "key" && payload !== "value") invalid("Invalid replay string role");
+      const parent = this.stack.at(-1);
+      if (payload === "key" && (!parent || parent.kind !== "object" || parent.key !== null))
+        invalid("Unexpected replay object key");
+      this.stringParts = [];
+      this.stringKind = payload;
+      this.stringUnits = 0;
+    } else if (event === "object" || event === "array") {
+      arity(1);
+      if (this.stack.length >= this.limits.maximumDepth)
+        invalid("Replay input exceeds its depth limit");
+      const container: Container =
+        event === "array"
+          ? { kind: "array", value: [] }
+          : { kind: "object", value: Object.create(null), lastKey: null, key: null };
+      this.attach(container.value);
+      this.stack.push(container);
+    } else if (event === "end-object" || event === "end-array") {
+      arity(1);
+      const parent = this.stack.at(-1);
+      if (
+        !parent ||
+        event !== `end-${parent.kind}` ||
+        (parent.kind === "object" && parent.key !== null)
+      )
+        invalid("Mismatched or incomplete replay container");
+      this.stack.pop();
+    } else if (event === "scalar") {
+      arity(2);
+      if (
+        payload !== null &&
+        typeof payload !== "boolean" &&
+        !(typeof payload === "number" && Number.isFinite(payload))
+      )
+        invalid("Invalid replay scalar");
+      this.attach(payload);
+    } else if (event === "special-number") {
+      arity(2);
+      // Preserve raw non-finite observations for SDK audit/blocking, not null.
+      if (payload === "NaN") this.attach(NaN);
+      else if (payload === "+Infinity") this.attach(Infinity);
+      else if (payload === "-Infinity") this.attach(-Infinity);
+      else if (payload === "-0") this.attach(-0);
+      else invalid("Invalid special replay number");
+    } else invalid("Unknown replay value event");
+  }
+  finish(): unknown {
+    if (this.sealed) invalid("Replay input builder is finalized");
+    this.sealed = true;
+    if (!this.assigned || this.stack.length || this.stringParts !== null)
+      invalid("Incomplete replay input value");
+    return this.root;
+  }
+}
+
+/** Live read-only input events. The enclosing genuine run owns its snapshots. */
+export function* replayValueFrames(value: unknown): Generator<ReplayFrame> {
+  const active = new Set<object>();
+  function* string(text: string, role: "key" | "value"): Generator<ReplayFrame> {
+    yield ["string-start", role];
+    for (let index = 0; index < text.length; index += REPLAY_TEXT_UNITS)
+      yield ["text", text.slice(index, index + REPLAY_TEXT_UNITS)];
+    yield ["string-end"];
+  }
+  function* visit(value: unknown): Generator<ReplayFrame> {
+    if (typeof value === "string") {
+      yield* string(value, "value");
+      return;
+    }
+    if (typeof value === "number" && (!Number.isFinite(value) || Object.is(value, -0))) {
+      yield [
+        "special-number",
+        Number.isNaN(value)
+          ? "NaN"
+          : value === Infinity
+            ? "+Infinity"
+            : value === -Infinity
+              ? "-Infinity"
+              : "-0",
+      ];
+      return;
+    }
+    if (value === null || typeof value === "number" || typeof value === "boolean") {
+      yield ["scalar", value];
+      return;
+    }
+    if (typeof value !== "object") invalid("Unsupported replay input value");
+    const array = Array.isArray(value);
+    const prototype = Object.getPrototypeOf(value);
+    if (
+      array ? prototype !== Array.prototype : prototype !== null && prototype !== Object.prototype
+    )
+      invalid("Replay input must contain plain data");
+    if (active.has(value)) invalid("Replay input contains a cycle");
+    active.add(value);
+    try {
+      yield [array ? "array" : "object"];
+      if (array) {
+        for (const key of Reflect.ownKeys(value))
+          if (
+            key !== "length" &&
+            (typeof key !== "string" ||
+              !/^(0|[1-9][0-9]*)$/.test(key) ||
+              Number(key) >= value.length)
+          )
+            invalid("Replay input arrays must contain indexed data only");
+        for (let index = 0; index < value.length; index++) {
+          const field = Object.getOwnPropertyDescriptor(value, String(index));
+          if (!field || !("value" in field))
+            invalid("Replay input arrays must contain indexed data");
+          yield* visit(field.value);
+        }
+      } else
+        for (const key of Object.keys(value).sort()) {
+          const field = Object.getOwnPropertyDescriptor(value, key);
+          if (!field || !("value" in field))
+            invalid("Replay input objects must contain data properties");
+          yield* string(key, "key");
+          yield* visit(field.value);
+        }
+      yield [array ? "end-array" : "end-object"];
+    } finally {
+      active.delete(value);
+    }
+  }
+  yield* visit(value);
+}