@interf/compiler 0.22.2 → 0.50.0

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

@@ -1,94 +0,0 @@
-import { basename } from "node:path";
-import { readInterfConfig, resolveSourceFolderPath } from "../../project/interf-detect.js";
-import { loadVerifiableContextSourceSnapshot, loadVerifiableContextViewSpec, saveVerifiableContextViewSpec, } from "./state-io.js";
-import { buildPlanPackagePathForVerifiableContext } from "./verifiable-context-paths.js";
-import { listBuildPlanContextArtifacts, readBuildPlanContextFile } from "./verifiable-context-schema.js";
-import { getActiveBuildPlan, resolveRequiredBuildPlanFromConfig } from "../../build-plans/package/build-plan-definitions.js";
-import { writeVerifiableContextSourceFiles, writeVerifiableContextSourceSnapshot, } from "./source-files.js";
-export function ensureVerifiableContextViewSpec(dirPath) {
-    const existing = loadVerifiableContextViewSpec(dirPath);
-    const now = new Date().toISOString();
-    const verifiableContextName = readInterfConfig(dirPath)?.name ?? basename(dirPath);
-    const defaults = buildDefaultVerifiableContextViewSpec(dirPath, verifiableContextName, now);
-    if (existing) {
-        const normalized = normalizeVerifiableContextViewSpec(existing, defaults);
-        if (JSON.stringify(normalized) !== JSON.stringify(existing)) {
-            saveVerifiableContextViewSpec(dirPath, normalized);
-        }
-        return normalized;
-    }
-    saveVerifiableContextViewSpec(dirPath, defaults);
-    return defaults;
-}
-export function ensureVerifiableContextSourceFiles(dirPath) {
-    const config = readInterfConfig(dirPath);
-    return writeVerifiableContextSourceFiles(dirPath, resolveSourceFolderPath(dirPath, config));
-}
-export function ensureVerifiableContextSourceSnapshot(dirPath, sourceFiles) {
-    const existing = loadVerifiableContextSourceSnapshot(dirPath);
-    if (existing)
-        return existing;
-    const config = readInterfConfig(dirPath);
-    const resolvedSourceFiles = sourceFiles ?? writeVerifiableContextSourceFiles(dirPath, resolveSourceFolderPath(dirPath, config));
-    return writeVerifiableContextSourceSnapshot({
-        verifiableContextPath: dirPath,
-        sourceFiles: resolvedSourceFiles,
-        runId: null,
-    });
-}
-export function normalizeVerifiableContextViewSpec(existing, defaults) {
-    const resolvedDefaults = defaults ?? existing;
-    return {
-        ...resolvedDefaults,
-        ...existing,
-        cards: Array.isArray(existing.cards) && existing.cards.length > 0
-            ? existing.cards.map((card) => {
-                if (card.format !== "fraction" || card.denominator_metric)
-                    return card;
-                const defaultCard = resolvedDefaults.cards.find((candidate) => candidate.id === card.id);
-                return {
-                    ...card,
-                    denominator_metric: defaultCard?.denominator_metric ?? "stage_total",
-                };
-            })
-            : resolvedDefaults.cards,
-        sections: Array.isArray(existing.sections) && existing.sections.length > 0 ? existing.sections : resolvedDefaults.sections,
-        graph_scope: Array.isArray(existing.graph_scope) && existing.graph_scope.length > 0
-            ? existing.graph_scope
-            : resolvedDefaults.graph_scope,
-    };
-}
-function buildDefaultVerifiableContextViewSpec(dirPath, verifiableContextName, generatedAt) {
-    const config = readInterfConfig(dirPath);
-    resolveRequiredBuildPlanFromConfig(config, `.interf/interf.json for ${dirPath}`);
-    const buildPlan = getActiveBuildPlan(dirPath);
-    const schema = readBuildPlanContextFile(buildPlanPackagePathForVerifiableContext(dirPath));
-    const schemaArtifacts = schema ? listBuildPlanContextArtifacts(schema) : [];
-    const outputDocumentPaths = schemaArtifacts
-        .filter((artifact) => artifact.role === "output" && artifact.kind !== "runtime")
-        .map((artifact) => artifact.path);
-    const defaultNote = schemaArtifacts.find((artifact) => artifact.role === "output" && artifact.kind === "file")?.path ?? null;
-    return {
-        kind: "verifiable-context-view-spec",
-        version: 2,
-        generated_at: generatedAt,
-        target_name: verifiableContextName,
-        health_source: ".interf/runtime/health.json",
-        state_source: ".interf/runtime/state.json",
-        default_note: defaultNote,
-        graph_scope: outputDocumentPaths,
-        cards: [
-            { id: "source-total", label: "Source Files", metric: "source_total", format: "number" },
-            { id: "stage-total", label: "Stages", metric: "stage_total", format: "number" },
-            { id: "completed-stages", label: "Completed", metric: "completed_stages", denominator_metric: "stage_total", format: "fraction" },
-        ],
-        sections: [
-            { id: "status", type: "status", title: "Build Status", path: ".interf/runtime/health.json" },
-            { id: "cards", type: "cards", title: "Key Metrics", path: ".interf/runtime/health.json" },
-            ...(outputDocumentPaths.length > 0
-                ? [{ id: "outputs", type: "documents", title: "Output Artifacts", paths: outputDocumentPaths }]
-                : []),
-            { id: "build-plan", type: "documents", title: "Build Plan Docs", paths: ["build-plan/README.md", ...buildPlan.stages.map((stage) => `build-plan/build/stages/${stage.skillDir}`)] },
-        ],
-    };
-}

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;

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

