@interf/compiler 0.22.2 → 0.50.0

package/dist/packages/engine/build/runtime-inventory.d.ts

@@ -1,7 +0,0 @@
-import { type RuntimeInventory, type RuntimeInventoryEntry } from "./lib/schema.js";
-export declare function emptyRuntimeInventory(): RuntimeInventory;
-export declare function buildInventoryFromEntries(entries: RuntimeInventoryEntry[], stage?: string): RuntimeInventory;
-export declare function buildInventoryEntryCount(inventory: RuntimeInventory | null): number;
-export declare function buildInventoryTotal(inventory: RuntimeInventory | null): number;
-export declare function buildInventoryFrontmatterScannedCount(inventory: RuntimeInventory | null): number;
-export declare function buildInventoryAbstractCoverageCount(inventory: RuntimeInventory | null): number;

package/dist/packages/engine/build/runtime-paths.d.ts

@@ -1,8 +0,0 @@
-export declare function runPath(dirPath: string): string;
-export declare function runHistoryPath(dirPath: string): string;
-export declare function stageContractPath(dirPath: string): string;
-export declare function archivedStageContractPath(dirPath: string, runId: string): string;
-export declare function logsDirPath(dirPath: string): string;
-export declare function promptLogPath(dirPath: string, runId: string): string;
-export declare function eventLogPath(dirPath: string, runId: string): string;
-export declare function statusLogPath(dirPath: string, runId: string): string;

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

@@ -1,26 +0,0 @@
-import { join } from "node:path";
-import { verifiableContextRuntimeArchivedStageContractPath, verifiableContextRuntimeLogsRoot, verifiableContextRuntimeRunHistoryPath, verifiableContextRuntimeRunPath, verifiableContextRuntimeStageContractPath, } from "./verifiable-context-paths.js";
-export function runPath(dirPath) {
-    return verifiableContextRuntimeRunPath(dirPath);
-}
-export function runHistoryPath(dirPath) {
-    return verifiableContextRuntimeRunHistoryPath(dirPath);
-}
-export function stageContractPath(dirPath) {
-    return verifiableContextRuntimeStageContractPath(dirPath);
-}
-export function archivedStageContractPath(dirPath, runId) {
-    return verifiableContextRuntimeArchivedStageContractPath(dirPath, runId);
-}
-export function logsDirPath(dirPath) {
-    return verifiableContextRuntimeLogsRoot(dirPath);
-}
-export function promptLogPath(dirPath, runId) {
-    return join(logsDirPath(dirPath), `${runId}.prompt.txt`);
-}
-export function eventLogPath(dirPath, runId) {
-    return join(logsDirPath(dirPath), `${runId}.events.ndjson`);
-}
-export function statusLogPath(dirPath, runId) {
-    return join(logsDirPath(dirPath), `${runId}.status.log`);
-}

package/dist/packages/engine/build/runtime-runs.d.ts

@@ -1,10 +0,0 @@
-import { type RuntimeRun, type RuntimeStageContract } from "./lib/schema.js";
-import { type RuntimeRunPatch, type RuntimeStageExecutionOptions } from "./runtime-types.js";
-export declare function loadRuntimeRun(dirPath: string): RuntimeRun | null;
-export declare function saveRuntimeRun(dirPath: string, run: RuntimeRun): void;
-export declare function writeStageContract(dirPath: string, contract: RuntimeStageContract): string;
-export declare function runExecutorStage(options: RuntimeStageExecutionOptions): Promise<number>;
-export declare function beginRuntimeRun(dirPath: string, run: RuntimeRun): RuntimeRun;
-export declare function updateRuntimeRun(dirPath: string, patch: RuntimeRunPatch): RuntimeRun | null;
-export declare function markRuntimeRunFailedAfterValidation(dirPath: string, summary: string): RuntimeRun | null;
-export declare function markRuntimeRunSucceededAfterValidation(dirPath: string, summary: string): RuntimeRun | null;

package/dist/packages/engine/build/runtime-runs.js

