@interf/compiler 0.9.5 → 0.16.0

package/dist/packages/{testing → engine/verify}/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 { targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, compiledInterfConfigPath, } from "../compile/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 → engine/verify}/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 → engine/verify}/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 { saveCompiledInterfConfig } from "../project-model/source-config.js";
-import { projectRawSnapshot, resolveCompiledRawPath } from "../compiler/raw-snapshot.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("/");
-}
+import { readInterfConfig, resolveSourceInputPath } from "../../project/interf.js";
+import { projectSourceFilesTestQueryShell } from "../agents/lib/shells.js";
+import { asPreparationDataDir, preparationPortableContextPath, } from "../../contracts/lib/preparation-paths.js";
+import { saveCompiledInterfConfig } from "../../project/source-config.js";
+import { buildCompiledSourceFiles } from "../compile/source-files.js";
+import { refreshCompiledArtifacts } from "../compile/state.js";
+import { testRootForCompiled, stageExecutionShellsRoot, targetTestSandboxesRootForCompiled, methodImprovementLoopsRoot, compiledQueryAcceptanceRoot, compiledRuntimeLogsRoot, } from "../compile/compiled-paths.js";
 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 → engine/verify}/test-specs.js

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readdirSync, writeFileSync, } from "node:fs";
 import { basename, extname, join } from "node:path";
-import { readJsonFileWithSchema } from "../shared/parse.js";
+import { readJsonFileWithSchema } from "../../contracts/utils/parse.js";
 import { TestSpecSchema } from "./lib/schema.js";
 import { TEST_SPEC_EXTENSIONS, assertTestId, assertWritableTestSpecPath, testSpecFilePath, testSpecTypePath, normalizeTestId, } from "./test-paths.js";
 function readTestSpecFile(filePath) {

package/dist/packages/{testing → engine/verify}/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 → engine/verify}/test-targets.js

@@ -1,6 +1,6 @@
-import { listPortableContextsForSourceFolder } from "../project-model/interf-detect.js";
-import { computeCompiledHealth } from "../compiler/state.js";
-import { DEFAULT_METHOD_ID, resolveMethodId } from "../methods/method-resolution.js";
+import { listPortableContextsForSourceFolder } from "../../project/interf-detect.js";
+import { computeCompiledHealth } from "../compile/state.js";
+import { DEFAULT_METHOD_ID, resolveMethodId } from "../../methods/method-resolution.js";
 function summarizeTargetSortKey(target) {
     return `${target.name}\u0000${target.method}`;
 }
@@ -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 → engine/verify}/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 → engine/verify}/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/dist/packages/{method-authoring → methods/authoring}/method-authoring.d.ts

