@gfdelarue/testkit 0.4.4 → 0.5.0

package/dist/database/admin.d.ts

@@ -1,31 +0,0 @@
-import { buildDatabaseUrl, type DatabaseConnection } from "./naming.js";
-export { buildDatabaseUrl };
-export declare const ADMIN_QUERY_COMMAND_TIMEOUT_MS = 15000;
-export interface ContainerAdminDatabaseInfrastructure {
-    adminDatabase?: string | null;
-    containerId: string;
-    containerName: string;
-    containerPort?: number | null;
-    password: string;
-    user: string;
-}
-export interface NetworkAdminDatabaseInfrastructure extends DatabaseConnection {
-    adminDatabase?: string | null;
-    containerName?: null | undefined;
-}
-export type AdminDatabaseInfrastructure = ContainerAdminDatabaseInfrastructure | NetworkAdminDatabaseInfrastructure;
-export interface AdminDatabaseOperationOptions {
-    signal?: AbortSignal;
-}
-export interface DrainDatabaseConnectionsOptions extends AdminDatabaseOperationOptions {
-    timeoutMs?: number;
-}
-export declare function databaseExists(infra: Readonly<AdminDatabaseInfrastructure>, dbName: string, options?: Readonly<AdminDatabaseOperationOptions>): Promise<boolean>;
-export declare function createEmptyDatabase(infra: Readonly<AdminDatabaseInfrastructure>, dbName: string, options?: Readonly<AdminDatabaseOperationOptions>): Promise<void>;
-export declare function cloneDatabaseFromTemplate(infra: Readonly<AdminDatabaseInfrastructure>, dbName: string, templateDbName: string, options?: Readonly<AdminDatabaseOperationOptions>): Promise<void>;
-export declare function dropDatabaseIfExists(infra: Readonly<AdminDatabaseInfrastructure>, dbName: string, options?: Readonly<AdminDatabaseOperationOptions>): Promise<void>;
-export declare function dropDatabaseWithForceOrDrain(infra: Readonly<AdminDatabaseInfrastructure>, dbName: string, options?: Readonly<AdminDatabaseOperationOptions>): Promise<void>;
-export declare function waitForDatabaseConnectionsToDrain(infra: Readonly<AdminDatabaseInfrastructure>, dbName: string, options?: Readonly<DrainDatabaseConnectionsOptions>): Promise<void>;
-export declare function runAdminQuery(infra: Readonly<AdminDatabaseInfrastructure>, args: readonly string[], options?: Readonly<AdminDatabaseOperationOptions>): Promise<string>;
-export declare function buildAdminQueryCommandArgs(infra: Readonly<AdminDatabaseInfrastructure>, args: readonly string[]): string[];
-export declare function isTransientAdminQueryConnectionError(error: unknown): boolean;

package/dist/database/cleanup.d.ts

@@ -1,36 +0,0 @@
-import { type TerminalRunDatabaseCleanupAuthority } from "../process/runs/ownership.js";
-import { type ManagedDockerContainer, type ManagedDockerVolume } from "./docker.js";
-import { type ProductLifecycleFence } from "../process/lifecycle-fence.js";
-export interface LocalPostgresCleanupOptions {
-    dryRun?: unknown;
-    productDir?: string | null;
-    stopIdle?: unknown;
-}
-interface ContainerCleanupEntry extends ManagedDockerContainer {
-    action?: "remove" | "skip" | "stop";
-    intendedAction?: "remove" | "stop";
-    reason: string;
-    resourceType?: undefined;
-    selectionReason?: string;
-}
-interface VolumeCleanupEntry extends ManagedDockerVolume {
-    action?: "remove" | "skip";
-    intendedAction?: "remove";
-    reason: string;
-    resourceType: "volume";
-    selectionReason?: string;
-}
-export type DatabaseResourceCleanupEntry = ContainerCleanupEntry | VolumeCleanupEntry;
-export interface LocalPostgresCleanupResult {
-    kept: DatabaseResourceCleanupEntry[];
-    removed: DatabaseResourceCleanupEntry[];
-    skipped: DatabaseResourceCleanupEntry[];
-    stopped: ContainerCleanupEntry[];
-    targets: DatabaseResourceCleanupEntry[];
-}
-export declare function cleanupLocalPostgresDockerResources(options?: Readonly<LocalPostgresCleanupOptions>): Promise<LocalPostgresCleanupResult>;
-export declare function destroyLocalPostgresDockerResources(fence: Readonly<ProductLifecycleFence>, options?: Readonly<Omit<LocalPostgresCleanupOptions, "productDir">>): Promise<LocalPostgresCleanupResult>;
-export declare function cleanupTerminalRunLocalPostgresDockerResources(fence: Readonly<ProductLifecycleFence>, terminalRunAuthority: Readonly<TerminalRunDatabaseCleanupAuthority>, options?: Readonly<Omit<LocalPostgresCleanupOptions, "productDir">>): Promise<LocalPostgresCleanupResult>;
-export declare function assertTerminalRunDatabaseCleanupAuthority(fence: Readonly<ProductLifecycleFence>, terminalRunAuthority: Readonly<TerminalRunDatabaseCleanupAuthority>): void;
-export declare function hasActiveProductRuntime(productDir: string): boolean;
-export {};

