@jterrazz/test 12.1.0 → 12.2.0

package/README.md

@@ -76,6 +76,21 @@ test('builds the project', async () => {
 });
 ```
 
+A CLI session can also BE the spec file. A literate `<case>.cli` states one scenario — the narrative in its header, the session in its blocks — and runs either as a test file of its own (the `literate()` vite plugin) or through `cli.run('case.cli')`:
+
+```
+test: refuses to build without a manifest
+given: an empty working directory
+then: the error names the file it wanted
+
+$ build
+exit: 1
+--- stderr
+Error: no my-cli.yaml in the current directory
+```
+
+Same engine as the chain, same `{{token}}` grammar, same `TEST_UPDATE=1` — which rewrites only what follows each `$`, never the header. Full grammar: [docs/04-cli.md](docs/04-cli.md#literate-specs--casecli).
+
 ### Website testing (browser)
 
 ```typescript
@@ -193,9 +208,9 @@ const result = await jobs.seed('pending.sql').trigger('nightly-report');
 
 A `JobHandle` is `{ name: string; execute: () => Promise<void> }`.
 
-### `specification.cli(bin, { root?, services?, docker?, transform? })`
+### `specification.cli(bin, { root?, services?, docker?, transform?, env?, serve? })`
 
-Runs a command binary against fixture projects in fresh temp directories. With `services`, connection URLs are injected into the child env automatically: `<KEY>_URL` per record key (CONSTANT_CASE at camelCase boundaries — `analyticsDb` → `ANALYTICS_DB_URL`), plus `DATABASE_URL` (exactly one SQL database) and `REDIS_URL` (exactly one redis). `.env()` overrides; `null` unsets.
+Runs a command binary against fixture projects in fresh temp directories. `env` (named environment sets) and `serve` (named servers) are the registries a [literate `<case>.cli`](docs/04-cli.md#literate-specs--casecli) names by word. With `services`, connection URLs are injected into the child env automatically: `<KEY>_URL` per record key (CONSTANT_CASE at camelCase boundaries — `analyticsDb` → `ANALYTICS_DB_URL`), plus `DATABASE_URL` (exactly one SQL database) and `REDIS_URL` (exactly one redis). `.env()` overrides; `null` unsets.
 
 ```typescript
 export const { cli, cleanup } = await specification.cli('my-migrate-tool', {
@@ -275,6 +290,7 @@ When `root` is absent, the framework walks up from the specification file to the
 | `.exec("args")`                            | cli     | `CliResult`    | Run the command                                                                          |
 | `.exec(["build", "start"])`                | cli     | `CliResult`    | Sequence in the same cwd; stops on first non-zero exit                                   |
 | `.exec("dev", { waitFor, timeout? })`      | cli     | `CliResult`    | Long-running: resolves at the pattern, killed at `timeout` (default 10 s)                |
+| `.run("case.cli")`                         | cli     | `CliResult`    | Run a literate `<case>.cli` — its header and EVERY block asserted; the last one returns  |
 | `.fetch(path)`                             | website | `FetchResult`  | One raw HTTP exchange — redirects surface as 3xx, never followed                         |
 | `.visit(path, scenario?)`                  | website | `PageResult`   | Render the page in a shared chromium; with a scenario, the capture is the final state    |
 | `.open(deepLink?, scenario?)`              | mobile  | `ScreenResult` | Relaunch the app fresh on the simulator; with a scenario, the capture is the final state |

package/dist/checker.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { r as TOKEN_KINDS } from "./match.js";
+import { a as LiterateSyntaxError, o as parseLiterateFile, r as TOKEN_KINDS } from "./match.js";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { basename, dirname, join, relative, resolve } from "node:path";
 //#region src/lint/checker-crossfile.ts
@@ -17,7 +17,9 @@ import { basename, dirname, join, relative, resolve } from "node:path";
 *
 * - **C9 dead fixtures** — per feature dir, a fixture file no test literal
 *   references is dead weight; a feature dir with conventional subdirs but no
-*   `<feature>.test.ts` is an orphan.
+*   `<feature>.test.ts` is an orphan. A literate `<case>.cli` counts as a test
+*   AND as a referrer: the paths on its `fixture:` lines keep those trees alive
+*   exactly as a `.fixture('…')` literal does.
 * - **B5 await-using (inference)** — the docker-aware runners of a spec file
 *   are derived from its `docker:` option, then every `<runner>….exec()` bound
 *   without `await using` in an importing test is flagged. The primary B5
@@ -160,6 +162,23 @@ function blankComments(text) {
 function readSource(path) {
 	return blankComments(readText(path));
 }
+/**
+* The fixture paths a literate `<case>.cli` names — its referrer literals. The
+* runner's own parser reads them, so the two channels cannot disagree about
+* what the file says; an unparseable file vouches for nothing (the D4b/B4 pass
+* is what reports it).
+*/
+function collectLiterateLiterals(path) {
+	try {
+		return new Set(parseLiterateFile(readText(path), path).header.fixtures);
+	} catch {
+		return /* @__PURE__ */ new Set();
+	}
+}
+/** Is this a file a domain's assets may be referenced from? */
+function isReferrer(name) {
+	return name.endsWith(".test.ts") || name.endsWith(".cli");
+}
 function isDir(path) {
 	try {
 		return statSync(path).isDirectory();
@@ -478,13 +497,13 @@ function checkDeadFixtures(rootDir) {
 		const convSubdirs = entries.filter((entry) => entry.isDirectory() && CONVENTIONAL_SUBDIRS.has(entry.name) && isConventionalSubdir(join(dir, entry.name))).map((entry) => entry.name);
 		if (convSubdirs.length === 0) continue;
 		const feature = basename(dir);
-		const testFiles = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".test.ts")).map((entry) => join(dir, entry.name));
+		const testFiles = entries.filter((entry) => entry.isFile() && isReferrer(entry.name)).map((entry) => join(dir, entry.name));
 		const rel = relative(rootDir, dir);
 		if (testFiles.length === 0) {
 			violations.push({
 				file: rel,
 				line: 1,
-				message: `${rel}: domain directory has conventional subdirs (${convSubdirs.join(", ")}) but no *.test.ts (C9 — see docs/10-linting.md)`,
+				message: `${rel}: domain directory has conventional subdirs (${convSubdirs.join(", ")}) but no *.test.ts or *.cli (C9 — see docs/10-linting.md)`,
 				severity: "error"
 			});
 			continue;
@@ -492,6 +511,10 @@ function checkDeadFixtures(rootDir) {
 		const literals = /* @__PURE__ */ new Set();
 		let downgrade = false;
 		for (const testFile of testFiles) {
+			if (testFile.endsWith(".cli")) {
+				for (const literal of collectLiterateLiterals(testFile)) literals.add(literal);
+				continue;
+			}
 			const text = readSource(testFile);
 			for (const literal of collectLiterals(text)) literals.add(literal);
 			downgrade ||= hasNonLiteralFixtureArg(text);
@@ -521,9 +544,10 @@ function checkPoolFixtures(rootDir) {
 	for (const pool of findPools(rootDir)) {
 		const specsRoot = dirname(pool);
 		const literals = /* @__PURE__ */ new Set();
-		for (const file of listFiles(specsRoot, (path) => path.endsWith(".ts"))) {
+		for (const file of listFiles(specsRoot, (path) => path.endsWith(".ts") || path.endsWith(".cli"))) {
 			if (file.startsWith(`${pool}/`) || file.startsWith(`${pool}\\`)) continue;
-			for (const literal of collectLiterals(readSource(file))) literals.add(literal);
+			const found = file.endsWith(".cli") ? collectLiterateLiterals(file) : collectLiterals(readSource(file));
+			for (const literal of found) literals.add(literal);
 		}
 		for (const entry of readdirSync(pool, { withFileTypes: true })) if (![...literals].some((literal) => literal.includes(entry.name))) {
 			const relEntry = relative(rootDir, join(pool, entry.name));
@@ -551,7 +575,10 @@ function checkPoolFixtures(rootDir) {
 * - the **HTTP first-line grammar** of depth-1 `requests/*.http` (a request line)
 *   and `expected/*.http` (a status line) (D4b);
 * - **tokens leaking into `requests/`** — requests are inputs, never matched, so
-*   a `{{token}}` there is almost always a mistake (D10, warning).
+*   a `{{token}}` there is almost always a mistake (D10, warning);
+* - the **literate `.cli` grammar** wherever a scenario file sits: its narrative
+*   (B4) and its shape (D4b), read through the runner's own parser, plus the
+*   token vocabulary of its blocks (D4).
 *
 * It shares TOKEN_KINDS with the runtime matcher so the channels cannot drift.
 */
@@ -632,6 +659,40 @@ function firstLine(text) {
 const REQUEST_LINE = /^(?<method>GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS) \/\S*/;
 const STATUS_LINE = /^HTTP\/\d(?:\.\d)? \d{3}\b/;
 /**
+* Check one literate `<case>.cli` file — B4's narrative and D4b's shape
+* through the SAME parser the runner uses (one grammar, no drift), then D4's
+* token vocabulary over its BODY only: a `{{token}}` in the header is text,
+* never a placeholder.
+*
+* Precision over recall, as everywhere in this channel: the parser refuses at
+* the first defect, so one file reports one grammar violation per run.
+*/
+function checkLiterateFile(text, rel) {
+	const violations = [];
+	let bodyStart = 0;
+	try {
+		bodyStart = parseLiterateFile(text, rel).headerText.split("\n").length - 1;
+	} catch (error) {
+		if (!(error instanceof LiterateSyntaxError)) throw error;
+		const rule = error.defect === "narrative" ? "B4" : "D4b";
+		return [{
+			file: rel,
+			line: error.line,
+			message: `${error.message} (${rule} — see docs/10-linting.md)`,
+			severity: "error"
+		}];
+	}
+	const body = text.split("\n").slice(bodyStart).join("\n");
+	for (const { line, token } of findUnknownTokens(body)) violations.push({
+		file: rel,
+		line: line + bodyStart,
+		message: `${rel}:${line + bodyStart}: unknown token ${token} — the D4 vocabulary is frozen (known: ${[...TOKEN_KINDS].join(", ")})`,
+		severity: "error",
+		token
+	});
+	return violations;
+}
+/**
 * Walk `rootDir` and check every fixture file. Paths in the result are relative
 * to `rootDir`. Errors fail the checker; warnings are advisory.
 */
@@ -653,6 +714,11 @@ function checkConventionFiles(rootDir) {
 				visit(path, next);
 				continue;
 			}
+			if (entry.name.endsWith(".cli")) {
+				const text = decodeText(path);
+				if (text !== null) violations.push(...checkLiterateFile(text, rel));
+				continue;
+			}
 			if (inside === null) continue;
 			const depth1 = dir.endsWith(`/${inside}`) || dir.endsWith(`\\${inside}`);
 			if (inside === "requests") {

package/dist/index.d.ts

@@ -926,6 +926,48 @@ declare class HttpResult extends BaseResult {
   get status(): number;
 }
 //#endregion
+//#region src/core/specification/cli/literate.d.ts
+/**
+ * Running a literate `<case>.cli` spec: one scenario, one workdir, one set of
+ * servers, every `$` block executed and asserted.
+ *
+ * The engine composes pieces that already exist rather than adding a second of
+ * anything — {@link copyPlan} for `fixture:`, the runner's own command adapter
+ * for each block, {@link ServeAdapter} for `serve:`, the `{{token}}` engine for
+ * the comparison, and {@link mergeTextPreservingPlaceholders} for the rewrite.
+ * What is new here is only the ORCHESTRATION the chain cannot express: several
+ * commands sharing one working directory, each asserted, none stopping the run.
+ */
+/**
+ * A server a literate header may start by name (`serve: mcp KEY=value`),
+ * registered once per app in the `serve` option of `specification.cli()`.
+ */
+interface LiterateServeRegistration {
+  /** Shell command that starts the server, run from the project root. */
+  command: string;
+  /** The variable the resolved URL is bound to in every block's child env. */
+  env: string;
+  /**
+   * Matched against the server's output; the FIRST capture group is the port
+   * it chose — named (`(?<port>\d+)`) or not, it is group 1 either way.
+   */
+  ready: RegExp;
+  /** Builds the URL bound to {@link env} from the announced port. */
+  url: (port: number) => string;
+}
+/** Per-call options for {@link runLiterateSpec} / `cli.run()`. */
+interface LiterateRunFlags {
+  /**
+   * Opt this file OUT of the update-mode rewrite. A frozen file is NEVER
+   * written under `TEST_UPDATE=1`: its mismatch still throws its diff. That
+   * is what makes a DELIBERATELY-WRONG `.cli` — one whose failure rendering
+   * is the subject of a negative test — survive an update run instead of
+   * being silently corrected into a passing file. The `.cli` mirror of
+   * `toMatch(name, { frozen: true })`.
+   */
+  frozen?: boolean;
+}
+//#endregion
 //#region src/core/specification/mobile/result.d.ts
 /** Result from a `.open()` action — the screen as the device saw it, final state. */
 declare class ScreenResult extends BaseResult {
@@ -1135,13 +1177,25 @@ interface SpecificationConfig {
    * facet factories auto-populate this when `dockerConfig` is present.
    */
   dockerTestRunId?: string;
+  /**
+   * Named environment SETS a literate `.cli` header may name by bare word
+   * (`env: frozen`). Declared once per app in `specification.cli()`.
+   */
+  envSets?: Record<string, CliEnv>;
   /**
    * When set, `.intercept()` is unavailable on this runner and throws this
    * reason immediately (compose mode — MSW is in-process, CONVENTIONS I3).
    */
   interceptDisabledReason?: string;
   jobs?: JobHandle[];
+  /** The project root — the working directory a literate `serve:` command runs from. */
+  root?: string;
   server?: ServerPort;
+  /**
+   * Named servers a literate `.cli` header may start (`serve: mcp KEY=value`).
+   * Declared once per app in `specification.cli()`.
+   */
+  serveRegistry?: Record<string, LiterateServeRegistration>;
   /**
    * The declared services record. In cli mode, drives the automatic
    * connection-URL injection into the child env (CONVENTIONS B6):
@@ -1230,6 +1284,14 @@ interface CliSpecification<DatabaseKey extends string = string> {
    * timeout.
    */
   exec: (args?: string | string[], options?: ExecOptions) => Promise<CliResult>;
+  /**
+   * Run a literate `<case>.cli` spec — its header (fixtures, env sets,
+   * servers) and every `$` block, each asserted — and resolve with the LAST
+   * block's result, so a `.test.ts` can add an assertion the file cannot
+   * express (a directory golden, a grep). The path is relative to the test
+   * file's own directory, where the `.cli` lives.
+   */
+  run: (file: string, options?: LiterateRunFlags) => Promise<CliResult>;
 }
 /**
  * The `website` facet — page chain entry handed out by
@@ -1561,6 +1623,20 @@ interface CliSpecificationOptions<Services extends ServiceRecord = ServiceRecord
    * containers get force-removed at scope exit (CONVENTIONS B5).
    */
   docker?: DockerSpecConfig;
+  /**
+   * Named environment SETS for literate `.cli` specs. A header line
+   * `env: frozen` applies the whole `frozen` record; `$WORKDIR` expands and
+   * `null` unsets, exactly as in `.env()`. Declared once per app so a
+   * scenario file states WHICH ground it stands on, not how to build it.
+   */
+  env?: Record<string, CliEnv>;
+  /**
+   * Named servers a literate `.cli` header may start (`serve: mcp KEY=value`).
+   * Each entry names the shell `command`, the `ready` regex whose capture
+   * group holds the port the server announces, the `url(port)` builder, and
+   * the `env` variable that URL is bound to in every block's child.
+   */
+  serve?: Record<string, LiterateServeRegistration>;
   /**
    * Project-root override (CONVENTIONS A9) — the single meaning of `root`:
    * it anchors compose detection and local-bin resolution for the tested
@@ -1699,14 +1775,24 @@ interface MobileHandle {
 declare function startMobile(options: MobileSpecificationOptions): Promise<MobileHandle>;
 //#endregion
 //#region src/core/specification/website/serve.adapter.d.ts
-/** Options for the local server started by `specification.website()`. */
+/** Options for a local server started by the framework. */
 interface ServeOptions {
   /** Shell command that starts the site. Receives the chosen port as `PORT`. */
   command: string;
   /** Fixed port. Default: an OS-assigned free port, injected as `PORT`. */
   port?: number;
-  /** Path polled until it answers with any HTTP status. Default `/`. */
-  ready?: string;
+  /**
+   * How readiness is observed. Two forms:
+   *
+   * - a **path** (or nothing) — the framework picks the port, injects it as
+   *   `PORT`, and polls `<baseUrl><path>` until it answers any HTTP status
+   *   (default `/`). This is `specification.website()`'s form.
+   * - a **regex over the child's output** with ONE capture group holding the
+   *   port the server chose itself. Nothing is injected as `PORT`: the server
+   *   announces its port and the framework reads it from the banner. This is
+   *   the form a literate `serve:` registration uses.
+   */
+  ready?: RegExp | string;
   /** Readiness budget in milliseconds. Default 30 000. */
   timeout?: number;
 }
@@ -1840,6 +1926,85 @@ declare const specification: {
   website: typeof startWebsite;
 };
 //#endregion
+//#region src/core/literate/literate-file.d.ts
+/**
+ * Parser / serializer for `<case>.cli` literate spec files.
+ *
+ * A literate spec is ONE scenario in one file: a header of `key: value` lines
+ * (the narrative and the ground the run stands on), a blank line, then one or
+ * more `$ <argv>` blocks holding the expected exit code and streams.
+ *
+ *     test: refuses to guess when it is run outside the checkout
+ *     given: a workdir with no home/ + apps/ pair anywhere above it
+ *     then: the error names where the command has to be run
+ *     fixture: $FIXTURES/repositories-stub/
+ *     env: frozen TERRA_ORIGIN=http://127.0.0.1:9
+ *     serve: mcp MCP_STUB_WITHHOLD=get-article
+ *
+ *     $ terra git repositories
+ *     exit: 1
+ *     --- stderr
+ *     Error: no directory with home/ and apps/ above the current directory
+ *
+ * The shape mirrors the `.http` grammar (a start section, then a body split at
+ * the first blank line) so a reader who knows one knows the other. The parser
+ * is pure text: it resolves nothing, runs nothing, and knows no filesystem.
+ */
+/** One `KEY=value` (or a bare word naming a registered env set) from an `env:` line. */
+type LiterateEnvToken = {
+  key: string;
+  kind: 'pair';
+  value: string;
+} | {
+  kind: 'set';
+  name: string;
+};
+/** One `serve:` line — a registered server name plus the extra env it is started with. */
+interface LiterateServeEntry {
+  env: Record<string, string>;
+  line: number;
+  name: string;
+}
+/**
+ * The header of a literate spec — everything before the first blank line.
+ *
+ * The field names ARE the grammar keys, `then:` included: a reader must be able
+ * to move between the file and this type without a translation table. The
+ * thenable hazard the linter guards is not reachable here — a header is data
+ * read out of a `LiterateSpec`, never a value the framework awaits.
+ */
+interface LiterateHeader {
+  /** `env:` lines, flattened to their tokens in declaration order. */
+  env: LiterateEnvToken[];
+  /** `fixture:` paths, in declaration order (they layer). */
+  fixtures: string[];
+  given: string;
+  /** `serve:` lines, in declaration order. */
+  serve: LiterateServeEntry[];
+  /** The vitest test title. */
+  test: string;
+  then: string;
+}
+/** One `$ <argv>` block: the command, its exit code, and both streams verbatim. */
+interface LiterateBlock {
+  /** The command line, exactly as written after `$ ` (may be empty). */
+  argv: string;
+  exitCode: number;
+  /** 1-based line of the `$ ` line in the source file. */
+  line: number;
+  /** Expected stderr; `null` when the block declares no `--- stderr` section. */
+  stderr: null | string;
+  /** Expected stdout, verbatim (no trailing newline). */
+  stdout: string;
+}
+/** A parsed `<case>.cli` file. */
+interface LiterateSpec {
+  blocks: LiterateBlock[];
+  header: LiterateHeader;
+  /** The header text verbatim, including its trailing blank line — never rewritten. */
+  headerText: string;
+}
+//#endregion
 //#region src/integrations/docker/docker-lookup.d.ts
 /** Return all container IDs (running or stopped) that carry `key=value`. */
 declare function findContainersByLabel(key: string, value: string): string[];
@@ -2262,7 +2427,7 @@ declare const mockOfDate: MockDatePort;
 //#endregion
 //#region src/index.d.ts
 declare module 'vitest' {
-  interface Matchers<T = any> {
+  interface Assertion<T = any> {
     /**
      * Assert the subject is empty — zero rows for a table (async), an
      * empty stream for a text accessor (console, errors, stdout).
@@ -2272,17 +2437,6 @@ declare module 'vitest' {
     } ? () => Promise<void> : never;
     /** Assert the container is running. Async — docker-backed subject. */
     toBeRunning: T extends ContainerAccessor ? () => Promise<void> : never;
-    /**
-     * Assert the table contains exactly the given rows for the given
-     * columns. Cells accept `match.*` dynamic-value matchers. Async —
-     * queries the database.
-     */
-    toMatchRows: T extends TableAccessor ? (expected: {
-      columns: string[];
-      rows: readonly (readonly unknown[])[];
-    }) => Promise<void> : never;
-  }
-  interface Assertion<T = any> {
     /**
      * On `@jterrazz/test` accessors: assert the subject matches a fixture
      * file under `expected/<name>` (flat — a slash creates a subfolder;
@@ -2297,7 +2451,16 @@ declare module 'vitest' {
      * the behaviour under test.
      */
     toMatch: T extends DirectoryAccessor | FilesystemAccessor ? (name: RegExp | string, options?: MatchFixtureOptions) => Promise<void> : T extends JsonAccessor | ResponseAccessor | TextAccessor ? (name: RegExp | string, options?: MatchFixtureOptions) => void : (expected: RegExp | string, options?: MatchFixtureOptions) => void;
+    /**
+     * Assert the table contains exactly the given rows for the given
+     * columns. Cells accept `match.*` dynamic-value matchers. Async —
+     * queries the database.
+     */
+    toMatchRows: T extends TableAccessor ? (expected: {
+      columns: string[];
+      rows: readonly (readonly unknown[])[];
+    }) => Promise<void> : never;
   }
 }
 //#endregion
-export { type ApiHandle, type ApiSpecification, type ApiSpecificationOptions, BaseResult, type BrowserConsoleMessage, type BrowserLinkElement, type BrowserMetaElement, type BrowserOpenOptions, type BrowserPage, type BrowserPort, type CaptureScope, type CliEnv, type CliHandle, type CliOutput, type CliPort, CliResult, type CliSpecification, type CliSpecificationOptions, ContainerAccessor, type ContainerPort, type Contract, type ContractInput, type ContractRequest, type ContractResponder, type ContractResponse, type ContractResponseValue, type Contracts, type DatabaseKeys, type DatabasePort, type DeviceOpenOptions, type DevicePort, type DeviceScreen, DirectoryAccessor, type DockerSpecConfig, type ElementKind, type ElementMatch, type ElementOptions, type ElementRef, type ExecOptions, FetchResult, type FileAccessor, FilesystemAccessor, type HonoApp, type HttpContractFilter, type HttpResponseInit, HttpResult, type IsolationStrategy, type JobHandle, type JobsHandle, type JobsSpecification, type JobsSpecificationOptions, JsonAccessor, type LandmarkKind, type MatchFixtureOptions, type MatchableRequest, Matcher, type MatcherKind, type MobileBackendOptions, type MobileElementKind, type MobileElementMatch, type MobileElementRef, type MobileHandle, type MobileScenario, type MobileSpecification, type MobileSpecificationOptions, type MobileVisitor, type MockDatePort, type MockPort, Orchestrator, PageResult, type PostgresOptions, type RedisOptions, ResponseAccessor, type ScreenNode, ScreenResult, type ServeOptions, type ServerPort, type ServerResponse, type ServiceHandle, type ServiceRecord, type SpecificationConfig, type SpecificationMode, type SqliteOptions, TableAccessor, TextAccessor, type TextFilter, type VisitScenario, type Visitor, type WebsiteBackendOptions, type WebsiteHandle, type WebsiteSpecification, type WebsiteSpecificationOptions, anthropic, banner, button, complementary, content, contentinfo, defineContract, defineContracts, field, findContainersByLabel, form, heading, http, inspectContainer, link, main, match, mockOf, mockOfDate, navigation, openai, postgres, redis, region, removeContainers, search, specification, sqlite, testId, text, within };
+export { type ApiHandle, type ApiSpecification, type ApiSpecificationOptions, BaseResult, type BrowserConsoleMessage, type BrowserLinkElement, type BrowserMetaElement, type BrowserOpenOptions, type BrowserPage, type BrowserPort, type CaptureScope, type CliEnv, type CliHandle, type CliOutput, type CliPort, CliResult, type CliSpecification, type CliSpecificationOptions, ContainerAccessor, type ContainerPort, type Contract, type ContractInput, type ContractRequest, type ContractResponder, type ContractResponse, type ContractResponseValue, type Contracts, type DatabaseKeys, type DatabasePort, type DeviceOpenOptions, type DevicePort, type DeviceScreen, DirectoryAccessor, type DockerSpecConfig, type ElementKind, type ElementMatch, type ElementOptions, type ElementRef, type ExecOptions, FetchResult, type FileAccessor, FilesystemAccessor, type HonoApp, type HttpContractFilter, type HttpResponseInit, HttpResult, type IsolationStrategy, type JobHandle, type JobsHandle, type JobsSpecification, type JobsSpecificationOptions, JsonAccessor, type LandmarkKind, type LiterateBlock, type LiterateHeader, type LiterateRunFlags, type LiterateServeRegistration, type LiterateSpec, type MatchFixtureOptions, type MatchableRequest, Matcher, type MatcherKind, type MobileBackendOptions, type MobileElementKind, type MobileElementMatch, type MobileElementRef, type MobileHandle, type MobileScenario, type MobileSpecification, type MobileSpecificationOptions, type MobileVisitor, type MockDatePort, type MockPort, Orchestrator, PageResult, type PostgresOptions, type RedisOptions, ResponseAccessor, type ScreenNode, ScreenResult, type ServeOptions, type ServerPort, type ServerResponse, type ServiceHandle, type ServiceRecord, type SpecificationConfig, type SpecificationMode, type SqliteOptions, TableAccessor, TextAccessor, type TextFilter, type VisitScenario, type Visitor, type WebsiteBackendOptions, type WebsiteHandle, type WebsiteSpecification, type WebsiteSpecificationOptions, anthropic, banner, button, complementary, content, contentinfo, defineContract, defineContracts, field, findContainersByLabel, form, heading, http, inspectContainer, link, main, match, mockOf, mockOfDate, navigation, openai, postgres, redis, region, removeContainers, search, specification, sqlite, testId, text, within };