@interf/compiler 0.22.2 → 0.33.0

package/dist/packages/engine/build/source-files.js

@@ -1,149 +0,0 @@
-import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { SourceFilesSchema, SourceSnapshotSchema, StageInputsSchema, } from "../../contracts/lib/schema.js";
-import { readJsonFileWithSchema } from "../../contracts/utils/parse.js";
-import { discoverSourceFiles } from "./discovery.js";
-import { verifiableContextRuntimeSourceFilesPath, verifiableContextRuntimeSourceSnapshotPath, verifiableContextRuntimeStageInputsPath, } from "./verifiable-context-paths.js";
-import { resolveSourceInputPath } from "../../project/interf-detect.js";
-function shortHash(value, length = 16) {
-    return createHash("sha256")
-        .update(value)
-        .digest("hex")
-        .slice(0, length);
-}
-function normalizeRelativePath(path) {
-    return path.replaceAll("\\", "/");
-}
-function buildSource(sourcePath) {
-    const locator = resolve(sourcePath);
-    return {
-        id: `src-${shortHash(locator, 12)}`,
-        kind: "local-folder",
-        locator,
-    };
-}
-function buildSourceFile(source, sourcePath, relativePath) {
-    const normalizedPath = normalizeRelativePath(relativePath);
-    return {
-        id: `file-${shortHash(`${source.id}\0${normalizedPath}`)}`,
-        path: normalizedPath,
-        locator: resolve(sourcePath, relativePath),
-    };
-}
-function buildSnapshotId(options) {
-    const fingerprint = {
-        source: options.sourceFiles.source,
-        files: options.sourceFiles.files.map((file) => [file.id, file.path, file.locator]),
-        generated_at: options.generatedAt,
-        run_id: options.runId ?? null,
-    };
-    return `snap-${shortHash(JSON.stringify(fingerprint))}`;
-}
-function writeJson(filePath, value) {
-    mkdirSync(dirname(filePath), { recursive: true });
-    writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
-}
-export function buildVerifiableContextSourceFiles(verifiableContextPath, sourcePath = resolveSourceInputPath(verifiableContextPath), generatedAt = new Date().toISOString()) {
-    const discovery = discoverSourceFiles(sourcePath, verifiableContextPath);
-    const source = buildSource(sourcePath);
-    const files = discovery.sourceFiles.map((relativePath) => buildSourceFile(source, sourcePath, relativePath));
-    return {
-        kind: "interf-source-files",
-        version: 1,
-        generated_at: generatedAt,
-        source,
-        source_total: files.length,
-        files,
-    };
-}
-export function writeVerifiableContextSourceFiles(verifiableContextPath, sourcePath = resolveSourceInputPath(verifiableContextPath), generatedAt = new Date().toISOString()) {
-    const sourceFiles = buildVerifiableContextSourceFiles(verifiableContextPath, sourcePath, generatedAt);
-    const parsed = SourceFilesSchema.parse(sourceFiles);
-    writeJson(verifiableContextRuntimeSourceFilesPath(verifiableContextPath), parsed);
-    return parsed;
-}
-export function buildVerifiableContextSourceSnapshot(options) {
-    const generatedAt = options.generatedAt ?? new Date().toISOString();
-    const sourceFiles = options.sourceFiles
-        ?? buildVerifiableContextSourceFiles(options.verifiableContextPath, options.sourcePath ?? resolveSourceInputPath(options.verifiableContextPath), generatedAt);
-    return {
-        kind: "interf-source-snapshot",
-        version: 1,
-        snapshot_id: buildSnapshotId({
-            sourceFiles,
-            generatedAt,
-            runId: options.runId ?? null,
-        }),
-        generated_at: generatedAt,
-        run_id: options.runId ?? null,
-        source: sourceFiles.source,
-        source_total: sourceFiles.source_total,
-        files: sourceFiles.files,
-    };
-}
-export function writeVerifiableContextSourceSnapshot(options) {
-    const snapshot = SourceSnapshotSchema.parse(buildVerifiableContextSourceSnapshot(options));
-    writeJson(verifiableContextRuntimeSourceSnapshotPath(options.verifiableContextPath), snapshot);
-    return snapshot;
-}
-export function buildBuildStageInputs(options) {
-    const generatedAt = options.generatedAt ?? new Date().toISOString();
-    return {
-        kind: "interf-stage-inputs",
-        version: 1,
-        generated_at: generatedAt,
-        run_id: options.runId ?? options.snapshot.run_id ?? null,
-        build_plan: options.buildPlanId,
-        stage: options.stageId,
-        source_snapshot_id: options.snapshot.snapshot_id,
-        input_total: options.snapshot.files.length,
-        inputs: options.snapshot.files.map((file) => ({
-            source_file_id: file.id,
-            path: file.path,
-            locator: file.locator,
-        })),
-    };
-}
-export function writeBuildStageInputs(options) {
-    const stageInputs = StageInputsSchema.parse(buildBuildStageInputs(options));
-    writeJson(verifiableContextRuntimeStageInputsPath(options.verifiableContextPath, options.stageId), stageInputs);
-    return stageInputs;
-}
-export function writeBuildSourceRuntime(options) {
-    const generatedAt = new Date().toISOString();
-    const sourceFiles = writeVerifiableContextSourceFiles(options.verifiableContextPath, options.sourcePath ?? resolveSourceInputPath(options.verifiableContextPath), generatedAt);
-    const snapshot = writeVerifiableContextSourceSnapshot({
-        verifiableContextPath: options.verifiableContextPath,
-        sourceFiles,
-        runId: options.runId ?? null,
-        generatedAt,
-    });
-    const stageInputs = options.stageIds.map((stageId) => writeBuildStageInputs({
-        verifiableContextPath: options.verifiableContextPath,
-        buildPlanId: options.buildPlanId,
-        stageId,
-        snapshot,
-        runId: options.runId ?? null,
-        generatedAt,
-    }));
-    return { sourceFiles, snapshot, stageInputs };
-}
-export function loadVerifiableContextSourceFiles(verifiableContextPath) {
-    const filePath = verifiableContextRuntimeSourceFilesPath(verifiableContextPath);
-    if (!existsSync(filePath))
-        return null;
-    return readJsonFileWithSchema(filePath, "verifiable-context source files", SourceFilesSchema);
-}
-export function loadVerifiableContextSourceSnapshot(verifiableContextPath) {
-    const filePath = verifiableContextRuntimeSourceSnapshotPath(verifiableContextPath);
-    if (!existsSync(filePath))
-        return null;
-    return readJsonFileWithSchema(filePath, "verifiable-context source snapshot", SourceSnapshotSchema);
-}
-export function loadBuildStageInputs(verifiableContextPath, stageId) {
-    const filePath = verifiableContextRuntimeStageInputsPath(verifiableContextPath, stageId);
-    if (!existsSync(filePath))
-        return null;
-    return readJsonFileWithSchema(filePath, "verifiable-context stage inputs", StageInputsSchema);
-}