@@ -1,126 +0,0 @@
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { warnInterf } from "../../contracts/utils/logger.js";
-import { readJsonFileUnchecked } from "../../contracts/utils/parse.js";
-import { listBuiltinBuildPlanArtifactSpecs, requiredBuildPlanArtifactOwners, } from "../../build-plans/package/builtin-build-plan.js";
-import { BuildPlanContextSchemaSchema, } from "./lib/schema.js";
-export const BUILD_PLAN_SCHEMA_FILE = "build-plan.schema.json";
-export function buildPlanSchemaFilePath(rootPath) {
-    return join(rootPath, BUILD_PLAN_SCHEMA_FILE);
-}
-export function resolveBuildPlanSchemaPath(rootPath) {
-    const path = buildPlanSchemaFilePath(rootPath);
-    return existsSync(path) ? path : null;
-}
-export function buildPlanSchemaExists(rootPath) {
-    return existsSync(buildPlanSchemaFilePath(rootPath));
-}
-export function buildPlanSchemaRelativePath() {
-    return `build-plan/${BUILD_PLAN_SCHEMA_FILE}`;
-}
-export function listBuildPlanContextArtifacts(schema) {
-    return schema.artifacts.map(artifactToBuildPlanArtifact);
-}
-export function findBuildPlanContextArtifact(schema, artifactId) {
-    return listBuildPlanContextArtifacts(schema).find((artifact) => artifact.id === artifactId) ?? null;
-}
-export function verifiableContextArtifactAbsolutePath(verifiableContextPath, artifact) {
-    return join(verifiableContextPath, artifact.path);
-}
-export function verifiableContextArtifactPath(artifact) {
-    if (artifact.kind === "file")
-        return artifact.path;
-    return artifact.path.endsWith("/") ? artifact.path : `${artifact.path}/`;
-}
-export function verifiableContextArtifactPathsForArtifactIds(schema, artifactIds) {
-    return artifactIds.map((artifactId) => {
-        const artifact = findBuildPlanContextArtifact(schema, artifactId);
-        if (!artifact) {
-            throw new Error(`Build Plan schema is missing declared Artifact "${artifactId}".`);
-        }
-        return verifiableContextArtifactPath(artifact);
-    });
-}
-export function ensureBuildPlanArtifactTargets(verifiableContextPath, schema) {
-    for (const artifact of listBuildPlanContextArtifacts(schema)) {
-        if (artifact.kind === "directory" || artifact.kind === "runtime") {
-            mkdirSync(verifiableContextArtifactAbsolutePath(verifiableContextPath, artifact), { recursive: true });
-            continue;
-        }
-        mkdirSync(dirname(verifiableContextArtifactAbsolutePath(verifiableContextPath, artifact)), { recursive: true });
-    }
-}
-function normalizeBuildPlanContextSchema(schema) {
-    return {
-        ...schema,
-        kind: "build-plan-schema",
-    };
-}
-function artifactToBuildPlanArtifact(artifact) {
-    if (artifact.shape.kind !== "path") {
-        return {
-            id: artifact.id,
-            role: "output",
-            path: artifact.id,
-            kind: "directory",
-            required: true,
-            owned_by: [...artifact.built_by_stages],
-            description: artifact.description,
-        };
-    }
-    return {
-        id: artifact.id,
-        role: "output",
-        path: artifact.shape.path,
-        kind: artifact.shape.artifact_kind,
-        required: true,
-        owned_by: [...artifact.built_by_stages],
-        description: artifact.description,
-    };
-}
-export function buildBuildPlanContextSchema(stages, label = "Build Plan schema") {
-    return {
-        kind: "build-plan-schema",
-        version: 1,
-        target_type: "verifiable-context",
-        label,
-        artifacts: listBuiltinBuildPlanArtifactSpecs().map((artifact) => ({
-            id: artifact.id,
-            description: artifact.description,
-            shape: {
-                kind: "path",
-                path: artifact.path,
-                artifact_kind: artifact.kind === "file" ? "file" : "directory",
-            },
-            checks: [],
-            built_by_stages: requiredBuildPlanArtifactOwners(stages, artifact.id),
-        })),
-    };
-}
-export function writeBuildPlanContextSchemaFile(rootPath, stages, label) {
-    const schema = buildBuildPlanContextSchema(stages, label);
-    writeBuildPlanContextSchemaDocument(rootPath, schema);
-    return schema;
-}
-export function writeBuildPlanContextSchemaDocument(rootPath, schema) {
-    const normalized = normalizeBuildPlanContextSchema(schema);
-    writeFileSync(buildPlanSchemaFilePath(rootPath), `${JSON.stringify(normalized, null, 2)}\n`);
-    return normalized;
-}
-export function readBuildPlanContextSchemaFile(rootPath) {
-    const path = buildPlanSchemaFilePath(rootPath);
-    if (!existsSync(path))
-        return null;
-    const raw = readJsonFileUnchecked(path, "Build Plan schema");
-    if (raw === null)
-        return null;
-    const parsed = BuildPlanContextSchemaSchema.safeParse(raw);
-    if (!parsed.success) {
-        warnInterf(`Warning: failed to validate Build Plan schema at ${path}: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
-        return null;
-    }
-    return normalizeBuildPlanContextSchema(parsed.data);
-}
-export function readBuildPlanContextFile(rootPath) {
-    return readBuildPlanContextSchemaFile(rootPath);
-}

package/dist/packages/engine/cloud-seams.d.ts

@@ -1,115 +0,0 @@
-/**
- * 0.17 — interface seams for the future cloud variant.
- *
- * These types document the injection points a cloud variant of the
- * engine slots into without forking. The local binary keeps its
- * in-process implementations (private `Map` fields on the runtime,
- * the per-instance bearer-token check in `server.ts`); cloud variants
- * provide their own implementations and pass them through
- * `startLocalService` / `LocalServiceRuntimeOptions`.
- *
- * Each seam below is paired with a `TODO(cloud)` marker at the
- * concrete call site so the cloud variant has a clear "wire this
- * through" landing pad. Local default behavior is unchanged in 0.17.
- */
-/**
- * **B4.1 — `IdempotencyStore` (E-1 in the 0.16 architecture audit).**
- *
- * Backs the `POS../../build-runs` idempotency-key dedupe cache. The
- * in-process `Map` cache works for one local engine; multi-replica
- * cloud needs a shared store (Redis-shaped) so a retry that lands on
- * a different replica hits the same dedupe entry.
- *
- * Local default: in-memory map on the runtime.
- *
- * Cloud injection: wrap a Redis client (or equivalent shared store).
- */
-export interface IdempotencyStore {
-    get(scope: string, key: string): {
-        runId: string;
-        expiresAt: number;
-    } | null;
-    set(scope: string, key: string, value: {
-        runId: string;
-        expiresAt: number;
-    }): void;
-    delete(scope: string, key: string): void;
-    prune(now: number): void;
-    size(): number;
-}
-/**
- * **B4.2 — `RunLeaseStore` (I-1 in the 0.16 architecture audit).**
- *
- * Tracks active Build runs so the engine can cancel them and reject
- * concurrent run starts on the same preparation. The local default uses
- * the runtime's `activeBuildRuns` map; multi-replica cloud needs a
- * shared lease store with heartbeat so a replica can take over a run
- * whose owning replica died.
- *
- * Local default: in-memory map on the runtime.
- *
- * Cloud injection: shared lease store with heartbeat (Redis lease,
- * Cassandra LWT, etc.) plus a `listActive()` heartbeat scan.
- */
-export interface RunLeaseStore {
-    acquire(runId: string, lease: RunLeaseEntry): void;
-    release(runId: string): void;
-    get(runId: string): RunLeaseEntry | null;
-    markCancelled(runId: string): void;
-    listActive(): Iterable<{
-        runId: string;
-        lease: RunLeaseEntry;
-    }>;
-}
-export interface RunLeaseEntry {
-    prepDataDir: string;
-    preparation: string;
-    cancelled: boolean;
-    cancelledAt?: string;
-}
-/**
- * **B4.3 — `tokenValidator` (S-2 in the 0.16 architecture audit).**
- *
- * Local default: every accepted token is treated equivalently — the
- * engine carries a single bearer token at startup, and any request
- * presenting that token is authorized. Cloud needs a per-account
- * token issuer + validator so the engine can attach an `account_id`
- * to billing events (Phase F) and scope writes per-account.
- *
- * Local default: configured bearer or `null` (loopback).
- *
- * Cloud injection: validate against a token-issuer service, return
- * the `account_id` so downstream code can attach it to runs and
- * billing events.
- */
-export type TokenValidator = (token: string) => TokenValidation | Promise<TokenValidation>;
-export interface TokenValidation {
-    ok: boolean;
-    account_id: string | null;
-    reason?: string;
-}
-export declare class InMemoryIdempotencyStore implements IdempotencyStore {
-    private buckets;
-    get(scope: string, key: string): {
-        runId: string;
-        expiresAt: number;
-    } | null;
-    set(scope: string, key: string, value: {
-        runId: string;
-        expiresAt: number;
-    }): void;
-    delete(scope: string, key: string): void;
-    prune(now: number): void;
-    size(): number;
-}
-export declare class InMemoryRunLeaseStore implements RunLeaseStore {
-    private leases;
-    acquire(runId: string, lease: RunLeaseEntry): void;
-    release(runId: string): void;
-    get(runId: string): RunLeaseEntry | null;
-    markCancelled(runId: string): void;
-    listActive(): Iterable<{
-        runId: string;
-        lease: RunLeaseEntry;
-    }>;
-}