@gfdelarue/testkit 0.3.0

package/dist/environment/runtime-preparation.d.ts

@@ -0,0 +1,30 @@
+import type { RuntimeServiceConfig } from "./template.js";
+import { type ConfiguredStepReporter, type ConfiguredStepServiceConfig } from "../steps/index.js";
+import { type SetupOperationRegistry } from "../evidence/setup-progress.js";
+import type { FingerprintPolicy } from "../repo/fingerprint-policy.js";
+import type { NormalizedBuildPrepareConfig } from "../steps/build-config.js";
+export type RuntimePreparationConfig = RuntimeServiceConfig & ConfiguredStepServiceConfig & {
+    runtimeLabel: string;
+    stateDir: string;
+    testkit: RuntimeServiceConfig["testkit"] & ConfiguredStepServiceConfig["testkit"] & {
+        envFiles?: readonly string[];
+        fingerprints?: FingerprintPolicy;
+        prepareDir: string;
+    };
+};
+export type RuntimePreparationInputConfig = Omit<RuntimePreparationConfig, "testkit"> & {
+    testkit: Omit<RuntimePreparationConfig["testkit"], "runtime"> & {
+        runtime: Omit<RuntimePreparationConfig["testkit"]["runtime"], "prepare"> & {
+            prepare?: NormalizedBuildPrepareConfig | null;
+        };
+    };
+};
+export interface RuntimePreparationOptions {
+    extraEnv?: NodeJS.ProcessEnv | null;
+    reporter?: ConfiguredStepReporter | null;
+    setupRegistry?: SetupOperationRegistry | null;
+    signal?: AbortSignal;
+}
+export declare function prepareRuntimeServices(runtimeConfigs: readonly RuntimePreparationInputConfig[], options?: Readonly<RuntimePreparationOptions>): Promise<void>;
+export declare function prepareRuntimeService(config: RuntimePreparationInputConfig, options?: Readonly<RuntimePreparationOptions>): Promise<void>;
+export declare function computeRuntimePrepareFingerprint(config: RuntimePreparationConfig, options?: Readonly<Pick<RuntimePreparationOptions, "signal">>): Promise<string>;

package/dist/environment/runtime-preparation.js

@@ -0,0 +1 @@
+import S from"crypto";import p from"fs";import k from"path";import{resolveServiceCwd as D}from"../config/loader/index.js";import{appendFileToHash as y}from"../repo/fingerprint-policy.js";import{announceResolvedToolchain as b,resolveConfiguredToolchain as v}from"../toolchains/index.js";import{readDatabaseUrl as m}from"../database/index.js";import{buildExecutionEnv as w,collectConfiguredInputs as x}from"../steps/index.js";import{runConfiguredSteps as R}from"../database/configured-steps.js";import"../evidence/setup-progress.js";const I="prepare-manifest.json";export async function prepareRuntimeServices(e,r={}){for(const t of e)await prepareRuntimeService(t,r)}export async function prepareRuntimeService(e,r={}){const t=e.testkit.runtime.prepare;if(!t||t.steps.length===0||!N(e))return;const n=e.testkit.prepareDir,s=await computeRuntimePrepareFingerprint(e,{signal:r.signal}),i=k.join(n,I);if(g(i)?.fingerprint===s){r.setupRegistry?.recordCached({config:e,stage:"runtime:prepare",kind:"runtime-prepare",summary:"runtime prepare cache hit"});return}p.rmSync(n,{recursive:!0,force:!0}),p.mkdirSync(n,{recursive:!0});const o={...w(e,{...e.testkit.local?.env||{},...r.extraEnv||{}},process.env)},d=m(e.stateDir);d&&(o.DATABASE_URL=d);const u=r.setupRegistry?.start({config:e,stage:"runtime:prepare",kind:"runtime-prepare",summary:"runtime prepare",recordLog:!1}),c=r.setupRegistry;try{await b(e,await v(e,{signal:r.signal}),r.reporter),await R({config:e,steps:t.steps,env:o,labelPrefix:"runtime:prepare",reporter:r.reporter,setupRegistry:c||null,parentOperation:u,signal:r.signal});const a=u?c?.finish(u,{status:"passed",summary:"runtime prepare"}):null;a&&r.reporter?.setupOperationFinished?.(a),A(i,{fingerprint:s,preparedAt:new Date().toISOString(),runtimeId:e.runtimeId||null,serviceName:e.name})}catch(a){const f=u?c?.finish(u,{status:"failed",summary:"runtime prepare",error:U(a,"message")||a}):null;throw f&&r.reporter?.setupOperationFinished?.(f),p.rmSync(n,{recursive:!0,force:!0}),a}}function N(e){return e.testkit.runtime.prepare!=null}export async function computeRuntimePrepareFingerprint(e,r={}){const t=await v(e,{signal:r.signal}),n=S.createHash("sha256");n.update(JSON.stringify({prepare:e.testkit.runtime.prepare,toolchain:t?{kind:"node",install:t.install,nodeVersion:t.nodeVersion,npmVersion:t.npmVersion,nodeSource:t.nodeSource,npmSource:t.npmSource,fingerprint:t.fingerprint}:null,serviceEnv:e.testkit.serviceEnv||{},local:e.testkit.local?{baseUrl:e.testkit.local.baseUrl,cwd:e.testkit.local.cwd,env:e.testkit.local.env||{},readyUrl:e.testkit.local.readyUrl,start:e.testkit.local.start}:null})),n.update(JSON.stringify(O(e)));const s=e.testkit.fingerprints||{exclude:[],include:[]};for(const i of e.testkit.envFiles||[])y(n,e.productDir,D(e.productDir,i),s);for(const i of x(e.productDir,e.testkit.runtime.prepare))y(n,e.productDir,i,s);return n.digest("hex")}function O(e){const r=[],t=m(e.stateDir);t&&r.push({service:e.name,url:t});const n=new Set;for(const i of Object.values(e.testkit.serviceEnv||{}))h(i,n,e.name);for(const i of Object.values(e.testkit.local?.env||{}))h(i,n,e.name);const s=e.testkit.templateContext?.stateDirByService;for(const i of[...n].sort()){const l=s?.get(i),o=l?m(l):null;r.push({service:i,url:o||null})}return r}function h(e,r,t){if(typeof e!="string")return;const n=/\{db(?:Url|Host|Port|Name|User|Password|Ssl)(?::([a-zA-Z0-9_-]+))?\}/g;let s=n.exec(e);for(;s;)r.add(s[1]||t),s=n.exec(e)}function g(e){if(!p.existsSync(e))return null;try{const r=JSON.parse(p.readFileSync(e,"utf8"));return F(r)?{fingerprint:r.fingerprint,...typeof r.preparedAt=="string"?{preparedAt:r.preparedAt}:{},...typeof r.runtimeId=="string"||typeof r.runtimeId=="number"||r.runtimeId===null?{runtimeId:r.runtimeId}:{},...typeof r.serviceName=="string"?{serviceName:r.serviceName}:{}}:null}catch{return null}}function A(e,r){p.writeFileSync(e,JSON.stringify(r,null,2))}function F(e){return typeof e=="object"&&e!==null&&!Array.isArray(e)}function U(e,r){if(!((typeof e!="object"||e===null)&&typeof e!="function"))return Reflect.get(e,r)}

package/dist/environment/runtime-service.d.ts

@@ -0,0 +1,18 @@
+import type { EngineJsonObject } from "../engines/api/index.js";
+import type { EngineId } from "../domain/identifiers.js";
+import type { ExecutionEnvironmentConfig } from "../steps/index.js";
+export interface ReadyServiceLocalConfig {
+    baseUrl?: null | string;
+    cwd?: string;
+    env?: Readonly<Record<string, string>>;
+}
+export interface ReadyServiceConfig extends ExecutionEnvironmentConfig {
+    engineConfigurations?: Readonly<Partial<Record<EngineId, EngineJsonObject>>>;
+    stateDir: string;
+    testkit: ExecutionEnvironmentConfig["testkit"] & {
+        execution: {
+            fileTimeoutSeconds: number;
+        };
+        local?: null | ReadyServiceLocalConfig;
+    };
+}

package/dist/environment/runtime-service.js

@@ -0,0 +1 @@
+export{};

package/dist/environment/services.d.ts

@@ -0,0 +1,48 @@
+import { type SupervisedProcessHandle, type SupervisedProcessReady } from "../process/index.js";
+import { type ToolchainResolvedReporter } from "../toolchains/index.js";
+import { type RuntimeServiceConfig } from "./template.js";
+import { type OutputLineHandler } from "../process/index.js";
+import type { RunLogRegistry } from "../evidence/logs.js";
+type LocalServiceConfig = RuntimeServiceConfig & {
+    runtimeLabel: string;
+    stateDir: string;
+    testkit: RuntimeServiceConfig["testkit"] & {
+        local: NonNullable<RuntimeServiceConfig["testkit"]["local"]> & {
+            readyTimeoutMs?: number;
+            shutdownTimeoutMs?: number;
+        };
+    };
+};
+export type ResolvedServiceConfig = RuntimeServiceConfig & {
+    runtimeLabel: string;
+    stateDir: string;
+};
+export interface LocalServiceLifecycle {
+    isStopRequested(): unknown;
+    registerService(config: LocalServiceConfig, supervisor: SupervisedProcessHandle, ownership: SupervisedProcessReady, cwd: string): unknown;
+    requestStop(reason?: unknown): unknown;
+    signal: AbortSignal;
+    unregisterService(supervisorPid: number): unknown;
+}
+export interface LocalServiceReporter extends ToolchainResolvedReporter<LocalServiceConfig> {
+    localServiceStarting?: (config: LocalServiceConfig, command: string) => unknown;
+    outputMode?: string;
+    writeDebugLine?: OutputLineHandler;
+}
+export interface StartLocalServicesOptions {
+    extraEnv?: NodeJS.ProcessEnv | null;
+    logRegistry?: RunLogRegistry | null;
+    reporter?: LocalServiceReporter | null;
+}
+export interface StartedLocalService {
+    completionMonitor: Promise<Error | null>;
+    expectCompletion(): void;
+    name: string;
+    outputDrains: Promise<void>[];
+    ownership: SupervisedProcessReady;
+    supervisor: SupervisedProcessHandle;
+}
+export declare function startLocalServices(runtimeConfigs: readonly ResolvedServiceConfig[], lifecycle: LocalServiceLifecycle, options?: Readonly<StartLocalServicesOptions>): Promise<StartedLocalService[]>;
+export declare function startLocalService(config: LocalServiceConfig, lifecycle: LocalServiceLifecycle, options?: Readonly<StartLocalServicesOptions>): Promise<StartedLocalService>;
+export declare function stopLocalServices(started: readonly StartedLocalService[], lifecycle: LocalServiceLifecycle | null | undefined): Promise<void>;
+export {};

