@gfdelarue/testkit 0.3.0

package/dist/config/loader/load.d.ts

@@ -0,0 +1,89 @@
+import { type EngineConfigurations } from "../../engines/catalog.js";
+import { type EngineId, type PublicTestType, type RunnerProfileId } from "../../domain/identifiers.js";
+import { type DiscoveredSuite, type DiscoveryOptions, type DiscoveryProject } from "./discovery.js";
+import { type NormalizedToolchainRegistry } from "../../toolchains/index.js";
+import { type TestFileMetadata } from "./file-metadata.js";
+import { type NormalizedDiscoveryConfig } from "./path-policy.js";
+import { type FingerprintPolicy } from "../../repo/fingerprint-policy.js";
+import { type NormalizedDatabaseConfig } from "./database.js";
+import { parseDotenv } from "./env.js";
+import { type NormalizedRuntimeIsolationConfig } from "./runtime-isolation.js";
+import { resolveProductDir, resolveServiceCwd } from "./paths.js";
+import { type NormalizedRuntimeConfig } from "./runtime.js";
+import { type NormalizedServiceRequirements, type NormalizedSkipConfig } from "./skip-config.js";
+import { type NormalizedArtifactArchiveConfig } from "../../evidence/index.js";
+import type { NormalizedExecutionConfig } from "./execution-model.js";
+type UnknownRecord = Record<string, unknown>;
+export interface NormalizedSuiteConfig extends DiscoveredSuite {
+    engineId: EngineId;
+    profileId: RunnerProfileId;
+    testType: PublicTestType;
+}
+export type ServiceSuites = Partial<Record<PublicTestType, NormalizedSuiteConfig[]>>;
+export interface NormalizedLocalServiceConfig {
+    baseUrl: string;
+    cwd: string;
+    env: Record<string, string>;
+    port?: number;
+    readyTimeoutMs?: number;
+    shutdownTimeoutMs?: number;
+    readyUrl?: false | null | string;
+    start: string;
+}
+export interface NormalizedServiceTestkitConfig {
+    database: NormalizedLoadedDatabaseConfig | undefined;
+    databaseFrom: string | undefined;
+    dependsOn: string[];
+    discovery: NormalizedDiscoveryConfig;
+    envFiles: string[];
+    execution: NormalizedExecutionConfig;
+    fileMetadataByPath: Map<string, TestFileMetadata>;
+    fingerprints: FingerprintPolicy;
+    local: NormalizedLocalServiceConfig | undefined;
+    requirements: NormalizedServiceRequirements;
+    runtime: NormalizedRuntimeConfig;
+    runtimeIsolation: NormalizedRuntimeIsolationConfig;
+    serviceEnv: Record<string, string>;
+    skip: NormalizedSkipConfig | undefined;
+    ui: unknown;
+}
+export type NormalizedLoadedDatabaseConfig = NormalizedDatabaseConfig & Record<PropertyKey, unknown>;
+export interface NormalizedServiceConfig {
+    artifacts: NormalizedArtifactArchiveConfig;
+    configFile: null | string;
+    engineConfigurations?: EngineConfigurations;
+    name: string;
+    productDir: string;
+    stateDir: string;
+    suites: ServiceSuites;
+    testkit: NormalizedServiceTestkitConfig;
+}
+export interface PreparedDiscovery {
+    readonly project: DiscoveryProject;
+    readonly fileMetadataByPath: Map<string, TestFileMetadata>;
+}
+export interface LoadConfigContextOptions {
+    preparedDiscovery?: PreparedDiscovery;
+    configContext?: unknown;
+    configImportCacheSalt?: string;
+    dir?: null | string;
+    discoveryOptions?: Omit<DiscoveryOptions, "discovery">;
+    requireLocalRuntime?: boolean;
+}
+export interface LoadConfigsOptions extends LoadConfigContextOptions {
+    service?: null | string;
+}
+export interface NormalizedConfigContext {
+    config: object;
+    configFile: null | string;
+    configs: NormalizedServiceConfig[];
+    discovery: DiscoveryProject;
+    execution: NormalizedExecutionConfig;
+    explicitServices: Partial<Record<string, UnknownRecord>>;
+    fingerprints: FingerprintPolicy;
+    productDir: string;
+    toolchains: NormalizedToolchainRegistry;
+}
+export { parseDotenv, resolveProductDir, resolveServiceCwd };
+export declare function loadConfigContext(opts?: Readonly<LoadConfigContextOptions>): Promise<NormalizedConfigContext>;
+export declare function loadConfigs(opts?: Readonly<LoadConfigsOptions>): Promise<NormalizedServiceConfig[]>;

package/dist/config/loader/load.js