@@ -1,224 +0,0 @@
-import { appendFileSync, mkdirSync, existsSync, readFileSync, writeFileSync, } from "node:fs";
-import { dirname, relative } from "node:path";
-import { buildRuntimeExecutorInfo } from "../agents/lib/executors.js";
-import { RuntimeRunSchema, } from "./lib/schema.js";
-import { getBuildPlanStageDefinition, getBuildPlanStagePosition, getBuildPlanStages, } from "../../build-plans/package/build-plan-definitions.js";
-import { archivedStageContractPath, eventLogPath, logsDirPath, promptLogPath, runHistoryPath, runPath, stageContractPath, statusLogPath, } from "./runtime-paths.js";
-import { warnInterf } from "../../contracts/utils/logger.js";
-export function loadRuntimeRun(dirPath) {
-    const path = runPath(dirPath);
-    if (!existsSync(path))
-        return null;
-    try {
-        const raw = JSON.parse(readFileSync(path, "utf8"));
-        const parsed = RuntimeRunSchema.safeParse(raw);
-        if (parsed.success)
-            return parsed.data;
-        warnInterf(`Warning: failed to validate runtime run at ${path}: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
-        return null;
-    }
-    catch (error) {
-        warnInterf(`Warning: failed to read runtime run at ${path}: ${error instanceof Error ? error.message : String(error)}`);
-        return null;
-    }
-}
-export function saveRuntimeRun(dirPath, run) {
-    mkdirSync(dirname(runPath(dirPath)), { recursive: true });
-    writeFileSync(runPath(dirPath), JSON.stringify(run, null, 2) + "\n");
-}
-export function writeStageContract(dirPath, contract) {
-    mkdirSync(dirname(stageContractPath(dirPath)), { recursive: true });
-    const path = stageContractPath(dirPath);
-    writeFileSync(path, JSON.stringify(contract, null, 2) + "\n");
-    return path;
-}
-function writeArchivedStageContract(dirPath, runId, contract) {
-    const path = archivedStageContractPath(dirPath, runId);
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, JSON.stringify(contract, null, 2) + "\n");
-    return path;
-}
-export async function runExecutorStage(options) {
-    const startedRun = startRuntimeRun(options);
-    const prompt = options.buildPrompt(startedRun.activeContractPath);
-    writeRuntimeRunPrompt(options.verifiableContextPath, startedRun.run.run_id, prompt);
-    const executionPath = options.executionPath ?? options.verifiableContextPath;
-    const code = await options.executor.execute(executionPath, prompt, {
-        eventLogPath: eventLogPath(options.verifiableContextPath, startedRun.run.run_id),
-        statusLogPath: statusLogPath(options.verifiableContextPath, startedRun.run.run_id),
-        completionCheck: options.completionCheck,
-        onStatus: options.onStatus,
-    });
-    finalizeRuntimeRun(options.verifiableContextPath, code);
-    return code;
-}
-export function beginRuntimeRun(dirPath, run) {
-    saveRuntimeRun(dirPath, run);
-    return run;
-}
-export function updateRuntimeRun(dirPath, patch) {
-    const current = loadRuntimeRun(dirPath);
-    if (!current)
-        return null;
-    const next = {
-        ...current,
-        ...patch,
-        updated_at: new Date().toISOString(),
-    };
-    saveRuntimeRun(dirPath, next);
-    return next;
-}
-export function markRuntimeRunFailedAfterValidation(dirPath, summary) {
-    const current = loadRuntimeRun(dirPath);
-    if (!current)
-        return null;
-    const finishedAt = current.finished_at ?? new Date().toISOString();
-    const next = {
-        ...current,
-        status: "failed",
-        updated_at: new Date().toISOString(),
-        finished_at: finishedAt,
-        exit_code: 1,
-        error: summary,
-        summary,
-    };
-    saveRuntimeRun(dirPath, next);
-    replaceOrAppendRunHistoryEntry(dirPath, next);
-    return next;
-}
-export function markRuntimeRunSucceededAfterValidation(dirPath, summary) {
-    const current = loadRuntimeRun(dirPath);
-    if (!current)
-        return null;
-    const finishedAt = current.finished_at ?? new Date().toISOString();
-    const next = {
-        ...current,
-        status: "succeeded",
-        updated_at: new Date().toISOString(),
-        finished_at: finishedAt,
-        exit_code: 0,
-        error: null,
-        summary,
-    };
-    saveRuntimeRun(dirPath, next);
-    replaceOrAppendRunHistoryEntry(dirPath, next);
-    return next;
-}
-function startRuntimeRun(options) {
-    const runId = createRunId();
-    const generatedAt = new Date().toISOString();
-    const buildPlanStages = getBuildPlanStages(options.buildPlan, options.buildPlanSourcePath);
-    const stagePosition = getBuildPlanStagePosition(options.buildPlan, options.stage, options.buildPlanSourcePath);
-    const stageDefinition = getBuildPlanStageDefinition(options.buildPlan, options.stage, options.buildPlanSourcePath);
-    const contract = {
-        kind: "interf-stage-contract",
-        version: 1,
-        generated_at: generatedAt,
-        run_id: runId,
-        target_type: "verifiable-context",
-        target_name: options.verifiableContextName,
-        build_plan: {
-            id: options.buildPlan,
-            stage_index: stagePosition?.stageIndex ?? null,
-            stage_total: stagePosition?.stageTotal ?? buildPlanStages.length,
-            stages: stagePosition?.stages ?? buildPlanStages,
-        },
-        stage: options.stage,
-        stage_label: stageDefinition?.label ?? options.stageLabel,
-        contract_type: options.contractType,
-        executor: buildRuntimeExecutorInfo(options.executor),
-        instructions: options.contract.instructions,
-        counts: options.contract.counts,
-        artifacts: options.contract.artifacts,
-        policies: options.contract.policies,
-    };
-    const activeContractPath = writeStageContract(options.verifiableContextPath, contract);
-    const archivedContractPath = writeArchivedStageContract(options.verifiableContextPath, runId, contract);
-    const run = {
-        kind: "interf-run",
-        version: 1,
-        run_id: runId,
-        target_type: "verifiable-context",
-        target_name: options.verifiableContextName,
-        build_plan: options.buildPlan,
-        stage: options.stage,
-        stage_label: stageDefinition?.label ?? options.stageLabel,
-        contract_type: options.contractType,
-        status: "running",
-        executor: buildRuntimeExecutorInfo(options.executor),
-        started_at: generatedAt,
-        updated_at: generatedAt,
-        finished_at: null,
-        contract_path: relative(options.verifiableContextPath, archivedContractPath),
-        ...(options.executionPath ? { execution_path: relative(options.verifiableContextPath, options.executionPath) } : {}),
-        counts: { ...contract.counts },
-        output_artifacts: [...contract.artifacts.writes],
-        logs: {
-            prompt_path: relative(options.verifiableContextPath, promptLogPath(options.verifiableContextPath, runId)),
-            event_stream_path: relative(options.verifiableContextPath, eventLogPath(options.verifiableContextPath, runId)),
-            status_path: relative(options.verifiableContextPath, statusLogPath(options.verifiableContextPath, runId)),
-        },
-        summary: options.summary,
-        exit_code: null,
-        error: null,
-    };
-    return {
-        run: beginRuntimeRun(options.verifiableContextPath, run),
-        activeContractPath: options.executionPath
-            ? "runtime/stage-contract.json"
-            : relative(options.verifiableContextPath, activeContractPath),
-    };
-}
-function finalizeRuntimeRun(dirPath, code) {
-    const current = loadRuntimeRun(dirPath);
-    if (!current)
-        return null;
-    const finishedAt = new Date().toISOString();
-    const next = {
-        ...current,
-        status: code === 0 ? "succeeded" : "failed",
-        updated_at: finishedAt,
-        finished_at: finishedAt,
-        exit_code: code,
-        error: code === 0 ? null : `Executor exited with code ${code}.`,
-        summary: code === 0
-            ? `${current.stage_label} completed successfully.`
-            : `${current.stage_label} failed with exit code ${code}.`,
-    };
-    saveRuntimeRun(dirPath, next);
-    appendFileSync(runHistoryPath(dirPath), JSON.stringify(next) + "\n");
-    return next;
-}
-function writeRuntimeRunPrompt(dirPath, runId, prompt) {
-    mkdirSync(logsDirPath(dirPath), { recursive: true });
-    writeFileSync(promptLogPath(dirPath, runId), `${prompt}\n`);
-}
-function createRunId() {
-    return `run_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
-}
-function replaceOrAppendRunHistoryEntry(dirPath, run) {
-    const historyPath = runHistoryPath(dirPath);
-    if (!existsSync(historyPath)) {
-        appendFileSync(historyPath, JSON.stringify(run) + "\n");
-        return;
-    }
-    const raw = readFileSync(historyPath, "utf8");
-    const lines = raw.split("\n").filter((line) => line.trim().length > 0);
-    let replaced = false;
-    const nextLines = lines.map((line) => {
-        try {
-            const entry = JSON.parse(line);
-            if (entry.run_id === run.run_id) {
-                replaced = true;
-                return JSON.stringify(run);
-            }
-        }
-        catch {
-            // preserve malformed history lines as-is
-        }
-        return line;
-    });
-    if (!replaced)
-        nextLines.push(JSON.stringify(run));
-    writeFileSync(historyPath, `${nextLines.join("\n")}\n`);
-}

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

@@ -1,5 +0,0 @@
-export type { RuntimeRunPatch, RuntimeRunStatus, RuntimeStageContractDraft, RuntimeStageExecutionOptions, RuntimeStageContractOptions, } from "./runtime-types.js";
-export { archivedStageContractPath, eventLogPath, logsDirPath, promptLogPath, runHistoryPath, runPath, stageContractPath, statusLogPath, } from "./runtime-paths.js";
-export { buildStagePrompt } from "./runtime-prompt.js";
-export { buildRuntimeStageContract, } from "./runtime-contracts.js";
-export { beginRuntimeRun, loadRuntimeRun, markRuntimeRunFailedAfterValidation, markRuntimeRunSucceededAfterValidation, runExecutorStage, saveRuntimeRun, updateRuntimeRun, writeStageContract, } from "./runtime-runs.js";

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

@@ -1,4 +0,0 @@
-export { archivedStageContractPath, eventLogPath, logsDirPath, promptLogPath, runHistoryPath, runPath, stageContractPath, statusLogPath, } from "./runtime-paths.js";
-export { buildStagePrompt } from "./runtime-prompt.js";
-export { buildRuntimeStageContract, } from "./runtime-contracts.js";
-export { beginRuntimeRun, loadRuntimeRun, markRuntimeRunFailedAfterValidation, markRuntimeRunSucceededAfterValidation, runExecutorStage, saveRuntimeRun, updateRuntimeRun, writeStageContract, } from "./runtime-runs.js";

package/dist/packages/engine/build/source-files.d.ts

@@ -1,46 +0,0 @@
-import { type SourceFiles, type SourceSnapshot, type StageInputs } from "../../contracts/lib/schema.js";
-export declare function buildVerifiableContextSourceFiles(verifiableContextPath: string, sourcePath?: string, generatedAt?: string): SourceFiles;
-export declare function writeVerifiableContextSourceFiles(verifiableContextPath: string, sourcePath?: string, generatedAt?: string): SourceFiles;
-export declare function buildVerifiableContextSourceSnapshot(options: {
-    verifiableContextPath: string;
-    sourceFiles?: SourceFiles;
-    sourcePath?: string;
-    runId?: string | null;
-    generatedAt?: string;
-}): SourceSnapshot;
-export declare function writeVerifiableContextSourceSnapshot(options: {
-    verifiableContextPath: string;
-    sourceFiles?: SourceFiles;
-    sourcePath?: string;
-    runId?: string | null;
-    generatedAt?: string;
-}): SourceSnapshot;
-export declare function buildBuildStageInputs(options: {
-    buildPlanId: string;
-    stageId: string;
-    snapshot: SourceSnapshot;
-    runId?: string | null;
-    generatedAt?: string;
-}): StageInputs;
-export declare function writeBuildStageInputs(options: {
-    verifiableContextPath: string;
-    buildPlanId: string;
-    stageId: string;
-    snapshot: SourceSnapshot;
-    runId?: string | null;
-    generatedAt?: string;
-}): StageInputs;
-export declare function writeBuildSourceRuntime(options: {
-    verifiableContextPath: string;
-    buildPlanId: string;
-    stageIds: string[];
-    sourcePath?: string;
-    runId?: string | null;
-}): {
-    sourceFiles: SourceFiles;
-    snapshot: SourceSnapshot;
-    stageInputs: StageInputs[];
-};
-export declare function loadVerifiableContextSourceFiles(verifiableContextPath: string): SourceFiles | null;
-export declare function loadVerifiableContextSourceSnapshot(verifiableContextPath: string): SourceSnapshot | null;
-export declare function loadBuildStageInputs(verifiableContextPath: string, stageId: string): StageInputs | null;

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.d.ts

@@ -1,5 +0,0 @@
-export declare function statePath(dirPath: string): string;
-export declare function healthPath(dirPath: string): string;
-export declare function viewSpecPath(dirPath: string): string;
-export declare function sourceFilesPath(dirPath: string): string;
-export declare function sourceSnapshotPath(dirPath: string): string;

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;