saeeol 1.3.0 → 1.3.1

package/test/saeeol/snapshot-cache.test.ts

@@ -0,0 +1,84 @@
+import { test, expect } from "bun:test"
+import { $ } from "bun"
+import { Snapshot } from "../../src/snapshot"
+import { Instance } from "../../src/project/instance"
+import { Filesystem } from "../../src/util/filesystem"
+import * as Log from "@saeeol/core/util/log"
+import { tmpdir } from "../fixture/fixture"
+
+Log.init({ print: false })
+
+async function bootstrap() {
+  return tmpdir({
+    git: true,
+    init: async (dir) => {
+      await Filesystem.write(`${dir}/a.txt`, "A")
+      await Filesystem.write(`${dir}/b.txt`, "B")
+      await $`git add .`.cwd(dir).quiet()
+      await $`git commit --no-gpg-sign -m init`.cwd(dir).quiet()
+    },
+  })
+}
+
+test("diffFull returns cached result for same hash pair", async () => {
+  await using tmp = await bootstrap()
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const before = await Snapshot.track()
+      expect(before).toBeTruthy()
+
+      await Filesystem.write(`${tmp.path}/a.txt`, "MODIFIED")
+      const after = await Snapshot.track()
+      expect(after).toBeTruthy()
+      expect(after).not.toBe(before)
+
+      const first = await Snapshot.diffFull(before!, after!)
+      const second = await Snapshot.diffFull(before!, after!)
+
+      // Should be the exact same array reference (cached)
+      expect(second).toBe(first)
+      expect(first.length).toBeGreaterThan(0)
+    },
+  })
+})
+
+test("diffFull returns empty array when from === to", async () => {
+  await using tmp = await bootstrap()
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const hash = await Snapshot.track()
+      expect(hash).toBeTruthy()
+
+      const result = await Snapshot.diffFull(hash!, hash!)
+      expect(result).toEqual([])
+    },
+  })
+})
+
+test("diffFull concurrent calls for same pair share one result", async () => {
+  await using tmp = await bootstrap()
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const before = await Snapshot.track()
+      expect(before).toBeTruthy()
+
+      await Filesystem.write(`${tmp.path}/a.txt`, "CONCURRENT")
+      const after = await Snapshot.track()
+      expect(after).toBeTruthy()
+
+      // Fire multiple concurrent calls — they should all resolve to the same object
+      const results = await Promise.all([
+        Snapshot.diffFull(before!, after!),
+        Snapshot.diffFull(before!, after!),
+        Snapshot.diffFull(before!, after!),
+      ])
+
+      expect(results[0]).toBe(results[1])
+      expect(results[1]).toBe(results[2])
+      expect(results[0].length).toBeGreaterThan(0)
+    },
+  })
+})

package/test/saeeol/snapshot-freeze-repro.test.ts

