tinker-agent 1.0.65

package/src/context/compiled-context-hash.ts

@@ -0,0 +1,138 @@
+import { sha256, stableJsonStringify } from "../model/model-request-preflight";
+import type { CompiledContextEntry, SwapOverride } from "./context-revision";
+import {
+  contentHash,
+  materializeAgentMessages,
+  type ProtocolContextView,
+} from "./protocol-frame";
+
+export function canonicalSequenceHash(
+  canonical: ProtocolContextView,
+  throughOrdinal = canonical.messages.length,
+): string {
+  return sha256(
+    stableJsonStringify({
+      sessionId: canonical.sessionId,
+      frames: canonical.frames
+        .filter((frame) => frame.firstOrdinal <= throughOrdinal)
+        .map((frame) => ({
+          frameId: frame.frameId,
+          kind: frame.kind,
+          state: frame.state,
+          firstOrdinal: frame.firstOrdinal,
+          lastOrdinal: frame.lastOrdinal,
+        })),
+      messages: canonical.messages
+        .filter((message) => message.ordinal <= throughOrdinal)
+        .map((message) => ({
+          frameId: message.frameId,
+          messageId: message.messageId,
+          ordinal: message.ordinal,
+          role: message.role,
+          contentSha256: message.contentSha256,
+        })),
+    }),
+  );
+}
+
+export function renderedMessageHash(
+  entries: readonly CompiledContextEntry[],
+  throughOrdinal = Number.POSITIVE_INFINITY,
+): string {
+  return sha256(
+    stableJsonStringify(
+      entries
+        .filter((entry) => entry.ordinal <= throughOrdinal)
+        .map((entry) => ({
+          frameId: entry.frameId,
+          messageId: entry.messageId,
+          ordinal: entry.ordinal,
+          representation: entry.representation,
+          sourceContentSha256: entry.sourceContentSha256,
+          rendered: renderedMessageDescriptor(entry),
+        })),
+    ),
+  );
+}
+
+export function canonicalRenderedMessageHash(
+  canonical: ProtocolContextView,
+  throughOrdinal = canonical.messages.length,
+): string {
+  const messages = materializeAgentMessages(canonical.messages);
+  const entries = canonical.messages.map((record, index) => {
+    const message = messages[index];
+    if (message === undefined) {
+      throw new Error(`Missing materialized message at index ${index}.`);
+    }
+    return {
+      frameId: record.frameId,
+      messageId: record.messageId,
+      ordinal: record.ordinal,
+      representation: "canonical" as const,
+      sourceContentSha256: record.contentSha256,
+      message,
+    };
+  });
+  return renderedMessageHash(entries, throughOrdinal);
+}
+
+export function activeOverrideManifestHash(overrides: readonly SwapOverride[]): string {
+  return sha256(
+    stableJsonStringify(
+      [...overrides]
+        .sort(
+          (left, right) =>
+            left.ordinal - right.ordinal ||
+            left.messageId.localeCompare(right.messageId),
+        )
+        .map((override) => ({
+          messageId: override.messageId,
+          frameId: override.frameId,
+          ordinal: override.ordinal,
+          originalContentSha256: override.originalContentSha256,
+          renderedContentSha256: override.renderedContentSha256,
+          rendererFormat: "swap-observation-v1",
+        })),
+    ),
+  );
+}
+
+function renderedMessageDescriptor(entry: CompiledContextEntry): unknown {
+  const message = entry.message;
+  switch (message.role) {
+    case "system":
+    case "user":
+      return {
+        role: message.role,
+        contentSha256:
+          entry.representation === "canonical"
+            ? entry.sourceContentSha256
+            : contentHash(message.content),
+      };
+    case "assistant":
+      return {
+        role: message.role,
+        contentSha256: entry.sourceContentSha256,
+        reasoningContentSha256:
+          message.reasoningContent === undefined
+            ? undefined
+            : contentHash(message.reasoningContent ?? null),
+        toolCallsSha256:
+          message.toolCalls === undefined
+            ? undefined
+            : sha256(stableJsonStringify(message.toolCalls)),
+      };
+    case "tool":
+      return {
+        role: message.role,
+        toolCallId: message.toolCallId,
+        providerToolCallId: message.providerToolCallId,
+        name: message.name,
+        contentSha256:
+          entry.representation === "canonical"
+            ? entry.sourceContentSha256
+            : contentHash(message.content),
+      };
+  }
+}