@@ -0,0 +1 @@
+import A from"path";import{buildEngineConfigurations as B}from"../../engines/catalog.js";import{isPublicTestType as K}from"../../domain/identifiers.js";import{discoverProject as G}from"./discovery.js";import{loadTestkitConfig as H}from"./config-loader.js";import{normalizeToolchainRegistry as J}from"../../toolchains/index.js";import{loadTestFileMetadataMap as Q}from"./file-metadata.js";import{mergeDiscoveryConfigs as V}from"./path-policy.js";import{normalizeDiscoveryConfig as I}from"./decode-discovery.js";import{normalizeFingerprintPolicy as W}from"../../repo/fingerprint-policy.js";import{normalizeDatabaseConfig as X}from"./database.js";import{inferEnvFiles as Y,loadServiceEnv as Z,parseDotenv as _}from"./env.js";import{normalizeRuntimeIsolationConfig as N}from"./runtime-isolation.js";import{resolveProductDir as M,resolveServiceCwd as ee}from"./paths.js";import{inferLocalRuntime as re,normalizeRepoExecution as oe,normalizeRuntimeConfig as te}from"./runtime.js";import{normalizeServiceRequirements as ne,normalizeSkipConfig as ie}from"./skip-config.js";import{normalizeArtifactArchiveConfig as se}from"../../evidence/index.js";import{validateConfigCoverage as ce,validateServiceConfig as fe}from"./validation.js";import{isObjectRecord as g,readProperty as i}from"./values.js";import{assertPortableServiceNameSet as ae,requireServiceName as de}from"../../domain/service-name.js";import{resolveEngineProfile as le}from"../../engines/catalog.js";export{_ as parseDotenv,M as resolveProductDir,ee as resolveServiceCwd};export async function loadConfigContext(e={}){const r=M(process.cwd(),e.dir),o=e.requireLocalRuntime!==!1,t=e.configContext||await H(r,{importCacheSalt:e.configImportCacheSalt??""}),{config:n,configFile:f}=he(t),d=oe(je(i(n,"execution"))),u=se(i(n,"artifacts")),a=J(i(n,"toolchains")),s=W(i(n,"fingerprints")),m=I(i(n,"discovery"),{allowRoots:!0}),c=be(i(n,"services")),p=e.preparedDiscovery?.project??G(r,ye(c),{...e.discoveryOptions||{},discovery:m}),$=Q(r,p.suitesByService,e.preparedDiscovery?.fileMetadataByPath),w=ue(p.suitesByService,$),b=[...new Set([...Object.keys(c),...Object.keys(w)])].sort((l,S)=>l.localeCompare(S)).map(l=>pe({name:l,productDir:r,config:n,configFile:f,execution:d,discovery:m,artifacts:u,toolchains:a,fingerprints:s,explicitService:c[l]||{},discoveredService:p.services[l]||null,suites:w[l]||{},fileMetadataByPath:$,requireLocalRuntime:o}));return ce(b),{productDir:r,config:n,configFile:f,execution:d,toolchains:a,fingerprints:s,explicitServices:c,discovery:p,configs:b}}function ue(e,r){return Object.fromEntries(Object.entries(e).map(([o,t])=>[o,me(o,t||{},r)]))}function me(e,r,o){const t={};for(const[n,f]of Object.entries(r)){if(!K(n))throw new Error(`Discovered service "${e}" contains unknown test type "${n}"`);t[n]=f.map(d=>{const u=d.files[0];if(!u)throw new Error(`Discovered suite ${e}/${n}:${d.name} contains no files`);const a=T(o,u),s=le(n,a.engineId);if(s.id!==a.profileId)throw new Error(`Discovered file ${u} resolved conflicting engine profile ${a.profileId}; expected ${s.id}`);for(const m of d.files.slice(1)){const c=T(o,m);if(c.engineId!==a.engineId||c.profileId!==a.profileId)throw new Error(`Discovered suite ${e}/${n}:${d.name} mixes engine profiles ${a.engineId}/${a.profileId} and ${c.engineId}/${c.profileId}`)}return{...d,testType:n,engineId:a.engineId,profileId:a.profileId}})}return t}function T(e,r){const o=e.get(r);if(!o)throw new Error(`Missing validated testkit metadata for discovered file: ${r}`);return o}export async function loadConfigs(e={}){const r=await loadConfigContext(e),{configs:o}=r,t=e.service?o.filter(n=>n.name===e.service):o;if(e.service&&t.length===0){const n=o.map(f=>f.name).join(", ");throw new Error(`Service "${e.service}" not found. Available: ${n}`)}return t}function pe({name:e,productDir:r,config:o,configFile:t,execution:n,discovery:f,artifacts:d,toolchains:u,fingerprints:a,explicitService:s,discoveredService:m,suites:c,fileMetadataByPath:p,requireLocalRuntime:$}){const w=B(o,new Set(Object.values(c).flatMap(y=>y.map(E=>E.engineId)))),v=ge(e,s,m,r),b=Y(r,s,v),l={...Z(r,b),...F(i(s,"env"),`Service "${e}" env`)},S=V(f,P(i(s,"discovery"),e));if(i(s,"migrate")||i(s,"seed"))throw new Error(`Service "${e}" uses removed migrate/seed hooks. Move template lifecycle to database.template.{migrate,seed,verify}.`);const C=we(s,e),j=te(i(s,"runtime"),e,u),D=ie(i(s,"skip"),{name:e,suites:c}),L=ne(i(s,"requirements"),{name:e,suites:c}),q=N(i(s,"runtimeIsolation"),{name:e,suites:c}),x=new Set(Object.values(c).flatMap(y=>y.flatMap(E=>E.files))),U=new Map([...p.entries()].filter(([y])=>x.has(y))),O=$e(i(s,"dependsOn"),`Service "${e}" dependsOn`),z=h(i(s,"databaseFrom"),`Service "${e}" databaseFrom`);return fe({name:e,local:v,database:C,databaseFrom:z,runtime:j,dependsOn:O,suites:c,productDir:r,requireLocalRuntime:$}),{name:e,productDir:r,configFile:t,...w===void 0?{}:{engineConfigurations:w},stateDir:A.join(r,".testkit",e),artifacts:d,suites:c,testkit:{execution:n,dependsOn:O,discovery:S,database:C,databaseFrom:z,envFiles:b,requirements:L,serviceEnv:l,skip:D,runtime:j,runtimeIsolation:q,ui:i(o,"ui")||null,fingerprints:a,fileMetadataByPath:U,local:v}}}function ge(e,r,o,t){if(Object.prototype.hasOwnProperty.call(r,"local"))return k(i(r,"local"),e);const n=o?.inferredLocalCwd||".",f=re(t,n);if(f)return f}function k(e,r){if(e===!1)return;if(!g(e))throw new Error(`Service "${r}" local must be an object or false`);const o=R(e.baseUrl,`Service "${r}" local.baseUrl`),t=R(e.start,`Service "${r}" local.start`),{shutdownTimeoutMs:n,...f}=e;return{...f,...Ee(n,r),baseUrl:o,start:t,cwd:h(e.cwd,`Service "${r}" local.cwd`)||".",env:F(e.env,`Service "${r}" local.env`),...ve(e.port,`Service "${r}" local.port`),...Se(e.readyTimeoutMs,`Service "${r}" local.readyTimeoutMs`),...Ce(e.readyUrl,r)}}function we(e,r){const o=X(e,r);if(!o)return;const t=h(i(o,"image"),`Service "${r}" database.image`),n=h(i(o,"password"),`Service "${r}" database.password`),f=h(i(o,"user"),`Service "${r}" database.user`);return{...o,...Object.prototype.hasOwnProperty.call(o,"image")?{image:t}:{},...Object.prototype.hasOwnProperty.call(o,"password")?{password:n}:{},...Object.prototype.hasOwnProperty.call(o,"user")?{user:f}:{}}}function P(e,r){try{return I(e,{allowRoots:!0})}catch(o){const t=o instanceof Error?o.message:String(o);throw new Error(`Service "${r}" has invalid discovery config: ${t}`,{cause:o})}}function be(e){if(e==null)return{};if(!g(e))throw new Error("testkit.config.ts services must be an object");const r=Object.fromEntries(Object.entries(e).map(([o,t])=>{if(de(o,`Service name "${o}"`),t==null)return[o,{}];if(!g(t))throw new Error(`Service "${o}" config must be an object`);return[o,t]}));return ae(Object.keys(r)),r}function ye(e){return Object.fromEntries(Object.entries(e).map(([r,o])=>{const t=o||{},n={discovery:P(i(t,"discovery"),r),local:Object.prototype.hasOwnProperty.call(t,"local")?k(i(t,"local"),r)||!1:void 0};return[r,n]}))}function he(e){if(!g(e))throw new Error("Loaded Testkit config context must be an object");const r=e.config;if(typeof r!="object"||r===null)throw new Error("Loaded Testkit config must be an object");const o=e.configFile;if(o!==null&&typeof o!="string")throw new Error("Loaded Testkit config file must be a string or null");return{config:r,configFile:o}}function $e(e,r){if(e==null)return[];if(!Array.isArray(e))throw new Error(`${r} must be an array of strings`);return e.map((o,t)=>{if(typeof o!="string")throw new Error(`${r}[${String(t)}] must be a string`);return o})}function F(e,r){if(e==null)return{};if(!g(e))throw new Error(`${r} must be an object of strings`);return Object.fromEntries(Object.entries(e).map(([o,t])=>{if(typeof t!="string")throw new Error(`${r}.${o} must be a string`);return[o,t]}))}function ve(e,r){if(e===void 0)return{};if(typeof e!="number")throw new Error(`${r} must be a number`);return{port:e}}function Se(e,r){if(e===void 0)return{};if(typeof e!="number")throw new Error(`${r} must be a number`);return{readyTimeoutMs:e}}function Ee(e,r){if(e===void 0)return{};if(typeof e!="number"||!Number.isInteger(e)||e<=0)throw new Error(`Service "${r}" local.shutdownTimeoutMs must be a positive finite integer in milliseconds`);return{shutdownTimeoutMs:e}}function Ce(e,r){if(e===void 0)return{};if(e===!1||e===null||typeof e=="string")return{readyUrl:e};throw new Error(`Service "${r}" local.readyUrl must be a string, false, or null`)}function h(e,r){if(e!==void 0){if(typeof e!="string")throw new Error(`${r} must be a string`);return e}}function R(e,r){if(typeof e!="string")throw new Error(`${r} must be a string`);return e}function je(e){if(e){if(!g(e))throw new Error("testkit.config.ts execution must be an object");return e}}

package/dist/config/loader/managed-configs.d.ts

@@ -0,0 +1,21 @@
+import { type NormalizedServiceConfig } from "./load.js";
+export interface LoadManagedConfigsOptions {
+    dir?: string;
+    service?: null | string;
+}
+export interface ManagedConfigCollection {
+    allConfigs: NormalizedServiceConfig[];
+    configs: NormalizedServiceConfig[];
+}
+export interface ManagedConfigDependencyNode {
+    name: string;
+    testkit: {
+        database?: unknown;
+        dependsOn: readonly string[];
+    };
+}
+export declare function loadManagedConfigs(options?: Readonly<LoadManagedConfigsOptions>): Promise<ManagedConfigCollection>;
+export declare function filterConfigsByService<Config extends ManagedConfigDependencyNode>(allConfigs: Config[], serviceName: null | string): Config[];
+export declare function resolveTargetConfig<Config extends ManagedConfigDependencyNode>(configs: readonly Config[], serviceName?: null | string): Config;
+export declare function collectRequiredConfigs<Config extends ManagedConfigDependencyNode>(configs: readonly Config[], targetName: string): Config[];
+export declare function topologicallySortConfigs<Config extends ManagedConfigDependencyNode>(configs: readonly Config[]): Config[];

package/dist/config/loader/managed-configs.js

@@ -0,0 +1 @@
+import{loadConfigs as d}from"./load.js";export async function loadManagedConfigs(e={}){const o=await d({dir:e.dir}),a=filterConfigsByService(o,e.service||null);return{allConfigs:o,configs:a}}export function filterConfigsByService(e,o){if(!o)return e;const a=e.filter(t=>t.name===o);if(a.length>0)return a;const i=e.map(t=>t.name).join(", ");throw new Error(`Service "${o}" not found. Available: ${i}`)}export function resolveTargetConfig(e,o=null){if(o){const t=e.find(r=>r.name===o);if(!t){const r=e.map(n=>n.name).join(", ");throw new Error(`Service "${o}" not found. Available: ${r}`)}return t}if(e.length===1)return e[0];const a=e.filter(t=>t.testkit.database);if(a.length===1)return a[0];const i=e.map(t=>t.name).join(", ");throw new Error(`Multiple services available. Pass --service. Available: ${i}`)}export function collectRequiredConfigs(e,o){const a=new Map(e.map(r=>[r.name,r])),i=new Set,t=r=>{if(i.has(r))return;const n=a.get(r);if(!n)throw new Error(`Missing config for dependency "${r}"`);i.add(r);for(const s of n.testkit.dependsOn)t(s)};return t(o),e.filter(r=>i.has(r.name))}export function topologicallySortConfigs(e){const o=new Map(e.map(n=>[n.name,n])),a=new Set,i=new Set,t=[],r=n=>{if(!a.has(n.name)){if(i.has(n.name))throw new Error(`Dependency cycle while resolving configs for "${n.name}"`);i.add(n.name);for(const s of n.testkit.dependsOn){const l=o.get(s);l&&r(l)}i.delete(n.name),a.add(n.name),t.push(n)}};for(const n of e)r(n);return t}

package/dist/config/loader/path-policy.d.ts

@@ -0,0 +1,9 @@
+export interface NormalizedDiscoveryConfig {
+    exclude?: string[];
+    roots?: string[];
+}
+export declare const DEFAULT_DISCOVERY_EXCLUDES: readonly string[];
+export declare function mergeDiscoveryConfigs(...configs: readonly (NormalizedDiscoveryConfig | null | undefined)[]): NormalizedDiscoveryConfig;
+export declare function resolveDiscoveryRoots(baseDir: string, roots: null | readonly unknown[] | undefined, defaultRoot?: unknown): string[];
+export declare function shouldExcludeDiscoveryPath(relativePath: unknown, exclude?: readonly string[]): boolean;
+export declare function normalizeDiscoveryPath(value: unknown): string;