package/dist/packages/engine/build/state-artifacts.d.ts

@@ -1,9 +0,0 @@
-import { type VerifiableContextHealth, type VerifiableContextViewSpec, type SourceFiles, type SourceSnapshot } from "./lib/schema.js";
-export declare function refreshVerifiableContextArtifacts(dirPath: string, options?: {
-    ensureViewSpec?: boolean;
-}): {
-    health: VerifiableContextHealth;
-    viewSpec?: VerifiableContextViewSpec;
-    sourceFiles: SourceFiles;
-    sourceSnapshot: SourceSnapshot;
-};

package/dist/packages/engine/build/state-artifacts.js

@@ -1,14 +0,0 @@
-import { saveVerifiableContextHealth, } from "./state-io.js";
-import { computeVerifiableContextHealth, } from "./state-health.js";
-import { ensureVerifiableContextSourceFiles, ensureVerifiableContextSourceSnapshot, ensureVerifiableContextViewSpec, } from "./state-view.js";
-export function refreshVerifiableContextArtifacts(dirPath, options) {
-    const health = computeVerifiableContextHealth(dirPath);
-    saveVerifiableContextHealth(dirPath, health);
-    const sourceFiles = ensureVerifiableContextSourceFiles(dirPath);
-    const sourceSnapshot = ensureVerifiableContextSourceSnapshot(dirPath, sourceFiles);
-    let viewSpec;
-    if (options?.ensureViewSpec) {
-        viewSpec = ensureVerifiableContextViewSpec(dirPath);
-    }
-    return { health, viewSpec, sourceFiles, sourceSnapshot };
-}

package/dist/packages/engine/build/state-health.d.ts

@@ -1,4 +0,0 @@
-import { type VerifiableContextHealth, type BuildStage, type RuntimeStatus } from "./lib/schema.js";
-export declare function computeVerifiableContextHealth(dirPath: string): VerifiableContextHealth;
-export declare function resolveVerifiableContextStatus(..._args: unknown[]): RuntimeStatus;
-export declare function resolveBuildStage(...args: unknown[]): BuildStage;

package/dist/packages/engine/build/state-io.d.ts

