fix(web): drop type casts from terminal font readiness helpers

Replace the cast-laden timeout interface with a DelayScheduler abstraction
so tests can supply a fully typed scheduler without `as` assertions, and
narrow document access through a typed local variable instead of casting
globalThis. Satisfies the strict effect-ts lint that forbids casting
outside src/core/axioms.ts.

Author: konard

packages/app/src/web/terminal-font-readiness.ts

@@ -7,11 +7,14 @@ export type FontReadinessTarget = {
   readonly ready: PromiseLike<object>
 }
 
+export type DelayScheduler = {
+  readonly schedule: (callback: () => void, delayMs: number) => () => void
+}
+
 export type TerminalFontReadinessArgs = {
-  readonly clearTimeoutImpl?: typeof globalThis.clearTimeout
   readonly descriptors: ReadonlyArray<string>
   readonly fonts: FontReadinessTarget | undefined
-  readonly setTimeoutImpl?: typeof globalThis.setTimeout
+  readonly scheduler?: DelayScheduler
   readonly timeoutMs?: number
 }
 
@@ -45,28 +48,29 @@ const ensureFontsLoaded = (
     { concurrency: "unbounded" }
   ).pipe(Effect.asVoid)
 
-type DelayTimers = {
-  readonly clearTimeoutImpl: typeof globalThis.clearTimeout
-  readonly setTimeoutImpl: typeof globalThis.setTimeout
-}
-
 const delayedFallback = (
   timeoutMs: number,
-  timers: DelayTimers
+  scheduler: DelayScheduler
 ): Effect.Effect<void> =>
   Effect.async((resume: (effect: Effect.Effect<void>) => void) => {
-    const handle = timers.setTimeoutImpl(() => {
+    const cancel = scheduler.schedule(() => {
       resume(Effect.void)
     }, timeoutMs)
     return Effect.sync(() => {
-      timers.clearTimeoutImpl(handle)
+      cancel()
     })
   })
 
-const resolveTimers = (args: TerminalFontReadinessArgs): DelayTimers => ({
-  clearTimeoutImpl: args.clearTimeoutImpl ?? globalThis.clearTimeout,
-  setTimeoutImpl: args.setTimeoutImpl ?? globalThis.setTimeout
-})
+const defaultScheduler: DelayScheduler = {
+  schedule: (callback, delayMs) => {
+    const handle = globalThis.setTimeout(callback, delayMs)
+    return () => {
+      globalThis.clearTimeout(handle)
+    }
+  }
+}
+
+const resolveScheduler = (args: TerminalFontReadinessArgs): DelayScheduler => args.scheduler ?? defaultScheduler
 
 const fontReadinessEffect = (
   fonts: FontReadinessTarget,
@@ -77,7 +81,7 @@ const fontReadinessEffect = (
   if (timeoutMs <= 0) {
     return work
   }
-  return Effect.race(work, delayedFallback(timeoutMs, resolveTimers(args)))
+  return Effect.race(work, delayedFallback(timeoutMs, resolveScheduler(args)))
 }
 
 export const awaitTerminalFontReadiness = (
@@ -89,7 +93,11 @@ export const awaitTerminalFontReadiness = (
   return fontReadinessEffect(args.fonts, args)
 }
 
+type GlobalThisWithDocument = {
+  readonly document?: { readonly fonts: FontReadinessTarget }
+}
+
 export const resolveDocumentFontFaceSet = (): FontReadinessTarget | undefined => {
-  const documentRef = (globalThis as { readonly document?: { readonly fonts?: FontReadinessTarget } }).document
-  return documentRef?.fonts
+  const globals: GlobalThisWithDocument = globalThis
+  return globals.document?.fonts
 }

packages/app/tests/docker-git/terminal-font-readiness.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from "@effect/vitest"
 import { Deferred, Effect, Exit, Fiber } from "effect"
 
-import { awaitTerminalFontReadiness } from "../../src/web/terminal-font-readiness.js"
+import { awaitTerminalFontReadiness, type DelayScheduler } from "../../src/web/terminal-font-readiness.js"
 
 type DeferredHandle<A> = {
   readonly deferred: Deferred.Deferred<A, Error>
@@ -51,8 +51,9 @@ const createFontsMock = (
     rejectReady: () => Deferred.fail(readyHandle.deferred, new Error("fonts ready failed")).pipe(Effect.asVoid),
     resolveLoads: () =>
       Effect.gen(function*(_) {
+        const emptyResult: ReadonlyArray<object> = []
         for (const handle of loadHandles) {
-          yield* _(Deferred.succeed(handle.deferred, [] as ReadonlyArray<object>))
+          yield* _(Deferred.succeed(handle.deferred, emptyResult))
         }
       }),
     resolveReady: () => Deferred.succeed(readyHandle.deferred, {}).pipe(Effect.asVoid)
@@ -65,34 +66,35 @@ const makeFontsMock = (): Effect.Effect<FontFaceSetMock> =>
     return createFontsMock(readyHandle, () => makeDeferredHandle<ReadonlyArray<object>>())
   })
 
-type TimersMock = {
-  readonly cleared: ReadonlyArray<object>
-  readonly clearTimeoutImpl: typeof globalThis.clearTimeout
+type SchedulerMock = {
+  readonly cancelCount: () => number
   readonly fire: () => void
-  readonly setTimeoutImpl: typeof globalThis.setTimeout
+  readonly scheduler: DelayScheduler
 }
 
-const createTimers = (): TimersMock => {
+const createScheduler = (): SchedulerMock => {
   const handlers: Array<{ readonly callback: () => void; readonly id: object }> = []
-  const cleared: Array<object> = []
-  return {
-    cleared,
-    clearTimeoutImpl: ((id: object) => {
-      cleared.push(id)
-      const index = handlers.findIndex((handler) => handler.id === id)
-      if (index !== -1) {
-        handlers.splice(index, 1)
+  let cancelCount = 0
+  const scheduler: DelayScheduler = {
+    schedule: (callback) => {
+      const id = {}
+      handlers.push({ callback, id })
+      return () => {
+        cancelCount += 1
+        const index = handlers.findIndex((handler) => handler.id === id)
+        if (index !== -1) {
+          handlers.splice(index, 1)
+        }
       }
-    }) as typeof globalThis.clearTimeout,
+    }
+  }
+  return {
+    cancelCount: () => cancelCount,
     fire: () => {
       const next = handlers.shift()
       next?.callback()
     },
-    setTimeoutImpl: ((callback: () => void) => {
-      const id = {}
-      handlers.push({ callback, id })
-      return id as ReturnType<typeof globalThis.setTimeout>
-    }) as typeof globalThis.setTimeout
+    scheduler
   }
 }
 
@@ -105,7 +107,7 @@ const yieldThrice = Effect.gen(function*(_) {
 type FontReadinessFixture = {
   readonly fiber: Fiber.RuntimeFiber<void>
   readonly fonts: FontFaceSetMock
-  readonly timers: TimersMock
+  readonly timers: SchedulerMock
 }
 
 const startFontReadinessFixture = (
@@ -114,12 +116,11 @@ const startFontReadinessFixture = (
 ): Effect.Effect<FontReadinessFixture> =>
   Effect.gen(function*(_) {
     const fonts = yield* _(makeFontsMock())
-    const timers = createTimers()
+    const timers = createScheduler()
     const baseArgs = {
-      clearTimeoutImpl: timers.clearTimeoutImpl,
       descriptors,
       fonts,
-      setTimeoutImpl: timers.setTimeoutImpl
+      scheduler: timers.scheduler
     }
     const args = timeoutMs === undefined ? baseArgs : { ...baseArgs, timeoutMs }
     const fiber = yield* _(Effect.fork(awaitTerminalFontReadiness(args)))
@@ -144,7 +145,7 @@ describe("terminal font readiness", () => {
       yield* _(fonts.resolveReady())
       yield* _(fonts.resolveLoads())
       yield* _(Fiber.join(fiber))
-      expect(timers.cleared.length).toBe(1)
+      expect(timers.cancelCount()).toBe(1)
     }))
 
   it.effect("swallows load failures so callers still proceed", () =>