package/src/context/compiled-context-validator.ts

@@ -0,0 +1,209 @@
+import type { AgentMessage } from "../agent/types";
+import { stableJsonStringify } from "../model/model-request-preflight";
+import { formatMessageSource } from "./context-source";
+import type { CompiledRevisionContext, SwapOverride } from "./context-revision";
+import {
+  contentHash,
+  type CanonicalMessageRecord,
+  type ProtocolContextView,
+} from "./protocol-frame";
+import { canonicalSequenceHash, renderedMessageHash } from "./compiled-context-hash";
+
+export class CompiledContextError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "CompiledContextError";
+  }
+}
+
+export class CompiledContextValidator {
+  validateActive(
+    compiled: CompiledRevisionContext,
+    canonical: ProtocolContextView,
+    overrides: readonly SwapOverride[],
+  ): void {
+    const byMessageId = overrideMap(overrides, "Active");
+    this.validate(compiled, canonical, byMessageId);
+  }
+
+  validateProspective(
+    compiled: CompiledRevisionContext,
+    canonical: ProtocolContextView,
+    overrides: readonly SwapOverride[],
+  ): void {
+    const byMessageId = overrideMap(overrides, "Prospective");
+    this.validate(compiled, canonical, byMessageId);
+  }
+
+  private validate(
+    compiled: CompiledRevisionContext,
+    canonical: ProtocolContextView,
+    overrides: ReadonlyMap<string, SwapOverride>,
+  ): void {
+    if (compiled.sessionId !== canonical.sessionId) {
+      fail("Compiled context belongs to another session.");
+    }
+    if (compiled.entries.length !== canonical.messages.length) {
+      fail("Compiled context changed the canonical message count.");
+    }
+    if (
+      compiled.canonicalThroughOrdinal !== canonical.messages.length ||
+      compiled.manifest.frameCount !== canonical.frames.length ||
+      compiled.manifest.messageCount !== compiled.entries.length
+    ) {
+      fail("Compiled context manifest counts do not match canonical history.");
+    }
+
+    const seenFrames = new Set<string>();
+    const seenMessages = new Set<string>();
+    const seenOrdinals = new Set<number>();
+    const consumedOverrides = new Set<string>();
+
+    for (let index = 0; index < compiled.entries.length; index += 1) {
+      const entry = requireItem(compiled.entries, index, "compiled entry");
+      const record = requireItem(canonical.messages, index, "canonical message");
+      if (
+        entry.frameId !== record.frameId ||
+        entry.messageId !== record.messageId ||
+        entry.ordinal !== record.ordinal ||
+        entry.sourceContentSha256 !== record.contentSha256
+      ) {
+        fail(`Compiled entry at ordinal ${record.ordinal} changed canonical identity.`);
+      }
+      if (seenMessages.has(entry.messageId) || seenOrdinals.has(entry.ordinal)) {
+        fail(`Compiled entry identity is duplicated at ordinal ${entry.ordinal}.`);
+      }
+      seenFrames.add(entry.frameId);
+      seenMessages.add(entry.messageId);
+      seenOrdinals.add(entry.ordinal);
+
+      const override = overrides.get(entry.messageId);
+      if (override === undefined) {
+        if (entry.representation !== "canonical") {
+          fail(`Unapproved swapped entry at ordinal ${entry.ordinal}.`);
+        }
+        assertSameMessage(entry.message, record);
+        continue;
+      }
+
+      consumedOverrides.add(entry.messageId);
+      validateOverrideIdentity(override, record);
+      if (record.role !== "tool" || entry.message.role !== "tool") {
+        fail(`Only tool messages may be swapped at ordinal ${entry.ordinal}.`);
+      }
+      if (
+        entry.representation !== "swapped" ||
+        entry.message.toolCallId !== record.toolCallId ||
+        entry.message.providerToolCallId !== record.providerToolCallId ||
+        entry.message.name !== record.name ||
+        entry.message.content !== override.renderedContent
+      ) {
+        fail(
+          `Swapped tool entry changed protocol identity at ordinal ${entry.ordinal}.`,
+        );
+      }
+    }
+
+    if (seenFrames.size !== canonical.frames.length) {
+      fail("Compiled entries do not preserve every protocol frame.");
+    }
+    if (consumedOverrides.size !== overrides.size) {
+      fail("A prospective override does not reference canonical history.");
+    }
+    if (
+      compiled.manifest.canonicalSequenceHash !== canonicalSequenceHash(canonical) ||
+      compiled.manifest.renderedMessageHash !== renderedMessageHash(compiled.entries)
+    ) {
+      fail("Compiled context manifest hash does not match its entries.");
+    }
+  }
+}
+
+function validateOverrideIdentity(
+  override: SwapOverride,
+  record: CanonicalMessageRecord,
+): void {
+  if (
+    override.frameId !== record.frameId ||
+    override.messageId !== record.messageId ||
+    override.ordinal !== record.ordinal ||
+    override.originalContentSha256 !== record.contentSha256
+  ) {
+    fail(`Swap override changed canonical identity at ordinal ${record.ordinal}.`);
+  }
+  const originalBytes = Buffer.byteLength(
+    record.role === "assistant" ? (record.content ?? "") : record.content,
+    "utf8",
+  );
+  const renderedBytes = Buffer.byteLength(override.renderedContent, "utf8");
+  if (
+    override.source !== formatMessageSource(record.messageId) ||
+    override.renderedContentSha256 !== contentHash(override.renderedContent) ||
+    override.originalBytes !== originalBytes ||
+    override.renderedBytes !== renderedBytes ||
+    override.byteSavings !== originalBytes - renderedBytes ||
+    override.byteSavings <= 0
+  ) {
+    fail(`Swap override metadata is invalid at ordinal ${record.ordinal}.`);
+  }
+}
+
+function overrideMap(
+  overrides: readonly SwapOverride[],
+  label: string,
+): ReadonlyMap<string, SwapOverride> {
+  const byMessageId = new Map(
+    overrides.map((override) => [override.messageId, override] as const),
+  );
+  if (byMessageId.size !== overrides.length) {
+    fail(`${label} compiled context contains duplicate overrides.`);
+  }
+  return byMessageId;
+}
+
+function assertSameMessage(actual: AgentMessage, record: CanonicalMessageRecord): void {
+  if (actual.role !== record.role) {
+    fail(`Canonical entry changed message role at ordinal ${record.ordinal}.`);
+  }
+  switch (record.role) {
+    case "system":
+    case "user":
+      if (actual.role !== record.role || actual.content !== record.content) {
+        fail(`Canonical entry changed message content at ordinal ${record.ordinal}.`);
+      }
+      return;
+    case "assistant":
+      if (
+        actual.role !== "assistant" ||
+        actual.content !== record.content ||
+        actual.reasoningContent !== record.reasoningContent ||
+        stableJsonStringify(actual.toolCalls ?? null) !==
+          stableJsonStringify(record.toolCalls ?? null)
+      ) {
+        fail(`Canonical entry changed assistant data at ordinal ${record.ordinal}.`);
+      }
+      return;
+    case "tool":
+      if (
+        actual.role !== "tool" ||
+        actual.toolCallId !== record.toolCallId ||
+        actual.providerToolCallId !== record.providerToolCallId ||
+        actual.name !== record.name ||
+        actual.content !== record.content
+      ) {
+        fail(`Canonical entry changed tool data at ordinal ${record.ordinal}.`);
+      }
+  }
+}
+
+function requireItem<T>(items: readonly T[], index: number, name: string): T {
+  const item = items[index];
+  if (item === undefined) {
+    fail(`Missing ${name} at index ${index}.`);
+  }
+  return item;
+}
+
+function fail(message: string): never {
+  throw new CompiledContextError(message);
+}

