@jterrazz/test 18.2.0 → 18.3.0

package/README.md

@@ -1,6 +1,6 @@
 # @jterrazz/test
 
-A testing framework on vitest for whole products: HTTP APIs, background jobs, CLIs, websites, running deployments, native mobile apps, rendered components, modules against real databases, and the lint rules a project ships. You declare what a test needs (Postgres, a built binary, a real Chromium, an iOS simulator), and the framework starts it, isolates it per worker and cleans it up. Each test is one sentence: a few setups, one action, and the whole result compared with `expect()`.
+A testing framework on vitest for whole products: HTTP APIs, background jobs, CLIs, websites, native mobile apps, rendered components, modules against real databases, and the lint rules a project ships. You declare what a test needs (Postgres, a built binary, a real Chromium, an iOS simulator), and the framework starts it, isolates it per worker and cleans it up. Each test is one sentence: a few setups, one action, and the whole result compared with `expect()`.
 
 ```typescript
 // specs/api/users/list/shape.spec.ts
@@ -52,8 +52,7 @@ An ES module project on Node 24, vitest 5 and `@jterrazz/typescript` 11 is requi
 | [Component](docs/guides/component-specs.md)     | A React component, hook or DOM function in a real Chromium      | `component.render()`           |
 | [Website](docs/guides/website-specs.md)         | A served page, fetched or driven in a browser                   | `specification.website()`      |
 | [Mobile](docs/guides/mobile-specs.md)           | A native app on an iOS simulator                                | `specification.mobile()`       |
-| [Deployment](docs/guides/deployment-specs.md)   | A running deployment, probed over the network, no browser       | `specification.deployment()`   |
-| [API](docs/guides/api-specs.md)                 | An HTTP app, through complete requests                          | `specification.api()`          |
+| [API](docs/guides/api-specs.md)                 | An HTTP app, in this process or deployed at a `url`             | `specification.api()`          |
 | [Job](docs/guides/job-specs.md)                 | A pipeline triggered by name                                    | `specification.job()`          |
 | [CLI](docs/guides/cli-specs.md)                 | A binary in a fresh working directory, often as a YAML document | `specification.cli()`          |
 | [Lint](docs/guides/lint-specs.md)               | The rules a project ships, over fixture trees                   | `specification.lint()`         |

package/dist/browser-shared-index.browser.js

@@ -3211,11 +3211,10 @@ async function waitUntil(predicate, options = {}) {
 }
 //#endregion
 //#region src/index.browser.ts
-/** The eight constructors, present and refusing in a page. */
+/** The seven constructors, present and refusing in a page. */
 const specification = {
 	api: () => refuse("specification.api()"),
 	cli: () => refuse("specification.cli()"),
-	deployment: () => refuse("specification.deployment()"),
 	integration: () => refuse("specification.integration()"),
 	job: () => refuse("specification.job()"),
 	lint: () => refuse("specification.lint()"),

package/dist/checker.js

@@ -1,5 +1,5 @@
-import { n as parsedJson } from "./shared-json-shape.js";
 import { t as CATALOGUE_CHAPTER } from "./shared-chapter.js";
+import { n as parsedJson } from "./shared-json-shape.js";
 import { i as findUnknownTokens, n as findKnownTokens, r as findMalformedRefs, t as TOKEN_KINDS } from "./shared-tokens.js";
 import { a as RUN_KEYS, c as isRelativePath, o as SPEC_EXTENSION, s as SpecSyntaxError, t as DOCUMENT_KEYS } from "./shared-spec-grammar.js";
 import { i as literalEnd, n as argumentsOf, o as openersAt, r as closingOf, s as skipString, t as argumentSpans } from "./shared-source-scan.js";

package/dist/config.d.ts

@@ -22,7 +22,7 @@ type TestSettings = {
   specifications?: readonly string[];
 };
 /** The helpers a project is built by, named by their specification. */
-type TestSpecification = 'api' | 'cli' | 'component' | 'deployment' | 'integration' | 'job' | 'lint' | 'mobile' | 'unit' | 'website';
+type TestSpecification = 'api' | 'cli' | 'component' | 'integration' | 'job' | 'lint' | 'mobile' | 'unit' | 'website';
 /** What a declared project states beyond its derived one: the global setups it runs, the options its helper takes, and why. */
 type TestProject = {
   readonly reason: string;

package/dist/config.js

@@ -1,5 +1,5 @@
-import { t as isRecord } from "./shared-json-shape.js";
 import { t as CATALOGUE_CHAPTER } from "./shared-chapter.js";
+import { t as isRecord } from "./shared-json-shape.js";
 import { n as specificationModules, t as derivedProjects } from "./shared-derived-projects.js";
 import { t as TEST_SECTION } from "./shared-test-section.js";
 import { n as recommendedRules, t as consumerRows } from "./shared-manifest.js";
@@ -13,7 +13,6 @@ var standard_default = defineStandard({ test: {
 		"api",
 		"cli",
 		"component",
-		"deployment",
 		"integration",
 		"job",
 		"lint",

package/dist/index.d.ts

@@ -307,6 +307,163 @@ declare class ResponseAccessor {
   constructor(response: ServerResponse, testDir: string, captures?: CaptureScope, recording?: ResponseRecording);
 }
 //#endregion
+//#region src/specifications/api/deployed/tls-facts.d.ts
+/** The certificate an HTTPS exchange was presented, and what the client made of it. */
+type TlsFacts = {
+  /** The names the certificate is valid for (its subjectAltName), each without its `DNS:` or `IP Address:` prefix. */
+  readonly altNames: readonly string[];
+  /** The code the trust check refused with (`DEPTH_ZERO_SELF_SIGNED_CERT`, `CERT_HAS_EXPIRED`, `ERR_TLS_CERT_ALTNAME_INVALID` ...), undefined when trusted. */
+  readonly authorizationError: string | undefined;
+  /** Whether the certificate chains to a trusted authority and covers the URL's host. */
+  readonly authorized: boolean;
+  /** Whole days from the exchange to `validTo`, negative once it has expired. */
+  readonly daysRemaining: number;
+  /** The issuer's common name, or its organisation when it states none. */
+  readonly issuer: string;
+  /** The TLS version negotiated (`TLSv1.3`). */
+  readonly protocol: string | undefined;
+  /** The subject's common name; empty when it states none. */
+  readonly subject: string;
+  readonly validFrom: Date;
+  readonly validTo: Date;
+  /** Whether the certificate is valid for `host`, wildcards read as a client reads them. */
+  covers: (host: string) => boolean;
+};
+//#endregion
+//#region src/specifications/api/deployed/exchange.result.d.ts
+/** What one request to a deployed api hands back: the response, or why none came, and the certificate it came over; no table and no disk, which a deployed api keeps to itself. */
+declare class ExchangeResult {
+  private readonly answer;
+  private readonly recording;
+  private readonly scope;
+  private readonly testDir;
+  /** The certificate an https request was presented and the trust check's verdict; undefined over http, or when no handshake completed. */
+  readonly tls: TlsFacts | undefined;
+  constructor(options: {
+    recording: ResponseRecording;
+    response: ServerResponse;
+    testDir: string;
+    tls: TlsFacts | undefined;
+  });
+  /** The whole response (status, headers, body), or `unreachable: <reason>`, compared whole: `toMatch(<.http text>)` or `toMatch(file(...))`. */
+  get response(): ResponseAccessor;
+}
+//#endregion
+//#region src/chain/action.d.ts
+type SliceReader = <Slice>(capability: {
+  readonly initial: Slice;
+  readonly name: string;
+}) => Slice;
+type Action<Name extends string, Args extends readonly unknown[], Result, Signature extends ChainSignature = ChainSignature, Needs extends object = Record<never, never>, Config extends ChainConfig = ChainConfig> = {
+  readonly accessors: readonly MatrixRow[];
+  readonly targets?: readonly MatrixRow[];
+  readonly kind: 'action';
+  readonly name: Name;
+  readonly options?: readonly ActionOption<string>[];
+  readonly row: MatrixRow;
+  /** A type alone, never set at runtime: `ChainOf` reads it. */
+  readonly signature?: Signature;
+  readonly verbs?: readonly MatrixRow[];
+  prepare?(args: Args, read: SliceReader): Promise<{
+    readonly workDir: null | string;
+  }> | {
+    readonly workDir: null | string;
+  };
+  perform(args: Args, read: SliceReader, adapters: Needs, run: Run<Config>): Promise<Result>;
+};
+type AnyAction = Action<string, readonly unknown[], unknown, ChainSignature, object>;
+//#endregion
+//#region src/specifications/api/deployed/request.action.d.ts
+type ExchangeSignature = ChainSignature & {
+  readonly chain: {
+    /** Send a GET to a URL, written whole or as a path from the specification's `url`, and resolve with what came back. */
+    get: (target: string) => Promise<ExchangeResult>;
+    /** Send a complete request: its `.http` text written in the test, or `file('./__requests__/<name>.http')`; its first line names the URL whole or a path. */
+    request: (source: DiskFile<'.http'> | string) => Promise<ExchangeResult>;
+  };
+};
+//#endregion
+//#region src/specifications/api/deployed/connect.capability.d.ts
+type ConnectChain<Self> = {
+  /** Open the socket on this address instead of the URL's host and port, as curl's `--connect-to`: the Host header and the TLS server name stay the URL's; a later call wins. */
+  connect: (address: string) => Self;
+};
+interface ConnectSignature extends ChainSignature {
+  readonly chain: ConnectChain<this['self']>;
+}
+//#endregion
+//#region src/chain/context/headers.capability.d.ts
+type HeadersMethod<Self> = (headers: Record<string, string>) => Self;
+type HeadersChain<Self> = {
+  /** Set HTTP headers for the exchange. Multiple calls merge. */
+  headers: HeadersMethod<Self>;
+};
+interface HeadersSignature extends ChainSignature {
+  readonly chain: HeadersChain<this['self']>;
+}
+//#endregion
+//#region src/chain/define-specification.d.ts
+type Composition = {
+  readonly actions: readonly AnyAction[];
+  readonly capabilities: readonly (AnyCapability | Sharing)[];
+  readonly options: Readonly<Record<string, MatrixRow>>;
+};
+//#endregion
+//#region src/chain/chain.d.ts
+type Names<List extends readonly {
+  readonly name: string;
+}[]> = List[number]['name'];
+type ContextOf<C extends Composition> = C['capabilities'][number] extends (infer Member) ? Member extends Capability<string, infer _Slice, infer _Args, infer _Signature, infer _Needs, infer Key> ? Key : never : never;
+type SharingOf<C extends Composition, Self> = 'with' extends Names<C['capabilities']> ? {
+  with: (context: Pick<ChainContext, ContextOf<C>>) => Self;
+} : unknown;
+type MethodsOf<Member, P extends SpecificationParams, Self> = Member extends {
+  readonly signature?: infer Signature;
+} ? Signature extends ChainSignature ? (Signature & {
+  readonly params: P;
+  readonly self: Self;
+})['chain'] : never : never;
+type Methods<C extends Composition, P extends SpecificationParams, Self> = Intersect<MethodsOf<C['actions'][number] | C['capabilities'][number], P, Self>>;
+type ChainOf<C extends Composition, P extends SpecificationParams, Self> = Pick<Methods<C, P, Self>, Extract<Names<C['actions']> | Names<C['capabilities']>, keyof Methods<C, P, Self>>> & SharingOf<C, Self>;
+//#endregion
+//#region src/specifications/api/deployed/deployed.composition.d.ts
+declare const composition$8: {
+  readonly actions: readonly [Action<"request", [source: string | DiskFile<".http">], ExchangeResult, ExchangeSignature, Record<never, never>, ApiDeployedConfig>, Action<"get", [target: string], ExchangeResult, ExchangeSignature, Record<never, never>, ApiDeployedConfig>];
+  readonly capabilities: readonly [Capability<"connect", string | null, [address: string], ConnectSignature, Record<never, never>, never, ChainConfig>, Capability<"headers", Readonly<Record<string, string>>, [headers: Record<string, string>], HeadersSignature, Record<never, never>, "headers", ChainConfig>, Sharing];
+  readonly options: {
+    ca: {
+      group: "Constructor option";
+      name: string;
+      probe: string;
+    };
+    insecure: {
+      group: "Constructor option";
+      name: string;
+      probe: string;
+    };
+    recordedHeaders: {
+      group: "Constructor option";
+      name: string;
+      probe: string;
+    };
+    timeout: {
+      group: "Constructor option";
+      name: string;
+      probe: string;
+    };
+    url: {
+      group: "Constructor option";
+      name: string;
+      probe: string;
+    };
+  };
+};
+/** The chain `specification.api({ url })` hands out: requests to the deployed api, over the network. */
+interface ApiDeployedSpecification extends ChainOf<typeof composition$8, {
+  databaseKey: string;
+  services: Record<string, unknown>;
+}, ApiDeployedSpecification> {}
+//#endregion
 //#region src/specifications/api/server/server.port.d.ts
 /** What a request carries beside its method, path and body. */
 type ServerRequestOptions = {
@@ -347,30 +504,6 @@ type HonoApp = {
   routes?: readonly TableEntry[];
 };
 //#endregion
-//#region src/chain/action.d.ts
-type SliceReader = <Slice>(capability: {
-  readonly initial: Slice;
-  readonly name: string;
-}) => Slice;
-type Action<Name extends string, Args extends readonly unknown[], Result, Signature extends ChainSignature = ChainSignature, Needs extends object = Record<never, never>, Config extends ChainConfig = ChainConfig> = {
-  readonly accessors: readonly MatrixRow[];
-  readonly targets?: readonly MatrixRow[];
-  readonly kind: 'action';
-  readonly name: Name;
-  readonly options?: readonly ActionOption<string>[];
-  readonly row: MatrixRow;
-  /** A type alone, never set at runtime: `ChainOf` reads it. */
-  readonly signature?: Signature;
-  readonly verbs?: readonly MatrixRow[];
-  prepare?(args: Args, read: SliceReader): Promise<{
-    readonly workDir: null | string;
-  }> | {
-    readonly workDir: null | string;
-  };
-  perform(args: Args, read: SliceReader, adapters: Needs, run: Run<Config>): Promise<Result>;
-};
-type AnyAction = Action<string, readonly unknown[], unknown, ChainSignature, object>;
-//#endregion
 //#region src/specifications/api/request/route.d.ts
 type RouteParamNames<Path extends string> = Path extends `${infer Route}?${string}` ? RouteParamNames<Route> : Path extends `${string}/:${infer Rest}` ? Rest extends `${infer Name}/${infer Tail}` ? Name | RouteParamNames<`/${Tail}`> : Rest : never;
 type RouteOptions<Path extends string> = [RouteParamNames<Path>] extends [never] ? {
@@ -415,16 +548,6 @@ interface ClockSignature extends ChainSignature {
   readonly chain: ClockChain<this['self']>;
 }
 //#endregion
-//#region src/chain/context/headers.capability.d.ts
-type HeadersMethod<Self> = (headers: Record<string, string>) => Self;
-type HeadersChain<Self> = {
-  /** Set HTTP headers for the exchange. Multiple calls merge. */
-  headers: HeadersMethod<Self>;
-};
-interface HeadersSignature extends ChainSignature {
-  readonly chain: HeadersChain<this['self']>;
-}
-//#endregion
 //#region src/stubs/intercept/intercept.port.d.ts
 type InterceptPort = {
   /** Refuse the setup when this adapter cannot serve a stub at all. */
@@ -453,32 +576,8 @@ type SeedPort = {
   readonly target: (database?: string) => DatabasePort;
 };
 //#endregion
-//#region src/chain/define-specification.d.ts
-type Composition = {
-  readonly actions: readonly AnyAction[];
-  readonly capabilities: readonly (AnyCapability | Sharing)[];
-  readonly options: Readonly<Record<string, MatrixRow>>;
-};
-//#endregion
-//#region src/chain/chain.d.ts
-type Names<List extends readonly {
-  readonly name: string;
-}[]> = List[number]['name'];
-type ContextOf<C extends Composition> = C['capabilities'][number] extends (infer Member) ? Member extends Capability<string, infer _Slice, infer _Args, infer _Signature, infer _Needs, infer Key> ? Key : never : never;
-type SharingOf<C extends Composition, Self> = 'with' extends Names<C['capabilities']> ? {
-  with: (context: Pick<ChainContext, ContextOf<C>>) => Self;
-} : unknown;
-type MethodsOf<Member, P extends SpecificationParams, Self> = Member extends {
-  readonly signature?: infer Signature;
-} ? Signature extends ChainSignature ? (Signature & {
-  readonly params: P;
-  readonly self: Self;
-})['chain'] : never : never;
-type Methods<C extends Composition, P extends SpecificationParams, Self> = Intersect<MethodsOf<C['actions'][number] | C['capabilities'][number], P, Self>>;
-type ChainOf<C extends Composition, P extends SpecificationParams, Self> = Pick<Methods<C, P, Self>, Extract<Names<C['actions']> | Names<C['capabilities']>, keyof Methods<C, P, Self>>> & SharingOf<C, Self>;
-//#endregion
 //#region src/specifications/api/api.composition.d.ts
-declare const composition$8: {
+declare const composition$7: {
   readonly actions: readonly [Action<"request", [source: string | DiskFile<".http">], HttpResult, RequestSignature, {
     server: ServerPort;
   }, ChainConfig>, Action<"get", [path: string, options?: RouteOptionsAny], HttpResult, RequestSignature, {
@@ -521,14 +620,14 @@ declare const composition$8: {
   };
 };
 /** The chain `specification.api()` hands out; the app answers in this process (`server-sees-declared-services`). */
-interface ApiSpecification<DatabaseKey extends string = string> extends ChainOf<typeof composition$8, {
+interface ApiSpecification<DatabaseKey extends string = string> extends ChainOf<typeof composition$7, {
   databaseKey: DatabaseKey;
   services: Record<string, unknown>;
 }, ApiSpecification<DatabaseKey>> {}
 //#endregion
 //#region src/specifications/api/api.handle.d.ts
-/** Options for {@link startApi | specification.api}. */
-type ApiSpecificationOptions<Services extends ServiceRecord = ServiceRecord> = {
+/** The app built in this process, from the services the specification starts. */
+type ApiServedOptions<Services extends ServiceRecord = ServiceRecord> = {
   /** Project root override; by default the nearest `package.json` above the specification file (`no-redundant-root`). */
   root?: string;
   /** The app factory: receives the started services record, returns the Hono app. */
@@ -536,7 +635,30 @@ type ApiSpecificationOptions<Services extends ServiceRecord = ServiceRecord> = {
   /** Named infrastructure record: the keys are the `database` vocabulary, and name the init-script folder. */
   services?: Services;
 };
-/** What `specification.api()` returns: `const { api, cleanup, docker } = ...` (`no-runner-alias`). */
+/** The api already deployed, met over the network at its URL. */
+type ApiDeployedOptions = {
+  /** A certificate authority trusted beside the ones node trusts: its PEM text, a value like any string. */
+  ca?: string;
+  /** Accept a certificate the trust check refuses (self-signed, expired, another host's); `result.tls` still says why. Default `false`. */
+  insecure?: boolean;
+  /** The headers update mode records into a golden that states none yet, those the response carries. Default `['content-type', 'location']`. */
+  recordedHeaders?: readonly string[];
+  /** The milliseconds one request may take, connection to last byte, before it reads `unreachable: timeout`. Default `5000`. */
+  timeout?: number;
+  /** The deployed api's base URL: a path is read from it (`.get('/health')`), a URL written whole reaches any host. */
+  url: string;
+};
+type Absent<Options> = { [Key in keyof Options]?: never; };
+/** Options for {@link startApi | specification.api}: `server` or `url`, exclusive by type. */
+type ApiSpecificationOptions<Services extends ServiceRecord = ServiceRecord> = (Absent<ApiDeployedOptions> & ApiServedOptions<Services>) | (Absent<ApiServedOptions> & ApiDeployedOptions);
+type ApiDeployedConfig = ChainConfig & {
+  baseUrl: string;
+  ca: string | undefined;
+  insecure: boolean;
+  recording: ResponseRecording;
+  timeout: number;
+};
+/** What `specification.api({ server })` returns: `const { api, cleanup, docker } = ...` (`no-runner-alias`). */
 type ApiHandle<DatabaseKey extends string = string> = {
   api: ApiSpecification<DatabaseKey>;
   /** Stop all infrastructure started by this specification. */
@@ -544,7 +666,13 @@ type ApiHandle<DatabaseKey extends string = string> = {
   /** Read a running container by id. */
   docker: (containerId: string) => ContainerAccessor;
 };
-declare function startApi<Services extends ServiceRecord>(options: ApiSpecificationOptions<Services>): Promise<ApiHandle<DatabaseKeys<Services>>>;
+/** What `specification.api({ url })` returns: `const { api, cleanup } = ...`; it starts nothing, so `cleanup` releases nothing and there is no container to read. */
+type ApiDeployedHandle = {
+  api: ApiDeployedSpecification;
+  cleanup: () => Promise<void>;
+};
+declare function startApi(options: Absent<ApiServedOptions> & ApiDeployedOptions): Promise<ApiDeployedHandle>;
+declare function startApi<Services extends ServiceRecord = ServiceRecord>(options: Absent<ApiDeployedOptions> & ApiServedOptions<Services>): Promise<ApiHandle<DatabaseKeys<Services>>>;
 //#endregion
 //#region src/services/startup/startup-report.d.ts
 type AppInfo = {
@@ -733,7 +861,7 @@ interface PrepareSignature extends ChainSignature {
 }
 //#endregion
 //#region src/specifications/cli/cli.composition.d.ts
-declare const composition$7: {
+declare const composition$6: {
   readonly actions: readonly [Action<"exec", [args?: string | string[], options?: ExecOptions], CliResult, ExecSignature, {
     command: CliPort;
   }, CliConfig>, Action<"run", [document: DiskFile<".spec.yaml">, options?: LiterateRunFlags], CliResult, RunSignature$1, Record<never, never>, CliConfig>];
@@ -806,7 +934,7 @@ declare const composition$7: {
   };
 };
 /** The chain `specification.cli()` hands out: a binary run in a fresh, empty working directory, in its own process. */
-interface CliSpecification<DatabaseKey extends string = string> extends ChainOf<typeof composition$7, {
+interface CliSpecification<DatabaseKey extends string = string> extends ChainOf<typeof composition$6, {
   databaseKey: DatabaseKey;
   services: Record<string, unknown>;
 }, CliSpecification<DatabaseKey>> {}
@@ -874,131 +1002,6 @@ type CliHandle<DatabaseKey extends string = string> = {
 };
 declare function startCli<Services extends ServiceRecord>(bin: string, options?: CliSpecificationOptions<Services>): Promise<CliHandle<DatabaseKeys<Services>>>;
 //#endregion
-//#region src/specifications/deployment/exchange/tls-facts.d.ts
-/** The certificate an HTTPS exchange was presented, and what the client made of it. */
-type TlsFacts = {
-  /** The names the certificate is valid for (its subjectAltName), each without its `DNS:` or `IP Address:` prefix. */
-  readonly altNames: readonly string[];
-  /** The code the trust check refused with (`DEPTH_ZERO_SELF_SIGNED_CERT`, `CERT_HAS_EXPIRED`, `ERR_TLS_CERT_ALTNAME_INVALID` ...), undefined when trusted. */
-  readonly authorizationError: string | undefined;
-  /** Whether the certificate chains to a trusted authority and covers the URL's host. */
-  readonly authorized: boolean;
-  /** Whole days from the exchange to `validTo`, negative once it has expired. */
-  readonly daysRemaining: number;
-  /** The issuer's common name, or its organisation when it states none. */
-  readonly issuer: string;
-  /** The TLS version negotiated (`TLSv1.3`). */
-  readonly protocol: string | undefined;
-  /** The subject's common name; empty when it states none. */
-  readonly subject: string;
-  readonly validFrom: Date;
-  readonly validTo: Date;
-  /** Whether the certificate is valid for `host`, wildcards read as a client reads them. */
-  covers: (host: string) => boolean;
-};
-//#endregion
-//#region src/specifications/deployment/exchange/exchange.result.d.ts
-/** What one exchange with a deployment hands back: the response, or why none came, and the certificate it was presented. */
-declare class ExchangeResult extends BaseResult {
-  private readonly answer;
-  private readonly recording;
-  /** The certificate an https exchange was presented and the trust check's verdict; undefined over http, or when no handshake completed. */
-  readonly tls: TlsFacts | undefined;
-  constructor(options: BaseResultOptions & {
-    recording: ResponseRecording;
-    response: ServerResponse;
-    tls: TlsFacts | undefined;
-  });
-  /** The whole response (status, headers, body), or `unreachable: <reason>`, compared whole: `toMatch(<.http text>)` or `toMatch(file(...))`. */
-  get response(): ResponseAccessor;
-}
-//#endregion
-//#region src/specifications/deployment/exchange/request.action.d.ts
-type ExchangeSignature = ChainSignature & {
-  readonly chain: {
-    /** Send a GET to a URL, written whole or as a path from the specification's `url`, and resolve with what came back. */
-    get: (target: string) => Promise<ExchangeResult>;
-    /** Send a complete request: its `.http` text written in the test, or `file('./__requests__/<name>.http')`; its first line names the URL whole or a path. */
-    request: (source: DiskFile<'.http'> | string) => Promise<ExchangeResult>;
-  };
-};
-//#endregion
-//#region src/specifications/deployment/exchange/connect.capability.d.ts
-type ConnectChain<Self> = {
-  /** Open the socket on this address instead of the URL's host and port, as curl's `--connect-to`: the Host header and the TLS server name stay the URL's; a later call wins. */
-  connect: (address: string) => Self;
-};
-interface ConnectSignature extends ChainSignature {
-  readonly chain: ConnectChain<this['self']>;
-}
-//#endregion
-//#region src/specifications/deployment/deployment.composition.d.ts
-declare const composition$6: {
-  readonly actions: readonly [Action<"request", [source: string | DiskFile<".http">], ExchangeResult, ExchangeSignature, Record<never, never>, DeploymentConfig>, Action<"get", [target: string], ExchangeResult, ExchangeSignature, Record<never, never>, DeploymentConfig>];
-  readonly capabilities: readonly [Capability<"connect", string | null, [address: string], ConnectSignature, Record<never, never>, never, ChainConfig>, Capability<"headers", Readonly<Record<string, string>>, [headers: Record<string, string>], HeadersSignature, Record<never, never>, "headers", ChainConfig>, Sharing];
-  readonly options: {
-    ca: {
-      group: "Constructor option";
-      name: string;
-      probe: string;
-    };
-    insecure: {
-      group: "Constructor option";
-      name: string;
-      probe: string;
-    };
-    recordedHeaders: {
-      group: "Constructor option";
-      name: string;
-      probe: string;
-    };
-    timeout: {
-      group: "Constructor option";
-      name: string;
-      probe: string;
-    };
-    url: {
-      group: "Constructor option";
-      name: string;
-      probe: string;
-    };
-  };
-};
-/** The chain `specification.deployment()` hands out: one HTTP exchange with a running deployment, over the network. */
-interface DeploymentSpecification extends ChainOf<typeof composition$6, {
-  databaseKey: string;
-  services: Record<string, unknown>;
-}, DeploymentSpecification> {}
-//#endregion
-//#region src/specifications/deployment/deployment.handle.d.ts
-/** Options for {@link startDeployment | specification.deployment}. */
-type DeploymentSpecificationOptions = {
-  /** A certificate authority trusted beside the ones node trusts: its PEM text, a value like any string. */
-  ca?: string;
-  /** Accept a certificate the trust check refuses (self-signed, expired, another host's); `result.tls` still says why. Default `false`. */
-  insecure?: boolean;
-  /** The headers update mode records into a golden that states none yet, those the response carries. Default `['content-type', 'location']`. */
-  recordedHeaders?: readonly string[];
-  /** The milliseconds one exchange may take, connection to last byte, before it reads `unreachable: timeout`. Default `5000`. */
-  timeout?: number;
-  /** The base URL a path is read from (`.get('/health')`); a URL written whole needs none. */
-  url?: string;
-};
-type DeploymentConfig = ChainConfig & {
-  baseUrl: string | undefined;
-  ca: string | undefined;
-  insecure: boolean;
-  recording: ResponseRecording;
-  timeout: number;
-};
-/** What `specification.deployment()` returns: `const { deployment, cleanup } = ...` (`no-runner-alias`). */
-type DeploymentHandle = {
-  /** Starts nothing, so releases nothing: passed to `afterAll` like every specification's. */
-  cleanup: () => Promise<void>;
-  deployment: DeploymentSpecification;
-};
-declare function startDeployment(options?: DeploymentSpecificationOptions): Promise<DeploymentHandle>;
-//#endregion
 //#region src/specifications/integration/call.result.d.ts
 type CallOutcome = {
   error: unknown;
@@ -1690,11 +1693,10 @@ type WebsiteHandle = {
 declare function startWebsite<Services extends ServiceRecord>(options: WebsiteSpecificationOptions<Services>): Promise<WebsiteHandle>;
 //#endregion
 //#region src/specifications/specification.d.ts
-/** The eight constructors, and only eight: the framework's whole entry surface. */
+/** The seven constructors, and only seven: the framework's whole entry surface. */
 type Specification = {
   api: typeof startApi;
   cli: typeof startCli;
-  deployment: typeof startDeployment;
   integration: typeof startIntegration;
   job: typeof startJob;
   lint: typeof startLint;
@@ -2051,5 +2053,5 @@ declare module 'vitest' {
   }
 }
 //#endregion
-export { type ApiHandle, type ApiSpecification, type ApiSpecificationOptions, type BaseResult, type BrowserConsoleMessage, type BrowserLinkElement, type BrowserMetaElement, type BrowserOpenOptions, type BrowserPage, type BrowserPort, type CallResult, type CaptureScope, type CliEnv, type CliHandle, type CliInput, type CliOutput, type CliPort, type CliResult, type CliSpecification, type CliSpecificationOptions, type ComponentChain, type ComponentScenario, type ComponentUi, type ComponentVisitor, type ContainerAccessor, type DeploymentHandle, type DeploymentSpecification, type DeploymentSpecificationOptions, type DeviceOpenOptions, type DevicePort, type DeviceScreen, type DeviceTimeouts, type DirectoryAccessor, type DiskDirectory, type DiskFile, type DiskTarget, type DockerSpecConfig, type DomMount, type ElementKind, type ElementMatch, type ExchangeResult, type ExecOptions, type FetchResult, type FileAccessor, type FileAt, type FilesystemAccessor, type HonoApp, type HttpResult, type IntegrationHandle, type IntegrationSpecification, type IntegrationSpecificationOptions, type Job, type JobHandle, type JobResult, type JobSpecification, type JobSpecificationOptions, type JsonAccessor, type LandmarkKind, type LintConfig, type LintHandle, type LintResult, type LintRules, type LintRunOptions, type LintSpecification, type LintSpecificationOptions, type LiterateRunFlags, type LiterateServeRegistration, type MatchFixtureOptions, Matcher, type MatcherKind, type MobileBackendOptions, type MobileElementKind, type MobileElementMatch, type MobileHandle, type MobileScenario, type MobileSpecification, type MobileSpecificationOptions, type MobileVisitor, type MockOfOptions, type MockPort, type PackedPackage, type PageResult, type PinnedClock, type PositionedCases, type PositionedRuleTester, type PrepareStep, type RelativePath, type RenderResult, type RenderSubject, type RenderedText, type ResponseAccessor, type ScreenNode, type ScreenResult, type ServerPort, type ServerRequestOptions, type ServerResponse, type ServerSpec, type SpecDocument, type SpecEnvToken, type SpecFileAssertion, type SpecFixture, type SpecRun, type SpecServeEntry, type SpecStream, type TableAccessor, type Target, type TargetOptions, type TextAccessor, type TlsFacts, type VisitScenario, type WaitUntilOptions, type WebsiteBackendOptions, type WebsiteHandle, type WebsiteSpecification, type WebsiteSpecificationOptions, type WebsiteVisitor, directory, file, match };
+export { type ApiDeployedHandle, type ApiDeployedOptions, type ApiDeployedSpecification, type ApiHandle, type ApiServedOptions, type ApiSpecification, type ApiSpecificationOptions, type BaseResult, type BrowserConsoleMessage, type BrowserLinkElement, type BrowserMetaElement, type BrowserOpenOptions, type BrowserPage, type BrowserPort, type CallResult, type CaptureScope, type CliEnv, type CliHandle, type CliInput, type CliOutput, type CliPort, type CliResult, type CliSpecification, type CliSpecificationOptions, type ComponentChain, type ComponentScenario, type ComponentUi, type ComponentVisitor, type ContainerAccessor, type DeviceOpenOptions, type DevicePort, type DeviceScreen, type DeviceTimeouts, type DirectoryAccessor, type DiskDirectory, type DiskFile, type DiskTarget, type DockerSpecConfig, type DomMount, type ElementKind, type ElementMatch, type ExchangeResult, type ExecOptions, type FetchResult, type FileAccessor, type FileAt, type FilesystemAccessor, type HonoApp, type HttpResult, type IntegrationHandle, type IntegrationSpecification, type IntegrationSpecificationOptions, type Job, type JobHandle, type JobResult, type JobSpecification, type JobSpecificationOptions, type JsonAccessor, type LandmarkKind, type LintConfig, type LintHandle, type LintResult, type LintRules, type LintRunOptions, type LintSpecification, type LintSpecificationOptions, type LiterateRunFlags, type LiterateServeRegistration, type MatchFixtureOptions, Matcher, type MatcherKind, type MobileBackendOptions, type MobileElementKind, type MobileElementMatch, type MobileHandle, type MobileScenario, type MobileSpecification, type MobileSpecificationOptions, type MobileVisitor, type MockOfOptions, type MockPort, type PackedPackage, type PageResult, type PinnedClock, type PositionedCases, type PositionedRuleTester, type PrepareStep, type RelativePath, type RenderResult, type RenderSubject, type RenderedText, type ResponseAccessor, type ScreenNode, type ScreenResult, type ServerPort, type ServerRequestOptions, type ServerResponse, type ServerSpec, type SpecDocument, type SpecEnvToken, type SpecFileAssertion, type SpecFixture, type SpecRun, type SpecServeEntry, type SpecStream, type TableAccessor, type Target, type TargetOptions, type TextAccessor, type TlsFacts, type VisitScenario, type WaitUntilOptions, type WebsiteBackendOptions, type WebsiteHandle, type WebsiteSpecification, type WebsiteSpecificationOptions, type WebsiteVisitor, directory, file, match };
 //# sourceMappingURL=index.d.ts.map