package/dist/database/configured-steps.d.ts

@@ -1,27 +0,0 @@
-import type { OwnedPostgresContainerRoute } from "../domain/postgres-route.js";
-import type { SetupOperationHandle, SetupOperationRegistry } from "../evidence/setup-progress.js";
-import { type ConfiguredStepReporter, type ConfiguredStepServiceConfig } from "../steps/run.js";
-import { type ToolchainEnvironment } from "../toolchains/index.js";
-import { type NormalizedConfiguredStep } from "../steps/configured-steps.js";
-export interface ConfiguredStepCompletion {
-    index: number;
-    label: string;
-    step: NormalizedConfiguredStep;
-    stepNumber: number;
-}
-export type ConfiguredStepCompletionHandler = (completion: Readonly<ConfiguredStepCompletion>) => unknown;
-export interface RunConfiguredStepsOptions {
-    afterStep?: ConfiguredStepCompletionHandler | null;
-    config: ConfiguredStepServiceConfig;
-    env: Readonly<ToolchainEnvironment>;
-    labelPrefix: string;
-    ownedContainer?: OwnedPostgresContainerRoute | null;
-    parentOperation?: SetupOperationHandle | string | null;
-    reporter?: ConfiguredStepReporter | null;
-    setupRegistry?: SetupOperationRegistry | null;
-    signal?: AbortSignal;
-    startIndex?: number;
-    stepTimeoutMs?: number;
-    steps?: readonly NormalizedConfiguredStep[];
-}
-export declare function runConfiguredSteps({ config, steps, env, labelPrefix, ownedContainer, reporter, setupRegistry, parentOperation, startIndex, afterStep, signal, stepTimeoutMs: configuredStepTimeoutMs, }: Readonly<RunConfiguredStepsOptions>): Promise<void>;

package/dist/database/constants.d.ts

@@ -1,11 +0,0 @@
-export declare const LOCAL_IMAGE = "pgvector/pgvector:pg16";
-export declare const LOCAL_USER = "testkit";
-export declare const LOCAL_PASSWORD = "testkit";
-export declare const LOCAL_ADMIN_DB = "postgres";
-export declare const LOCAL_MAX_CONNECTIONS = 200;
-export declare const LOCAL_READY_TIMEOUT_MS = 60000;
-export declare const LOCAL_POLL_INTERVAL_MS = 1000;
-export declare const LOCAL_ADMIN_QUERY_RETRY_MS = 15000;
-export declare const LOCAL_ADMIN_QUERY_RETRY_INTERVAL_MS = 250;
-export declare const LOCAL_DROP_DATABASE_TIMEOUT_MS = 15000;
-export declare const LOCAL_DROP_DATABASE_POLL_INTERVAL_MS = 250;

package/dist/database/docker-metadata.d.ts

@@ -1,3 +0,0 @@
-import { type ManagedProcessResult } from "../process/index.js";
-/** Only successful metadata reads bypass the original command and its diagnostics. */
-export declare function runDockerMetadataCommand(args: readonly string[], displayLabel: string, timeoutMs: number, signal: AbortSignal | undefined, fallback: (remainingMs: number) => Promise<ManagedProcessResult>): Promise<ManagedProcessResult>;

package/dist/database/docker.d.ts

