@jterrazz/test 7.1.0 → 9.0.0

package/dist/index.d.cts

@@ -1,734 +0,0 @@
-import { a as PostgresOptions, c as IsolationStrategy, i as redis, l as DatabasePort, n as sqlite, o as postgres, r as RedisOptions, s as ServiceHandle, t as SqliteOptions } from "./sqlite.adapter.cjs";
-import { n as InterceptResponse, r as InterceptTrigger } from "./types.cjs";
-import { i as mockOfDate, n as mockOf, r as MockDatePort, t as MockPort } from "./mock-of.cjs";
-
-//#region src/builder/cli/command.port.d.ts
-/**
- * Result of executing a CLI command, including exit code and captured output streams.
- */
-interface CommandResult {
-  /** Process exit code (0 = success). */
-  exitCode: number;
-  /** Captured standard output. */
-  stdout: string;
-  /** Captured standard error. */
-  stderr: string;
-}
-/**
- * Options for spawning a long-running process.
- */
-interface SpawnOptions {
-  /** Resolve when stdout/stderr contains this string. */
-  waitFor: string;
-  /** Kill the process after this many milliseconds. */
-  timeout: number;
-}
-/**
- * Extra environment variables to set for the child process.
- * Values are merged on top of process.env. A `null` value unsets the variable.
- */
-type CommandEnv = Record<string, null | string>;
-/**
- * Abstract CLI interface for specification runners.
- * Implement this to plug in your command execution strategy.
- */
-interface CommandPort {
-  /** Execute a CLI command with the given arguments in the given working directory. */
-  exec(args: string, cwd: string, env?: CommandEnv): Promise<CommandResult>;
-  /** Spawn a long-running process and wait for a pattern or timeout. */
-  spawn(args: string, cwd: string, options: SpawnOptions, env?: CommandEnv): Promise<CommandResult>;
-}
-//#endregion
-//#region src/builder/http/server.port.d.ts
-/**
- * HTTP response returned by a server port, with parsed JSON body.
- */
-interface ServerResponse {
-  /** HTTP status code. */
-  status: number;
-  /** Parsed JSON response body, or null if parsing failed. */
-  body: unknown;
-  /** Response headers as a flat key-value map. */
-  headers: Record<string, string>;
-}
-/**
- * Abstract server interface for specification runners.
- * Integration mode uses an in-process Hono app; E2E mode uses real HTTP via fetch.
- */
-interface ServerPort {
-  /** Send an HTTP request and return the parsed response. */
-  request(method: string, path: string, body?: unknown, headers?: Record<string, string>): Promise<ServerResponse>;
-}
-//#endregion
-//#region src/builder/common/directory-accessor.d.ts
-interface DirectorySnapshotOptions {
-  /** Extra path segments to ignore (in addition to default: .git, node_modules, etc.). */
-  ignore?: string[];
-  /**
-   * Force update mode regardless of vitest flags / env vars.
-   * `true` writes the fixture, `false` always asserts. Defaults to auto-detect.
-   */
-  update?: boolean;
-}
-/**
- * Handle to a directory produced by a specification run.
- * Supports snapshot-based assertions via {@link toMatchFixture} and file listing via {@link files}.
- */
-declare class DirectoryAccessor {
-  private absPath;
-  private testDir;
-  constructor(absPath: string, testDir: string);
-  /**
-   * Compare the directory tree against `expected/{name}/` (relative to the test file).
-   * On mismatch, throws with a structured diff. With update mode enabled, the
-   * fixture is overwritten with the current contents instead.
-   */
-  toMatchFixture(name: string, options?: DirectorySnapshotOptions): Promise<void>;
-  /**
-   * List all files in the directory (recursive, sorted, ignoring defaults).
-   * Useful for ad-hoc assertions when you don't want a full snapshot.
-   */
-  files(options?: {
-    ignore?: string[];
-  }): Promise<string[]>;
-}
-//#endregion
-//#region src/builder/common/response-accessor.d.ts
-/** Accessor for an HTTP response body with file-based assertion support. */
-declare class ResponseAccessor {
-  readonly body: unknown;
-  private testDir;
-  constructor(body: unknown, testDir: string);
-  /**
-   * Assert that the response body matches the JSON in `responses/{file}`.
-   *
-   * @example
-   *   result.response.toMatchFile("expected-items.json");
-   */
-  toMatchFile(file: string): void;
-}
-//#endregion
-//#region src/builder/common/table-assertion.d.ts
-/** Assertion helper for verifying database table contents after a specification run. */
-declare class TableAssertion {
-  private tableName;
-  private db;
-  constructor(tableName: string, db: DatabasePort);
-  /**
-   * Assert that the table contains exactly the expected rows for the given columns.
-   *
-   * @example
-   *   await result.table("users").toMatch({
-   *     columns: ["name", "email"],
-   *     rows: [["Alice", "alice@example.com"]],
-   *   });
-   */
-  toMatch(expected: {
-    columns: string[];
-    rows: unknown[][];
-  }): Promise<void>;
-  /** Assert that the table has zero rows. */
-  toBeEmpty(): Promise<void>;
-}
-//#endregion
-//#region src/builder/common/result.d.ts
-/** Read-only handle to a single file produced by a CLI action. */
-interface FileAccessor {
-  /** The UTF-8 text content. Throws if the file does not exist. */
-  readonly content: string;
-  readonly exists: boolean;
-}
-/**
- * The outcome of a single specification run.
- * Provides accessors for CLI output, HTTP responses, files, directories, and database tables.
- */
-declare class SpecificationResult {
-  private commandResult?;
-  private config;
-  private requestInfo?;
-  private responseData?;
-  private testDir;
-  private workDir?;
-  constructor(options: {
-    commandResult?: CommandResult;
-    config: SpecificationConfig;
-    requestInfo?: {
-      body?: unknown;
-      method: string;
-      path: string;
-    };
-    response?: ServerResponse;
-    testDir: string;
-    workDir?: string;
-  });
-  /** The process exit code. Only available after a CLI action. */
-  get exitCode(): number;
-  /** The HTTP response status code. Only available after an HTTP action. */
-  get status(): number;
-  /** The captured standard output. Only available after a CLI action. */
-  get stdout(): string;
-  /** The captured standard error. Only available after a CLI action. */
-  get stderr(): string;
-  /**
-   * Extract text blocks from stdout that contain a pattern.
-   * Useful for parsing structured CLI output (linters, compilers).
-   *
-   * @example
-   *   expect(result.grep('error.ts')).toContain('no-unused-vars');
-   */
-  grep(pattern: string): string;
-  /** Access the HTTP response body for assertions. Only available after an HTTP action. */
-  get response(): ResponseAccessor;
-  /** Access a directory (relative to the working directory) for snapshot assertions. */
-  directory(path?: string): DirectoryAccessor;
-  /** Access a single file (relative to the working directory) for content assertions. */
-  file(path: string): FileAccessor;
-  /** Access a database table for row-level assertions. */
-  table(tableName: string, options?: {
-    service?: string;
-  }): TableAssertion;
-  private resolveDatabase;
-}
-//#endregion
-//#region src/builder/specification-builder.d.ts
-/** A named job that can be triggered via .job(). */
-interface JobHandle$1 {
-  name: string;
-  execute: () => Promise<void>;
-}
-/** Adapter configuration passed to the specification runner at setup time. */
-interface SpecificationConfig {
-  command?: CommandPort;
-  database?: DatabasePort;
-  databases?: Map<string, DatabasePort>;
-  fixturesRoot?: string;
-  jobs?: JobHandle$1[];
-  server?: ServerPort;
-}
-/**
- * Fluent builder for declaring a single test specification.
- *
- * Chain setup methods ({@link seed}, {@link fixture}, {@link env}), an action
- * ({@link get}, {@link post}, {@link exec}), then call {@link run} to execute
- * and receive a {@link SpecificationResult} for assertions.
- */
-declare class SpecificationBuilder {
-  private commandArgs;
-  private commandEnv;
-  private config;
-  private fixtures;
-  private intercepts;
-  private jobName;
-  private label;
-  private mocks;
-  private projectName;
-  private request;
-  private requestHeaders;
-  private seeds;
-  private spawnConfig;
-  private testDir;
-  constructor(config: SpecificationConfig, testDir: string, label: string);
-  /**
-   * Queue a SQL seed file to run before the action.
-   *
-   * @example
-   *   spec("creates user").seed("users.sql").exec("list-users").run();
-   */
-  seed(file: string, options?: {
-    service?: string;
-  }): this;
-  /** Copy a file or directory from `fixtures/` into the working directory before execution. */
-  fixture(file: string): this;
-  /** Copy an entire project fixture from `fixturesRoot` into the working directory. */
-  project(name: string): this;
-  /** Register an MSW mock definition file from `mock/` to intercept HTTP calls. */
-  mock(file: string): this;
-  /**
-   * Set environment variables for the CLI process. Merged on top of process.env.
-   * Use `null` to unset a variable. Multiple calls merge.
-   *
-   * The token `$WORKDIR` (in any value) is replaced with the actual working
-   * directory at run-time — useful for tests that need a fully isolated `HOME`.
-   *
-   * @example
-   *   spec("...").env({ HOME: "$WORKDIR", TZ: "UTC" }).exec("status").run();
-   */
-  env(env: CommandEnv): this;
-  /**
-   * Set HTTP headers for the request. Multiple calls merge.
-   *
-   * @example
-   *   spec("french").headers({ 'Accept-Language': 'fr' }).get("/articles").run();
-   */
-  headers(headers: Record<string, string>): this;
-  /**
-   * Intercept an outgoing HTTP request and return a controlled response.
-   * Uses MSW under the hood. Intercepts are queued — multiple calls with the
-   * same trigger fire sequentially (first match consumed first).
-   *
-   * @param trigger - What to match (use openai.agent(), http.get(), etc.)
-   * @param response - What to return: an InterceptResponse object, or a filename
-   *   from `intercepts/` (JSON loaded and auto-wrapped by the trigger).
-   *
-   * @example
-   *   // With inline response
-   *   .intercept(openai.agent({...}), openai.reply({ categories: ['TECH'] }))
-   *
-   *   // With JSON fixture file (loaded from intercepts/ directory)
-   *   .intercept(openai.agent({...}), 'ingest-tech.json')
-   *   .intercept(http.get(url), 'world-news-tech.json')
-   */
-  intercept(trigger: InterceptTrigger, response: InterceptResponse | string): this;
-  /**
-   * Send a GET request to the server adapter.
-   *
-   * @example
-   *   spec("list items").get("/api/items").run();
-   */
-  get(path: string): this;
-  /**
-   * Send a POST request to the server adapter.
-   *
-   * @param bodyFile - Optional JSON file from `requests/` to use as the request body.
-   * @example
-   *   spec("create item").post("/api/items", "new-item.json").run();
-   */
-  post(path: string, bodyFile?: string): this;
-  /** Send a PUT request to the server adapter. */
-  put(path: string, bodyFile?: string): this;
-  /** Send a DELETE request to the server adapter. */
-  delete(path: string): this;
-  /**
-   * Execute a CLI command (or a sequence of commands) in an isolated working directory.
-   * When an array is passed, commands run sequentially and stop on the first non-zero exit code.
-   *
-   * @example
-   *   spec("init project").exec("init --name demo").run();
-   *   spec("multi-step").exec(["init", "build"]).run();
-   */
-  exec(args: string | string[]): this;
-  /** Spawn a long-running CLI process with custom spawn options (e.g. timeout, signal). */
-  spawn(args: string, options: SpawnOptions): this;
-  /**
-   * Execute a named job registered via the app() factory.
-   *
-   * @param name - The job name to trigger (must match a registered JobHandle.name).
-   *
-   * @example
-   *   spec('pipeline').intercept(openai.chat(), openai.response({...})).job('report-refresh').run();
-   */
-  job(name: string): this;
-  /**
-   * Execute the specification: run seeds, copy fixtures, then perform the
-   * configured action (HTTP or CLI).
-   *
-   * @returns The result object used for assertions.
-   * @example
-   *   const result = await spec("test").exec("status").run();
-   *   expect(result.exitCode).toBe(0);
-   */
-  run(): Promise<SpecificationResult>;
-  private resolveEnv;
-  private prepareWorkDir;
-  private runHttpAction;
-  private runJobAction;
-  private runCliAction;
-}
-/** Factory function returned by `cli()`, `integration()`, or `e2e()` that starts a new spec. */
-type SpecificationRunner = (label: string) => SpecificationBuilder;
-/**
- * Create a {@link SpecificationRunner} bound to the given adapter configuration.
- * The test file directory is auto-detected from the call stack.
- */
-declare function createSpecificationRunner(config: SpecificationConfig): SpecificationRunner;
-//#endregion
-//#region src/docker/docker-port.d.ts
-/** Abstract interface for interacting with a Docker container (exec, inspect, file I/O). */
-interface DockerContainerPort {
-  /** Execute a command inside the container, return stdout */
-  exec(cmd: string[]): Promise<string>;
-  /** Read a file from inside the container */
-  file(path: string): Promise<{
-    exists: boolean;
-    content: string;
-  }>;
-  /** Check if container is running */
-  isRunning(): Promise<boolean>;
-  /** Get container logs */
-  logs(tail?: number): Promise<string>;
-  /** Get full docker inspect JSON */
-  inspect(): Promise<DockerInspectResult>;
-  /** Check if a file/directory exists */
-  exists(path: string): Promise<boolean>;
-}
-/** Normalized subset of `docker inspect` output for assertion use. */
-interface DockerInspectResult {
-  id: string;
-  name: string;
-  state: {
-    running: boolean;
-    exitCode: number;
-    status: string;
-  };
-  config: {
-    image: string;
-    env: string[];
-  };
-  hostConfig: {
-    memory: number;
-    cpuQuota: number;
-    networkMode: string;
-    mounts: Array<{
-      source: string;
-      destination: string;
-      type: string;
-    }>;
-  };
-  networkSettings: {
-    networks: Record<string, {
-      gateway: string;
-      ipAddress: string;
-    }>;
-  };
-}
-//#endregion
-//#region src/docker/docker-assertion.d.ts
-/**
- * Fluent assertion builder for Docker containers.
- * Chain async assertions like `toBeRunning()`, `toHaveFile()`, `toHaveMount()`.
- */
-declare class DockerAssertion {
-  private container;
-  constructor(container: DockerContainerPort);
-  /** Assert the container is running */
-  toBeRunning(): Promise<this>;
-  /** Assert the container is NOT running / doesn't exist */
-  toNotExist(): Promise<this>;
-  /** Assert a file exists inside the container */
-  toHaveFile(path: string, opts?: {
-    containing?: string;
-  }): Promise<this>;
-  /** Assert a file does NOT exist */
-  toNotHaveFile(path: string): Promise<this>;
-  /** Assert a directory exists */
-  toHaveDirectory(path: string): Promise<this>;
-  /** Assert a mount exists */
-  toHaveMount(destination: string): Promise<this>;
-  /** Assert network mode */
-  toHaveNetwork(mode: string): Promise<this>;
-  /** Assert memory limit */
-  toHaveMemoryLimit(bytes: number): Promise<this>;
-  /** Assert CPU quota */
-  toHaveCpuQuota(quota: number): Promise<this>;
-  /** Execute a command and return output for custom assertions */
-  exec(cmd: string[]): Promise<string>;
-  /** Read a file for custom assertions */
-  readFile(path: string): Promise<string>;
-  /** Get logs for custom assertions */
-  getLogs(tail?: number): Promise<string>;
-}
-//#endregion
-//#region src/infra/orchestrator.d.ts
-interface OrchestratorOptions {
-  services: ServiceHandle[];
-  mode: 'e2e' | 'integration';
-  root?: string;
-  /** Compose project name — used for per-worker stack isolation. */
-  projectName?: string;
-}
-/**
- * Orchestrator for test infrastructure.
- * Integration: starts services via testcontainers.
- * E2E: runs full docker compose up.
- */
-declare class Orchestrator {
-  private services;
-  private mode;
-  private root;
-  private projectName;
-  private running;
-  private composeStack;
-  private composeHandles;
-  private started;
-  constructor(options: OrchestratorOptions);
-  /**
-   * Start declared services via testcontainers (integration mode).
-   * Phase 1: start all containers in parallel (the slow part).
-   * Phase 2: wire connections, healthcheck, and init sequentially (fast).
-   */
-  start(): Promise<void>;
-  /**
-   * Stop testcontainers (integration mode).
-   */
-  stop(): Promise<void>;
-  /**
-   * Start full docker compose stack (e2e mode).
-   * Auto-detects infra services and creates handles for them.
-   */
-  startCompose(): Promise<void>;
-  /**
-   * Stop docker compose stack (e2e mode).
-   */
-  stopCompose(): Promise<void>;
-  /**
-   * Get a database service by compose name, or the first one if no name given.
-   */
-  getDatabase(serviceName?: string): DatabasePort | null;
-  /**
-   * Get all database services keyed by compose name.
-   */
-  getDatabases(): Map<string, DatabasePort>;
-  /**
-   * Get app URL from compose (e2e mode).
-   */
-  getAppUrl(): null | string;
-}
-//#endregion
-//#region src/spec/targets.d.ts
-/** Any object with a request method compatible with Hono's app.request(). */
-type HonoApp$1 = {
-  request: (path: string, init?: RequestInit) => Promise<Response> | Response;
-};
-/** A named job that can be triggered via .job(). */
-interface JobHandle {
-  name: string;
-  execute: () => Promise<void>;
-}
-/** Services map passed to the app factory after infrastructure starts. */
-type AppServices = Record<string, ServiceHandle>;
-/**
- * Return value from the app() factory. Either a bare server (backward compat)
- * or an object with server + jobs for job-based testing.
- */
-type AppFactoryResult = HonoApp$1 | {
-  server: HonoApp$1;
-  jobs: JobHandle[];
-};
-/** In-process Hono app target. Created by {@link app}. */
-interface AppTarget {
-  readonly kind: 'app';
-  readonly factory: (services: AppServices) => AppFactoryResult;
-}
-/** Docker compose stack target. Created by {@link stack}. */
-interface StackTarget {
-  readonly kind: 'stack';
-  readonly root: string;
-}
-/** CLI command target. Created by {@link command}. */
-interface CommandTarget {
-  readonly kind: 'command';
-  readonly bin: string;
-}
-/** Any target that produces an HTTP interface (app or stack). */
-type HttpTarget = AppTarget | StackTarget;
-/** Any valid spec target. */
-type SpecTarget = AppTarget | CommandTarget | StackTarget;
-/**
- * Test against an in-process Hono app. The factory receives started services
- * so you can wire connection strings into your app/DI container.
- *
- * @param factory - Function that receives services and returns a Hono app instance.
- *
- * @example
- *   const db = postgres({ compose: 'db' });
- *   await spec(
- *       app((services) => createApp({ databaseUrl: services.db.connectionString })),
- *       { services: [db] },
- *   );
- */
-declare function app(factory: (services: AppServices) => HonoApp$1): AppTarget;
-/**
- * Test against a full docker compose stack. The stack is started with
- * `docker compose up` and real HTTP requests are sent to the app service.
- *
- * @param root - Project root containing `docker/compose.test.yaml`.
- *
- * @example
- *   await spec(stack('../../'));
- */
-declare function stack(root: string): StackTarget;
-/**
- * Test a CLI binary. Each spec runs in a fresh temp directory.
- *
- * @param bin - Path to the CLI binary or command name (resolved from node_modules/.bin or PATH).
- *
- * @example
- *   await spec(command('my-cli'), { root: '../fixtures' });
- */
-declare function command(bin: string): CommandTarget;
-//#endregion
-//#region src/spec/spec.d.ts
-/** Shared options for all spec targets. */
-interface SpecOptions {
-  /** Project root for fixture lookup and compose detection (relative paths supported). */
-  root?: string;
-  /** Infrastructure services to start via testcontainers. */
-  services?: ServiceHandle[];
-}
-/** A specification runner with teardown support and orchestrator access. */
-interface SpecRunner {
-  /** The function to create individual specs: `runner('label').get('/path').run()`. */
-  (label: string): SpecificationBuilder;
-  /** Stop all infrastructure started by this runner. */
-  cleanup: () => Promise<void>;
-  /**
-   * Get a Docker assertion builder for a running container.
-   *
-   * @example
-   *   await runner.docker('my-container').toBeRunning();
-   */
-  docker: (containerId: string) => DockerAssertion;
-  /** The orchestrator managing the test infrastructure lifecycle. */
-  orchestrator: Orchestrator;
-}
-/**
- * Create a specification runner for the given target.
- *
- * @param target - What to test against: {@link app}, {@link stack}, or {@link command}.
- * @param options - Shared options: root directory, infrastructure services.
- *
- * @example
- *   // HTTP — in-process app with testcontainers
- *   const s = await spec(app(() => createApp(db)), { services: [db] });
- *
- *   // HTTP — full docker compose stack
- *   const s = await spec(stack('../../'));
- *
- *   // CLI — command binary
- *   const s = await spec(command('my-cli'), { root: '../fixtures' });
- */
-declare function spec(target: SpecTarget, options?: SpecOptions): Promise<SpecRunner>;
-//#endregion
-//#region src/infra/ports/container.port.d.ts
-/**
- * Abstract container interface.
- * Represents a running service (database, cache, etc.)
- */
-interface ContainerPort {
-  /** Start the container and wait until ready. */
-  start(): Promise<void>;
-  /** Stop and remove the container. */
-  stop(): Promise<void>;
-  /** Get the mapped host port for a container port. */
-  getMappedPort(containerPort: number): number;
-  /** Get the host to connect to. */
-  getHost(): string;
-  /** Get a full connection string for this service. */
-  getConnectionString(): string;
-  /** Get container logs (stdout + stderr). */
-  getLogs(): Promise<string>;
-}
-//#endregion
-//#region src/builder/cli/adapters/exec.adapter.d.ts
-/**
- * Executes CLI commands via Node.js child_process.
- * Uses `execSync` for one-shot commands and `spawn` for long-running processes.
- * Used by the `cli()` specification runner.
- */
-declare class ExecAdapter implements CommandPort {
-  private command;
-  constructor(command: string);
-  exec(args: string, cwd: string, extraEnv?: CommandEnv): Promise<CommandResult>;
-  spawn(args: string, cwd: string, options: SpawnOptions, extraEnv?: CommandEnv): Promise<CommandResult>;
-}
-//#endregion
-//#region src/builder/http/adapters/fetch.adapter.d.ts
-/**
- * Server adapter that sends real HTTP requests via the Fetch API.
- * Used by the `e2e()` specification runner to hit a live server.
- */
-declare class FetchAdapter implements ServerPort {
-  private baseUrl;
-  constructor(url: string);
-  request(method: string, path: string, body?: unknown, headers?: Record<string, string>): Promise<ServerResponse>;
-}
-//#endregion
-//#region src/builder/http/adapters/hono.adapter.d.ts
-/**
- * Server adapter that dispatches requests in-process through a Hono app instance.
- * Used by the `integration()` specification runner -- no network overhead.
- */
-declare class HonoAdapter implements ServerPort {
-  private app;
-  constructor(app: {
-    request: (path: string, init?: RequestInit) => Promise<Response> | Response;
-  });
-  request(method: string, path: string, body?: unknown, headers?: Record<string, string>): Promise<ServerResponse>;
-}
-//#endregion
-//#region src/spec/legacy-integration.d.ts
-type HonoApp = {
-  fetch: (...args: any[]) => any;
-  request: (path: string, init?: RequestInit) => Promise<Response> | Response;
-};
-interface IntegrationOptions {
-  /** Factory that returns a Hono app — called after services start. */
-  app: () => HonoApp;
-  /** Project root for compose detection (relative paths supported). */
-  root?: string;
-  /** Declared services — started via testcontainers. */
-  services: ServiceHandle[];
-}
-/** A specification runner that also exposes teardown and the underlying orchestrator. */
-interface SpecificationRunnerWithCleanup extends SpecificationRunner {
-  /** Stop all infrastructure containers started by this runner. */
-  cleanup: () => Promise<void>;
-  /** The orchestrator managing the test infrastructure lifecycle. */
-  orchestrator: Orchestrator;
-}
-/**
- * Create an integration specification runner.
- * Starts infra containers via testcontainers, app runs in-process.
- */
-declare function integration(options: IntegrationOptions): Promise<SpecificationRunnerWithCleanup>;
-//#endregion
-//#region src/spec/legacy-cli.d.ts
-interface CliOptions {
-  /** CLI command to run (resolved from node_modules/.bin or PATH). */
-  command: string;
-  /** Project root — base dir for .project() fixture lookup (relative paths supported). */
-  root?: string;
-  /** Optional infrastructure services (started via testcontainers). */
-  services?: ServiceHandle[];
-}
-/**
- * Create a CLI specification runner.
- * Runs CLI commands against fixture projects. Optionally starts infrastructure.
- */
-declare function cli(options: CliOptions): Promise<SpecificationRunnerWithCleanup>;
-//#endregion
-//#region src/spec/legacy-e2e.d.ts
-interface E2eOptions {
-  /** Project root — must contain docker/compose.test.yaml. */
-  root?: string;
-}
-/**
- * Create an E2E specification runner.
- * Starts full docker compose stack. App URL and database auto-detected.
- */
-declare function e2e(options?: E2eOptions): Promise<SpecificationRunnerWithCleanup>;
-//#endregion
-//#region src/builder/common/grep.d.ts
-/**
- * Extract text blocks from output that contain a pattern.
- * Splits by blank lines (how linter/compiler output is structured),
- * returns only blocks matching the pattern.
- *
- * @example
- * expect(grep(result.stdout, "unused-var.ts")).toContain("no-unused-vars")
- * expect(grep(result.stdout, "valid/sorted.ts")).not.toContain("sort-imports")
- */
-declare function grep(output: string, pattern: string): string;
-//#endregion
-//#region src/builder/common/reporter.d.ts
-/** Strip ANSI escape codes from a string. */
-declare function stripAnsi(str: string): string;
-/** Strip ANSI codes and replace volatile tokens (ports, durations) with placeholders. */
-declare function normalizeOutput(str: string): string;
-//#endregion
-//#region src/docker/docker-adapter.d.ts
-/** Create a {@link DockerContainerPort} bound to an existing container by ID. */
-declare function dockerContainer(containerId: string): DockerContainerPort;
-//#endregion
-export { type AppFactoryResult, type AppServices, type AppTarget, type CliOptions, type CommandEnv, type CommandPort, type CommandResult, type CommandTarget, type ContainerPort, type DatabasePort, DirectoryAccessor, type DirectorySnapshotOptions, DockerAssertion, type DockerContainerPort, type DockerInspectResult, type E2eOptions, ExecAdapter, FetchAdapter, type FileAccessor, HonoAdapter, type HttpTarget, type IntegrationOptions, type IsolationStrategy, type JobHandle, type MockDatePort, type MockPort, Orchestrator, type PostgresOptions, type RedisOptions, ResponseAccessor, type ServerPort, type ServerResponse, type ServiceHandle, type SpawnOptions, type SpecOptions, type SpecRunner, type SpecTarget, SpecificationBuilder, type SpecificationConfig, SpecificationResult, type SpecificationRunner, type SpecificationRunnerWithCleanup, type SqliteOptions, type StackTarget, TableAssertion, app, cli, command, createSpecificationRunner, dockerContainer, e2e, grep, integration, mockOf, mockOfDate, normalizeOutput, postgres, redis, spec, sqlite, stack, stripAnsi };
-//# sourceMappingURL=index.d.cts.map