@jterrazz/test 15.2.0 → 15.3.0

package/dist/index.d.ts

@@ -1,119 +1,7 @@
 import { Scalar } from "yaml";
-import { DeepMockProxy } from "vitest-mock-extended";
+import { DeepMockProxy, MockProxy } from "vitest-mock-extended";
 import { ReactNode as ComponentUi } from "react";
 import "vitest/browser";
-//#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
 //#region src/specification/contracts/types.d.ts
 /**
  * The observed outgoing request, reduced to what contract matchers inspect.
@@ -157,7 +45,11 @@ 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;
@@ -174,6 +66,31 @@ type ContractResponse = {
    */
   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
  * contract is served, rather than fixed ahead of time. Handed the same
@@ -272,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
@@ -424,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
@@ -978,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 {
@@ -1194,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).
@@ -1240,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. */
@@ -1264,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. */
@@ -1273,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
@@ -1317,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;
   /**
@@ -1863,6 +2025,28 @@ type HttpContractFilter = {
   /** 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). */
@@ -1902,6 +2086,27 @@ declare const http: {
    * 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;
 };
@@ -1965,13 +2170,35 @@ declare const openai: {
 };
 //#endregion
 //#region src/vitest/mock-of.d.ts
-/** Factory signature that creates a deep mock proxy for any interface. */
-type MockPort = <T>() => DeepMockProxy<T>;
+/** 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;
+};
 /**
- * Create a deep mock proxy for a given type.
- * Wraps `vitest-mock-extended`'s `mockDeep` for convenient port mocking.
- */
-declare const mockOf: MockPort;
+ * 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. */
@@ -1987,6 +2214,115 @@ type MockDatePort = {
  */
 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> {
@@ -2188,6 +2524,14 @@ type CliSpecificationOptions<Services extends ServiceRecord = ServiceRecord> = {
    * 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`
@@ -2245,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> = {
@@ -2291,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`). */
@@ -2324,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;
 };
 /**
@@ -2345,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;
   /**
@@ -2369,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
@@ -2391,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
@@ -2403,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
@@ -2411,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;
@@ -2435,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).
  *
@@ -2462,10 +2969,11 @@ 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;
@@ -2774,4 +3282,11 @@ declare class SqliteHandle implements DatabasePort, ServiceHandle {
  */
 declare function sqlite(options?: SqliteOptions): SqliteHandle;
 //#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, 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 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, type RenderResult, type RenderSubject, type RenderedText, 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, component, content, contentinfo, defineContract, defineContracts, dialog, disabled, enabled, field, findContainersByLabel, focused, form, heading, http, inspectContainer, link, listitem, main, match, mockOf, mockOfDate, navigation, openai, option, postgres, redis, region, removeContainers, row, search, selected, specification, sqlite, status, table, testId, text, valued, within };
+//#region src/index.d.ts
+/**
+ * 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 intercept: Intercept;
+//#endregion
+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 };