@@ -1,65 +0,0 @@
-import type { ManagedProcessResult } from "../process/index.js";
-export declare const TESTKIT_MANAGED_LABEL = "com.elench.testkit.managed";
-export declare const TESTKIT_RESOURCE_KIND_LABEL = "com.elench.testkit.resource.kind";
-export declare const TESTKIT_RESOURCE_NAME_LABEL = "com.elench.testkit.resource.name";
-export declare const TESTKIT_PRODUCT_DIR_LABEL = "com.elench.testkit.product.dir";
-export declare const TESTKIT_PRODUCT_ID_LABEL = "com.elench.testkit.product.id";
-export declare const TESTKIT_SCOPE_LABEL = "com.elench.testkit.scope";
-export declare const TESTKIT_CACHE_POLICY_LABEL = "com.elench.testkit.cache.policy";
-export declare const TESTKIT_CREATED_AT_LABEL = "com.elench.testkit.created-at";
-export declare const TESTKIT_RESOURCE_GENERATION_LABEL = "com.elench.testkit.resource.generation";
-export declare const DOCKER_OWNERSHIP_OPERATION_TIMEOUTS_MS: Readonly<{
-    inspect: 30000;
-    list: 30000;
-    remove: 120000;
-    stop: 30000;
-}>;
-export type DockerLabels = Readonly<Record<string, string>>;
-export interface ProductIdentity {
-    dir: string;
-    id: string;
-}
-export interface DockerOwnershipOperationOptions {
-    signal?: AbortSignal;
-}
-export interface DockerResourceIdentity {
-    cachePolicy?: null | string;
-    createdAt?: null | string;
-    generation: string;
-    kind: string;
-    name: string;
-    scope?: null | string;
-}
-export interface ManagedDockerContainer {
-    createdAt: null | string;
-    id: string;
-    image: string;
-    labels: DockerLabels;
-    name: string;
-    running: boolean;
-    shortId: string;
-    status: string;
-}
-export interface ManagedDockerVolume {
-    createdAt: null | string;
-    driver: string;
-    labels: DockerLabels;
-    mountpoint: string;
-    name: string;
-}
-type DockerInspectRecord = Record<string, unknown>;
-export declare function buildProductIdentity(productDir: string): ProductIdentity;
-export declare function buildDockerResourceLabels(productDir: string, resource: Readonly<DockerResourceIdentity>): DockerLabels;
-export declare function dockerLabelArgs(labels: Readonly<Record<string, unknown>>): string[];
-export declare function inspectDockerContainer(containerRef: string, options?: Readonly<DockerOwnershipOperationOptions>): Promise<DockerInspectRecord | null>;
-export declare function listManagedDockerContainers(product: Readonly<ProductIdentity>): Promise<ManagedDockerContainer[]>;
-export declare function inspectDockerVolume(volumeRef: string, options?: Readonly<DockerOwnershipOperationOptions>): Promise<DockerInspectRecord | null>;
-export declare function listManagedDockerVolumes(product: Readonly<ProductIdentity>): Promise<ManagedDockerVolume[]>;
-export declare function removeDockerContainer(containerRef: string, displayName?: string): Promise<boolean>;
-export declare function removeDockerVolume(volumeRef: string, expected: Readonly<ManagedDockerVolume>, options?: Readonly<DockerOwnershipOperationOptions>): Promise<boolean>;
-export declare function sameDockerVolumeGeneration(current: Readonly<ManagedDockerVolume>, expected: Readonly<ManagedDockerVolume>): boolean;
-export declare function stopDockerContainer(containerRef: string, displayName?: string): Promise<boolean>;
-export declare function normalizeDockerContainerInspect(value: unknown): ManagedDockerContainer | null;
-export declare function normalizeDockerVolumeInspect(value: unknown): ManagedDockerVolume | null;
-export declare function runDockerCommand(args: readonly string[], displayLabel: string, timeoutMs: number, signal?: AbortSignal): Promise<ManagedProcessResult>;
-export {};

package/dist/database/drizzle/index.d.ts

@@ -1,13 +0,0 @@
-type UnknownRecord = Record<string, unknown>;
-export interface DrizzleConfigOptions {
-    consumer?: string;
-    cwd?: string;
-    env?: NodeJS.ProcessEnv;
-    files?: string[];
-    onlyWhenAllowed?: boolean;
-    override?: boolean;
-    requireLocalDatabase?: boolean;
-}
-export declare function defineConfig(): Record<string, never>;
-export declare function defineConfig<TConfig extends UnknownRecord>(config: TConfig, options?: DrizzleConfigOptions): TConfig;
-export {};

package/dist/database/fingerprint.d.ts

@@ -1,12 +0,0 @@
-import { type NormalizedDatabaseConfig } from "../config/loader/index.js";
-import { type SourceSchemaServiceConfig, type SourceSchemaState } from "./schema-source.js";
-export type TemplateFingerprintConfig = Omit<SourceSchemaServiceConfig, "testkit"> & {
-    testkit: SourceSchemaServiceConfig["testkit"] & {
-        database: NonNullable<SourceSchemaServiceConfig["testkit"]["database"]> & Pick<NormalizedDatabaseConfig, "image" | "user" | "roles">;
-        envFiles?: readonly string[];
-    };
-};
-export interface TemplateFingerprintOptions {
-    sourceSchemaState?: SourceSchemaState | null;
-}
-export declare function computeTemplateFingerprint(config: Readonly<TemplateFingerprintConfig>, options?: Readonly<TemplateFingerprintOptions>): Promise<string>;

package/dist/database/index.d.ts