package/dist/config/loader/path-policy.js

@@ -0,0 +1 @@
+import u from"fs";import l from"path";const f=String;export const DEFAULT_DISCOVERY_EXCLUDES=Object.freeze([".cache",".git",".hg",".next",".nuxt",".playwright-browsers",".svn",".testkit",".turbo","build","coverage","dist","node_modules","playwright-report","test-results"]);export function mergeDiscoveryConfigs(...o){const e={};for(const t of o)t&&(Array.isArray(t.roots)&&(e.roots=[...t.roots]),Array.isArray(t.exclude)&&t.exclude.length>0&&(e.exclude=[...new Set([...e.exclude||[],...t.exclude])]));return e}export function resolveDiscoveryRoots(o,e,t="."){const s=Array.isArray(e)&&e.length>0?e:[t],c=new Set,a=[];for(const i of s){const r=normalizeDiscoveryPath(i);if(!r)continue;const n=l.resolve(o,r==="."?".":r);!u.existsSync(n)||!u.statSync(n).isDirectory()||c.has(n)||(c.add(n),a.push(n))}return a.sort((i,r)=>i.localeCompare(r))}export function shouldExcludeDiscoveryPath(o,e=[]){const t=normalizeDiscoveryPath(o);return!t||t==="."?!1:e.some(s=>d(t,s))}export function normalizeDiscoveryPath(o){return f(o||"").trim().split(l.sep).join("/").replace(/^\.\/+/u,"").replace(/\/+/gu,"/").replace(/\/+$/u,"")||"."}function d(o,e){return o===e||o.startsWith(`${e}/`)}

package/dist/config/loader/paths.d.ts

@@ -0,0 +1,5 @@
+export declare function resolveServiceCwd(productDir: string, maybeRelative?: string | null): string;
+export declare function ensureExistingPath(productDir: string, relativePath: string, label: string): void;
+export declare function ensureExistingContainedPath(productDir: string, relativePath: string, label: string): void;
+export declare function normalizePath(value?: string | null): string;
+export declare function resolveProductDir(cwd: string, explicitDir?: string | null): string;

package/dist/config/loader/paths.js

@@ -0,0 +1 @@
+import n from"fs";import s from"path";import{resolveContainedPath as i}from"../../process/files/contained-path.js";export function resolveServiceCwd(o,r){return s.resolve(o,r||".")}export function ensureExistingPath(o,r,e){const t=resolveServiceCwd(o,r);if(!n.existsSync(t))throw new Error(`${e} does not exist: ${r}`)}export function ensureExistingContainedPath(o,r,e){const t=i(o,r,e);if(!n.existsSync(t))throw new Error(`${e} does not exist: ${r}`)}export function normalizePath(o){return(o||"").replaceAll("\\","/").replace(/^\.\/+/,"")}export function resolveProductDir(o,r){const e=r?s.resolve(o,r):o;if(!n.existsSync(e))throw new Error(`Product directory does not exist: ${e}`);return e}

package/dist/config/loader/runtime-isolation.d.ts

@@ -0,0 +1,44 @@
+import { type TypedSuiteSelector } from "../../domain/suite-selection.js";
+import type { PublicTestType } from "../../domain/identifiers.js";
+import { type RuntimeIsolationPolicy } from "../../domain/runtime-isolation-contract.js";
+export { DEFAULT_RUNTIME_ISOLATION_POLICY, isRuntimeIsolationPolicy, normalizeRuntimeIsolationPolicy, RUNTIME_ISOLATION_POLICIES, type RuntimeIsolationPolicy, } from "../../domain/runtime-isolation-contract.js";
+export interface RuntimeIsolationSuiteInput {
+    files?: readonly string[];
+    name: string;
+    testType: PublicTestType;
+}
+export type RuntimeIsolationSuiteCollection = Readonly<Record<string, readonly RuntimeIsolationSuiteInput[] | undefined>>;
+export interface RuntimeIsolationNormalizationOptions {
+    name: string;
+    suites?: null | RuntimeIsolationSuiteCollection;
+}
+export interface NormalizedSuiteRuntimeIsolationRule {
+    policy: RuntimeIsolationPolicy;
+    selector: TypedSuiteSelector;
+}
+export interface NormalizedFileRuntimeIsolationRule {
+    path: string;
+    policy: RuntimeIsolationPolicy;
+}
+export interface NormalizedRuntimeIsolationConfig {
+    defaultPolicy: RuntimeIsolationPolicy;
+    filePolicyByPath: ReadonlyMap<string, RuntimeIsolationPolicy>;
+    files: NormalizedFileRuntimeIsolationRule[];
+    suites: NormalizedSuiteRuntimeIsolationRule[];
+}
+export interface RuntimeIsolationFileMetadata<Policy extends string = RuntimeIsolationPolicy> {
+    runtimeIsolation?: null | Policy;
+}
+export interface RuntimeIsolationResolverTestkitConfig<Policy extends string = string> {
+    fileMetadataByPath?: ReadonlyMap<string, RuntimeIsolationFileMetadata<Policy>>;
+    runtimeIsolation?: NormalizedRuntimeIsolationConfig;
+}
+export interface RuntimeIsolationResolverConfig<Policy extends string = string> {
+    testkit?: RuntimeIsolationResolverTestkitConfig<Policy>;
+}
+export interface RuntimeIsolationResolutionSuite {
+    name: string;
+    testType: PublicTestType;
+}
+export declare function normalizeRuntimeIsolationConfig(value: unknown, { name, suites }: RuntimeIsolationNormalizationOptions): NormalizedRuntimeIsolationConfig;
+export declare function resolveRuntimeIsolationPolicy<Policy extends string>(config: RuntimeIsolationResolverConfig<Policy>, suite: RuntimeIsolationResolutionSuite, filePath: string): Policy | RuntimeIsolationPolicy;

package/dist/config/loader/runtime-isolation.js

@@ -0,0 +1 @@
+import{matchesSuiteSelectors as P,parseSuiteSelectors as v}from"../../domain/suite-selection.js";import{isObjectRecord as y}from"./values.js";import{DEFAULT_RUNTIME_ISOLATION_POLICY as E,normalizeRuntimeIsolationPolicy as m}from"../../domain/runtime-isolation-contract.js";import{normalizePath as I}from"./paths.js";export{DEFAULT_RUNTIME_ISOLATION_POLICY,isRuntimeIsolationPolicy,normalizeRuntimeIsolationPolicy,RUNTIME_ISOLATION_POLICIES}from"../../domain/runtime-isolation-contract.js";const R=String;export function normalizeRuntimeIsolationConfig(e,{name:t,suites:d}){if(!e)return h();if(typeof e=="string")return{...h(),defaultPolicy:m(e,`Service "${t}" runtimeIsolation`)};if(!y(e))throw new Error(`Service "${t}" runtimeIsolation must be a policy string or object`);const l=[],f=new Set;for(const o of Object.values(d||{}))for(const r of o||[]){l.push({testType:r.testType,name:r.name});for(const s of r.files||[])f.add(I(s))}const c=e.default==null?E:m(e.default,`Service "${t}" runtimeIsolation.default`),u=[],a=new Set;for(const[o,r]of g(e.suites,`Service "${t}" runtimeIsolation.suites`).entries()){if(!y(r))throw new Error(`Service "${t}" runtimeIsolation.suites entries must be objects`);const s=r,i=R(s.selector||"").trim();if(!i)throw new Error(`Service "${t}" runtimeIsolation.suites[${o.toString()}] requires a selector`);const w=v([i]);if(w.length!==1)throw new Error(`Service "${t}" runtimeIsolation.suites["${i}"] is invalid`);const n=w[0];if(n.kind!=="typed")throw new Error(`Service "${t}" runtimeIsolation.suites["${i}"] must use a typed selector like ui:auth`);if(a.has(n.raw))throw new Error(`Service "${t}" defines duplicate runtimeIsolation.suites selector "${n.raw}"`);if(!l.some($=>P($.testType,$.name,[n])))throw new Error(`Service "${t}" runtimeIsolation.suites selector "${n.raw}" did not match any discovered suite`);a.add(n.raw),u.push({selector:n,policy:m(s.policy||s.runtimeIsolation,`Service "${t}" runtimeIsolation.suites["${n.raw}"].policy`)})}const p=[],S=new Set;for(const[o,r]of g(e.files,`Service "${t}" runtimeIsolation.files`).entries()){if(!y(r))throw new Error(`Service "${t}" runtimeIsolation.files entries must be objects`);const s=r,i=I(T(s.path,`Service "${t}" runtimeIsolation.files[${o.toString()}].path`));if(!i)throw new Error(`Service "${t}" runtimeIsolation.files[${o.toString()}] requires a path`);if(!f.has(i))throw new Error(`Service "${t}" runtimeIsolation.files["${i}"] did not match any discovered test file`);if(S.has(i))throw new Error(`Service "${t}" defines duplicate runtimeIsolation.files path "${i}"`);S.add(i),p.push({path:i,policy:m(s.policy||s.runtimeIsolation,`Service "${t}" runtimeIsolation.files["${i}"].policy`)})}return{defaultPolicy:c,suites:u,files:p,filePolicyByPath:new Map(p.map(o=>[o.path,o.policy]))}}export function resolveRuntimeIsolationPolicy(e,t,d){const l=I(d),f=e.testkit?.fileMetadataByPath?.get(l)||null,c=e.testkit?.runtimeIsolation||h(),u=f?.runtimeIsolation||c.filePolicyByPath.get(l);if(u)return u;for(const a of c.suites)if(P(t.testType,t.name,[a.selector]))return a.policy;return c.defaultPolicy}function h(){return{defaultPolicy:E,suites:[],files:[],filePolicyByPath:new Map}}function g(e,t){if(e==null)return[];if(!Array.isArray(e))throw new Error(`${t} must be an array`);return e}function T(e,t){if(e==null||typeof e=="string")return e;throw new Error(`${t} must be a string`)}

