@interf/compiler 0.22.2 → 0.33.0

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

@@ -0,0 +1,119 @@
+import { existsSync, readFileSync, } from "node:fs";
+import { warnInterf } from "../../contracts/utils/logger.js";
+import { readJsonFileUnchecked, readJsonFileWithSchema } from "../../contracts/utils/parse.js";
+import { ContextGraphHealthSchema, ContextGraphStateSchema, ContextGraphViewSpecSchema, SourceFilesSchema, SourceManifestSchema, SourceStateSchema, } from "./lib/schema.js";
+import { emptyExecutionInventory, } from "./runtime-inventory.js";
+import { healthPath, sourceManifestPath, sourceFilesPath, sourceStatePath, statePath, viewSpecPath, } from "./state-paths.js";
+import { contextGraphExecutionInventoryPath, } from "./context-graph-paths.js";
+import { writeJsonAtomic } from "./atomic-fs.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 = ContextGraphStateSchema.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) {
+    writeJsonAtomic(statePath(dirPath), state);
+}
+export function loadContextGraphHealth(dirPath) {
+    const path = healthPath(dirPath);
+    if (!existsSync(path))
+        return null;
+    return readJsonFileWithSchema(path, "context-graph health", ContextGraphHealthSchema);
+}
+export function saveContextGraphHealth(dirPath, health) {
+    writeJsonAtomic(healthPath(dirPath), health);
+}
+export function loadContextGraphViewSpec(dirPath) {
+    const path = viewSpecPath(dirPath);
+    if (!existsSync(path))
+        return null;
+    return loadViewSpec(path, ContextGraphViewSpecSchema);
+}
+export function saveContextGraphViewSpec(dirPath, viewSpec) {
+    writeJsonAtomic(viewSpecPath(dirPath), viewSpec);
+}
+export function loadContextGraphSourceManifest(dirPath) {
+    const path = sourceManifestPath(dirPath);
+    if (!existsSync(path))
+        return null;
+    return readJsonFileWithSchema(path, "context-graph source manifest", SourceManifestSchema);
+}
+export function loadContextGraphSourceFiles(dirPath) {
+    const manifest = loadContextGraphSourceManifest(dirPath);
+    if (manifest) {
+        return SourceFilesSchema.parse({
+            kind: "interf-source-files",
+            version: 1,
+            generated_at: manifest.generated_at,
+            source: manifest.source,
+            source_total: manifest.source_total,
+            files: manifest.files.map((file) => ({
+                id: file.id,
+                path: file.path,
+                locator: file.locator,
+                ...(typeof file.size_bytes === "number" ? { size_bytes: file.size_bytes } : {}),
+            })),
+        });
+    }
+    const path = sourceFilesPath(dirPath);
+    if (!existsSync(path))
+        return null;
+    return readJsonFileWithSchema(path, "context-graph source files", SourceFilesSchema);
+}
+export function loadContextGraphSourceState(dirPath) {
+    const manifest = loadContextGraphSourceManifest(dirPath);
+    if (manifest) {
+        return SourceStateSchema.parse({
+            kind: "interf-source-state",
+            version: 1,
+            graph_id: manifest.manifest_id,
+            generated_at: manifest.generated_at,
+            run_id: manifest.run_id,
+            source: manifest.source,
+            source_total: manifest.source_total,
+            files: manifest.files.map((file) => ({
+                id: file.id,
+                path: file.path,
+                locator: file.locator,
+                ...(typeof file.size_bytes === "number" ? { size_bytes: file.size_bytes } : {}),
+            })),
+        });
+    }
+    const path = sourceStatePath(dirPath);
+    if (!existsSync(path))
+        return null;
+    return readJsonFileWithSchema(path, "context-graph source state", SourceStateSchema);
+}
+export function saveEmptyExecutionInventory(dirPath) {
+    writeJsonAtomic(contextGraphExecutionInventoryPath(dirPath), emptyExecutionInventory());
+}
+export function initContextGraphState() {
+    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 → runtime}/build/state-paths.d.ts

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

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