@@ -1,39 +0,0 @@
-export { cleanupOrphanedLocalInfrastructure, cleanupTerminalRunLocalInfrastructure } from "./lifecycle-cleanup.js";
-import { type NormalizedDatabaseConfig } from "../config/loader/index.js";
-import { type SourceSchemaServiceConfig } from "./schema-source.js";
-import { type UserHostLocalPostgresActivityOptions } from "./activity-gate.js";
-import { type LocalPostgresCleanupOptions, type LocalPostgresCleanupResult } from "./cleanup.js";
-import type { DatabaseProgress } from "./progress.js";
-import { type ProductLifecycleFence } from "../process/lifecycle-fence.js";
-export { dropDatabaseWithForceOrDrain, isTransientAdminQueryConnectionError, waitForDatabaseConnectionsToDrain, } from "./admin.js";
-export { readDatabaseInfo, readDatabaseUrl, type DatabaseInfo } from "./state.js";
-export type { DatabaseProgress } from "./progress.js";
-export { refreshDatabaseSchema, verifyDatabaseSchema, type DatabaseSchemaOperationContext, type ResolvedSchemaOperationPlan, type SchemaOperationConfigResolver, type VerifyDatabaseSchemaOptions, } from "./schema-operations.js";
-export type DatabaseRuntimeConfig = Omit<SourceSchemaServiceConfig, "stateDir" | "testkit"> & {
-    stateDir: string;
-    testkit: SourceSchemaServiceConfig["testkit"] & {
-        database?: NormalizedDatabaseConfig | null;
-    };
-};
-export interface RuntimeDatabaseStateLocation {
-    productDir: string;
-    stateDir: string;
-}
-export type DatabaseCleanupOptions = Pick<LocalPostgresCleanupOptions, "dryRun" | "stopIdle">;
-export interface ProvisionDatabaseOptions {
-    progress?: DatabaseProgress | null;
-    signal?: AbortSignal;
-    skipSchemaSourceVerify?: boolean;
-}
-export interface ReadyDatabase {
-    container: string;
-    databaseName: string;
-    templateFingerprint: string;
-    url: string;
-}
-export declare function provisionDatabase(config: Readonly<DatabaseRuntimeConfig>, options?: Readonly<ProvisionDatabaseOptions>): Promise<ReadyDatabase | null>;
-export declare function destroyRuntimeDatabase({ productDir, stateDir }: Readonly<RuntimeDatabaseStateLocation>, activityOptions?: Readonly<UserHostLocalPostgresActivityOptions>): Promise<void>;
-export declare function destroyServiceDatabaseCache(productDir: string, serviceName: string, activityOptions?: Readonly<UserHostLocalPostgresActivityOptions>): Promise<void>;
-export declare function destroyOwnedLocalDatabaseResources(fence: Readonly<ProductLifecycleFence>, options?: Readonly<DatabaseCleanupOptions>): Promise<LocalPostgresCleanupResult>;
-export declare function cleanupOwnedLocalDatabaseResources(productDir: string, options?: Readonly<DatabaseCleanupOptions>): Promise<LocalPostgresCleanupResult>;
-export declare function isDatabaseStateDir(dir: string): boolean;

package/dist/database/lifecycle-cleanup.d.ts

@@ -1,7 +0,0 @@
-import { type UserHostLocalPostgresActivityOptions } from "./activity-gate.js";
-import { type ProductLifecycleFence } from "../process/lifecycle-fence.js";
-import type { TerminalRunDatabaseCleanupAuthority } from "../process/runs/ownership.js";
-import type { LocalPostgresCleanupResult } from "./cleanup.js";
-export declare function cleanupOrphanedLocalInfrastructure(productDir: string, activityOptions?: Readonly<UserHostLocalPostgresActivityOptions>): Promise<LocalPostgresCleanupResult>;
-export declare function cleanupOrphanedLocalInfrastructureUnlocked(productDir: string): Promise<LocalPostgresCleanupResult>;
-export declare function cleanupTerminalRunLocalInfrastructure(fence: Readonly<ProductLifecycleFence>, terminalRunAuthority: Readonly<TerminalRunDatabaseCleanupAuthority>, activityOptions?: Readonly<UserHostLocalPostgresActivityOptions>): Promise<LocalPostgresCleanupResult>;

package/dist/database/local-postgres.d.ts