@@ -1,6 +1,14 @@
-import type { MethodExecutor } from "../agents/lib/executors.js";
-import { validateMethodPackage } from "../method-package/local-methods.js";
-import type { SourceReadinessCheck } from "../project-model/lib/schema.js";
+import type { MethodExecutor } from "../../engine/agents/lib/executors.js";
+import { validateMethodPackage } from "../package/local-methods.js";
+import type { SourceReadinessCheck } from "../../project/lib/schema.js";
+/**
+ * Walk method.json after a successful authoring run and fill in
+ * `role: "general"` for any stage missing a role field. Custom role
+ * names are kept as-is. Idempotent — does nothing when every stage
+ * already declares a role. Returns the list of stage ids that were
+ * touched so the runtime can surface that to the user.
+ */
+export declare function ensureStageRoles(methodPath: string): string[];
 export interface MethodAuthoringRunResult {
     status: "updated" | "no-change" | "invalid" | "executor-failed";
     changed: boolean;
@@ -10,7 +18,7 @@ export interface MethodAuthoringRunResult {
     shellPath: string;
 }
 export declare function runMethodAuthoringDraft(options: {
-    sourcePath: string;
+    prepDataDir: string;
     sourceFolderPath: string;
     baseMethodId?: string;
     methodId: string;

package/dist/packages/{method-authoring → methods/authoring}/method-authoring.js

@@ -1,9 +1,62 @@
-import { rmSync } from "node:fs";
-import { createMethodAuthoringShell } from "../agents/lib/shells.js";
-import { createScratchLocalMethodPackage } from "../method-package/interf-method-package.js";
-import { CONTEXT_INTERFACE_FILE } from "../method-package/context-interface.js";
-import { loadMethodDefinitionFromDir, validateMethodPackage, methodDefinitionPath, } from "../method-package/local-methods.js";
+import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { createMethodAuthoringShell } from "../../engine/agents/lib/shells.js";
+import { createScratchLocalMethodPackage } from "../package/interf-method-package.js";
+import { CONTEXT_INTERFACE_FILE } from "../package/context-interface.js";
+import { loadMethodDefinitionFromDir, validateMethodPackage, methodDefinitionPath, } from "../package/local-methods.js";
 import { runMethodEditSession } from "./method-edit-session.js";
+/**
+ * Walk method.json after a successful authoring run and fill in
+ * `role: "general"` for any stage missing a role field. Custom role
+ * names are kept as-is. Idempotent — does nothing when every stage
+ * already declares a role. Returns the list of stage ids that were
+ * touched so the runtime can surface that to the user.
+ */
+export function ensureStageRoles(methodPath) {
+    const methodJsonPath = join(methodPath, "method.json");
+    if (!existsSync(methodJsonPath))
+        return [];
+    let raw;
+    try {
+        raw = readFileSync(methodJsonPath, "utf8");
+    }
+    catch {
+        return [];
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        return [];
+    const value = parsed;
+    if (!Array.isArray(value.stages))
+        return [];
+    const touched = [];
+    let changed = false;
+    const nextStages = value.stages.map((stage) => {
+        if (!stage || typeof stage !== "object" || Array.isArray(stage))
+            return stage;
+        const stageRecord = stage;
+        const declaredRole = typeof stageRecord.role === "string" && stageRecord.role.trim().length > 0
+            ? stageRecord.role.trim()
+            : null;
+        if (declaredRole)
+            return stage;
+        const id = typeof stageRecord.id === "string" ? stageRecord.id : "(unknown)";
+        touched.push(id);
+        changed = true;
+        return { ...stageRecord, role: "general" };
+    });
+    if (!changed)
+        return [];
+    value.stages = nextStages;
+    writeFileSync(methodJsonPath, `${JSON.stringify(value, null, 2)}\n`);
+    return touched;
+}
 function buildMethodAuthoringPrompt() {
     return [
         "This is an automated Interf Method-authoring run, not an open-ended chat session.",
@@ -14,13 +67,14 @@ function buildMethodAuthoringPrompt() {
         `Then read \`method/README.md\`, \`method/method.json\`, and \`method/${CONTEXT_INTERFACE_FILE}\`.`,
         "The `method/` directory starts as a neutral Method package scaffold, not as a suggested Method.",
         "Replace the scaffold purpose, inputs, context interface, stages, stage docs, proof rules, and query guidance with the Method this agent work actually needs.",
-        "Review `artifacts/source-folder/raw/` before editing the package.",
+        "Read `runtime/source-files.json` and inspect the listed source locators before editing the package.",
         "Prefer direct file-reading and search tools over shell commands for routine file inspection.",
         "Do not use shell helpers like `cat`, `sed`, `ls`, or `find` when a native read/search tool can inspect the same files.",
         "Edit only files under `method/`.",
         "Keep the Method package valid for the current compiler API and `method.schema.json`.",
         "Choose stage ids, stage order, reads, writes, acceptance criteria, and stage docs from the source data and preparation-and-evidence brief.",
         "Use kebab-case ids everywhere: stage ids, skill_dir values, zone ids, reads/writes values, and package ids. Never use underscores.",
+        "Each stage MAY declare a `role`: one of `extractor`, `summarizer`, `structurer`, `verifier`, or `general`. Pick the role that best matches what the stage's prompt asks the agent to do. Omit `role` (or use `general`) when the stage doesn't fit any specialized role. Custom role names are allowed; the engine treats unknown roles as `general`.",
         "Do not preserve the placeholder `prepare` stage unless the final Method genuinely needs a stage with that exact role.",
         "When editing acceptance criteria: `zone_counts_at_least` maps declared zone ids to fixed numeric minimums.",
         "`zone_counts_at_least_counts` also maps declared zone ids to runtime count-key strings such as `source_total`; `source_total` is a value, never a zone key.",
@@ -76,7 +130,7 @@ function validateAuthoredMethodPackage(methodPath) {
 }
 export async function runMethodAuthoringDraft(options) {
     const methodPath = createScratchLocalMethodPackage({
-        sourcePath: options.sourcePath,
+        prepDataDir: options.prepDataDir,
         methodId: options.methodId,
         label: options.label,
         hint: options.hint,
@@ -102,6 +156,15 @@ export async function runMethodAuthoringDraft(options) {
     if (session.status !== "updated") {
         rmSync(methodPath, { recursive: true, force: true });
     }
+    else {
+        // 0.15 — auto-fill `role: "general"` for any stage the agent
+        // didn't explicitly tag. Idempotent and silent when every stage
+        // already declares a role.
+        const touched = ensureStageRoles(methodPath);
+        if (touched.length > 0 && options.onStatus) {
+            options.onStatus(`STATUS: filled role=general on ${touched.length} stage(s) the author didn't tag (${touched.join(", ")}).`);
+        }
+    }
     return {
         status: session.status,
         changed: session.changed,

package/dist/packages/{method-authoring → methods/authoring}/method-edit-session.d.ts

@@ -1,5 +1,5 @@
-import type { MethodExecutor } from "../agents/lib/executors.js";
-import type { MethodValidationResult } from "../method-package/local-methods.js";
+import type { MethodExecutor } from "../../engine/agents/lib/executors.js";
+import type { MethodValidationResult } from "../package/local-methods.js";
 import { type MethodEditShellArtifacts } from "./lib/method-edit-utils.js";
 export interface MethodEditSessionResult {
     status: "updated" | "no-change" | "invalid" | "executor-failed";

package/dist/packages/{method-authoring → methods/authoring}/method-improvement.d.ts

@@ -1,7 +1,7 @@
-import type { MethodExecutor } from "../agents/lib/executors.js";
-import { type MethodValidationResult } from "../method-package/local-methods.js";
-import type { SourcePreparationConfig } from "../project-model/lib/schema.js";
-import type { MethodImprovementLoopSummary } from "../compiler/lib/schema.js";
+import type { MethodExecutor } from "../../engine/agents/lib/executors.js";
+import { type MethodValidationResult } from "../package/local-methods.js";
+import type { SourcePreparationConfig } from "../../project/lib/schema.js";
+import type { MethodImprovementLoopSummary } from "../../engine/compile/lib/schema.js";
 export interface MethodImprovementRunResult {
     status: "updated" | "no-change" | "invalid" | "executor-failed";
     changed: boolean;

package/dist/packages/{method-authoring → methods/authoring}/method-improvement.js

@@ -1,15 +1,16 @@
 import { appendFileSync, existsSync, mkdirSync, writeFileSync, } from "node:fs";
 import { join, relative } from "node:path";
-import { createMethodImprovementShell, freezeMethodImprovementShell, } from "../agents/lib/shells.js";
-import { validateMethodPackage } from "../method-package/local-methods.js";
-import { CONTEXT_INTERFACE_FILE } from "../method-package/context-interface.js";
-import { readJsonFileWithSchema } from "../shared/parse.js";
-import { resolveMethodImprovementReviewPaths } from "../method-package/method-review-paths.js";
-import { targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, methodImprovementRunRoot, methodPackagePathForCompiled, } from "../compiler/compiled-paths.js";
-import { readInterfConfig } from "../project-model/interf.js";
-import { saveCompiledInterfConfig } from "../project-model/source-config.js";
-import { MethodImprovementRunLedgerSchema, } from "../compiler/lib/schema.js";
+import { createMethodImprovementShell, freezeMethodImprovementShell, } from "../../engine/agents/lib/shells.js";
+import { validateMethodPackage } from "../package/local-methods.js";
+import { CONTEXT_INTERFACE_FILE } from "../package/context-interface.js";
+import { readJsonFileWithSchema } from "../../contracts/utils/parse.js";
+import { resolveMethodImprovementReviewPaths } from "../package/method-review-paths.js";
+import { targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, methodImprovementRunRoot, methodPackagePathForCompiled, } from "../../engine/compile/compiled-paths.js";
+import { readInterfConfig } from "../../project/interf.js";
+import { saveCompiledInterfConfig } from "../../project/source-config.js";
+import { MethodImprovementRunLedgerSchema, } from "../../engine/compile/lib/schema.js";
 import { runMethodEditSession } from "./method-edit-session.js";
+import { ensureStageRoles } from "./method-authoring.js";
 function toShellArtifactPath(absolutePath, sourceRoot, shellRoot) {
     if (!absolutePath)
         return null;
@@ -64,7 +65,7 @@ function buildMethodImprovementPrompt() {
         "Treat the Method package as four aligned layers: purpose, inputs, context interface, and stages.",
         "Prefer editing the stage docs, Method contract, input contract, or schema ownership that actually change portable-context outputs.",
         "Edit only files under `method/`.",
-        "Do not edit checks, test specs, raw source files, or generated portable-context outputs.",
+        "Do not edit checks, test specs, source files, or generated portable-context outputs.",
         "Keep the Method package valid for the current compiler API and `method.schema.json`.",
         "Respect stage boundaries: a stage may only introduce links that resolve within that stage's declared writes or already-existing read zones.",
         "Do not make one stage point at files or notes that are only created later by another stage.",
@@ -169,6 +170,11 @@ export async function runMethodImprovementLoop(options) {
         validate: validateMethodPackage,
         maxValidationRepairAttempts: 1,
     });
+    if (session.status === "updated") {
+        // 0.15 — fill role=general on any stage the improvement run
+        // dropped a role from. Idempotent and silent when complete.
+        ensureStageRoles(methodRoot);
+    }
     const preservedShellManifestPath = freezeMethodImprovementShell(shell.rootPath);
     writeMethodImprovementRunLedger(options.compiledPath, options.runId, buildMethodImprovementLoopRecord({
         targetName: compiledName,

package/dist/packages/{method-package → methods/package}/builtin-compiled-method.d.ts

@@ -1,12 +1,11 @@
-import { COMPILED_ZONE_KINDS, type CompiledZoneKind } from "../compiler/method-primitives.js";
-export declare const BUILTIN_COMPILED_STAGE_IDS: {
+import { type CompiledZoneKind } from "../../engine/compile/method-primitives.js";
+declare const BUILTIN_COMPILED_STAGE_IDS: {
     readonly SUMMARIZE: "summarize";
     readonly STRUCTURE: "structure";
     readonly SHAPE: "shape";
 };
-export type BuiltinCompiledStageId = typeof BUILTIN_COMPILED_STAGE_IDS[keyof typeof BUILTIN_COMPILED_STAGE_IDS];
+type BuiltinCompiledStageId = typeof BUILTIN_COMPILED_STAGE_IDS[keyof typeof BUILTIN_COMPILED_STAGE_IDS];
 export declare const BUILTIN_COMPILED_ZONE_IDS: {
-    readonly RAW: "raw";
     readonly SUMMARIES: "summaries";
     readonly KNOWLEDGE_ENTITIES: "knowledge-entities";
     readonly KNOWLEDGE_CLAIMS: "knowledge-claims";
@@ -35,4 +34,4 @@ export declare function requiredCompiledZoneOwners<TStage extends {
     id: string;
     writes: readonly string[];
 }>(stages: readonly TStage[], zoneId: BuiltinCompiledZoneId): string[];
-export { COMPILED_ZONE_KINDS };
+export {};

package/dist/packages/{method-package → methods/package}/builtin-compiled-method.js

@@ -1,16 +1,14 @@
 import { join } from "node:path";
 import { z } from "zod";
-import { readJsonFileWithSchema } from "../shared/parse.js";
-import { COMPILED_ZONE_KINDS } from "../compiler/method-primitives.js";
-import { MethodCompiledSchemaSchema } from "../compiler/lib/schema.js";
+import { readJsonFileWithSchema } from "../../contracts/utils/parse.js";
+import { MethodCompiledSchemaSchema } from "../../engine/compile/lib/schema.js";
 import { PACKAGE_ROOT } from "./lib/package-root.js";
-export const BUILTIN_COMPILED_STAGE_IDS = {
+const BUILTIN_COMPILED_STAGE_IDS = {
     SUMMARIZE: "summarize",
     STRUCTURE: "structure",
     SHAPE: "shape",
 };
 export const BUILTIN_COMPILED_ZONE_IDS = {
-    RAW: "raw",
     SUMMARIES: "summaries",
     KNOWLEDGE_ENTITIES: "knowledge-entities",
     KNOWLEDGE_CLAIMS: "knowledge-claims",
@@ -30,12 +28,7 @@ const BuiltinMethodPackageSchema = z.object({
     stages: z.array(BuiltinMethodStageSchema).min(1),
 });
 let builtinCompiledContractCache = null;
-function builtinMethodRootPath() {
-    return join(PACKAGE_ROOT, "builtin-methods", "interf-default");
-}
-function builtinMethodPath(relativePath) {
-    return join(builtinMethodRootPath(), relativePath);
-}
+const BUILTIN_DEFAULT_METHOD_ROOT = join(PACKAGE_ROOT, "builtin-methods", "interf-default");
 function assertBuiltinZoneId(value) {
     if (!BUILTIN_ZONE_ID_SET.has(value)) {
         throw new Error(`Built-in Interf Method schema declares unsupported zone id "${value}".`);
@@ -51,13 +44,15 @@ function assertBuiltinStageId(value) {
 function loadBuiltinCompiledContract() {
     if (builtinCompiledContractCache)
         return builtinCompiledContractCache;
-    const schema = readJsonFileWithSchema(builtinMethodPath("method.schema.json"), "built-in Interf Method schema", MethodCompiledSchemaSchema);
+    const schemaPath = join(BUILTIN_DEFAULT_METHOD_ROOT, "method.schema.json");
+    const methodPath = join(BUILTIN_DEFAULT_METHOD_ROOT, "method.json");
+    const schema = readJsonFileWithSchema(schemaPath, "built-in Interf Method schema", MethodCompiledSchemaSchema);
     if (!schema) {
-        throw new Error(`Missing or invalid built-in Method schema at ${builtinMethodPath("method.schema.json")}.`);
+        throw new Error(`Missing or invalid built-in Method schema at ${schemaPath}.`);
     }
-    const method = readJsonFileWithSchema(builtinMethodPath("method.json"), "built-in Interf Method package", BuiltinMethodPackageSchema);
+    const method = readJsonFileWithSchema(methodPath, "built-in Interf Method package", BuiltinMethodPackageSchema);
     if (!method) {
-        throw new Error(`Missing or invalid built-in Method package at ${builtinMethodPath("method.json")}.`);
+        throw new Error(`Missing or invalid built-in Method package at ${methodPath}.`);
     }
     const zones = schema.zones.map((zone) => ({
         id: assertBuiltinZoneId(zone.id),
@@ -91,4 +86,3 @@ export function requiredCompiledZoneOwners(stages, zoneId) {
         .filter((stage) => stage.writes.includes(zoneId))
         .map((stage) => stage.id)));
 }
-export { COMPILED_ZONE_KINDS };

package/dist/packages/{method-package → methods/package}/context-interface.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { type MethodCompiledSchema, type MethodCompiledZone, type MethodZoneId } from "../compiler/lib/schema.js";
+import { type MethodCompiledSchema, type MethodCompiledZone, type MethodZoneId } from "../../engine/compile/lib/schema.js";
 export declare const CONTEXT_INTERFACE_FILE = "method.schema.json";
 export declare const ContextInterfaceSchema: z.ZodObject<{
     kind: z.ZodLiteral<"method-schema">;
@@ -9,8 +9,8 @@ export declare const ContextInterfaceSchema: z.ZodObject<{
     zones: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         role: z.ZodEnum<{
-            output: "output";
             runtime: "runtime";
+            output: "output";
             input: "input";
             working: "working";
         }>;
@@ -25,31 +25,6 @@ export declare const ContextInterfaceSchema: z.ZodObject<{
         description: z.ZodString;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-export declare const ContextInterfaceZoneSchema: z.ZodObject<{
-    id: z.ZodString;
-    role: z.ZodEnum<{
-        output: "output";
-        runtime: "runtime";
-        input: "input";
-        working: "working";
-    }>;
-    path: z.ZodString;
-    kind: z.ZodEnum<{
-        runtime: "runtime";
-        file: "file";
-        directory: "directory";
-    }>;
-    required: z.ZodBoolean;
-    owned_by: z.ZodArray<z.ZodString>;
-    description: z.ZodString;
-}, z.core.$strip>;
-export declare const ContextInterfaceZoneIdSchema: z.ZodString;
-export declare const ContextInterfaceZoneRoleSchema: z.ZodEnum<{
-    output: "output";
-    runtime: "runtime";
-    input: "input";
-    working: "working";
-}>;
 export declare const MethodInputSpecSchema: z.ZodObject<{
     id: z.ZodString;
     label: z.ZodString;
@@ -57,23 +32,15 @@ export declare const MethodInputSpecSchema: z.ZodObject<{
     required: z.ZodDefault<z.ZodBoolean>;
     examples: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
-export declare const MethodInputContractSchema: z.ZodArray<z.ZodObject<{
-    id: z.ZodString;
-    label: z.ZodString;
-    description: z.ZodString;
-    required: z.ZodDefault<z.ZodBoolean>;
-    examples: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strict>>;
 export type ContextInterface = MethodCompiledSchema;
 export type ContextInterfaceZone = MethodCompiledZone;
 export type ContextInterfaceZoneId = MethodZoneId;
-export type ContextInterfaceZoneRole = z.infer<typeof ContextInterfaceZoneRoleSchema>;
 export type MethodInputSpec = z.infer<typeof MethodInputSpecSchema>;
-export interface ContextInterfaceStageLike {
+interface ContextInterfaceStageLike {
     id: string;
     writes: readonly string[];
 }
-export interface ContextInterfaceSummary {
+interface ContextInterfaceSummary {
     inputZones: ContextInterfaceZone[];
     workingZones: ContextInterfaceZone[];
     outputZones: ContextInterfaceZone[];
@@ -82,15 +49,12 @@ export interface ContextInterfaceSummary {
 export declare function contextInterfaceFilePath(rootPath: string): string;
 export declare function resolveContextInterfacePath(rootPath: string): string | null;
 export declare function contextInterfaceExists(rootPath: string): boolean;
-export declare function contextInterfaceRelativePath(): string;
-export declare function listContextInterfaceZones(contextInterface: ContextInterface): ContextInterfaceZone[];
-export declare function findContextInterfaceZone(contextInterface: ContextInterface, zoneId: ContextInterfaceZoneId): ContextInterfaceZone | null;
 export declare function contextInterfaceZoneAbsolutePath(compiledPath: string, zone: Pick<ContextInterfaceZone, "path">): string;
 export declare function contextInterfaceArtifactPath(zone: Pick<ContextInterfaceZone, "path" | "kind">): string;
-export declare function contextInterfaceArtifactPathsForZoneIds(contextInterface: ContextInterface, zoneIds: readonly ContextInterfaceZoneId[]): string[];
 export declare function summarizeContextInterface(contextInterface: ContextInterface): ContextInterfaceSummary;
 export declare function deriveMethodInputsFromContextInterface(contextInterface: ContextInterface | null | undefined): MethodInputSpec[];
 export declare function buildContextInterface(stages: ContextInterfaceStageLike[], label?: string): ContextInterface;
 export declare function writeContextInterfaceFile(rootPath: string, stages: ContextInterfaceStageLike[], label?: string): ContextInterface;
 export declare function writeContextInterface(rootPath: string, contextInterface: ContextInterface): ContextInterface;
 export declare function readContextInterface(rootPath: string): ContextInterface | null;
+export {};