@jterrazz/test 15.1.1 → 15.3.0

package/dist/index.d.ts

@@ -1,117 +1,7 @@
 import { Scalar } from "yaml";
-import { DeepMockProxy } from "vitest-mock-extended";
-//#region src/specification/matching/match.d.ts
-/**
- * Code-side dynamic-value matchers (`match.*`) and the capture scope shared
- * by every assertion of a single spec execution.
- *
- * Matchers are used inside `toMatchRows` rows and any structural comparison;
- * their file-side twins are the `{{placeholder}}` forms in `_expected/*.http`
- * fixtures (body AND headers), `_expected/*.json` files, and text snapshots
- * (`_expected/*.txt`). One grammar, one vocabulary (CONVENTIONS D4).
- */
-/** The frozen token vocabulary (CONVENTIONS D4) plus the code-only kinds. */
-type MatcherKind = 'any' | 'base64' | 'date' | 'duration' | 'email' | 'float' | 'hex' | 'includes' | 'int' | 'ip' | 'iso8601' | 'number' | 'path' | 'port' | 'ref' | 'regex' | 'semver' | 'sha' | 'string' | 'time' | 'ulid' | 'url' | 'uuid' | 'workdir';
-/** Every kind usable as a `{{token}}` in fixture files (all but ref/regex/includes). */
-declare const TOKEN_KINDS: readonly ["any", "base64", "date", "duration", "email", "float", "hex", "int", "ip", "iso8601", "number", "path", "port", "semver", "sha", "string", "time", "ulid", "url", "uuid", "workdir"];
-/** A token kind valid inside a fixture `{{...}}` placeholder. */
-type TokenKind = (typeof TOKEN_KINDS)[number];
-/**
- * A dynamic-value matcher. Created via the {@link match} factories — never
- * constructed directly by user code.
- */
-declare class Matcher {
-  /** For kind 'includes': the substring the actual value must contain. */
-  readonly includes?: string | undefined;
-  readonly kind: MatcherKind;
-  /** For kind 'ref': the capture to assert inequality against. */
-  readonly notRef?: string | undefined;
-  /** For kind 'ref': the capture name. */
-  readonly refName?: string | undefined;
-  /** For kind 'regex': the pattern the actual value must match. */
-  readonly regex?: RegExp | undefined;
-  constructor(kind: MatcherKind, options?: {
-    includes?: string | undefined;
-    notRef?: string | undefined;
-    refName?: string | undefined;
-    regex?: RegExp | undefined;
-  });
-  /** Placeholder-style rendering used in failure diffs and serialization. */
-  toString(): string;
-  toJSON(): string;
-}
-/** A no-argument matcher factory — what every typed entry of `match` is. */
-type TypedMatcher = () => Matcher;
-/**
- * Dynamic-value matchers for structural comparisons — the code-side mirror of
- * the `{{token}}` fixture grammar (CONVENTIONS D4).
- *
- * @example
- *   await expect(result.table('users', { database: 'db' })).toMatchRows({
- *       columns: ['id', 'name'],
- *       rows: [[match.uuid(), 'Alice']],
- *   });
- */
-/**
- * The matcher roster: one no-argument factory per token kind, plus the three
- * code-only forms the `{{token}}` grammar does not carry.
- */
-type MatchFactories = Record<TokenKind, TypedMatcher> & {
-  includes: (substring: string) => Matcher;
-  ref: (name: string, options?: {
-    not?: string;
-  }) => Matcher;
-  regex: (regex: RegExp) => Matcher;
-};
-declare const match: MatchFactories;
-/**
- * Named captures recorded by `match.ref()` / `{{type#ref}}` placeholders.
- * One scope lives on each spec result — every assertion chained off the same
- * result shares it, and a new chain starts fresh.
- */
-declare class CaptureScope {
-  private readonly values;
-  /**
-   * The exact working directory of the current spec, when the framework
-   * knows it (cli mode). Drives the `{{workdir}}` token / `match.workdir()`.
-   */
-  workdir?: string | undefined;
-  constructor(workdir?: string);
-  get(name: string): unknown;
-  has(name: string): boolean;
-  set(name: string, value: unknown): void;
-}
-//#endregion
-//#region src/specification/facets/_common/result/json.d.ts
-/**
- * Read-only accessor for a JSON payload parsed from a text stream (stdout).
- *
- * Lazily parses the JSON on first use; parse errors are deferred until the
- * value is read so that callers can still read the raw stream text without
- * triggering a throw.
- *
- * ANSI escape sequences are stripped by default before `JSON.parse`
- * (CONVENTIONS D6). When a `transform` is configured on the spec runner, it
- * runs on the stripped text — an escape hatch for application noise not
- * covered by the `{{token}}` grammar.
- *
- * Assertions go through `expect()`: `expect(result.json).toMatch('name.json')`
- * (deep-equal against `_expected/<name>`, with `{{placeholder}}` support).
- */
-declare class JsonAccessor {
-  /** @internal Ref-capture scope shared by the current spec execution. */
-  readonly captures: CaptureScope;
-  /** @internal */
-  private readonly rawText;
-  /** @internal Test-file directory — fixture resolution root for matchers. */
-  readonly testDir: string;
-  /** @internal */
-  private readonly transform?;
-  constructor(rawText: string, testDir: string, transform?: (text: string) => string, captures?: CaptureScope);
-  /** The parsed JSON value. Throws if the text is not valid JSON. */
-  get value(): unknown;
-}
-//#endregion
+import { DeepMockProxy, MockProxy } from "vitest-mock-extended";
+import { ReactNode as ComponentUi } from "react";
+import "vitest/browser";
 //#region src/specification/contracts/types.d.ts
 /**
  * The observed outgoing request, reduced to what contract matchers inspect.
@@ -155,12 +45,51 @@ type ContractRequest = {
 type ContractResponse = {
   /** HTTP status code (default: 200). */
   status?: number;
-  /** Response body — an object is JSON, a string is text, `null`/`undefined` is empty. */
+  /**
+   * Response body — an object is JSON, a string is text, `null`/`undefined`
+   * is empty, and a {@link StreamBody} (built by `http.stream()` /
+   * `http.sse()`) arrives in pieces.
+   */
   body: unknown;
   /** Response headers. */
   headers?: Record<string, string> | undefined;
   /** Delay in ms before responding (for timeout testing). */
   delay?: number | undefined;
+  /**
+   * A transport failure instead of a reply: the request never reached a
+   * server, so `fetch` rejects. `status`, `body` and `headers` say nothing
+   * here — there is no response to carry them.
+   *
+   * The one thing a status code cannot express. A component's "the server did
+   * not answer, check that it is running" branch is reached by a rejected
+   * `fetch`, and a 503 stand-in tests the other branch entirely.
+   */
+  transport?: 'network-error' | undefined;
+};
+/**
+ * The marker that tells a STREAMED body from a value that happens to be an
+ * object. A body reaches three different engines (msw's server, msw's worker,
+ * the `node:http` stub) and each of them serialises "an object" as JSON, so a
+ * stream declared as a plain value arrives as `{}`. The tag is what each
+ * engine recognises before it reaches for `JSON.stringify`.
+ */
+declare const STREAM_BODY = "@jterrazz/test:stream";
+/**
+ * A body that arrives in pieces — what `http.stream()` and `http.sse()` build.
+ *
+ * The chunks are written in order, `delayBetweenChunks` milliseconds apart,
+ * and the connection closes after the last one. It is the chunks and their
+ * ORDER that a streaming subject is specified against: a client that renders
+ * tokens as they land, or one that reconnects on a half-read body.
+ */
+type StreamBody = {
+  /** The pieces, written in order. */
+  chunks: readonly string[];
+  /** The `content-type` the stream is served under. */
+  contentType: string;
+  /** Milliseconds between two chunks. Default 0 — everything at once. */
+  delayBetweenChunks: number;
+  kind: typeof STREAM_BODY;
 };
 /**
  * A dynamic response: computed from the observed request at the moment the
@@ -260,6 +189,144 @@ declare function defineContract(contract: Contract): Contract;
  */
 declare function defineContracts(...items: ContractInput[]): Contracts;
 //#endregion
+//#region src/integrations/msw/scope.d.ts
+/**
+ * One block's worth of declared network. Disposed at the end of the scope that
+ * declared it: the handlers are dropped, and an unmatched request is thrown.
+ */
+type InterceptScope = AsyncDisposable;
+/**
+ * The module-scope network double. Resolves once the engine is listening —
+ * which is why it is a promise, and why the canonical form awaits it:
+ *
+ * ```typescript
+ * await using _ = await intercept(http.get(url), http.json({ ok: true }));
+ * ```
+ *
+ * Without that `await` the subject could reach the real network before the
+ * first handler is in place, so the shape refuses the racy spelling: a promise
+ * is not an `AsyncDisposable`, and the compiler says so.
+ */
+type Intercept = ((contracts: ContractInput) => Promise<InterceptScope>) & ((request: ContractRequest, response: ContractResponder | ContractResponse) => Promise<InterceptScope>);
+//#endregion
+//#region src/specification/matching/match.d.ts
+/**
+ * Code-side dynamic-value matchers (`match.*`) and the capture scope shared
+ * by every assertion of a single spec execution.
+ *
+ * Matchers are used inside `toMatchRows` rows and any structural comparison;
+ * their file-side twins are the `{{placeholder}}` forms in `_expected/*.http`
+ * fixtures (body AND headers), `_expected/*.json` files, and text snapshots
+ * (`_expected/*.txt`). One grammar, one vocabulary (CONVENTIONS D4).
+ */
+/** The frozen token vocabulary (CONVENTIONS D4) plus the code-only kinds. */
+type MatcherKind = 'any' | 'base64' | 'date' | 'duration' | 'email' | 'float' | 'hex' | 'includes' | 'int' | 'ip' | 'iso8601' | 'number' | 'path' | 'port' | 'ref' | 'regex' | 'semver' | 'sha' | 'string' | 'time' | 'ulid' | 'url' | 'uuid' | 'workdir';
+/** Every kind usable as a `{{token}}` in fixture files (all but ref/regex/includes). */
+declare const TOKEN_KINDS: readonly ["any", "base64", "date", "duration", "email", "float", "hex", "int", "ip", "iso8601", "number", "path", "port", "semver", "sha", "string", "time", "ulid", "url", "uuid", "workdir"];
+/** A token kind valid inside a fixture `{{...}}` placeholder. */
+type TokenKind = (typeof TOKEN_KINDS)[number];
+/**
+ * A dynamic-value matcher. Created via the {@link match} factories — never
+ * constructed directly by user code.
+ */
+declare class Matcher {
+  /** For kind 'includes': the substring the actual value must contain. */
+  readonly includes?: string | undefined;
+  readonly kind: MatcherKind;
+  /** For kind 'ref': the capture to assert inequality against. */
+  readonly notRef?: string | undefined;
+  /** For kind 'ref': the capture name. */
+  readonly refName?: string | undefined;
+  /** For kind 'regex': the pattern the actual value must match. */
+  readonly regex?: RegExp | undefined;
+  constructor(kind: MatcherKind, options?: {
+    includes?: string | undefined;
+    notRef?: string | undefined;
+    refName?: string | undefined;
+    regex?: RegExp | undefined;
+  });
+  /** Placeholder-style rendering used in failure diffs and serialization. */
+  toString(): string;
+  toJSON(): string;
+}
+/** A no-argument matcher factory — what every typed entry of `match` is. */
+type TypedMatcher = () => Matcher;
+/**
+ * Dynamic-value matchers for structural comparisons — the code-side mirror of
+ * the `{{token}}` fixture grammar (CONVENTIONS D4).
+ *
+ * @example
+ *   await expect(result.table('users', { database: 'db' })).toMatchRows({
+ *       columns: ['id', 'name'],
+ *       rows: [[match.uuid(), 'Alice']],
+ *   });
+ */
+/**
+ * The matcher roster: one no-argument factory per token kind, plus the three
+ * code-only forms the `{{token}}` grammar does not carry.
+ */
+type MatchFactories = Record<TokenKind, TypedMatcher> & {
+  includes: (substring: string) => Matcher;
+  ref: (name: string, options?: {
+    not?: string;
+  }) => Matcher;
+  regex: (regex: RegExp) => Matcher;
+};
+declare const match: MatchFactories;
+/**
+ * Named captures recorded by `match.ref()` / `{{type#ref}}` placeholders.
+ * One scope lives on each spec result — every assertion chained off the same
+ * result shares it, and a new chain starts fresh.
+ */
+declare class CaptureScope {
+  private readonly values;
+  /**
+   * The exact working directory of the current spec, when the framework
+   * knows it (cli mode). Drives the `{{workdir}}` token / `match.workdir()`.
+   */
+  workdir?: string | undefined;
+  constructor(workdir?: string);
+  get(name: string): unknown;
+  has(name: string): boolean;
+  set(name: string, value: unknown): void;
+}
+//#endregion
+//#region src/specification/facets/_common/result/json.d.ts
+/**
+ * Read-only accessor for a JSON payload parsed from a text stream (stdout).
+ *
+ * Lazily parses the JSON on first use; parse errors are deferred until the
+ * value is read so that callers can still read the raw stream text without
+ * triggering a throw.
+ *
+ * ANSI escape sequences are stripped by default before `JSON.parse`
+ * (CONVENTIONS D6). When a `transform` is configured on the spec runner, it
+ * runs on the stripped text — an escape hatch for application noise not
+ * covered by the `{{token}}` grammar.
+ *
+ * Assertions go through `expect()`: `expect(result.json).toMatch('name.json')`
+ * (deep-equal against `_expected/<name>`, with `{{placeholder}}` support).
+ */
+declare class JsonAccessor<Value = unknown> {
+  /** @internal Ref-capture scope shared by the current spec execution. */
+  readonly captures: CaptureScope;
+  /** @internal */
+  private readonly rawText;
+  /** @internal Test-file directory — fixture resolution root for matchers. */
+  readonly testDir: string;
+  /** @internal */
+  private readonly transform?;
+  constructor(rawText: string, testDir: string, transform?: (text: string) => string, captures?: CaptureScope);
+  /**
+   * The parsed JSON value. Throws if the text is not valid JSON.
+   *
+   * `Value` is `unknown` unless the subject that produced this accessor
+   * knows better — `.call<T>()` does, and hands its T straight through so a
+   * one-field reading needs no cast in the test.
+   */
+  get value(): Value;
+}
+//#endregion
 //#region src/specification/ports/browser.port.d.ts
 /**
  * The landmark roles — the standard set of page regions, and the only
@@ -267,8 +334,15 @@ declare function defineContracts(...items: ContractInput[]): Contracts;
  * so `within()` never becomes a second selector language.
  */
 type LandmarkKind = 'banner' | 'complementary' | 'contentinfo' | 'form' | 'main' | 'navigation' | 'region' | 'search';