@@ -1,71 +0,0 @@
-import { type DockerLabels } from "./docker.js";
-import type { DatabaseMaterializationInput } from "../config/loader/index.js";
-import { type LocalPostgresState } from "./state-files.js";
-export declare const LOCAL_POSTGRES_DOCKER_TIMEOUTS_MS: Readonly<{
-    inspect: 30000;
-    readinessAttempt: 10000;
-    remove: 120000;
-    run: number;
-    start: 120000;
-    volumeCreate: 120000;
-}>;
-interface DockerRunOptions {
-    containerName: string;
-    image: string;
-    labels: DockerLabels;
-    maxConnections: number;
-    password: string;
-    user: string;
-    volumeMountPath: string;
-    volumeName: string;
-}
-interface LocalPostgresContainerReuseOptions {
-    image: string;
-    maxConnections: number;
-    volumeMountPath: string;
-    volumeName: string;
-}
-export interface LocalPostgresOperationOptions {
-    signal?: AbortSignal;
-}
-interface DockerContainerConfig {
-    Cmd?: string[] | null;
-    Image?: string | null;
-    Labels?: DockerLabels | null;
-}
-interface DockerContainerHostConfig {
-    NetworkMode?: string | null;
-}
-interface DockerContainerMount {
-    Destination?: string | null;
-    Name?: string | null;
-    Type?: string | null;
-}
-interface DockerContainerPortBinding {
-    HostPort?: string | null;
-}
-export interface DockerContainerInspect {
-    Config?: DockerContainerConfig | null;
-    HostConfig?: DockerContainerHostConfig | null;
-    Id?: string | null;
-    Mounts?: (DockerContainerMount | null | undefined)[] | null;
-    NetworkSettings?: {
-        Ports?: Record<string, DockerContainerPortBinding[] | null> | null;
-    } | null;
-    State?: {
-        Running?: boolean | null;
-    } | null;
-}
-export type InspectedDockerContainer = DockerContainerInspect & {
-    Id: string;
-};
-export declare function ensureLocalContainer(productDir: string, database?: Readonly<DatabaseMaterializationInput>, options?: Readonly<LocalPostgresOperationOptions>): Promise<LocalPostgresState>;
-export declare function buildDockerRunArgs({ containerName, labels, volumeName, volumeMountPath, user, password, image, maxConnections, }: Readonly<DockerRunOptions>): string[];
-export declare function loadExistingLocalContainer(productDir: string, options?: Readonly<LocalPostgresOperationOptions>): Promise<LocalPostgresState | null>;
-export declare function isReusableLocalPostgresContainer(inspect: Readonly<DockerContainerInspect>, options: Readonly<LocalPostgresContainerReuseOptions>): boolean;
-export declare function inspectContainer(containerName: string, options?: Readonly<LocalPostgresOperationOptions>): Promise<InspectedDockerContainer | null>;
-export declare function normalizeLocalPostgresContainerInspect(value: unknown): DockerContainerInspect | null;
-export declare function stopAndRemoveContainer(containerRef: string, displayName?: string, options?: Readonly<LocalPostgresOperationOptions>): Promise<void>;
-export declare function matchesStableDockerLabels(existingLabels: Readonly<Record<string, unknown>>, expectedLabels: Readonly<Record<string, unknown>>): boolean;
-export declare function resolveLocalPostgresVolumeTarget(image: unknown): string;
-export {};

package/dist/database/naming.d.ts

@@ -1,17 +0,0 @@
-export interface DatabaseConnection {
-    host: string;
-    password: string;
-    port: number;
-    sslMode?: string | null;
-    user: string;
-}
-export declare function buildDatabaseUrl(infra: Readonly<DatabaseConnection>, dbName: string): string;
-export declare function buildContainerName(productDir: string): string;
-export declare function buildVolumeName(productDir: string, generation: string): string;
-export declare function buildTemplateDatabaseName(serviceName: string, fingerprint: string): string;
-export declare function buildRuntimeDatabaseName(serviceName: string, bindingKey: string, fingerprint: string): string;
-export declare function hashString(value: string, length?: number): string;
-export declare function slugSegment(value: string): string;
-export declare function limitIdentifier(value: string, maxLength: number): string;
-export declare function escapeIdentifier(value: unknown): string;
-export declare function escapeSqlLiteral(value: unknown): string;

package/dist/database/postgres/index.d.ts