package/dist/config/loader/runtime.d.ts

@@ -0,0 +1,25 @@
+import { type ExecutionConfigInput, type NormalizedExecutionConfig } from "./execution-model.js";
+import { type NormalizedBuildConfig, type NormalizedBuildPrepareConfig } from "../../steps/build-config.js";
+import { type NormalizedRuntimeToolchain, type NormalizedToolchainRegistry } from "../../toolchains/index.js";
+export type { NormalizedNodeToolchainConfig, NormalizedRuntimeToolchain, NormalizedToolchainRegistry, } from "../../toolchains/index.js";
+export interface NormalizedRuntimeConfig {
+    build: NormalizedBuildConfig | null;
+    instances: number;
+    maxConcurrentTasks: number;
+    prepare: NormalizedBuildPrepareConfig;
+    toolchain: NormalizedRuntimeToolchain | null;
+}
+export interface InferredLocalRuntimeConfig {
+    baseUrl: string;
+    cwd: string;
+    env: Record<string, string>;
+    port: number;
+    readyUrl: string;
+    start: string;
+}
+export declare function inferLocalRuntime(productDir: string, cwd: string): InferredLocalRuntimeConfig | undefined;
+export declare function normalizeRuntimeConfig(value: unknown, serviceName: string, toolchains: NormalizedToolchainRegistry | null | undefined): NormalizedRuntimeConfig;
+export declare function normalizeRuntimePrepareConfig(value: unknown, serviceName: string): NormalizedBuildPrepareConfig;
+export declare function normalizeRepoExecution(execution: ExecutionConfigInput | null | undefined): NormalizedExecutionConfig;
+export declare function detectNextApp(cwd: string): boolean;
+export { normalizeConfiguredStep as normalizeTemplateLifecycleStep, normalizeConfiguredSteps as normalizeTemplateLifecycleSteps, normalizeOptionalString, parseModuleSpecifier, } from "../../steps/configured-steps.js";

package/dist/config/loader/runtime.js

@@ -0,0 +1 @@
+import n from"fs";import i from"path";import{DEFAULT_FILE_TIMEOUT_SECONDS as m}from"../../domain/file-timeout.js";import{normalizeExecutionConfig as a,normalizeRuntimeMaxConcurrentTasks as l,normalizeRuntimeInstances as f}from"./decode-execution.js";import"./execution-model.js";import{normalizeConfiguredInputs as S,normalizeConfiguredSteps as x}from"../../steps/configured-steps.js";import{buildConfigToPrepare as d,normalizeBuildConfig as h}from"../../steps/build-config.js";import{normalizeRuntimeToolchain as b}from"../../toolchains/index.js";import{resolveServiceCwd as C}from"./paths.js";export function inferLocalRuntime(e,r){const t=C(e,r);if(n.existsSync(t)){if(detectNextApp(t))return{cwd:r,start:"{bin:next} dev -p {port}",port:3e3,baseUrl:"http://127.0.0.1:{port}",readyUrl:"http://127.0.0.1:{port}",env:{}};if(n.existsSync(i.join(t,"cmd","server")))return{cwd:r,start:"go run ./cmd/server",port:3e3,baseUrl:"http://127.0.0.1:{port}",readyUrl:"http://127.0.0.1:{port}/health",env:{}};if(n.existsSync(i.join(t,"package.json"))&&n.existsSync(i.join(t,"src")))return{cwd:r,start:"{bin:tsx} watch src/index.ts",port:3e3,baseUrl:"http://127.0.0.1:{port}",readyUrl:"http://127.0.0.1:{port}/health",env:{}}}}export function normalizeRuntimeConfig(e,r,t){if(!e)return{build:null,instances:1,maxConcurrentTasks:Number.POSITIVE_INFINITY,prepare:{inputs:[],steps:[]},toolchain:null};const o=c(e)?e:{},s=h(o.build,`Service "${r}" runtime.build`),p=normalizeRuntimePrepareConfig(o.prepare,r),u=d(s);return{build:s,instances:f(o.instances??1,`Service "${r}" runtime.instances`),maxConcurrentTasks:l(o.maxConcurrentTasks,`Service "${r}" runtime.maxConcurrentTasks`),prepare:{inputs:[...new Set([...u.inputs,...p.inputs])],steps:[...u.steps,...p.steps]},toolchain:b(o.toolchain,`Service "${r}" runtime.toolchain`,t||{})}}export function normalizeRuntimePrepareConfig(e,r){if(e==null)return{inputs:[],steps:[]};if(!c(e))throw new Error(`Service "${r}" runtime.prepare must be an object`);return{inputs:S(e.inputs,`Service "${r}" runtime.prepare`),steps:x(e.steps,`Service "${r}" runtime.prepare.steps`)}}export function normalizeRepoExecution(e){return e?a(e):a({workers:1,fileTimeoutSeconds:m})}export function detectNextApp(e){return n.existsSync(i.join(e,"next.config.js"))||n.existsSync(i.join(e,"next.config.mjs"))||n.existsSync(i.join(e,"next.config.ts"))}function c(e){return e!==null&&typeof e=="object"}export{normalizeConfiguredStep as normalizeTemplateLifecycleStep,normalizeConfiguredSteps as normalizeTemplateLifecycleSteps,normalizeOptionalString,parseModuleSpecifier}from"../../steps/configured-steps.js";

package/dist/config/loader/skip-config.d.ts

@@ -0,0 +1,44 @@
+import type { EngineId, PublicTestType, RunnerProfileId } from "../../domain/identifiers.js";
+import { type SuiteSelector, type TypedSuiteSelector } from "../../domain/suite-selection.js";
+export interface SelectableSuite {
+    engineId: EngineId;
+    files: readonly string[];
+    name: string;
+    profileId: RunnerProfileId;
+    testType: PublicTestType;
+}
+export type ServiceSuiteCollection = Readonly<Partial<Record<PublicTestType, null | readonly SelectableSuite[] | undefined>>>;
+export interface SkipConfigNormalizationContext {
+    name: string;
+    suites: ServiceSuiteCollection;
+}
+export interface NormalizedSkipFileRule {
+    path: string;
+    reason: string;
+}
+export interface NormalizedSkipSuiteRule {
+    reason: string;
+    selector: SuiteSelector;
+}
+export interface NormalizedSkipConfig {
+    fileReasonByPath: Map<string, string>;
+    files: NormalizedSkipFileRule[];
+    suites: NormalizedSkipSuiteRule[];
+}
+export interface NormalizedRequirementFileRule {
+    locks: string[];
+    path: string;
+}
+export interface NormalizedRequirementSuiteRule {
+    locks: string[];
+    selector: TypedSuiteSelector;
+}
+export interface NormalizedServiceRequirements {
+    fileLocksByPath: Map<string, string[]>;
+    files: NormalizedRequirementFileRule[];
+    suites: NormalizedRequirementSuiteRule[];
+}
+export declare function normalizeSkipReason(reason: unknown, label: string): string;
+export declare function normalizeSkipConfig(value: unknown, { name, suites }: Readonly<SkipConfigNormalizationContext>): NormalizedSkipConfig | undefined;
+export declare function normalizeServiceRequirements(value: unknown, { name, suites }: Readonly<SkipConfigNormalizationContext>): NormalizedServiceRequirements;
+export declare function normalizeRequirementLocks(value: unknown, label: string): string[];

package/dist/config/loader/skip-config.js

