@terreno/jobs 57.20.0 → 57.22.0

package/CHANGELOG.md

@@ -20,6 +20,87 @@ Upgrade notes for consumer action live in [`mcp-server/src/docs/upgrades/`](mcp-
 
 Unreleased changes live in [`changelog/unreleased/`](changelog/unreleased/). Add one Markdown file per feature (see that directory's README) instead of editing this section.
 
+## [57.22.0] - 2026-11-03
+
+Upgrade note: [`mcp-server/src/docs/upgrades/57.22.0.md`](mcp-server/src/docs/upgrades/57.22.0.md).
+
+### Breaking
+
+- `@terreno/ai` no longer integrates with Langfuse. The built-in observability prompt registry, traces, and review queue (`ObservabilityApp` with `createLocalObservabilityPlugin()`) replace it. Removed exports: `LangfuseApp`, `LangfuseCache`, `getCached`, `setCached`, `invalidateCache`, `initLangfuseClient`, `getLangfuseClient`, `isLangfuseInitialized`, `shutdownLangfuseClient`, `compilePrompt`, `createPrompt`, `getPrompt`, `invalidatePromptCache`, `initTracing`, `shutdownTracing`, `createTelemetryConfig`, `preparePromptForAI`, and the types `ChatMessage`, `GetPromptOptions`, `LangfuseAppOptions`, `LangfuseCachedPrompt`, `PaginatedResult`, `PreparePromptResult`, `PromptListItem`, `ScoreSubmission`, `ScoringFunction`, `TelemetrySettings`, `TraceListItem`. The `@terreno/ai/langfuseApp` and `@terreno/ai/langfuseClient` subpath exports are gone, along with the `@langfuse/client`, `@langfuse/otel`, and `@opentelemetry/*` dependencies of `@terreno/ai`.
+- `addGptRoutes` drops `langfuseSystemPromptName`; use `systemPromptName` (a registry prompt) instead. Chat turns no longer set `experimental_telemetry`.
+- `ControlPrimary` is now only `"local"`.
+- The example backend no longer reads `LANGFUSE_SECRET_KEY`, `LANGFUSE_PUBLIC_KEY`, `LANGFUSE_BASE_URL`, `LANGFUSE_ORGANIZATION`, `LANGFUSE_PROJECT`, or `LANGFUSE_PROJECT_ID`. Deploys (`.github/workflows/cd.yml`, `scripts/ci/gcp-deploy.sh`) no longer mount the Langfuse secrets, and `infra/flourish/main.tf` drops the `backend_secret_langfuse_secret_key` and `backend_secret_langfuse_public_key` modules, so the next `terraform apply` deletes those two Secret Manager secrets. Deploy a revision without the mounts before applying.
+
+### Added
+
+- `addGptRoutes` accepts `systemPromptName` and `systemPromptLabel`. A chat turn prepends that observability registry prompt to the system prompt and records its version on the trace.
+- The example chat reads `chat-assistant` and the `generate_joke` tool reads `joke-generator` from the observability prompt registry.
+- `bun run backend:seed` fills every AI Observability screen: labelled prompt versions for `example-summarize`, `joke-generator`, and `chat-assistant`, golden datasets, finished experiments, traces with scores, and review items in every status. Run it on an existing database with the `seedAiObservabilityDemo` admin script.
+- Review batches: pick a human question set and press **Grab 10 recent traces** to give reviewers a fixed set of inputs and outputs (`POST /ai/observability/review/batches`).
+- The review item screen shows one input, one output, and every question as Yes / No rows. On web, `Y` / `N` answer the highlighted question, `Enter` submits and moves to the next batch item, and `S` skips. Evaluator dimensions accept a reviewer `question`.
+- Run any LLM judge over a batch and see overall and per-question agreement with the human answers, plus a list of disagreements (`POST /ai/observability/review/batches/:id/judgeRuns`).
+- The AI observability seed adds the `summary-review-questions` question set, two judges for it, and a 10-item batch with 8 answers where one judge agrees 97% and the other 78%.
+- Observability registry prompts can reference other prompts with `{{> base-rules}}`, `{{> base-rules label=staging}}`, or `{{> base-rules version=3}}` (default label `production`). Shared instructions live in one prompt; `PromptRegistry.get`, the playground, experiments, and judges use the resolved text.
+- Every reference must resolve when it is saved. Creating a prompt, saving a version, and moving a label return 400 `Invalid prompt reference` for a malformed tag, an unknown prompt or version, or a label the referenced prompt does not have yet, 400 `Prompt reference cycle` when the change would make prompts include each other, and 400 `Prompt references nested too deeply` when it would nest the prompt, or any prompt that includes it, more than 5 levels.
+- Traces stay named after the called prompt. `ObsTrace.prompts` lists it first, then each shared prompt version it pulled in, marked with `includedBy`. `PromptVersionRef.includes` and harness prompt refs carry the same list.
+
+### Fixed
+
+- Review queue: `Y` and `N` answer the highlighted question when a Yes/No segment is focused. **What the AI was given** and **What the AI wrote** are headings above the field cards.
+- Review batches: **Save batch** sits on the New batch card. Search and **More filters** share a baseline.
+- Prompt hub: description, folder, and tags sit on the Versions screen with the editor. System and template fields explain what to write.
+- Evaluator detail loads the judge prompt `outputSchema` (so helpfulness no longer reports a missing dimension) and experiment rows open that experiment.
+
+## [57.21.0] - 2026-11-01
+
+Upgrade note: [`mcp-server/src/docs/upgrades/57.21.0.md`](mcp-server/src/docs/upgrades/57.21.0.md).
+
+### Breaking
+
+- The `terreno-scan` plugin is now `terreno-loop`, and its skills are renamed from `terreno-scan-*` to `terreno-loop-*`. The resident loop `terreno-scan-loop` is now `terreno-loop-run`: `/terreno-loop:run` in Claude Code, `/terreno-loop-run` in Cursor, `$terreno-loop-run` in Codex. Claude Code moves existing installs over through the marketplace `renames` entry. In Cursor and Codex, uninstall `terreno-scan` and install `terreno-loop`. Campaign state stays at `.terreno/scan/<goal>.json`, so campaigns already in progress resume.
+
+### Added
+
+- `@terreno/admin-spa` serves an MCP OAuth consent screen at `/console/oauth/consent`, so a backend with no product frontend can set `mcpOAuth.consentUrl` to `${issuer}/console/oauth/consent`. Any signed-in user can approve or deny a request with their Better Auth session; signed-out users sign in and return through the login screen's new `returnTo` parameter, which accepts only in-app paths.
+- Claude Code plugins now publish to npm with every release, as `@terreno/agent-plugin` and `@terreno/agent-plugin-loop`. A new `terreno-releases` marketplace installs them at the latest stable release. To pin one release, add `TerrenoLabs/terreno#<version>` instead. See [Install agent skills](docs/how-to/install-agent-skills.md#pick-a-channel).
+- The generated Claude plugin manifest no longer pins `version`. Before this change, plugins installed from the `TerrenoLabs/terreno` marketplace stayed on the `2.12.0` copy, because their version never changed. They now update on every commit. Run `/plugin update terreno@terreno-plugins` once to leave `2.12.0`.
+- The `terreno-planning` lifecycle plugin (2.13.0) plans e2e tests and manual regression cases in every IP:
+
+  - Grow requires `## E2E tests` and `## Regression cases` sections (either may be `None — <reason>`), read from the e2e guide at `docs/testing/e2e.md` or a `## Testing conventions` override in AGENTS.md or CLAUDE.md.
+  - Regression cases stay minimal: most features add none. A case is only for what a developer or QA must check by hand, such as push notifications, and Roast fails one that repeats an existing case.
+  - Pick writes each planned spec in the task that delivers it, and Roast runs it; a missing or failing row is `FAIL`.
+  - Brew gates on every planned spec and merges regression cases into `docs/regression/<area>.md` with the next free ID.
+  - Taste re-checks both sections after behaviour-changing fixes and renumbers regression ID collisions with `master`.
+  - `bun run check:lifecycle-skills` enforces these phrases in every stage.
+  - New `backfill-regression` skill proposes manual regression cases one area at a time and writes only the sets the human approves.
+  - A consumer opts out of manual regression suites with `Regression suites | none` in its `## Testing conventions` table.
+- The `terreno-planning` lifecycle plugin (2.14.0) grows an end-user guide with every feature:
+
+  - Every IP has a `## User guide` section listing the guide pages it adds, updates, or retires, or `None — <reason>`. Pages live in `docs/user-guide/<area>/<feature>.md`, one feature per page, with `title`, `audience`, `platforms`, and `questions` frontmatter that chat agents use to answer "how do I…" questions.
+  - Pick writes each page in the task that ships the feature, Roast checks it against the shipped screens, Brew gates on it and the index, and Taste keeps it current after fixes.
+  - A repo opts out with `| User guide | none — <reason> |` in a `## User guide conventions` table in AGENTS.md or CLAUDE.md.
+  - New `backfill-user-guide` skill drafts pages for features that shipped without one, one area at a time, and writes only the pages the human approves.
+  - `bun run check:user-guide` validates the pages and index (CI `repo-policies`); `--uncovered <app dir>` lists screens no page names.
+  - Terreno's own guide covers the example app's main features.
+- `@terreno/api`: opt-in `mcpRequestLog` on `TerrenoApp` records one metadata-only `McpRequestLog` row per MCP tool call (tool, user, credential, service token or OAuth client, duration, outcome, error class; never arguments, results, or error text), expiring after `retentionDays` (default 30).
+- `@terreno/api`: opt-in `mcpToolSettings` on `TerrenoApp` registers every MCP tool in `McpToolSetting` at startup; tools an admin switches off are hidden from `tools/list` and rejected by `tools/call`.
+- `@terreno/api`: deleting an `McpOAuthToken` row revokes its whole connection (token family) and keeps the rows. New `McpOAuthToken.revokeAllForUser` and `McpServiceToken.revokeAllForUser`.
+- `@terreno/admin-backend`: `mcpAdminModels()` adds MCP admin screens (service tokens, OAuth clients, OAuth connections, request log, tool switches), `mcpAdminStatements` for RBAC, and `mcpAdminScripts()` adds `mcp-sign-out-everywhere`. See [Manage MCP from the admin panel](docs/how-to/manage-mcp-in-admin.md).
+- Docs: [Expose an MCP server safely](docs/how-to/expose-mcp-server-safely.md) (OAuth, service tokens, Cloudflare Tunnel, Access) and the `bootstrap-mcp-server` skill for a single-binary MCP server with the admin console embedded.
+- Every workspace package has a real-process smoke test and an e2e page:
+
+  - Each package's `e2e/smoke.ts` (or `smoke.spec.ts` for browser packages) runs its built output through its public entry: a server on a real port, the compiled binary, or a page in Chromium. `bun run --cwd <package> smoke` runs one; `bun run smoke` runs them all and prints each package's time. The CircleCI `smoke` job runs them on every package change.
+  - `@terreno/test` adds the smoke helpers `smokeMongoUri()`, `spawnUntilReady()`, `spawnExampleBackend()`, `runBin()`, and `freePort()`.
+  - The [E2E testing guide](docs/testing/e2e.md) explains the test tiers and links one page per package under `docs/testing/e2e/`.
+  - Manual regression cases live in `docs/regression/<area>.md`, one file per area, and `bun run check:regression-suites` validates them.
+  - example-frontend's smoke serves a web export that `bun run --cwd example-frontend export:smoke` builds once with a placeholder API URL; the smoke swaps in a `freePort()` API URL as it serves the bundle, so the 30 s smoke no longer rebuilds the export. `spawnUntilReady()` takes `stopGraceMs`, and `spawnExampleBackend()` stops example-backend after 0.5 s instead of 5 s.
+- Every workspace package has a `typecheck` script that runs `tsc` over source and test files through a new `tsconfig.typecheck.json`. Root `bun run lint` ends with `bun run typecheck`, and CircleCI runs it in a new `typecheck` job. Test files that had type errors were fixed.
+
+### Changed
+
+- `@terreno/api`: deleting an `McpOAuthToken` row with document or query `deleteOne` now revokes that row's whole token family (the connection) and keeps the rows instead of removing one pair. `deleteMany` is unchanged.
+- `@terreno/ui`: new `theme.field` tokens (`background`, `backgroundDisabled`, `border`, `borderFocus`, `borderError`, `borderDisabled`) style form inputs. `TextField`, `SelectField`, `DateTimeField`, `HeightField`, and `OtpField` read them instead of `surface.base` and `border.dark`. Defaults equal the old colors, but overriding `surface` or `border` no longer recolors those fields; use `setTheme({field: ...})`.
+
 ## [57.20.0] - 2026-10-30
 
 Upgrade note: [`mcp-server/src/docs/upgrades/57.20.0.md`](mcp-server/src/docs/upgrades/57.20.0.md).

package/biome.jsonc

@@ -6,6 +6,7 @@
       "package.json",
       "src/**/*.ts",
       "src/**/*.tsx",
+      "e2e/**/*.ts",
       "!!**/node_modules",
       "!!node_modules",
       "!!**/dist",

package/e2e/smoke.ts

@@ -0,0 +1,194 @@
+/**
+ * Real-process smoke for @terreno/jobs. Run `bun e2e/smoke.ts` after `bun run compile`.
+ *
+ * The smoke re-runs this file with `worker` as a child process: the compiled `@terreno/jobs`
+ * `JobsApp` with its default `MongoJobRunner` poll loop, against `smokeMongoUri()`, plus a
+ * readiness route on a free port. The parent is the enqueuing process: it registers its own
+ * `JobsApp` with the same job definition, enqueues one job, and checks that the worker process
+ * ran the handler and marked the job completed. Exits non-zero on the first failed check.
+ */
+import {
+  freePort,
+  type SpawnedProcess,
+  smokeMongoUri,
+  spawnUntilReady,
+  stopSmokeMongo,
+} from "@terreno/test";
+import {DateTime} from "luxon";
+
+const WORKER_ARG = "worker";
+const JOB_NAME = "jobsSmoke/record";
+const RUNS_COLLECTION = "jobsSmokeRuns";
+const COMPLETION_TIMEOUT_MS = 15000;
+const POLL_INTERVAL_MS = 100;
+
+interface SmokePayload {
+  runId: number;
+}
+
+/** What the worker's handler writes, so the parent can see which process ran the job. */
+interface SmokeRun {
+  jobId: string;
+  pid: number;
+  runId: number;
+}
+
+/**
+ * Child: a standalone worker, the shape of a dedicated jobs entrypoint. The handler records the
+ * job id and this process's pid. `/health` answers once the poll loop is running, and SIGTERM
+ * stops the worker before exiting. The packages are imported here, not at the top, so the
+ * parent's enqueue path loads them on its own.
+ */
+const work = async (): Promise<void> => {
+  const {logger} = await import("@terreno/api");
+  const {JobsApp} = await import("@terreno/jobs");
+  const {default: mongoose} = await import("mongoose");
+
+  await mongoose.connect(process.env.MONGO_URI as string);
+
+  const jobsApp = new JobsApp({pollIntervalMs: POLL_INTERVAL_MS});
+  jobsApp.define(JOB_NAME, {
+    handler: async (payload, ctx) => {
+      const run: SmokeRun = {
+        jobId: ctx.jobId,
+        pid: process.pid,
+        runId: (payload as SmokePayload).runId,
+      };
+      await mongoose.connection.collection(RUNS_COLLECTION).insertOne(run);
+      ctx.log.info(`[jobsSmoke] ran job ${ctx.jobId} in pid ${process.pid}`);
+    },
+    retry: {maxAttempts: 1},
+  });
+  await jobsApp.startWorker();
+
+  const server = Bun.serve({
+    fetch: () => {
+      const isWorkerActive = jobsApp.isWorkerActive();
+      return Response.json({worker: isWorkerActive}, {status: isWorkerActive ? 200 : 503});
+    },
+    hostname: "127.0.0.1",
+    port: Number(process.env.PORT),
+  });
+  process.once("SIGTERM", () => {
+    void (async (): Promise<void> => {
+      try {
+        await jobsApp.stopWorker();
+        await server.stop();
+        await mongoose.disconnect();
+      } finally {
+        process.exit(0);
+      }
+    })();
+  });
+  logger.info(`[jobsSmoke] worker polling, ready on port ${process.env.PORT}`);
+};
+
+/** Waits for the job to leave `pending`/`running`, and returns its final status. */
+const waitForTerminalStatus = async ({
+  findStatus,
+}: {
+  findStatus: () => Promise<string | undefined>;
+}): Promise<string | undefined> => {
+  const deadline = DateTime.now().plus({milliseconds: COMPLETION_TIMEOUT_MS});
+  let status = await findStatus();
+  while (DateTime.now() < deadline && (status === "pending" || status === "running")) {
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+    status = await findStatus();
+  }
+  return status;
+};
+
+/** Parent: boots the worker, enqueues one job from this process, and checks who ran it. */
+const run = async (): Promise<void> => {
+  const startedAt = DateTime.now();
+  const runId = startedAt.toMillis();
+  const {setupLogging} = await import("@terreno/api");
+  const {JobsApp, Job, JobSchedule, getJobsService} = await import("@terreno/jobs");
+  const {default: express} = await import("express");
+  const {default: mongoose} = await import("mongoose");
+
+  const port = await freePort();
+  const mongoUri = await smokeMongoUri({databaseName: "jobsSmoke"});
+  let worker: SpawnedProcess | undefined;
+
+  try {
+    worker = await spawnUntilReady({
+      cmd: [process.execPath, __filename, WORKER_ARG],
+      env: {MONGO_URI: mongoUri, PORT: String(port)},
+      timeoutMs: 20000,
+      url: `http://127.0.0.1:${port}/health`,
+    });
+
+    // Info level hides the admin routes' "no OpenAPI" debug lines from the bare Express app.
+    setupLogging({disableFileLogging: true, level: "info"});
+    // The enqueuing process shares the definition (for retry settings) but never starts a
+    // worker, so its handler running would mean the job did not cross processes.
+    await mongoose.connect(mongoUri);
+    const jobsApp = new JobsApp();
+    jobsApp.define(JOB_NAME, {
+      handler: async () => {
+        throw new Error("the enqueuing process must not run the job");
+      },
+      retry: {maxAttempts: 1},
+    });
+    jobsApp.register(express());
+    // register() builds indexes in the background; finish them before disconnecting.
+    await Promise.all([Job.init(), JobSchedule.init()]);
+
+    const job = await getJobsService().enqueue({name: JOB_NAME, payload: {runId}});
+    const jobId = job._id.toString();
+    if (job.status !== "pending") {
+      throw new Error(`enqueue: expected a pending job, got ${job.status}`);
+    }
+    console.info(`✅ enqueue persists pending job ${jobId} from pid ${process.pid}`);
+
+    const status = await waitForTerminalStatus({
+      findStatus: async () => (await Job.findOneOrNone({_id: job._id}))?.status,
+    });
+    if (status !== "completed") {
+      throw new Error(
+        `worker: job ${jobId} is ${status ?? "missing"}, not completed, after ${COMPLETION_TIMEOUT_MS} ms`
+      );
+    }
+    console.info(`✅ the worker process marks job ${jobId} completed`);
+
+    const runs = await mongoose.connection
+      .collection<SmokeRun>(RUNS_COLLECTION)
+      .find({jobId})
+      .toArray();
+    if (runs.length !== 1) {
+      throw new Error(`worker: expected the handler to run once, it ran ${runs.length} times`);
+    }
+    const [ran] = runs;
+    if (ran.pid !== worker.pid || ran.runId !== runId) {
+      throw new Error(
+        `worker: handler ran in pid ${ran.pid} with runId ${ran.runId}, expected worker pid ${worker.pid} and runId ${runId}`
+      );
+    }
+    console.info(`✅ the handler ran once, in worker pid ${worker.pid}, with the enqueued payload`);
+  } catch (error: unknown) {
+    if (worker) {
+      console.error(`--- worker output ---\n${worker.output()}`);
+    }
+    throw error;
+  } finally {
+    await worker?.stop();
+    await mongoose.disconnect();
+    await stopSmokeMongo();
+  }
+
+  console.info(`jobs smoke passed in ${DateTime.now().diff(startedAt).toMillis()} ms`);
+};
+
+const main = process.argv[2] === WORKER_ARG ? work : run;
+main().then(
+  () => {
+    if (main === run) {
+      process.exit(0);
+    }
+  },
+  (error: unknown) => {
+    console.error(`❌ ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+);

package/package.json

@@ -4,7 +4,7 @@
     "url": "https://github.com/TerrenoLabs/terreno/issues"
   },
   "dependencies": {
-    "@terreno/api": "57.20.0",
+    "@terreno/api": "57.22.0",
     "cron": "^4.3.4",
     "express": "^5.2.1",
     "luxon": "^3.7.2"
@@ -12,7 +12,7 @@
   "description": "Durable background jobs plugin for @terreno/api — part of Terreno, the batteries-included TypeScript framework for universal apps.",
   "devDependencies": {
     "@biomejs/biome": "^2.3.6",
-    "@terreno/test": "57.20.0",
+    "@terreno/test": "57.22.0",
     "@types/bun": "^1.4.0",
     "@types/express": "^5.0.6",
     "@types/luxon": "^3.7.1",
@@ -70,13 +70,15 @@
     "compile": "bun tsc",
     "compile:watch": "bun tsc -w",
     "dev": "bun tsc -w",
-    "lint": "biome check ./src",
-    "lint:fix": "biome check --write ./src",
+    "lint": "biome check ./src ./e2e",
+    "lint:fix": "biome check --write ./src ./e2e",
+    "smoke": "bun e2e/smoke.ts",
     "test": "bun test",
     "test:agent": "AGENT=1 bun test --only-failures",
     "test:ci": "bun test",
-    "test:coverage": "bun run ../scripts/check-coverage.ts"
+    "test:coverage": "bun run ../scripts/check-coverage.ts",
+    "typecheck": "tsc -p tsconfig.typecheck.json"
   },
   "types": "dist/index.d.ts",
-  "version": "57.20.0"
+  "version": "57.22.0"
 }

package/src/tests/gcpCloudTasksRunner.test.ts

@@ -141,7 +141,7 @@ describe("GcpCloudTasksRunner", () => {
     const {client: _client, ...configWithoutClient} = baseConfig();
     let isPeerAvailable = true;
     try {
-      createRequire(import.meta.url)("@google-cloud/tasks");
+      createRequire(__filename)("@google-cloud/tasks");
     } catch {
       isPeerAvailable = false;
     }

package/src/tests/vercelQueuesRunner.test.ts

@@ -35,6 +35,16 @@ import {
   type VercelQueuesRunnerConfig,
 } from "../runners/vercelQueues";
 
+/** A fixed, valid instant; the runner helpers take `DateTime<true>`. */
+const parseValidUtc = (iso: string): DateTime<true> => {
+  const parsed = DateTime.fromISO(iso, {zone: "utc"});
+  if (!parsed.isValid) {
+    throw new Error(`Invalid ISO timestamp: ${iso}`);
+  }
+  return parsed;
+};
+const FIXED_NOW = parseValidUtc("2026-06-01T12:00:00.000Z");
+
 interface RecordedSendCall {
   options?: VercelQueueSendOptions;
   payload: unknown;
@@ -87,7 +97,7 @@ const createFakeHandleCallback = (): {
         return new Response("ok", {status: 200});
       } catch (error: unknown) {
         const directive = options?.retry?.(error, sampleMetadata());
-        if (directive?.acknowledge === true) {
+        if (directive && "acknowledge" in directive) {
           return new Response("acknowledged", {status: 200});
         }
         if (directive && "afterSeconds" in directive) {
@@ -139,7 +149,7 @@ describe("VercelQueuesRunner", () => {
     const runner = new VercelQueuesRunner(baseConfig());
 
     assert.equal(runner.requiresExecuteRoute, false);
-    assert.isUndefined(runner.start);
+    assert.isUndefined(Reflect.get(runner, "start"));
   });
 
   it("throws when topic is missing or blank", (): void => {
@@ -194,7 +204,7 @@ describe("VercelQueuesRunner", () => {
   });
 
   it("bumps retention to cover delaySeconds beyond 24h with a fixed now", (): void => {
-    const now = DateTime.fromISO("2026-06-01T12:00:00.000Z", {zone: "utc"});
+    const now = FIXED_NOW;
     const runAt = now.plus({hours: 30});
     const job = buildJob({runAt: runAt.toJSDate()});
     const options = buildVercelQueueSendOptions(job, {}, now);
@@ -258,7 +268,7 @@ describe("VercelQueuesRunner", () => {
 });
 
 describe("computeVercelQueueRetryAfterSeconds", () => {
-  const now = DateTime.fromISO("2026-06-01T12:00:00.000Z", {zone: "utc"});
+  const now = FIXED_NOW;
 
   it("clamps retry visibility to the vendor 30..3600 second range", (): void => {
     assert.equal(

package/tsconfig.typecheck.json

@@ -0,0 +1,18 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "composite": false,
+    "incremental": false,
+    "declaration": false,
+    "declarationMap": false,
+    "types": [
+      "node",
+      "bun"
+    ]
+  },
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}