@@ -1,71 +0,0 @@
-import type { Readable } from "node:stream";
-import type { OwnedPostgresContainerRoute } from "../../domain/postgres-route.js";
-export declare const POSTGRES_CLIENT_CONTAINER_LABEL = "com.elench.testkit.postgres-client.container";
-export declare const POSTGRES_CLIENT_TIMEOUT_MS: number;
-export interface PostgresConnectionInput {
-    database?: string | null;
-    host?: string | null;
-    password?: string | null;
-    port?: number | string | null;
-    rawUrl?: unknown;
-    sslMode?: string | null;
-    user?: string | null;
-}
-export interface PostgresConnection extends PostgresConnectionInput {
-    database: string;
-    host: string;
-    port: number | string;
-    user: string;
-}
-export interface DockerPsqlOptions {
-    args?: readonly unknown[];
-    connection?: PostgresConnectionInput | null;
-    cwd?: string;
-    databaseUrl?: string | null;
-    env?: NodeJS.ProcessEnv;
-    image?: string | null;
-    ownedContainer?: OwnedPostgresContainerRoute | null;
-    signal?: AbortSignal;
-    timeoutMs?: number;
-}
-export interface DockerPostgresClientOptions extends DockerPsqlOptions {
-    clientCommand?: string | null;
-}
-export interface BuildDockerPostgresClientArgsOptions {
-    args?: readonly unknown[];
-    clientCommand: string;
-    connection: PostgresConnection;
-    cwd?: string;
-    env?: NodeJS.ProcessEnv;
-    image?: string;
-    ownedContainer?: OwnedPostgresContainerRoute | null;
-}
-export interface PostgresCommandResult {
-    command: string;
-    escapedCommand: string;
-    exitCode: number | null;
-    failed: boolean;
-    shortMessage?: string;
-    signal: NodeJS.Signals | null;
-    stderr: string;
-    stdout: string;
-}
-export interface PostgresClientProcess extends Promise<PostgresCommandResult> {
-    pid: number | undefined;
-    stderr: Readable | null;
-    stop(): boolean;
-    stdout: Readable | null;
-}
-interface RewritePostgresFileArgsResult {
-    args: string[];
-    mountArgs: string[];
-}
-export declare function postgresClientImage(env?: NodeJS.ProcessEnv): string;
-export declare function runDockerPsql(options: DockerPsqlOptions): Promise<PostgresCommandResult>;
-export declare function startDockerPgDump(options: DockerPsqlOptions): PostgresClientProcess;
-export declare function runDockerPostgresClient(options?: DockerPostgresClientOptions): Promise<PostgresCommandResult>;
-export declare function startDockerPostgresClient({ clientCommand, args, cwd, env, connection, databaseUrl, image, ownedContainer, signal, timeoutMs, }?: DockerPostgresClientOptions): PostgresClientProcess;
-export declare function buildDockerPostgresClientArgs(options: BuildDockerPostgresClientArgsOptions): string[];
-export declare function rewritePostgresFileArgsForDocker(args: readonly string[], cwd?: string): RewritePostgresFileArgsResult;
-export declare function connectionFromDatabaseUrl(rawUrl: unknown): PostgresConnection | null;
-export {};

package/dist/database/progress.d.ts

@@ -1,6 +0,0 @@
-import type { ConfiguredStepReporter } from "../steps/index.js";
-import type { SetupOperationRegistry } from "../evidence/setup-progress.js";
-export interface DatabaseProgress {
-    reporter?: ConfiguredStepReporter | null;
-    setupRegistry?: SetupOperationRegistry | null;
-}

package/dist/database/roles.d.ts

@@ -1,19 +0,0 @@
-import type { NormalizedDatabaseConfig } from "../config/loader/index.js";
-import type { StepServiceIdentity } from "../evidence/setup-progress.js";
-import type { LocalPostgresState } from "./state-files.js";
-import type { DatabaseTemplateStepOptions } from "./template-steps.js";
-export declare const DATABASE_ROLES_LOCK: readonly [1952805748, 1919904869];
-type DatabaseRoleConfig = NormalizedDatabaseConfig["roles"][number];
-interface DatabaseRoleServiceConfig extends StepServiceIdentity {
-    productDir: string;
-    testkit: {
-        database: {
-            roles: readonly DatabaseRoleConfig[];
-        };
-    };
-}
-interface DatabaseRoleOptions extends Pick<DatabaseTemplateStepOptions, "reporter" | "setupRegistry" | "signal"> {
-    timeoutMs?: number;
-}
-export declare function ensureDatabaseRoles(config: Readonly<DatabaseRoleServiceConfig>, infra: Readonly<LocalPostgresState>, options?: Readonly<DatabaseRoleOptions>): Promise<void>;
-export {};

package/dist/database/runtime-config.d.ts

@@ -1,16 +0,0 @@
-import { type NormalizedDatabaseConfig, type NormalizedDatabaseTemplateConfig, type NormalizedSourceSchemaConfig } from "../config/loader/index.js";
-import { type TemplateResolutionContext } from "../steps/index.js";
-export declare function finalizeRuntimeDatabaseConfig(database: NormalizedDatabaseConfig | null | undefined, context: TemplateResolutionContext): import("../config/loader/database-materialization.js").MaterializedDatabaseConfig<{
-    image?: string;
-    password?: string;
-    user?: string;
-    binding: import("../config/loader/execution-model.js").DatabaseBinding;
-    maxConnections: number | undefined;
-    reservedConnections: number | undefined;
-    reset: boolean;
-    roles: import("../config/authoring/index.js").DatabaseRoleConfig[];
-    runtimeConnections: number | undefined;
-    serviceName: string;
-    sourceSchema: NormalizedSourceSchemaConfig | null;
-    template: NormalizedDatabaseTemplateConfig;
-}> | undefined;

package/dist/database/runtime-reservations.d.ts