package/dist/environment/services.js

@@ -0,0 +1 @@
+import{DEFAULT_READY_TIMEOUT_MS as x,waitForReady as M,serviceCompletionError as y}from"../process/readiness.js";import{resolveServiceCwd as A}from"../config/loader/index.js";import{startSupervisedProcess as f,ProcessExitedBeforeReadyError as k,DEFAULT_SHUTDOWN_TIMEOUT_MS as R}from"../process/index.js";import{announceResolvedToolchain as U,applyToolchainEnv as g,resolveConfiguredToolchain as D}from"../toolchains/index.js";import{buildExecutionEnv as O}from"../steps/index.js";import{numericPortFromUrl as P}from"./template.js";import{assertLocalServicePortsAvailable as _}from"./readiness.js";import{captureOutput as T}from"../process/index.js";import{prepareServiceStartInvocation as C}from"../process/service-processes.js";import{readDatabaseUrl as F}from"../database/index.js";export async function startLocalServices(e,r,t={}){const s=[];try{for(const a of e){if(!B(a))continue;const n=await startLocalService(a,r,t);s.push(n)}}catch(a){try{await stopLocalServices(s,r)}catch(n){throw new AggregateError([a,n],"Local service startup failed and its supervised cleanup also failed",{cause:n})}throw a}return s}export async function startLocalService(e,r,t={}){const s=A(e.productDir,e.testkit.local.cwd),a=await D(e,{signal:r.signal});await U(e,a,t.reporter);const n=g(O(e,{...e.testkit.local.env||{},...t.extraEnv||{}},process.env),a),l=e.testkit.local.port||P(e.testkit.local.baseUrl);l&&(n.PORT=String(l));const b=F(e.stateDir);b&&(n.DATABASE_URL=b),await _(e),t.reporter?.localServiceStarting?.(e,e.testkit.local.start);const v=C(e.testkit.local.start,n),d=t.logRegistry?.ensureServiceLogRecord(e),L=t.reporter?.outputMode==="debug"?o=>t.reporter?.writeDebugLine?.(o):null,i=f({args:v.args,windowsVerbatimArguments:v.windowsVerbatimArguments,cwd:s,displayLabel:`Testkit local service ${e.runtimeLabel}:${e.name}`,env:I(n),executable:v.executable,outputMode:"caller-drained",signal:r.signal,shutdownTimeoutMs:e.testkit.local.shutdownTimeoutMs??R,timeoutMs:null}),S=[T(i.stdout,{livePrefix:`[${e.runtimeLabel}:${e.name}]`,liveWriter:L,onLine(o){d&&t.logRegistry?.append(d,"stdout",o)}}),T(i.stderr,{livePrefix:`[${e.runtimeLabel}:${e.name}]`,liveWriter:L,onLine(o){d&&t.logRegistry?.append(d,"stderr",o)}})];let h,p=!1,w=!1;try{h=await i.ready,p=!0,r.registerService(e,i,h,s);const o=e.testkit.local.readyTimeoutMs||x;e.testkit.local.readyUrl!==!1&&e.testkit.local.readyUrl!=null&&await M({name:`${e.runtimeLabel}:${e.name}`,url:e.testkit.local.readyUrl,timeoutMs:o,process:i,signal:r.signal})}catch(o){const u=o instanceof k?y(`${e.runtimeLabel}:${e.name}`,o):o;w=!0;const c=[];try{c.push(...await $(i,S,!1))}catch(E){c.push(m(E))}if(p)try{r.unregisterService(i.pid)}catch(E){c.push(m(E))}throw c.length>0?new AggregateError([u,...c],`Local service ${e.runtimeLabel}:${e.name} startup and cleanup failed`,{cause:o}):u}return{completionMonitor:i.completion.then(o=>{if(w)return null;if(r.signal.aborted){if(p){p=!1;try{r.unregisterService(i.pid)}catch{}}return null}let u=y(`${e.runtimeLabel}:${e.name}`,o,"unexpectedly");if(p){p=!1;try{r.unregisterService(i.pid)}catch(c){u=new AggregateError([u,c],`Local service ${e.runtimeLabel}:${e.name} exited and its manifest entry could not be removed`)}}try{r.requestStop(u.message)}catch(c){u=new AggregateError([u,c],`Local service ${e.runtimeLabel}:${e.name} exited and the active run could not be interrupted`)}return u}),expectCompletion(){w=!0},name:e.name,outputDrains:S,ownership:h,supervisor:i}}export async function stopLocalServices(e,r){const t=[];for(const s of[...e].reverse()){s.expectCompletion();try{t.push(...await $(s.supervisor,s.outputDrains)),await s.completionMonitor}catch(a){t.push(m(a))}finally{try{r?.unregisterService(s.ownership.pid)}catch(a){t.push(m(a))}}}if(t.length>0)throw new AggregateError(t,"Could not stop all local services")}async function $(e,r,t=!0){const a=await e.stop().then(l=>({error:null,result:l}),l=>({error:m(l),result:null})),n=await Promise.allSettled(r);return[...a.result?j(a.result,t):[a.error],...n.flatMap(l=>l.status==="rejected"?[m(l.reason)]:[])]}function j(e,r=!0){return[...r?[e.error]:[],e.terminationError].filter(t=>t!==null)}function I(e){return Object.fromEntries(Object.entries(e).filter(r=>r[1]!==void 0))}function m(e){return e instanceof Error?e:new Error(String(e))}function B(e){return e.testkit.local!=null}

package/dist/environment/state.d.ts

@@ -0,0 +1,18 @@
+import type { RuntimeGraph } from "./planning-types.js";
+export type GraphMetadataInput = Pick<RuntimeGraph, "dirName" | "instanceCount" | "key" | "maxConcurrentTasks" | "portNamespaceIndex" | "portNamespaceStride" | "runtimeNames" | "targetNames">;
+export interface GraphMetadata extends Record<string, unknown> {
+    dirName?: null | string;
+    instanceCount?: null | number;
+    key?: null | string;
+    maxConcurrentTasks?: null | number;
+    portNamespaceIndex?: null | number;
+    portNamespaceStride?: null | number;
+    runtimeNames?: string[];
+    runtimeServices?: string[];
+    targetServices?: string[];
+}
+export declare function findRuntimeStateDirs(rootDir: string, isDatabaseStateDir: (directory: string) => boolean): string[];
+export declare function findGraphDirsForService(productDir: string, serviceName: string): string[];
+export declare function writeGraphMetadata(graphDir: string, graph: Readonly<GraphMetadataInput>): void;
+export declare function readGraphMetadata(graphDir: string): GraphMetadata | null;
+export declare function normalizePathSeparators(filePath: string): string;

package/dist/environment/state.js

@@ -0,0 +1 @@
+import c from"fs";import u from"path";const y="graph.json";export function findRuntimeStateDirs(e,t){const n=[],a=r=>{if(!c.existsSync(r))return;const s=c.readdirSync(r,{withFileTypes:!0});t(r)&&n.push(r);for(const o of s)o.isDirectory()&&a(u.join(r,o.name))};return a(e),n.sort((r,s)=>s.length-r.length)}export function findGraphDirsForService(e,t){const n=u.join(e,".testkit","_graphs");if(!c.existsSync(n))return[];const a=[];for(const r of c.readdirSync(n,{withFileTypes:!0})){if(!r.isDirectory())continue;const s=u.join(n,r.name),o=readGraphMetadata(s);o&&(o.runtimeServices??[]).includes(t)&&a.push(s)}return a.sort()}export function writeGraphMetadata(e,t){c.mkdirSync(e,{recursive:!0});const n={key:t.key||null,dirName:t.dirName||null,instanceCount:Number.isFinite(t.instanceCount)?t.instanceCount:null,maxConcurrentTasks:Number.isFinite(t.maxConcurrentTasks)?t.maxConcurrentTasks:null,portNamespaceIndex:Number.isFinite(t.portNamespaceIndex)?t.portNamespaceIndex:null,portNamespaceStride:Number.isFinite(t.portNamespaceStride)?t.portNamespaceStride:null,runtimeNames:[...t.runtimeNames].sort(),runtimeServices:t.runtimeNames,targetServices:[...t.targetNames].sort()};c.writeFileSync(u.join(e,y),JSON.stringify(n,null,2))}export function readGraphMetadata(e){const t=u.join(e,y);if(!c.existsSync(t))return null;try{const n=JSON.parse(c.readFileSync(t,"utf8"));return x(n)}catch{return null}}export function normalizePathSeparators(e){return e.split(u.sep).join("/")}function x(e){if(!A(e))return null;const{dirName:t,instanceCount:n,key:a,maxConcurrentTasks:r,portNamespaceIndex:s,portNamespaceStride:o,runtimeNames:l,runtimeServices:p,targetServices:d,...S}=e,i={...S};return N(t)&&(i.dirName=t),m(n)&&(i.instanceCount=n),N(a)&&(i.key=a),m(r)&&(i.maxConcurrentTasks=r),m(s)&&(i.portNamespaceIndex=s),m(o)&&(i.portNamespaceStride=o),Array.isArray(l)&&(i.runtimeNames=l.filter(f)),Array.isArray(p)&&(i.runtimeServices=p.filter(f)),Array.isArray(d)&&(i.targetServices=d.filter(f)),i}function A(e){return typeof e=="object"&&e!==null&&!Array.isArray(e)}function N(e){return e===null||typeof e=="string"}function m(e){return e===null||typeof e=="number"&&Number.isFinite(e)}function f(e){return typeof e=="string"}

package/dist/environment/status-runtime.d.ts

