@interf/compiler 0.9.5 → 0.16.0

package/dist/packages/{compiler → engine/compile}/reset.js

@@ -14,8 +14,10 @@ const COMPILE_RUNTIME_RESET_ENTRIES = [
     "view-spec.json",
     "inventory.json",
     "run.json",
-    "raw-snapshot.json",
+    "source-files.json",
+    "source-snapshot.json",
     "stage-contract.json",
+    "stages",
 ];
 const PRESERVED_COMPILED_ROOTS = new Set([
     ".agents",

package/dist/packages/{compiler → engine/compile}/runtime-acceptance.js

@@ -1,9 +1,10 @@
 import { existsSync, } from "node:fs";
 import { join } from "node:path";
-import { listFilesRecursive } from "../shared/filesystem.js";
-import { readJsonFileWithSchema } from "../shared/parse.js";
+import { listFilesRecursive } from "../../contracts/utils/filesystem.js";
+import { readJsonFileWithSchema } from "../../contracts/utils/parse.js";
 import { METHOD_SCHEMA_FILE, compiledZoneAbsolutePath, findCompiledSchemaZone, readCompiledSchemaFile, } from "./compiled-schema.js";
 import { RuntimeStageContractSchema, } from "./lib/schema.js";
+import { ACCEPTANCE_RULE_KEYS } from "../../contracts/lib/schema.js";
 import { stageContractPath } from "./runtime-paths.js";
 import { methodPackagePathForCompiled } from "./compiled-paths.js";
 import { loadState } from "./state-io.js";
@@ -17,18 +18,20 @@ function toFiniteNumber(value) {
 function hasAcceptanceRules(acceptance) {
     if (!acceptance)
         return false;
-    return (acceptance.artifacts_exist?.length ?? 0) > 0 ||
-        (acceptance.stage_truthy?.length ?? 0) > 0 ||
-        Object.keys(acceptance.stage_equals_counts ?? {}).length > 0 ||
-        Object.keys(acceptance.stage_at_least ?? {}).length > 0 ||
-        Object.keys(acceptance.stage_at_least_counts ?? {}).length > 0 ||
-        Object.keys(acceptance.zone_counts_at_least ?? {}).length > 0 ||
-        Object.keys(acceptance.zone_counts_at_least_counts ?? {}).length > 0 ||
-        (acceptance.markdown_frontmatter_valid_zones?.length ?? 0) > 0 ||
-        Object.keys(acceptance.frontmatter_required_keys_in_zones ?? {}).length > 0 ||
-        (acceptance.markdown_abstract_valid_zones?.length ?? 0) > 0 ||
-        (acceptance.wikilinks_valid_in_zones?.length ?? 0) > 0 ||
-        Object.keys(acceptance.artifacts_must_not_contain ?? {}).length > 0;
+    // Drive off the canonical rule-key list so a new key added to
+    // contracts/ is automatically considered here.
+    for (const key of ACCEPTANCE_RULE_KEYS) {
+        const value = acceptance[key];
+        if (Array.isArray(value)) {
+            if (value.length > 0)
+                return true;
+        }
+        else if (value && typeof value === "object") {
+            if (Object.keys(value).length > 0)
+                return true;
+        }
+    }
+    return false;
 }
 function readPathValue(record, keyPath) {
     if (!record)

package/dist/packages/{compiler → engine/compile}/runtime-contracts.js

@@ -18,9 +18,6 @@ export function buildRuntimeStageContract(options) {
                 ...localSkillDocs,
             ],
             writes: options.stageWriteArtifacts,
-            verifies: [
-                `interf verify stage ${options.stageId} --json`,
-            ],
         },
         policies: {
             execution_mode: "deterministic",

package/dist/packages/{compiler → engine/compile}/runtime-prompt.js

@@ -39,7 +39,7 @@ export function buildStagePrompt(instructions, contractPath, statusLines) {
         "Do not narrate intentions, plans, or reasoning to the user.",
         "Only emit user-visible updates that begin with STATUS:, DONE:, BLOCKED:, or ERROR:.",
         "Those status lines are progress hints for the operator. The CLI decides stage completion from artifacts, validation, and reconcile checks rather than trusting status text alone.",
-        "Before any long-running raw inspection or shell-based helper step, emit a STATUS: line that names the current subtask.",
+        "Before any long-running source inspection or shell-based helper step, emit a STATUS: line that names the current subtask.",
         "If work stays in progress, do not remain silent for more than about one minute. Emit another STATUS: line when you switch files, page groups, targets, or extraction methods.",
         "If you respond conversationally instead of executing the stage, the run will be treated as failed.",
         "As soon as the required proof artifacts are complete, stop. Do not keep browsing or auditing after the contract is satisfied.",

package/dist/packages/{compiler → engine/compile}/runtime-reconcile.d.ts

@@ -1,2 +1,2 @@
-import { type MethodStageDefinition } from "../method-package/method-definitions.js";
+import { type MethodStageDefinition } from "../../methods/package/method-definitions.js";
 export declare function reconcileCompiledStageRun(dirPath: string, stage: Pick<MethodStageDefinition, "id" | "contractType" | "reads" | "writes">): boolean;

package/dist/packages/{compiler → engine/compile}/runtime-reconcile.js

@@ -1,11 +1,12 @@
 import { existsSync, readFileSync, statSync, writeFileSync, } from "node:fs";
 import { extname, join, relative } from "node:path";
-import { listFilesRecursive } from "../shared/filesystem.js";
+import { listFilesRecursive } from "../../contracts/utils/filesystem.js";
 import { compiledZoneAbsolutePath, findCompiledSchemaZone, readCompiledSchemaFile, } from "./compiled-schema.js";
-import { parseJsonFrontmatter } from "../shared/parse.js";
+import { parseJsonFrontmatter } from "../../contracts/utils/parse.js";
 import { loadRuntimeRun } from "./runtime.js";
 import { initCompiledState, loadState, refreshCompiledArtifacts, saveState, } from "./state.js";
 import { compiledInventoryFromEntries } from "./runtime-inventory.js";
+import { STANDARD_EVIDENCE_FRONTMATTER_KEYS, } from "../../contracts/lib/schema.js";
 import { compiledRuntimeRoot, methodPackagePathForCompiled } from "./compiled-paths.js";
 import { extractSynthAbstract, isOutputMarkdownFile } from "./validate.js";
 function readActiveRunStartedAtMs(dirPath) {
@@ -80,15 +81,16 @@ function buildInventoryMetadata(options) {
         metadata.abstract = abstract;
         metadata.abstract_read = true;
     }
+    // Project the standard evidence frontmatter keys onto the inventory
+    // metadata. Method authors that emit the canonical evidence keys
+    // (`STANDARD_EVIDENCE_FRONTMATTER_KEYS` in contracts) get them
+    // surfaced on stage inventory entries; non-standard keys are ignored.
     const frontmatter = options.parsedFrontmatter.frontmatter;
-    if (typeof frontmatter.source_kind === "string") {
-        metadata.source_kind = frontmatter.source_kind;
-    }
-    if (typeof frontmatter.evidence_tier === "string") {
-        metadata.evidence_tier = frontmatter.evidence_tier;
-    }
-    if (typeof frontmatter.truth_mode === "string") {
-        metadata.truth_mode = frontmatter.truth_mode;
+    for (const key of STANDARD_EVIDENCE_FRONTMATTER_KEYS) {
+        const value = frontmatter[key];
+        if (typeof value === "string") {
+            metadata[key] = value;
+        }
     }
     return metadata;
 }

package/dist/packages/{compiler → engine/compile}/runtime-runs.d.ts

@@ -1,10 +1,9 @@
 import { type RuntimeRun, type RuntimeStageContract } from "./lib/schema.js";
-import { type RuntimeRunPatch, type RuntimeStageExecutionOptions, type RuntimeSummarizeExecutionOptions } from "./runtime-types.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 runExecutorSummarizeStage(options: RuntimeSummarizeExecutionOptions): 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;

package/dist/packages/{compiler → engine/compile}/runtime-runs.js

@@ -1,12 +1,10 @@
 import { appendFileSync, mkdirSync, existsSync, readFileSync, writeFileSync, } from "node:fs";
-import { dirname, join, relative } from "node:path";
-import chalk from "chalk";
-import { countFilesRecursive } from "../shared/filesystem.js";
+import { dirname, relative } from "node:path";
 import { buildRuntimeExecutorInfo } from "../agents/lib/executors.js";
 import { RuntimeRunSchema, } from "./lib/schema.js";
-import { getMethodStageDefinition, getMethodStagePosition, getMethodStages, } from "../method-package/method-definitions.js";
+import { getMethodStageDefinition, getMethodStagePosition, getMethodStages, } from "../../methods/package/method-definitions.js";
 import { archivedStageContractPath, eventLogPath, logsDirPath, promptLogPath, runHistoryPath, runPath, stageContractPath, statusLogPath, } from "./runtime-paths.js";
-import { warnInterf } from "../shared/logger.js";
+import { warnInterf } from "../../contracts/utils/logger.js";
 export function loadRuntimeRun(dirPath) {
     const path = runPath(dirPath);
     if (!existsSync(path))
@@ -54,44 +52,6 @@ export async function runExecutorStage(options) {
     finalizeRuntimeRun(options.compiledPath, code);
     return code;
 }
-export async function runExecutorSummarizeStage(options) {
-    const startedRun = startRuntimeRun(options);
-    const prompt = options.buildPrompt(startedRun.activeContractPath);
-    let lastReported = 0;
-    writeRuntimeRunPrompt(options.compiledPath, startedRun.run.run_id, prompt);
-    const executionPath = options.executionPath ?? options.compiledPath;
-    const progressPromise = options.executor.execute(executionPath, prompt, {
-        eventLogPath: eventLogPath(options.compiledPath, startedRun.run.run_id),
-        statusLogPath: statusLogPath(options.compiledPath, startedRun.run.run_id),
-        completionCheck: options.completionCheck,
-        onStatus: options.onStatus,
-    });
-    const timer = setInterval(() => {
-        const currentSummaryCount = countFilesRecursive(join(options.compiledPath, "summaries"));
-        const completed = Math.max(0, Math.min(options.targetCount, currentSummaryCount - options.startingSummaryCount));
-        if (completed <= lastReported)
-            return;
-        lastReported = completed;
-        updateRuntimeRun(options.compiledPath, {
-            counts: {
-                ...startedRun.run.counts,
-                completed_summaries: completed,
-                target_summaries: options.targetCount,
-            },
-            summary: `${options.stageLabel} ${completed}/${options.targetCount} source files into summaries.`,
-        });
-        console.log(chalk.dim(`  STATUS: wrote ${completed}/${options.targetCount} summaries`));
-        options.onStatus?.(`STATUS: wrote ${completed}/${options.targetCount} summaries`);
-    }, 10000);
-    try {
-        const code = await progressPromise;
-        finalizeRuntimeRun(options.compiledPath, code);
-        return code;
-    }
-    finally {
-        clearInterval(timer);
-    }
-}
 export function beginRuntimeRun(dirPath, run) {
     saveRuntimeRun(dirPath, run);
     return run;

package/dist/packages/{compiler → engine/compile}/runtime-types.d.ts

@@ -1,6 +1,6 @@
 import { type MethodExecutor } from "../agents/lib/executors.js";
 import { type RuntimeRun, type RuntimeStageAcceptance, type RuntimeStageContract, type RuntimeStageInstructions } from "./lib/schema.js";
-import type { MethodId, RuntimeContractType, RuntimeStage } from "../contracts/lib/schema.js";
+import type { MethodId, RuntimeContractType, RuntimeStage } from "../../contracts/lib/schema.js";
 export type RuntimeRunStatus = "running" | "succeeded" | "failed";
 export type RuntimeStageContractDraft = Omit<RuntimeStageContract, "kind" | "version" | "generated_at" | "run_id" | "target_type" | "target_name" | "method" | "stage" | "stage_label" | "contract_type" | "executor">;
 export interface RuntimeStageExecutionOptions {
@@ -19,10 +19,6 @@ export interface RuntimeStageExecutionOptions {
     completionCheck?: (() => boolean) | null;
     onStatus?: (line: string) => void;
 }
-export interface RuntimeSummarizeExecutionOptions extends RuntimeStageExecutionOptions {
-    startingSummaryCount: number;
-    targetCount: number;
-}
 export interface RuntimeStageAcceptanceValidation {
     ok: boolean;
     summary: string;

package/dist/packages/{compiler → engine/compile}/runtime.d.ts

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

package/dist/packages/{compiler → engine/compile}/runtime.js

@@ -2,4 +2,4 @@ export { archivedStageContractPath, eventLogPath, logsDirPath, promptLogPath, ru
 export { validateStageContractAcceptance } from "./runtime-acceptance.js";
 export { buildStagePrompt } from "./runtime-prompt.js";
 export { buildRuntimeStageContract, } from "./runtime-contracts.js";
-export { beginRuntimeRun, loadRuntimeRun, markRuntimeRunFailedAfterValidation, markRuntimeRunSucceededAfterValidation, runExecutorStage, runExecutorSummarizeStage, saveRuntimeRun, updateRuntimeRun, writeStageContract, } from "./runtime-runs.js";
+export { beginRuntimeRun, loadRuntimeRun, markRuntimeRunFailedAfterValidation, markRuntimeRunSucceededAfterValidation, runExecutorStage, saveRuntimeRun, updateRuntimeRun, writeStageContract, } from "./runtime-runs.js";

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

@@ -0,0 +1,46 @@
+import { type SourceFiles, type SourceSnapshot, type StageInputs } from "../../contracts/lib/schema.js";
+export declare function buildCompiledSourceFiles(compiledPath: string, sourcePath?: string, generatedAt?: string): SourceFiles;
+export declare function writeCompiledSourceFiles(compiledPath: string, sourcePath?: string, generatedAt?: string): SourceFiles;
+export declare function buildCompiledSourceSnapshot(options: {
+    compiledPath: string;
+    sourceFiles?: SourceFiles;
+    sourcePath?: string;
+    runId?: string | null;
+    generatedAt?: string;
+}): SourceSnapshot;
+export declare function writeCompiledSourceSnapshot(options: {
+    compiledPath: string;
+    sourceFiles?: SourceFiles;
+    sourcePath?: string;
+    runId?: string | null;
+    generatedAt?: string;
+}): SourceSnapshot;
+export declare function buildCompiledStageInputs(options: {
+    methodId: string;
+    stageId: string;
+    snapshot: SourceSnapshot;
+    runId?: string | null;
+    generatedAt?: string;
+}): StageInputs;
+export declare function writeCompiledStageInputs(options: {
+    compiledPath: string;
+    methodId: string;
+    stageId: string;
+    snapshot: SourceSnapshot;
+    runId?: string | null;
+    generatedAt?: string;
+}): StageInputs;
+export declare function writeCompiledSourceRuntime(options: {
+    compiledPath: string;
+    methodId: string;
+    stageIds: string[];
+    sourcePath?: string;
+    runId?: string | null;
+}): {
+    sourceFiles: SourceFiles;
+    snapshot: SourceSnapshot;
+    stageInputs: StageInputs[];
+};
+export declare function loadCompiledSourceFiles(compiledPath: string): SourceFiles | null;
+export declare function loadCompiledSourceSnapshot(compiledPath: string): SourceSnapshot | null;
+export declare function loadCompiledStageInputs(compiledPath: string, stageId: string): StageInputs | null;

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

@@ -0,0 +1,149 @@
+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 { compiledRuntimeSourceFilesPath, compiledRuntimeSourceSnapshotPath, compiledRuntimeStageInputsPath, } from "./compiled-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 buildCompiledSourceFiles(compiledPath, sourcePath = resolveSourceInputPath(compiledPath), generatedAt = new Date().toISOString()) {
+    const discovery = discoverSourceFiles(sourcePath, compiledPath);
+    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 writeCompiledSourceFiles(compiledPath, sourcePath = resolveSourceInputPath(compiledPath), generatedAt = new Date().toISOString()) {
+    const sourceFiles = buildCompiledSourceFiles(compiledPath, sourcePath, generatedAt);
+    const parsed = SourceFilesSchema.parse(sourceFiles);
+    writeJson(compiledRuntimeSourceFilesPath(compiledPath), parsed);
+    return parsed;
+}
+export function buildCompiledSourceSnapshot(options) {
+    const generatedAt = options.generatedAt ?? new Date().toISOString();
+    const sourceFiles = options.sourceFiles
+        ?? buildCompiledSourceFiles(options.compiledPath, options.sourcePath ?? resolveSourceInputPath(options.compiledPath), 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 writeCompiledSourceSnapshot(options) {
+    const snapshot = SourceSnapshotSchema.parse(buildCompiledSourceSnapshot(options));
+    writeJson(compiledRuntimeSourceSnapshotPath(options.compiledPath), snapshot);
+    return snapshot;
+}
+export function buildCompiledStageInputs(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,
+        method: options.methodId,
+        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 writeCompiledStageInputs(options) {
+    const stageInputs = StageInputsSchema.parse(buildCompiledStageInputs(options));
+    writeJson(compiledRuntimeStageInputsPath(options.compiledPath, options.stageId), stageInputs);
+    return stageInputs;
+}
+export function writeCompiledSourceRuntime(options) {
+    const generatedAt = new Date().toISOString();
+    const sourceFiles = writeCompiledSourceFiles(options.compiledPath, options.sourcePath ?? resolveSourceInputPath(options.compiledPath), generatedAt);
+    const snapshot = writeCompiledSourceSnapshot({
+        compiledPath: options.compiledPath,
+        sourceFiles,
+        runId: options.runId ?? null,
+        generatedAt,
+    });
+    const stageInputs = options.stageIds.map((stageId) => writeCompiledStageInputs({
+        compiledPath: options.compiledPath,
+        methodId: options.methodId,
+        stageId,
+        snapshot,
+        runId: options.runId ?? null,
+        generatedAt,
+    }));
+    return { sourceFiles, snapshot, stageInputs };
+}
+export function loadCompiledSourceFiles(compiledPath) {
+    const filePath = compiledRuntimeSourceFilesPath(compiledPath);
+    if (!existsSync(filePath))
+        return null;
+    return readJsonFileWithSchema(filePath, "compiled source files", SourceFilesSchema);
+}
+export function loadCompiledSourceSnapshot(compiledPath) {
+    const filePath = compiledRuntimeSourceSnapshotPath(compiledPath);
+    if (!existsSync(filePath))
+        return null;
+    return readJsonFileWithSchema(filePath, "compiled source snapshot", SourceSnapshotSchema);
+}
+export function loadCompiledStageInputs(compiledPath, stageId) {
+    const filePath = compiledRuntimeStageInputsPath(compiledPath, stageId);
+    if (!existsSync(filePath))
+        return null;
+    return readJsonFileWithSchema(filePath, "compiled stage inputs", StageInputsSchema);
+}

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

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

package/dist/packages/{compiler → engine/compile}/state-artifacts.js

@@ -1,13 +1,14 @@
 import { saveCompiledHealth, } from "./state-io.js";
 import { computeCompiledHealth, } from "./state-health.js";
-import { ensureCompiledRawSnapshot, ensureCompiledViewSpec, } from "./state-view.js";
+import { ensureCompiledSourceFiles, ensureCompiledSourceSnapshot, ensureCompiledViewSpec, } from "./state-view.js";
 export function refreshCompiledArtifacts(dirPath, options) {
     const health = computeCompiledHealth(dirPath);
     saveCompiledHealth(dirPath, health);
-    const rawSnapshot = ensureCompiledRawSnapshot(dirPath);
+    const sourceFiles = ensureCompiledSourceFiles(dirPath);
+    const sourceSnapshot = ensureCompiledSourceSnapshot(dirPath, sourceFiles);
     let viewSpec;
     if (options?.ensureViewSpec) {
         viewSpec = ensureCompiledViewSpec(dirPath);
     }
-    return { health, viewSpec, rawSnapshot };
+    return { health, viewSpec, sourceFiles, sourceSnapshot };
 }

package/dist/packages/{compiler → engine/compile}/state-health.js

@@ -1,12 +1,12 @@
 import { basename } from "node:path";
-import { readInterfConfig, resolveSourceFolderPath, } from "../project-model/interf-detect.js";
+import { readInterfConfig, resolveSourceFolderPath, } from "../../project/interf-detect.js";
 import { discoverSourceFiles } from "./discovery.js";
 import { loadRuntimeRun } from "./runtime.js";
 import { loadState } from "./state-io.js";
 import { validateCompiled, validateCompiledStage, validateCompiledMethod, } from "./validate.js";
 import { readCompiledSchemaFile } from "./compiled-schema.js";
 import { methodPackagePathForCompiled } from "./compiled-paths.js";
-import { getActiveCompiledMethod, resolveRequiredCompiledMethodFromConfig } from "../method-package/method-definitions.js";
+import { getActiveCompiledMethod, resolveRequiredCompiledMethodFromConfig } from "../../methods/package/method-definitions.js";
 import { countCompiledZoneArtifacts } from "./artifact-counts.js";
 export function computeCompiledHealth(dirPath) {
     const now = new Date().toISOString();

package/dist/packages/{compiler → engine/compile}/state-io.d.ts

@@ -1,10 +1,11 @@
-import { type CompiledHealth, type CompiledRawSnapshot, type CompiledState, type CompiledViewSpec } from "./lib/schema.js";
+import { type CompiledHealth, type CompiledState, type CompiledViewSpec, 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 loadCompiledHealth(dirPath: string): CompiledHealth | null;
 export declare function saveCompiledHealth(dirPath: string, health: CompiledHealth): void;
 export declare function loadCompiledViewSpec(dirPath: string): CompiledViewSpec | null;
 export declare function saveCompiledViewSpec(dirPath: string, viewSpec: CompiledViewSpec): void;
-export declare function loadCompiledRawSnapshot(dirPath: string): CompiledRawSnapshot | null;
+export declare function loadCompiledSourceFiles(dirPath: string): SourceFiles | null;
+export declare function loadCompiledSourceSnapshot(dirPath: string): SourceSnapshot | null;
 export declare function saveEmptyCompiledInventory(dirPath: string): void;
 export declare function initCompiledState(): CompiledState;

package/dist/packages/{compiler → engine/compile}/state-io.js

@@ -1,9 +1,9 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
-import { warnInterf } from "../shared/logger.js";
-import { readJsonFileUnchecked, readJsonFileWithSchema } from "../shared/parse.js";
-import { CompiledHealthSchema, CompiledRawSnapshotSchema, CompiledStateSchema, CompiledViewSpecSchema, } from "./lib/schema.js";
+import { warnInterf } from "../../contracts/utils/logger.js";
+import { readJsonFileUnchecked, readJsonFileWithSchema } from "../../contracts/utils/parse.js";
+import { CompiledHealthSchema, CompiledStateSchema, CompiledViewSpecSchema, SourceFilesSchema, SourceSnapshotSchema, } from "./lib/schema.js";
 import { emptyCompiledInventory, } from "./runtime-inventory.js";
-import { healthPath, rawSnapshotPath, statePath, viewSpecPath } from "./state-paths.js";
+import { healthPath, sourceFilesPath, sourceSnapshotPath, statePath, viewSpecPath, } from "./state-paths.js";
 import { compiledRuntimeInventoryPath, compiledRuntimeRoot, } from "./compiled-paths.js";
 export function loadState(dirPath) {
     const path = statePath(dirPath);
@@ -43,11 +43,17 @@ export function saveCompiledViewSpec(dirPath, viewSpec) {
     mkdirSync(compiledRuntimeRoot(dirPath), { recursive: true });
     writeFileSync(viewSpecPath(dirPath), JSON.stringify(viewSpec, null, 2) + "\n");
 }
-export function loadCompiledRawSnapshot(dirPath) {
-    const path = rawSnapshotPath(dirPath);
+export function loadCompiledSourceFiles(dirPath) {
+    const path = sourceFilesPath(dirPath);
     if (!existsSync(path))
         return null;
-    return readJsonFileWithSchema(path, "compiled raw snapshot", CompiledRawSnapshotSchema);
+    return readJsonFileWithSchema(path, "compiled source files", SourceFilesSchema);
+}
+export function loadCompiledSourceSnapshot(dirPath) {
+    const path = sourceSnapshotPath(dirPath);
+    if (!existsSync(path))
+        return null;
+    return readJsonFileWithSchema(path, "compiled source snapshot", SourceSnapshotSchema);
 }
 export function saveEmptyCompiledInventory(dirPath) {
     mkdirSync(compiledRuntimeRoot(dirPath), { recursive: true });

package/dist/packages/{compiler → engine/compile}/state-paths.d.ts

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

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

@@ -0,0 +1,16 @@
+import { compiledRuntimeHealthPath, compiledRuntimeSourceFilesPath, compiledRuntimeSourceSnapshotPath, compiledRuntimeStatePath, compiledRuntimeViewSpecPath, } from "./compiled-paths.js";
+export function statePath(dirPath) {
+    return compiledRuntimeStatePath(dirPath);
+}
+export function healthPath(dirPath) {
+    return compiledRuntimeHealthPath(dirPath);
+}
+export function viewSpecPath(dirPath) {
+    return compiledRuntimeViewSpecPath(dirPath);
+}
+export function sourceFilesPath(dirPath) {
+    return compiledRuntimeSourceFilesPath(dirPath);
+}
+export function sourceSnapshotPath(dirPath) {
+    return compiledRuntimeSourceSnapshotPath(dirPath);
+}

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

@@ -0,0 +1,5 @@
+import { type CompiledViewSpec, type SourceFiles, type SourceSnapshot } from "./lib/schema.js";
+export declare function ensureCompiledViewSpec(dirPath: string): CompiledViewSpec;
+export declare function ensureCompiledSourceFiles(dirPath: string): SourceFiles;
+export declare function ensureCompiledSourceSnapshot(dirPath: string, sourceFiles?: SourceFiles): SourceSnapshot;
+export declare function normalizeCompiledViewSpec(existing: CompiledViewSpec, defaults?: CompiledViewSpec): CompiledViewSpec;

package/dist/packages/{compiler → engine/compile}/state-view.js

@@ -1,12 +1,10 @@
-import { basename, relative } from "node:path";
-import { mkdirSync, writeFileSync } from "node:fs";
-import { discoverSourceFiles } from "./discovery.js";
-import { readInterfConfig, resolveSourceFolderPath } from "../project-model/interf-detect.js";
-import { loadCompiledViewSpec, saveCompiledViewSpec, } from "./state-io.js";
-import { rawSnapshotPath } from "./state-paths.js";
-import { compiledRuntimeRoot, methodPackagePathForCompiled } from "./compiled-paths.js";
+import { basename } from "node:path";
+import { readInterfConfig, resolveSourceFolderPath } from "../../project/interf-detect.js";
+import { loadCompiledSourceSnapshot, loadCompiledViewSpec, saveCompiledViewSpec, } from "./state-io.js";
+import { methodPackagePathForCompiled } from "./compiled-paths.js";
 import { readCompiledSchemaFile } from "./compiled-schema.js";
-import { getActiveCompiledMethod, resolveRequiredCompiledMethodFromConfig } from "../method-package/method-definitions.js";
+import { getActiveCompiledMethod, resolveRequiredCompiledMethodFromConfig } from "../../methods/package/method-definitions.js";
+import { writeCompiledSourceFiles, writeCompiledSourceSnapshot, } from "./source-files.js";
 export function ensureCompiledViewSpec(dirPath) {
     const existing = loadCompiledViewSpec(dirPath);
     const now = new Date().toISOString();
@@ -22,29 +20,21 @@ export function ensureCompiledViewSpec(dirPath) {
     saveCompiledViewSpec(dirPath, defaults);
     return defaults;
 }
-export function ensureCompiledRawSnapshot(dirPath) {
-    const now = new Date().toISOString();
+export function ensureCompiledSourceFiles(dirPath) {
     const config = readInterfConfig(dirPath);
-    const compiledName = config?.name ?? basename(dirPath);
-    const sourcePath = resolveSourceFolderPath(dirPath, config);
-    const discovery = discoverSourceFiles(sourcePath, dirPath);
-    const sampleFiles = [...discovery.sourceFiles]
-        .sort((a, b) => a.length - b.length || a.localeCompare(b))
-        .slice(0, 10);
-    const sourceRoot = relative(dirPath, sourcePath) || ".";
-    const artifact = {
-        kind: "compiled-raw-snapshot",
-        version: 1,
-        generated_at: now,
-        target_name: compiledName,
-        source_root: sourceRoot,
-        raw_root: sourceRoot,
-        source_total: discovery.totalCount,
-        sample_files: sampleFiles,
-    };
-    mkdirSync(compiledRuntimeRoot(dirPath), { recursive: true });
-    writeFileSync(rawSnapshotPath(dirPath), JSON.stringify(artifact, null, 2) + "\n");
-    return artifact;
+    return writeCompiledSourceFiles(dirPath, resolveSourceFolderPath(dirPath, config));
+}
+export function ensureCompiledSourceSnapshot(dirPath, sourceFiles) {
+    const existing = loadCompiledSourceSnapshot(dirPath);
+    if (existing)
+        return existing;
+    const config = readInterfConfig(dirPath);
+    const resolvedSourceFiles = sourceFiles ?? writeCompiledSourceFiles(dirPath, resolveSourceFolderPath(dirPath, config));
+    return writeCompiledSourceSnapshot({
+        compiledPath: dirPath,
+        sourceFiles: resolvedSourceFiles,
+        runId: null,
+    });
 }
 export function normalizeCompiledViewSpec(existing, defaults) {
     const resolvedDefaults = defaults ?? existing;