-/** The interactive//textual element kinds — what a visitor actually acts on. */
-type ElementKind = 'button' | 'field' | 'heading' | 'link' | 'testId' | 'text';
+/**
+ * The interactive/textual element kinds — what a visitor actually acts on.
+ *
+ * `dialog`, `status`, `table`, `row`, `listitem` and `option` are ARIA roles
+ * like the landmarks, but they are not CONTAINERS of a page: they are things a
+ * visitor reads and acts on, and they are the roles the estate's UI specs were
+ * already reaching for through `getByRole` or, worse, through `.first()`.
+ */
+type ElementKind = 'button' | 'dialog' | 'field' | 'heading' | 'link' | 'listitem' | 'option' | 'row' | 'status' | 'table' | 'testId' | 'text';
 /**
  * A user-facing element descriptor — pure data, built by the element
  * vocabulary (`button()`, `link()`, `field()`, …) and translated into
@@ -285,9 +359,37 @@ type ElementRef = {
    * "Read Articles".
    */
   exact?: boolean;
+  /**
+   * Assert about the element's FOCUS rather than its presence — built by
+   * `focused(element)`. The accessibility tree carries no focus state, so
+   * where the keyboard is cannot be goldened; it is asserted by a verb.
+   */
+  focused?: boolean;
+  /**
+   * Narrows to "and it is (not) accepting input" — built by `disabled(x)` /
+   * `enabled(x)`. Like `focused`, a STATE the vocabulary can already name the
+   * element of; unlike it, one the ARIA tree carries too (`[disabled]`), so
+   * this modifier is what names the ONE control a test is about, and it
+   * reaches the direction a behavioural substitute cannot — clicking a
+   * disabled control is a timeout, never an answer.
+   */
+  disabled?: boolean;
   kind: ElementKind | LandmarkKind;
   /** Landmarks may be anonymous (`main()`, `banner()`); everything else is named. */
   name?: string;
