@interf/compiler 0.9.4 → 0.13.0

package/dist/packages/testing/readiness-check-run.d.ts

@@ -14,21 +14,21 @@ export interface ReadinessCheckRunResult {
     preparationConfig: SourcePreparationConfig;
     portableContextPath: string | null;
     mode: TestRunMode;
-    rawOutcome: SavedReadinessCheckOutcome | null;
+    sourceFilesOutcome: SavedReadinessCheckOutcome | null;
     compiledOutcome: SavedReadinessCheckOutcome | null;
-    comparisonRunPath: string | null;
-    comparison: ReadinessCheckRun | null;
+    readinessRunPath: string | null;
+    readinessRun: ReadinessCheckRun | null;
 }
 export declare function readinessPassRate(outcome: SavedReadinessCheckOutcome): number;
-export declare function readSavedReadinessCheckRun(projectPath: string, preparationName: string): ReadinessCheckRun | null;
+export declare function readSavedReadinessCheckRun(prepDataDir: string, preparationName: string): ReadinessCheckRun | null;
 export declare function parseReadinessCheckRun(value: unknown): ReadinessCheckRun | null;
 export declare function readReadinessCheckRunAtPath(filePath: string, label?: string): ReadinessCheckRun | null;
 export declare function readCurrentSavedReadinessCheckRun(options: {
-    projectPath: string;
+    prepDataDir: string;
     preparationName: string;
     checks: SourcePreparationConfig["checks"];
 }): {
-    comparison: ReadinessCheckRun | null;
+    readinessRun: ReadinessCheckRun | null;
     stale: boolean;
 };
 export declare function saveReadinessCheckRun(options: {
@@ -37,7 +37,7 @@ export declare function saveReadinessCheckRun(options: {
     preparationName: string;
     checksFingerprint: string;
     mode: TestRunMode;
-    rawOutcome: SavedReadinessCheckOutcome | null;
+    sourceFilesOutcome: SavedReadinessCheckOutcome | null;
     compiledOutcome: SavedReadinessCheckOutcome | null;
 }): string;
 export declare function runSavedSourceFilesCheck(options: {

package/dist/packages/testing/readiness-check-run.js

@@ -1,11 +1,11 @@
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { buildTestSpecFromCompiledPreparationConfig, buildTestSpecFromSourceFolderConfig, fingerprintReadinessChecks, resolveSourcePreparationPath, } from "../project-model/source-config.js";
-import { preparationLatestReadinessRunPath, preparationLatestReadinessSummaryPath, preparationTestRunPath, preparationTestRunsRoot, normalizePreparationTestRunId, portableContextPath, } from "../project-model/project-paths.js";
+import { asPreparationDataDir, preparationLatestReadinessRunPath, preparationLatestReadinessSummaryPath, preparationTestRunPath, preparationTestRunsRoot, normalizePreparationTestRunId, preparationPortableContextPath, } from "../contracts/lib/preparation-paths.js";
 import { testRootForCompiled } from "../compiler/compiled-paths.js";
 import { readJsonFileWithSchema } from "../shared/parse.js";
 import { resolveMethodId } from "../methods/method-resolution.js";
-import { createCompiledTestTarget, createRawTestTarget, runTargetTestsAuto, saveTargetTestRun, } from "./test.js";
+import { createCompiledTestTarget, createSourceFilesTestTarget, runTargetTestsAuto, saveTargetTestRun, } from "./test.js";
 import { ReadinessCheckRunSchema, } from "./lib/schema.js";
 export function readinessPassRate(outcome) {
     return outcome.result.totalCases > 0
@@ -28,9 +28,9 @@ function summarizeSavedTestOutcome(label, outcome) {
     };
 }
 function writePreparationTargetRun(options) {
-    const dirPath = preparationTestRunsRoot(options.projectPath, options.preparationName, options.target);
+    const dirPath = preparationTestRunsRoot(asPreparationDataDir(options.prepDataDir), options.preparationName, options.target);
     mkdirSync(dirPath, { recursive: true });
-    const runPath = preparationTestRunPath(options.projectPath, options.preparationName, options.target, options.generatedAt, options.runId, options.runSuffix);
+    const runPath = preparationTestRunPath(asPreparationDataDir(options.prepDataDir), options.preparationName, options.target, options.generatedAt, options.runId, options.runSuffix);
     writeFileSync(runPath, `${JSON.stringify(options.payload, null, 2)}\n`);
     return runPath;
 }
@@ -41,27 +41,23 @@ function renderLatestSummaryMarkdown(payload) {
         "| Target | Readiness checks |",
         "| --- | --- |",
     ];
-    if (payload.raw) {
-        lines.push(`| Source files | \`${payload.raw.passed_cases}/${payload.raw.total_cases}\` |`);
+    if (payload.source_files) {
+        lines.push(`| Source files | \`${payload.source_files.passed_cases}/${payload.source_files.total_cases}\` |`);
     }
     if (payload.compiled) {
         lines.push(`| Portable Context | \`${payload.compiled.passed_cases}/${payload.compiled.total_cases}\` |`);
     }
     lines.push("");
-    if (payload.summary.raw_pass_rate != null && payload.summary.compiled_pass_rate != null) {
-        const direction = (payload.summary.pass_rate_delta ?? 0) >= 0 ? "improved" : "decreased";
-        lines.push(`Readiness-check pass rate ${direction} from ${payload.summary.raw_pass_rate}% to ${payload.summary.compiled_pass_rate}%.`, "");
-    }
-    if (payload.raw) {
-        lines.push(`- Latest source-files run: ${payload.raw.run_path}`);
+    if (payload.source_files) {
+        lines.push(`- Latest source-files run: ${payload.source_files.run_path}`);
     }
     if (payload.compiled) {
         lines.push(`- Latest portable-context run: ${payload.compiled.run_path}`);
     }
     return `${lines.join("\n")}\n`;
 }
-export function readSavedReadinessCheckRun(projectPath, preparationName) {
-    const latestPath = preparationLatestReadinessRunPath(projectPath, preparationName);
+export function readSavedReadinessCheckRun(prepDataDir, preparationName) {
+    const latestPath = preparationLatestReadinessRunPath(asPreparationDataDir(prepDataDir), preparationName);
     if (!existsSync(latestPath))
         return null;
     return readReadinessCheckRunAtPath(latestPath, "latest readiness-check run");
@@ -74,31 +70,31 @@ export function readReadinessCheckRunAtPath(filePath, label = "readiness-check r
     return readJsonFileWithSchema(filePath, label, ReadinessCheckRunSchema);
 }
 export function readCurrentSavedReadinessCheckRun(options) {
-    const latestComparison = readSavedReadinessCheckRun(options.projectPath, options.preparationName);
-    if (!latestComparison) {
-        return { comparison: null, stale: false };
+    const latestRun = readSavedReadinessCheckRun(options.prepDataDir, options.preparationName);
+    if (!latestRun) {
+        return { readinessRun: null, stale: false };
     }
     const currentFingerprint = fingerprintReadinessChecks(options.checks);
-    if (!latestComparison.checks_fingerprint || latestComparison.checks_fingerprint !== currentFingerprint) {
-        return { comparison: null, stale: true };
+    if (!latestRun.checks_fingerprint || latestRun.checks_fingerprint !== currentFingerprint) {
+        return { readinessRun: null, stale: true };
     }
-    return { comparison: latestComparison, stale: false };
+    return { readinessRun: latestRun, stale: false };
 }
 export function saveReadinessCheckRun(options) {
     const generatedAt = new Date().toISOString();
-    const rawSummary = options.rawOutcome
-        ? summarizeSavedTestOutcome("Source files", options.rawOutcome)
+    const sourceFilesSummary = options.sourceFilesOutcome
+        ? summarizeSavedTestOutcome("Source files", options.sourceFilesOutcome)
         : null;
     const compiledSummary = options.compiledOutcome
         ? summarizeSavedTestOutcome("Portable Context", options.compiledOutcome)
         : null;
-    const effectiveMode = rawSummary && compiledSummary
+    const effectiveMode = sourceFilesSummary && compiledSummary
         ? "both"
-        : rawSummary
-            ? "raw"
+        : sourceFilesSummary
+            ? "source-files"
             : "compiled";
-    const rawPassRate = rawSummary
-        ? Math.round((rawSummary.passed_cases / rawSummary.total_cases) * 100)
+    const sourceFilesPassRate = sourceFilesSummary
+        ? Math.round((sourceFilesSummary.passed_cases / sourceFilesSummary.total_cases) * 100)
         : null;
     const compiledPassRate = compiledSummary
         ? Math.round((compiledSummary.passed_cases / compiledSummary.total_cases) * 100)
@@ -114,18 +110,17 @@ export function saveReadinessCheckRun(options) {
             name: options.preparationName,
             portable_context_path: options.portableContextPath,
         },
-        raw: rawSummary,
+        source_files: sourceFilesSummary,
         compiled: compiledSummary,
         summary: {
-            raw_pass_rate: rawPassRate,
-            compiled_pass_rate: compiledPassRate,
-            pass_rate_delta: rawPassRate !== null && compiledPassRate !== null ? compiledPassRate - rawPassRate : null,
+            source_files_pass_rate: sourceFilesPassRate,
+            portable_context_pass_rate: compiledPassRate,
         },
     };
-    const latestStatePath = preparationLatestReadinessRunPath(options.sourcePath, options.preparationName);
+    const latestStatePath = preparationLatestReadinessRunPath(asPreparationDataDir(options.sourcePath), options.preparationName);
     mkdirSync(dirname(latestStatePath), { recursive: true });
     writeFileSync(latestStatePath, `${JSON.stringify(payload, null, 2)}\n`);
-    writeFileSync(preparationLatestReadinessSummaryPath(options.sourcePath, options.preparationName), renderLatestSummaryMarkdown(payload));
+    writeFileSync(preparationLatestReadinessSummaryPath(asPreparationDataDir(options.sourcePath), options.preparationName), renderLatestSummaryMarkdown(payload));
     if (options.portableContextPath) {
         mkdirSync(testRootForCompiled(options.portableContextPath), { recursive: true });
         writeFileSync(join(testRootForCompiled(options.portableContextPath), "latest.json"), `${JSON.stringify(payload, null, 2)}\n`);
@@ -134,15 +129,15 @@ export function saveReadinessCheckRun(options) {
 }
 export async function runSavedSourceFilesCheck(options) {
     const spec = buildTestSpecFromSourceFolderConfig({
-        sourcePath: options.sourcePath,
+        prepDataDir: options.sourcePath,
         targetName: options.preparationConfig.name,
-        targetType: "raw",
+        targetType: "source-files",
     });
     if (!spec)
         return null;
     const sourceFolderPath = resolveSourcePreparationPath(options.sourcePath, options.preparationConfig);
-    const target = createRawTestTarget(sourceFolderPath);
-    const artifactRoot = preparationLatestReadinessRunPath(options.sourcePath, options.preparationConfig.name);
+    const target = createSourceFilesTestTarget(sourceFolderPath);
+    const artifactRoot = preparationLatestReadinessRunPath(asPreparationDataDir(options.sourcePath), options.preparationConfig.name);
     const run = await runTargetTestsAuto(sourceFolderPath, spec, [target], {
         executor: options.executor,
         preserveSandboxes: options.preserveSandboxes ?? "on-failure",
@@ -152,9 +147,9 @@ export async function runSavedSourceFilesCheck(options) {
     if (!result)
         return null;
     const preparationRunPath = writePreparationTargetRun({
-        projectPath: options.sourcePath,
+        prepDataDir: options.sourcePath,
         preparationName: options.preparationConfig.name,
-        target: "file-as-is",
+        target: "source-files",
         generatedAt: run.generated_at,
         runId: normalizePreparationTestRunId(spec.id),
         runSuffix: options.runSuffix,
@@ -188,7 +183,7 @@ export async function runSavedPortableContextCheck(options) {
         return null;
     const compiledRunPath = saveTargetTestRun(portableContextPath, run);
     const preparationRunPath = writePreparationTargetRun({
-        projectPath: options.sourcePath,
+        prepDataDir: options.sourcePath,
         preparationName: options.preparationConfig.name,
         target: "compiled",
         generatedAt: run.generated_at,
@@ -204,7 +199,7 @@ export async function runSavedPortableContextCheck(options) {
     };
 }
 export async function runReadinessChecksForExecutor(options) {
-    const rawPromise = options.mode === "raw" || options.mode === "both"
+    const sourceFilesPromise = options.mode === "source-files" || options.mode === "both"
         ? runSavedSourceFilesCheck({
             sourcePath: options.sourcePath,
             preparationConfig: options.preparationConfig,
@@ -223,23 +218,23 @@ export async function runReadinessChecksForExecutor(options) {
             runSuffix: options.runSuffix,
         })
         : Promise.resolve(null);
-    const [rawOutcome, compiledOutcome] = await Promise.all([rawPromise, compiledPromise]);
-    const modeSatisfied = (options.mode !== "raw" || Boolean(rawOutcome)) &&
+    const [sourceFilesOutcome, compiledOutcome] = await Promise.all([sourceFilesPromise, compiledPromise]);
+    const modeSatisfied = (options.mode !== "source-files" || Boolean(sourceFilesOutcome)) &&
         (options.mode !== "compiled" || Boolean(compiledOutcome)) &&
-        (options.mode !== "both" || (Boolean(rawOutcome) && Boolean(compiledOutcome)));
+        (options.mode !== "both" || (Boolean(sourceFilesOutcome) && Boolean(compiledOutcome)));
     const shouldSave = options.saveLatest !== false;
-    const comparisonRunPath = shouldSave && modeSatisfied
+    const readinessRunPath = shouldSave && modeSatisfied
         ? saveReadinessCheckRun({
             sourcePath: options.sourcePath,
             portableContextPath: options.portableContextPath,
             preparationName: options.preparationConfig.name,
             checksFingerprint: fingerprintReadinessChecks(options.preparationConfig.checks),
             mode: options.mode,
-            rawOutcome,
+            sourceFilesOutcome,
             compiledOutcome,
         })
         : null;
-    const comparison = shouldSave && modeSatisfied
+    const readinessRun = shouldSave && modeSatisfied
         ? readSavedReadinessCheckRun(options.sourcePath, options.preparationConfig.name)
         : null;
     return {
@@ -247,12 +242,12 @@ export async function runReadinessChecksForExecutor(options) {
         preparationConfig: options.preparationConfig,
         portableContextPath: options.portableContextPath,
         mode: options.mode,
-        rawOutcome,
+        sourceFilesOutcome,
         compiledOutcome,
-        comparisonRunPath,
-        comparison,
+        readinessRunPath,
+        readinessRun,
     };
 }
 function portableContextPathForPreparation(sourcePath, preparationName) {
-    return portableContextPath(sourcePath, preparationName);
+    return preparationPortableContextPath(asPreparationDataDir(sourcePath), preparationName);
 }

package/dist/packages/testing/test-execution.js

@@ -201,16 +201,16 @@ function buildTestQueryPrompt(target, testCase, answerPath, tracePath) {
             "Read `AGENTS.md` first.",
             "Use the local native `interf-query` skill available in this portable context.",
             "Answer the check question the same way you would answer a real user inside this portable context.",
-            "Prefer the Method-declared portable-context outputs before consulting `raw/`.",
-            "This sandbox is self-contained: the copied portable context has sanitized source files under `raw/` via `.interf/interf.json` `source.path`.",
-            "The original Interf Workspace is intentionally absent from this sandbox. Work only from this sandboxed portable context and its embedded raw files.",
+            "Prefer the Method-declared portable-context outputs before consulting source references.",
+            "This sandbox is self-contained: the copied portable context has source references in `.interf/runtime/source-snapshot.json`.",
+            "The original Interf Workspace is intentionally absent from this sandbox. Use the source locators only when the portable context needs verification.",
         ]
         : [
-            "You are running an Interf baseline test inside an isolated raw test shell.",
+            "You are running an Interf baseline test inside an isolated source-files test shell.",
             "Read `AGENTS.md` first.",
             "Use the local native `interf-query` skill available in this shell.",
             "There is no portable context in this sandbox.",
-            "Answer only from `raw/` inside this shell.",
+            "Answer only from source references listed in `runtime/source-files.json` inside this shell.",
             "The original control plane folder is intentionally absent from this sandbox.",
         ];
     return [
@@ -218,7 +218,7 @@ function buildTestQueryPrompt(target, testCase, answerPath, tracePath) {
         "Emit only STATUS:, DONE:, BLOCKED:, or ERROR: lines.",
         "Do not ask follow-up questions.",
         `Write the answer to ${JSON.stringify(answerPath)}.`,
-        `Write the trace to ${JSON.stringify(tracePath)} with keys: case_id, target, artifacts_consulted, raw_paths_read, used_source_files, answer_summary.`,
+        `Write the trace to ${JSON.stringify(tracePath)} with keys: case_id, target, artifacts_consulted, source_paths_read, used_source_files, answer_summary.`,
         `Set \`case_id\` to ${JSON.stringify(testCase.id)}.`,
         `Set \`target\` to ${JSON.stringify(target.type)}.`,
         `Question: ${testCase.question}`,

package/dist/packages/testing/test-paths.js

@@ -1,10 +1,11 @@
 import { existsSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, compiledInterfConfigPath, } from "../compiler/compiled-paths.js";
+import { asPreparationDataDir, preparationTestsSpecsRoot, } from "../contracts/lib/preparation-paths.js";
 const TEST_ID_PATTERN = /^[a-z0-9][a-z0-9-]{0,79}$/;
 export const TEST_SPEC_EXTENSIONS = new Set([".json"]);
 export function testSpecRootPath(sourcePath) {
-    return join(sourcePath, "interf", "tests", "specs");
+    return preparationTestsSpecsRoot(asPreparationDataDir(sourcePath));
 }
 export function testSpecTypePath(sourcePath, type) {
     return join(testSpecRootPath(sourcePath), type);
@@ -18,7 +19,7 @@ export function targetTestRunsPath(compiledPath, type) {
         return join(targetTestRunsRootForCompiled(compiledPath), type);
     }
     if (isPreparationTestsRootPath(compiledPath)) {
-        return join(compiledPath, type === "raw" ? "file-as-is" : "compiled", "runs");
+        return join(compiledPath, type === "source-files" ? "source-files" : "compiled", "runs");
     }
     throw new Error(`Unsupported test artifact root: ${compiledPath}. Expected portable context or interf/<preparation>/.interf/tests root.`);
 }
@@ -30,7 +31,7 @@ export function targetTestSandboxesPath(compiledPath, type) {
         return join(targetTestSandboxesRootForCompiled(compiledPath), type);
     }
     if (isPreparationTestsRootPath(compiledPath)) {
-        return join(compiledPath, type === "raw" ? "file-as-is" : "compiled", "sandboxes");
+        return join(compiledPath, type === "source-files" ? "source-files" : "compiled", "sandboxes");
     }
     throw new Error(`Unsupported test artifact root: ${compiledPath}. Expected portable context or interf/<preparation>/.interf/tests root.`);
 }

package/dist/packages/testing/test-sandbox.d.ts

@@ -2,7 +2,6 @@ import type { TestTargetCandidate } from "./test-types.js";
 export type TestSandboxRetentionMode = "on-failure" | "always";
 export interface TestSandbox {
     rootPath: string;
-    rawPath: string;
     targetPath: string;
     compiledPath: string | null;
     preserve(destinationPath: string): string;

package/dist/packages/testing/test-sandbox.js

@@ -1,17 +1,14 @@
-import { cpSync, existsSync, mkdirSync, mkdtempSync, renameSync, rmSync, } from "node:fs";
+import { cpSync, mkdirSync, mkdtempSync, renameSync, rmSync, writeFileSync, } from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname, join, relative, sep } from "node:path";
+import { dirname, join } from "node:path";
 import { refreshCompiledBootstrapGuidance } from "../agents/lib/compiled-bootstrap.js";
-import { readInterfConfig } from "../project-model/interf.js";
-import { projectRawTestQueryShell } from "../agents/lib/shells.js";
-import { portableContextPath } from "../project-model/project-paths.js";
+import { readInterfConfig, resolveSourceInputPath } from "../project-model/interf.js";
+import { projectSourceFilesTestQueryShell } from "../agents/lib/shells.js";
+import { asPreparationDataDir, preparationPortableContextPath, } from "../contracts/lib/preparation-paths.js";
 import { saveCompiledInterfConfig } from "../project-model/source-config.js";
-import { projectRawSnapshot, resolveCompiledRawPath } from "../compiler/raw-snapshot.js";
+import { buildCompiledSourceFiles } from "../compiler/source-files.js";
 import { refreshCompiledArtifacts } from "../compiler/state.js";
 import { testRootForCompiled, stageExecutionShellsRoot, targetTestSandboxesRootForCompiled, methodImprovementLoopsRoot, compiledQueryAcceptanceRoot, compiledRuntimeLogsRoot, } from "../compiler/compiled-paths.js";
-function toPortableRelativePath(fromPath, toPath) {
-    return relative(fromPath, toPath).split(sep).join("/");
-}
 function sanitizeCompiledArtifacts(compiledPath) {
     for (const absolutePath of [
         testRootForCompiled(compiledPath),
@@ -28,16 +25,14 @@ export function createTestSandbox(target) {
     let sandboxRoot = mkdtempSync(join(tmpdir(), "interf-test-sandbox-"));
     let preserved = false;
     const sandboxCompiledPath = () => (target.type === "compiled"
-        ? portableContextPath(sandboxRoot, target.name)
+        ? preparationPortableContextPath(asPreparationDataDir(sandboxRoot), target.name)
         : null);
-    const sandboxRawPath = () => (target.type === "compiled"
-        ? join(portableContextPath(sandboxRoot, target.name), "raw")
-        : join(sandboxRoot, "raw"));
     const sandboxTargetPath = () => (target.type === "compiled"
-        ? portableContextPath(sandboxRoot, target.name)
+        ? preparationPortableContextPath(asPreparationDataDir(sandboxRoot), target.name)
         : sandboxRoot);
     try {
         if (target.type === "compiled") {
+            const sourceInputPath = resolveSourceInputPath(target.path);
             mkdirSync(dirname(sandboxTargetPath()), { recursive: true });
             cpSync(target.path, sandboxTargetPath(), { recursive: true });
             sanitizeCompiledArtifacts(sandboxTargetPath());
@@ -45,29 +40,21 @@ export function createTestSandbox(target) {
             if (!sandboxConfig) {
                 throw new Error(`Sandbox portable context is missing interf.json: ${sandboxTargetPath()}`);
             }
-            if (!existsSync(resolveCompiledRawPath(sandboxTargetPath(), sandboxConfig))) {
-                throw new Error(`Sandbox portable context is missing its local raw snapshot: ${sandboxTargetPath()}. Rebuild the portable context before testing it.`);
-            }
             saveCompiledInterfConfig(sandboxTargetPath(), {
                 ...sandboxConfig,
                 checks: [],
                 source: {
-                    path: toPortableRelativePath(sandboxTargetPath(), sandboxRawPath()),
+                    path: sourceInputPath,
+                    preparation_path: sourceInputPath,
                 },
             });
             refreshCompiledBootstrapGuidance(sandboxTargetPath());
             refreshCompiledArtifacts(sandboxTargetPath(), { ensureViewSpec: true });
         }
         else {
-            projectRawSnapshot({
-                sourcePath: target.path,
-                destinationPath: sandboxRawPath(),
-                compiledPath: target.path,
-                mode: "link-or-copy",
-                prune: false,
-                preserveTimestamps: false,
-            });
-            projectRawTestQueryShell(sandboxTargetPath());
+            mkdirSync(join(sandboxTargetPath(), "runtime"), { recursive: true });
+            writeFileSync(join(sandboxTargetPath(), "runtime", "source-files.json"), `${JSON.stringify(buildCompiledSourceFiles(sandboxTargetPath(), target.path), null, 2)}\n`);
+            projectSourceFilesTestQueryShell(sandboxTargetPath());
         }
     }
     catch (error) {
@@ -78,9 +65,6 @@ export function createTestSandbox(target) {
         get rootPath() {
             return sandboxRoot;
         },
-        get rawPath() {
-            return sandboxRawPath();
-        },
         get targetPath() {
             return sandboxTargetPath();
         },

package/dist/packages/testing/test-targets.d.ts

@@ -1,5 +1,5 @@
 import type { TestTargetCandidate } from "./test-types.js";
 export declare function listCompiledTestTargets(sourcePath: string): TestTargetCandidate[];
 export declare function createCompiledTestTarget(compiledPath: string, compiledName: string, methodId?: string): TestTargetCandidate;
-export declare function createRawTestTarget(sourcePath: string): TestTargetCandidate;
+export declare function createSourceFilesTestTarget(sourcePath: string): TestTargetCandidate;
 export declare function listTestTargets(sourcePath: string): TestTargetCandidate[];

package/dist/packages/testing/test-targets.js

@@ -22,15 +22,15 @@ export function createCompiledTestTarget(compiledPath, compiledName, methodId =
         eligible: health.status === "compiled",
     };
 }
-export function createRawTestTarget(sourcePath) {
+export function createSourceFilesTestTarget(sourcePath) {
     return {
-        type: "raw",
-        name: "raw",
+        type: "source-files",
+        name: "source-files",
         path: sourcePath,
-        method: "raw",
+        method: "source-files",
         status: "compiled",
-        stage: "raw",
-        summary: "Run the checks against an isolated sandbox of the raw files.",
+        stage: "source-files",
+        summary: "Run the checks against source file references in an isolated test shell.",
         eligible: true,
     };
 }

package/dist/packages/testing/test.d.ts

@@ -1,4 +1,4 @@
 export type { TestCaseExpect, TestCase, TestSpec, TestCheckResult, TestCaseResult, TestTargetResult, TestTargetRun, TestTargetType, LoadedTestSpec, TestTargetCandidate, } from "./test-types.js";
 export { listTestSpecs, loadTestSpec, loadTestSpecFromFile, writeTestSpec, } from "./test-specs.js";
-export { createRawTestTarget, createCompiledTestTarget, listCompiledTestTargets, listTestTargets, } from "./test-targets.js";
+export { createSourceFilesTestTarget, createCompiledTestTarget, listCompiledTestTargets, listTestTargets, } from "./test-targets.js";
 export { runTargetTests, runTargetTestsWithJudge, runTargetTestsAuto, saveTargetTestRun, } from "./test-execution.js";

package/dist/packages/testing/test.js

@@ -1,3 +1,3 @@
 export { listTestSpecs, loadTestSpec, loadTestSpecFromFile, writeTestSpec, } from "./test-specs.js";
-export { createRawTestTarget, createCompiledTestTarget, listCompiledTestTargets, listTestTargets, } from "./test-targets.js";
+export { createSourceFilesTestTarget, createCompiledTestTarget, listCompiledTestTargets, listTestTargets, } from "./test-targets.js";
 export { runTargetTests, runTargetTestsWithJudge, runTargetTestsAuto, saveTargetTestRun, } from "./test-execution.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@interf/compiler",
-  "version": "0.9.4",
+  "version": "0.13.0",
   "description": "Interf prepares data for agent work. It runs locally, processes your files, shows evidence that your data is ready, and writes portable context: a local folder with verifiable outputs agents can use.",
   "type": "module",
   "bin": {
@@ -14,17 +14,9 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
-    "./compiler": {
-      "types": "./dist/packages/compiler/index.d.ts",
-      "import": "./dist/packages/compiler/index.js"
-    },
-    "./method-package": {
-      "types": "./dist/packages/method-package/index.d.ts",
-      "import": "./dist/packages/method-package/index.js"
-    },
-    "./method-authoring": {
-      "types": "./dist/packages/method-authoring/index.d.ts",
-      "import": "./dist/packages/method-authoring/index.js"
+    "./contracts": {
+      "types": "./dist/packages/contracts/index.d.ts",
+      "import": "./dist/packages/contracts/index.js"
     },
     "./execution": {
       "types": "./dist/packages/execution/index.d.ts",
@@ -34,22 +26,10 @@
       "types": "./dist/packages/local-service/index.d.ts",
       "import": "./dist/packages/local-service/index.js"
     },
-    "./project-model": {
-      "types": "./dist/packages/project-model/index.d.ts",
-      "import": "./dist/packages/project-model/index.js"
-    },
-    "./agents": {
-      "types": "./dist/packages/agents/index.d.ts",
-      "import": "./dist/packages/agents/index.js"
-    },
-    "./testing": {
-      "types": "./dist/packages/testing/index.d.ts",
-      "import": "./dist/packages/testing/index.js"
-    },
     "./package.json": "./package.json"
   },
   "scripts": {
-    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc && chmod 755 dist/bin.js",
+    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true});require('fs').rmSync('.tsbuildinfo',{force:true})\" && tsc && chmod 755 dist/bin.js",
     "dev": "tsc --watch",
     "web:dev": "npm --prefix apps/compiler-ui run dev",
     "web:typecheck": "npm --prefix apps/compiler-ui run typecheck",
@@ -87,7 +67,7 @@
     "claude",
     "codex"
   ],
-  "license": "Apache-2.0",
+  "license": "UNLICENSED",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/interf-labs/interf.git"