codex-copilot-dx 0.6.21 → 0.7.1

package/src/profile-routing.mjs

@@ -1,103 +1,3 @@
-import {
-  isClaudeCopilotCatalogEntry,
-  isClaudeCopilotModel,
-} from "./models.mjs";
-import { createRoutePlan } from "./route-plan.mjs";
-
-function catalogData(catalog) {
-  if (Array.isArray(catalog)) return catalog;
-  return Array.isArray(catalog?.data) ? catalog.data : [];
-}
-
-export function profileRouting({ claudeMode = "inherited", claudeConfigured = false } = {}) {
-  const isolated = claudeMode === "isolated" || claudeConfigured === true;
-  return Object.freeze({ responses: "codex", messages: isolated ? "claude" : "codex" });
-}
-
-export function createPmStudioModelRouter({ getCatalog, isClaudeEnabled } = {}) {
-  if (typeof getCatalog !== "function") throw new Error("getCatalog is required");
-  if (typeof isClaudeEnabled !== "function") throw new Error("isClaudeEnabled is required");
-
-  const unset = Symbol("unset");
-  let cachedCatalog = unset;
-  let cachedEnabled = false;
-  let cachedAllowed = new Map();
-  let cachedKnown = new Set();
-  let rebuilds = 0;
-
-  function availability() {
-    const catalog = getCatalog();
-    const enabled = isClaudeEnabled() === true;
-    if (catalog === cachedCatalog && enabled === cachedEnabled) {
-      return { allowed: cachedAllowed, known: cachedKnown };
-    }
-
-    const allowed = new Map();
-    const known = new Set();
-    for (const model of catalogData(catalog)) {
-      const id = String(model?.id || "").trim();
-      if (!id || !isClaudeCopilotCatalogEntry(model)) continue;
-      known.add(id);
-      if (enabled && isClaudeCopilotModel(model) && !allowed.has(id)) allowed.set(id, model);
-    }
-    cachedCatalog = catalog;
-    cachedEnabled = enabled;
-    cachedAllowed = allowed;
-    cachedKnown = known;
-    rebuilds += 1;
-    return { allowed, known };
-  }
-
-  function classify(modelId) {
-    const id = String(modelId || "").trim();
-    const { allowed, known } = availability();
-    if (allowed.has(id)) return "claude";
-    if (known.has(id) || id.toLowerCase().startsWith("claude-")) return "unsupported_claude";
-    return "enterprise";
-  }
-
-  function plan(modelId) {
-    const id = String(modelId || "").trim();
-    const modelType = classify(id);
-    const protocol = "openai-chat-completions";
-    if (modelType === "claude") {
-      return createRoutePlan({
-        disposition: "relay",
-        origin: "ccdx",
-        profile: "claude",
-        protocol,
-        model: id,
-        surface: "pm-studio",
-      });
-    }
-    if (modelType === "unsupported_claude") {
-      return createRoutePlan({
-        disposition: "reject",
-        origin: "ccdx",
-        profile: "claude",
-        protocol,
-        model: id || "unknown",
-        surface: "pm-studio",
-      });
-    }
-    return createRoutePlan({
-      disposition: "native",
-      origin: "pm-studio-native",
-      profile: "enterprise",
-      protocol,
-      model: id || "unknown",
-      surface: "pm-studio",
-    });
-  }
-
-  return Object.freeze({
-    plan,
-    classify,
-    allowedModels() {
-      return [...availability().allowed.values()];
-    },
-    diagnostics() {
-      return { rebuilds, allowed: cachedAllowed.size, known: cachedKnown.size };
-    },
-  });
+export function profileRouting() {
+  return Object.freeze({ responses: "codex" });
 }

package/src/profile-runtime.mjs

@@ -1,11 +1,8 @@
 import {
-  AUTH_PROFILE_CLAUDE,
   AUTH_PROFILE_CODEX,
-  authProfilePaths,
-  profileReauthMessage,
   readAuthProfileCredentials,
 } from "./auth-profile.mjs";
-import { createCopilotClient, defaultCopilotClient } from "./copilot.mjs";
+import { defaultCopilotClient } from "./copilot.mjs";
 import { githubTokenFingerprint } from "./github-identity.mjs";
 
 function safeProfileStatus(credentials) {
@@ -28,75 +25,25 @@ export function createProfileRuntime({
   home,
   codexClient = defaultCopilotClient,
 } = {}) {
-  const unreadableCredentials = () => ({
-    profile: AUTH_PROFILE_CLAUDE,
-    configured: true,
-    valid: false,
-    reason: "credential_read_failed",
-    token: "",
-    identity: null,
-    paths: authProfilePaths(AUTH_PROFILE_CLAUDE, { home }),
-  });
-  const readCredentials = () => {
-    try {
-      return readAuthProfileCredentials(AUTH_PROFILE_CLAUDE, { home });
-    } catch {
-      return unreadableCredentials();
-    }
-  };
-  const credentials = readCredentials();
-  const claudeProfile = safeProfileStatus(credentials);
-  const claudeCredentialFingerprint = credentials.valid
-    ? githubTokenFingerprint(credentials.token)
-    : "";
-  const isClaudeProfileCurrent = () => {
-    if (!claudeCredentialFingerprint) return false;
-    const current = readCredentials();
-    return current.valid === true
-      && githubTokenFingerprint(current.token) === claudeCredentialFingerprint;
-  };
-  let codexCredentialFingerprint = "";
+  let credentials;
   try {
-    const codexCredentials = readAuthProfileCredentials(AUTH_PROFILE_CODEX, { home });
-    if (codexCredentials.valid) {
-      codexCredentialFingerprint = githubTokenFingerprint(codexCredentials.token);
-    }
+    credentials = readAuthProfileCredentials(AUTH_PROFILE_CODEX, { home });
   } catch {
-    // The Codex client remains authoritative if its optional metadata cannot
-    // be inspected; only credential-bound cache reuse is disabled.
-  }
-
-  if (!credentials.configured) {
-    return Object.freeze({
-      codexClient,
-      claudeClient: codexClient,
-      claudeMode: "inherited",
-      claudeProfile,
-      codexCredentialFingerprint,
-      claudeCredentialFingerprint: "",
-      isClaudeProfileCurrent,
-    });
+    credentials = {
+      profile: AUTH_PROFILE_CODEX,
+      configured: true,
+      valid: false,
+      reason: "credential_read_failed",
+      token: "",
+      identity: null,
+    };
   }
 
-  const readRuntimeCredentials = credentials.reason === "credential_read_failed"
-    ? () => credentials
-    : readCredentials;
-  const claudeClient = createCopilotClient({
-    profile: AUTH_PROFILE_CLAUDE,
-    home,
-    tokenPath: credentials.paths.tokenPath,
-    allowTokenDiscovery: false,
-    readGithubCredentials: readRuntimeCredentials,
-    reauthMessage: (reason) => `${reason}\n${profileReauthMessage(AUTH_PROFILE_CLAUDE, { home })}`,
-  });
-
   return Object.freeze({
     codexClient,
-    claudeClient,
-    claudeMode: "isolated",
-    claudeProfile,
-    codexCredentialFingerprint,
-    claudeCredentialFingerprint,
-    isClaudeProfileCurrent,
+    codexProfile: safeProfileStatus(credentials),
+    codexCredentialFingerprint: credentials.valid
+      ? githubTokenFingerprint(credentials.token)
+      : "",
   });
 }

package/src/responses-handler.mjs

@@ -286,7 +286,7 @@ export function createResponsesHandler(options) {
               sendJsonError(res, responseError, statusCode || 500);
               return;
             }
-            await endStreamWithError(res, "responses", error || new Error(errMsg), abort);
+            await endStreamWithError(res, error || new Error(errMsg), abort);
           }, {
             signal: abort.signal,
             abort,

package/src/responses-proxy.mjs

@@ -258,7 +258,7 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
       }
     } catch (e) {
       logRequestFailure("Responses", e, options.abort);
-      await endStreamWithError(res, "responses", e, options.abort);
+      await endStreamWithError(res, e, options.abort);
       return { successful: false, compacted: false };
     } finally {
       await reader.cancel().catch(() => {});

package/src/running-adapter.mjs

@@ -3,11 +3,9 @@ import { localPackageVersion } from "./version.mjs";
 
 export const ADAPTER_HEALTH_PATH = "/_ccdx/health";
 export const ADAPTER_STATUS_PATH = "/_ccdx/status";
-export const ADAPTER_PROTOCOL_VERSION = 2;
+export const ADAPTER_PROTOCOL_VERSION = 3;
 export const ADAPTER_VERSION = localPackageVersion();
-export const ADAPTER_CAPABILITIES = Object.freeze([
-  "pm_studio_split_origin_v1",
-]);
+export const ADAPTER_CAPABILITIES = Object.freeze([]);
 const ADAPTER_INSTANCE_ID = randomUUID();
 
 export function adapterHealthPayload() {

package/src/stream-errors.mjs

@@ -1,19 +1,16 @@
 import { writeOrDrain } from "./http-transport.mjs";
 import { markStreamFailure } from "./stream-performance.mjs";
 
-function streamErrorData(protocol, error, abort) {
+function streamErrorData(error, abort) {
   const code = abort?.reason || error?.code || "upstream_stream_error";
   const message = `${code}: ${error?.message || "Upstream stream failed"}`;
-  if (protocol === "anthropic") {
-    return { type: "error", error: { type: "api_error", message } };
-  }
   return { type: "error", code, message, param: null };
 }
 
-export async function endStreamWithError(res, protocol, error, abort) {
+export async function endStreamWithError(res, error, abort) {
   markStreamFailure();
   if (res.destroyed || res.writableEnded) return;
-  const data = streamErrorData(protocol, error, abort);
+  const data = streamErrorData(error, abort);
   await writeOrDrain(res, `event: error\ndata: ${JSON.stringify(data)}\n\n`).catch(() => false);
   if (!res.destroyed && !res.writableEnded) res.end();
 }

package/src/stream-performance.mjs

@@ -1,7 +1,7 @@
 import { performance } from "node:perf_hooks";
 import { currentRequestContext } from "./request-context.mjs";
 
-const PERFORMANCE_ROUTES = Object.freeze(["responses", "responses_compact", "messages"]);
+const PERFORMANCE_ROUTES = Object.freeze(["responses", "responses_compact"]);
 const TTFT_EDGES_MS = Object.freeze([
   100, 200, 300, 500, 700, 1_000, 1_400, 2_000, 2_800, 4_000,
   5_500, 8_000, 12_000, 16_000, 24_000, 36_000, 60_000, 120_000, 300_000,

package/src/terminal-activity.mjs

@@ -1,14 +1,21 @@
+import {
+  DEFAULT_TERMINAL_ANIMATION_THEME,
+  TERMINAL_ANIMATION_THEMES,
+  TERMINAL_ANIMATION_TRACK_WIDTH,
+  getTerminalAnimationCycleLength,
+  getTerminalAnimationFrameDelay,
+  isTerminalAnimationTheme,
+  renderTerminalAnimationFrame,
+} from "./terminal-animation.mjs";
+
+export { renderCometFrame } from "./terminal-animation.mjs";
+
 const ESC = "\u001b";
 const ERASE_LINE = `\r${ESC}[2K`;
 const HIDE_CURSOR = `${ESC}[?25l`;
 const SHOW_CURSOR = `${ESC}[?25h`;
 
-const TRACK_WIDTH = 20;
-const TAIL_LENGTH = 7;
 const IDLE_DELAY_MS = 800;
-const FRAME_DELAY_MS = 45;
-const LOOP_PAUSE_MS = 200;
-const TAIL_COLORS = [159, 123, 87, 51, 45, 39, 33];
 
 function envFlagEnabled(value) {
   const normalized = String(value || "").trim().toLowerCase();
@@ -21,22 +28,7 @@ function terminalActivityEnabled({ env, output, errorOutput }) {
   if (envFlagEnabled(env.CI) || String(env.TERM || "").toLowerCase() === "dumb") return false;
   if (output?.isTTY !== true || errorOutput?.isTTY !== true) return false;
   const columns = Number(output.columns);
-  return !Number.isFinite(columns) || columns <= 0 || columns >= TRACK_WIDTH + 2;
-}
-
-export function renderCometFrame(position) {
-  let track = "";
-  for (let column = 0; column < TRACK_WIDTH; column += 1) {
-    const distance = position - column;
-    if (distance === 0) {
-      track += `${ESC}[97m:${ESC}[0m`;
-    } else if (distance > 0 && distance <= TAIL_LENGTH) {
-      track += `${ESC}[38;5;${TAIL_COLORS[distance - 1]}m:${ESC}[0m`;
-    } else {
-      track += " ";
-    }
-  }
-  return `[${track}]`;
+  return !Number.isFinite(columns) || columns <= 0 || columns >= TERMINAL_ANIMATION_TRACK_WIDTH + 2;
 }
 
 function disabledIndicator() {
@@ -53,8 +45,13 @@ export function createTerminalActivityIndicator({
   errorOutput = process.stderr,
   consoleObj = console,
   timers = { setTimeout, clearTimeout },
+  theme = DEFAULT_TERMINAL_ANIMATION_THEME,
 } = {}) {
   if (!terminalActivityEnabled({ env, output, errorOutput })) return disabledIndicator();
+  if (!isTerminalAnimationTheme(theme)) throw new TypeError(`Unknown terminal animation theme: ${String(theme)}`);
+
+  const themeMetadata = TERMINAL_ANIMATION_THEMES.find(({ id }) => id === theme);
+  const cycleLength = getTerminalAnimationCycleLength(theme);
 
   const methods = ["log", "warn", "error", "debug"];
   const originals = Object.fromEntries(methods.map((method) => [method, consoleObj[method]]));
@@ -81,9 +78,12 @@ export function createTerminalActivityIndicator({
     clearTimer(frameTimer);
     frameTimer = null;
     framePosition = 0;
-    if (cursorHidden || frameVisible) output.write(`${ERASE_LINE}${SHOW_CURSOR}`);
-    cursorHidden = false;
-    frameVisible = false;
+    try {
+      if (cursorHidden || frameVisible) output.write(`${ERASE_LINE}${SHOW_CURSOR}`);
+    } finally {
+      cursorHidden = false;
+      frameVisible = false;
+    }
   };
 
   const cancelPendingOutput = () => {
@@ -98,20 +98,23 @@ export function createTerminalActivityIndicator({
       clearAnimation();
       return;
     }
-    if (framePosition >= TRACK_WIDTH + TAIL_LENGTH) {
-      output.write(ERASE_LINE);
-      frameVisible = false;
+    if (framePosition >= cycleLength) {
       framePosition = 0;
-      frameTimer = schedule(drawNextFrame, LOOP_PAUSE_MS);
-      return;
+      if (themeMetadata.loopPauseMs > 0) {
+        output.write(ERASE_LINE);
+        frameVisible = false;
+        frameTimer = schedule(drawNextFrame, themeMetadata.loopPauseMs);
+        return;
+      }
     }
 
+    const frameIndex = themeMetadata.startFrame + framePosition;
     const prefix = cursorHidden ? "" : HIDE_CURSOR;
     cursorHidden = true;
     frameVisible = true;
-    output.write(`${prefix}${ERASE_LINE}${renderCometFrame(framePosition)}`);
+    output.write(`${prefix}${ERASE_LINE}${renderTerminalAnimationFrame(theme, frameIndex)}`);
     framePosition += 1;
-    frameTimer = schedule(drawNextFrame, FRAME_DELAY_MS);
+    frameTimer = schedule(drawNextFrame, getTerminalAnimationFrameDelay(theme, frameIndex));
   };
 
   const scheduleAfterIdle = () => {
@@ -161,9 +164,12 @@ export function createTerminalActivityIndicator({
       activeRequests = 0;
       clearTimer(idleTimer);
       idleTimer = null;
-      clearAnimation();
-      for (const method of methods) {
-        if (consoleObj[method] === wrappers[method]) consoleObj[method] = originals[method];
+      try {
+        clearAnimation();
+      } finally {
+        for (const method of methods) {
+          if (consoleObj[method] === wrappers[method]) consoleObj[method] = originals[method];
+        }
       }
     },
   };

package/src/terminal-animation.mjs

@@ -0,0 +1,249 @@
+const ESC = "\u001b";
+
+export const TERMINAL_ANIMATION_TRACK_WIDTH = 20;
+export const DEFAULT_TERMINAL_ANIMATION_THEME = "comet";
+
+const TAIL_LENGTH = 7;
+const TAIL_COLORS = Object.freeze([159, 123, 87, 51, 45, 39, 33]);
+const BRAILLE_GLYPHS = Object.freeze(["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]);
+
+function colorCell(glyph, color) {
+  return `${ESC}[${color}m${glyph}${ESC}[0m`;
+}
+
+function blankTrack() {
+  return Array.from({ length: TERMINAL_ANIMATION_TRACK_WIDTH }, () => " ");
+}
+
+function setCell(cells, index, glyph, color) {
+  if (index < 0 || index >= TERMINAL_ANIMATION_TRACK_WIDTH) return;
+  cells[index] = colorCell(glyph, color);
+}
+
+function drawComet(cells, head, direction, tailLength = TAIL_LENGTH) {
+  for (let distance = tailLength; distance >= 1; distance -= 1) {
+    setCell(cells, head - (direction * distance), ":", `38;5;${TAIL_COLORS[distance - 1]}`);
+  }
+  setCell(cells, head, ":", "97");
+}
+
+function wrapTrack(cells) {
+  return `[${cells.join("")}]`;
+}
+
+function pingPongState(index) {
+  const period = (TERMINAL_ANIMATION_TRACK_WIDTH - 1) * 2;
+  const offset = index % period;
+  return offset < TERMINAL_ANIMATION_TRACK_WIDTH
+    ? { position: offset, direction: 1 }
+    : { position: period - offset, direction: -1 };
+}
+
+const THEME_DEFINITIONS = Object.freeze([
+  Object.freeze({
+    id: "comet",
+    label: "Comet",
+    frameCount: TERMINAL_ANIMATION_TRACK_WIDTH + TAIL_LENGTH,
+    frameDelayMs: 45,
+    loopPauseMs: 200,
+    startFrame: 0,
+    render: renderCometFrame,
+  }),
+  Object.freeze({
+    id: "twin",
+    label: "Twin",
+    frameCount: 26,
+    frameDelayMs: 60,
+    loopPauseMs: 0,
+    startFrame: 5,
+    render(index) {
+      const cells = blankTrack();
+      drawComet(cells, index - 3, 1, 4);
+      drawComet(cells, TERMINAL_ANIMATION_TRACK_WIDTH + 2 - index, -1, 4);
+      return wrapTrack(cells);
+    },
+  }),
+  Object.freeze({
+    id: "shuttle",
+    label: "Shuttle",
+    frameCount: (TERMINAL_ANIMATION_TRACK_WIDTH - 1) * 2,
+    frameDelayMs: 55,
+    loopPauseMs: 0,
+    startFrame: 7,
+    frameDelay(index) {
+      const { position } = pingPongState(index);
+      return position === 0 || position === TERMINAL_ANIMATION_TRACK_WIDTH - 1 ? 160 : 55;
+    },
+    render(index) {
+      const cells = blankTrack();
+      const { position, direction } = pingPongState(index);
+      drawComet(cells, position, direction);
+      return wrapTrack(cells);
+    },
+  }),
+  Object.freeze({
+    id: "chase",
+    label: "Chase",
+    frameCount: TERMINAL_ANIMATION_TRACK_WIDTH + 14,
+    frameDelayMs: 65,
+    loopPauseMs: 0,
+    startFrame: 13,
+    render(index) {
+      const cells = blankTrack();
+      const first = index - 4;
+      let second = first - 11;
+      if (second < -4) second += TERMINAL_ANIMATION_TRACK_WIDTH + 14;
+      drawComet(cells, first, 1, 4);
+      drawComet(cells, second, 1, 4);
+      return wrapTrack(cells);
+    },
+  }),
+  Object.freeze({
+    id: "mirror",
+    label: "Mirror",
+    frameCount: (Math.floor(TERMINAL_ANIMATION_TRACK_WIDTH / 2) - 1) * 2,
+    frameDelayMs: 75,
+    loopPauseMs: 0,
+    startFrame: 3,
+    render(index) {
+      const cells = blankTrack();
+      const half = Math.floor(TERMINAL_ANIMATION_TRACK_WIDTH / 2);
+      const period = (half - 1) * 2;
+      const distance = index < half ? index : period - index;
+      drawComet(cells, half - 1 - distance, -1, 3);
+      drawComet(cells, half + distance, 1, 3);
+      return wrapTrack(cells);
+    },
+  }),
+  Object.freeze({
+    id: "pulse",
+    label: "Pulse",
+    frameCount: 8,
+    frameDelayMs: 115,
+    loopPauseMs: 0,
+    startFrame: 2,
+    render(index) {
+      const cells = blankTrack();
+      const radii = [0, 1, 2, 3, 4, 3, 2, 1];
+      const radius = radii[index];
+      const center = Math.floor((TERMINAL_ANIMATION_TRACK_WIDTH - 1) / 2);
+      setCell(cells, center, ":", "97");
+      for (let distance = 1; distance <= radius; distance += 1) {
+        const color = `38;5;${TAIL_COLORS[distance]}`;
+        setCell(cells, center - distance, ":", color);
+        setCell(cells, center + distance, ":", color);
+      }
+      return wrapTrack(cells);
+    },
+  }),
+  Object.freeze({
+    id: "braille",
+    label: "Braille",
+    frameCount: BRAILLE_GLYPHS.length,
+    frameDelayMs: 80,
+    loopPauseMs: 0,
+    startFrame: 0,
+    render(index) {
+      const cells = blankTrack();
+      setCell(cells, Math.floor(TERMINAL_ANIMATION_TRACK_WIDTH / 2), BRAILLE_GLYPHS[index], `38;5;${TAIL_COLORS[2]}`);
+      return wrapTrack(cells);
+    },
+  }),
+]);
+
+const DEFINITIONS_BY_ID = new Map(THEME_DEFINITIONS.map((theme) => [theme.id, theme]));
+
+export const TERMINAL_ANIMATION_THEMES = Object.freeze(THEME_DEFINITIONS.map(({
+  id,
+  label,
+  frameCount,
+  frameDelayMs,
+  loopPauseMs,
+  startFrame,
+}) => Object.freeze({ id, label, frameCount, frameDelayMs, loopPauseMs, startFrame })));
+
+export function isTerminalAnimationTheme(value) {
+  return typeof value === "string" && DEFINITIONS_BY_ID.has(value);
+}
+
+function themeDefinition(theme) {
+  const definition = DEFINITIONS_BY_ID.get(theme);
+  if (!definition) throw new TypeError(`Unknown terminal animation theme: ${String(theme)}`);
+  return definition;
+}
+
+function normalizedFrameIndex(frameIndex, frameCount) {
+  if (!Number.isSafeInteger(frameIndex)) throw new TypeError("Terminal animation frame index must be an integer");
+  return ((frameIndex % frameCount) + frameCount) % frameCount;
+}
+
+export function getTerminalAnimationCycleLength(theme) {
+  return themeDefinition(theme).frameCount;
+}
+
+export function getTerminalAnimationFrameDelay(theme, frameIndex) {
+  const definition = themeDefinition(theme);
+  const index = normalizedFrameIndex(frameIndex, definition.frameCount);
+  return definition.frameDelay?.(index) ?? definition.frameDelayMs;
+}
+
+export function renderTerminalAnimationFrame(theme, frameIndex) {
+  const definition = themeDefinition(theme);
+  return definition.render(normalizedFrameIndex(frameIndex, definition.frameCount));
+}
+
+export function renderCometFrame(position) {
+  let track = "";
+  for (let column = 0; column < TERMINAL_ANIMATION_TRACK_WIDTH; column += 1) {
+    const distance = position - column;
+    if (distance === 0) {
+      track += `${ESC}[97m:${ESC}[0m`;
+    } else if (distance > 0 && distance <= TAIL_LENGTH) {
+      track += `${ESC}[38;5;${TAIL_COLORS[distance - 1]}m:${ESC}[0m`;
+    } else {
+      track += " ";
+    }
+  }
+  return `[${track}]`;
+}
+
+function outputSupportsPreview(output) {
+  if (output?.isTTY !== true) return false;
+  const columns = Number(output.columns);
+  return !Number.isFinite(columns) || columns <= 0 || columns >= TERMINAL_ANIMATION_TRACK_WIDTH + 2;
+}
+
+export async function playTerminalAnimationPreview(theme, {
+  output = process.stdout,
+  timers = { setTimeout, clearTimeout },
+} = {}) {
+  const definition = themeDefinition(theme);
+  if (!outputSupportsPreview(output)) return false;
+
+  const eraseLine = `\r${ESC}[2K`;
+  let timer = null;
+  let previewStarted = false;
+
+  const wait = (delay) => new Promise((resolve) => {
+    let settled = false;
+    const nextTimer = timers.setTimeout(() => {
+      settled = true;
+      timer = null;
+      resolve();
+    }, delay);
+    timer = settled ? null : nextTimer;
+  });
+
+  try {
+    for (let offset = 0; offset < definition.frameCount; offset += 1) {
+      const frameIndex = definition.startFrame + offset;
+      previewStarted = true;
+      output.write(`${eraseLine}${renderTerminalAnimationFrame(theme, frameIndex)}`);
+      await wait(getTerminalAnimationFrameDelay(theme, frameIndex));
+    }
+    return true;
+  } finally {
+    if (timer) timers.clearTimeout(timer);
+    if (previewStarted) output.write(eraseLine);
+  }
+}