@jterrazz/test 18.1.0 → 18.3.0

package/README.md

@@ -52,7 +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()`       |
-| [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/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";
@@ -1767,16 +1767,16 @@ function firstLine(text) {
 }
 const GRAMMAR = {
 	request: {
-		line: /^(?<method>GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS) \/\S*/u,
+		line: /^(?<method>GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS) (?:\/|https?:\/\/)/u,
 		teaching: (name) => ({
-			fix: `start ${name} with its request line, \`GET /path\` or another method`,
+			fix: `start ${name} with its request line, \`GET /path\`, \`GET https://host/path\` or another method`,
 			found: `the first line of ${name} is no request line`
 		})
 	},
 	response: {
-		line: /^HTTP\/\d(?:\.\d)? \d{3}\b/u,
+		line: /^(?:HTTP\/\d(?:\.\d)? \d{3}\b|unreachable: \S)/u,
 		teaching: (name) => ({
-			fix: `start ${name} with its status line, \`HTTP/1.1 200 OK\` or the status it expects`,
+			fix: `start ${name} with its status line, \`HTTP/1.1 200 OK\` or the status it expects, or \`unreachable: <reason>\``,
 			found: `the first line of ${name} is no status line`
 		})
 	}

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";

package/dist/index.d.ts

@@ -279,6 +279,15 @@ type ServerResponse = {
   body: unknown;
   /** Response headers as a flat key-value map. */
   headers: Record<string, string>;
+  /** Why no response came back (`refused`, `timeout`, `dns`, `tls CERT_HAS_EXPIRED` ...): set only when the exchange never answered, and then the status is 0, the headers empty and the body null. */
+  unreachable?: string | undefined;
+};
+/** What update mode writes into a golden that states nothing yet: which headers it records, and whether a golden stating no body keeps stating none. */
+type ResponseRecording = {
+  /** A golden that states no body keeps stating none: the body is claimed by writing it. */
+  readonly bodyKeptAbsent: boolean;
+  /** The header names a fresh golden records, those the response carries. */
+  readonly headers: readonly string[];
 };
 /** Read-only accessor for an HTTP response, compared by `expect(...).toMatch(...)`. */
 declare class ResponseAccessor {
@@ -288,12 +297,173 @@ declare class ResponseAccessor {
   readonly captures: CaptureScope;
   /** Response headers as a flat, lower-cased key-value map. */
   readonly headers: Record<string, string>;
+  /** @internal */
+  readonly recording: ResponseRecording;
   readonly status: number;
   /** @internal */
   readonly testDir: string;
-  constructor(response: ServerResponse, testDir: string, captures?: CaptureScope);
+  /** Why the exchange never answered, a golden's `unreachable: <reason>` line; undefined when it answered. */
+  readonly unreachable: string | undefined;
+  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 = {
@@ -334,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] ? {
@@ -402,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. */
@@ -440,30 +576,6 @@ 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$7: {
   readonly actions: readonly [Action<"request", [source: string | DiskFile<".http">], HttpResult, RequestSignature, {
@@ -514,8 +626,8 @@ interface ApiSpecification<DatabaseKey extends string = string> extends ChainOf<
 }, 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. */
@@ -523,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. */
@@ -531,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 = {
@@ -1912,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 DeviceOpenOptions, type DevicePort, type DeviceScreen, type DeviceTimeouts, type DirectoryAccessor, type DiskDirectory, type DiskFile, type DiskTarget, type DockerSpecConfig, type DomMount, type ElementKind, type ElementMatch, 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 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