@@ -0,0 +1,22 @@
+import { contextGraphRuntimeHealthPath, contextGraphRuntimeSourceManifestAuditPath, contextGraphRuntimeSourceManifestPath, contextGraphRuntimeSourceFilesPath, contextGraphRuntimeSourceStatePath, contextGraphRuntimeStatePath, contextGraphRuntimeViewSpecPath, } from "./context-graph-paths.js";
+export function statePath(dirPath) {
+    return contextGraphRuntimeStatePath(dirPath);
+}
+export function healthPath(dirPath) {
+    return contextGraphRuntimeHealthPath(dirPath);
+}
+export function viewSpecPath(dirPath) {
+    return contextGraphRuntimeViewSpecPath(dirPath);
+}
+export function sourceManifestPath(dirPath) {
+    return contextGraphRuntimeSourceManifestPath(dirPath);
+}
+export function sourceManifestAuditPath(dirPath) {
+    return contextGraphRuntimeSourceManifestAuditPath(dirPath);
+}
+export function sourceFilesPath(dirPath) {
+    return contextGraphRuntimeSourceFilesPath(dirPath);
+}
+export function sourceStatePath(dirPath) {
+    return contextGraphRuntimeSourceStatePath(dirPath);
+}

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

@@ -0,0 +1,5 @@
+import { type ContextGraphViewSpec, type SourceFiles, type SourceState } from "./lib/schema.js";
+export declare function ensureContextGraphViewSpec(dirPath: string): ContextGraphViewSpec;
+export declare function ensureContextGraphSourceFiles(dirPath: string): SourceFiles;
+export declare function ensureContextGraphSourceState(dirPath: string, sourceFiles?: SourceFiles): SourceState;
+export declare function normalizeContextGraphViewSpec(existing: ContextGraphViewSpec, defaults?: ContextGraphViewSpec): ContextGraphViewSpec;

package/dist/packages/{engine → runtime}/build/state-view.js

@@ -1,42 +1,70 @@
 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 { readInterfConfig, resolveSourceFolderPath } from "../../projects/interf-detect.js";
+import { SourceFilesSchema, SourceStateSchema, } from "./lib/schema.js";
+import { loadContextGraphSourceFiles, loadContextGraphSourceState, loadContextGraphViewSpec, saveContextGraphViewSpec, } from "./state-io.js";
+import { loadContextGraphSourceManifest, sourceManifestToSourceFiles, sourceManifestToSourceState, } from "./source-manifest.js";
+import { buildPlanPackagePathForContextGraph } from "./context-graph-paths.js";
+import { listBuildPlanContextArtifacts, readBuildPlanContextFile } from "./context-graph-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);
+export function ensureContextGraphViewSpec(dirPath) {
+    const existing = loadContextGraphViewSpec(dirPath);
     const now = new Date().toISOString();
-    const verifiableContextName = readInterfConfig(dirPath)?.name ?? basename(dirPath);
-    const defaults = buildDefaultVerifiableContextViewSpec(dirPath, verifiableContextName, now);
+    const contextGraphName = readInterfConfig(dirPath)?.name ?? basename(dirPath);
+    const defaults = buildDefaultContextGraphViewSpec(dirPath, contextGraphName, now);
     if (existing) {
-        const normalized = normalizeVerifiableContextViewSpec(existing, defaults);
+        const normalized = normalizeContextGraphViewSpec(existing, defaults);
         if (JSON.stringify(normalized) !== JSON.stringify(existing)) {
-            saveVerifiableContextViewSpec(dirPath, normalized);
+            saveContextGraphViewSpec(dirPath, normalized);
         }
         return normalized;
     }
-    saveVerifiableContextViewSpec(dirPath, defaults);
+    saveContextGraphViewSpec(dirPath, defaults);
     return defaults;
 }