@@ -0,0 +1,53 @@
+import type { DesiredRuntimeGraph } from "./planning-types.js";
+export interface RuntimeDirectoryStatus {
+    id: string;
+    path: string;
+}
+export interface StaleRuntimeDirectoryStatus extends RuntimeDirectoryStatus {
+    active: boolean;
+}
+export interface DesiredRuntimeGraphStatus {
+    instanceCount: number;
+    runtimeIds: string[];
+    runtimeServices: string[];
+    targetServices: string[];
+}
+export interface ActualRuntimeGraphStatus {
+    runtimeServices: string[];
+    targetServices: string[];
+}
+export interface RuntimeGraphStatus {
+    actual: ActualRuntimeGraphStatus | null;
+    currentRuntimeDirs: RuntimeDirectoryStatus[];
+    desired: DesiredRuntimeGraphStatus | null;
+    exists: boolean;
+    name: string;
+    orphan: boolean;
+    path: string;
+    runtimeDirCount: number;
+    staleRuntimeDirs: StaleRuntimeDirectoryStatus[];
+}
+export interface RunStatusEntry {
+    pid?: number;
+    ports: string[];
+    runId: unknown;
+    startedAt: null | string;
+    status: "active" | "stale";
+}
+export interface RunStatus {
+    active: number;
+    runs: RunStatusEntry[];
+    stale: number;
+    total: number;
+}
+export interface RuntimeCleanupTarget {
+    graph: string;
+    path: string;
+    runtimeId: string;
+}
+export interface RuntimeGraphStatusOptions {
+    desiredGraphs?: readonly DesiredRuntimeGraph[];
+    serviceName?: null | string;
+}
+export declare function collectRuntimeGraphStatus(productDir: string, { desiredGraphs, serviceName }?: Readonly<RuntimeGraphStatusOptions>): RuntimeGraphStatus[];
+export declare function collectRunStatus(productDir: string): RunStatus;

package/dist/environment/status-runtime.js

@@ -0,0 +1 @@
+import u from"fs";import c from"path";import{buildRuntimeIds as w}from"../domain/runtime-identity.js";import{isRunManifestActive as S,listRunManifests as v}from"./lifecycle.js";import{readGraphMetadata as I}from"./state.js";export function collectRuntimeGraphStatus(s,{desiredGraphs:i=[],serviceName:e=null}={}){const t=c.join(s,".testkit","_graphs"),d=new Map(i.map(r=>[r.dirName,r])),m=new Map;if(u.existsSync(t))for(const r of u.readdirSync(t,{withFileTypes:!0}).sort((n,o)=>n.name.localeCompare(o.name))){if(!r.isDirectory())continue;const n=c.join(t,r.name);m.set(r.name,{name:r.name,path:n,metadata:I(n)})}const D=x(s);return[...new Set([...d.keys(),...m.keys()])].sort().map(r=>{const n=d.get(r)||null,o=m.get(r)||null,p=o?.path||c.join(t,r),l=A(p),f=n?w(n.instanceCount):[],h=new Set(f),g=l.filter(a=>!h.has(a.id)).map(a=>({...a,active:D.has(a.path)})),y=l.filter(a=>h.has(a.id));return{name:r,path:p,exists:!!o,desired:n?{instanceCount:n.instanceCount,runtimeIds:f,runtimeServices:n.runtimeNames,targetServices:n.targetNames}:null,actual:o?{runtimeServices:[...o.metadata?.runtimeServices||[]].sort(),targetServices:[...o.metadata?.targetServices||[]].sort()}:null,runtimeDirCount:l.length,currentRuntimeDirs:y,staleRuntimeDirs:g,orphan:!n}}).filter(r=>e?new Set([...r.desired?.runtimeServices||[],...r.desired?.targetServices||[],...r.actual?.runtimeServices||[],...r.actual?.targetServices||[]]).has(e):!0)}export function collectRunStatus(s){const e=v(s).map(t=>({runId:t.runId,pid:t.pid,status:S(t)?"active":"stale",startedAt:t.startedAt||null,ports:N(t)}));return{total:e.length,active:e.filter(t=>t.status==="active").length,stale:e.filter(t=>t.status==="stale").length,runs:e}}function N(s){const i=[];for(const e of s.services)for(const t of e.ports)t.host&&t.port&&i.push(`${t.host}:${t.port.toString()}`);return[...new Set(i)].sort()}function x(s){const i=new Set;for(const e of v(s))if(S(e))for(const t of e.runtimeDirs)i.add(c.resolve(t));return i}function A(s){const i=c.join(s,"runtimes");return u.existsSync(i)?u.readdirSync(i,{withFileTypes:!0}).filter(e=>e.isDirectory()&&/^runtime-\d+$/.test(e.name)).map(e=>({id:e.name,path:c.resolve(i,e.name)})).sort((e,t)=>R(e.id)-R(t.id)||e.id.localeCompare(t.id)):[]}function R(s){return Number(s.match(/^runtime-(\d+)$/)?.[1]||Number.MAX_SAFE_INTEGER)}

package/dist/environment/template.d.ts

@@ -0,0 +1,180 @@
+import type { RuntimeSocket } from "../process/runtime-socket.js";
+import { type NormalizedDatabaseConfig, type NormalizedRuntimeConfig } from "../config/loader/index.js";
+import { type ExecutionEnvironmentConfig, type ExecutionEnvironmentLocalConfig, type ExecutionEnvironmentTestkitConfig, type ExecutionTemplateContextValues, type RuntimeUrlMapping } from "../steps/index.js";
+import { readDatabaseInfo } from "../database/index.js";
+type RuntimeIdentifier = number | string;
+type StringMap = ReadonlyMap<string, string>;
+interface RuntimeLocalConfig extends ExecutionEnvironmentLocalConfig {
+    baseUrl: string;
+    cwd?: string;
+    port?: number;
+    readyUrl?: false | null | string;
+    shutdownTimeoutMs?: number;
+    start: string;
+}
+interface RuntimeServiceTestkitConfig extends ExecutionEnvironmentTestkitConfig {
+    database?: NormalizedDatabaseConfig | null;
+    local?: RuntimeLocalConfig | null;
+    runtime: NormalizedRuntimeConfig;
+}
+export interface RuntimeServiceConfig extends ExecutionEnvironmentConfig {
+    testkit: RuntimeServiceTestkitConfig;
+}
+export interface RuntimePortNamespace {
+    index?: unknown;
+    portOffset?: unknown;
+    stride?: unknown;
+}
+export interface RuntimeInstanceResolutionOptions {
+    externalEndpoints?: Readonly<Record<string, null | string | undefined>>;
+    graphDirName?: null | string;
+    portNamespaceIndex?: number;
+    portNamespaceStride?: number;
+    portOffset?: number;
+    privateEndpoints?: Readonly<Record<string, null | string | undefined>>;
+    publicEndpoints?: Readonly<Record<string, null | string | undefined>>;
+    publicHost?: null | string;
+    serviceContextEndpoints?: Readonly<Record<string, null | string | undefined>>;
+}
+interface RuntimeUrlResolutionContext extends ExecutionTemplateContextValues {
+    portMap: ReadonlyMap<string, number>;
+}
+export declare function resolveRuntimeInstanceConfigs<T extends RuntimeServiceConfig>(runtimeConfigs: readonly T[], runtimeId: string, runtimeDir: string, options?: RuntimeInstanceResolutionOptions): (T & {
+    stateDir: string;
+    runtimeId: string;
+    runtimeLabel: string;
+    testkit: {
+        database: import("../config/loader/database-materialization.js").MaterializedDatabaseConfig<{
+            sourceSchema: import("../config/loader/database.js").NormalizedSourceSchemaConfig | null;
+            template: import("../config/loader/database.js").NormalizedDatabaseTemplateConfig;
+            image?: string | undefined;
+            password?: string | undefined;
+            user?: string | undefined;
+            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;
+        }> | undefined;
+        prepareDir: string;
+        templateContext: {
+            runtimeId: string;
+            runtimeLabel: string;
+            runtimeDir: string;
+            productDir: string;
+            serviceName: string;
+            serviceCwd: string;
+            serviceStateDir: string;
+            prepareDir: string;
+            portMap: ReadonlyMap<string, number>;
+            baseUrlByService: StringMap;
+            readyUrlByService: StringMap;
+            publicBaseUrlByService: StringMap;
+            privateBaseUrlByService: StringMap;
+            serviceContextUrlByService: StringMap;
+            publicHost: string | null;
+            stateDirByService: StringMap;
+            urlMappings: readonly RuntimeUrlMapping[];
+            leaseId: null;
+            leaseDir: null;
+            databaseBindingsReader: typeof readDatabaseInfo;
+        };
+        runtime: {
+            prepare: import("../steps/build-config.js").NormalizedBuildPrepareConfig;
+            build: import("../steps/build-config.js").NormalizedBuildConfig | null;
+            instances: number;
+            maxConcurrentTasks: number;
+            toolchain: import("../toolchains/index.js").NormalizedRuntimeToolchain | null;
+        };
+        local: {
+            start: string;
+            cwd: string | undefined;
+            port: number | undefined;
+            baseUrl: string | undefined;
+            readyUrl: string | undefined;
+            env: {
+                [x: string]: string;
+            };
+            shutdownTimeoutMs?: number;
+        } | undefined;
+        mode?: string;
+        serviceEnv?: Readonly<Record<string, string>>;
+        ui?: unknown;
+    };
+})[];
+export declare function buildPortMap(runtimeConfigs: readonly RuntimeServiceConfig[], runtimeId: RuntimeIdentifier, namespace?: RuntimePortNamespace): Map<string, number>;
+export declare function resolveRuntimeConfig<T extends RuntimeServiceConfig>(config: T, runtimeId: string, runtimeLabel: string, runtimeDir: string, portMap: ReadonlyMap<string, number>, baseUrlByService: StringMap, readyUrlByService: StringMap, publicBaseUrlByService: StringMap, privateBaseUrlByService: StringMap, serviceContextUrlByService: StringMap, publicHost: null | string, stateDirByService: StringMap, urlMappings: readonly RuntimeUrlMapping[]): T & {
+    stateDir: string;
+    runtimeId: string;
+    runtimeLabel: string;
+    testkit: {
+        database: import("../config/loader/database-materialization.js").MaterializedDatabaseConfig<{
+            sourceSchema: import("../config/loader/database.js").NormalizedSourceSchemaConfig | null;
+            template: import("../config/loader/database.js").NormalizedDatabaseTemplateConfig;
+            image?: string | undefined;
+            password?: string | undefined;
+            user?: string | undefined;
+            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;
+        }> | undefined;
+        prepareDir: string;
+        templateContext: {
+            runtimeId: string;
+            runtimeLabel: string;
+            runtimeDir: string;
+            productDir: string;
+            serviceName: string;
+            serviceCwd: string;
+            serviceStateDir: string;
+            prepareDir: string;
+            portMap: ReadonlyMap<string, number>;
+            baseUrlByService: StringMap;
+            readyUrlByService: StringMap;
+            publicBaseUrlByService: StringMap;
+            privateBaseUrlByService: StringMap;
+            serviceContextUrlByService: StringMap;
+            publicHost: string | null;
+            stateDirByService: StringMap;
+            urlMappings: readonly RuntimeUrlMapping[];
+            leaseId: null;
+            leaseDir: null;
+            databaseBindingsReader: typeof readDatabaseInfo;
+        };
+        runtime: {
+            prepare: import("../steps/build-config.js").NormalizedBuildPrepareConfig;
+            build: import("../steps/build-config.js").NormalizedBuildConfig | null;
+            instances: number;
+            maxConcurrentTasks: number;
+            toolchain: import("../toolchains/index.js").NormalizedRuntimeToolchain | null;
+        };
+        local: {
+            start: string;
+            cwd: string | undefined;
+            port: number | undefined;
+            baseUrl: string | undefined;
+            readyUrl: string | undefined;
+            env: {
+                [x: string]: string;
+            };
+            shutdownTimeoutMs?: number;
+        } | undefined;
+        mode?: string;
+        serviceEnv?: Readonly<Record<string, string>>;
+        ui?: unknown;
+    };
+};
+export declare function resolveServiceStateDir(runtimeDir: string, config: Pick<ExecutionEnvironmentConfig, "name">): string;
+export declare function resolveServicePrepareDir(runtimeDir: string, config: Pick<ExecutionEnvironmentConfig, "name">): string;
+export declare function resolveRuntimeUrl(rawUrl: string, serviceName: string, runtimeId: string, context: RuntimeUrlResolutionContext): string;
+export declare function rewriteUrlPort(rawUrl: string, port: number): string;
+export declare function numericPortFromUrl(rawUrl: string): number | null;
+export declare function socketFromUrl(rawUrl: string): RuntimeSocket | null;
+export declare function normalizeSocketHost(hostname: string): string;
+export {};