@@ -0,0 +1 @@
+import{isObjectRecord as y}from"./values.js";import{matchesSuiteSelectors as k,parseSuiteSelectors as q}from"../../domain/suite-selection.js";import{normalizePath as E}from"./paths.js";const S=String;export function normalizeSkipReason(s,e){const u=S(s||"").trim();if(!u)throw new Error(`${e} requires a non-empty reason`);return u}export function normalizeSkipConfig(s,{name:e,suites:u}){if(!s)return;const f=b(s,`Service "${e}" skip`),l=new Set,a=[];for(const t of Object.values(u))for(const i of t||[]){a.push({testType:i.testType,name:i.name});for(const r of i.files)l.add(E(r))}const c=new Set,p=[];for(const t of m(f.files,`Service "${e}" skip.files`)){const i=$(t,`Service "${e}" skip.files entries must be objects`),r=E(typeof i.path=="string"?i.path:void 0),o=normalizeSkipReason(i.reason,`Service "${e}" skip.files["${r}"]`);if(!r)throw new Error(`Service "${e}" skip.files entries require a non-empty path`);if(c.has(r))throw new Error(`Service "${e}" defines duplicate skip.files path "${r}"`);if(!l.has(r))throw new Error(`Service "${e}" skip.files path "${r}" did not match any discovered suite file`);c.add(r),p.push({path:r,reason:o})}const d=m(f.suites,`Service "${e}" skip.suites`).map((t,i)=>{const r=$(t,`Service "${e}" skip.suites entries must be objects`),o=S(r.selector||"").trim();if(!o)throw new Error(`Service "${e}" skip.suites[${String(i)}] requires a non-empty selector`);const v=normalizeSkipReason(r.reason,`Service "${e}" skip.suites["${o}"]`),w=q([o]),g=w[0];if(w.length!==1)throw new Error(`Service "${e}" skip.suites["${o}"] is invalid`);return{selector:g,reason:v}}),h=new Set,n=[];for(const t of d){if(h.has(t.selector.raw))throw new Error(`Service "${e}" defines duplicate skip.suites selector "${t.selector.raw}"`);if(!a.some(r=>k(r.testType,r.name,[t.selector])))throw new Error(`Service "${e}" skip.suites selector "${t.selector.raw}" did not match any discovered suite`);h.add(t.selector.raw),n.push(t)}if(!(p.length===0&&n.length===0))return{files:p,fileReasonByPath:new Map(p.map(t=>[t.path,t.reason])),suites:n}}export function normalizeServiceRequirements(s,{name:e,suites:u}){if(!s)return R();const f=b(s,`Service "${e}" requirements`),l=[],a=new Set;for(const n of Object.values(u))for(const t of n||[]){l.push({testType:t.testType,name:t.name});for(const i of t.files)a.add(i)}const c=[],p=new Set;for(const n of m(f.suites,`Service "${e}" requirements.suites`)){const t=$(n,`Service "${e}" requirements.suites entries must be objects`),i=S(t.selector||"").trim();if(!i)throw new Error(`Service "${e}" requirements.suites entries require a selector`);const r=q([i]),o=r[0];if(r.length!==1)throw new Error(`Service "${e}" requirements.suites["${i}"] is invalid`);if(o.kind!=="typed")throw new Error(`Service "${e}" requirements.suites["${i}"] must use a typed selector like int:health`);if(p.has(o.raw))throw new Error(`Service "${e}" defines duplicate requirements.suites selector "${o.raw}"`);if(!l.some(w=>k(w.testType,w.name,[o])))throw new Error(`Service "${e}" requirements.suites selector "${o.raw}" did not match any discovered suite`);p.add(o.raw),c.push({selector:o,locks:normalizeRequirementLocks(t.locks,`Service "${e}" requirements.suites["${o.raw}"].locks`)})}const d=[],h=new Set;for(const[n,t]of m(f.files,`Service "${e}" requirements.files`).entries()){const i=$(t,`Service "${e}" requirements.files entries must be objects`),r=S(i.path||"").trim();if(!r)throw new Error(`Service "${e}" requirements.files[${String(n)}] requires a path`);if(!a.has(r))throw new Error(`Service "${e}" requirements.files["${r}"] did not match any discovered test file`);if(h.has(r))throw new Error(`Service "${e}" defines duplicate requirements.files path "${r}"`);h.add(r),d.push({path:r,locks:normalizeRequirementLocks(i.locks,`Service "${e}" requirements.files["${r}"].locks`)})}return{suites:c,files:d,fileLocksByPath:new Map(d.map(n=>[n.path,n.locks]))}}export function normalizeRequirementLocks(s,e){const u=Array.isArray(s)?s:s==null?[]:[s],f=new Set,l=[];for(const a of u){const c=S(a||"").trim();if(!c)throw new Error(`${e} entries must be non-empty strings`);f.has(c)||(f.add(c),l.push(c))}return l.sort()}function R(){return{suites:[],files:[],fileLocksByPath:new Map}}function b(s,e){if(!y(s))throw new Error(`${e} must be an object`);return s}function $(s,e){if(!y(s))throw new Error(e);return s}function m(s,e){if(s==null)return[];if(!Array.isArray(s))throw new Error(`${e} must be an array`);return s}

package/dist/config/loader/validation.d.ts

@@ -0,0 +1,16 @@
+import type { NormalizedLoadedDatabaseConfig, NormalizedLocalServiceConfig, NormalizedServiceConfig } from "./load.js";
+import type { NormalizedRuntimeConfig } from "./runtime.js";
+import type { ServiceSuiteCollection } from "./skip-config.js";
+export interface ServiceConfigValidationInput {
+    database: NormalizedLoadedDatabaseConfig | undefined;
+    databaseFrom: string | undefined;
+    dependsOn: readonly string[];
+    local: NormalizedLocalServiceConfig | undefined;
+    name: string;
+    productDir: string;
+    requireLocalRuntime?: boolean;
+    runtime: NormalizedRuntimeConfig;
+    suites: ServiceSuiteCollection;
+}
+export declare function validateConfigCoverage(configs: readonly NormalizedServiceConfig[]): void;
+export declare function validateServiceConfig({ name, local, database, databaseFrom, runtime, dependsOn, suites, productDir, requireLocalRuntime, }: Readonly<ServiceConfigValidationInput>): void;

package/dist/config/loader/validation.js

@@ -0,0 +1 @@
+import{validateConfiguredCollection as f}from"../../steps/configured-steps.js";import{resolveEngineProfile as $}from"../../engines/catalog.js";import{ensureExistingContainedPath as m,ensureExistingPath as h}from"./paths.js";const S=["migrate","seed","verify"];export function validateConfigCoverage(e){const n=new Set(e.map(t=>t.name));for(const t of e){for(const r of t.testkit.dependsOn)if(!n.has(r))throw new Error(`Service "${t.name}" depends on "${r}", but ${r} is not defined`);const s=t.testkit.databaseFrom;if(s&&!n.has(s))throw new Error(`Service "${t.name}" databaseFrom "${s}" is not defined`)}}export function validateServiceConfig({name:e,local:n,database:t,databaseFrom:s,runtime:r,dependsOn:d,suites:p,productDir:a,requireLocalRuntime:l=!0}){const w=Object.entries(p).some(([o,v])=>(v||[]).some(i=>{if(i.testType!==o)throw new Error(`Service "${e}" suite ${o}:${i.name} declares conflicting test type ${i.testType}`);const c=$(i.testType,i.engineId);if(c.id!==i.profileId)throw new Error(`Service "${e}" suite ${i.testType}:${i.name} declares conflicting engine profile ${i.profileId}; expected ${c.id}`);return c.capabilities.applicationRuntime==="required"}));if(l&&w&&!n)throw new Error(`Service "${e}" defines suites whose engine profile requires an application runtime, but no local runtime could be resolved. Add it in testkit.config.ts.`);if(t&&s)throw new Error(`Service "${e}" cannot define both database and databaseFrom`);if(r.instances<1)throw new Error(`Service "${e}" runtime.instances must be a positive integer`);if(r.maxConcurrentTasks<=0)throw new Error(`Service "${e}" runtime.maxConcurrentTasks must be a positive integer when provided`);for(const o of d)if(o===e)throw new Error(`Service "${e}" cannot depend on itself`);if(n?.cwd&&h(a,n.cwd,`Service "${e}" local.cwd`),r.toolchain?.cwd&&m(a,r.toolchain.cwd,`Service "${e}" runtime.toolchain.cwd`),t)for(const o of S)f({productDir:a,label:`Service "${e}" database.template.${o}`,steps:t.template[o]});f({productDir:a,label:`Service "${e}" database.template`,inputs:t?.template.inputs||[]}),f({productDir:a,label:`Service "${e}" runtime.prepare`,inputs:r.prepare.inputs,steps:r.prepare.steps})}

package/dist/config/loader/values.d.ts

@@ -0,0 +1,4 @@
+export declare function isObjectRecord(value: unknown): value is Record<string, unknown>;
+export declare function isObjectLike(value: unknown): value is object;
+export declare function readProperty(value: unknown, key: string): unknown;
+export declare function readObjectRecord(value: unknown): Record<string, unknown>;

package/dist/config/loader/values.js

@@ -0,0 +1 @@
+export function isObjectRecord(t){return typeof t=="object"&&t!==null&&!Array.isArray(t)}export function isObjectLike(t){return typeof t=="object"&&t!==null||typeof t=="function"}export function readProperty(t,r){return isObjectLike(t)?Reflect.get(t,r):void 0}export function readObjectRecord(t){return isObjectRecord(t)?t:{}}

package/dist/config/runtime/build-assets.d.ts

@@ -0,0 +1,6 @@
+export interface CopyTscRuntimeAssetsContext {
+    args?: unknown;
+    cwd: string;
+    prepareDir?: string | null;
+}
+export declare function copyTscRuntimeAssets(context: Readonly<CopyTscRuntimeAssetsContext>): Promise<void>;

package/dist/config/runtime/build-assets.js