@@ -0,0 +1,100 @@
+//
+// Regression test for the freeze bug: before the caps + worker offload,
+// Snapshot.diffFull on a file with tens of thousands of lines could block
+// the thread for minutes. In the TUI, that same thread hosts the Hono
+// server — so the POST /:id/abort endpoint (what ESC fires) never ran.
+//
+// This test proves:
+//   1. A synthetic freeze workload (30k-line file) now completes quickly.
+//   2. The abort endpoint responds within a bounded time while the freeze
+//      workload runs concurrently.
+//   3. A concurrent setInterval keeps ticking — i.e. the event loop keeps
+//      breathing and ESC would be delivered.
+
+import { test, expect, afterEach, mock } from "bun:test"
+import { $ } from "bun"
+import { Instance } from "../../src/project/instance"
+import { Server } from "../../src/server/server"
+import { Session } from "../../src/session/session"
+import { Snapshot } from "../../src/snapshot"
+import { Filesystem } from "../../src/util/filesystem"
+import * as Log from "@saeeol/core/util/log"
+import { disposeAllInstances, tmpdir } from "../fixture/fixture"
+
+Log.init({ print: false })
+
+afterEach(async () => {
+  mock.restore()
+  await disposeAllInstances()
+})
+
+test("pathological diffFull workload finishes quickly and does not block abort", async () => {
+  // 3000-line file that churns every line between snapshots. Before the fix
+  // this ran through structuredPatch at context=MAX_SAFE_INTEGER synchronously
+  // and could take minutes.
+  const v1 = Array.from({ length: 3000 }, (_, i) => `v1_line_${i}`).join("\n") + "\n"
+  const v2 = Array.from({ length: 3000 }, (_, i) => `v2_line_${i}`).join("\n") + "\n"
+
+  await using tmp = await tmpdir({
+    git: true,
+    init: async (dir) => {
+      await Filesystem.write(`${dir}/fat.json`, v1)
+      await $`git add .`.cwd(dir).quiet()
+      await $`git commit --no-gpg-sign -m init`.cwd(dir).quiet()
+    },
+  })
+
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const session = await Session.create({})
+
+      const before = await Snapshot.track()
+      expect(before).toBeTruthy()
+
+      await Filesystem.write(`${tmp.path}/fat.json`, v2)
+      const after = await Snapshot.track()
+      expect(after).toBeTruthy()
+
+      // Kick off a diffFull that exercises the freeze path.
+      const diffPromise = Snapshot.diffFull(before!, after!)
+
+      // Concurrently keep a tick counter running. If the event loop blocks we
+      // will see this count fall behind wall-clock elapsed.
+      let ticks = 0
+      const start = Date.now()
+      const timer = setInterval(() => {
+        ticks++
+      }, 25)
+
+      // Fire an abort request against the Hono app in the middle of the diff.
+      const app = Server.Default().app
+      const abortStart = Date.now()
+      const res = await app.request(`/session/${session.id}/abort`, { method: "POST" })
+      const abortLatency = Date.now() - abortStart
+      expect(res.status).toBe(200)
+      // The abort endpoint must respond well under a second even under load.
+      expect(abortLatency).toBeLessThan(2000)
+
+      const diffs = await diffPromise
+      clearInterval(timer)
+      const total = Date.now() - start
+
+      // The freeze workload must finish in bounded time. Five seconds is
+      // generous even for a slow CI box; without the fix this hangs.
+      expect(total).toBeLessThan(5000)
+      // And we must have ticked at least a few times during the work — proves
+      // the event loop stayed responsive (ESC would actually arrive).
+      expect(ticks).toBeGreaterThan(0)
+
+      // With git-based diff the patch is a real unified diff, not empty.
+      const hit = diffs.find((d) => d.file === "fat.json")
+      expect(hit).toBeDefined()
+      expect(hit!.patch).toMatch(/^diff --git /m)
+      expect(hit!.patch).toContain("-v1_line_0")
+      expect(hit!.patch).toContain("+v2_line_0")
+      expect(hit!.additions).toBeGreaterThan(0)
+      expect(hit!.deletions).toBeGreaterThan(0)
+    },
+  })
+})

package/test/saeeol/snapshot-track-timeout.test.ts