package/dist/environment/template.js

@@ -0,0 +1 @@
+import{finalizeRuntimeDatabaseConfig as R}from"../database/runtime-config.js";import w from"path";import{finalizeConfiguredInputs as N,finalizeConfiguredSteps as y}from"../steps/configured-steps.js";import"../config/loader/index.js";import{finalizeString as h,resolveTemplateString as E}from"../steps/index.js";import{readDatabaseInfo as M}from"../database/index.js";const O=100;export function resolveRuntimeInstanceConfigs(t,e,r,s={}){const o=B(s.graphDirName,e),c=buildPortMap(t,e,{index:s.portNamespaceIndex||0,stride:s.portNamespaceStride||1,portOffset:s.portOffset||0}),i=new Map,p=new Map,l=new Map,u=new Map,d=new Map,m=new Map,S=x(s.externalEndpoints),v=x(s.publicEndpoints),k=x(s.privateEndpoints),f=x(s.serviceContextEndpoints);for(const n of t)m.set(n.name,resolveServiceStateDir(r,n));for(const n of t)n.testkit.local&&(i.set(n.name,resolveRuntimeUrl(n.testkit.local.baseUrl,n.name,e,{runtimeId:e,runtimeLabel:o,runtimeDir:r,portMap:c,baseUrlByService:i,readyUrlByService:p,stateDirByService:m})),n.testkit.local.readyUrl!==!1&&n.testkit.local.readyUrl!=null&&p.set(n.name,resolveRuntimeUrl(n.testkit.local.readyUrl,n.name,e,{runtimeId:e,runtimeLabel:o,runtimeDir:r,portMap:c,baseUrlByService:i,readyUrlByService:p,stateDirByService:m})));for(const[n,a]of Object.entries(S))i.has(n)||i.set(n,a),p.has(n)||p.set(n,a);for(const[n,a]of Object.entries(v))l.set(n,a);for(const[n,a]of Object.entries(k))u.set(n,a);for(const[n,a]of Object.entries(f))d.set(n,a);for(const[n,a]of i.entries())l.has(n)||l.set(n,g(a,s.publicHost||null)),d.has(n)||d.set(n,a),u.has(n)||u.set(n,a);const b=[];for(const n of t){if(!n.testkit.local)continue;const a=i.get(n.name),U=p.get(n.name);a&&b.push([n.testkit.local.baseUrl,a]),U&&b.push([n.testkit.local.readyUrl,U])}return t.map(n=>resolveRuntimeConfig(n,e,o,r,c,i,p,l,u,d,s.publicHost||null,m,b))}function x(t){return Object.fromEntries(Object.entries(t??{}).map(([e,r])=>[e,(r??"").trim()]).filter(e=>e[1].length>0))}export function buildPortMap(t,e,r={}){const s=new Map,o=new Map,c=j(e,r)+Number(r.portOffset||0);for(const i of t){if(!i.testkit.local)continue;const p=i.testkit.local.port||numericPortFromUrl(i.testkit.local.baseUrl);if(!p)continue;const l=p+c;if(l>65535)throw new Error(`Runtime port resolution exceeded 65535 for service "${i.name}" (${String(l)}). Reduce runtime instances or choose lower local.port/baseUrl ports in testkit.config.ts.`);const u=o.get(l);if(u)throw new Error(`Runtime port collision: services "${u}" and "${i.name}" both resolve to ${String(l)}. Assign distinct local.port/baseUrl ports in testkit.config.ts.`);o.set(l,i.name),s.set(i.name,l)}return s}export function resolveRuntimeConfig(t,e,r,s,o,c,i,p,l,u,d,m,S){const v=resolveServiceStateDir(s,t),k=resolveServicePrepareDir(s,t),f={runtimeId:e,runtimeLabel:r,runtimeDir:s,productDir:t.productDir,serviceName:t.name,serviceCwd:t.testkit.local?.cwd||".",serviceStateDir:v,prepareDir:k,portMap:o,baseUrlByService:c,readyUrlByService:i,publicBaseUrlByService:p,privateBaseUrlByService:l,serviceContextUrlByService:u,publicHost:d,stateDirByService:m,urlMappings:S,leaseId:null,leaseDir:null,databaseBindingsReader:M},b=R(t.testkit.database,f),n={...t.testkit.runtime,prepare:P(t.testkit.runtime.prepare,f)},a=t.testkit.local?{...t.testkit.local,start:h(t.testkit.local.start,f),cwd:t.testkit.local.cwd!==void 0?h(t.testkit.local.cwd,f):t.testkit.local.cwd,port:o.get(t.name)||t.testkit.local.port,baseUrl:c.get(t.name),readyUrl:i.get(t.name),env:{...t.testkit.local.env||{}}}:void 0;return{...t,stateDir:v,runtimeId:e,runtimeLabel:r,testkit:{...t.testkit,database:b,prepareDir:k,templateContext:f,runtime:n,local:a}}}export function resolveServiceStateDir(t,e){return w.join(t,"services",e.name)}export function resolveServicePrepareDir(t,e){return w.join(resolveServiceStateDir(t,e),"prepared")}export function resolveRuntimeUrl(t,e,r,s){const o=E(t,{...s,runtimeId:r,serviceName:e}),c=s.portMap.get(e);return c?rewriteUrlPort(o,c):o}function g(t,e){if(!e)return t;try{const r=new URL(t);r.hostname=e;let s=r.toString();return!t.endsWith("/")&&r.pathname==="/"&&s.endsWith("/")&&(s=s.slice(0,-1)),s}catch{return t}}function P(t,e){return t?{inputs:N(t.inputs,r=>h(r,e)),steps:y(t.steps,r=>h(r,e))}:{inputs:[],steps:[]}}export function rewriteUrlPort(t,e){try{const r=new URL(t);if(!r.port)return t;const s=new URL(t);s.port=String(e);let o=s.toString();return!t.endsWith("/")&&r.pathname==="/"&&o.endsWith("/")&&(o=o.slice(0,-1)),o}catch{return t}}export function numericPortFromUrl(t){try{const e=new URL(t),r=Number(e.port);return Number.isInteger(r)&&r>0?r:null}catch{return null}}export function socketFromUrl(t){try{const e=new URL(t),r=Number(e.port);if(!Number.isInteger(r)||r<=0)return null;const s=normalizeSocketHost(e.hostname);return s?{host:s,port:r}:null}catch{return null}}export function normalizeSocketHost(t){return!t||t==="localhost"?"127.0.0.1":t==="[::1]"?"::1":t}function j(t,e={}){const r=String(t).match(/(\d+)$/),s=r?Number.parseInt(r[1],10)-1:0,o=Math.max(0,Number(e.index||0)),c=Math.max(1,Number(e.stride||1));return O*(o*c+s)}function B(t,e){return t?`${t}/${e}`:e}

package/dist/evidence/artifact-config.d.ts

@@ -0,0 +1,14 @@
+export interface NormalizedArtifactRetentionConfig {
+    maxRuns: number | null;
+    maxAgeDays: number | null;
+    preserveSuites: string[];
+}
+export interface NormalizedArtifactPublicationConfig {
+    directory: string;
+    required: boolean;
+}
+export interface NormalizedArtifactArchiveConfig {
+    retention: NormalizedArtifactRetentionConfig;
+    publication: NormalizedArtifactPublicationConfig | null;
+}
+export declare function normalizeArtifactArchiveConfig(config?: unknown): NormalizedArtifactArchiveConfig;

package/dist/evidence/artifact-config.js