@@ -0,0 +1 @@
+import s from"fs";import n from"path";const h=new Set([".csv",".css",".gql",".graphql",".html",".json",".md",".sql",".txt",".wasm",".yaml",".yml"]),f=String;export function copyTscRuntimeAssets(t){return new Promise(e=>{d(t),e()})}function d(t){if(!t.prepareDir)throw new Error("copyTscRuntimeAssets requires a runtime prepare directory");const e=D(t.args),r=m(o(e.sourceDir,"src"),"sourceDir"),i=m(o(e.outDir,"dist"),"outDir"),y=S(e.extensions),c=n.resolve(t.cwd,r),w=n.resolve(t.prepareDir,i);if(s.existsSync(c))for(const u of p(c)){const a=n.relative(c,u);if(g(a,y))continue;const l=n.join(w,a);s.mkdirSync(n.dirname(l),{recursive:!0}),s.copyFileSync(u,l)}}function D(t){return typeof t!="object"||t===null?{}:{extensions:Reflect.get(t,"extensions"),outDir:Reflect.get(t,"outDir"),sourceDir:Reflect.get(t,"sourceDir")}}function m(t,e){const r=f(o(t,"")).trim();if(!r)throw new Error(`${e} must be a non-empty relative path`);if(n.isAbsolute(r)||r.split(n.sep).includes(".."))throw new Error(`${e} must be a relative path inside the service cwd`);return r}function S(t){if(t==null)return h;if(!Array.isArray(t))throw new Error("extensions must be an array");return new Set(t.map((e,r)=>{const i=f(o(e,"")).trim().toLowerCase();if(!/^\.[a-z0-9]+$/i.test(i))throw new Error(`extensions[${String(r)}] must look like ".json"`);return i}))}function o(t,e){return!!t?t:e}function g(t,e){const r=t.split(n.sep).join("/");return r.includes("/__testkit__/")||r.startsWith("__testkit__/")||/(^|\/)[^/]+\.test\.[^/]+$/i.test(r)||/(^|\/)[^/]+\.spec\.[^/]+$/i.test(r)?!0:!e.has(n.extname(r).toLowerCase())}function*p(t){for(const e of s.readdirSync(t,{withFileTypes:!0})){const r=n.join(t,e.name);if(e.isDirectory()){yield*p(r);continue}e.isFile()&&(yield r)}}

package/dist/config/runtime/env/index.d.ts

@@ -0,0 +1,35 @@
+export interface LoadDotenvFilesOptions {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    files?: string[];
+    onlyWhenAllowed?: boolean;
+    override?: boolean;
+}
+export interface PostgresConnectionEnvFallback {
+    database?: string;
+    host?: string;
+    password?: string;
+    port?: number | string;
+    ssl?: boolean;
+    username?: string;
+}
+export interface PostgresConnectionEnvOptions {
+    env?: NodeJS.ProcessEnv;
+    fallback?: PostgresConnectionEnvFallback;
+}
+export interface PostgresConnectionEnvValue {
+    database: string;
+    host: string;
+    password: string;
+    port: number;
+    ssl: boolean;
+    username: string;
+}
+export declare function isManagedRuntime(env?: NodeJS.ProcessEnv): boolean;
+export declare function managedRuntimeMode(env?: NodeJS.ProcessEnv): null | string;
+export declare function shouldLoadDotenv(env?: NodeJS.ProcessEnv): boolean;
+export declare function loadDotenvFiles(options?: LoadDotenvFilesOptions): {
+    loaded: string[];
+};
+export declare function assertLocalDatabaseUrl(env?: NodeJS.ProcessEnv, consumer?: string): void;
+export declare function readPostgresConnectionFromEnv(prefix: string, options?: PostgresConnectionEnvOptions): PostgresConnectionEnvValue;

package/dist/config/runtime/env/index.js

@@ -0,0 +1 @@
+import u from"fs";import f from"path";import{parseDotenvString as v}from"../../../process/files/dotenv.js";const w=new Set(["localhost","127.0.0.1","::1"]),A=new Set(["postgres:","postgresql:"]),d=[".env",".env.local"],c=String;export function isManagedRuntime(e=process.env){return e.TESTKIT_ACTIVE==="1"}export function managedRuntimeMode(e=process.env){return isManagedRuntime(e)?e.TESTKIT_MODE||"test":null}export function shouldLoadDotenv(e=process.env){return e.NODE_ENV!=="production"&&!isManagedRuntime(e)}export function loadDotenvFiles(e={}){const t=e.env||process.env;if(e.onlyWhenAllowed!==!1&&!shouldLoadDotenv(t))return{loaded:[]};const n=f.resolve(e.cwd||process.cwd()),r=e.override!==!1,o=T(e.files),s=[];for(const p of o){const i=f.resolve(n,p);if(!u.existsSync(i))continue;const m=v(u.readFileSync(i,"utf8"));for(const[l,E]of Object.entries(m))(r||t[l]==null)&&(t[l]=E);s.push(i)}return{loaded:s}}function T(e){if(e===void 0)return d;if(!Array.isArray(e))throw new Error("loadDotenvFiles options.files must be an array of non-empty strings");if(e.length===0)return d;const t=Array.from(e);if(!t.every(n=>typeof n=="string"&&n.trim().length>0))throw new Error("loadDotenvFiles options.files must be an array of non-empty strings");return t}export function assertLocalDatabaseUrl(e=process.env,t="This command"){if(!isManagedRuntime(e))return;const n=e.DATABASE_URL;if(!n)throw new Error(`${t} requires DATABASE_URL when TESTKIT_ACTIVE=1.`);let r;try{r=new URL(n)}catch{throw new Error(`${t} requires a valid DATABASE_URL when TESTKIT_ACTIVE=1.`)}if(!A.has(r.protocol)||!w.has(r.hostname)){const o=`${r.protocol}//${r.hostname}${r.port?`:${r.port}`:""}`;throw new Error(`${t} managed Testkit runtime requires a local PostgreSQL DATABASE_URL. Refusing ${o}.`)}}export function readPostgresConnectionFromEnv(e,t={}){const n=t.env||process.env,r=c(e||"").trim();if(!r)throw new Error("readPostgresConnectionFromEnv requires an environment variable prefix");const o=t.fallback||{};return{host:a(n,`${r}_HOST`,o.host),port:h(n,`${r}_PORT`,o.port),database:a(n,`${r}_NAME`,o.database),username:a(n,`${r}_USER`,o.username),password:a(n,`${r}_PASSWORD`,o.password),ssl:S(n,`${r}_SSL`,o.ssl??!1)}}function a(e,t,n){const r=e[t]?.trim();if(r)return r;const o=c(n??"").trim();if(n!=null&&o)return o;throw new Error(`${t} environment variable is required`)}function h(e,t,n){const o=e[t]?.trim()||(n==null?"":c(n)),s=Number.parseInt(o,10);if(!Number.isInteger(s)||s<=0)throw new Error(`${t} must be a positive integer`);return s}function S(e,t,n){const r=e[t];if(!r)return!!n;switch(r.trim().toLowerCase()){case"1":case"true":case"yes":case"on":return!0;case"0":case"false":case"no":case"off":return!1;default:return!!n}}

package/dist/config/runtime/next-runtime-tsconfig.d.ts

@@ -0,0 +1,6 @@
+export interface NextRuntimeTsconfigContext {
+    cwd?: string;
+    productDir?: string;
+    runtimeId?: string | null;
+}
+export declare function writeNextRuntimeTsconfig(context?: NextRuntimeTsconfigContext): Promise<void>;

package/dist/config/runtime/next-runtime-tsconfig.js

@@ -0,0 +1,2 @@
+import d from"fs";import t from"path";export async function writeNextRuntimeTsconfig(n={}){const i=n.cwd??n.productDir,o=n.runtimeId;if(!i||!o)throw new Error("writeNextRuntimeTsconfig requires cwd and runtimeId");const u=t.join(i,".next-testkit",o),r=t.join(u,"tsconfig.json"),c=t.dirname(r),e=a=>t.relative(c,a).replaceAll(t.sep,"/"),s=t.join(i,"src"),m=t.join(i,"tests"),p={extends:e(t.join(i,"tsconfig.json")),compilerOptions:{paths:{"@/*":[e(t.join(s,"*"))]}},include:[e(t.join(i,"next-env.d.ts")),`${e(s)}/**/*.ts`,`${e(s)}/**/*.tsx`,`${e(s)}/**/*.mts`,"dist/types/**/*.ts","dist/dev/types/**/*.ts"],exclude:["node_modules",`${e(s)}/**/__testkit__/**`,`${e(m)}/**`,".next/cache",".next/dev"]};await d.promises.mkdir(c,{recursive:!0}),await d.promises.writeFile(r,`${JSON.stringify(p,null,2)}
+`)}

package/dist/database/activity-gate.d.ts

@@ -0,0 +1,22 @@
+export interface UserHostLocalPostgresActivityLocation {
+    readonly homeDirectory: string;
+    readonly hostname: string;
+    readonly uid: number;
+    readonly username: string;
+}
+export interface UserHostLocalPostgresActivityPaths {
+    readonly activityDirectory: string;
+    readonly productsDirectory: string;
+}
+export interface UserHostLocalPostgresActivityOptions {
+    /**
+     * Immutable identity captured by an owning caller. Ordinary runtime callers
+     * omit this and use the authoritative OS identity at the coordination seam.
+     */
+    readonly location?: Readonly<UserHostLocalPostgresActivityLocation>;
+    readonly signal?: AbortSignal;
+}
+/** Serializes local Postgres mutations for one canonical product. */
+export declare function withUserHostLocalPostgresActivity<Result>(productDir: string, operation: () => Result | PromiseLike<Result>, options?: Readonly<UserHostLocalPostgresActivityOptions>): Promise<Result>;
+export declare function resolveUserHostLocalPostgresActivityPaths({ homeDirectory, hostname, uid, username, }: Readonly<UserHostLocalPostgresActivityLocation>): UserHostLocalPostgresActivityPaths;
+export declare function readSystemUserHostLocalPostgresActivityLocation(): UserHostLocalPostgresActivityLocation;

