test(7 packages): 229 more test typecheck errors, and the fetch seam no caller could fill

packages/ai/src/fetch-seam.ts

@@ -0,0 +1,15 @@
+// Single responsibility: the one injectable HTTP call every transport in this package takes.
+//
+// Shared by all three rather than declared three times: both chat providers and the embedder hand
+// a URL and a `RequestInit` to something that answers a `Response`, and three separate spellings
+// of that is three places a test double has to be kept assignable to.
+
+/**
+ * Just the call. `typeof fetch` also carries `preconnect`, which no test double should have to —
+ * and none can supply, so every fake written against `typeof fetch` here needed
+ * `as unknown as typeof fetch` to compile: an option no caller could fill without a double cast.
+ *
+ * The same seam `@ultimat3/cache` (`PurgeFetch`), `@ultimat3/auth` (`OAuthFetch`),
+ * `@ultimat3/mail` (`MailFetch`) and `@ultimat3/scraping` (`ScrapeFetch`) already name.
+ */
+export type AiFetch = (input: string, init: RequestInit) => Promise<Response>;

packages/ai/src/index.ts

@@ -91,6 +91,7 @@ export {
   promptsWithoutEvals,
   resetEvals,
 } from './evals';
+export type { AiFetch } from './fetch-seam';
 export type { CreateGatewayInput, Gateway, GatewayCache, RetryPolicy } from './gateway';
 export { backoffMs, cacheKeyFor, createGateway, DEFAULT_RETRY, isRetryable } from './gateway';
 export type { HiveDef, HiveSplitArgs } from './hive';

packages/ai/src/openai-provider.test.ts

@@ -13,6 +13,7 @@ import { beforeEach, describe, expect, test } from 'bun:test';
 import { anonymousCtx, t } from '@ultimat3/action';
 import { secret } from '@ultimat3/core';
 import { allow } from '@ultimat3/policy';
+import type { AiFetch } from './fetch-seam';
 import { createGateway } from './gateway';
 import { llm } from './llm';
 import { modelSpec } from './models';
@@ -32,16 +33,16 @@ interface Call {
 }
 
 /** Records what left the process and replies with whatever the test wants back. */