@@ -1,11 +0,0 @@
-import { type VerifiableContextHealth, type VerifiableContextState, type VerifiableContextViewSpec, type SourceFiles, type SourceSnapshot } from "./lib/schema.js";
-export declare function loadState<T>(dirPath: string): T | null;
-export declare function saveState<T>(dirPath: string, state: T): void;
-export declare function loadVerifiableContextHealth(dirPath: string): VerifiableContextHealth | null;
-export declare function saveVerifiableContextHealth(dirPath: string, health: VerifiableContextHealth): void;
-export declare function loadVerifiableContextViewSpec(dirPath: string): VerifiableContextViewSpec | null;
-export declare function saveVerifiableContextViewSpec(dirPath: string, viewSpec: VerifiableContextViewSpec): void;
-export declare function loadVerifiableContextSourceFiles(dirPath: string): SourceFiles | null;
-export declare function loadVerifiableContextSourceSnapshot(dirPath: string): SourceSnapshot | null;
-export declare function saveEmptyRuntimeInventory(dirPath: string): void;
-export declare function initVerifiableContextState(): VerifiableContextState;

package/dist/packages/engine/build/state-io.js

@@ -1,82 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
-import { warnInterf } from "../../contracts/utils/logger.js";
-import { readJsonFileUnchecked, readJsonFileWithSchema } from "../../contracts/utils/parse.js";
-import { VerifiableContextHealthSchema, VerifiableContextStateSchema, VerifiableContextViewSpecSchema, SourceFilesSchema, SourceSnapshotSchema, } from "./lib/schema.js";
-import { emptyRuntimeInventory, } from "./runtime-inventory.js";
-import { healthPath, sourceFilesPath, sourceSnapshotPath, statePath, viewSpecPath, } from "./state-paths.js";
-import { verifiableContextRuntimeInventoryPath, verifiableContextRuntimeRoot, } from "./verifiable-context-paths.js";
-export function loadState(dirPath) {
-    const path = statePath(dirPath);
-    if (!existsSync(path))
-        return null;
-    const raw = readJsonFileUnchecked(path, "runtime state");
-    if (raw === null)
-        return null;
-    const parsed = VerifiableContextStateSchema.safeParse(raw);
-    if (parsed.success) {
-        return parsed.data;
-    }
-    warnInterf(`Warning: failed to validate runtime state at ${path}: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
-    return null;
-}
-export function saveState(dirPath, state) {
-    mkdirSync(verifiableContextRuntimeRoot(dirPath), { recursive: true });
-    writeFileSync(statePath(dirPath), JSON.stringify(state, null, 2) + "\n");
-}
-export function loadVerifiableContextHealth(dirPath) {
-    const path = healthPath(dirPath);
-    if (!existsSync(path))
-        return null;
-    return readJsonFileWithSchema(path, "verifiable-context health", VerifiableContextHealthSchema);
-}
-export function saveVerifiableContextHealth(dirPath, health) {
-    mkdirSync(verifiableContextRuntimeRoot(dirPath), { recursive: true });
-    writeFileSync(healthPath(dirPath), JSON.stringify(health, null, 2) + "\n");
-}
-export function loadVerifiableContextViewSpec(dirPath) {
-    const path = viewSpecPath(dirPath);
-    if (!existsSync(path))
-        return null;
-    return loadViewSpec(path, VerifiableContextViewSpecSchema);
-}
-export function saveVerifiableContextViewSpec(dirPath, viewSpec) {
-    mkdirSync(verifiableContextRuntimeRoot(dirPath), { recursive: true });
-    writeFileSync(viewSpecPath(dirPath), JSON.stringify(viewSpec, null, 2) + "\n");
-}
-export function loadVerifiableContextSourceFiles(dirPath) {
-    const path = sourceFilesPath(dirPath);
-    if (!existsSync(path))
-        return null;
-    return readJsonFileWithSchema(path, "verifiable-context source files", SourceFilesSchema);
-}
-export function loadVerifiableContextSourceSnapshot(dirPath) {
-    const path = sourceSnapshotPath(dirPath);
-    if (!existsSync(path))
-        return null;
-    return readJsonFileWithSchema(path, "verifiable-context source snapshot", SourceSnapshotSchema);
-}
-export function saveEmptyRuntimeInventory(dirPath) {
-    mkdirSync(verifiableContextRuntimeRoot(dirPath), { recursive: true });
-    writeFileSync(verifiableContextRuntimeInventoryPath(dirPath), JSON.stringify(emptyRuntimeInventory(), null, 2) + "\n");
-}
-export function initVerifiableContextState() {
-    return {
-        version: 2,
-        pending: [],
-        stages: {},
-        last_add: null,
-        last_build: null,
-        warning_count: 0,
-        error_count: 0,
-    };
-}
-function loadViewSpec(filePath, schema) {
-    try {
-        const raw = JSON.parse(readFileSync(filePath, "utf8"));
-        const parsed = schema.safeParse(raw);
-        return parsed.success ? parsed.data ?? null : null;
-    }
-    catch {
-        return null;
-    }
-}

package/dist/packages/engine/build/state-paths.js

@@ -1,16 +0,0 @@
-import { verifiableContextRuntimeHealthPath, verifiableContextRuntimeSourceFilesPath, verifiableContextRuntimeSourceSnapshotPath, verifiableContextRuntimeStatePath, verifiableContextRuntimeViewSpecPath, } from "./verifiable-context-paths.js";
-export function statePath(dirPath) {
-    return verifiableContextRuntimeStatePath(dirPath);
-}
-export function healthPath(dirPath) {
-    return verifiableContextRuntimeHealthPath(dirPath);
-}
-export function viewSpecPath(dirPath) {
-    return verifiableContextRuntimeViewSpecPath(dirPath);
-}
-export function sourceFilesPath(dirPath) {
-    return verifiableContextRuntimeSourceFilesPath(dirPath);
-}
-export function sourceSnapshotPath(dirPath) {
-    return verifiableContextRuntimeSourceSnapshotPath(dirPath);
-}

package/dist/packages/engine/build/state-view.d.ts

@@ -1,5 +0,0 @@
-import { type VerifiableContextViewSpec, type SourceFiles, type SourceSnapshot } from "./lib/schema.js";
-export declare function ensureVerifiableContextViewSpec(dirPath: string): VerifiableContextViewSpec;
-export declare function ensureVerifiableContextSourceFiles(dirPath: string): SourceFiles;
-export declare function ensureVerifiableContextSourceSnapshot(dirPath: string, sourceFiles?: SourceFiles): SourceSnapshot;
-export declare function normalizeVerifiableContextViewSpec(existing: VerifiableContextViewSpec, defaults?: VerifiableContextViewSpec): VerifiableContextViewSpec;

package/dist/packages/engine/build/state.d.ts

@@ -1,7 +0,0 @@
-export type { RuntimeStatus, BuildStage, VerifiableContextState, VerifiableContextHealth, ViewSection, ViewCard, VerifiableContextViewSpec, SourceFiles, SourceSnapshot, StageInputs, } from "./lib/schema.js";
-export { statePath, healthPath, viewSpecPath, sourceFilesPath, sourceSnapshotPath, } from "./state-paths.js";
-export { loadState, saveState, loadVerifiableContextHealth, saveVerifiableContextHealth, loadVerifiableContextViewSpec, loadVerifiableContextSourceFiles, loadVerifiableContextSourceSnapshot, saveVerifiableContextViewSpec, initVerifiableContextState, } from "./state-io.js";
-export { refreshVerifiableContextArtifacts, } from "./state-artifacts.js";
-export { computeVerifiableContextHealth, resolveVerifiableContextStatus, resolveBuildStage, } from "./state-health.js";
-export { ensureVerifiableContextViewSpec, ensureVerifiableContextSourceFiles, ensureVerifiableContextSourceSnapshot, normalizeVerifiableContextViewSpec, } from "./state-view.js";
-export declare function initializeBuildRuntimeState(dirPath: string): void;

package/dist/packages/engine/build/state.js

@@ -1,12 +0,0 @@
-export { statePath, healthPath, viewSpecPath, sourceFilesPath, sourceSnapshotPath, } from "./state-paths.js";
-export { loadState, saveState, loadVerifiableContextHealth, saveVerifiableContextHealth, loadVerifiableContextViewSpec, loadVerifiableContextSourceFiles, loadVerifiableContextSourceSnapshot, saveVerifiableContextViewSpec, initVerifiableContextState, } from "./state-io.js";
-export { refreshVerifiableContextArtifacts, } from "./state-artifacts.js";
-export { computeVerifiableContextHealth, resolveVerifiableContextStatus, resolveBuildStage, } from "./state-health.js";
-export { ensureVerifiableContextViewSpec, ensureVerifiableContextSourceFiles, ensureVerifiableContextSourceSnapshot, normalizeVerifiableContextViewSpec, } from "./state-view.js";
-import { saveEmptyRuntimeInventory, initVerifiableContextState, saveState } from "./state-io.js";
-import { refreshVerifiableContextArtifacts } from "./state-artifacts.js";
-export function initializeBuildRuntimeState(dirPath) {
-    saveState(dirPath, initVerifiableContextState());
-    saveEmptyRuntimeInventory(dirPath);
-    refreshVerifiableContextArtifacts(dirPath, { ensureViewSpec: true });
-}

package/dist/packages/engine/build/validate-helpers.d.ts

@@ -1,12 +0,0 @@
-export declare function asStringArray(value: unknown): string[];
-export declare function asRejectedEntries(value: unknown): Array<{
-    path: string;
-    reason: string;
-}>;
-export declare function asFileEntries(value: unknown): Array<{
-    file: string;
-}>;
-export declare function isSubset(left: Set<string>, right: Set<string>): boolean;
-export declare function setsEqual(left: Set<string>, right: Set<string>): boolean;
-export declare function setIntersectionSize(left: Set<string>, right: Set<string>): number;
-export declare function dedupeStrings(values: string[]): string[];

package/dist/packages/engine/build/validate-helpers.js

@@ -1,41 +0,0 @@
-export function asStringArray(value) {
-    if (!Array.isArray(value))
-        return [];
-    return value.filter((item) => typeof item === "string");
-}
-export function asRejectedEntries(value) {
-    if (!Array.isArray(value))
-        return [];
-    return value.filter((item) => !!item &&
-        typeof item === "object" &&
-        typeof item.path === "string" &&
-        typeof item.reason === "string");
-}
-export function asFileEntries(value) {
-    if (!Array.isArray(value))
-        return [];
-    return value.filter((item) => !!item &&
-        typeof item === "object" &&
-        typeof item.file === "string");
-}
-export function isSubset(left, right) {
-    for (const item of left) {
-        if (!right.has(item))
-            return false;
-    }
-    return true;
-}
-export function setsEqual(left, right) {
-    return left.size === right.size && isSubset(left, right);
-}
-export function setIntersectionSize(left, right) {
-    let count = 0;
-    for (const item of left) {
-        if (right.has(item))
-            count += 1;
-    }
-    return count;
-}
-export function dedupeStrings(values) {
-    return Array.from(new Set(values));
-}

package/dist/packages/engine/build/verifiable-context-paths.d.ts

@@ -1,47 +0,0 @@
-export declare const VERIFIABLE_CONTEXT_INTERF_DIR = ".interf";
-export declare const VERIFIABLE_CONTEXT_CONFIG_FILE = "interf.json";
-export declare const VERIFIABLE_CONTEXT_BUILD_PLAN_DIR = "build-plan";
-export declare const VERIFIABLE_CONTEXT_TEST_DIR = "tests";
-export declare const VERIFIABLE_CONTEXT_TEST_TARGETS_DIR = "targets";
-export declare const VERIFIABLE_CONTEXT_RUNTIME_DIR = "runtime";
-export declare const VERIFIABLE_CONTEXT_RUNTIME_STATE_FILE = "state.json";
-export declare const VERIFIABLE_CONTEXT_RUNTIME_HEALTH_FILE = "health.json";
-export declare const VERIFIABLE_CONTEXT_RUNTIME_VIEW_SPEC_FILE = "view-spec.json";
-export declare const VERIFIABLE_CONTEXT_RUNTIME_SOURCE_FILES_FILE = "source-files.json";
-export declare const VERIFIABLE_CONTEXT_RUNTIME_SOURCE_SNAPSHOT_FILE = "source-snapshot.json";
-export declare const VERIFIABLE_CONTEXT_RUNTIME_STAGE_INPUTS_DIR = "stages";
-export declare const VERIFIABLE_CONTEXT_RUNTIME_STAGE_INPUTS_FILE = "inputs.json";
-export declare const VERIFIABLE_CONTEXT_RUNTIME_INVENTORY_FILE = "inventory.json";
-export declare const VERIFIABLE_CONTEXT_RUNTIME_RUN_FILE = "run.json";
-export declare const VERIFIABLE_CONTEXT_RUNTIME_RUN_HISTORY_FILE = "run-history.jsonl";
-export declare const VERIFIABLE_CONTEXT_RUNTIME_STAGE_CONTRACT_FILE = "stage-contract.json";
-export declare function verifiableContextRuntimeRoot(verifiableContextPath: string): string;
-export declare function verifiableContextRuntimeFilePath(verifiableContextPath: string, fileName: string): string;
-export declare function verifiableContextInterfRoot(verifiableContextPath: string): string;
-export declare function verifiableContextInterfConfigPath(verifiableContextPath: string): string;
-export declare function buildPlanPackagePathForVerifiableContext(verifiableContextPath: string): string;
-export declare function testRootForVerifiableContext(verifiableContextPath: string): string;
-export declare function testTargetsRootForVerifiableContext(verifiableContextPath: string): string;
-export declare function stageExecutionShellsRoot(verifiableContextPath: string): string;
-export declare function buildPlanImprovementLoopsRoot(verifiableContextPath: string): string;
-export declare function buildPlanImprovementRunRoot(verifiableContextPath: string, runId: string): string;
-export declare function buildPlanImprovementLoopRoot(verifiableContextPath: string, runId: string, loopIndex: number): string;
-export declare function targetTestRunsRootForVerifiableContext(verifiableContextPath: string): string;
-export declare function targetTestSandboxesRootForVerifiableContext(verifiableContextPath: string): string;
-export declare function verifiableContextRuntimeLogsRoot(verifiableContextPath: string): string;
-export declare function verifiableContextRuntimeArchivedStageContractPath(verifiableContextPath: string, runId: string): string;
-export declare function verifiableContextQueryAcceptanceRoot(verifiableContextPath: string): string;
-export declare function verifiableContextRuntimeStatePath(verifiableContextPath: string): string;
-export declare function verifiableContextRuntimeHealthPath(verifiableContextPath: string): string;
-export declare function verifiableContextRuntimeViewSpecPath(verifiableContextPath: string): string;
-export declare function verifiableContextRuntimeSourceFilesPath(verifiableContextPath: string): string;
-export declare function verifiableContextRuntimeSourceSnapshotPath(verifiableContextPath: string): string;
-export declare function verifiableContextRuntimeStagesRoot(verifiableContextPath: string): string;
-export declare function verifiableContextRuntimeStageRoot(verifiableContextPath: string, stageId: string): string;
-export declare function verifiableContextRuntimeStageInputsPath(verifiableContextPath: string, stageId: string): string;
-export declare function verifiableContextRuntimeInventoryPath(verifiableContextPath: string): string;
-export declare function verifiableContextRuntimeRunPath(verifiableContextPath: string): string;
-export declare function verifiableContextRuntimeRunHistoryPath(verifiableContextPath: string): string;
-export declare function verifiableContextRuntimeStageContractPath(verifiableContextPath: string): string;
-export declare function resolveSourceControlPathForVerifiableContext(verifiableContextPath: string): string;
-export declare function defaultControlPathForVerifiableContext(verifiableContextPath: string): string;

package/dist/packages/engine/build/verifiable-context-paths.js

@@ -1,121 +0,0 @@
-import { basename, dirname, join, relative, resolve, sep } from "node:path";
-export const VERIFIABLE_CONTEXT_INTERF_DIR = ".interf";
-export const VERIFIABLE_CONTEXT_CONFIG_FILE = "interf.json";
-export const VERIFIABLE_CONTEXT_BUILD_PLAN_DIR = "build-plan";
-export const VERIFIABLE_CONTEXT_TEST_DIR = "tests";
-export const VERIFIABLE_CONTEXT_TEST_TARGETS_DIR = "targets";
-export const VERIFIABLE_CONTEXT_RUNTIME_DIR = "runtime";
-export const VERIFIABLE_CONTEXT_RUNTIME_STATE_FILE = "state.json";
-export const VERIFIABLE_CONTEXT_RUNTIME_HEALTH_FILE = "health.json";
-export const VERIFIABLE_CONTEXT_RUNTIME_VIEW_SPEC_FILE = "view-spec.json";
-export const VERIFIABLE_CONTEXT_RUNTIME_SOURCE_FILES_FILE = "source-files.json";
-export const VERIFIABLE_CONTEXT_RUNTIME_SOURCE_SNAPSHOT_FILE = "source-snapshot.json";
-export const VERIFIABLE_CONTEXT_RUNTIME_STAGE_INPUTS_DIR = "stages";
-export const VERIFIABLE_CONTEXT_RUNTIME_STAGE_INPUTS_FILE = "inputs.json";
-export const VERIFIABLE_CONTEXT_RUNTIME_INVENTORY_FILE = "inventory.json";
-export const VERIFIABLE_CONTEXT_RUNTIME_RUN_FILE = "run.json";
-export const VERIFIABLE_CONTEXT_RUNTIME_RUN_HISTORY_FILE = "run-history.jsonl";
-export const VERIFIABLE_CONTEXT_RUNTIME_STAGE_CONTRACT_FILE = "stage-contract.json";
-export function verifiableContextRuntimeRoot(verifiableContextPath) {
-    return join(verifiableContextPath, VERIFIABLE_CONTEXT_INTERF_DIR, VERIFIABLE_CONTEXT_RUNTIME_DIR);
-}
-export function verifiableContextRuntimeFilePath(verifiableContextPath, fileName) {
-    return join(verifiableContextRuntimeRoot(verifiableContextPath), fileName);
-}
-export function verifiableContextInterfRoot(verifiableContextPath) {
-    return join(verifiableContextPath, VERIFIABLE_CONTEXT_INTERF_DIR);
-}
-export function verifiableContextInterfConfigPath(verifiableContextPath) {
-    return join(verifiableContextInterfRoot(verifiableContextPath), VERIFIABLE_CONTEXT_CONFIG_FILE);
-}
-export function buildPlanPackagePathForVerifiableContext(verifiableContextPath) {
-    return join(verifiableContextInterfRoot(verifiableContextPath), VERIFIABLE_CONTEXT_BUILD_PLAN_DIR);
-}
-export function testRootForVerifiableContext(verifiableContextPath) {
-    return join(verifiableContextInterfRoot(verifiableContextPath), VERIFIABLE_CONTEXT_TEST_DIR);
-}
-export function testTargetsRootForVerifiableContext(verifiableContextPath) {
-    return join(testRootForVerifiableContext(verifiableContextPath), VERIFIABLE_CONTEXT_TEST_TARGETS_DIR);
-}
-export function stageExecutionShellsRoot(verifiableContextPath) {
-    return join(verifiableContextRuntimeRoot(verifiableContextPath), "execution-shells");
-}
-export function buildPlanImprovementLoopsRoot(verifiableContextPath) {
-    return join(verifiableContextRuntimeRoot(verifiableContextPath), "improvement-loops");
-}
-export function buildPlanImprovementRunRoot(verifiableContextPath, runId) {
-    return join(buildPlanImprovementLoopsRoot(verifiableContextPath), runId);
-}
-export function buildPlanImprovementLoopRoot(verifiableContextPath, runId, loopIndex) {
-    return join(buildPlanImprovementRunRoot(verifiableContextPath, runId), `loop-${String(loopIndex).padStart(2, "0")}`);
-}
-export function targetTestRunsRootForVerifiableContext(verifiableContextPath) {
-    return join(testTargetsRootForVerifiableContext(verifiableContextPath), "runs");
-}
-export function targetTestSandboxesRootForVerifiableContext(verifiableContextPath) {
-    return join(testTargetsRootForVerifiableContext(verifiableContextPath), "sandboxes");
-}
-export function verifiableContextRuntimeLogsRoot(verifiableContextPath) {
-    return join(verifiableContextRuntimeRoot(verifiableContextPath), "logs");
-}
-export function verifiableContextRuntimeArchivedStageContractPath(verifiableContextPath, runId) {
-    return join(verifiableContextRuntimeLogsRoot(verifiableContextPath), `${runId}.stage-contract.json`);
-}
-export function verifiableContextQueryAcceptanceRoot(verifiableContextPath) {
-    return join(verifiableContextRuntimeRoot(verifiableContextPath), "query-acceptance");
-}
-export function verifiableContextRuntimeStatePath(verifiableContextPath) {
-    return verifiableContextRuntimeFilePath(verifiableContextPath, VERIFIABLE_CONTEXT_RUNTIME_STATE_FILE);
-}
-export function verifiableContextRuntimeHealthPath(verifiableContextPath) {
-    return verifiableContextRuntimeFilePath(verifiableContextPath, VERIFIABLE_CONTEXT_RUNTIME_HEALTH_FILE);
-}
-export function verifiableContextRuntimeViewSpecPath(verifiableContextPath) {
-    return verifiableContextRuntimeFilePath(verifiableContextPath, VERIFIABLE_CONTEXT_RUNTIME_VIEW_SPEC_FILE);
-}
-export function verifiableContextRuntimeSourceFilesPath(verifiableContextPath) {
-    return verifiableContextRuntimeFilePath(verifiableContextPath, VERIFIABLE_CONTEXT_RUNTIME_SOURCE_FILES_FILE);
-}
-export function verifiableContextRuntimeSourceSnapshotPath(verifiableContextPath) {
-    return verifiableContextRuntimeFilePath(verifiableContextPath, VERIFIABLE_CONTEXT_RUNTIME_SOURCE_SNAPSHOT_FILE);
-}
-export function verifiableContextRuntimeStagesRoot(verifiableContextPath) {
-    return join(verifiableContextRuntimeRoot(verifiableContextPath), VERIFIABLE_CONTEXT_RUNTIME_STAGE_INPUTS_DIR);
-}
-export function verifiableContextRuntimeStageRoot(verifiableContextPath, stageId) {
-    return join(verifiableContextRuntimeStagesRoot(verifiableContextPath), stageId);
-}
-export function verifiableContextRuntimeStageInputsPath(verifiableContextPath, stageId) {
-    return join(verifiableContextRuntimeStageRoot(verifiableContextPath, stageId), VERIFIABLE_CONTEXT_RUNTIME_STAGE_INPUTS_FILE);
-}
-export function verifiableContextRuntimeInventoryPath(verifiableContextPath) {
-    return verifiableContextRuntimeFilePath(verifiableContextPath, VERIFIABLE_CONTEXT_RUNTIME_INVENTORY_FILE);
-}
-export function verifiableContextRuntimeRunPath(verifiableContextPath) {
-    return verifiableContextRuntimeFilePath(verifiableContextPath, VERIFIABLE_CONTEXT_RUNTIME_RUN_FILE);
-}
-export function verifiableContextRuntimeRunHistoryPath(verifiableContextPath) {
-    return verifiableContextRuntimeFilePath(verifiableContextPath, VERIFIABLE_CONTEXT_RUNTIME_RUN_HISTORY_FILE);
-}
-export function verifiableContextRuntimeStageContractPath(verifiableContextPath) {
-    return verifiableContextRuntimeFilePath(verifiableContextPath, VERIFIABLE_CONTEXT_RUNTIME_STAGE_CONTRACT_FILE);
-}
-export function resolveSourceControlPathForVerifiableContext(verifiableContextPath) {
-    // Flat preparation data layout: the verifiable context lives at
-    // `<preparation-data-dir>/<preparation>/`, so the preparation data folder is
-    // the parent of the verifiable context. Reject the filesystem root and the
-    // legacy `<root>/interf/<preparation>/` shape so stale fixtures fail loudly.
-    const verifiableContextAbsolute = resolve(verifiableContextPath);
-    const parent = dirname(verifiableContextAbsolute);
-    if (parent === verifiableContextAbsolute) {
-        throw new Error(`Verifiable context is not under the canonical Interf preparation data layout: ${verifiableContextPath}`);
-    }
-    if (basename(parent) === "interf") {
-        throw new Error(`Verifiable context is not under the canonical Interf preparation data layout: ${verifiableContextPath}`);
-    }
-    return parent;
-}
-export function defaultControlPathForVerifiableContext(verifiableContextPath) {
-    const relativePath = relative(verifiableContextPath, resolveSourceControlPathForVerifiableContext(verifiableContextPath));
-    return relativePath.length > 0 ? relativePath.split(sep).join("/") : ".";
-}

package/dist/packages/engine/build/verifiable-context-schema.d.ts

@@ -1,21 +0,0 @@
-import { type BuildPlanContextSchema, type BuildPlanArtifact, type BuildPlanArtifactId } from "./lib/schema.js";
-export interface BuildPlanSchemaStageLike {
-    id: string;
-    writes: readonly string[];
-}
-export declare const BUILD_PLAN_SCHEMA_FILE = "build-plan.schema.json";
-export declare function buildPlanSchemaFilePath(rootPath: string): string;
-export declare function resolveBuildPlanSchemaPath(rootPath: string): string | null;
-export declare function buildPlanSchemaExists(rootPath: string): boolean;
-export declare function buildPlanSchemaRelativePath(): string;
-export declare function listBuildPlanContextArtifacts(schema: BuildPlanContextSchema): BuildPlanArtifact[];
-export declare function findBuildPlanContextArtifact(schema: BuildPlanContextSchema, artifactId: BuildPlanArtifactId): BuildPlanArtifact | null;
-export declare function verifiableContextArtifactAbsolutePath(verifiableContextPath: string, artifact: Pick<BuildPlanArtifact, "path">): string;
-export declare function verifiableContextArtifactPath(artifact: Pick<BuildPlanArtifact, "path" | "kind">): string;
-export declare function verifiableContextArtifactPathsForArtifactIds(schema: BuildPlanContextSchema, artifactIds: readonly BuildPlanArtifactId[]): string[];
-export declare function ensureBuildPlanArtifactTargets(verifiableContextPath: string, schema: BuildPlanContextSchema): void;
-export declare function buildBuildPlanContextSchema(stages: BuildPlanSchemaStageLike[], label?: string): BuildPlanContextSchema;
-export declare function writeBuildPlanContextSchemaFile(rootPath: string, stages: BuildPlanSchemaStageLike[], label?: string): BuildPlanContextSchema;
-export declare function writeBuildPlanContextSchemaDocument(rootPath: string, schema: BuildPlanContextSchema): BuildPlanContextSchema;
-export declare function readBuildPlanContextSchemaFile(rootPath: string): BuildPlanContextSchema | null;
-export declare function readBuildPlanContextFile(rootPath: string): BuildPlanContextSchema | null;