@@ -0,0 +1,519 @@
+//
+// Unit tests for SaeeolSnapshotTrack.wrap — the slow-repo guard that sits
+// on top of Snapshot.track(). These tests inject fake hooks so we don't
+// touch the real Question module or write to the filesystem.
+
+import { describe, expect, test } from "bun:test"
+import { Duration, Effect } from "effect"
+import type { MessageID, SessionID, PartID } from "../../src/session/schema"
+import { SaeeolSnapshotTrack } from "../../src/overlay/snapshot/track"
+
+const SESSION = "ses_test" as SessionID
+const MESSAGE = "msg_test" as MessageID
+
+// Build a fast inner snapshot that resolves immediately with a hash.
+const fastInner = (hash = "deadbeef") => Effect.succeed<string | undefined>(hash)
+
+// Build a slow inner snapshot that resolves after `ms` milliseconds.
+const slowInner = (ms: number, hash = "slowhash") =>
+  Effect.promise(() => new Promise<string | undefined>((resolve) => setTimeout(() => resolve(hash), ms)))
+
+// Build an inner snapshot that never completes unless interrupted.
+const hangInner = () => Effect.promise(() => new Promise<string | undefined>(() => {}))
+
+// Build an inner snapshot that fails with a typed Effect error. The double
+// cast mirrors how the real `Snapshot.track` Effect is shaped: callers see
+// `Effect.Effect<string | undefined>` (error channel `never`), but failures
+// can still flow through because the production code path uses `Effect.catch`
+// to absorb them. Centralizing the cast here keeps per-test code readable.
+const failingInner = (err: Error) =>
+  Effect.fail(err as unknown as never) as unknown as Effect.Effect<string | undefined>
+
+type Event = { kind: "start"; text: string } | { kind: "update"; text: string } | { kind: "end" }
+
+interface Calls {
+  ask: number
+  persist: number
+  progress: Event[]
+}
+
+const makeHooks = (
+  answer: SaeeolSnapshotTrack.Answer | Promise<SaeeolSnapshotTrack.Answer>,
+): { hooks: SaeeolSnapshotTrack.Hooks; calls: Calls } => {
+  const calls: Calls = { ask: 0, persist: 0, progress: [] }
+  let counter = 0
+  const hooks: SaeeolSnapshotTrack.Hooks = {
+    async ask() {
+      calls.ask += 1
+      return answer
+    },
+    async persistDisable() {
+      calls.persist += 1
+    },
+    async startProgress(input: { sessionID: SaeeolSnapshotTrack.ProgressHandle["sessionID"]; messageID: SaeeolSnapshotTrack.ProgressHandle["messageID"]; text: string }) {
+      calls.progress.push({ kind: "start", text: input.text })
+      counter += 1
+      return {
+        sessionID: input.sessionID,
+        messageID: input.messageID,
+        partID: `prt_${counter}` as PartID,
+      }
+    },
+    async updateProgress(input: { handle: SaeeolSnapshotTrack.ProgressHandle; text: string }) {
+      calls.progress.push({ kind: "update", text: input.text })
+    },
+    async endProgress() {
+      calls.progress.push({ kind: "end" })
+    },
+  }
+  return { hooks, calls }
+}
+
+describe("SaeeolSnapshotTrack.wrap", () => {
+  test("returns the hash when inner resolves before the timeout", async () => {
+    const state = SaeeolSnapshotTrack.makeState()
+    const { hooks, calls } = makeHooks("continue")
+
+    const result = await Effect.runPromise(
+      SaeeolSnapshotTrack.wrap({
+        inner: fastInner("fast-hash"),
+        state,
+        sessionID: SESSION,
+        messageID: MESSAGE,
+        hooks,
+        timeoutMs: 1000,
+      }),
+    )
+
+    expect(result).toBe("fast-hash")
+    expect(calls.ask).toBe(0)
+    expect(calls.persist).toBe(0)
+    expect(state.disabledForSession).toBe(false)
+    expect(state.asked).toBe(false)
+  })
+
+  test("returns undefined immediately when already disabled", async () => {
+    const state = SaeeolSnapshotTrack.makeState()
+    state.disabledForSession = true
+    const { hooks, calls } = makeHooks("continue")
+
+    // We pass a hang inner to prove it's never started — if the guard
+    // didn't short-circuit, this test would time out.
+    const result = await Effect.runPromise(
+      SaeeolSnapshotTrack.wrap({
+        inner: hangInner(),
+        state,
+        sessionID: SESSION,
+        messageID: MESSAGE,
+        hooks,
+        timeoutMs: 5,
+      }),
+    )
+
+    expect(result).toBeUndefined()
+    expect(calls.ask).toBe(0)
+  })
+
+  test('timeout + user answer "continue" joins the fiber and returns its value', async () => {
+    const state = SaeeolSnapshotTrack.makeState()
+    const { hooks, calls } = makeHooks("continue")
+
+    const result = await Effect.runPromise(
+      SaeeolSnapshotTrack.wrap({
+        inner: slowInner(80, "finished-late"),
+        state,
+        sessionID: SESSION,
+        messageID: MESSAGE,
+        hooks,
+        timeoutMs: 20,
+        progressDelayMs: 5,
+      }),
+    )
+
+    expect(result).toBe("finished-late")
+    expect(calls.ask).toBe(1)
+    expect(calls.persist).toBe(0)
+    // After a successful "continue" the guard resets `asked` so a subsequent
+    // slow turn still gets the dialog instead of being silently disabled.
+    expect(state.asked).toBe(false)
+    expect(state.disabledForSession).toBe(false)
+  })
+
+  test('timeout + "disable" interrupts, persists, and flips disabledForSession', async () => {
+    const state = SaeeolSnapshotTrack.makeState()
+    const { hooks, calls } = makeHooks("disable")
+
+    const result = await Effect.runPromise(
+      SaeeolSnapshotTrack.wrap({
+        inner: hangInner(),
+        state,
+        sessionID: SESSION,
+        messageID: MESSAGE,
+        hooks,
+        timeoutMs: 10,
+        progressDelayMs: 2,
+      }),
+    )
+
+    expect(result).toBeUndefined()
+    expect(calls.ask).toBe(1)
+    expect(calls.persist).toBe(1)
+    expect(state.disabledForSession).toBe(true)
+    expect(state.asked).toBe(true)
+  })
+
+  test('timeout + "dismissed" interrupts and disables, but does NOT persist', async () => {
+    const state = SaeeolSnapshotTrack.makeState()
+    const { hooks, calls } = makeHooks("dismissed")
+
+    const result = await Effect.runPromise(
+      SaeeolSnapshotTrack.wrap({
+        inner: hangInner(),
+        state,
+        sessionID: SESSION,
+        messageID: MESSAGE,
+        hooks,
+        timeoutMs: 10,
+        progressDelayMs: 2,
+      }),
+    )
+
+    expect(result).toBeUndefined()
+    expect(calls.ask).toBe(1)
+    expect(calls.persist).toBe(0)
+    expect(state.disabledForSession).toBe(true)
+    expect(state.asked).toBe(true)
+  })
+
+  test("timeout without sessionID skips the prompt and disables silently", async () => {
+    const state = SaeeolSnapshotTrack.makeState()
+    const { hooks, calls } = makeHooks("continue")
+
+    const result = await Effect.runPromise(
+      SaeeolSnapshotTrack.wrap({
+        inner: hangInner(),
+        state,
+        hooks,
+        timeoutMs: 10,
+        progressDelayMs: 2,
+      }),
+    )
+
+    expect(result).toBeUndefined()
+    expect(calls.ask).toBe(0)
+    expect(calls.persist).toBe(0)
+    expect(state.disabledForSession).toBe(true)
+    expect(state.asked).toBe(false)
+    // No messageID either → progress indicator is suppressed entirely.
+    expect(calls.progress).toEqual([])
+  })
+
+  test("subsequent call after disable returns undefined without starting the inner", async () => {
+    const state = SaeeolSnapshotTrack.makeState()
+    const { hooks: firstHooks } = makeHooks("disable")
+
+    await Effect.runPromise(
+      SaeeolSnapshotTrack.wrap({
+        inner: hangInner(),
+        state,
+        sessionID: SESSION,
+        messageID: MESSAGE,
+        hooks: firstHooks,
+        timeoutMs: 10,
+        progressDelayMs: 2,
+      }),
+    )
+    expect(state.disabledForSession).toBe(true)
+
+    let innerStarted = false
+    const spyingInner = Effect.sync(() => {
+      innerStarted = true
+      return "should-not-run" as string | undefined
+    })
+    const { hooks: secondHooks, calls: secondCalls } = makeHooks("continue")
+
+    const secondResult = await Effect.runPromise(
+      SaeeolSnapshotTrack.wrap({
+        inner: spyingInner,
+        state,
+        sessionID: SESSION,
+        messageID: MESSAGE,
+        hooks: secondHooks,
+        timeoutMs: 10,
+      }),
+    )
+
+    expect(secondResult).toBeUndefined()
+    expect(innerStarted).toBe(false)
+    expect(secondCalls.ask).toBe(0)
+  })
+
+  test("second slow call after a successful continue re-asks instead of silently disabling", async () => {
+    const state = SaeeolSnapshotTrack.makeState()
+    const { hooks, calls } = makeHooks("continue")
+
+    // First call: slow → ask → continue → finishes
+    const first = await Effect.runPromise(
+      SaeeolSnapshotTrack.wrap({
+        inner: slowInner(80, "hash-1"),
+        state,
+        sessionID: SESSION,
+        messageID: MESSAGE,
+        hooks,
+        timeoutMs: 20,
+        progressDelayMs: 5,
+      }),
+    )
+    expect(first).toBe("hash-1")
+    expect(calls.ask).toBe(1)
+    // Reset semantics: successful continue clears `asked` so a future slow
+    // turn gets the dialog again instead of being silently disabled.
+    expect(state.asked).toBe(false)
+    expect(state.disabledForSession).toBe(false)
+
+    // Second call: still slow → dialog again → user picks continue again → finishes
+    const second = await Effect.runPromise(
+      SaeeolSnapshotTrack.wrap({
+        inner: slowInner(80, "hash-2"),
+        state,
+        sessionID: SESSION,
+        messageID: MESSAGE,
+        hooks,
+        timeoutMs: 20,
+        progressDelayMs: 5,
+      }),
+    )
+    expect(second).toBe("hash-2")
+    expect(calls.ask).toBe(2) // re-asked
+    expect(state.disabledForSession).toBe(false)
+  })
+
+  test("continue path keeps `asked` sticky when the fiber finished with no hash", async () => {
+    const state = SaeeolSnapshotTrack.makeState()
+    const { hooks, calls } = makeHooks("continue")
+
+    // Simulate the fiber eventually completing but with no hash (e.g.
+    // snapshot disabled mid-flight or non-git repo). The continue path waits
+    // for it, so we get undefined back — and we must not reset `asked`,
+    // otherwise repeated failures would keep re-prompting the user every
+    // turn.
+    const noHashInner = Effect.promise(
+      () => new Promise<string | undefined>((resolve) => setTimeout(() => resolve(undefined), 80)),
+    )
+    const first = await Effect.runPromise(
+      SaeeolSnapshotTrack.wrap({
+        inner: noHashInner,
+        state,
+        sessionID: SESSION,
+        messageID: MESSAGE,
+        hooks,
+        timeoutMs: 20,
+        progressDelayMs: 5,
+      }),
+    )
+    expect(first).toBeUndefined()
+    expect(calls.ask).toBe(1)
+    expect(state.asked).toBe(true)
+  })
+
+  test("inner typed failure is caught and returned as undefined", async () => {
+    const state = SaeeolSnapshotTrack.makeState()
+    const { hooks, calls } = makeHooks("continue")
+
+    // Typed failure — mirrors how the real inner `track()` fails, which is
+    // what Effect.catch inside wrap() is designed to handle. Untyped defects
+    // (e.g. rejected Promises without Effect.tryPromise) are NOT caught; they
+    // propagate and surface as test failures.
+    const result = await Effect.runPromise(
+      SaeeolSnapshotTrack.wrap({
+        inner: failingInner(new Error("boom")),
+        state,
+        sessionID: SESSION,
+        messageID: MESSAGE,
+        hooks,
+        timeoutMs: 100,
+      }),
+    )
+
+    expect(result).toBeUndefined()
+    expect(calls.ask).toBe(0)
+    expect(state.disabledForSession).toBe(false)
+  })
+})
+
+describe("SaeeolSnapshotTrack progress indicator", () => {
+  // Strip the braille spinner frame (first Unicode codepoint, plus the
+  // trailing space) so tests can assert on the stable descriptive text
+  // without caring which animation frame landed.
+  const withoutFrame = (text: string) => text.replace(/^[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]\s/, "")
+
+  test("fast path does NOT publish a progress message (avoids UI flash)", async () => {
+    const state = SaeeolSnapshotTrack.makeState()
+    const { hooks, calls } = makeHooks("continue")
+
+    await Effect.runPromise(
+      SaeeolSnapshotTrack.wrap({
+        inner: fastInner("hash"),
+        state,
+        sessionID: SESSION,
+        messageID: MESSAGE,
+        hooks,
+        timeoutMs: 1000,
+      }),
+    )
+
+    // The 500ms default delay means fast snapshots never emit a start.
+    expect(calls.progress).toEqual([])
+  })
+
+  test("slow-but-succeeding path (under timeout) starts then ends the indicator", async () => {
+    const state = SaeeolSnapshotTrack.makeState()
+    const { hooks, calls } = makeHooks("continue")
+
+    await Effect.runPromise(
+      SaeeolSnapshotTrack.wrap({
+        inner: slowInner(200, "late-hash"),
+        state,
+        sessionID: SESSION,
+        messageID: MESSAGE,
+        hooks,
+        timeoutMs: 5_000,
+        progressDelayMs: 5,
+      }),
+    )
+
+    const events = calls.progress
+    expect(events.at(0)?.kind).toBe("start")
+    expect(events.at(-1)?.kind).toBe("end")
+
+    const firstText = events.at(0) as Extract<(typeof events)[number], { text: string }>
+    expect(withoutFrame(firstText.text)).toBe(
+      SaeeolSnapshotTrack.formatProgress(SaeeolSnapshotTrack.PROGRESS_INITIALIZING, "").trim(),
+    )
+
+    // Every "update" event is just an animation tick of the same label — we
+    // intentionally do NOT escalate the text after the timeout; the dialog
+    // carries the "why", and the in-chat indicator stays short and stable.
+    for (const evt of events) {
+      if (evt.kind !== "update") continue
+      expect(withoutFrame(evt.text)).toBe(
+        SaeeolSnapshotTrack.formatProgress(SaeeolSnapshotTrack.PROGRESS_INITIALIZING, "").trim(),
+      )
+    }
+  })
+
+  test("timed-out path keeps the initializing label (no text escalation)", async () => {
+    const state = SaeeolSnapshotTrack.makeState()
+    const { hooks, calls } = makeHooks("continue")
+
+    await Effect.runPromise(
+      SaeeolSnapshotTrack.wrap({
+        inner: slowInner(800, "late-hash"),
+        state,
+        sessionID: SESSION,
+        messageID: MESSAGE,
+        hooks,
+        timeoutMs: 200,
+        progressDelayMs: 5,
+      }),
+    )
+
+    const events = calls.progress
+    expect(events.at(0)?.kind).toBe("start")
+    expect(events.at(-1)?.kind).toBe("end")
+
+    // After the timeout trips, the label should stay on PROGRESS_INITIALIZING.
+    // Every emitted event carries the same descriptive text modulo spinner
+    // frame, proving we never escalated to a second template.
+    const base = SaeeolSnapshotTrack.formatProgress(SaeeolSnapshotTrack.PROGRESS_INITIALIZING, "").trim()
+    for (const evt of events) {
+      if (!("text" in evt)) continue
+      expect(withoutFrame(evt.text)).toBe(base)
+    }
+  })
+
+  test("disable path removes the indicator before returning", async () => {
+    const state = SaeeolSnapshotTrack.makeState()
+    const { hooks, calls } = makeHooks("disable")
+
+    await Effect.runPromise(
+      SaeeolSnapshotTrack.wrap({
+        inner: hangInner(),
+        state,
+        sessionID: SESSION,
+        messageID: MESSAGE,
+        hooks,
+        timeoutMs: 200,
+        progressDelayMs: 5,
+      }),
+    )
+
+    expect(calls.progress.at(-1)).toEqual({ kind: "end" })
+  })
+
+  test("missing messageID suppresses the indicator even when slow", async () => {
+    const state = SaeeolSnapshotTrack.makeState()
+    const { hooks, calls } = makeHooks("continue")
+
+    await Effect.runPromise(
+      SaeeolSnapshotTrack.wrap({
+        inner: slowInner(150, "hash"),
+        state,
+        sessionID: SESSION,
+        hooks,
+        timeoutMs: 5_000,
+        progressDelayMs: 5,
+      }),
+    )
+
+    // No messageID → skip the progress indicator entirely.
+    expect(calls.progress).toEqual([])
+  })
+
+  test("frames cycle through the braille spinner set while animating", async () => {
+    const state = SaeeolSnapshotTrack.makeState()
+    const { hooks, calls } = makeHooks("continue")
+
+    // Run long enough to get multiple animation ticks.
+    await Effect.runPromise(
+      SaeeolSnapshotTrack.wrap({
+        inner: slowInner(500, "hash"),
+        state,
+        sessionID: SESSION,
+        messageID: MESSAGE,
+        hooks,
+        timeoutMs: 5_000,
+        progressDelayMs: 5,
+      }),
+    )
+
+    const textEvents = calls.progress.filter(
+      (e): e is Extract<(typeof calls.progress)[number], { text: string }> => "text" in e,
+    )
+    const frames = new Set<string>()
+    for (const evt of textEvents) {
+      const m = evt.text.match(/^([⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏])/)
+      if (m) frames.add(m[1])
+    }
+    // At least two different frames should have been rendered during the run.
+    expect(frames.size).toBeGreaterThanOrEqual(2)
+  })
+})
+
+describe("SaeeolSnapshotTrack constants", () => {
+  test("TIMEOUT_MS defaults to 10s and respects env override", () => {
+    // The constant is evaluated once at module load, so we can only assert
+    // on the default in this run. The env override is exercised by running
+    // with SAEEOL_SNAPSHOT_TRACK_TIMEOUT_MS, which this test suite does not set.
+    expect(SaeeolSnapshotTrack.TIMEOUT_MS).toBe(10_000)
+  })
+
+  test("exposes stable answer labels", () => {
+    expect(SaeeolSnapshotTrack.ANSWER_CONTINUE).toBe("Continue with snapshots")
+    expect(SaeeolSnapshotTrack.ANSWER_DISABLE).toBe("Disable for this project")
+  })
+})
+
+// Small guard: if Duration is ever swapped out for an incompatible version,
+// this will catch it at compile time.
+void Duration.millis