-function fakeFetch(calls: Call[], reply: (call: Call, index: number) => Response): typeof fetch {
-  const impl = async (input: unknown, init?: RequestInit): Promise<Response> => {
-    calls.push({
-      url: String(input),
-      headers: { ...(init?.headers as Record<string, string> | undefined) },
-      body: JSON.parse(String(init?.body ?? '{}')) as Record<string, unknown>,
-    });
-    return reply(calls[calls.length - 1] as Call, calls.length - 1);
+function fakeFetch(calls: Call[], reply: (call: Call, index: number) => Response): AiFetch {
+  return async (input, init) => {
+    const call: Call = {
+      url: input,
+      headers: { ...(init.headers as Record<string, string> | undefined) },
+      body: JSON.parse(String(init.body ?? '{}')) as Record<string, unknown>,
+    };
+    calls.push(call);
+    return reply(call, calls.length - 1);
   };
-  return impl as unknown as typeof fetch;
 }
 
 const jsonResponse = (body: unknown, status = 200): Response =>

packages/ai/src/openai-provider.ts

@@ -11,6 +11,7 @@ import type { Secret } from '@ultimat3/core';
 import { isSecret, revealSecret } from '@ultimat3/core';
 import { detailOf, withoutKey } from './error-body';
 import { AiKeyMissingError, AiRequestInvalidError, AiTransportError } from './errors';
+import type { AiFetch } from './fetch-seam';
 import type { ModelId } from './models';
 import { chatCompletionBody } from './openai-body';
 // Imported for its registration side effect: a provider that cannot price what it serves throws
@@ -66,7 +67,7 @@ export interface OpenAiProviderInput {
    */
   readonly name?: string;
   /** Injectable so a test can assert the request body without a network. Defaults to `fetch`. */
-  readonly fetch?: typeof fetch;
+  readonly fetch?: AiFetch;
 }
 
 /**
@@ -197,7 +198,7 @@ class OpenAiProvider implements Provider {
     signal: AbortSignal | undefined,
   ): Promise<Response> {
     const apiKey = this.apiKey();
-    const doFetch = this.config.fetch ?? fetch;
+    const doFetch: AiFetch = this.config.fetch ?? fetch;
     const response = await doFetch(this.url(), {
       method: 'POST',
       headers: {

packages/ai/src/provider-fixture.ts

@@ -1,6 +1,7 @@
 // Shared fixtures for the Anthropic provider suites: a recording fetch, a real SSE body, and the
 // canonical event sequence. Here rather than duplicated because `provider.test.ts` and
 // `provider-stream.test.ts` assert on the same wire and must not drift apart.
+import type { AiFetch } from './fetch-seam';
 import type { StreamChunk } from './provider';
 
 export interface Call {
@@ -10,20 +11,16 @@ export interface Call {
 }
 
 /** Records what left the process and replies with whatever the test wants back. */
-export function fakeFetch(
-  calls: Call[],
-  reply: (call: Call, index: number) => Response,
-): typeof fetch {
-  const impl = async (input: unknown, init?: RequestInit): Promise<Response> => {
+export function fakeFetch(calls: Call[], reply: (call: Call, index: number) => Response): AiFetch {
+  return async (input, init) => {
     const call: Call = {
-      url: String(input),
-      headers: { ...(init?.headers as Record<string, string> | undefined) },
-      body: JSON.parse(String(init?.body ?? '{}')) as Record<string, unknown>,
+      url: input,
+      headers: { ...(init.headers as Record<string, string> | undefined) },
+      body: JSON.parse(String(init.body ?? '{}')) as Record<string, unknown>,
     };
     calls.push(call);
     return reply(call, calls.length - 1);
   };
-  return impl as unknown as typeof fetch;
 }
 
 /** A real SSE body — the provider reads it through the same framing a socket would deliver. */

packages/ai/src/provider-parity.test.ts

@@ -12,6 +12,7 @@
 import { beforeEach, describe, expect, test } from 'bun:test';
 import { secret } from '@ultimat3/core';
 import { AiTransportError } from './errors';
+import type { AiFetch } from './fetch-seam';
 import { OPENAI_MODEL_IDS, registerOpenAiModels } from './openai-models';
 import { openAiProvider } from './openai-provider';
 import { ChatCompletionStream, parseChatCompletion } from './openai-wire';
@@ -44,9 +45,8 @@ const transportError = (value: unknown): AiTransportError => {
 };
 
 /** Records what left the process and replies with whatever the case wants back. */
-function fakeFetch(reply: () => Response): typeof fetch {
-  const impl = async (): Promise<Response> => reply();
-  return impl as unknown as typeof fetch;
+function fakeFetch(reply: () => Response): AiFetch {
+  return async () => reply();
 }
 
 beforeEach(() => {
@@ -226,15 +226,12 @@ describe("the caller's abort signal reaches the socket", () => {
     // flight — which on a long completion is the expensive one. `agent()` puts `ctx.signal` on
     // every request; a provider that drops it makes that guarantee a comment.
     const seen: (AbortSignal | undefined)[] = [];
-    const recording = (): typeof fetch => {
-      const impl = async (_url: string, init?: RequestInit): Promise<Response> => {
-        seen.push(init?.signal ?? undefined);
-        return new Response(JSON.stringify({ error: { message: 'stop here' } }), {
-          status: 503,
-          headers: { 'content-type': 'application/json' },
-        });
-      };
-      return impl as unknown as typeof fetch;
+    const recording = (): AiFetch => async (_url, init) => {
+      seen.push(init.signal ?? undefined);
+      return new Response(JSON.stringify({ error: { message: 'stop here' } }), {
+        status: 503,
+        headers: { 'content-type': 'application/json' },
+      });
     };
 
     const signal = new AbortController().signal;
@@ -282,14 +279,11 @@ describe("the caller's abort signal reaches the socket", () => {
 
   test('a request with no signal attaches none, rather than an explicit undefined', async () => {
     let init: RequestInit | undefined;
-    const impl = async (_url: string, given?: RequestInit): Promise<Response> => {
+    const impl: AiFetch = async (_url, given) => {
       init = given;
       return new Response('{}', { status: 503 });
     };
-    const anthropic = new AnthropicProvider({
-      apiKey: KEY,
-      fetch: impl as unknown as typeof fetch,
-    });
+    const anthropic = new AnthropicProvider({ apiKey: KEY, fetch: impl });
     await anthropic
       .generate({ messages: [{ role: 'user', content: 'hi' }], maxTokens: 16 })
       .catch(() => undefined);

packages/ai/src/provider.ts

@@ -6,6 +6,7 @@
 import type { Money } from '@ultimat3/money';
 import { detailOf, withoutKey } from './error-body';
 import { AiKeyMissingError, AiTransportError } from './errors';
+import type { AiFetch } from './fetch-seam';
 import type { Effort, ModelId, ThinkingMode } from './models';
 import { ANTHROPIC_MODEL_IDS, DEFAULT_MODEL, modelIds, modelSpec, reasoningBody } from './models';
 import { readSse } from './sse';
@@ -180,7 +181,7 @@ export interface AnthropicProviderInput {
   readonly apiKey?: string;
   readonly baseUrl?: string;
   /** Injectable so a test can assert the request body without a network. Defaults to `fetch`. */
-  readonly fetch?: typeof fetch;
+  readonly fetch?: AiFetch;
 }
 
 const ANTHROPIC_VERSION = '2023-06-01';
@@ -303,7 +304,7 @@ export class AnthropicProvider implements Provider {
     if (apiKey === undefined || apiKey === '') {
       throw new AiKeyMissingError({ provider: this.name, envVar: API_KEY_ENV });
     }
-    const doFetch = this.config.fetch ?? fetch;
+    const doFetch: AiFetch = this.config.fetch ?? fetch;
     const url = `${this.config.baseUrl ?? 'https://api.anthropic.com'}/v1/messages`;
     const response = await doFetch(url, {
       method: 'POST',

packages/ai/src/remote-embedder.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, test } from 'bun:test';
 import { isUltimateError } from '@ultimat3/core';
 import { cosine } from './embeddings';
+import type { AiFetch } from './fetch-seam';
 import { RemoteEmbedder } from './remote-embedder';
 
 interface Call {
@@ -9,16 +10,16 @@ interface Call {
   readonly body: { model?: string; input?: string[] };
 }
 
-function fakeFetch(calls: Call[], reply: (call: Call, index: number) => Response): typeof fetch {
-  const impl = async (input: unknown, init?: RequestInit): Promise<Response> => {
-    calls.push({
-      url: String(input),
-      headers: { ...(init?.headers as Record<string, string> | undefined) },
-      body: JSON.parse(String(init?.body ?? '{}')) as Call['body'],
-    });
-    return reply(calls[calls.length - 1] as Call, calls.length - 1);
+function fakeFetch(calls: Call[], reply: (call: Call, index: number) => Response): AiFetch {
+  return async (input, init) => {
+    const call: Call = {
+      url: input,
+      headers: { ...(init.headers as Record<string, string> | undefined) },
+      body: JSON.parse(String(init.body ?? '{}')) as Call['body'],
+    };
+    calls.push(call);
+    return reply(call, calls.length - 1);
   };
-  return impl as unknown as typeof fetch;
 }
 
 /** A provider reply whose vectors encode their own input index, so order is checkable. */
@@ -173,25 +174,25 @@ describe('RemoteEmbedder outbound safety', () => {
 
   test('every request carries an AbortSignal', async () => {
     let seen: unknown;
-    const impl = async (_input: unknown, init?: RequestInit): Promise<Response> => {
-      seen = init?.signal;
+    const impl: AiFetch = async (_input, init) => {
+      seen = init.signal;
       return embeddingsFor(['a'], 0);
     };
     const remote = new RemoteEmbedder({
       name: 'voyage-3',
       dimension: 2,
       apiKey: 'key-1',
       baseUrl: 'https://embeddings.test/v1',
-      fetch: impl as unknown as typeof fetch,
+      fetch: impl,
     });
     await remote.embed(['a']);
     expect(seen).toBeInstanceOf(AbortSignal);
   });
 
   test('a deadline that expires is a coded transport failure, never a bare DOMException', async () => {
-    const impl = async (_input: unknown, init?: RequestInit): Promise<Response> =>
+    const impl: AiFetch = async (_input, init) =>
       await new Promise<Response>((_resolve, reject) => {
-        init?.signal?.addEventListener('abort', () => {
+        init.signal?.addEventListener('abort', () => {
           reject(init.signal?.reason ?? new Error('aborted'));
         });
       });
@@ -201,13 +202,13 @@ describe('RemoteEmbedder outbound safety', () => {
       apiKey: 'key-1',
       baseUrl: 'https://embeddings.test/v1',
       timeoutMs: 5,
-      fetch: impl as unknown as typeof fetch,
+      fetch: impl,
     });
     expect(await codeOf(() => remote.embed(['a']))).toBe('X_AI_PROVIDER_UNAVAILABLE');
   });
 
   test('a response body past the cap is refused rather than buffered', async () => {
-    const impl = async (): Promise<Response> =>
+    const impl: AiFetch = async () =>
       new Response(JSON.stringify({ data: [{ index: 0, embedding: new Array(4096).fill(1) }] }), {
         headers: { 'content-type': 'application/json' },
       });
@@ -217,7 +218,7 @@ describe('RemoteEmbedder outbound safety', () => {
       apiKey: 'key-1',
       baseUrl: 'https://embeddings.test/v1',
       maxResponseBytes: 512,
-      fetch: impl as unknown as typeof fetch,
+      fetch: impl,
     });
     expect(await codeOf(() => remote.embed(['a']))).toBe('X_AI_PROVIDER_UNAVAILABLE');
   });

packages/ai/src/remote-embedder.ts

@@ -10,6 +10,7 @@ import { readWithinLimit } from '@ultimat3/core';
 import type { Embedder } from './embeddings';
 import { normalize } from './embeddings';
 import { AiKeyMissingError, AiTransportError, EmbedderDimMismatchError } from './errors';
+import type { AiFetch } from './fetch-seam';
 
 const API_KEY_ENV = 'EMBEDDINGS_API_KEY';
 const DEFAULT_BASE_URL = 'https://api.voyageai.com/v1';
@@ -44,7 +45,7 @@ export interface RemoteEmbedderInput {
   /** Bytes this process will hold of one response. Defaults to 32 MiB. */
   readonly maxResponseBytes?: number;
   /** Injectable so a test can assert the request body without a network. Defaults to `fetch`. */
-  readonly fetch?: typeof fetch;
+  readonly fetch?: AiFetch;
 }
 
 export class RemoteEmbedder implements Embedder {
@@ -77,7 +78,7 @@ export class RemoteEmbedder implements Embedder {
     if (apiKey === undefined || apiKey === '') {
       throw new AiKeyMissingError({ provider: this.name, envVar: API_KEY_ENV });
     }
-    const doFetch = this.config.fetch ?? fetch;
+    const doFetch: AiFetch = this.config.fetch ?? fetch;
     const timeoutMs = this.config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const url = `${this.config.baseUrl ?? DEFAULT_BASE_URL}/embeddings`;
     let response: Response;

packages/jobs/src/backfill-inspect.test.ts

@@ -59,7 +59,12 @@ describe('inspectBackfills', () => {
   test('a driver that ships no ledger answers an EMPTY list, never a throw', async () => {
     // `x jobs ls` and the jobs panel report the queue; a queue that failed on "no backfills
     // recorded" would be a broken command for a fact nobody asked about.
-    const driver: JobDriver = { ...createMemoryDriver(), backfills: undefined };
+    // The key is REMOVED, not set to `undefined`: `backfills?: BackfillLedger` under
+    // `exactOptionalPropertyTypes` is "absent or a ledger", and a driver that ships no ledger is
+    // one where the property does not exist — which is also the only shape a real driver has.
+    const { backfills: _ledger, ...withoutLedger } = createMemoryDriver();
+    const driver: JobDriver = withoutLedger;
+    expect(Object.hasOwn(driver, 'backfills')).toBe(false);
     expect(await inspectBackfills(driver)).toEqual([]);
   });
 

packages/jobs/src/backfill-pass.test.ts

@@ -102,11 +102,11 @@ describe('one pass', () => {
       // `steps.ts` retains a completed step's output for the whole run, so a checkpoint carrying
       // its page would hold every row the pass has touched until the job ended.
       expect(Object.keys(output).sort()).toEqual(['cursor', 'rows']);
-      expect(typeof output.rows).toBe('number');
-      expect(output.cursor === null || typeof output.cursor === 'string').toBe(true);
+      expect(typeof output['rows']).toBe('number');
+      expect(output['cursor'] === null || typeof output['cursor'] === 'string').toBe(true);
     }
     // The pass ends because the source did, and that is what the last checkpoint records.
-    expect(checkpoints.at(-1)?.cursor).toBeNull();
+    expect(checkpoints.at(-1)?.['cursor']).toBeNull();
   });
 });
 

packages/jobs/src/backfill-throttle.test.ts

@@ -68,6 +68,9 @@ const throttled = (rate: number): Throttled => {
     },
   });
   const definition: BackfillDefinition<Row> = {
+    // REQUIRED, and the same declaration the real `slow-sweep` below makes: the source narrows to
+    // one org itself, so the pass declares no tenant of its own.
+    tenant: 'none',
     name: 'paced-sweep',
     source: () => table.where({ orgId: ORG }),
     handle: ({ rows: page, index }) => {

packages/jobs/src/driver-memory.ts

@@ -38,7 +38,18 @@ export interface MemoryDriverOptions {
 
 const LIVE_STATES = new Set(['ready', 'delayed', 'running', 'suspended']);
 
-export function createMemoryDriver(options: MemoryDriverOptions = {}): JobDriver {
+/**
+ * The in-memory driver's own type: `JobDriver` with `close` REQUIRED.
+ *
+ * `JobDriver.close` is optional because a driver may hold nothing to release. This one always
+ * does — it clears the job map — and every wrapper in the test suite delegates through
+ * `base.close()`. Declaring it here is what makes that delegation a CHECKED call: against a plain
+ * `JobDriver` the only way to write it is `base.close?.()`, which a driver that quietly stopped
+ * shipping a `close` would satisfy in silence.
+ */
+export type MemoryJobDriver = JobDriver & { close(): Promise<void> };
+
+export function createMemoryDriver(options: MemoryDriverOptions = {}): MemoryJobDriver {
   const clock = options.clock ?? systemClock;
   const steps = options.steps ?? createMemoryStepStore();
   const backfills = options.backfills ?? createMemoryBackfillLedger(clock);