package/dist/database/activity-gate.js

@@ -0,0 +1 @@
+import{AsyncLocalStorage as p}from"node:async_hooks";import n from"node:fs";import h from"node:os";import c from"node:path";import{withProcessLock as E}from"../process/locks.js";import{hashString as u}from"./naming.js";const S=Object.freeze([".testkit","_locks","local-postgres"]),P=448,m=18,f=new p;export async function withUserHostLocalPostgresActivity(t,o,e={}){$();const r=e.location??readSystemUserHostLocalPostgresActivityLocation(),s=D(r),i=L(s.productsDirectory,t);return f.run(!0,()=>E(i,o,{hostScope:"current-host",signal:e.signal}))}export function resolveUserHostLocalPostgresActivityPaths({homeDirectory:t,hostname:o,uid:e,username:r}){const s=c.resolve(a(t,"home directory")),i=a(o,"hostname").trim().toLowerCase(),l=a(r,"username").trim().toLowerCase();if(!Number.isSafeInteger(e))throw new Error("Local Postgres activity gate requires a valid user ID");const w=e>=0?`uid:${e.toString()}`:`username:${l}`,y=c.join(s,...S,`host-${u(i,24)}-user-${u(w,24)}`);return Object.freeze({activityDirectory:y,productsDirectory:c.join(y,"products")})}export function readSystemUserHostLocalPostgresActivityLocation(){const t=h.userInfo();return{homeDirectory:t.homedir,hostname:h.hostname(),uid:t.uid,username:t.username}}function D(t){const o=k(t.homeDirectory,t.uid),e=resolveUserHostLocalPostgresActivityPaths({...t,homeDirectory:o});let r=o;const s=c.relative(o,e.activityDirectory).split(c.sep);for(const i of s)r=v(c.join(r,i),o,t.uid);return v(e.productsDirectory,o,t.uid),e}function L(t,o){const e=n.realpathSync.native(c.resolve(a(o,"product directory")));return c.join(t,`product-${u(e,24)}.lock`)}function k(t,o){const e=c.resolve(a(t,"home directory"));if(!n.statSync(e).isDirectory())throw new Error(`Cannot use non-directory home for the local Postgres activity gate: ${e}`);const s=n.realpathSync.native(e);return d(s,!1,o),s}function v(t,o,e){let r;try{r=n.lstatSync(t)}catch(i){if(!g(i,"ENOENT"))throw i;try{n.mkdirSync(t,{mode:P})}catch(l){if(!g(l,"EEXIST"))throw l}r=n.lstatSync(t)}if(!r.isDirectory()||r.isSymbolicLink())throw new Error(`Local Postgres activity lock ancestor is not a real directory: ${t}`);const s=n.realpathSync.native(t);return A(s,o),d(s,!0,e),s}function d(t,o,e){if(e<0)return;let r=n.lstatSync(t);if(r.uid!==e)throw new Error(`Local Postgres activity lock ancestor is not owned by the current user: ${t}`);if((r.mode&m)!==0){if(!o)throw new Error(`Local Postgres activity lock ancestor is writable by another user: ${t}`);if(n.chmodSync(t,r.mode&511&~m),r=n.lstatSync(t),(r.mode&m)!==0)throw new Error(`Could not secure local Postgres activity lock ancestor: ${t}`)}}function A(t,o){const e=c.relative(o,t);if(e===".."||e.startsWith(`..${c.sep}`)||c.isAbsolute(e))throw new Error(`Local Postgres activity lock escaped the user home: ${t}`)}function $(){if(f.getStore()!==void 0)throw new Error("Nested local Postgres activity is not allowed")}function a(t,o){if(t.trim().length===0)throw new Error(`Local Postgres activity gate requires a ${o}`);return t}function g(t,o){return typeof t=="object"&&t!==null&&"code"in t&&Reflect.get(t,"code")===o}

package/dist/database/admin.d.ts

@@ -0,0 +1,31 @@
+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/admin.js

@@ -0,0 +1,2 @@
+import{randomUUID as T}from"node:crypto";import{managedHostProcessInfrastructureError as g,runManagedHostProcess as E}from"../process/index.js";import{LOCAL_ADMIN_DB as u,LOCAL_ADMIN_QUERY_RETRY_INTERVAL_MS as f,LOCAL_ADMIN_QUERY_RETRY_MS as S,LOCAL_DROP_DATABASE_POLL_INTERVAL_MS as O,LOCAL_DROP_DATABASE_TIMEOUT_MS as R}from"./constants.js";import{buildDatabaseUrl as y,escapeIdentifier as c,escapeSqlLiteral as l}from"./naming.js";import{runDockerPsql as b}from"./postgres/index.js";export{y as buildDatabaseUrl};export const ADMIN_QUERY_COMMAND_TIMEOUT_MS=15e3;export async function databaseExists(t,e,o={}){return(await runAdminQuery(t,["-tAc",`SELECT 1 FROM pg_database WHERE datname = '${l(e)}'`],o)).trim()==="1"}export async function createEmptyDatabase(t,e,o={}){await runAdminQuery(t,["-c",`CREATE DATABASE "${c(e)}"`],o)}export async function cloneDatabaseFromTemplate(t,e,o,r={}){await runAdminQuery(t,["-c",`CREATE DATABASE "${c(e)}" TEMPLATE "${c(o)}"`],r)}export async function dropDatabaseIfExists(t,e,o={}){await dropDatabaseWithForceOrDrain(t,e,o)}export async function dropDatabaseWithForceOrDrain(t,e,o={}){const r={signal:o.signal};try{await runAdminQuery(t,["-c",`DROP DATABASE IF EXISTS "${c(e)}" WITH (FORCE)`],r);return}catch(n){if(!M(n))throw n}if(!await databaseExists(t,e,r))return;let s=!1;try{await runAdminQuery(t,["-c",`ALTER DATABASE "${c(e)}" WITH ALLOW_CONNECTIONS false`],r),s=!0,await waitForDatabaseConnectionsToDrain(t,e,{signal:o.signal}),await runAdminQuery(t,["-c",`DROP DATABASE IF EXISTS "${c(e)}"`],r),s=!1}finally{s&&await databaseExists(t,e)&&await runAdminQuery(t,["-c",`ALTER DATABASE "${c(e)}" WITH ALLOW_CONNECTIONS true`]).catch(()=>{})}}export async function waitForDatabaseConnectionsToDrain(t,e,o={}){const r=o.timeoutMs??R,s=Date.now()+r,n={signal:o.signal};for(;;){D(o.signal),await C(t,e,n);const i=await L(t,e,n);if(i===0)return;if(Date.now()>=s)throw new Error(`Timed out waiting for database "${e}" connections to close (${String(i)} remaining)`);await A(O,o.signal)}}export async function runAdminQuery(t,e,o={}){const r=buildAdminQueryCommandArgs(t,e),s=Date.now();for(;;){D(o.signal);try{let n;if(_(t)){const a=`testkit-admin-${T()}`,d=await E({args:["exec","-e",`PGAPPNAME=${a}`,...r.slice(1)],cwd:process.cwd(),displayLabel:`Docker Postgres admin query for ${t.containerName}`,env:process.env,executable:"docker",signal:o.signal,timeoutMs:ADMIN_QUERY_COMMAND_TIMEOUT_MS});d.cancelled&&await E({args:buildAdminQueryCommandArgs(t,["-tAc",`SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE application_name = '${a}'`]),cwd:process.cwd(),displayLabel:`Docker Postgres admin query cancellation for ${t.containerName}`,env:process.env,executable:"docker",timeoutMs:ADMIN_QUERY_COMMAND_TIMEOUT_MS});const m=g(`Docker Postgres admin query for ${t.containerName}`,d);if(m)throw m;n={exitCode:d.exitCode,stderr:d.stderr,stdout:d.stdout}}else{const a={...process.env,PGPASSWORD:t.password,...t.sslMode?{PGSSLMODE:t.sslMode}:{}};n=await b({args:r,env:a,timeoutMs:ADMIN_QUERY_COMMAND_TIMEOUT_MS,connection:{host:t.host,port:t.port,user:t.user,password:t.password,database:t.adminDatabase||u,sslMode:t.sslMode},signal:o.signal})}if(n.exitCode!=null&&n.exitCode!==0){const a=new Error(n.shortMessage||n.stderr||n.stdout||`psql failed with exit code ${String(n.exitCode)}`);throw Reflect.set(a,"stdout",n.stdout||""),Reflect.set(a,"stderr",n.stderr||""),a}const{stdout:i}=n;return i}catch(n){if(Date.now()-s>=S||!isTransientAdminQueryConnectionError(n))throw n;await A(f,o.signal)}}}export function buildAdminQueryCommandArgs(t,e){return _(t)?["exec","-e",`PGPASSWORD=${t.password}`,t.containerId,"psql","-v","ON_ERROR_STOP=1","-U",t.user,"-d",t.adminDatabase||u,"-p",String(t.containerPort||5432),...e]:["-v","ON_ERROR_STOP=1","-h",t.host,"-p",String(t.port),"-U",t.user,"-d",t.adminDatabase||u,...e]}export function isTransientAdminQueryConnectionError(t){const e=w(t);return e.includes('connection to server on socket "/var/run/postgresql/.s.PGSQL.5432" failed')||e.includes("No such file or directory")||e.includes("the database system is starting up")||e.includes("could not connect to server")||e.includes("connection refused")||e.includes("Connection timed out")||e.includes("connection timed out")||e.includes("Operation timed out")||e.includes("i/o timeout")||e.includes("server closed the connection unexpectedly")||e.includes("terminating connection due to administrator command")}async function C(t,e,o){await runAdminQuery(t,["-c",["SELECT pg_terminate_backend(pid)","FROM pg_stat_activity",`WHERE datname = '${l(e)}' AND pid <> pg_backend_pid();`].join(" ")],o)}async function L(t,e,o){const r=await runAdminQuery(t,["-tAc",["SELECT COUNT(*)","FROM pg_stat_activity",`WHERE datname = '${l(e)}' AND pid <> pg_backend_pid();`].join(" ")],o);return Number.parseInt(r.trim(),10)||0}function M(t){const e=w(t);return e.includes('syntax error at or near "WITH"')||e.includes('option "force"')}function A(t,e){return new Promise((o,r)=>{if(e?.aborted){r(p(e));return}const s=setTimeout(n,t);e?.addEventListener("abort",i,{once:!0});function n(){e?.removeEventListener("abort",i),o()}function i(){clearTimeout(s),r(e?p(e):new Error("Database administration aborted"))}})}function D(t){if(t?.aborted)throw p(t)}function p(t){return t.reason instanceof Error?t.reason:new Error("Database administration aborted",{cause:t.reason})}function w(t){return["shortMessage","stderr","stdout","message"].map(e=>P(x(t,e)||"")).join(`
+`)}function x(t,e){if(!(typeof t!="object"&&typeof t!="function"||t===null))return Reflect.get(t,e)}function P(t){if(typeof t=="symbol")throw new TypeError("Cannot convert a Symbol value to a string");return String(t)}function _(t){return!!t.containerName}