@@ -1,19 +0,0 @@
-import { type DatabaseMaterializationInput } from "../config/loader/index.js";
-export interface DatabaseReservationService {
-    name: string;
-    testkit: {
-        database?: DatabaseMaterializationInput | null;
-    };
-}
-export interface RuntimeDatabaseReservation {
-    available: number;
-    capacity: number;
-    key: string;
-    kind: "postgres";
-    perRuntime: number;
-    reserved: number;
-    resourceName: "local";
-    scope: "local";
-    services: string[];
-}
-export declare function buildGraphResourceReservations(runtimeConfigs: readonly DatabaseReservationService[]): RuntimeDatabaseReservation[];

package/dist/database/schema-operations.d.ts

@@ -1,18 +0,0 @@
-import { type DatabaseRuntimeConfig } from "./index.js";
-import type { DatabaseProgress } from "./progress.js";
-import { type RefreshedSourceSchemaState } from "./schema-source.js";
-export interface ResolvedSchemaOperationPlan {
-    /** Configs in provisioning order; dependencies before dependents. */
-    configs: readonly DatabaseRuntimeConfig[];
-    target: DatabaseRuntimeConfig;
-}
-export type SchemaOperationConfigResolver = (runtimeRootDir: string) => ResolvedSchemaOperationPlan;
-export interface DatabaseSchemaOperationContext {
-    progress?: DatabaseProgress | null;
-    signal?: AbortSignal;
-}
-export interface VerifyDatabaseSchemaOptions extends DatabaseSchemaOperationContext {
-    skipSchemaSourceVerify?: boolean;
-}
-export declare function verifyDatabaseSchema(productDir: string, resolveConfigs: SchemaOperationConfigResolver, options?: Readonly<VerifyDatabaseSchemaOptions>): Promise<void>;
-export declare function refreshDatabaseSchema(productDir: string, resolveConfigs: SchemaOperationConfigResolver, options?: Readonly<DatabaseSchemaOperationContext>): Promise<RefreshedSourceSchemaState>;

package/dist/database/schema-source.d.ts