@@ -0,0 +1 @@
+export function normalizeArtifactArchiveConfig(r){const n=e(r,"artifacts"),i=e(n?.retention,"artifacts.retention"),t=e(n?.publication,"artifacts.publication");return{retention:{maxRuns:o(i?.maxRuns,"artifacts.retention.maxRuns"),maxAgeDays:s(i?.maxAgeDays,"artifacts.retention.maxAgeDays"),preserveSuites:a(i?.preserveSuites,"artifacts.retention.preserveSuites")},publication:t?{directory:u(t.directory,"artifacts.publication.directory"),required:f(t.required,"artifacts.publication.required")}:null}}function o(r,n){if(r==null)return null;if(typeof r!="number"||!Number.isInteger(r)||r<=0)throw new Error(`${n} must be a positive integer`);return r}function s(r,n){if(r==null)return null;if(typeof r!="number"||!Number.isFinite(r)||r<=0)throw new Error(`${n} must be a positive number`);return r}function a(r,n){if(r==null)return[];if(!m(r))throw new Error(`${n} must be an array of non-empty strings`);const i=r.map(t=>{if(typeof t!="string"||t.trim().length===0)throw new Error(`${n} must be an array of non-empty strings`);return t.trim()});return[...new Set(i)].sort()}function u(r,n){if(typeof r!="string"||r.trim().length===0)throw new Error(`${n} is required`);return r.trim()}function f(r,n){if(r===void 0)return!1;if(typeof r!="boolean")throw new Error(`${n} must be a boolean`);return r}function e(r,n){if(r!=null){if(!c(r))throw new Error(`${n} must be an object`);return r}}function c(r){return typeof r=="object"&&r!==null&&!Array.isArray(r)}function m(r){return Array.isArray(r)}

package/dist/evidence/artifact-validation.d.ts

@@ -0,0 +1,5 @@
+export { requireObjectRecord, isObjectRecord, requireStringArray as normalizeStringArray } from "./read-fields.js";
+export type UnknownRecord = Record<string, unknown>;
+export declare function isUnknownArray(value: unknown): value is unknown[];
+export declare function readOptionalProperty(value: UnknownRecord | undefined, key: string): unknown;
+export declare function normalizeOptionalNonEmptyString(value: unknown, label: string): string | null;

package/dist/evidence/artifact-validation.js

@@ -0,0 +1 @@
+export{requireObjectRecord,isObjectRecord,requireStringArray as normalizeStringArray}from"./read-fields.js";export function isUnknownArray(r){return Array.isArray(r)}export function readOptionalProperty(r,n){return r?.[n]}export function normalizeOptionalNonEmptyString(r,n){if(r==null||r==="")return null;if(typeof r!="string")throw new Error(`${n} must be a string or null`);return r}

package/dist/evidence/artifacts.d.ts

@@ -0,0 +1,75 @@
+import type { RunArtifactDocument } from "./reporting-types.js";
+import { type EngineJsonValue } from "../engines/api/index.js";
+import { type EngineId, type PublicTestType, type RunnerProfileId } from "../domain/identifiers.js";
+import { type NormalizedArtifactArchiveConfig } from "./artifact-config.js";
+import { applyRunBundleRetention, publishRunBundle, sealRunBundle, type RunBundleArtifact, type SealRunBundleOptions } from "./bundles.js";
+import { type Timings, type TimingUpdate } from "./timing.js";
+import type { ReportingArtifactReference } from "./reporting-types.js";
+import { type SecureFileCopyResult } from "./secure-file-copy.js";
+export type WrittenRunArtifact<Artifact extends RunArtifactDocument> = Omit<Artifact, "archive"> & RunBundleArtifact;
+export interface WriteRunArtifactOptions extends Omit<SealRunBundleOptions, "archiveConfig" | "declaredEnvironmentKeys"> {
+    archiveConfig?: NormalizedArtifactArchiveConfig | null;
+    declaredEnvironmentKeys?: readonly string[];
+}
+export interface WriteRunArtifactDependencies {
+    applyRunBundleRetention?: typeof applyRunBundleRetention;
+    publishRunBundle?: typeof publishRunBundle;
+    sealRunBundle?: typeof sealRunBundle;
+    writeLatestProjection?: (filePath: string, value: unknown) => void;
+}
+export interface InterruptLiveRunArtifactOptions {
+    finishedAt?: Date | number | string;
+    reason?: string;
+    runId?: null | string;
+    status?: string;
+}
+export interface ArtifactTask {
+    engineId: EngineId;
+    file?: null | string;
+    id: number | string;
+    profileId: RunnerProfileId;
+    serviceName?: null | string;
+    suiteKey?: null | string;
+    suiteName?: null | string;
+    testType: PublicTestType;
+}
+export interface PersistedArtifactReference extends ReportingArtifactReference {
+    contentType: string;
+    kind: null | string;
+    summary: null | string;
+}
+interface RuntimeArtifactInput {
+    contentType?: null | string;
+    data?: EngineJsonValue;
+    emittedAt?: null | string;
+    kind?: null | string;
+    name: string;
+    summary?: null | string;
+}
+interface FileArtifactInput {
+    contentType?: null | string;
+    kind?: null | string;
+    name?: null | string;
+    path: string;
+    summary?: null | string;
+}
+interface TaskOutputArtifactInput extends Partial<Omit<RuntimeArtifactInput, "data">> {
+    stream?: null | string;
+    text: string;
+}
+export interface PersistTaskFileArtifactsOptions {
+    copyResults?: SecureFileCopyResult[];
+    maxBytes?: number;
+    sizeLimitDescription?: string;
+    sourceRoot?: string;
+}
+export declare function writeRunArtifact<Artifact extends RunArtifactDocument>(productDir: string, artifact: Artifact, options?: WriteRunArtifactOptions, dependencies?: Readonly<WriteRunArtifactDependencies>): WrittenRunArtifact<Artifact>;
+export declare function writeLiveRunArtifact(productDir: string, artifact: RunArtifactDocument): void;
+export declare function finalizeLiveRunArtifact(productDir: string, options?: InterruptLiveRunArtifactOptions): boolean;
+export declare function resetResultArtifacts(productDir: string): void;
+export declare function persistTaskArtifacts(productDir: string, task: Readonly<ArtifactTask>, emittedArtifacts: readonly RuntimeArtifactInput[]): PersistedArtifactReference[];
+export declare function persistTaskFileArtifacts(productDir: string, task: Readonly<ArtifactTask>, fileArtifacts: readonly FileArtifactInput[], options?: Readonly<PersistTaskFileArtifactsOptions>): PersistedArtifactReference[];
+export declare function persistTaskOutputArtifacts(productDir: string, task: Readonly<ArtifactTask>, outputs: readonly TaskOutputArtifactInput[]): PersistedArtifactReference[];
+export declare function loadTimings(productDir: string): Timings;
+export declare function saveTimings(productDir: string, timings: Timings, updates: readonly TimingUpdate[]): void;
+export {};

package/dist/evidence/artifacts.js