package/dist/database/cleanup.d.ts

@@ -0,0 +1,36 @@
+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/cleanup.js

@@ -0,0 +1 @@
+import{hasActiveRunManifest as A,hasActiveRunManifestWithTerminalAuthority as v}from"../process/runs/ownership.js";import{observeProcessCreationIdentity as l}from"../process/index.js";import{TESTKIT_PRODUCT_ID_LABEL as y,TESTKIT_RESOURCE_KIND_LABEL as g,TESTKIT_SCOPE_LABEL as k,buildProductIdentity as T,listManagedDockerContainers as L,listManagedDockerVolumes as P,removeDockerContainer as C,removeDockerVolume as w,stopDockerContainer as E}from"./docker.js";import{requireProductLifecycleFenceProductDir as i}from"../process/lifecycle-fence.js";import{hasRemainingLocalArtifacts as D,readOwnedStateValues as R}from"./state.js";export async function cleanupLocalPostgresDockerResources(e={}){return f({...e,force:!1})}export async function destroyLocalPostgresDockerResources(e,r={}){const t=i(e);return f({...r,assertMutationAuthority:()=>{if(i(e)!==t)throw new Error("Database destroy lifecycle authority changed products")},force:!0,productDir:t})}export async function cleanupTerminalRunLocalPostgresDockerResources(e,r,t={}){const s=i(e),a=()=>{assertTerminalRunDatabaseCleanupAuthority(e,r)};return a(),f({...t,assertMutationAuthority:a,force:!1,productDir:s,terminalRunAuthority:r})}export function assertTerminalRunDatabaseCleanupAuthority(e,r){const t=i(e);if(v(t,l,r))throw new Error(`Cannot clean terminal Testkit run ${r.runId} database resources while another product run is active or its terminal ownership is invalid`)}async function f(e){e.assertMutationAuthority?.();const r=T(e.productDir||process.cwd()),t=await L(r),s=await P(r),a=[],u=[],d=[],c=[],h=[];for(const o of t){if(!I(o))continue;const n=M(o,r,e);n.action==="remove"?a.push({...o,action:"remove",reason:n.reason}):n.action==="stop"?a.push({...o,action:"stop",reason:n.reason}):n.reason&&u.push({...o,reason:n.reason})}for(const o of s){if(!S(o))continue;const n=_(o,r,e);n.action==="remove"?a.push({...o,action:"remove",reason:n.reason,resourceType:"volume"}):n.reason&&u.push({...o,reason:n.reason,resourceType:"volume"})}if(!e.dryRun)for(const o of a)e.assertMutationAuthority?.(),o.action==="stop"?await E(o.id,o.name)?h.push(o):c.push(p(o)):o.resourceType==="volume"?await w(o.name,o)?d.push(o):c.push(p(o)):await C(o.id,o.name)?d.push(o):c.push(p(o));return{removed:e.dryRun?[]:d,stopped:e.dryRun?[]:h,skipped:e.dryRun?[]:c,targets:a,kept:u}}function p(e){return e.resourceType==="volume"?{...e,action:"skip",intendedAction:"remove",reason:"resource-changed-or-disappeared-before-mutation",selectionReason:e.reason}:{...e,action:"skip",intendedAction:e.action==="stop"?"stop":"remove",reason:"resource-changed-or-disappeared-before-mutation",selectionReason:e.reason}}function M(e,r,t){return e.labels[y]!==r.id?{action:"keep",reason:"different-product"}:t.force?{action:"remove",reason:"destroy-current-product"}:m(r.dir,t)?{action:"keep",reason:"current-product-active"}:D(r.dir)?R(r.dir,["container_name","local_container_name"]).has(e.name)?b(e,r.dir,t)?{action:"stop",reason:"current-product-idle"}:{action:"keep",reason:"current-product-referenced"}:{action:"remove",reason:"current-product-unreferenced"}:{action:"remove",reason:"current-product-no-local-artifacts"}}function _(e,r,t){return e.labels[y]!==r.id?{action:"keep",reason:"different-product"}:t.force?{action:"remove",reason:"destroy-current-product"}:m(r.dir,t)?{action:"keep",reason:"current-product-active"}:D(r.dir)?R(r.dir,["volume_name"]).has(e.name)?{action:"keep",reason:"current-product-referenced"}:{action:"remove",reason:"current-product-unreferenced"}:{action:"remove",reason:"current-product-no-local-artifacts"}}function b(e,r,t){return!!(t.stopIdle&&e.running&&!m(r,t))}function I(e){const{labels:r}=e;return r[g]==="postgres-container"&&r[k]==="local-postgres"}function S(e){const{labels:r}=e;return r[g]==="postgres-volume"&&r[k]==="local-postgres"}export function hasActiveProductRuntime(e){return A(e,l)}function m(e,r){return r.terminalRunAuthority===void 0?hasActiveProductRuntime(e):v(e,l,r.terminalRunAuthority)}

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

@@ -0,0 +1,27 @@
+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/configured-steps.js

@@ -0,0 +1 @@
+import{runDockerPsql as E}from"./postgres/index.js";import{awaitCapturedResult as _}from"../evidence/step-output.js";import{applySetupNodeOptions as M,runConfiguredStep as D}from"../steps/run.js";import{announceResolvedToolchain as R,applyToolchainEnv as y,resolveConfiguredToolchain as A}from"../toolchains/index.js";import{resolveConfiguredCwd as P,resolveConfiguredPath as N,summarizeConfiguredStep as m}from"../steps/configured-steps.js";const U=3600*1e3;export async function runConfiguredSteps({config:e,steps:n=[],env:S,labelPrefix:O,ownedContainer:f=null,reporter:s=null,setupRegistry:o=null,parentOperation:g=null,startIndex:p=0,afterStep:c=null,signal:h,stepTimeoutMs:C}){if(n.length===0)return;const b=L(C),a=await A(e,{signal:h});await R(e,a,s);for(const[v,t]of n.entries()){const w=p+v+1,r=`${O}:${e.name}:${String(w)}`,u=o?.start({config:e,stage:r,kind:"setup-step",summary:m(t),parentId:$(g)});s?.phaseStarted?.(r);try{const i=y(M(S),a),l={livePrefix:`[${e.runtimeLabel||e.name}:${e.name}]`,liveWriter:s?.outputMode==="debug"?d=>{s.writeDebugLine?.(d)}:null,logRecord:u?._logRecord||null};if(t.kind==="sql-file"){const d=await E({databaseUrl:i.DATABASE_URL,args:[i.DATABASE_URL,"-v","ON_ERROR_STOP=1","-X","-f",N(e.productDir,t.cwd,t.path)],cwd:P(e.productDir,t.cwd),env:i,ownedContainer:f});_(d,l)}else await D(e,t,i,a,{...l,ownedContainer:f,signal:h,timeoutMs:b});const T=u&&o?o.finish(u,{status:"passed",summary:m(t)}):null;T&&s?.setupOperationFinished?.(T)}catch(i){const l=u&&o?o.finish(u,{status:"failed",summary:m(t),error:I(i)}):null;throw l&&s?.setupOperationFinished?.(l),i}c&&await c({step:t,index:p+v,stepNumber:w,label:r})}}function $(e){return typeof e=="string"?e||null:e?.id||null}function I(e){return(typeof e!="object"||e===null)&&typeof e!="function"?e:Reflect.get(e,"message")||e}function L(e){const n=e??U;if(!Number.isSafeInteger(n)||n<=0)throw new Error("Configured step timeout must be a positive safe integer in milliseconds");return n}

package/dist/database/constants.d.ts

@@ -0,0 +1,11 @@
+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;