package/src/context/context-manager.ts

@@ -0,0 +1,362 @@
+import { ContextBuilder } from "../agent/context-builder";
+import type { ContextMeter, ContextUsageSnapshot } from "../agent/context-meter";
+import type { SessionLedger } from "../agent/session-ledger";
+import type { RuntimeIdFactory } from "../ids/runtime-id";
+import {
+  CommittedPrefixAuditError,
+  type CommittedPrefixAuditor,
+} from "../model/committed-prefix-auditor";
+import type { ModelClient } from "../model/model-client";
+import { promptPrefixFingerprint } from "../model/prompt-prefix-hash";
+import { estimatePromptSegments } from "../model/token-estimator";
+import { SessionError } from "../session/session-errors";
+import type { SessionStore } from "../session/session-store";
+import type { ToolDefinition } from "../tools/types";
+import { canonicalSequenceHash, renderedMessageHash } from "./compiled-context-hash";
+import { CompiledContextError } from "./compiled-context-validator";
+import { swapOnlyPolicyV1 } from "./context-policy";
+import { ContextProtocolError } from "./context-protocol-validator";
+import {
+  ContextRevisionCompiler,
+  ContextRevisionError,
+} from "./context-revision-compiler";
+import {
+  assertPlanBaseCurrent,
+  SwapPlanner,
+  SwapPlanningDiagnosticError,
+  SwapPlanStaleError,
+} from "./swap-planner";
+
+export type ContextCompactionTrigger =
+  | { kind: "manual" }
+  | { kind: "runtime_pressure" }
+  | { kind: "benchmark_forced"; targetTokens: number };
+
+export type ContextCompactionResult =
+  | {
+      status: "unchanged";
+      outcome: "below_target" | "no_eligible_candidates";
+      revisionId: ReturnType<RuntimeIdFactory["createContextRevisionId"]>;
+      revisionNumber: number;
+      totalOverrideCount: number;
+      rawTokensBefore: number;
+      guardedTokensBefore: number;
+      targetTokens: number;
+      planningDurationMs: number;
+      durationMs: number;
+    }
+  | {
+      status: "compacted";
+      outcome: "target_reached" | "insufficient_candidates";
+      previousRevisionId: ReturnType<RuntimeIdFactory["createContextRevisionId"]>;
+      revisionId: ReturnType<RuntimeIdFactory["createContextRevisionId"]>;
+      previousRevisionNumber: number;
+      revisionNumber: number;
+      addedOverrideCount: number;
+      totalOverrideCount: number;
+      originalObservationBytes: number;
+      projectedObservationBytes: number;
+      rawTokensBefore: number;
+      rawTokensAfter: number;
+      guardedTokensBefore: number;
+      guardedTokensAfter: number;
+      targetTokens: number;
+      planHash: string;
+      planningDurationMs: number;
+      validationDurationMs: number;
+      transactionDurationMs: number;
+      activationDurationMs: number;
+      durationMs: number;
+    };
+
+export class ContextManagerError extends Error {
+  constructor(
+    readonly stage: "snapshot" | "plan" | "validate" | "commit" | "activate",
+    readonly code: string,
+    readonly fatal: boolean,
+    readonly committed: boolean,
+    message: string,
+    options?: ErrorOptions,
+  ) {
+    super(message, options);
+    this.name = "ContextManagerError";
+  }
+}
+
+type ModelPreparer = Pick<ModelClient, "prepare">;
+
+export class ContextManager {
+  private readonly planner: SwapPlanner;
+  private readonly compiler = new ContextRevisionCompiler();
+  private readonly requestBuilder = new ContextBuilder();
+
+  constructor(
+    private readonly input: {
+      store: SessionStore;
+      ledger: SessionLedger;
+      model: ModelPreparer;
+      contextMeter: ContextMeter;
+      committedPrefixAuditor: CommittedPrefixAuditor;
+      idFactory: RuntimeIdFactory;
+      tools: () => readonly ToolDefinition[];
+      onUsageUpdated: (snapshot: ContextUsageSnapshot) => Promise<void>;
+    },
+  ) {
+    this.planner = new SwapPlanner(input.model);
+  }
+
+  async compact(trigger: ContextCompactionTrigger): Promise<ContextCompactionResult> {
+    const startedAt = performance.now();
+    let built;
+    let activePrepared;
+    let activeUsage;
+    const tools = this.input.tools();
+    try {
+      this.input.store.assertContextRevisionIdle();
+      built = this.input.ledger.buildCommittedModelRequest(tools);
+      activePrepared = this.input.model.prepare(built.request);
+      activeUsage = this.input.contextMeter.measure(activePrepared);
+    } catch (error) {
+      throw managerError("snapshot", error);
+    }
+
+    let planning;
+    try {
+      planning = this.planner.plan({
+        active: built.compiled,
+        revision: built.revision,
+        activeOverrides: built.activeOverrides,
+        canonical: built.canonical,
+        activePrepared,
+        activeUsage,
+        tools,
+        policy: swapOnlyPolicyV1,
+        trigger: trigger.kind,
+        ...(trigger.kind === "benchmark_forced"
+          ? { forcedTargetTokens: trigger.targetTokens }
+          : {}),
+      });
+    } catch (error) {
+      throw managerError("plan", error);
+    }
+    const planningDurationMs = elapsedMs(startedAt);
+
+    if (
+      planning.outcome === "below_target" ||
+      planning.outcome === "no_eligible_candidates"
+    ) {
+      return Object.freeze({
+        status: "unchanged",
+        outcome: planning.outcome,
+        revisionId: built.revision.revisionId,
+        revisionNumber: built.revision.revisionNumber,
+        totalOverrideCount: built.revision.totalOverrideCount,
+        rawTokensBefore: planning.rawTokensBefore,
+        guardedTokensBefore: planning.guardedTokensBefore,
+        targetTokens: planning.targetTokens,
+        planningDurationMs,
+        durationMs: elapsedMs(startedAt),
+      });
+    }
+    if (planning.outcome === "below_trigger") {
+      throw new ContextManagerError(
+        "plan",
+        "manual_below_trigger",
+        true,
+        false,
+        "Active compaction cannot finish with a shadow-only below-trigger outcome.",
+      );
+    }
+    const plan = planning.plan;
+    if (plan === undefined || plan.addedOverrides.length === 0) {
+      throw new ContextManagerError(
+        "validate",
+        "missing_swap_plan",
+        true,
+        false,
+        "Committable swap planning produced no revision plan.",
+      );
+    }
+
+    const candidateOverrides = [...built.activeOverrides, ...plan.addedOverrides];
+    const validationStartedAt = performance.now();
+    let candidatePrepared;
+    let candidateCompiled;
+    try {
+      candidateCompiled = this.compiler.compileProspective({
+        active: built.compiled,
+        canonical: built.canonical,
+        activeOverrides: built.activeOverrides,
+        addedOverrides: plan.addedOverrides,
+      });
+      const candidate = this.requestBuilder.build({
+        canonical: built.canonical,
+        revision: built.revision,
+        activeOverrides: candidateOverrides,
+        compiled: candidateCompiled,
+        tools,
+      });
+      candidatePrepared = this.input.model.prepare(candidate.request);
+      assertCandidatePrepared(activePrepared, candidatePrepared, plan);
+
+      const current = this.input.ledger.buildCommittedModelRequest(tools);
+      const currentPrepared = this.input.model.prepare(current.request);
+      assertPlanBaseCurrent(plan, {
+        active: current.compiled,
+        revision: current.revision,
+        activeOverrides: current.activeOverrides,
+        activePrepared: currentPrepared,
+      });
+      this.input.store.assertContextRevisionIdle();
+    } catch (error) {
+      throw managerError("validate", error);
+    }
+    const validationDurationMs = elapsedMs(validationStartedAt);
+
+    const revisionId = this.input.idFactory.createContextRevisionId();
+    const transactionStartedAt = performance.now();
+    let revision;
+    try {
+      revision = this.input.store.commitSwapRevision({
+        revisionId,
+        expectedBaseRevisionId: plan.baseRevisionId,
+        expectedBaseRevisionNumber: plan.baseRevisionNumber,
+        expectedCanonicalThroughOrdinal: plan.baseCanonicalThroughOrdinal,
+        expectedBaseOverrideManifestSha256: plan.baseOverrideManifestSha256,
+        policyVersion: plan.policyVersion,
+        rendererFormat: "swap-observation-v1",
+        planHash: plan.planHash,
+        addedOverrides: plan.addedOverrides,
+        nextOverrideManifestSha256: plan.nextOverrideManifestSha256,
+        canonicalSequenceSha256: canonicalSequenceHash(
+          built.canonical,
+          plan.baseCanonicalThroughOrdinal,
+        ),
+        renderedMessageSha256: renderedMessageHash(
+          candidateCompiled.entries,
+          plan.baseCanonicalThroughOrdinal,
+        ),
+      });
+    } catch (error) {
+      throw managerError("commit", error);
+    }
+    const transactionDurationMs = elapsedMs(transactionStartedAt);
+
+    const activationStartedAt = performance.now();
+    try {
+      this.input.contextMeter.startRevision({
+        reason: "context_rebuilt",
+        requestConfigHash: candidatePrepared.requestConfigHash,
+        toolSchemaHash: candidatePrepared.toolSchemaHash,
+      });
+      this.input.committedPrefixAuditor.audit(revisionId, candidatePrepared);
+      const usage = this.input.contextMeter.measure(candidatePrepared);
+      if (usage.source !== "estimated_full") {
+        throw new Error(
+          "First context measurement after revision activation was not a full estimate.",
+        );
+      }
+      await this.input.onUsageUpdated(usage);
+    } catch (error) {
+      throw new ContextManagerError(
+        "activate",
+        errorCode(error),
+        true,
+        true,
+        "Context revision committed but runtime activation failed.",
+        { cause: error },
+      );
+    }
+    const activationDurationMs = elapsedMs(activationStartedAt);
+
+    return Object.freeze({
+      status: "compacted",
+      outcome: planning.outcome,
+      previousRevisionId: built.revision.revisionId,
+      revisionId,
+      previousRevisionNumber: built.revision.revisionNumber,
+      revisionNumber: revision.revisionNumber,
+      addedOverrideCount: plan.addedOverrides.length,
+      totalOverrideCount: revision.totalOverrideCount,
+      originalObservationBytes: planning.originalObservationBytes,
+      projectedObservationBytes: planning.projectedObservationBytes,
+      rawTokensBefore: plan.rawTokensBefore,
+      rawTokensAfter: plan.rawTokensAfter,
+      guardedTokensBefore: plan.guardedTokensBefore,
+      guardedTokensAfter: plan.guardedTokensAfter,
+      targetTokens: plan.targetTokens,
+      planHash: plan.planHash,
+      planningDurationMs,
+      validationDurationMs,
+      transactionDurationMs,
+      activationDurationMs,
+      durationMs: elapsedMs(startedAt),
+    });
+  }
+}
+
+function assertCandidatePrepared(
+  active: ReturnType<ModelPreparer["prepare"]>,
+  candidate: ReturnType<ModelPreparer["prepare"]>,
+  plan: NonNullable<ReturnType<SwapPlanner["plan"]>["plan"]>,
+): void {
+  const rawTokens = estimatePromptSegments(candidate.promptSegments).totalTokens;
+  const fingerprint = promptPrefixFingerprint(candidate);
+  if (
+    candidate.provider !== active.provider ||
+    candidate.model !== active.model ||
+    candidate.requestConfigHash !== active.requestConfigHash ||
+    candidate.toolSchemaHash !== active.toolSchemaHash ||
+    candidate.requestMaxOutputTokens !== active.requestMaxOutputTokens ||
+    rawTokens !== plan.rawTokensAfter ||
+    fingerprint.prefixHash !== plan.projectedPrefixHash ||
+    plan.rawTokensAfter >= plan.rawTokensBefore ||
+    plan.guardedTokensAfter >= plan.guardedTokensBefore
+  ) {
+    throw new Error("Prepared candidate does not match its validated swap plan.");
+  }
+}
+
+function managerError(
+  stage: ContextManagerError["stage"],
+  error: unknown,
+): ContextManagerError {
+  if (error instanceof ContextManagerError) {
+    return error;
+  }
+  const fatal = isFatalContextError(error) || stage === "commit";
+  const diagnostic = error instanceof SwapPlanningDiagnosticError;
+  return new ContextManagerError(
+    stage,
+    diagnostic ? error.code : errorCode(error),
+    fatal,
+    false,
+    error instanceof Error ? error.message : `Context compaction failed at ${stage}.`,
+    { cause: error },
+  );
+}
+
+function isFatalContextError(error: unknown): boolean {
+  return (
+    error instanceof ContextProtocolError ||
+    error instanceof ContextRevisionError ||
+    error instanceof CompiledContextError ||
+    error instanceof SwapPlanStaleError ||
+    error instanceof CommittedPrefixAuditError ||
+    error instanceof SessionError
+  );
+}
+
+function errorCode(error: unknown): string {
+  if (error instanceof SessionError) {
+    return error.code;
+  }
+  if (error instanceof Error) {
+    return error.name;
+  }
+  return "CONTEXT_COMPACTION_FAILED";
+}
+
+function elapsedMs(startedAt: number): number {
+  return Math.round((performance.now() - startedAt) * 100) / 100;
+}