@@ -0,0 +1,2 @@
+import{isPathWithin as F}from"../process/files/paths.js";import{readRunDocument as P}from"./read-run.js";import l from"node:fs";import o from"node:path";import"../engines/api/index.js";import"../domain/identifiers.js";import{normalizeArtifactArchiveConfig as _}from"./artifact-config.js";import{applyRunBundleRetention as C,publishRunBundle as M,sealRunBundle as B}from"./bundles.js";import{RETENTION_DECISION_SCHEMA_VERSION as $}from"./contracts.js";import{applyTimingUpdates as U,createEmptyTimings as I,normalizeTimings as J}from"./timing.js";import{isObjectRecord as q,isUnknownArray as V,normalizeOptionalNonEmptyString as E,normalizeStringArray as K,readOptionalProperty as x,requireObjectRecord as X}from"./artifact-validation.js";import{errorMessage as G,isPropertyContainer as W,readProperty as H,serializeJson as j,writeJsonFileAtomicWithRetry as k}from"../process/files/json-file.js";import{copyRegularFileSecurely as Q}from"./secure-file-copy.js";const N="timings.json",A="artifacts",Y="logs",Z="setup",R="live.json",tt=1e4,z=String;export function writeRunArtifact(t,e,r={},n={}){const i=e,s=o.join(t,".testkit","results");l.mkdirSync(s,{recursive:!0});const c=i.archive,a=r.archiveConfig??_(x(c,"request")||{}),u=r.declaredEnvironmentKeys??K(x(c,"declaredEnvironmentKeys")||[],"run artifact declaredEnvironmentKeys"),m=n.sealRunBundle??B,p=n.publishRunBundle??M,d=n.applyRunBundleRetention??C,y=n.writeLatestProjection??k,f=m(t,i,{env:r.env,archiveConfig:a,declaredEnvironmentKeys:u}),h=et(t,f.archive.runId,a.publication,p),S=rt(t,f.archive.runId,a.retention,d),v=i.finalizationFailure,L={...f,...v===void 0?{}:{finalizationFailure:v},run:h.status==="failed"&&h.required===!0||f.archive.cleanup?.status==="failed"||v!==void 0&&f.run.status!=="interrupted"?{...f.run,status:"failed"}:f.run,archive:{...f.archive,publication:h,retention:S}};return nt(s,L,y)}function et(t,e,r,n){try{return n(t,e,r)}catch(i){return{bytesUploaded:0,configured:r!==null,error:T(i),recordedAt:new Date().toISOString(),required:r?.required??!1,runId:e,schemaVersion:1,status:"failed",target:r===null?null:o.resolve(t,r.directory)}}}function rt(t,e,r,n){try{return n(t,e,r)}catch(i){return{currentRunId:e,decidedAt:new Date().toISOString(),error:T(i),garbageCollection:{failures:[],reclaimedBytes:0,removedObjects:0,status:"not_started"},policy:{maxAgeDays:r.maxAgeDays,maxRuns:r.maxRuns,preserveSuites:[...r.preserveSuites]},protectedRunIds:[e],removed:[],removalErrors:[],schemaVersion:$,status:"failed"}}}function nt(t,e,r){const n=o.join(t,"latest.json"),i={path:w(o.relative(o.dirname(t),n)),status:"complete"},s={...e,archive:{...e.archive,latest:i}};try{return r(n,s),s}catch(c){return{...s,archive:{...s.archive,latest:{...i,error:T(c),status:"failed"}}}}}function T(t){try{return G(t)}catch{return"Unknown post-seal archive operation failure"}}export function writeLiveRunArtifact(t,e){const r=e,n=o.join(t,".testkit","results");l.mkdirSync(n,{recursive:!0}),k(o.join(n,R),r)}export function finalizeLiveRunArtifact(t,e={}){const r=ot(e),n=o.join(t,".testkit","results",R),i=ft(n);if(i===null)return!1;const s=it(i,r);return s?(writeRunArtifact(t,s),!0):!1}function it(t,e){const r=P(t,"live run artifact"),n=r.run.id||null;if(e.runId&&n&&n!==e.runId)return null;const i=at(e.finishedAt),s=new Date(i).toISOString(),c=ut(r.run.startedAt),a=c===null?r.run.durationMs:Math.max(0,i-c);return{...r,generatedAt:s,run:{...r.run,id:n??e.runId,status:e.status,finishedAt:s,durationMs:a,interruptReason:e.reason},timings:st(r.timings,s,e.reason)}}function st(t,e,r){if(t==null)return t;const n=X(t,"live run artifact.timings"),i=n.operations;if(i==null)return n;if(!V(i))throw new Error("live run artifact.timings.operations must be an array");return{...n,operations:i.map(s=>!q(s)||s.status!=="running"?s:{...s,status:"cancelled",finishedAt:E(s.finishedAt,"live run operation.finishedAt")??e,message:E(s.message,"live run operation.message")??r})}}function ot(t){return{runId:t.runId??null,reason:t.reason??"run interrupted",status:t.status??"interrupted",finishedAt:t.finishedAt??Date.now()}}function at(t){if(t instanceof Date&&Number.isFinite(t.getTime()))return t.getTime();if(typeof t=="number"&&Number.isFinite(t))return t;if(typeof t=="string"){const e=Date.parse(t);if(Number.isFinite(e))return e}return Date.now()}function ut(t){if(typeof t!="string")return null;const e=Date.parse(t);return Number.isFinite(e)?e:null}export function resetResultArtifacts(t){l.rmSync(o.join(t,".testkit","results",A),{recursive:!0,force:!0}),l.rmSync(o.join(t,".testkit","results",Y),{recursive:!0,force:!0}),l.rmSync(o.join(t,".testkit","results",Z),{recursive:!0,force:!0}),l.rmSync(o.join(t,".testkit","results",R),{force:!0})}export function persistTaskArtifacts(t,e,r){if(r.length===0)return[];const n=g(e.serviceName||"service"),i=D(t,n);return r.map((s,c)=>{const a=ct(s),u={schemaVersion:2,source:"testkit-runtime-artifact",service:e.serviceName,suite:{engineId:e.engineId,key:e.suiteKey,name:e.suiteName,profileId:e.profileId,testType:e.testType},file:e.file,taskId:e.id,index:c,name:a.name,kind:a.kind,summary:a.summary,contentType:a.contentType,emittedAt:a.emittedAt,data:a.data},m=`${j(u,"runtime artifact payload")}
+`,p=O(i,e.id,c,a.name,".json",y=>{l.writeFileSync(y,m,{flag:"wx"})}),d=o.join(".testkit","results",A,n,p);return{name:u.name,kind:u.kind,summary:u.summary,contentType:u.contentType,path:w(d)}})}export function persistTaskFileArtifacts(t,e,r,n={}){if(r.length===0)return[];const i=g(e.serviceName||"service"),s=D(t,i);return r.map((c,a)=>{const u=lt(c),m=o.resolve(u.path),p=pt(m,u.contentType),d=[],y=O(s,e.id,a,u.name,p,S=>{d.push(Q(m,S,{...n.maxBytes===void 0?{}:{maxBytes:n.maxBytes},...n.sourceRoot===void 0?{}:{sourceRoot:n.sourceRoot},...n.sizeLimitDescription===void 0?{}:{sizeLimitDescription:n.sizeLimitDescription}}))}),f=d.at(0);if(f===void 0)throw new Error("File artifact copy completed without a result");n.copyResults?.push(f);const h=o.join(".testkit","results",A,i,y);return{name:u.name,kind:u.kind,summary:u.summary,contentType:u.contentType??yt(m),path:w(h)}})}export function persistTaskOutputArtifacts(t,e,r){if(r.length===0)return[];const n=[];for(const i of r){const s=i.text;s.trim().length!==0&&n.push({name:i.name||"task-output",kind:i.kind||"runtime.output",summary:i.summary||dt(s),contentType:i.contentType||"text/plain",emittedAt:i.emittedAt||new Date().toISOString(),data:{stream:i.stream||null,text:s}})}return persistTaskArtifacts(t,e,n)}export function loadTimings(t){const e=o.join(t,".testkit",N);if(!l.existsSync(e))return I();try{const r=JSON.parse(l.readFileSync(e,"utf8"));return J(r)}catch{return I()}}export function saveTimings(t,e,r){if(r.length===0)return;const n=U(e,r),i=o.join(t,".testkit");l.mkdirSync(i,{recursive:!0}),l.writeFileSync(o.join(i,N),j(n,"timings"))}function ct(t){return{name:t.name,kind:t.kind||null,summary:t.summary||null,contentType:t.contentType||"application/json",emittedAt:t.emittedAt||null,data:t.data}}function lt(t){return{path:t.path,name:t.name||"artifact",kind:t.kind||null,summary:t.summary||null,contentType:t.contentType||null}}function mt(t,e,r,n,i=0){const s=i===0?"":`-${(i+1).toString().padStart(2,"0")}`;return`task-${g(t)}-${(e+1).toString().padStart(2,"0")}-${g(r)}${s}${n}`}function O(t,e,r,n,i,s){for(let c=0;c<tt;c+=1){const a=mt(e,r,n,i,c),u=o.join(t,a);try{return s(u),a}catch(m){if(b(m,"EEXIST"))continue;throw l.rmSync(u,{force:!0}),m}}throw new Error(`Could not allocate a unique artifact path for task ${z(e)} and artifact ${n}`)}function D(t,e){const r=o.resolve(t);if(!l.statSync(r).isDirectory())throw new Error("Artifact product directory must be a directory");const i=l.realpathSync(r);let s=r;for(const c of[".testkit","results",A,e]){s=o.join(s,c);try{l.mkdirSync(s)}catch(m){if(!b(m,"EEXIST"))throw m}const a=l.lstatSync(s);if(a.isSymbolicLink()||!a.isDirectory())throw new Error(`Artifact output directory ${JSON.stringify(s)} must be a real directory below productDir`);const u=l.realpathSync(s);if(!F(i,u))throw new Error(`Artifact output directory ${JSON.stringify(s)} escapes productDir`)}return s}function g(t){return z(t).trim().toLowerCase().replace(/[^a-z0-9._-]+/g,"-").replace(/^-+|-+$/g,"")||"artifact"}function w(t){return t.split(o.sep).join("/")}function ft(t){try{return JSON.parse(l.readFileSync(t,"utf8"))}catch{return null}}function dt(t){const e=t.split(/\r?\n/u).map(r=>r.trim()).find(Boolean);return e?e.slice(0,120):"captured task output"}function pt(t,e){const r=o.extname(t);if(r)return r;const n=(e??"").split(";",1)[0].trim().toLowerCase();return n==="text/markdown"?".md":n==="text/plain"?".txt":n==="application/json"?".json":n==="application/zip"?".zip":n==="image/png"?".png":n==="image/jpeg"?".jpg":n==="text/html"?".html":n==="video/webm"?".webm":".artifact"}function yt(t){const e=o.extname(t).toLowerCase();return e===".md"||e===".markdown"?"text/markdown":e===".txt"||e===".log"?"text/plain":e===".json"?"application/json":"application/octet-stream"}function b(t,e){return W(t)&&H(t,"code")===e}

package/dist/evidence/bundles.d.ts

@@ -0,0 +1,28 @@
+import type { RunArtifactDocument } from "./reporting-types.js";
+import type { NormalizedArtifactPublicationConfig, NormalizedArtifactRetentionConfig } from "./artifact-config.js";
+import { type RunBundleArtifact, type RunBundleCleanup, type RunBundleManifest, type RunBundlePublication, type RunBundleRetentionDecision, type RunBundleSummary, type RunBundleVerification, type VerifiedRunBundleUpload, type SealRunBundleOptions } from "./contracts.js";
+export type { RunBundleArchive, RunBundleArtifact, RunBundleCleanup, RunBundleLatestProjection, RunBundleManifest, RunBundleManifestEntry, RunBundlePublication, RunBundleRedaction, RunBundleRetentionDecision, RunBundleStorage, RunBundleSummary, RunBundleVerification, VerifiedRunBundleUpload, SealRunBundleOptions, } from "./contracts.js";
+interface PublicationReceiptInput extends RunBundlePublication {
+    bytesUploaded: number;
+}
+export interface RunBundleSealDependencies {
+    cleanupActiveRunResults?: (resultsDir: string) => RunBundleCleanup;
+}
+export interface RunBundleRetentionDependencies {
+    removeObject?: (objectPath: string) => void;
+    removeRunBundle?: (bundlePath: string) => void;
+}
+export interface RunBundlePublicationDependencies {
+    writePublicationReceipt?: (productDir: string, runId: string, receipt: PublicationReceiptInput) => RunBundlePublication;
+}
+export declare function sealRunBundle(productDir: string, artifact: RunArtifactDocument, options?: SealRunBundleOptions, dependencies?: Readonly<RunBundleSealDependencies>): RunBundleArtifact;
+export declare function loadVerifiedRunBundleArtifactIfExists(productDir: string, runId: unknown): RunBundleArtifact | null;
+export declare function loadRunBundleArtifact(productDir: string, runId: unknown): RunBundleArtifact;
+export declare function loadRunBundleManifest(productDir: string, runId: unknown): RunBundleManifest;
+export declare function listRunBundles(productDir: string, options?: {
+    file?: null | string;
+}): RunBundleSummary[];
+export declare function verifyRunBundle(productDir: string, runId: unknown): RunBundleVerification;
+export declare function prepareVerifiedRunBundleUpload(productDir: string, requestedRunId?: null | string): VerifiedRunBundleUpload;
+export declare function publishRunBundle(productDir: string, runId: unknown, publication: NormalizedArtifactPublicationConfig | null, dependencies?: Readonly<RunBundlePublicationDependencies>): RunBundlePublication;
+export declare function applyRunBundleRetention(productDir: string, currentRunId: unknown, retention?: Partial<NormalizedArtifactRetentionConfig>, dependencies?: Readonly<RunBundleRetentionDependencies>): RunBundleRetentionDecision;

package/dist/evidence/bundles.js