-export function ensureVerifiableContextSourceFiles(dirPath) {
+export function ensureContextGraphSourceFiles(dirPath) {
+    const existing = loadContextGraphSourceFiles(dirPath);
+    if (existing)
+        return existing;
+    const manifest = loadContextGraphSourceManifest(dirPath);
+    if (manifest)
+        return sourceManifestToSourceFiles(manifest);
     const config = readInterfConfig(dirPath);
-    return writeVerifiableContextSourceFiles(dirPath, resolveSourceFolderPath(dirPath, config));
+    const now = new Date().toISOString();
+    const sourceFiles = SourceFilesSchema.parse({
+        kind: "interf-source-files",
+        version: 1,
+        generated_at: now,
+        source: {
+            id: "src-unscanned",
+            kind: "local-folder",
+            locator: resolveSourceFolderPath(dirPath, config),
+        },
+        source_total: 0,
+        files: [],
+    });
+    return sourceFiles;
 }
-export function ensureVerifiableContextSourceSnapshot(dirPath, sourceFiles) {
-    const existing = loadVerifiableContextSourceSnapshot(dirPath);
+export function ensureContextGraphSourceState(dirPath, sourceFiles) {
+    const existing = loadContextGraphSourceState(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,
+    const manifest = loadContextGraphSourceManifest(dirPath);
+    if (manifest)
+        return sourceManifestToSourceState(manifest);
+    const resolvedSourceFiles = sourceFiles ?? ensureContextGraphSourceFiles(dirPath);
+    const sourceState = SourceStateSchema.parse({
+        kind: "interf-source-state",
+        version: 1,
+        graph_id: "source-manifest-unrecorded",
+        generated_at: resolvedSourceFiles.generated_at,
+        run_id: null,
+        source: resolvedSourceFiles.source,
+        source_total: resolvedSourceFiles.source_total,
+        files: resolvedSourceFiles.files,
     });
+    return sourceState;
 }
-export function normalizeVerifiableContextViewSpec(existing, defaults) {
+export function normalizeContextGraphViewSpec(existing, defaults) {
     const resolvedDefaults = defaults ?? existing;
     return {
         ...resolvedDefaults,
@@ -53,30 +81,29 @@ export function normalizeVerifiableContextViewSpec(existing, defaults) {
             })
             : 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,
+        document_scope: Array.isArray(existing.document_scope) && existing.document_scope.length > 0
+            ? existing.document_scope
+            : resolvedDefaults.document_scope,
     };
 }
-function buildDefaultVerifiableContextViewSpec(dirPath, verifiableContextName, generatedAt) {
+function buildDefaultContextGraphViewSpec(dirPath, contextGraphName, generatedAt) {
     const config = readInterfConfig(dirPath);
     resolveRequiredBuildPlanFromConfig(config, `.interf/interf.json for ${dirPath}`);
     const buildPlan = getActiveBuildPlan(dirPath);
-    const schema = readBuildPlanContextFile(buildPlanPackagePathForVerifiableContext(dirPath));
+    const schema = readBuildPlanContextFile(buildPlanPackagePathForContextGraph(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;
+    const defaultNote = schemaArtifacts.find((artifact) => artifact.kind === "file")?.path ?? null;
     return {
-        kind: "verifiable-context-view-spec",
+        kind: "context-graph-view-spec",
         version: 2,
         generated_at: generatedAt,
-        target_name: verifiableContextName,
+        target_name: contextGraphName,
         health_source: ".interf/runtime/health.json",
         state_source: ".interf/runtime/state.json",
         default_note: defaultNote,
-        graph_scope: outputDocumentPaths,
+        document_scope: outputDocumentPaths,
         cards: [
             { id: "source-total", label: "Source Files", metric: "source_total", format: "number" },
             { id: "stage-total", label: "Stages", metric: "stage_total", format: "number" },

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

@@ -0,0 +1,7 @@
+export type { RuntimeStatus, BuildStage, ContextGraphState, ContextGraphHealth, ViewSection, ViewCard, ContextGraphViewSpec, SourceFiles, SourceState, StageInputs, } from "./lib/schema.js";
+export { statePath, healthPath, viewSpecPath, sourceFilesPath, sourceStatePath, } from "./state-paths.js";
+export { loadState, saveState, loadContextGraphHealth, saveContextGraphHealth, loadContextGraphViewSpec, loadContextGraphSourceFiles, loadContextGraphSourceState, saveContextGraphViewSpec, initContextGraphState, } from "./state-io.js";
+export { refreshContextGraphArtifacts, } from "./state-artifacts.js";
+export { computeContextGraphHealth, resolveContextGraphStatus, resolveBuildStage, } from "./state-health.js";
+export { ensureContextGraphViewSpec, ensureContextGraphSourceFiles, ensureContextGraphSourceState, normalizeContextGraphViewSpec, } from "./state-view.js";
+export declare function initializeBuildRuntimeState(dirPath: string): void;

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

@@ -0,0 +1,12 @@
+export { statePath, healthPath, viewSpecPath, sourceFilesPath, sourceStatePath, } from "./state-paths.js";
+export { loadState, saveState, loadContextGraphHealth, saveContextGraphHealth, loadContextGraphViewSpec, loadContextGraphSourceFiles, loadContextGraphSourceState, saveContextGraphViewSpec, initContextGraphState, } from "./state-io.js";
+export { refreshContextGraphArtifacts, } from "./state-artifacts.js";
+export { computeContextGraphHealth, resolveContextGraphStatus, resolveBuildStage, } from "./state-health.js";
+export { ensureContextGraphViewSpec, ensureContextGraphSourceFiles, ensureContextGraphSourceState, normalizeContextGraphViewSpec, } from "./state-view.js";
+import { saveEmptyExecutionInventory, initContextGraphState, saveState } from "./state-io.js";
+import { refreshContextGraphArtifacts } from "./state-artifacts.js";
+export function initializeBuildRuntimeState(dirPath) {
+    saveState(dirPath, initContextGraphState());
+    saveEmptyExecutionInventory(dirPath);
+    refreshContextGraphArtifacts(dirPath, { ensureViewSpec: true });
+}

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

@@ -0,0 +1,30 @@
+/**
+ * Traces builder — evidence rollup for humans.
+ *
+ * Traces are the visible product. "20 of 20 files processed, 847 pages
+ * read, 18 charts extracted, 92 entities found, 12 checks passed." Each
+ * trace rolls up one quantifiable piece of evidence the user can verify
+ * at a glance.
+ *
+ * Traces are derived (not stored): the builder walks the current
+ * Context Graph's artifacts + Checks / benchmark results + source file index and
+ * rolls them into a single Traces wire shape per request. Future
+ * enhancement: cache the rolled-up Traces on the Context Graph manifest
+ * so Context Graph bundles ship with traces attached.
+ */
+import type { ArtifactStatus, Readiness } from "../../contracts/lib/schema.js";
+import type { Traces } from "../../contracts/lib/project-schema.js";
+export interface BuildTracesInput {
+    projectId: string;
+    graphId: string;
+    readiness: Readiness | null;
+    artifacts: readonly ArtifactStatus[];
+    sourceFileCount: number;
+    filesProcessed?: number;
+    generatedAt?: string;
+}
+/**
+ * Build a Traces wire shape from the inputs available after a Build.
+ * Empty/safe when the Project has no Context Graph yet.
+ */
+export declare function buildTraces(input: BuildTracesInput): Traces;

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

@@ -0,0 +1,133 @@
+/**
+ * Traces builder — evidence rollup for humans.
+ *
+ * Traces are the visible product. "20 of 20 files processed, 847 pages
+ * read, 18 charts extracted, 92 entities found, 12 checks passed." Each
+ * trace rolls up one quantifiable piece of evidence the user can verify
+ * at a glance.
+ *
+ * Traces are derived (not stored): the builder walks the current
+ * Context Graph's artifacts + Checks / benchmark results + source file index and
+ * rolls them into a single Traces wire shape per request. Future
+ * enhancement: cache the rolled-up Traces on the Context Graph manifest
+ * so Context Graph bundles ship with traces attached.
+ */
+function clampObservedCount(value, total) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return 0;
+    return Math.min(Math.max(0, Math.trunc(value)), total);
+}
+/**
+ * Build a Traces wire shape from the inputs available after a Build.
+ * Empty/safe when the Project has no Context Graph yet.
+ */
+export function buildTraces(input) {
+    const generatedAt = input.generatedAt ?? new Date().toISOString();
+    const sourceFiles = input.sourceFileCount;
+    // Files-processed is evidence-backed. Source inventory gives the
+    // denominator; Build evidence or accepted stage evidence must provide the
+    // observed value.
+    const filesProcessed = clampObservedCount(input.filesProcessed, sourceFiles);
+    const filesTotal = sourceFiles;
+    const check_results = input.artifacts.flatMap((artifact) => artifact.check_results ?? []);
+    const requiredCheckResults = check_results.filter((result) => result.required !== false);
+    const checksTotal = requiredCheckResults.length;
+    const checksPassed = requiredCheckResults.filter((result) => result.passed).length;
+    // Phase B quantitative signals — sum any stage-emitted counts that surface
+    // through `CheckResult.details`. Stages opt in by writing { pages_read,
+    // charts_extracted, entities_found } into their check-result details; unwired
+    // stages contribute zero. The top-level Traces shape exposes the totals
+    // when at least one stage emitted; otherwise the fields stay undefined.
+    const sumDetail = (key) => {
+        let total = 0;
+        let saw = false;
+        for (const result of check_results) {
+            const raw = result.details?.[key];
+            if (typeof raw === "number" && Number.isFinite(raw) && raw >= 0) {
+                total += Math.trunc(raw);
+                saw = true;
+            }
+        }
+        return saw ? total : -1;
+    };
+    const pagesRead = sumDetail("pages_read");
+    const chartsExtracted = sumDetail("charts_extracted");
+    const entitiesFound = sumDetail("entities_found");
+    const items = [];
+    if (sourceFiles > 0) {
+        items.push({
+            kind: "files-processed",
+            label: "Source files processed",
+            count: filesProcessed,
+            total: sourceFiles,
+            passed: filesProcessed >= sourceFiles,
+            detail: filesProcessed >= sourceFiles
+                ? "Build evidence covers every Source file."
+                : `${sourceFiles - filesProcessed} Source file${sourceFiles - filesProcessed === 1 ? "" : "s"} lack accepted Build evidence.`,
+        });
+    }
+    if (pagesRead >= 0) {
+        items.push({
+            kind: "pages-read",
+            label: "Pages read",
+            count: pagesRead,
+            passed: true,
+        });
+    }
+    if (chartsExtracted >= 0) {
+        items.push({
+            kind: "charts-extracted",
+            label: "Charts extracted",
+            count: chartsExtracted,
+            passed: true,
+        });
+    }
+    if (entitiesFound >= 0) {
+        items.push({
+            kind: "entities-found",
+            label: "Entities found",
+            count: entitiesFound,
+            passed: true,
+        });
+    }
+    for (const artifact of input.artifacts) {
+        items.push({
+            kind: `artifact:${artifact.artifact_id}`,
+            label: artifact.summary ?? `Artifact ${artifact.artifact_id}`,
+            passed: artifact.status === "ready",
+            detail: artifact.status === "ready"
+                ? "Built; checks passed."
+                : artifact.status === "failed"
+                    ? "Build failed."
+                    : artifact.status === "not_ready"
+                        ? "Checks did not pass."
+                        : "Skipped.",
+        });
+    }
+    if (checksTotal > 0) {
+        items.push({
+            kind: "checks",
+            label: "Checks passed",
+            count: checksPassed,
+            total: checksTotal,
+            passed: checksPassed === checksTotal,
+        });
+    }
+    const ready = input.readiness?.ready ?? false;
+    return {
+        kind: "interf-context-graph-traces",
+        version: 1,
+        generated_at: generatedAt,
+        graph_id: input.graphId,
+        project_id: input.projectId,
+        files_processed: filesProcessed,
+        files_total: filesTotal,
+        checks_passed: checksPassed,
+        checks_total: checksTotal,
+        ready,
+        ...(pagesRead >= 0 ? { pages_read: pagesRead } : {}),
+        ...(chartsExtracted >= 0 ? { charts_extracted: chartsExtracted } : {}),
+        ...(entitiesFound >= 0 ? { entities_found: entitiesFound } : {}),
+        items,
+    };
+}

package/dist/packages/{engine/build/validate-verifiable-context.d.ts → runtime/build/validate-context-graph.d.ts}

@@ -1,4 +1,4 @@
-export interface VerifiableContextValidationSummary {
+export interface ContextGraphValidationSummary {
     config_present: boolean;
     config_valid: boolean;
     config_type_match: boolean;
@@ -16,12 +16,12 @@ export interface BuildStageValidation {
     checks: Record<string, boolean>;
     errors: string[];
 }
-export interface VerifiableContextValidation extends BuildStageValidation {
+export interface ContextGraphValidation extends BuildStageValidation {
     stage_results: Record<string, boolean>;
 }
-export declare function validateVerifiableContextSetup(dirPath: string): VerifiableContextValidationSummary;
+export declare function validateContextGraphSetup(dirPath: string): ContextGraphValidationSummary;
 export declare function validateBuildStage(dirPath: string, stageId: string): BuildStageValidation;
-export declare function validateVerifiableContext(dirPath: string): VerifiableContextValidation;
+export declare function validateContextGraph(dirPath: string): ContextGraphValidation;
 export declare function validateBuildSummarize(dirPath: string): BuildStageValidation;
-export declare function validateVerifiableContextStructure(dirPath: string): BuildStageValidation;
-export declare function validateBuildOutput(dirPath: string): VerifiableContextValidation;
+export declare function validateContextGraphStructure(dirPath: string): BuildStageValidation;
+export declare function validateBuildOutput(dirPath: string): ContextGraphValidation;