+  /**
+   * Narrows to "and it is (not) the chosen one" — built by `selected(x)`.
+   * An option of a COLLAPSED select is in the tree and in the document, and
+   * it has no box on the screen, so this facet of it is read from the node
+   * (`:checked`) rather than from what a visitor could point at.
+   */
+  selected?: boolean;
+  /**
+   * The value the field must hold — built by `valued(field('Title'), '…')`.
+   * A field's value is a PROPERTY of the node: a controlled input's `value`
+   * attribute never moves, so nothing but the live value answers for it.
+   */
+  value?: string;
   /**
    * Restrict the search to the elements of another descriptor — built by
    * `within(scope, target)`. Chains: a scope may itself carry a scope.
@@ -300,6 +402,12 @@ type ElementRef = {
  * without opening a browser.
  */
 type ElementMatch = {
+  /**
+   * The accessible name, when it differs from the text — an `aria-label` is
+   * what a role descriptor MATCHED on, and printing the text alone sends the
+   * author to disambiguate a name they cannot see.
+   */
+  accessibleName?: string | undefined;
   /** Nearest landmark ancestor (`nav`, `footer`, `main`…), when there is one. */
   context?: string | undefined;
   /** The attribute that disambiguates most — `href` for links, `name` for fields. */
@@ -340,7 +448,13 @@ type Visitor = {
   click: (element: ElementRef) => Promise<void>;
   /** Fill a form field with a value. */
   fill: (element: ElementRef, value: string) => Promise<void>;
-  /** Navigate to a path of the site under test. */
+  /**
+   * Wait until the element is GONE — hidden, or never in the document. The
+   * absence primitive: `see()` cannot answer "the dialog closed", because an
+   * element that never appears and one that disappeared read the same to it.
+   */
+  gone: (element: ElementRef) => Promise<void>;
+  /** Navigate to a path of the site under test. */
   goto: (path: string) => Promise<void>;
   /** Hover the element. */
   hover: (element: ElementRef) => Promise<void>;
@@ -365,6 +479,11 @@ type BrowserOpenOptions = {
    * and the boundary of the `external` policy.
    */
   baseUrl: string;
+  /**
+   * Pin the page's own `Date` at this instant before the first byte is
+   * parsed — the calendar the site's scripts read. `.clock()` on the chain.
+   */
+  clock?: string | undefined;
   /**
    * Cross-origin request policy. `'block'` aborts every request leaving
    * the site under test (analytics, CDNs) — the browser-side analog of
@@ -396,6 +515,8 @@ type BrowserPage = {
   status: number;
   /** Rendered `document.body.innerText`. */
   text: string;
+  /** The ARIA snapshot of the rendered `<body>` — the outline a golden pins. */
+  tree: string;
   /** `document.title` after rendering. */
   title: string;
   /** Final URL after redirects and scenario navigation. */
@@ -813,24 +934,6 @@ declare class TextAccessor {
   toString(): string;
   valueOf(): string;
 }
-/**
- * Wrap an arbitrary string into a {@link TextAccessor} anchored on the calling
- * test's directory — the same caller-detection the builders use.
- *
- * The product surface of a test framework is its own error messages, checker
- * output, and reports; those deserve the same goldening as any other output.
- * `text()` makes an ad-hoc string a first-class snapshot subject:
- *
- * ```typescript
- * const message = await catchMessage(() => expect(result.response).toMatch('wrong-body.http'));
- * expect(text(message)).toMatch('wrong-body-error.txt'); // resolves to _expected/
- * ```
- *
- * ANSI is stripped before every comparison (the raw form stays on `.text`),
- * the `{{token}}` grammar applies to the fixture, and `.grep()` composition
- * works exactly as on any stream accessor.
- */
-declare function text(value: string): TextAccessor;
 //#endregion
 //#region src/specification/facets/cli/result.d.ts
 /**
@@ -935,6 +1038,62 @@ type LiterateRunFlags = {
   frozen?: boolean | undefined;
 };
 //#endregion
+//#region src/specification/facets/integration/result.d.ts
+/** What `.call()` produced: the value it returned, or the error it threw. */
+type CallOutcome = {
+  error: unknown;
+  threw: boolean;
+  value: unknown;
+};
+type CallResultOptions = BaseResultOptions & {
+  outcome: CallOutcome;
+};
+/**
+ * What `result.value` is, decided by what the call returned: a string reads as
+ * a stream, anything else as JSON. `.call<T>()` already knows T, so the test
+ * reads one field (`result.value.value.ok`) without narrowing a union first.
+ */
+type CallValue<Returned> = Returned extends string ? TextAccessor : JsonAccessor<Returned>;
+/**
+ * The result of an in-process call — the integration facet's whole surface.
+ *
+ * Two readings, never both: `value` is what the call RETURNED, `error` is
+ * what it THREW. A module that refuses is specified the same way a module
+ * that answers is, and neither needs a `try`/`catch` in the test — which is
+ * the shape that used to make a refusal spec three times the size of the
+ * happy one, and the shape that quietly passes when nothing throws at all.
+ *
+ * Both are the package's ordinary accessors, so the golden mechanism reaches
+ * them, and `Returned` is what `.call<T>()` returned — `result.value.value` is
+ * that type, not `unknown`, so a one-field reading needs no golden file: `toMatch('<name>.json'|'<name>.txt')`, the `{{token}}` grammar,
+ * `{ frozen }` and `TEST_UPDATE=1` all work here exactly as on an HTTP
+ * response or a command's stdout.
+ */
+declare class CallResult<Returned = unknown> extends BaseResult {
+  private readonly outcome;
+  constructor(options: CallResultOptions);
+  /**
+   * What the call THREW, as text — the message of an `Error`, the value
+   * itself when something else was thrown, and empty when it returned.
+   *
+   * Empty rather than absent on purpose: `await expect(result.error).toBeEmpty()`
+   * is how a spec says "and it did not refuse" — awaited, because the
+   * matcher answers a promise on every subject it takes, and a dropped one
+   * passes the test while the failure surfaces as an unhandled rejection
+   * (D2 refuses the bare form).
+   */
+  get error(): TextAccessor;
+  /**
+   * What the call RETURNED. A string reads as a stream (`<name>.txt`),
+   * anything else as JSON (`<name>.json`) — the same two subjects every
+   * other facet's results are built from.
+   *
+   * A call that threw returns the empty value: what it produced is
+   * {@link CallResult.error}.
+   */
+  get value(): CallValue<Returned>;
+}
+//#endregion
 //#region src/specification/facets/mobile/result.d.ts
 /** Result from a `.open()` action — the screen as the device saw it, final state. */
 declare class ScreenResult extends BaseResult {
@@ -1027,6 +1186,13 @@ declare class PageResult extends BaseResult {
   get status(): number;
   /** Rendered body text as a text accessor. */
   get content(): TextAccessor;
+  /**
+   * The ARIA snapshot of the rendered `<body>` — the page's outline, as the
+   * accessibility tree draws it, and the one golden a rendered surface pins.
+   * Deterministic where a screenshot is not, and the SAME dialect a component
+   * spec asserts, so a page and the components inside it read alike.
+   */
+  get tree(): TextAccessor;
   /** The document title as a text accessor. */
   get title(): TextAccessor;
   /** Final URL after redirects. */
@@ -1144,11 +1310,23 @@ type SpecificationConfig = {
    * facet factories auto-populate this when `dockerConfig` is present.
    */
   dockerTestRunId?: string | undefined;
+  /**
+   * Environment applied to every run of the declared binary
+   * (`specification.cli({ defaults })`) — under a chain's own `.env()` and
+   * under a document's `env:`, both of which win.
+   */
+  defaultEnv?: CliEnv | undefined;
   /**
    * Named environment SETS a spec document may name by bare word
    * (`env: frozen`). Declared once per app in `specification.cli()`.
    */
   envSets?: Record<string, CliEnv> | undefined;
+  /**
+   * When set, `.clock()` is unavailable on this runner and throws this
+   * reason immediately (compose mode — the calendar it would pin is this
+   * process's, and the app runs in a container).
+   */
+  clockDisabledReason?: string | undefined;
   /**
    * When set, `.intercept()` is unavailable on this runner and throws this
    * reason immediately (compose mode — MSW is in-process, CONVENTIONS I3).
@@ -1190,6 +1368,8 @@ type InterceptMethod<T> = ((contracts: ContractInput) => T) & ((request: Contrac
  * of the declared services record that are databases.
  */
 type ApiSpecification<DatabaseKey extends string = string> = {
+  /** Pin the app's `Date` at `iso` for this chain — the calendar the app reads. */
+  clock: (iso: string) => ApiSpecification<DatabaseKey>;
   /** Set HTTP headers for the request. Multiple calls merge. */
   headers: (headers: Record<string, string>) => ApiSpecification<DatabaseKey>;
   /** Declare outgoing calls — a contract, a list, a composite, or an inline request + response pair. */
@@ -1214,6 +1394,8 @@ type ApiSpecification<DatabaseKey extends string = string> = {
  * Jobs run in-process by definition (CONVENTIONS A5/A8).
  */
 type JobsSpecification<DatabaseKey extends string = string> = {
+  /** Pin the job's `Date` at `iso` for this chain — the calendar the job reads. */
+  clock: (iso: string) => JobsSpecification<DatabaseKey>;
   /** Declare outgoing calls — a contract, a list, a composite, or an inline request + response pair. */
   intercept: InterceptMethod<JobsSpecification<DatabaseKey>>;
   /** Queue a SQL seed file from `_seeds/` to run before the action. */
@@ -1223,6 +1405,31 @@ type JobsSpecification<DatabaseKey extends string = string> = {
   /** Execute the named job registered via the `jobs` option and resolve with the result. */
   trigger: (name: string) => Promise<BaseResult>;
 };
+/**
+ * The `integration` facet — the in-process chain handed out by
+ * `specification.integration()`.
+ *
+ * The subject is a MODULE, not an entry: no HTTP, no binary, no page. What
+ * makes it a spec rather than a module test is what it stands on — real
+ * services, declared contracts, a golden — so it takes the same setups as
+ * every other facet and ends on the one action a module has: being called.
+ */
+type IntegrationSpecification<Services extends Record<string, unknown> = Record<string, unknown>, DatabaseKey extends string = string> = {
+  /** Pin the module's `Date` at `iso` for this chain. */
+  clock: (iso: string) => IntegrationSpecification<Services, DatabaseKey>;
+  /** Declare outgoing calls — a contract, a list, a composite, or an inline request + response pair. */
+  intercept: InterceptMethod<IntegrationSpecification<Services, DatabaseKey>>;
+  /** Queue a SQL seed file from `_seeds/` to run before the call. */
+  seed: (file: string, options?: {
+    database?: DatabaseKey;
+  }) => IntegrationSpecification<Services, DatabaseKey>;
+  /**
+   * Call the module and resolve with what it produced. The started services
+   * record is handed in, so the subject is constructed with the real
+   * connection strings rather than with a double.
+   */
+  call: <T>(subject: (services: Services) => Promise<T> | T) => Promise<CallResult<T>>;
+};
 /**
  * The `cli` facet — command chain entry handed out by `specification.cli()`.
  * Setup methods chain; `.exec()` is the single terminal action (CONVENTIONS
@@ -1267,6 +1474,11 @@ type CliSpecification<DatabaseKey extends string = string> = {
  * performs one raw HTTP exchange and never follows redirects.
  */
 type WebsiteSpecification = {
+  /**
+   * Pin the PAGE's `Date` at `iso` for this chain — what the site's own
+   * scripts read. A `.fetch()` opens no page and refuses the setup.
+   */
+  clock: (iso: string) => WebsiteSpecification;
   /** Set HTTP headers for the exchange (incl. User-Agent overrides). Multiple calls merge. */
   headers: (headers: Record<string, string>) => WebsiteSpecification;
   /**
@@ -1441,7 +1653,16 @@ declare class ContainerAccessor {
   private containerExec;
 }
 //#endregion
-//#region src/vitest/matchers.d.ts
+//#region src/specification/facets/_common/result/match-options.d.ts
+/**
+ * The per-call option both `toMatch` implementations honour.
+ *
+ * A golden is read from disk under node and through a server command from
+ * inside a page, and BOTH builds must answer `{ frozen: true }` the same way —
+ * so the option is declared here, where the node matchers and the page's
+ * matchers can each reach it, rather than in the runner's own folder, which a
+ * seam may not import (rule I1).
+ */
 /**
  * Per-call options for the fixture-file `toMatch` subjects. `frozen` opts a
  * single fixture OUT of update-mode rewriting: a frozen fixture is NEVER
@@ -1456,180 +1677,875 @@ type MatchFixtureOptions = {
   frozen?: boolean;
 };
 //#endregion
-//#region src/specification/facets/_common/orchestrator.d.ts
-type OrchestratorOptions = {
-  /**
-   * Named infrastructure record. Keys become the database vocabulary of the
-   * spec (`.seed()` / `.table()` `database` option) and drive the compose
-   * binding: a handle with no explicit `composeService` links to the compose
-   * service named exactly like its key, else the kebab-case conversion of the
-   * key (`analyticsDb` → `analytics-db`) — see {@link resolveComposeBinding}.
-   */
-  services: Record<string, ServiceHandle>;
-  mode: 'e2e' | 'integration';
-  /**
-   * The project root, already resolved. REQUIRED: the constructors derive it
-   * by walking up from the calling specification file (CONVENTIONS A9), and
-   * the orchestrator is handed the answer. Defaulting to `process.cwd()` here
-   * meant one silent second opinion about what the project is — the runner
-   * resolving from the caller, this from wherever the runner happened to be
-   * launched, which in a workspace is rarely the same directory.
-   */
-  root: string;
-  /** Compose project name — used for per-worker stack isolation. */
-  projectName?: string;
-};
+//#region src/integrations/vitest-browser/ui.d.ts
 /**
- * Orchestrator for test infrastructure.
- * Integration: starts services via testcontainers.
- * E2E: runs full docker compose up.
+ * A vanilla DOM subject: a function handed the container it must fill. Its
+ * optional return is the teardown, the way a DOM library states one.
  */
-declare class Orchestrator {
-  private readonly services;
-  private readonly mode;
-  private readonly root;
-  private readonly projectName;
-  private running;
-  private composeStack;
-  private composeHandles;
-  private started;
-  constructor(options: OrchestratorOptions);
-  /**
-   * Bind each declared handle to a compose service (CONVENTIONS A6): a record
-   * key resolves to the service named exactly like it, else the kebab-case
-   * conversion of the key; an explicit `composeService` wins. Throws on an
-   * ambiguous binding (both names present). Runs once compose config is known
-   * so the two-step resolution can consult the real service list.
-   */
-  private resolveBindings;
-  /**
-   * Start declared services via testcontainers (integration mode).
-   * Phase 1: start all containers in parallel (the slow part).
-   * Phase 2: wire connections, healthcheck, and init sequentially (fast).
-   */
-  start(): Promise<void>;
-  /**
-   * Stop testcontainers (integration mode).
-   */
-  stop(): Promise<void>;
-  /**
-   * Start full docker compose stack (e2e mode).
-   * Auto-detects infra services and creates handles for them.
-   */
-  startCompose(): Promise<void>;
-  /**
-   * Stop docker compose stack (e2e mode).
-   */
-  stopCompose(): Promise<void>;
-  /**
-   * Get the default database — the first declared handle that is one.
-   */
-  getDatabase(): DatabasePort | null;
-  /**
-   * Get all database services keyed by their record key (declared services)
-   * or compose service name (stack-detected services).
-   */
-  getDatabases(): Map<string, DatabasePort>;
-  private allHandles;
-  /**
-   * Get app URL from compose (e2e mode).
-   */
-  getAppUrl(): null | string;
+type DomMount = (container: HTMLElement) => (() => void) | void;
+/**
+ * The `server.commands` this seam registers, declared in the module every part
+ * of the seam already imports.
+ *
+ * A `declare module` merges only as an interface, and only from a file that is
+ * itself a module and part of the program — a lone `.d.ts` would have to be
+ * pulled in by an empty import, and its single `export {}` is exactly what a
+ * formatter is free to drop, turning the augmentation into an ambient
+ * declaration that SHADOWS the module it meant to extend.
+ */
+declare module 'vitest/browser' {
+  interface BrowserCommands {
+    ariaTree: () => Promise<string>;
+    goldenRead: (name: string) => Promise<null | string>;
+    goldenWrite: (name: string, content: string) => Promise<string>;
+  }
 }
 //#endregion
-//#region src/specification/facets/_common/services.d.ts
+//#region src/integrations/vitest-browser/vitest-browser.adapter.d.ts
+/** What a mounted subject offers the chain, React or vanilla DOM alike. */
+type MountedSurface = {
+  /** The element the subject was mounted into. */
+  container: HTMLElement;
+  /** Replace the rendered tree — a prop change, as a parent makes one. */
+  rerender: (ui: ComponentUi) => Promise<void>;
+  /** Take it off the screen, as a parent does. */
+  unmount: () => Promise<void>;
+};
+/** The verbs a rendered surface shares with a page, plus the two a parent owns. */
+declare function componentVerbs(surface: MountedSurface): {
+  check: (element: ElementRef) => Promise<void>;
+  click: (element: ElementRef) => Promise<void>;
+  fill: (element: ElementRef, value: string) => Promise<void>;
+  gone: (element: ElementRef) => Promise<void>;
+  hover: (element: ElementRef) => Promise<void>;
+  press: (key: string) => Promise<void>;
+  rerender: (ui: ComponentUi) => Promise<void>;
+  see: (element: ElementRef) => Promise<void>;
+  select: (element: ElementRef, option: string) => Promise<void>;
+  unmount: () => Promise<void>;
+};
+//#endregion
+//#region src/specification/facets/component/rendered-text.d.ts
 /**
- * Infrastructure services declared as a named record. Keys become the typed
- * vocabulary of the whole spec: the server factory receives the same record,
- * and `.seed()` / `.table()` target databases by key.
- */
-type ServiceRecord = Record<string, ServiceHandle>;
-/** Keys of a services record whose handles are databases. */
-type DatabaseKeys<Services extends ServiceRecord> = { [K in keyof Services]: Services[K] extends DatabasePort ? K & string : never; }[keyof Services];
+ * A stream captured INSIDE the page.
+ *
+ * Structurally identical to any other {@link TextAccessor} — the same
+ * `{{token}}` grammar, the same ANSI stripping, the same `.grep()` — and
+ * marked so the matcher augmentation can say the one thing that differs: its
+ * golden lives on the server, so `toMatch` is awaited here where it is
+ * synchronous everywhere else.
+ */
+declare class RenderedText extends TextAccessor {
+  /** The marker the `toMatch` overload reads. Never asserted on directly. */
+  readonly capturedInPage: true;
+}
 //#endregion
-//#region src/specification/facets/api/start-api.d.ts
-/** Any object with a request method compatible with Hono's app.request(). */
-type HonoApp = {
-  request: (path: string, init?: RequestInit) => Promise<Response> | Response;
-};
-/** Execution mode — exists ONLY on `specification.api()` (CONVENTIONS A5). */
-type SpecificationMode = 'compose' | 'node';
-/** Options for {@link startApi | specification.api}. */
-type ApiSpecificationOptions<Services extends ServiceRecord = ServiceRecord> = {
-  /**
-   * Execution mode override. Resolution: `options.mode` >
-   * `process.env.TEST_MODE` > `'node'`. Never hardcode this in a
-   * specification file when `server` is defined — set it per vitest
-   * project via `env: { TEST_MODE: 'compose' }` (CONVENTIONS A5).
-   */
-  mode?: SpecificationMode;
+//#region src/specification/facets/component/component.result.d.ts
+/**
+ * What a render resolves to — the component as the page saw it, after the
+ * scenario ran.
+ *
+ * Five accessors and no more: the ARIA outline a golden pins, the two
+ * renderings a probe reads, and the two streams a spec wants silent. Nothing
+ * here reaches back into React — a spec that needs the component's internals
+ * is asserting the implementation, not the surface a user meets.
+ */
+declare class RenderResult {
+  /** The browser console as a stream — one `[type] text` line per message. */
+  readonly console: RenderedText;
+  /** Rendered text of the whole document body (`innerText`). */
+  readonly content: RenderedText;
+  /** Console messages of type `error` only, plus any uncaught page error. */
+  readonly errors: RenderedText;
+  /** The mounted markup, serialised — the escape hatch for a class or an attribute. */
+  readonly html: RenderedText;
+  /** The ARIA snapshot of the rendered body — the outline a golden pins. */
+  readonly tree: RenderedText;
+  constructor(streams: {
+    console: string;
+    content: string;
+    errors: string;
+    html: string;
+    tree: string;
+  });
+}
+//#endregion
+//#region src/specification/facets/component/component.types.d.ts
+/**
+ * The component facet's shape, stated where BOTH runtimes can read it.
+ *
+ * The page gets the working chain; node gets a stub under the same name and
+ * the same type, so a component test that ran in the wrong project fails on
+ * the line that rendered rather than on a missing export. The published types
+ * are the node build's, so this file is the one description of the facet.
+ */
+/** The interaction vocabulary a render scenario is handed — the When. */
+type ComponentVisitor = ReturnType<typeof componentVerbs>;
+/** The behaviour of a render; assertions stay in the Then, on the result (W1). */
+type ComponentScenario = (visitor: ComponentVisitor) => Promise<void>;
+/**
+ * What `.render()` mounts. A React tree is an element (`<PostTable />`); a
+ * vanilla DOM subject is the FUNCTION that fills a container, which is how a
+ * DOM-only module is called in production too.
+ */
+type RenderSubject = ComponentUi | DomMount;
+/**
+ * The chain. Every setup returns a new one, so the handle a spec imports never
+ * carries the previous test's contracts, wrapper or clock.
+ */
+type ComponentChain = {
+  /** Pin the page's `Date` for this render — the clock the component reads. */
+  clock: (iso: string) => ComponentChain;
   /**
-   * Project root override for compose detection and init scripts. When
-   * absent, the root is auto-discovered by walking up from the calling
-   * specification file to the first directory containing
-   * `docker/compose.test.yaml`, else the first containing `package.json`
-   * (CONVENTIONS A9).
+   * Declare what the network replies — the same contracts, the same queue
+   * and the same strictness as every other facet (D7), served by msw's
+   * worker instead of its node interceptor.
    */
-  root?: string;
+  intercept: {
+    (contracts: ContractInput): ComponentChain;
+    (request: ContractRequest, response: ContractResponder | ContractResponse): ComponentChain;
+  };
+  /** Mount the subject, run the scenario, and capture what the page shows. */
+  render: (subject: RenderSubject, scenario?: ComponentScenario) => Promise<RenderResult>;
   /**
-   * The app factory — receives the started services record (fully typed)
-   * and returns the Hono app. Required in node mode, ignored in compose
-   * mode (the app runs as a compose service there).
+   * The page size THIS render gets — the Given of a component that reads
+   * `matchMedia` or a container query. The project's size is restored when
+   * the test ends, so a narrow render never leaks into the next one.
    */
-  server?: (services: Services) => HonoApp;
+  viewport: (size: {
+    height: number;
+    width: number;
+  }) => ComponentChain;
   /**
-   * Named infrastructure record. Keys become the `database` vocabulary of
-   * `.seed()` / `.table()` and drive the compose binding: a handle with no
-   * `composeService` option links to the compose service named exactly like
-   * its key, else the kebab-case conversion of the key (CONVENTIONS A6).
+   * Wrap every render of this chain — the test-local Given a router stub or
+   * a `<StrictMode>` is. The project's own `wrap` stays outermost: it is the
+   * app's frame, and one test does not get to sit outside it.
    */
-  services?: Services;
+  wrap: (wrapper: (ui: ComponentUi) => ComponentUi) => ComponentChain;
 };
+//#endregion
+//#region src/specification/facets/website/elements.d.ts
 /**
- * The record returned by {@link startApi | specification.api}. Destructure
- * with the canonical names (CONVENTIONS A3):
+ * The element vocabulary — user-facing descriptors for visit scenarios.
+ * Reads like English (`click(link('Articles'))`), translates to
+ * accessibility-first locators in the browser integration. CSS/XPath is
+ * deliberately not expressible; `testId()` is the single escape hatch.
  *
- *     const { api, cleanup, docker } = await specification.api(…);
+ * A descriptor must designate exactly ONE element (CONVENTIONS W3). Two knobs
+ * narrow it, in this order of preference:
+ *
+ *   1. `within(scope, target)` — search inside a landmark, the way a person
+ *      would say "the Articles link *in the nav*";
+ *   2. `{ exact: true }` — match the accessible name whole rather than as a
+ *      substring, when two names genuinely overlap.
  */
-type ApiHandle<DatabaseKey extends string = string> = {
-  api: ApiSpecification<DatabaseKey>;
-  /** Stop all infrastructure started by this specification. */
-  cleanup: () => Promise<void>;
+/** Options accepted by every named descriptor. */
+type ElementOptions = {
   /**
-   * Read a running container by id — returns a {@link ContainerAccessor}
-   * usable with `await expect(...).toBeRunning()` and read accessors.
+   * Match the accessible name as a whole string. Default is substring —
+   * `link('Articles')` also matches "Read Articles".
    */
-  docker: (containerId: string) => ContainerAccessor;
-  /** The orchestrator managing the test infrastructure lifecycle. */
-  orchestrator: Orchestrator;
+  exact?: boolean;
 };
-declare function startApi<Services extends ServiceRecord>(options: ApiSpecificationOptions<Services>): Promise<ApiHandle<DatabaseKeys<Services>>>;
-//#endregion
-//#region src/specification/facets/cli/start-cli.d.ts
-/** Options for {@link startCli | specification.cli}. */
-type CliSpecificationOptions<Services extends ServiceRecord = ServiceRecord> = {
-  /**
-   * Opt-in Docker awareness. When set, every spec generates a unique
-   * test-run id, injects it into the child process env under `envVar`,
-   * and exposes `.container(name)` accessors on the result that lazily
-   * query Docker. Always declare results with `await using` so leaked
-   * containers get force-removed at scope exit (CONVENTIONS B5).
-   */
-  docker?: DockerSpecConfig;
-  /**
-   * Named environment SETS for `<case>.spec.yaml` documents. An `env:` entry
-   * `frozen` applies the whole `frozen` record; `$WORKDIR` expands and `null`
-   * unsets, exactly as in `.env()`. Declared once per app so a document
-   * states WHICH ground it stands on, not how to build it.
-   */
-  env?: Record<string, CliEnv>;
-  /**
-   * Named servers a `<case>.spec.yaml` document may start (`serve: [mcp]`, or
-   * `- mcp: { KEY: value }` to add env to that one). 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 run's child.
-   */
+/** A user-facing element factory — what every name in this module is. */
+type ElementFactory = (name: string, options?: ElementOptions) => ElementRef;
+/** A button (or element with the button role), by accessible name. */
+declare const button: ElementFactory;
+/** A form field, by label. */
+declare const field: ElementFactory;
+/** A heading, by accessible name. */
+declare const heading: ElementFactory;
+/** A link, by accessible name. */
+declare const link: ElementFactory;
+/** An element containing the given text. */
+declare const content: ElementFactory;
+/** The escape hatch: an element by `data-testid`. Prefer user-facing elements. */
+declare const testId: (id: string) => ElementRef;
+/** A landmark factory — the optionally-named containers `within()` accepts. */
+type LandmarkFactory = (name?: string, options?: ElementOptions) => ElementRef;
+/** The `banner` landmark — the page header. */
+declare const banner: LandmarkFactory;
+/** The `complementary` landmark — an `<aside>`, a sidebar. */
+declare const complementary: LandmarkFactory;
+/** The `contentinfo` landmark — the page footer. */
+declare const contentinfo: LandmarkFactory;
+/** The `form` landmark — a form carrying an accessible name. */
+declare const form: LandmarkFactory;
+/** The `main` landmark — the primary content of the document. */
+declare const main: LandmarkFactory;
+/** The `navigation` landmark — a `<nav>`. Name it when a page has several. */
+declare const navigation: LandmarkFactory;
+/** The `region` landmark — a `<section>` carrying an accessible name. */
+declare const region: LandmarkFactory;
+/** The `search` landmark. */
+declare const search: LandmarkFactory;
+/**
+ * Restrict a descriptor to the inside of another — the answer to ambiguity,
+ * and the one the framework prefers over a test id.
+ *
+ *     click(within(navigation(), link('Articles')))
+ *
+ * Composes outside-in: the scope may itself be scoped, so a deeply nested
+ * target reads `within(main(), within(region('Series'), link('Part 2')))`.
+ * Any descriptor works as a scope, including `testId()` when a container has
+ * no landmark role to stand on.
+ */
+declare const within: (scope: ElementRef, target: ElementRef) => ElementRef;
+/** A modal or non-modal `<dialog>`, by accessible name. A closed one is absent. */
+declare const dialog: LandmarkFactory;
+/** A live region announcing a result — `role="status"`, an `<output>`. */
+declare const status: LandmarkFactory;
+/** A table, by its caption or accessible name. */
+declare const table: LandmarkFactory;
+/** A row of a table or grid, by the text of its cells. */
+declare const row: LandmarkFactory;
+/** An item of a list, by its text. Retires the `.first()` of an unnamed `<li>`. */
+declare const listitem: LandmarkFactory;
+/**
+ * An option of a select or a listbox, by its label — named inside the field
+ * that holds it: `within(field('Channel'), option('LinkedIn'))`.
+ *
+ * Asserted by PRESENCE, not by visibility: the options of a collapsed
+ * `<select>` are in the document and in the accessibility tree, and none of
+ * them has a box on the screen until it is opened. `see(option('LinkedIn'))`
+ * therefore asks "is it offered", and `see(selected(option('LinkedIn')))`
+ * asks which one the field is on.
+ */
+declare const option: ElementFactory;
+/**
+ * Where the keyboard is: `see(focused(button('Open')))` asserts the element has
+ * focus, `gone(focused(x))` that it does not.
+ *
+ * A modifier rather than a descriptor of its own, because focus is a STATE of
+ * an element the vocabulary can already name. It is a verb's business and never
+ * a golden's: the accessibility tree carries no focus, so a tree snapshot of a
+ * dialog that took the keyboard and one that did not are byte-identical.
+ */
+declare const focused: (element: ElementRef) => ElementRef;
+/**
+ * Whether the element accepts input: `see(disabled(button('Delete')))` asserts
+ * it refuses, `see(enabled(button('Delete')))` that it takes it.
+ *
+ * Modifiers rather than descriptors, for the same reason as `focused`: being
+ * disabled is a state of an element the vocabulary already names. Unlike focus,
+ * the ARIA tree carries it, so a golden pins a whole outline's enablement and
+ * these name the ONE control a test is about. They also buy the direction a
+ * behavioural substitute cannot reach — clicking a disabled control is a
+ * timeout, never an assertion.
+ */
+declare const disabled: (element: ElementRef) => ElementRef;
+/** The other direction of {@link disabled} — the element takes input. */
+declare const enabled: (element: ElementRef) => ElementRef;
+/**
+ * Which option the field is on: `see(selected(option('LinkedIn')))`, and
+ * `gone(selected(option('X')))` for the one it left.
+ *
+ * A modifier for the same reason as {@link disabled}: being chosen is a state
+ * of an element the vocabulary already names. No matcher answers for it — a
+ * `<option>` is not a checkbox — so both adapters read the `:checked` the CSS
+ * spec gives a selected option.
+ */
+declare const selected: (element: ElementRef) => ElementRef;
+/**
+ * What the field holds: `see(valued(field('Title'), 'Launch teaser'))`, and
+ * `gone(valued(field('Title'), '…'))` for a value it no longer holds.
+ *
+ * A modifier for the same reason as {@link disabled}: what a field holds is a
+ * state of an element the vocabulary already names, and this is how the ONE
+ * field a test is about is waited for — a golden pins a whole outline instead.
+ * Read from the node's live value, never from the `value` ATTRIBUTE, which a
+ * controlled input never moves.
+ */
+declare const valued: (element: ElementRef, value: string) => ElementRef;
+//#endregion
+//#region src/specification/contracts/filters.d.ts
+/**
+ * A text filter on a provider request builder (`openai.chat({ user })`,
+ * `anthropic.messages({ system })`, …).
+ *
+ * A **string is EXACT**. That is deliberate: a substring filter silently
+ * cross-matches — two prompts sharing a preamble both satisfy the first
+ * contract, and the spec goes green on the wrong reply. Looser matching is
+ * explicit, and says which looseness it means:
+ *
+ * - a `RegExp` — pattern matching;
+ * - `match.includes('…')` — containment, the code-only matcher (it never joins
+ *   the `{{token}}` file vocabulary, CONVENTIONS D4);
+ * - any other `match.*` matcher, evaluated by the same structural engine the
+ *   assertions use.
+ */
+type TextFilter = Matcher | RegExp | string;
+//#endregion
+//#region src/integrations/anthropic/anthropic.d.ts
+type AnthropicMessagesFilter = {
+  model?: TextFilter;
+  system?: TextFilter;
+  user?: TextFilter;
+  tools?: string[];
+};
+/**
+ * Anthropic API intercept helpers.
+ */
+declare const anthropic: {
+  /**
+   * Request: match Messages API calls, optionally routed through a
+   * custom gateway URL. When used with a JSON fixture file, the data is
+   * returned as-is (no wrapping) because Anthropic fixtures are typically
+   * already in the Messages API response shape.
+   *
+   * @example
+   *   anthropic.messages()
+   *   anthropic.messages({ system: /classify/ })
+   *   anthropic.messages({ user: buildPrompt() })   // string = EXACT equality
+   *   anthropic.messages({ user: /classify/ }, GATEWAY)
+   */
+  messages(filter?: AnthropicMessagesFilter, url?: string): ContractRequest;
+  /** Response: wrap data in Anthropic messages format. */
+  reply(data: unknown): ContractResponse;
+  /** Response: return an Anthropic error. */
+  error(status: number, message?: string): ContractResponse;
+  /** Response: simulate a timeout. */
+  timeout(): ContractResponse;
+};
+//#endregion
+//#region src/specification/contracts/http.d.ts
+/**
+ * Request filters for the generic HTTP provider. Every field is a subset
+ * constraint — a request matches when all provided fields match.
+ */
+type HttpContractFilter = {
+  /**
+   * Body constraint. An object is a deep SUBSET match (toMatchObject-style)
+   * whose leaf values may be `match.*` matchers; a string is a containment
+   * test and a RegExp a `test()` over the raw text body.
+   */
+  body?: object | RegExp | string;
+  /** Header subset. Names are case-insensitive; string = exact value, RegExp = `test()`. */
+  headers?: Record<string, RegExp | string>;
+  /** Query-param subset. string = exact value, RegExp = `test()`. */
+  query?: Record<string, RegExp | string>;
+};
+/** Init options for a streamed reply. */
+type HttpStreamInit = {
+  /** The `content-type` the stream is served under. Default `application/octet-stream`. */
+  contentType?: string;
+  /** Milliseconds between two chunks. Default 0 — every chunk at once. */
+  delay?: number;
+  /** Response headers, merged over the builder's own. */
+  headers?: Record<string, string>;
+  /** HTTP status code. Default 200. */
+  status?: number;
+};
+/** One server-sent event, as `http.sse()` frames it. */
+type SseEvent = {
+  /** The `data:` payload. An object is serialised as JSON; a string is sent as-is. */
+  data: unknown;
+  /** The `event:` name. Omitted for an unnamed (default `message`) event. */
+  event?: string;
+  /** The `id:` the client echoes as `Last-Event-ID` when it reconnects. */
+  id?: string;
+  /** The `retry:` hint, in milliseconds. */
+  retry?: number;
+};
+/** Init options shared by the response builders. */
+type HttpResponseInit = {
+  /** Delay in ms before responding (for timeout testing). */
+  delay?: number;
+  /** Response headers, merged over the builder's own. */
+  headers?: Record<string, string>;
+  /** HTTP status code. */
+  status?: number;
+};
+/**
+ * Generic HTTP contract helpers for any URL. The url is absolute (string or
+ * RegExp), or a PATH FORM starting with `/` — `http.get('/articles/{{uuid}}')`
+ * matches that path on ANY origin, which is what an app calling its own
+ * backend needs. An optional {@link HttpContractFilter} narrows matching by
+ * body, headers, or query — a request that hits the URL/method but fails the
+ * filter counts as unmatched (strict contracts, CONVENTIONS D7).
+ *
+ * @example
+ *   defineContract({ request: http.get('/articles/{{uuid}}'), response: http.json(article) })
+ *   defineContract({ request: http.post(URL, { body: { user: 'alice' } }), response: http.empty() })
+ */
+declare const http: {
+  any(url: RegExp | string, filter?: HttpContractFilter): ContractRequest;
+  delete(url: RegExp | string, filter?: HttpContractFilter): ContractRequest;
+  get(url: RegExp | string, filter?: HttpContractFilter): ContractRequest;
+  patch(url: RegExp | string, filter?: HttpContractFilter): ContractRequest;
+  post(url: RegExp | string, filter?: HttpContractFilter): ContractRequest;
+  put(url: RegExp | string, filter?: HttpContractFilter): ContractRequest;
+  /** Response: a body-less reply (204 by default). */
+  empty(status?: number): ContractResponse;
+  /** Response: an error status. Without a body, `{ error: 'HTTP <status>' }`. */
+  error(status: number, body?: unknown): ContractResponse;
+  /** Response: a JSON body (200 by default). */
+  json(body: unknown, init?: HttpResponseInit): ContractResponse;
+  /**
+   * Response: no response at all — the request fails in transport, the way a
+   * server that is not running fails it. `fetch` rejects; no status is served.
+   */
+  unreachable(): ContractResponse;
+  /**
+   * Response: a body that arrives in PIECES, written in order.
+   *
+   * A subject that reads a response as it lands — a token-by-token render, a
+   * progress bar, a reconnect on a half-read body — is specified by the
+   * chunks and their order, which a single serialised body cannot state.
+   * Honoured by all three engines: msw's server, msw's worker, and the
+   * `node:http` stub the website and mobile facets serve from.
+   *
+   * @example
+   *   http.stream(['Hel', 'lo, ', 'world'], { contentType: 'text/plain', delay: 10 })
+   */
+  stream(chunks: readonly string[], init?: HttpStreamInit): ContractResponse;
+  /**
+   * Response: a server-sent event stream — one chunk per event, framed the
+   * way an `EventSource` reads them, served as `text/event-stream`.
+   *
+   * @example
+   *   http.sse([{ data: { token: 'Hel' } }, { data: { token: 'lo' } }, { event: 'done', data: '' }])
+   */
+  sse(events: readonly SseEvent[], init?: Omit<HttpStreamInit, "contentType">): ContractResponse;
+  /** Response: a text body, served as `text/plain` (200 by default). */
+  text(body: string, init?: HttpResponseInit): ContractResponse;
+};
+//#endregion
+//#region src/integrations/openai/openai.d.ts
+type OpenAIChatFilter = {
+  model?: TextFilter;
+  system?: TextFilter;
+  user?: TextFilter;
+  tools?: string[];
+  temperature?: number;
+};
+type OpenAIResponsesFilter = {
+  model?: TextFilter;
+  system?: TextFilter;
+  user?: TextFilter;
+  tools?: string[];
+};
+/**
+ * OpenAI API intercept helpers.
+ */
+declare const openai: {
+  /**
+   * Request: match Chat Completions API calls. STRING filters mean EXACT
+   * equality (pass the app's own prompt builder); loosen deliberately with a
+   * RegExp or `match.includes(...)`.
+   *
+   * @example
+   *   openai.chat()                            // any chat call
+   *   openai.chat({ model: 'gpt-4o' })         // exact model
+   *   openai.chat({ system: buildPrompt() })   // exact system prompt
+   *   openai.chat({ system: /classify/ })      // pattern
+   */
+  chat(filter?: OpenAIChatFilter): ContractRequest;
+  /**
+   * Request: match Responses API calls (AI SDK v5+) with auto-wrapping.
+   * String filters mean EXACT equality (see {@link openai.chat}).
+   * When used with a JSON file, the data is automatically wrapped in the
+   * Responses API envelope.
+   *
+   * @param filter - Optional body filters.
+   * @param url - Custom gateway URL (default: api.openai.com).
+   *
+   * @example
+   *   openai.responses({ user: /Report Ingestion/ }, GATEWAY)
+   */
+  responses(filter?: OpenAIResponsesFilter, url?: string): ContractRequest;
+  /**
+   * Response: wrap data in Chat Completions format.
+   *
+   * @example
+   *   openai.reply({ categories: ['TECH'] })
+   */
+  reply(data: unknown): ContractResponse;
+  /** Response: return an OpenAI error. */
+  error(status: number, message?: string): ContractResponse;
+  /** Response: return malformed content. */
+  malformed(content: string): ContractResponse;
+  /** Response: simulate a timeout. */
+  timeout(): ContractResponse;
+};
+//#endregion
+//#region src/vitest/mock-of.d.ts
+/** How much of the port the double answers for. */
+type MockOfOptions = {
+  /**
+   * Deep (the default): reading a member that was never stubbed hands back
+   * another double, however far down the port nests. `false` gives the flat
+   * proxy — every member of `T` and nothing beneath them, which is what a
+   * port with a nested namespace wants when the test only ever touches the
+   * first level.
+   */
+  deep?: boolean;
+};
+/**
+ * A typed double for an injected port — the fourth rung of the doubles ladder
+ * (docs/12-conventions.md), and the only one a module test may build itself.
+ *
+ * The type argument is the port: `T` is constrained to `object` and has no
+ * default, so a double is always asked for something. A call with no argument
+ * answers for `object`, which satisfies no port and fails where it is used.
+ *
+ * @example
+ *   const gateway = mockOf<PaymentGateway>();                // deep
+ *   const clock = mockOf<ClockPort>({ deep: false });        // flat
+ */
+declare function mockOf<T extends object>(options: {
+  deep: false;
+}): MockProxy<T>;
+declare function mockOf<T extends object>(options?: MockOfOptions): DeepMockProxy<T>;
+/** The factory's own shape — kept as a name so a consumer can annotate with it. */
+type MockPort = typeof mockOf;
+//#endregion
+//#region src/vitest/mock-of-date.d.ts
+/** Interface for freezing and resetting the global Date in tests. */
+type MockDatePort = {
+  /** Restore the real Date object. */
+  reset: () => void;
+  /** Freeze `Date.now()` and `new Date()` to the given value. */
+  set: (date: Date | number | string) => void;
+};
+/**
+ * Freeze or reset the global Date for deterministic time-dependent tests.
+ * Wraps the `mockdate` package.
+ */
+declare const mockOfDate: MockDatePort;
+//#endregion
+//#region src/vitest/clock.d.ts
+/**
+ * The one time primitive.
+ *
+ * Time is the determinism the framework owns (CONVENTIONS D16): a test that
+ * samples `Date.now()` and asserts on what comes back is a test that fails on
+ * the next leap second, and a test that reaches for `vi.useFakeTimers()` owns a
+ * teardown it will one day forget. `clock` is both answers in one name — the
+ * instant is stated, and the scope restores itself.
+ *
+ * ```typescript
+ * using _ = clock.at('2026-03-04T09:30:00Z');   // Date is pinned until the scope ends
+ * ```
+ *
+ * `at()` takes the CALENDAR and leaves the scheduler alone: a UI framework's
+ * own loop, a `setTimeout` inside the subject and every promise still resolve
+ * on their own. `run()` takes the scheduler too, for a subject whose behaviour
+ * IS the passage of time — a debounce, a retry backoff, a poll.
+ */
+/** A pinned clock — released when the `using` scope that declared it ends. */
+type PinnedClock = Disposable;
+declare const clock: {
+  /**
+   * Move the pinned clock forward by `ms` — and, under {@link clock.run},
+   * fire every callback that came due, awaiting what each of them started.
+   *
+   * Only a pinned clock moves: called with no clock taken, it says so rather
+   * than silently doing nothing to the real one.
+   */
+  advance(ms: number): Promise<void>;
+  /**
+   * Pin `Date` at `iso` for the current scope. `Date` ONLY: the scheduler
+   * stays real, so a subject that awaits, renders or polls keeps running.
+   *
+   * @example
+   *   using _ = clock.at('2026-03-04T09:30:00Z');
+   *   expect(stampedAt()).toBe('2026-03-04T09:30:00.000Z');
+   */
+  at(iso: string): PinnedClock;
+  /**
+   * Take the scheduler as well as the calendar: `setTimeout`, `setInterval`
+   * and their friends queue instead of firing, and {@link clock.advance} is
+   * what makes them due. For a subject whose behaviour IS elapsed time — a
+   * debounce, a retry backoff, a poll — where waiting for real would be the
+   * arbitrary sleep J2 forbids.
+   *
+   * @example
+   *   using _ = clock.run('2026-03-04T09:30:00Z');
+   *   const pending = retrying(failsTwice);
+   *   await clock.advance(5_000);
+   *   await expect(pending).resolves.toBe('ok');
+   */
+  run(iso?: string): PinnedClock;
+};
+//#endregion
+//#region src/specification/assertions/required.d.ts
+/**
+ * The value, or a failure that says what was missing and why it mattered.
+ *
+ * A test reaching into a captured structure — a row, a header, the third
+ * element of a list — meets `T | undefined` and has to do something about it.
+ * The two things it usually does are both wrong: `!` erases the question, and
+ * an `if (!x) throw new Error('missing')` re-states the same three lines in
+ * every repository (the estate had two hand-written copies of exactly this).
+ * `required` is that gesture with the reason attached, so the failure reads as
+ * a sentence rather than as a `TypeError` two frames further down.
+ *
+ * @example
+ *   const id = required(result.response.body.id, 'the creation reply carries the new id');
+ */
+declare function required<T>(value: null | T | undefined, why: string): T;
+//#endregion
+//#region src/specification/assertions/wait-until.d.ts
+/** How long to wait, and how often to look. */
+type WaitUntilOptions = {
+  /** Milliseconds between two readings. Default 50. */
+  interval?: number;
+  /** How long the condition has to become true. Default 5 000 ms. */
+  timeout?: number;
+  /** What the condition is, named in the failure. Default: the predicate's source. */
+  why?: string;
+};
+/**
+ * Wait until a condition holds — the sanctioned answer to "the thing I am
+ * specifying is not ready yet".
+ *
+ * A spec that sleeps for a guessed duration is a spec that is slow on a fast
+ * machine and flaky on a slow one, which is why J2 refuses `setTimeout` under
+ * `specs/`. Every facet that drives something already waits on a CONDITION —
+ * a served page, a banner on stdout, an element the visitor can see — and this
+ * is that primitive where no facet owns the waiting: a background write to
+ * land, a queue to drain, a file to appear.
+ *
+ * The failure names the condition and how long it was given, so a timeout is a
+ * sentence rather than "expected true, got false".
+ *
+ * The budget is measured on `performance.now()`, not on `Date` — `clock.at()`
+ * freezes the calendar, and a deadline read off a frozen calendar never
+ * arrives: the poll would run until vitest killed the test with a sentence
+ * about the file rather than about the condition.
+ *
+ * Not for a subject under `clock.run()`: there the scheduler is the test's, and
+ * `clock.advance(ms)` is what makes time pass.
+ *
+ * @example
+ *   await waitUntil(() => outbox.length === 1, { why: 'the job wrote its one message' });
+ */
+declare function waitUntil(predicate: () => boolean | Promise<boolean>, options?: WaitUntilOptions): Promise<void>;
+//#endregion
+//#region src/surface.d.ts
+declare module 'vitest' {
+  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).
+     */
+    toBeEmpty: T extends TableAccessor ? () => Promise<void> : T extends {
+      readonly comparableText: string;
+    } ? () => Promise<void> : never;
+    /** Assert the container is running. Async — docker-backed subject. */
+    toBeRunning: T extends ContainerAccessor ? () => Promise<void> : never;
+    /**
+     * On `@jterrazz/test` accessors: assert the subject matches a fixture
+     * file under `_expected/<name>` (flat — a slash creates a subfolder;
+     * `.http` format for `result.response`). Async for filesystem/directory
+     * subjects (tree compare on disk), and for a subject captured INSIDE a
+     * page (`result.tree`, `result.html`, … — the file crosses the browser
+     * seam through a server command).
+     *
+     * Pass `{ frozen: true }` to opt a single fixture OUT of update-mode
+     * rewriting: a frozen fixture is never overwritten under `TEST_UPDATE=1`
+     * (or vitest `-u`), and a frozen mismatch/missing fixture still throws.
+     * Use it for a deliberately-wrong fixture whose diff/error rendering is
+     * the behaviour under test.
+     */
+    toMatch: T extends DirectoryAccessor | FilesystemAccessor ? (name: RegExp | string, options?: MatchFixtureOptions) => Promise<void> : T extends {
+      readonly capturedInPage: true;
+    } ? (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
+//#region src/specification/facets/_common/orchestrator.d.ts
+type OrchestratorOptions = {
+  /**
+   * Named infrastructure record. Keys become the database vocabulary of the
+   * spec (`.seed()` / `.table()` `database` option) and drive the compose
+   * binding: a handle with no explicit `composeService` links to the compose
+   * service named exactly like its key, else the kebab-case conversion of the
+   * key (`analyticsDb` → `analytics-db`) — see {@link resolveComposeBinding}.
+   */
+  services: Record<string, ServiceHandle>;
+  mode: 'e2e' | 'integration';
+  /**
+   * The project root, already resolved. REQUIRED: the constructors derive it
+   * by walking up from the calling specification file (CONVENTIONS A9), and
+   * the orchestrator is handed the answer. Defaulting to `process.cwd()` here
+   * meant one silent second opinion about what the project is — the runner
+   * resolving from the caller, this from wherever the runner happened to be
+   * launched, which in a workspace is rarely the same directory.
+   */
+  root: string;
+  /** Compose project name — used for per-worker stack isolation. */
+  projectName?: string;
+};
+/**
+ * Orchestrator for test infrastructure.
+ * Integration: starts services via testcontainers.
+ * E2E: runs full docker compose up.
+ */
+declare class Orchestrator {
+  private readonly services;
+  private readonly mode;
+  private readonly root;
+  private readonly projectName;
+  private running;
+  private composeStack;
+  private composeHandles;
+  private started;
+  constructor(options: OrchestratorOptions);
+  /**
+   * Bind each declared handle to a compose service (CONVENTIONS A6): a record
+   * key resolves to the service named exactly like it, else the kebab-case
+   * conversion of the key; an explicit `composeService` wins. Throws on an
+   * ambiguous binding (both names present). Runs once compose config is known
+   * so the two-step resolution can consult the real service list.
+   */
+  private resolveBindings;
+  /**
+   * Start declared services via testcontainers (integration mode).
+   * Phase 1: start all containers in parallel (the slow part).
+   * Phase 2: wire connections, healthcheck, and init sequentially (fast).
+   */
+  start(): Promise<void>;
+  /**
+   * Stop testcontainers (integration mode).
+   */
+  stop(): Promise<void>;
+  /**
+   * Start full docker compose stack (e2e mode).
+   * Auto-detects infra services and creates handles for them.
+   */
+  startCompose(): Promise<void>;
+  /**
+   * Stop docker compose stack (e2e mode).
+   */
+  stopCompose(): Promise<void>;
+  /**
+   * Get the default database — the first declared handle that is one.
+   */
+  getDatabase(): DatabasePort | null;
+  /**
+   * Get all database services keyed by their record key (declared services)
+   * or compose service name (stack-detected services).
+   */
+  getDatabases(): Map<string, DatabasePort>;
+  private allHandles;
+  /**
+   * Get app URL from compose (e2e mode).
+   */
+  getAppUrl(): null | string;
+}
+//#endregion
+//#region src/specification/facets/_common/services.d.ts
+/**
+ * Infrastructure services declared as a named record. Keys become the typed
+ * vocabulary of the whole spec: the server factory receives the same record,
+ * and `.seed()` / `.table()` target databases by key.
+ */
+type ServiceRecord = Record<string, ServiceHandle>;
+/** Keys of a services record whose handles are databases. */
+type DatabaseKeys<Services extends ServiceRecord> = { [K in keyof Services]: Services[K] extends DatabasePort ? K & string : never; }[keyof Services];
+//#endregion
+//#region src/specification/facets/api/start-api.d.ts
+/** Any object with a request method compatible with Hono's app.request(). */
+type HonoApp = {
+  request: (path: string, init?: RequestInit) => Promise<Response> | Response;
+};
+/** Execution mode — exists ONLY on `specification.api()` (CONVENTIONS A5). */
+type SpecificationMode = 'compose' | 'node';
+/** Options for {@link startApi | specification.api}. */
+type ApiSpecificationOptions<Services extends ServiceRecord = ServiceRecord> = {
+  /**
+   * Execution mode override. Resolution: `options.mode` >
+   * `process.env.TEST_MODE` > `'node'`. Never hardcode this in a
+   * specification file when `server` is defined — set it per vitest
+   * project via `env: { TEST_MODE: 'compose' }` (CONVENTIONS A5).
+   */
+  mode?: SpecificationMode;
+  /**
+   * Project root override for compose detection and init scripts. When
+   * absent, the root is auto-discovered by walking up from the calling
+   * specification file to the first directory containing
+   * `docker/compose.test.yaml`, else the first containing `package.json`
+   * (CONVENTIONS A9).
+   */
+  root?: string;
+  /**
+   * The app factory — receives the started services record (fully typed)
+   * and returns the Hono app. Required in node mode, ignored in compose
+   * mode (the app runs as a compose service there).
+   */
+  server?: (services: Services) => HonoApp;
+  /**
+   * Named infrastructure record. Keys become the `database` vocabulary of
+   * `.seed()` / `.table()` and drive the compose binding: a handle with no
+   * `composeService` option links to the compose service named exactly like
+   * its key, else the kebab-case conversion of the key (CONVENTIONS A6).
+   */
+  services?: Services;
+};
+/**
+ * The record returned by {@link startApi | specification.api}. Destructure
+ * with the canonical names (CONVENTIONS A3):
+ *
+ *     const { api, cleanup, docker } = await specification.api(…);
+ */
+type ApiHandle<DatabaseKey extends string = string> = {
+  api: ApiSpecification<DatabaseKey>;
+  /** Stop all infrastructure started by this specification. */
+  cleanup: () => Promise<void>;
+  /**
+   * Read a running container by id — returns a {@link ContainerAccessor}
+   * usable with `await expect(...).toBeRunning()` and read accessors.
+   */
+  docker: (containerId: string) => ContainerAccessor;
+  /** The orchestrator managing the test infrastructure lifecycle. */
+  orchestrator: Orchestrator;
+};
+declare function startApi<Services extends ServiceRecord>(options: ApiSpecificationOptions<Services>): Promise<ApiHandle<DatabaseKeys<Services>>>;
+//#endregion
+//#region src/specification/facets/cli/start-cli.d.ts
+/** Options for {@link startCli | specification.cli}. */
+type CliSpecificationOptions<Services extends ServiceRecord = ServiceRecord> = {
+  /**
+   * Opt-in Docker awareness. When set, every spec generates a unique
+   * test-run id, injects it into the child process env under `envVar`,
+   * and exposes `.container(name)` accessors on the result that lazily
+   * query Docker. Always declare results with `await using` so leaked
+   * containers get force-removed at scope exit (CONVENTIONS B5).
+   */
+  docker?: DockerSpecConfig;
+  /**
+   * Environment applied to EVERY run of this binary — the variables the
+   * product needs to be deterministic at all (`TZ`, `NO_COLOR`, `LANG`,
+   * a config home under the spec's own workdir). Stated once per app
+   * instead of repeated on every chain and in every document; a chained
+   * `.env()` and a document's `env:` both win over it.
+   */
+  defaults?: CliEnv;
+  /**
+   * Named environment SETS for `<case>.spec.yaml` documents. An `env:` entry
+   * `frozen` applies the whole `frozen` record; `$WORKDIR` expands and `null`
+   * unsets, exactly as in `.env()`. Declared once per app so a document
+   * states WHICH ground it stands on, not how to build it.
+   */
+  env?: Record<string, CliEnv>;
+  /**
+   * Named servers a `<case>.spec.yaml` document may start (`serve: [mcp]`, or
+   * `- mcp: { KEY: value }` to add env to that one). 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 run's child.
+   */
   serve?: Record<string, LiterateServeRegistration>;
   /**
    * Project-root override (CONVENTIONS A9) — the single meaning of `root`:
@@ -1673,6 +2589,42 @@ type CliHandle<DatabaseKey extends string = string> = {
 };
 declare function startCli<Services extends ServiceRecord>(bin: string, options?: CliSpecificationOptions<Services>): Promise<CliHandle<DatabaseKeys<Services>>>;
 //#endregion
+//#region src/specification/facets/integration/start-integration.d.ts
+/** Options for {@link startIntegration | specification.integration}. */
+type IntegrationSpecificationOptions<Services extends ServiceRecord = ServiceRecord> = {
+  /** Project-root override — see the `root` option of `specification.api()`. */
+  root?: string;
+  /**
+   * Named infrastructure the module is specified AGAINST — a real database,
+   * a real cache, a `process()` it talks to. Omit it for the other half of
+   * the facet: a pure module whose oracle is a golden.
+   */
+  services?: Services;
+};
+/**
+ * The record returned by {@link startIntegration | specification.integration}.
+ * Destructure with the canonical names (CONVENTIONS A3):
+ *
+ *     const { integration, cleanup } = await specification.integration(…);
+ */
+type IntegrationHandle<Services extends ServiceRecord = ServiceRecord, DatabaseKey extends string = string> = {
+  /** Stop all infrastructure started by this specification. */
+  cleanup: () => Promise<void>;
+  integration: IntegrationSpecification<Services, DatabaseKey>;
+};
+/**
+ * Specify a module the way the assembled product is specified: against real
+ * services and declared contracts, with the golden mechanism on what it
+ * produces.
+ *
+ * The fork is the SUBJECT. A module alone is a module test, beside its code,
+ * with no runner at all. A module that needs a real database, or whose oracle
+ * is a golden file, is this — and it used to be neither: a `specs/` folder
+ * with plain vitest, a hand-built sqlite template, a `beforeAll` that started
+ * a container, and a `toMatchSnapshot` where the package has a golden engine.
+ */
+declare function startIntegration<Services extends ServiceRecord>(options?: IntegrationSpecificationOptions<Services>): Promise<IntegrationHandle<Services, DatabaseKeys<Services>>>;
+//#endregion
 //#region src/specification/facets/jobs/start-jobs.d.ts
 /** Options for {@link startJobs | specification.jobs}. */
 type JobsSpecificationOptions<Services extends ServiceRecord = ServiceRecord> = {
@@ -1719,7 +2671,7 @@ type MobileBackendOptions = {
   port?: number;
 };
 /** Options for {@link startMobile | specification.mobile}. */
-type MobileSpecificationOptions = {
+type MobileSpecificationOptions<Services extends ServiceRecord = ServiceRecord> = {
   /** The app under test — terminated and relaunched by every `.open()`. */
   app: {
     /** Bundle id of the installed app (`com.example.app`). */
@@ -1752,6 +2704,14 @@ type MobileSpecificationOptions = {
    * driving a DEV build states the wait its bundler's cold boot needs
    * (`{ action: 45_000 }`) instead of sleeping inside its scenarios.
    */
+  /**
+   * Named services started with the runner and stopped with it — a
+   * `process()` for the bundler the app loads from, a database a dev build
+   * reads. Metro stops being a `beforeAll` the repository maintains: it is
+   * `process({ command: 'expo start', ready: /Metro waiting on .*:(\\d+)/ })`
+   * like every other external process the framework owns.
+   */
+  services?: Services;
   timeouts?: DeviceTimeouts;
 };
 /**
@@ -1773,13 +2733,35 @@ type MobileHandle = {
   /** The resolved simulator UDID the specs run against. */
   udid: string;
 };
-declare function startMobile(options: MobileSpecificationOptions): Promise<MobileHandle>;
+declare function startMobile<Services extends ServiceRecord>(options: MobileSpecificationOptions<Services>): Promise<MobileHandle>;
 //#endregion
 //#region src/specification/facets/website/serve.adapter.d.ts
-/** Options for a local server started by the framework. */
-type ServeOptions = {
-  /** Shell command that starts the site. Receives the chosen port as `PORT`. */
+/**
+ * The ONE shape an external process takes — the site under test, a backend a
+ * page talks to, a bundler a simulator loads from. Built by `process()`
+ * (chapter 11) and accepted wherever a facet starts something outside this
+ * process: `website({ server })`, `services: { api: process(…) }`, and the
+ * literate `serve:` registry.
+ */
+type ProcessOptions = {
+  /**
+   * A one-shot command run ONCE per specification, before the process is
+   * spawned, which must exit 0 — a build, a migration, a fixture load. Its
+   * failure is the specification's, and it says so.
+   */
+  before?: string;
+  /** Shell command that starts the process. Receives the chosen port as `PORT`. */
   command: string;
+  /** Working directory, relative to the project root. Default: the root itself. */
+  cwd?: string;
+  /**
+   * Environment for the child, on top of the runner's own. A function
+   * receives the services already started beside this one, so a process can
+   * be handed a sibling's connection string.
+   */
+  env?: ((services: Record<string, {
+    connectionString: string;
+  }>) => Record<string, string>) | Record<string, string>;
   /** Fixed port. Default: an OS-assigned free port, injected as `PORT`. */
   port?: number;
   /**
@@ -1797,8 +2779,96 @@ type ServeOptions = {
   /** Readiness budget in milliseconds. Default 30 000. */
   timeout?: number;
 };
+/**
+ * What `ProcessOptions` was called in 15.2, when the only process the
+ * framework owned was a website's server.
+ *
+ * @deprecated Renamed to {@link ProcessOptions} in 15.3 — the shape is the
+ * one external process every facet starts, not a website's alone. The alias
+ * is removed in 16.0.
+ */
+type ServeOptions = ProcessOptions;
+//#endregion
+//#region src/specification/facets/_common/process.d.ts
+/**
+ * An external process, declared like any other service.
+ *
+ * Before this there were three shapes for the same thing: `website({ server })`
+ * took a `ServeOptions`, a literate document took a `serve:` entry, and a
+ * project that needed a second process — an API behind the site, Metro behind
+ * the simulator — started one by hand in a `beforeAll` and killed it in an
+ * `afterAll` it sometimes forgot. `process()` is the one shape, and the
+ * framework owns the lifetime.
+ *
+ * It sits in a `services` record beside `postgres()`, `redis()` and
+ * `sqlite()`, so it starts after them and can be handed their connection
+ * strings through `env`, and it is stopped with the specification.
+ */
+declare class ProcessHandle implements ServiceHandle {
+  /** Embedded: nothing to pull, nothing to run in a container. */
+  readonly defaultImage = "";
+  readonly defaultPort = 0;
+  readonly environment: Record<string, string>;
+  readonly type = "process";
+  composeName: null | string;
+  connectionString: string;
+  started: boolean;
+  private adapter;
+  private readonly options;
+  constructor(options: ProcessOptions);
+  buildConnectionString(host: string, port: number): string;
+  createDatabaseAdapter(): DatabasePort | null;
+  healthcheck(): Promise<void>;
+  /**
+   * A process is not a container, so the orchestrator never starts it: the
+   * facet does, once its siblings are up and their connection strings are
+   * readable ({@link startProcessServices}).
+   */
+  initialize(): Promise<void>;
+  /**
+   * Isolation is the RUN's, not the worker's — and a run here is one
+   * EVALUATION of the specification module. Under vitest's default
+   * isolation that is once per test file, so two files that import the same
+   * specification get a child each, with the id the facet minted for it.
+   * Nothing is acquired or reset between tests: the id is what tells two
+   * runs apart, never a label a spec samples.
+   */
+  isolation(): IsolationStrategy;
+  reset(): Promise<void>;
+  /**
+   * Spawn it and wait until it answers. `services` is every handle declared
+   * beside this one, already started — what an `env` function reads.
+   *
+   * @internal
+   */
+  spawnWith(root: string, services: Record<string, {
+    connectionString: string;
+  }>, runId: string): Promise<void>;
+  /** Terminate the process group. Idempotent. */
+  shutdown(): Promise<void>;
+  /** What it was declared as — what a facet reads to start it in a slot of its own. */
+  get spec(): ProcessOptions;
+  /** The base URL it came up on — known only once it is started. */
+  get url(): string;
+}
+/**
+ * Declare an external process the framework owns for the life of the
+ * specification.
+ *
+ * @example
+ *   const { website, cleanup } = await specification.website({
+ *       services: { api: process({ command: 'bin/server web', ready: '/health' }) },
+ *       server: ({ api }) => process({
+ *           command: 'next dev',
+ *           env: { NEXT_PUBLIC_API_URL: api.connectionString },
+ *       }),
+ *   });
+ */
+declare function processService(options: ProcessOptions): ProcessHandle;
 //#endregion
 //#region src/specification/facets/website/start-website.d.ts
+/** What `server` may be handed as, and what it resolves to. */
+type ServerSpec<Services extends ServiceRecord> = ((services: Services) => ProcessHandle | ProcessOptions) | ProcessHandle | ProcessOptions;
 /**
  * The declared stub backend behind the site under test — started before the
  * server command, torn down with the runner. Its URL is injected into the
@@ -1819,7 +2889,7 @@ type WebsiteBackendOptions = {
  * mode for the same reason: a deployed site cannot be pointed at a local
  * stub.
  */
-type WebsiteSpecificationOptions = {
+type WebsiteSpecificationOptions<Services extends ServiceRecord = ServiceRecord> = {
   /**
    * Cross-origin request policy for visits. Default: `'block'` with a
    * local `server` (deterministic — analytics and CDNs never leave the
@@ -1831,6 +2901,14 @@ type WebsiteSpecificationOptions = {
    * `server` command. Auto-discovered from the calling file when absent.
    */
   root?: string;
+  /**
+   * Named services started with the runner, before the site is: a database
+   * the site reads, a `process()` backend it calls. They are started in
+   * declaration order and stopped with the specification, and `server` may
+   * be a function of them — which is how a site is handed the URL of the
+   * API it was started beside.
+   */
+  services?: Services;
 } & ({
   /**
    * Declared stub backend: started BEFORE the server command, its
@@ -1839,10 +2917,11 @@ type WebsiteSpecificationOptions = {
    */
   backend?: WebsiteBackendOptions;
   /**
-   * Start the site locally: a shell command receiving a free port
-   * as `PORT`, polled on `ready` (default `/`) until it answers.
+   * Start the site locally: a `process()` — a shell command receiving
+   * a free port as `PORT`, polled on `ready` (default `/`) until it
+   * answers — or a function of the started services returning one.
    */
-  server: ServeOptions;
+  server: ServerSpec<Services>;
   url?: never;
 } | {
   backend?: never;
@@ -1863,11 +2942,11 @@ type WebsiteHandle = {
   url: string;
   website: WebsiteSpecification;
 };
-declare function startWebsite(options: WebsiteSpecificationOptions): Promise<WebsiteHandle>;
+declare function startWebsite<Services extends ServiceRecord>(options: WebsiteSpecificationOptions<Services>): Promise<WebsiteHandle>;
 //#endregion
 //#region src/specification/facets/_common/specification.d.ts
 /**
- * The five specification constructors (CONVENTIONS A2) — created in a
+ * The six specification constructors (CONVENTIONS A2) — created in a
  * `*.specification.ts` file under `specs/`, destructured with canonical
  * names, and cleaned up via `afterAll(cleanup)` (A1/A3/A4).
  *
@@ -1890,16 +2969,21 @@ declare function startWebsite(options: WebsiteSpecificationOptions): Promise<Web
  *   export const { cli, cleanup } = await specification.cli('my-cli');
  *   afterAll(cleanup);
  */
-/** The five constructors, and only five — the framework's whole entry surface. */
+/** The six constructors, and only six — the framework's whole entry surface. */
 type Specification = {
   api: typeof startApi;
   cli: typeof startCli;
+  integration: typeof startIntegration;
   jobs: typeof startJobs;
   mobile: typeof startMobile;
   website: typeof startWebsite;
 };
 declare const specification: Specification;
 //#endregion
+//#region src/specification/facets/component/component.node.d.ts
+/** Present, typed, and refusing — every setup and the terminal action alike. */
+declare const component: ComponentChain;
+//#endregion
 //#region src/specification/literate/spec-document.d.ts
 /**
  * The facets a document may describe. `cli` is the only one implemented; the
@@ -1988,93 +3072,51 @@ declare function inspectContainer(id: string): unknown;
 /** Force-remove the given container IDs in a single call. Errors are swallowed. */
 declare function removeContainers(ids: string[]): void;
 //#endregion
-//#region src/specification/ports/container.port.d.ts
-/**
- * Abstract container interface.
- * Represents a running service (database, cache, etc.)
- */
-type ContainerPort = {
-  /** Start the container and wait until ready. */
-  start: () => Promise<void>;
-  /** Stop and remove the container. */
-  stop: () => Promise<void>;
-  /** Get the mapped host port for a container port. */
-  getMappedPort: (containerPort: number) => number;
-  /** Get the host to connect to. */
-  getHost: () => string;
-  /** Get a full connection string for this service. */
-  getConnectionString: () => string;
-  /** Get container logs (stdout + stderr). */
-  getLogs: () => Promise<string>;
-};
-//#endregion
-//#region src/specification/facets/website/elements.d.ts
-/**
- * The element vocabulary — user-facing descriptors for visit scenarios.
- * Reads like English (`click(link('Articles'))`), translates to
- * accessibility-first locators in the browser integration. CSS/XPath is
- * deliberately not expressible; `testId()` is the single escape hatch.
- *
- * A descriptor must designate exactly ONE element (CONVENTIONS W3). Two knobs
- * narrow it, in this order of preference:
- *
- *   1. `within(scope, target)` — search inside a landmark, the way a person
- *      would say "the Articles link *in the nav*";
- *   2. `{ exact: true }` — match the accessible name whole rather than as a
- *      substring, when two names genuinely overlap.
- */
-/** Options accepted by every named descriptor. */
-type ElementOptions = {
-  /**
-   * Match the accessible name as a whole string. Default is substring —
-   * `link('Articles')` also matches "Read Articles".
-   */
-  exact?: boolean;
-};
-/** A user-facing element factory — what every name in this module is. */
-type ElementFactory = (name: string, options?: ElementOptions) => ElementRef;
-/** A button (or element with the button role), by accessible name. */
-declare const button: ElementFactory;
-/** A form field, by label. */
-declare const field: ElementFactory;
-/** A heading, by accessible name. */
-declare const heading: ElementFactory;
-/** A link, by accessible name. */
-declare const link: ElementFactory;
-/** An element containing the given text. */
-declare const content: ElementFactory;
-/** The escape hatch: an element by `data-testid`. Prefer user-facing elements. */
-declare const testId: (id: string) => ElementRef;
-/** A landmark factory — the optionally-named containers `within()` accepts. */
-type LandmarkFactory = (name?: string, options?: ElementOptions) => ElementRef;
-/** The `banner` landmark — the page header. */
-declare const banner: LandmarkFactory;
-/** The `complementary` landmark — an `<aside>`, a sidebar. */
-declare const complementary: LandmarkFactory;
-/** The `contentinfo` landmark — the page footer. */
-declare const contentinfo: LandmarkFactory;
-/** The `form` landmark — a form carrying an accessible name. */
-declare const form: LandmarkFactory;
-/** The `main` landmark — the primary content of the document. */
-declare const main: LandmarkFactory;
-/** The `navigation` landmark — a `<nav>`. Name it when a page has several. */
-declare const navigation: LandmarkFactory;
-/** The `region` landmark — a `<section>` carrying an accessible name. */
-declare const region: LandmarkFactory;
-/** The `search` landmark. */
-declare const search: LandmarkFactory;
-/**
- * Restrict a descriptor to the inside of another — the answer to ambiguity,
- * and the one the framework prefers over a test id.
+//#region src/specification/facets/_common/result/text-subject.d.ts
+/**
+ * Wrap an arbitrary string into a {@link TextAccessor} anchored on the calling
+ * test's directory — the same caller-detection the builders use.
  *
- *     click(within(navigation(), link('Articles')))
+ * The product surface of a test framework is its own error messages, checker
+ * output, and reports; those deserve the same goldening as any other output.
+ * `text()` makes an ad-hoc string a first-class snapshot subject:
  *
- * Composes outside-in: the scope may itself be scoped, so a deeply nested
- * target reads `within(main(), within(region('Series'), link('Part 2')))`.
- * Any descriptor works as a scope, including `testId()` when a container has
- * no landmark role to stand on.
+ * ```typescript
+ * const message = await catchMessage(() => expect(result.response).toMatch('wrong-body.http'));
+ * expect(text(message)).toMatch('wrong-body-error.txt'); // resolves to _expected/
+ * ```
+ *
+ * ANSI is stripped before every comparison (the raw form stays on `.text`),
+ * the `{{token}}` grammar applies to the fixture, and `.grep()` composition
+ * works exactly as on any stream accessor.
+ *
+ * The ANCHOR is why this sits apart from the accessor it builds: reading the
+ * caller's frame means reading a stack and a real path, which is node's alone.
+ * {@link TextAccessor} itself is a pure projection over a captured string, so
+ * it loads in a page — and the browser entry builds its own `text()`, where
+ * the golden commands resolve `_expected/` from the test's path server-side.
  */
-declare const within: (scope: ElementRef, target: ElementRef) => ElementRef;
+declare function text(value: string): TextAccessor;
+//#endregion
+//#region src/specification/ports/container.port.d.ts
+/**
+ * Abstract container interface.
+ * Represents a running service (database, cache, etc.)
+ */
+type ContainerPort = {
+  /** Start the container and wait until ready. */
+  start: () => Promise<void>;
+  /** Stop and remove the container. */
+  stop: () => Promise<void>;
+  /** Get the mapped host port for a container port. */
+  getMappedPort: (containerPort: number) => number;
+  /** Get the host to connect to. */
+  getHost: () => string;
+  /** Get a full connection string for this service. */
+  getConnectionString: () => string;
+  /** Get container logs (stdout + stderr). */
+  getLogs: () => Promise<string>;
+};
 //#endregion
 //#region src/integrations/postgres/postgres.d.ts
 type PostgresOptions = {
@@ -2240,228 +3282,11 @@ declare class SqliteHandle implements DatabasePort, ServiceHandle {
  */
 declare function sqlite(options?: SqliteOptions): SqliteHandle;
 //#endregion
-//#region src/specification/contracts/filters.d.ts
-/**
- * A text filter on a provider request builder (`openai.chat({ user })`,
- * `anthropic.messages({ system })`, …).
- *
- * A **string is EXACT**. That is deliberate: a substring filter silently
- * cross-matches — two prompts sharing a preamble both satisfy the first
- * contract, and the spec goes green on the wrong reply. Looser matching is
- * explicit, and says which looseness it means:
- *
- * - a `RegExp` — pattern matching;
- * - `match.includes('…')` — containment, the code-only matcher (it never joins
- *   the `{{token}}` file vocabulary, CONVENTIONS D4);
- * - any other `match.*` matcher, evaluated by the same structural engine the
- *   assertions use.
- */
-type TextFilter = Matcher | RegExp | string;
-//#endregion
-//#region src/integrations/anthropic/anthropic.d.ts
-type AnthropicMessagesFilter = {
-  model?: TextFilter;
-  system?: TextFilter;
-  user?: TextFilter;
-  tools?: string[];
-};
-/**
- * Anthropic API intercept helpers.
- */
-declare const anthropic: {
-  /**
-   * Request: match Messages API calls, optionally routed through a
-   * custom gateway URL. When used with a JSON fixture file, the data is
-   * returned as-is (no wrapping) because Anthropic fixtures are typically
-   * already in the Messages API response shape.
-   *
-   * @example
-   *   anthropic.messages()
-   *   anthropic.messages({ system: /classify/ })
-   *   anthropic.messages({ user: buildPrompt() })   // string = EXACT equality
-   *   anthropic.messages({ user: /classify/ }, GATEWAY)
-   */
-  messages(filter?: AnthropicMessagesFilter, url?: string): ContractRequest;
-  /** Response: wrap data in Anthropic messages format. */
-  reply(data: unknown): ContractResponse;
-  /** Response: return an Anthropic error. */
-  error(status: number, message?: string): ContractResponse;
-  /** Response: simulate a timeout. */
-  timeout(): ContractResponse;
-};
-//#endregion
-//#region src/specification/contracts/http.d.ts
-/**
- * Request filters for the generic HTTP provider. Every field is a subset
- * constraint — a request matches when all provided fields match.
- */
-type HttpContractFilter = {
-  /**
-   * Body constraint. An object is a deep SUBSET match (toMatchObject-style)
-   * whose leaf values may be `match.*` matchers; a string is a containment
-   * test and a RegExp a `test()` over the raw text body.
-   */
-  body?: object | RegExp | string;
-  /** Header subset. Names are case-insensitive; string = exact value, RegExp = `test()`. */
-  headers?: Record<string, RegExp | string>;
-  /** Query-param subset. string = exact value, RegExp = `test()`. */
-  query?: Record<string, RegExp | string>;
-};
-/** Init options shared by the response builders. */
-type HttpResponseInit = {
-  /** Delay in ms before responding (for timeout testing). */
-  delay?: number;
-  /** Response headers, merged over the builder's own. */
-  headers?: Record<string, string>;
-  /** HTTP status code. */
-  status?: number;
-};
-/**
- * Generic HTTP contract helpers for any URL. The url is absolute (string or
- * RegExp), or a PATH FORM starting with `/` — `http.get('/articles/{{uuid}}')`
- * matches that path on ANY origin, which is what an app calling its own
- * backend needs. An optional {@link HttpContractFilter} narrows matching by
- * body, headers, or query — a request that hits the URL/method but fails the
- * filter counts as unmatched (strict contracts, CONVENTIONS D7).
- *
- * @example
- *   defineContract({ request: http.get('/articles/{{uuid}}'), response: http.json(article) })
- *   defineContract({ request: http.post(URL, { body: { user: 'alice' } }), response: http.empty() })
- */
-declare const http: {
-  any(url: RegExp | string, filter?: HttpContractFilter): ContractRequest;
-  delete(url: RegExp | string, filter?: HttpContractFilter): ContractRequest;
-  get(url: RegExp | string, filter?: HttpContractFilter): ContractRequest;
-  patch(url: RegExp | string, filter?: HttpContractFilter): ContractRequest;
-  post(url: RegExp | string, filter?: HttpContractFilter): ContractRequest;
-  put(url: RegExp | string, filter?: HttpContractFilter): ContractRequest;
-  /** Response: a body-less reply (204 by default). */
-  empty(status?: number): ContractResponse;
-  /** Response: an error status. Without a body, `{ error: 'HTTP <status>' }`. */
-  error(status: number, body?: unknown): ContractResponse;
-  /** Response: a JSON body (200 by default). */
-  json(body: unknown, init?: HttpResponseInit): ContractResponse;
-  /** Response: a text body, served as `text/plain` (200 by default). */
-  text(body: string, init?: HttpResponseInit): ContractResponse;
-};
-//#endregion
-//#region src/integrations/openai/openai.d.ts
-type OpenAIChatFilter = {
-  model?: TextFilter;
-  system?: TextFilter;
-  user?: TextFilter;
-  tools?: string[];
-  temperature?: number;
-};
-type OpenAIResponsesFilter = {
-  model?: TextFilter;
-  system?: TextFilter;
-  user?: TextFilter;
-  tools?: string[];
-};
-/**
- * OpenAI API intercept helpers.
- */
-declare const openai: {
-  /**
-   * Request: match Chat Completions API calls. STRING filters mean EXACT
-   * equality (pass the app's own prompt builder); loosen deliberately with a
-   * RegExp or `match.includes(...)`.
-   *
-   * @example
-   *   openai.chat()                            // any chat call
-   *   openai.chat({ model: 'gpt-4o' })         // exact model
-   *   openai.chat({ system: buildPrompt() })   // exact system prompt
-   *   openai.chat({ system: /classify/ })      // pattern
-   */
-  chat(filter?: OpenAIChatFilter): ContractRequest;
-  /**
-   * Request: match Responses API calls (AI SDK v5+) with auto-wrapping.
-   * String filters mean EXACT equality (see {@link openai.chat}).
-   * When used with a JSON file, the data is automatically wrapped in the
-   * Responses API envelope.
-   *
-   * @param filter - Optional body filters.
-   * @param url - Custom gateway URL (default: api.openai.com).
-   *
-   * @example
-   *   openai.responses({ user: /Report Ingestion/ }, GATEWAY)
-   */
-  responses(filter?: OpenAIResponsesFilter, url?: string): ContractRequest;
-  /**
-   * Response: wrap data in Chat Completions format.
-   *
-   * @example
-   *   openai.reply({ categories: ['TECH'] })
-   */
-  reply(data: unknown): ContractResponse;
-  /** Response: return an OpenAI error. */
-  error(status: number, message?: string): ContractResponse;
-  /** Response: return malformed content. */
-  malformed(content: string): ContractResponse;
-  /** Response: simulate a timeout. */
-  timeout(): ContractResponse;
-};
-//#endregion
-//#region src/vitest/mock-of.d.ts
-/** Factory signature that creates a deep mock proxy for any interface. */
-type MockPort = <T>() => DeepMockProxy<T>;
-/**
- * Create a deep mock proxy for a given type.
- * Wraps `vitest-mock-extended`'s `mockDeep` for convenient port mocking.
- */
-declare const mockOf: MockPort;
-//#endregion
-//#region src/vitest/mock-of-date.d.ts
-/** Interface for freezing and resetting the global Date in tests. */
-type MockDatePort = {
-  /** Restore the real Date object. */
-  reset: () => void;
-  /** Freeze `Date.now()` and `new Date()` to the given value. */
-  set: (date: Date | number | string) => void;
-};
+//#region src/index.d.ts
 /**
- * Freeze or reset the global Date for deterministic time-dependent tests.
- * Wraps the `mockdate` package.
+ * The module-scope network double, on msw's node server — what a test with no
+ * chain to hang contracts on reaches for (chapter 10).
  */
-declare const mockOfDate: MockDatePort;
-//#endregion
-//#region src/index.d.ts
-declare module 'vitest' {
-  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).
-     */
-    toBeEmpty: T extends TableAccessor ? () => Promise<void> : T extends {
-      readonly comparableText: string;
-    } ? () => Promise<void> : never;
-    /** Assert the container is running. Async — docker-backed subject. */
-    toBeRunning: T extends ContainerAccessor ? () => Promise<void> : never;
-    /**
-     * On `@jterrazz/test` accessors: assert the subject matches a fixture
-     * file under `_expected/<name>` (flat — a slash creates a subfolder;
-     * `.http` format for `result.response`). Async for filesystem/directory
-     * subjects (tree compare on disk). Other subjects keep vitest-native
-     * `toMatch` semantics (string substring / regexp).
-     *
-     * Pass `{ frozen: true }` to opt a single fixture OUT of update-mode
-     * rewriting: a frozen fixture is never overwritten under `TEST_UPDATE=1`
-     * (or vitest `-u`), and a frozen mismatch/missing fixture still throws.
-     * Use it for a deliberately-wrong fixture whose diff/error rendering is
-     * 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;
-  }
-}
+declare const intercept: Intercept;
 //#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 CliInput, 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, type DeviceTimeouts, 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 LiterateRunFlags, type LiterateServeRegistration, 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 SpecDocument, type SpecEnvToken, type SpecFileAssertion, type SpecFixture, type SpecKind, type SpecRun, type SpecServeEntry, type SpecStream, 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, CallResult, type CaptureScope, type CliEnv, type CliHandle, type CliInput, type CliOutput, type CliPort, CliResult, type CliSpecification, type CliSpecificationOptions, type ComponentChain, type ComponentScenario, type ComponentUi, type ComponentVisitor, 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, type DeviceTimeouts, DirectoryAccessor, type DockerSpecConfig, type DomMount, type ElementKind, type ElementMatch, type ElementOptions, type ElementRef, type ExecOptions, FetchResult, type FileAccessor, FilesystemAccessor, type HonoApp, type HttpContractFilter, type HttpResponseInit, HttpResult, type HttpStreamInit, type IntegrationHandle, type IntegrationSpecification, type IntegrationSpecificationOptions, type Intercept, type InterceptScope, type IsolationStrategy, type JobHandle, type JobsHandle, type JobsSpecification, type JobsSpecificationOptions, JsonAccessor, type LandmarkKind, type LiterateRunFlags, type LiterateServeRegistration, 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 MockOfOptions, type MockPort, Orchestrator, PageResult, type PinnedClock, type PostgresOptions, ProcessHandle, type ProcessOptions, type RedisOptions, type RenderResult, type RenderSubject, type RenderedText, ResponseAccessor, type ScreenNode, ScreenResult, type ServeOptions, type ServerPort, type ServerResponse, type ServerSpec, type ServiceHandle, type ServiceRecord, type SpecDocument, type SpecEnvToken, type SpecFileAssertion, type SpecFixture, type SpecKind, type SpecRun, type SpecServeEntry, type SpecStream, type SpecificationConfig, type SpecificationMode, type SqliteOptions, type SseEvent, type StreamBody, TableAccessor, TextAccessor, type TextFilter, type VisitScenario, type Visitor, type WaitUntilOptions, type WebsiteBackendOptions, type WebsiteHandle, type WebsiteSpecification, type WebsiteSpecificationOptions, anthropic, banner, button, clock, complementary, component, content, contentinfo, defineContract, defineContracts, dialog, disabled, enabled, field, findContainersByLabel, focused, form, heading, http, inspectContainer, intercept, link, listitem, main, match, mockOf, mockOfDate, navigation, openai, option, postgres, processService as process, redis, region, removeContainers, required, row, search, selected, specification, sqlite, status, table, testId, text, valued, waitUntil, within };