@@ -0,0 +1 @@
+import{optionalString as A}from"../kernel/unknown-values.js";import{readRunProvenance as oe}from"./read-provenance.js";import{parseRunBundleArtifact as ae,parseRunBundleManifest as J,readRunBundleArtifact as ce}from"./read-bundle.js";import{readRunDocument as ue}from"./read-run.js";import le from"crypto";import c from"fs";import u from"path";import{redactSensitiveText as Y}from"../kernel/redaction.js";import{BUNDLE_SCHEMA_VERSION as G,OBJECTS_DIRNAME as Q,PROVENANCE_SCHEMA_VERSION as fe,RETENTION_DECISION_SCHEMA_VERSION as de,RUNS_DIRNAME as me}from"./contracts.js";import{bundleRelativePath as P,errorMessage as k,hashFile as z,isObjectRecord as $,normalizePath as X,normalizeRunId as w,objectRecords as Z,optionalStringArray as D,optionalUnknownArray as pe,readJsonFile as O,requirePublicationPathOutsideResults as M,requireRunId as he,runIncludesFile as ge,resolveManifestEntryPath as U,resolveRunBundleDirectory as x,resolveRunsRoot as ee,resultsRoot as q,sanitizeSegment as ye,sha256 as C,stableJson as W,treeBytes as te,walkFiles as ne,writeBufferAtomic as ve,writeJson as N}from"./storage.js";import{resolveCiProvenance as Se}from"./ci-provenance.js";const K=["artifacts","logs","setup"],Re=/(?:PASSWORD|TOKEN|SECRET|PRIVATE_KEY|AUTH|COOKIE|SESSION|API_KEY)/iu,je=["package.json","package-lock.json","npm-shrinkwrap.json","pnpm-lock.yaml","yarn.lock","testkit.config.ts","testkit.config.mts","testkit.config.js","testkit.config.mjs"];export function sealRunBundle(e,r,t={},s={}){const n=r,i=he(n),o=ee(e,!0),a=u.dirname(o),f=u.join(o,i),m=s.cleanupActiveRunResults??_e,p=loadVerifiedRunBundleArtifactIfExists(e,i);if(p!==null)return{...p,archive:{...p.archive,cleanup:m(a)}};const d=u.join(o,`.${i}.${String(process.pid)}.${String(Date.now())}.${le.randomBytes(4).toString("hex")}.tmp`);c.mkdirSync(d,{recursive:!0});try{const R=Ne(t.env??process.env),g=be({productDir:e,resultsDir:a,runId:i,tempDir:d,sensitiveValues:R}),h=Ie(n,i,R),y=ue(h.artifact,"run artifact");g.redaction.structuredReplacements=h.replacements,g.redaction.replacements+=h.replacements;const v=Be(e,y,i,{...t,redaction:g.redaction}),j={schemaVersion:G,runId:i,status:"complete",canonicalRunPath:P(i,"run.json"),manifestPath:P(i,"manifest.json"),provenancePath:P(i,"provenance.json"),integrity:"sha256",publication:{configured:!!t.archiveConfig?.publication,status:t.archiveConfig?.publication?"pending":"not_configured"},redaction:g.redaction};y.archive=j,N(u.join(d,"run.json"),y),N(u.join(d,"provenance.json"),v);const b=Ae(d),V=C(Buffer.from(W(b))),E={schemaVersion:G,runId:i,createdAt:new Date().toISOString(),algorithm:"sha256",files:b,storage:{fileCount:b.length,logicalBytes:b.reduce((_,F)=>_+F.bytes,0),objectBytesWritten:g.objectBytesWritten,deduplicatedBytes:g.deduplicatedBytes},redaction:g.redaction,digest:V};return N(u.join(d,"manifest.json"),E),c.renameSync(d,f),{...y,archive:{...j,cleanup:m(a),manifestDigest:E.digest,storage:E.storage}}}catch(R){try{c.rmSync(d,{recursive:!0,force:!0})}catch{}try{xe(e)}catch{}throw R}}export function loadVerifiedRunBundleArtifactIfExists(e,r){const t=w(r),s=x(e,t);if(!c.existsSync(s))return null;const n=verifyRunBundle(e,t);if(!n.ok)throw new Error(`Immutable run bundle ${t} already exists but failed integrity verification: ${n.errors.join("; ")}`);return loadRunBundleArtifact(e,t)}export function loadRunBundleArtifact(e,r){const t=w(r),s=ce(e,t),n=loadRunBundleManifest(e,t);return{...s,archive:{...s.archive,manifestDigest:n.digest,storage:n.storage}}}export function loadRunBundleManifest(e,r){const t=w(r),s=x(e,t),n=u.join(s,"manifest.json");if(!c.existsSync(n))throw new Error(`No immutable Testkit run manifest found for ${t}`);return J(O(n),n,t)}export function listRunBundles(e,r={}){const t=ee(e,!1);return c.existsSync(t)?c.readdirSync(t,{withFileTypes:!0}).filter(n=>n.isDirectory()&&!n.name.startsWith(".")).map(n=>{try{const i=loadRunBundleArtifact(e,n.name);return r.file&&!ge(i,r.file)?null:{runId:n.name,status:i.run.status,startedAt:i.run.startedAt,finishedAt:i.run.finishedAt??null,manifestDigest:i.archive.manifestDigest??null,canonicalRunPath:i.archive.canonicalRunPath}}catch{return null}}).filter(n=>n!==null).sort((n,i)=>(i.finishedAt??i.startedAt??"").localeCompare(n.finishedAt??n.startedAt??"")):[]}export function verifyRunBundle(e,r){const t=w(r);try{return T(x(e,t),t)}catch(s){return{ok:!1,runId:t,errors:[k(s)],checkedFiles:0}}}export function prepareVerifiedRunBundleUpload(e,r=null){const t=r??listRunBundles(e).at(0)?.runId??null;if(t===null)throw new Error("No immutable Testkit run bundle is available to publish");const s=verifyRunBundle(e,t);if(!s.ok)throw new Error(`Immutable run bundle ${t} failed integrity verification: ${s.errors.join("; ")}`);const n=loadRunBundleManifest(e,t),i=x(e,t);return{runId:t,manifest:n,files:n.files.map(o=>({...o,absolutePath:U(i,o.path)}))}}export function publishRunBundle(e,r,t,s={}){const n=w(r),i=s.writePublicationReceipt??ke;if(!t)return i(e,n,{status:"not_configured",required:!1,target:null,bytesUploaded:0});const o=u.resolve(e,t.directory);try{M(e,o)}catch(d){return i(e,n,{status:"failed",required:t.required,target:o,error:k(d),bytesUploaded:0})}const a=ye(u.basename(e)),f=u.join(o,a),m=u.join(f,n),p=u.join(f,`.${n}.${String(process.pid)}.${String(Date.now())}.tmp`);try{const d=x(e,n);if(c.mkdirSync(f,{recursive:!0}),M(e,f),c.existsSync(m)){const h=c.lstatSync(m);if(h.isSymbolicLink()||!h.isDirectory())throw new Error("Publication target must be a regular bundle directory");M(e,m);const y=T(d,n);if(!y.ok)throw new Error(`Source run bundle failed integrity verification: ${y.errors.join("; ")}`);const v=T(m,n);if(!v.ok)throw new Error(`Publication target failed integrity verification: ${v.errors.join("; ")}`);if(y.manifestDigest!==v.manifestDigest)throw new Error("Publication target already exists with a different manifest digest");return i(e,n,{status:"complete",required:t.required,target:m,manifestDigest:y.manifestDigest,reused:!0,bundleBytes:te(d),bytesUploaded:0})}const R=te(d);c.cpSync(d,p,{recursive:!0,preserveTimestamps:!0});const g=T(p,n);if(!g.ok)throw new Error(g.errors.join("; "));return c.renameSync(p,m),i(e,n,{status:"complete",required:t.required,target:m,manifestDigest:g.manifestDigest,reused:!1,bundleBytes:R,bytesUploaded:R})}catch(d){return c.rmSync(p,{recursive:!0,force:!0}),i(e,n,{status:"failed",required:t.required,target:m,error:k(d),bytesUploaded:0})}}export function applyRunBundleRetention(e,r,t={},s={}){const n=w(r),i=s.removeObject??ie,o=s.removeRunBundle??Pe,a=t.maxRuns??null,f=t.maxAgeDays??null,m=new Set(t.preserveSuites||[]),p=listRunBundles(e).map(l=>({...l,artifact:loadRunBundleArtifact(e,l.runId)})),d=new Set([n]);for(const l of p)$e(l.artifact,m)&&d.add(l.runId);const R=new Set(a?p.slice(0,a).map(l=>l.runId):p.map(l=>l.runId)),g=f==null?null:Date.now()-f*24*60*60*1e3,h=[];for(const l of p){if(d.has(l.runId))continue;const S=g!=null&&Date.parse(l.finishedAt||l.startedAt||"")<g,I=!R.has(l.runId);if(!S&&!I)continue;const B=[];S&&B.push("max_age"),I&&B.push("max_runs"),h.push({path:u.join(q(e),me,l.runId),reasons:B,runId:l.runId})}const y=new Map(p.map(l=>[l.runId,loadRunBundleManifest(e,l.runId).files.filter(S=>S.path.startsWith("files/")).map(S=>S.sha256)])),v=re(e),j=[],b=[];for(const l of h){let S=null;try{o(l.path)}catch(B){S=H(B)}const I=!c.existsSync(l.path);!I&&S===null&&(S="Run bundle still exists after removal completed"),I&&j.push({reasons:l.reasons,runId:l.runId}),S!==null&&b.push({...l,error:S,removed:I})}const V=new Set(j.map(l=>l.runId)),E=new Set(p.filter(l=>!V.has(l.runId)).flatMap(l=>y.get(l.runId)??[])),_=se(v,E,i),F=new Date().toISOString();return Oe({currentRunId:n,decidedAt:F,garbageCollection:_,policy:{maxRuns:a,maxAgeDays:f,preserveSuites:[...m].sort()},protectedRunIds:[...d].sort(),removed:j,removalErrors:b})}function be({resultsDir:e,tempDir:r,sensitiveValues:t}){let s=0,n=0,i=0,o=0,a=0;const f=u.join(e,Q,"sha256");c.mkdirSync(f,{recursive:!0});for(const m of K){const p=u.join(e,m);if(c.existsSync(p))for(const d of ne(p)){const R=u.relative(p,d),g=c.readFileSync(d),h=Ce(g,d,t);h.scanned&&(i+=1),h.replacements>0&&(o+=1,a+=h.replacements);const y=C(h.buffer),v=u.join(f,y);c.existsSync(v)?n+=h.buffer.length:(ve(v,h.buffer),c.chmodSync(v,292),s+=h.buffer.length);const j=u.join(r,"files",m,R);c.mkdirSync(u.dirname(j),{recursive:!0});try{c.linkSync(v,j)}catch{c.copyFileSync(v,j)}}}return{objectBytesWritten:s,deduplicatedBytes:n,redaction:{policyVersion:1,status:"applied",textualFilesScanned:i,filesRedacted:o,replacements:a,sensitiveEnvironmentKeys:t.map(m=>m.key).sort(),valuesStored:!1}}}function Ie(e,r,t){const s=new Map(K.map(i=>[`.testkit/results/${i}/`,`${P(r,`files/${i}`)}/`])),n=L(e,s);return Ee(we(n),t)}function we(e){if(!$(e))return e;const r={...e};if($(r.product)){const t={...r.product};delete t.directory,r.product=t}if($(r.git)){const t={...r.git};delete t.remoteUrl,delete t.repoRoot,delete t.worktreePath,r.git=t}return delete r.host,r}function L(e,r){if(Array.isArray(e))return e.map(s=>L(s,r));if($(e))return Object.fromEntries(Object.entries(e).map(([s,n])=>[s,L(n,r)]));if(typeof e!="string")return e;let t=e;for(const[s,n]of r)t.startsWith(s)&&(t=`${n}${t.slice(s.length)}`);return t}function Ee(e,r){let t=0;function s(n){if(Array.isArray(n))return n.map(s);if($(n))return Object.fromEntries(Object.entries(n).map(([o,a])=>[o,s(a)]));if(typeof n!="string")return n;let i=Y(n);i!==n&&(t+=1);for(const o of r){if(!i.includes(o.value))continue;const a=i.split(o.value);t+=a.length-1,i=a.join("<redacted>")}return i}return{artifact:s(e),replacements:t}}function Be(e,r,t,s){const n=D(r.run.fileNames),i=[...new Set([...je,...n])].map(o=>Ve(e,o)).filter(o=>o!==null);return{schemaVersion:fe,runId:t,ci:Se(s.env??process.env),source:{git:r.git??null,files:i},runtime:{controller:{testkitVersion:A(r.run.testkitVersion),node:process.versions.node,platform:process.platform,architecture:process.arch},runtimeStats:pe(r.run.runtimeStats)},scenario:{types:D(r.run.types),suiteSelectors:D(r.run.suiteSelectors),fileNames:n,serviceFilter:A(r.run.serviceFilter),planningDigest:C(Buffer.from(W(r.planning??null))),declaredEnvironmentKeys:[...new Set(s.declaredEnvironmentKeys??[])].sort()},redaction:s.redaction}}function Ae(e){return ne(e).map(r=>({path:X(u.relative(e,r)),bytes:c.statSync(r).size,sha256:z(r)})).sort((r,t)=>r.path.localeCompare(t.path))}function T(e,r){const t=u.join(e,"manifest.json"),s=J(O(t),t,r);ae(O(u.join(e,"run.json")),u.join(e,"run.json"),r);const n=[];for(const o of s.files){let a;try{a=U(e,o.path)}catch(m){n.push(k(m));continue}if(!c.existsSync(a)){n.push(`missing ${o.path}`);continue}const f=c.lstatSync(a);if(f.isSymbolicLink()){n.push(`symbolic link not allowed ${o.path}`);continue}if(!f.isFile()){n.push(`not a regular file ${o.path}`);continue}f.size!==o.bytes&&n.push(`size mismatch ${o.path}`),z(a)!==o.sha256&&n.push(`checksum mismatch ${o.path}`)}C(Buffer.from(W(s.files)))!==s.digest&&n.push("manifest digest mismatch"),s.storage.fileCount!==s.files.length&&n.push("manifest file count mismatch");for(const o of["run.json","provenance.json"])s.files.some(a=>a.path===o)||n.push(`manifest must include ${o}`);if(n.length===0){const o=U(e,"provenance.json");oe(O(o),o,r)}return{runId:r,checkedFiles:s.files.length,storage:s.storage,ok:n.length===0,errors:n,manifestDigest:s.digest}}function ke(e,r,t){const s={schemaVersion:1,runId:r,recordedAt:new Date().toISOString(),...t};return N(u.join(q(e),"publications",`${r}.json`),s),s}function $e(e,r){return r.size===0?!1:Z(e.services).some(t=>Z(t.suites).some(s=>{const n=A(t.name)??"",i=A(s.name)??"",o=A(s.testType)??"";return[i,`${o}:${i}`,`${n}/${o}:${i}`].some(f=>r.has(f))}))}function xe(e){const r=new Set;for(const t of listRunBundles(e)){const s=loadRunBundleManifest(e,t.runId);for(const n of s.files)n.path.startsWith("files/")&&r.add(n.sha256)}return se(re(e),r,ie)}function re(e){const r=u.join(q(e),Q,"sha256");return c.existsSync(r)?c.readdirSync(r,{withFileTypes:!0}).filter(t=>t.isFile()).map(t=>{const s=u.join(r,t.name);return{bytes:c.statSync(s).size,digest:t.name,path:s}}):[]}function se(e,r,t){const s=[];let n=0,i=0;for(const o of e){if(r.has(o.digest))continue;let a=null;try{t(o.path)}catch(m){a=H(m)}!c.existsSync(o.path)?(n+=1,i+=o.bytes):a===null&&(a="Object still exists after removal completed"),a!==null&&s.push({error:a,path:o.path})}return{failures:s,reclaimedBytes:i,removedObjects:n,status:s.length===0?"complete":"failed"}}function Pe(e){c.rmSync(e,{recursive:!0,force:!0})}function ie(e){c.rmSync(e,{force:!0})}function Oe({currentRunId:e,decidedAt:r,garbageCollection:t,policy:s,protectedRunIds:n,removed:i,removalErrors:o}){const a=[...o.map(f=>`remove ${f.runId}: ${f.error}`),...t.failures.map(f=>`garbage collect ${f.path}: ${f.error}`)];return{currentRunId:e,decidedAt:r,garbageCollection:t,policy:s,protectedRunIds:n,removed:i,removalErrors:o,schemaVersion:de,status:a.length===0?"complete":"failed",...a.length===0?{}:{error:a.join("; ")}}}function Ce(e,r,t){if(!Te(e,r)){for(const o of t)if(e.includes(Buffer.from(o.value)))throw new Error(`Refusing to archive binary file containing sensitive environment value: ${r}`);return{buffer:e,scanned:!1,replacements:0}}const s=e.toString("utf8");let n=Y(s),i=n===s?0:1;for(const o of t){if(!n.includes(o.value))continue;const a=n.split(o.value);i+=a.length-1,n=a.join("<redacted>")}return{buffer:Buffer.from(n),scanned:!0,replacements:i}}function Ne(e){const r=[];for(const[t,s]of Object.entries(e))Re.test(t)&&typeof s=="string"&&s.length>=8&&r.push({key:t,value:s});return r}function Te(e,r){if(e.includes(0))return!1;const t=u.extname(r).toLowerCase();return![".zip",".gz",".png",".jpg",".jpeg",".webm",".pdf"].includes(t)}function Ve(e,r){const t=u.resolve(e,r);return!t.startsWith(`${u.resolve(e)}${u.sep}`)||!c.existsSync(t)||!c.statSync(t).isFile()?null:{path:X(u.relative(e,t)),bytes:c.statSync(t).size,sha256:z(t)}}function _e(e){const r=[];for(const t of[...K.map(s=>u.join(e,s)),u.join(e,"live.json")])try{c.rmSync(t,{recursive:!0,force:!0})}catch(s){r.push(`${t}: ${H(s)}`)}return r.length===0?{status:"complete"}:{error:r.join("; "),status:"failed"}}function H(e){try{return k(e)}catch{return"Unknown post-seal archive operation failure"}}

