@terreno/blocks 57.20.0 → 57.21.0

package/CHANGELOG.md

@@ -20,6 +20,56 @@ 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.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",
       "scripts/**/*.ts",
+      "e2e/**/*.ts",
       "!!**/node_modules",
       "!!node_modules",
       "!!**/dist",

package/e2e/smoke.ts

@@ -0,0 +1,96 @@
+/**
+ * Real-process smoke for @terreno/blocks. Run `bun e2e/smoke.ts` after `bun run compile`.
+ *
+ * Finds the compiled `terreno-blocks` binary through the installed package's `bin` field, the
+ * way a consumer's package manager links it, and runs `validate` on two documents written to a
+ * temp dir: a valid one must exit 0 with no output, and an invalid one must exit non-zero and
+ * name the failing path and error code. Exits non-zero on the first failed check.
+ */
+import {mkdtempSync, readFileSync, rmSync, writeFileSync} from "node:fs";
+import {tmpdir} from "node:os";
+import {dirname, join} from "node:path";
+import {runBin} from "@terreno/test";
+
+const BIN_NAME = "terreno-blocks";
+
+const VALID_DOCUMENT = `v: 1
+blocks:
+  - type: text
+    markdown: Signups grew 12% this month.
+  - type: actions
+    id: followups
+    elements:
+      - type: button
+        id: weekly
+        text: Show weekly
+        action:
+          kind: reply
+          text: Show weekly signups
+`;
+
+// The text block has no `markdown`, so validation must report MISSING_REQUIRED at that path.
+const INVALID_DOCUMENT = `v: 1
+blocks:
+  - type: text
+`;
+const EXPECTED_ERROR_PATH = "blocks[0].markdown";
+const EXPECTED_ERROR_CODE = "MISSING_REQUIRED";
+
+/** Resolves the installed package by name, then follows its `bin` field to the compiled CLI. */
+const resolveBlocksBin = (): string => {
+  const packageDir = dirname(dirname(require.resolve("@terreno/blocks")));
+  const manifest = JSON.parse(readFileSync(join(packageDir, "package.json"), "utf8")) as {
+    bin?: Record<string, string>;
+  };
+  const relativeBin = manifest.bin?.[BIN_NAME];
+  if (!relativeBin) {
+    throw new Error(`@terreno/blocks package.json has no "${BIN_NAME}" bin`);
+  }
+  return join(packageDir, relativeBin);
+};
+
+const run = async (): Promise<void> => {
+  const startedAt = performance.now();
+  const bin = resolveBlocksBin();
+  const workDir = mkdtempSync(join(tmpdir(), "blocks-smoke-"));
+
+  try {
+    const validPath = join(workDir, "valid.yaml");
+    writeFileSync(validPath, VALID_DOCUMENT);
+    const valid = await runBin({args: ["validate", validPath], bin});
+    if (valid.exitCode !== 0 || valid.stdout !== "" || valid.stderr !== "") {
+      throw new Error(
+        `${BIN_NAME} validate (valid): expected exit 0 with no output, got exit ${valid.exitCode}\nstdout: ${valid.stdout}\nstderr: ${valid.stderr}`
+      );
+    }
+    console.info(`✅ ${BIN_NAME} validate accepts a valid document with exit 0`);
+
+    const invalidPath = join(workDir, "invalid.yaml");
+    writeFileSync(invalidPath, INVALID_DOCUMENT);
+    const invalid = await runBin({args: ["validate", invalidPath], bin});
+    const isErrorReported =
+      invalid.stdout.includes(EXPECTED_ERROR_PATH) && invalid.stdout.includes(EXPECTED_ERROR_CODE);
+    if (invalid.exitCode === 0 || !isErrorReported) {
+      throw new Error(
+        `${BIN_NAME} validate (invalid): expected a non-zero exit naming ${EXPECTED_ERROR_PATH} ${EXPECTED_ERROR_CODE}, got exit ${invalid.exitCode}\nstdout: ${invalid.stdout}\nstderr: ${invalid.stderr}`
+      );
+    }
+    console.info(
+      `✅ ${BIN_NAME} validate rejects an invalid document with exit ${invalid.exitCode} and ${EXPECTED_ERROR_CODE}`
+    );
+  } finally {
+    rmSync(workDir, {force: true, recursive: true});
+  }
+
+  console.info(`blocks smoke passed in ${Math.round(performance.now() - startedAt)} ms`);
+};
+
+run().then(
+  () => {
+    process.exit(0);
+  },
+  (error: unknown) => {
+    console.error(`❌ ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+);

package/package.json

@@ -47,14 +47,16 @@
     "compile": "bun tsc",
     "compile:watch": "bun tsc -w",
     "dev": "bun tsc -w",
-    "lint": "biome check ./src ./scripts",
-    "lint:fix": "biome check --write ./src ./scripts",
+    "lint": "biome check ./src ./scripts ./e2e",
+    "lint:fix": "biome check --write ./src ./scripts ./e2e",
     "schemas": "bun scripts/writeJsonSchemas.ts",
+    "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.21.0"
 }

package/src/asks/docParity.test.ts

@@ -4,15 +4,7 @@ import {join} from "node:path";
 import {ASK_ERROR_CODES} from "./errors";
 import {ASK_LIMITS} from "./limits";
 
-const REFERENCE_PATH = join(
-  import.meta.dir,
-  "..",
-  "..",
-  "..",
-  "docs",
-  "reference",
-  "agent-ui-asks.md"
-);
+const REFERENCE_PATH = join(__dirname, "..", "..", "..", "docs", "reference", "agent-ui-asks.md");
 
 const reference = readFileSync(REFERENCE_PATH, "utf8");
 

package/src/asks/jsonSchema.test.ts

@@ -2,12 +2,12 @@ import {describe, expect, it} from "bun:test";
 import {readdirSync, readFileSync} from "node:fs";
 import {join} from "node:path";
 import {z} from "zod";
-import {validAskFixtures} from "../tests/askFixtures";
+import {fixtureAsk, validAskFixtures} from "../tests/askFixtures";
 import {pendingAskListSchema, turnRequestSchema, turnResultSchema} from "./headless";
 import {askJsonSchemas} from "./jsonSchema";
 import {simpleCardSchema, toSimpleCard} from "./simpleCard";
 
-const SCHEMAS_DIR = join(import.meta.dir, "..", "..", "schemas");
+const SCHEMAS_DIR = join(__dirname, "..", "..", "schemas");
 
 const documents = askJsonSchemas();
 
@@ -21,7 +21,7 @@ const fromDocument = (fileName: string): z.ZodType => {
 };
 
 const CARDS = validAskFixtures().map((fixture) =>
-  toSimpleCard({input: fixture.input, kind: fixture.kind, toolCallId: "call_fixture"})
+  toSimpleCard({...fixtureAsk(fixture), toolCallId: "call_fixture"})
 );
 
 const [CARD] = CARDS;

package/src/asks/schema.test.ts

@@ -9,6 +9,7 @@ import {
   askInputSchemaFor,
   askKindsForSurface,
   COMPACT_ASK_KINDS,
+  type ConfirmAskInput,
   choiceAskInputSchema,
   compactChoiceAskInputSchema,
   confirmAskInputSchema,
@@ -190,9 +191,13 @@ describe("markdownLengthBounds", () => {
 
 describe("confirmButtonLabels", () => {
   it("uses the ask's labels, defaulting to Confirm and Cancel", () => {
-    expect(confirmButtonLabels({prompt: "Go?"})).toEqual({confirm: "Confirm", deny: "Cancel"});
-    expect(
-      confirmButtonLabels({confirmLabel: "Delete 14 todos", denyLabel: "Keep them", prompt: "Go?"})
-    ).toEqual({confirm: "Delete 14 todos", deny: "Keep them"});
+    const plain: ConfirmAskInput = {prompt: "Go?"};
+    const labeled: ConfirmAskInput = {
+      confirmLabel: "Delete 14 todos",
+      denyLabel: "Keep them",
+      prompt: "Go?",
+    };
+    expect(confirmButtonLabels(plain)).toEqual({confirm: "Confirm", deny: "Cancel"});
+    expect(confirmButtonLabels(labeled)).toEqual({confirm: "Delete 14 todos", deny: "Keep them"});
   });
 });

package/src/asks/simpleCard.test.ts

@@ -1,5 +1,10 @@
 import {describe, expect, it} from "bun:test";
-import {type ValidAskFixture, validAskFixtures, validAskFixturesOf} from "../tests/askFixtures";
+import {
+  fixtureAsk,
+  type ValidAskFixture,
+  validAskFixtures,
+  validAskFixturesOf,
+} from "../tests/askFixtures";
 import {ASK_LIMITS} from "./limits";
 import type {
   ChoiceAskInput,
@@ -192,9 +197,9 @@ const expectedCard = (fixture: ValidAskFixture): {buttons: ExpectedButton[]; han
 describe("toSimpleCard golden fixtures", () => {
   for (const fixture of validAskFixtures()) {
     it(`derives the expected card for valid/${fixture.name}`, () => {
-      expect(
-        toSimpleCard({input: fixture.input, kind: fixture.kind, toolCallId: TOOL_CALL_ID})
-      ).toEqual(fixture.simple);
+      expect(toSimpleCard({...fixtureAsk(fixture), toolCallId: TOOL_CALL_ID})).toEqual(
+        fixture.simple
+      );
     });
   }
 });
@@ -202,11 +207,7 @@ describe("toSimpleCard golden fixtures", () => {
 describe("toSimpleCard properties over every valid fixture", () => {
   for (const fixture of validAskFixtures()) {
     describe(`valid/${fixture.name}`, () => {
-      const card = toSimpleCard({
-        input: fixture.input,
-        kind: fixture.kind,
-        toolCallId: TOOL_CALL_ID,
-      });
+      const card = toSimpleCard({...fixtureAsk(fixture), toolCallId: TOOL_CALL_ID});
 
       it("passes simpleCardSchema", () => {
         expect(simpleCardSchema.safeParse(card).success).toBe(true);
@@ -232,9 +233,9 @@ describe("toSimpleCard properties over every valid fixture", () => {
       it("has the buttons and handoff of its rule-table row", () => {
         const expected = expectedCard(fixture);
         expect(card.handoff).toBe(expected.handoff);
-        expect(card.buttons.map(({id, response, style}) => ({id, response, style}))).toEqual(
-          expected.buttons
-        );
+        expect<ExpectedButton[]>(
+          card.buttons.map(({id, response, style}) => ({id, response, style}))
+        ).toEqual(expected.buttons);
       });
 
       it("never shows two buttons with the same label", () => {
@@ -442,9 +443,9 @@ describe("toSimpleCard properties over compact asks", () => {
 
   it("follows the optionsFit row of the rule table", () => {
     for (const {card, input} of cards) {
-      expect(card.buttons.map(({id, response, style}) => ({id, response, style}))).toEqual(
-        buttonsForRow(input, "optionsFit")
-      );
+      expect<ExpectedButton[]>(
+        card.buttons.map(({id, response, style}) => ({id, response, style}))
+      ).toEqual(buttonsForRow(input, "optionsFit"));
     }
   });
 
@@ -744,9 +745,9 @@ describe("toSimpleCard confirm rules", () => {
 
   it("puts approve first and deny last, with no Skip even when the ask allows declining", () => {
     for (const {card, input} of cards) {
-      expect(card.buttons.map(({id, response, style}) => ({id, response, style}))).toEqual(
-        confirmButtons(input)
-      );
+      expect<ExpectedButton[]>(
+        card.buttons.map(({id, response, style}) => ({id, response, style}))
+      ).toEqual(confirmButtons(input));
     }
   });
 
@@ -841,9 +842,9 @@ describe("toSimpleCard markdown rules", () => {
 
   it("offers Approve draft exactly when the draft meets the length rules, then Cancel", () => {
     for (const {card, fits, input} of cards) {
-      expect(card.buttons.map(({id, response, style}) => ({id, response, style}))).toEqual(
-        markdownButtons(input, fits)
-      );
+      expect<ExpectedButton[]>(
+        card.buttons.map(({id, response, style}) => ({id, response, style}))
+      ).toEqual(markdownButtons(input, fits));
     }
   });
 
@@ -935,9 +936,9 @@ describe("toSimpleCard form rules", () => {
 
   it("offers Submit defaults exactly when there is a default and every required field has one", () => {
     for (const {card, input, values} of cards) {
-      expect(card.buttons.map(({id, response, style}) => ({id, response, style}))).toEqual(
-        formButtons(input, values)
-      );
+      expect<ExpectedButton[]>(
+        card.buttons.map(({id, response, style}) => ({id, response, style}))
+      ).toEqual(formButtons(input, values));
     }
   });
 

package/src/asks/validateInput.test.ts

@@ -1,5 +1,6 @@
 import {describe, expect, it} from "bun:test";
 import {invalidAskFixtures, validAskFixtures} from "../tests/askFixtures";
+import type {AskErrorCode} from "./errors";
 import {type AskKind, type AskSurface, isCompactAskKind} from "./schema";
 import {validateAskInput} from "./validateInput";
 
@@ -8,7 +9,7 @@ const NO_OPTION = {id: "no", label: "No"};
 const TWO_OPTIONS = [{id: "yes", label: "Yes"}, NO_OPTION];
 
 /** What the compact surface returns for each valid fixture, read off the compact rules by hand. */
-const COMPACT_ERRORS_BY_FIXTURE: Record<string, {code: string; path: string}[]> = {
+const COMPACT_ERRORS_BY_FIXTURE: Record<string, {code: AskErrorCode; path: string}[]> = {
   "choice-emoji-label-cut": [{code: "TOO_LONG", path: "options[0].label"}],
   "choice-labels-collide-after-cut": [
     {code: "TOO_LONG", path: "options[0].label"},

package/src/blocksDocParity.test.ts

@@ -5,7 +5,7 @@ import {join} from "node:path";
 import {BLOCK_ERROR_CODES, BLOCK_WARNING_CODES} from "./errors";
 
 const reference = readFileSync(
-  join(import.meta.dir, "..", "..", "docs", "reference", "blocks.md"),
+  join(__dirname, "..", "..", "docs", "reference", "blocks.md"),
   "utf8"
 );
 

package/src/cli.test.ts

@@ -3,22 +3,22 @@ import {join} from "node:path";
 
 import {launchBlocksCli, runBlocksCli} from "./cli";
 
-const validFixture = join(import.meta.dir, "fixtures", "valid", "prose.yaml");
-const invalidFixture = join(import.meta.dir, "fixtures", "invalid", "unknown-key.yaml");
+const validFixture = join(__dirname, "fixtures", "valid", "prose.yaml");
+const invalidFixture = join(__dirname, "fixtures", "invalid", "unknown-key.yaml");
 
 describe("terreno-blocks validate", () => {
   it("exits 0 for a valid file and 1 for an invalid file", async () => {
-    const valid = Bun.spawn(["bun", join(import.meta.dir, "cli.ts"), "validate", validFixture], {
+    const valid = Bun.spawn(["bun", join(__dirname, "cli.ts"), "validate", validFixture], {
       stderr: "pipe",
       stdout: "pipe",
     });
     expect(await valid.exited).toBe(0);
     expect(await new Response(valid.stdout).text()).toBe("");
 
-    const invalid = Bun.spawn(
-      ["bun", join(import.meta.dir, "cli.ts"), "validate", invalidFixture],
-      {stderr: "pipe", stdout: "pipe"}
-    );
+    const invalid = Bun.spawn(["bun", join(__dirname, "cli.ts"), "validate", invalidFixture], {
+      stderr: "pipe",
+      stdout: "pipe",
+    });
     expect(await invalid.exited).toBe(1);
     const report = await new Response(invalid.stdout).text();
     expect(report).toContain("blocks[0].color  UNKNOWN_KEY  ");

package/src/golden.test.ts

@@ -7,7 +7,7 @@ import {blockPlainText} from "./plainText";
 import type {Block, BlocksDocument} from "./schema";
 import {validateBlocks} from "./validate";
 
-const goldenPath = join(import.meta.dir, "fixtures", "golden", "sunday-roast.yaml");
+const goldenPath = join(__dirname, "fixtures", "golden", "sunday-roast.yaml");
 
 // The roast reply needs these options: https images and both host callbacks.
 const goldenOptions = {

package/src/jsonSchema.test.ts

@@ -7,7 +7,7 @@ import {blocksJsonSchema} from "./jsonSchema";
 import {parseBlocks} from "./parse";
 import {blocksSchema} from "./schema";
 
-const fixturesDir = join(import.meta.dir, "fixtures");
+const fixturesDir = join(__dirname, "fixtures");
 
 describe("blocksJsonSchema", () => {
   it("accepts and rejects the same parsed fixtures as the Zod schema", () => {

package/src/parse.test.ts

@@ -1,14 +1,18 @@
 import {describe, expect, it} from "bun:test";
 import {readdirSync, readFileSync} from "node:fs";
 import {join} from "node:path";
-
-import {parseBlocks} from "./parse";
+import type {BlockError, BlockErrorCode} from "./errors";
+import {type ParseBlocksResult, parseBlocks} from "./parse";
 import {wrapAsTextDocument} from "./schema";
-import {validateBlocks} from "./validate";
+import {type ValidateBlocksResult, validateBlocks} from "./validate";
+
+/** The errors of a failed parse or validation, or none when it succeeded. */
+const errorsOf = (result: ParseBlocksResult | ValidateBlocksResult): BlockError[] =>
+  result.ok ? [] : result.errors;
 
-const fixturesDir = join(import.meta.dir, "fixtures");
+const fixturesDir = join(__dirname, "fixtures");
 
-const expectedInvalid: Record<string, {code: string; path: string}[]> = {
+const expectedInvalid: Record<string, {code: BlockErrorCode; path: string}[]> = {
   // An empty visibleText string trips both the min(1) and the blank-text checks.
   "card-eyebrow-empty.yaml": [
     {code: "TOO_SHORT", path: "blocks[0].eyebrow"},
@@ -159,11 +163,7 @@ describe("block fixtures", () => {
     expect(names.sort()).toEqual(Object.keys(expectedInvalid).sort());
     for (const name of names) {
       const parsed = parseBlocks(readFileSync(join(dir, name), "utf8"));
-      const errors = parsed.ok
-        ? validateBlocks(parsed.value).ok
-          ? []
-          : validateBlocks(parsed.value).errors
-        : parsed.errors;
+      const errors = parsed.ok ? errorsOf(validateBlocks(parsed.value)) : parsed.errors;
       expect(errors.map((item) => ({code: item.code, path: item.path}))).toEqual(
         expectedInvalid[name]
       );
@@ -208,13 +208,13 @@ describe("validateBlocks limits", () => {
   });
 
   it("rejects empty input, a second document, and a mapping without v", () => {
-    expect(parseBlocks("").errors).toEqual([
+    expect(errorsOf(parseBlocks(""))).toEqual([
       expect.objectContaining({code: "NOT_A_DOCUMENT", path: ""}),
     ]);
-    expect(parseBlocks("v: 1\n---\nv: 1\n").errors).toEqual([
+    expect(errorsOf(parseBlocks("v: 1\n---\nv: 1\n"))).toEqual([
       expect.objectContaining({code: "NOT_A_DOCUMENT", path: ""}),
     ]);
-    expect(parseBlocks("blocks:\n  - type: divider\n").errors).toEqual([
+    expect(errorsOf(parseBlocks("blocks:\n  - type: divider\n"))).toEqual([
       expect.objectContaining({code: "NOT_A_DOCUMENT", path: ""}),
     ]);
   });

package/src/parsePartial.test.ts

@@ -4,7 +4,7 @@ import {join} from "node:path";
 
 import {parseBlocksPartial} from "./parsePartial";
 
-const partialDir = join(import.meta.dir, "fixtures", "partial");
+const partialDir = join(__dirname, "fixtures", "partial");
 
 describe("parseBlocksPartial", () => {
   it("returns every block of a finished document and pending false", () => {

package/src/tests/askFixtures.ts

@@ -1,9 +1,10 @@
 import {readdirSync, readFileSync} from "node:fs";
 import {join} from "node:path";
+import type {AskErrorCode} from "../asks/errors";
 import type {Ask, AskKind} from "../asks/schema";
 import type {SimpleCard} from "../asks/simpleCard";
 
-const FIXTURES_DIR = join(import.meta.dir, "..", "asks", "fixtures");
+const FIXTURES_DIR = join(__dirname, "..", "asks", "fixtures");
 
 export type ValidAskFixture = Ask & {
   name: string;
@@ -11,7 +12,7 @@ export type ValidAskFixture = Ask & {
 };
 
 export interface InvalidAskFixture {
-  errors: {code: string; path: string}[];
+  errors: {code: AskErrorCode; path: string}[];
   input: unknown;
   kind: AskKind;
   name: string;
@@ -38,3 +39,10 @@ export const validAskFixturesOf = <Kind extends AskKind>(
 
 export const invalidAskFixtures = (): InvalidAskFixture[] =>
   readFixtures<InvalidAskFixture>("invalid");
+
+/**
+ * The ask a fixture describes. The fixture spreads `Ask`, but TypeScript cannot keep `input` and
+ * `kind` correlated once they are read separately, so this restates the pairing.
+ */
+export const fixtureAsk = (fixture: ValidAskFixture): Ask =>
+  ({input: fixture.input, kind: fixture.kind}) as Ask;

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"
+  ]
+}