@@ -1,96 +0,0 @@
-import type { Hash } from "crypto";
-import type { NormalizedSourceSchemaConfig } from "../config/loader/index.js";
-import { type RepoState } from "../repo/state.js";
-import { type DatabaseTemplateServiceConfig, type DatabaseTemplateStepOptions } from "./template-steps.js";
-import { type SourceSchemaDumpResolution } from "./source-url.js";
-type UnknownRecord = Record<string, unknown>;
-type SourceSchemaUnavailableMode = "fail" | "warn-cache";
-type SourceSchemaTestkitConfig = DatabaseTemplateServiceConfig["testkit"] & {
-    fingerprints?: unknown;
-};
-export interface SourceSchemaCacheConfig {
-    name: string;
-    productDir: string;
-    testkit?: Pick<SourceSchemaTestkitConfig, "fingerprints">;
-}
-export interface SourceSchemaServiceConfig extends DatabaseTemplateServiceConfig {
-    testkit: SourceSchemaTestkitConfig;
-}
-export interface SourceSchemaCacheLocationOptions {
-    repoState?: RepoState | null;
-}
-export interface SourceSchemaCacheLocation {
-    cacheDir: string;
-    cacheKey: string;
-    cacheKind: string;
-    cachePath: string;
-    indexPath: string;
-    metadataPath: string;
-    repoState: RepoState;
-    rootDir: string;
-}
-type SourceSchemaOperationOptions = Pick<DatabaseTemplateStepOptions, "ownedContainer" | "parentOperation" | "reporter" | "setupRegistry">;
-export interface SourceSchemaOptions extends SourceSchemaCacheLocationOptions, SourceSchemaOperationOptions {
-    env?: NodeJS.ProcessEnv | null;
-    signal?: AbortSignal;
-    skipSchemaSourceVerify?: boolean;
-}
-interface SourceSchemaVerificationOptions extends SourceSchemaOptions {
-    resolveLocalSnapshotImage?: () => Promise<string>;
-}
-export interface InactiveSourceSchemaState {
-    active: false;
-    cachePath?: string;
-}
-export interface ActiveSourceSchemaState extends SourceSchemaCacheLocation {
-    active: true;
-    cacheExists: boolean;
-    ci: boolean;
-    envName: string | null;
-    refreshed: boolean;
-    refreshError?: unknown;
-    refreshInfo?: SourceSchemaRefreshInfo;
-    sourceSchema: NormalizedSourceSchemaConfig;
-    sourceUrl: string | null;
-    unavailableMode: SourceSchemaUnavailableMode;
-}
-export interface RefreshedSourceSchemaState extends ActiveSourceSchemaState {
-    cacheExists: true;
-    refreshed: true;
-    refreshInfo: SourceSchemaRefreshInfo;
-}
-export type SourceSchemaState = ActiveSourceSchemaState | InactiveSourceSchemaState;
-interface SourceSchemaMetadata extends UnknownRecord {
-    refreshedAt: string;
-    sourceUrl?: SourceSchemaDumpResolution["metadata"];
-}
-export interface SourceSchemaRefreshInfo {
-    metadata: SourceSchemaMetadata;
-    reusedExistingRefresh: boolean;
-    waitedForLock: boolean;
-}
-export interface SourceSchemaMismatchDiagnostics {
-    diffPath: string;
-    localPath: string;
-    metaPath: string;
-    sourceCachePath: string;
-    sourcePath: string;
-}
-export type SourceSchemaVerification = {
-    status: "disabled" | "matched" | "skipped";
-} | {
-    diagnostics: SourceSchemaMismatchDiagnostics;
-    status: "mismatch";
-};
-export declare function getSourceSchemaRootDir(config: Readonly<SourceSchemaCacheConfig>): string;
-export declare function getSourceSchemaCachePath(config: Readonly<SourceSchemaCacheConfig>, options?: Readonly<SourceSchemaCacheLocationOptions>): Promise<string>;
-export declare function resolveSourceSchemaCacheLocation(config: Readonly<SourceSchemaCacheConfig>, options?: Readonly<SourceSchemaCacheLocationOptions>): Promise<SourceSchemaCacheLocation>;
-export declare function resolveSourceSchemaState(config: Readonly<SourceSchemaServiceConfig>, options?: Readonly<SourceSchemaOptions>): Promise<SourceSchemaState>;
-export declare function prepareSourceSchemaCache(config: Readonly<SourceSchemaServiceConfig>, options?: Readonly<SourceSchemaOptions>): Promise<SourceSchemaState>;
-export declare function forceRefreshSourceSchemaCache(config: Readonly<SourceSchemaServiceConfig>, previousState: Readonly<SourceSchemaState> | null, options?: Readonly<SourceSchemaOptions>): Promise<RefreshedSourceSchemaState>;
-export declare function applySourceSchemaCache(config: Readonly<SourceSchemaServiceConfig>, databaseUrl: string, state: Readonly<SourceSchemaState> | null | undefined, options?: Readonly<SourceSchemaOptions>): Promise<boolean>;
-export declare function verifyLocalSchemaMatchesSource(config: Readonly<SourceSchemaServiceConfig>, databaseUrl: string, state: Readonly<SourceSchemaState> | null | undefined, options?: Readonly<SourceSchemaVerificationOptions>): Promise<SourceSchemaVerification>;
-export declare function createSourceSchemaMismatchError(config: Readonly<SourceSchemaServiceConfig>, state: Readonly<ActiveSourceSchemaState>, verification: Readonly<SourceSchemaVerification> | null | undefined): Error;
-export declare function appendSourceSchemaCacheToHash(hash: Pick<Hash, "update">, config: Readonly<SourceSchemaServiceConfig>, state?: Readonly<SourceSchemaState> | null): Promise<void>;
-export declare function buildUnifiedDiffText(leftText: unknown, rightText: unknown, leftLabel?: string, rightLabel?: string): string;
-export {};

package/dist/database/source-refresh-lock.d.ts

@@ -1,8 +0,0 @@
-import { type ProcessLockOptions } from "../process/locks.js";
-export interface SourceSchemaRefreshLockContext {
-    requestedAt: number;
-    waited: boolean;
-}
-export type SourceSchemaRefreshLockOptions = Pick<ProcessLockOptions, "retryIntervalMs" | "signal">;
-export declare function withSourceSchemaRefreshLock<Result>(lockPath: string, task: (context: Readonly<SourceSchemaRefreshLockContext>) => Promise<Result> | Result, options?: Readonly<SourceSchemaRefreshLockOptions>): Promise<Result>;
-export declare function getSourceSchemaRefreshLockPath(cachePath: string): string;

package/dist/database/source-url.d.ts

@@ -1,22 +0,0 @@
-export type DatabaseHostKind = "neon-pooler" | "neon-direct" | "unsupported-pooler" | "unknown-direct";
-export interface DatabaseHostClassification {
-    kind: DatabaseHostKind;
-    host: string;
-}
-export interface SourceSchemaDumpResolution {
-    originalUrl: string;
-    dumpUrl: string;
-    rewritten: boolean;
-    notice: string | null;
-    metadata: {
-        originalHost: string;
-        originalClassification: DatabaseHostKind;
-        resolvedHost: string;
-        resolvedClassification: DatabaseHostKind;
-        rewritten: boolean;
-    };
-}
-export declare function resolveSourceSchemaDumpUrl(databaseUrl: string): SourceSchemaDumpResolution;
-export declare function classifyDatabaseHost(hostname: string): DatabaseHostClassification;
-export declare function redactDatabaseUrl(databaseUrl: string): string;
-export declare function assertPgDumpArgsAreSourceSafe(args: readonly string[]): void;