package/dist/evidence/ci-provenance.d.ts

@@ -0,0 +1,9 @@
+export type CiProvider = "github" | "gitlab" | "other";
+export interface CiProvenance {
+    readonly actor: string | null;
+    readonly eventName: string | null;
+    readonly provider: CiProvider | null;
+    readonly runId: string | null;
+    readonly runUrl: string | null;
+}
+export declare function resolveCiProvenance(env: Readonly<NodeJS.ProcessEnv>): CiProvenance;

package/dist/evidence/ci-provenance.js

@@ -0,0 +1 @@
+export function resolveCiProvenance(r){const n=i(r);if(n===null)return{actor:null,eventName:null,provider:null,runId:null,runUrl:null};if(n==="github"){const u=t(r,"GITHUB_RUN_ID");return{actor:t(r,"GITHUB_ACTOR"),eventName:t(r,"GITHUB_EVENT_NAME"),provider:n,runId:u,runUrl:o(r,u)}}return{actor:t(r,"GITLAB_USER_LOGIN")??t(r,"CI_COMMIT_AUTHOR"),eventName:t(r,"CI_PIPELINE_SOURCE")??t(r,"CI_EVENT_NAME"),provider:n,runId:t(r,"CI_PIPELINE_ID")??t(r,"CI_JOB_ID"),runUrl:t(r,"CI_PIPELINE_URL")??t(r,"CI_JOB_URL")}}function i(r){return I(r,"GITHUB_ACTIONS")||e(r,"GITHUB_")?"github":I(r,"GITLAB_CI")||t(r,"CI_SERVER_NAME")?.toLowerCase()==="gitlab"?"gitlab":I(r,"CI")||e(r,"CI_")?"other":null}function o(r,n){const u=t(r,"GITHUB_SERVER_URL"),l=t(r,"GITHUB_REPOSITORY");return u===null||l===null||n===null?null:`${u.replace(/\/+$/u,"")}/${l}/actions/runs/${n}`}function t(r,n){const u=r[n]?.trim();return u||null}function I(r,n){return t(r,n)!==null}function e(r,n){return Object.entries(r).some(([u,l])=>u.startsWith(n)&&!!l?.trim())}