@interf/compiler 0.18.0 → 0.22.0

package/dist/packages/project/lib/schema.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
-import { MethodIdSchema, PreparationNameSchema } from "../../contracts/lib/schema.js";
-export { MethodIdSchema, PreparationNameSchema, } from "../../contracts/lib/schema.js";
+import { BuildPlanIdSchema, PreparationNameSchema } from "../../contracts/lib/schema.js";
+export { BuildPlanIdSchema, PreparationNameSchema, } from "../../contracts/lib/schema.js";
 export declare const SourceReadinessCheckSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     question: z.ZodString;
@@ -14,12 +14,101 @@ export declare const SourceReadinessCheckSchema: z.ZodObject<{
     }, z.core.$strip>>;
     strictness: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
+export declare const RequestedArtifactCheckSchema: z.ZodObject<{
+    label: z.ZodString;
+}, z.core.$loose>;
+export declare const RequestedArtifactOutputSchema: z.ZodObject<{
+    path: z.ZodOptional<z.ZodString>;
+    shape: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"path">;
+        path: z.ZodString;
+        artifact_kind: z.ZodEnum<{
+            file: "file";
+            directory: "directory";
+        }>;
+    }, z.core.$strict>>;
+    checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            file_exists: "file_exists";
+            min_file_count: "min_file_count";
+            min_file_count_matches_source: "min_file_count_matches_source";
+            frontmatter_valid: "frontmatter_valid";
+            frontmatter_required_keys: "frontmatter_required_keys";
+            wikilinks_valid: "wikilinks_valid";
+            must_not_contain: "must_not_contain";
+            must_contain: "must_contain";
+            qa_match: "qa_match";
+        }>;
+        description: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        required: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>>;
+    stage_hint: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const RequestedArtifactSchema: z.ZodPreprocess<z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    purpose: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    checks: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        label: z.ZodString;
+    }, z.core.$loose>]>>>;
+    output: z.ZodOptional<z.ZodObject<{
+        path: z.ZodOptional<z.ZodString>;
+        shape: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodLiteral<"path">;
+            path: z.ZodString;
+            artifact_kind: z.ZodEnum<{
+                file: "file";
+                directory: "directory";
+            }>;
+        }, z.core.$strict>>;
+        checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                file_exists: "file_exists";
+                min_file_count: "min_file_count";
+                min_file_count_matches_source: "min_file_count_matches_source";
+                frontmatter_valid: "frontmatter_valid";
+                frontmatter_required_keys: "frontmatter_required_keys";
+                wikilinks_valid: "wikilinks_valid";
+                must_not_contain: "must_not_contain";
+                must_contain: "must_contain";
+                qa_match: "qa_match";
+            }>;
+            description: z.ZodOptional<z.ZodString>;
+            params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            required: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strict>>>;
+        stage_hint: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+export declare const SourceProfileItemSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodString>;
+    page_count: z.ZodOptional<z.ZodNumber>;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const SourceProfileSchema: z.ZodObject<{
+    summary: z.ZodOptional<z.ZodString>;
+    items: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodString>;
+        kind: z.ZodOptional<z.ZodString>;
+        page_count: z.ZodOptional<z.ZodNumber>;
+        note: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+    observations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    limitations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
 export declare const SourcePreparationConfigSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     name: z.ZodString;
     path: z.ZodString;
     about: z.ZodOptional<z.ZodString>;
-    method: z.ZodOptional<z.ZodString>;
+    build_plan: z.ZodOptional<z.ZodString>;
     max_attempts: z.ZodOptional<z.ZodNumber>;
     max_loops: z.ZodOptional<z.ZodNumber>;
     checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -35,15 +124,65 @@ export declare const SourcePreparationConfigSchema: z.ZodObject<{
         }, z.core.$strip>>;
         strictness: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>>;
+    requested_artifacts: z.ZodOptional<z.ZodArray<z.ZodPreprocess<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        title: z.ZodString;
+        purpose: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        checks: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            label: z.ZodString;
+        }, z.core.$loose>]>>>;
+        output: z.ZodOptional<z.ZodObject<{
+            path: z.ZodOptional<z.ZodString>;
+            shape: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodLiteral<"path">;
+                path: z.ZodString;
+                artifact_kind: z.ZodEnum<{
+                    file: "file";
+                    directory: "directory";
+                }>;
+            }, z.core.$strict>>;
+            checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodEnum<{
+                    file_exists: "file_exists";
+                    min_file_count: "min_file_count";
+                    min_file_count_matches_source: "min_file_count_matches_source";
+                    frontmatter_valid: "frontmatter_valid";
+                    frontmatter_required_keys: "frontmatter_required_keys";
+                    wikilinks_valid: "wikilinks_valid";
+                    must_not_contain: "must_not_contain";
+                    must_contain: "must_contain";
+                    qa_match: "qa_match";
+                }>;
+                description: z.ZodOptional<z.ZodString>;
+                params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                required: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strict>>>;
+            stage_hint: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>>;
+    source_profile: z.ZodOptional<z.ZodObject<{
+        summary: z.ZodOptional<z.ZodString>;
+        items: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            path: z.ZodOptional<z.ZodString>;
+            kind: z.ZodOptional<z.ZodString>;
+            page_count: z.ZodOptional<z.ZodNumber>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>>;
+        observations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        limitations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$loose>>;
 }, z.core.$strict>;
 export declare const SourceFolderBindingSchema: z.ZodObject<{
     path: z.ZodString;
 }, z.core.$loose>;
-export declare const CompiledInterfConfigSchema: z.ZodObject<{
-    type: z.ZodLiteral<"compiled">;
+export declare const VerifiableContextInterfConfigSchema: z.ZodObject<{
+    type: z.ZodLiteral<"verifiable-context">;
     name: z.ZodString;
     about: z.ZodOptional<z.ZodString>;
-    method: z.ZodString;
+    build_plan: z.ZodString;
     max_attempts: z.ZodOptional<z.ZodNumber>;
     max_loops: z.ZodOptional<z.ZodNumber>;
     checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -59,7 +198,7 @@ export declare const CompiledInterfConfigSchema: z.ZodObject<{
         }, z.core.$strip>>;
         strictness: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>>;
-    method_origin: z.ZodOptional<z.ZodObject<{
+    build_plan_origin: z.ZodOptional<z.ZodObject<{
         selected: z.ZodString;
         local_draft: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
@@ -70,10 +209,10 @@ export declare const CompiledInterfConfigSchema: z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$loose>;
 export declare const InterfConfigSchema: z.ZodObject<{
-    type: z.ZodLiteral<"compiled">;
+    type: z.ZodLiteral<"verifiable-context">;
     name: z.ZodString;
     about: z.ZodOptional<z.ZodString>;
-    method: z.ZodString;
+    build_plan: z.ZodString;
     max_attempts: z.ZodOptional<z.ZodNumber>;
     max_loops: z.ZodOptional<z.ZodNumber>;
     checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -89,7 +228,7 @@ export declare const InterfConfigSchema: z.ZodObject<{
         }, z.core.$strip>>;
         strictness: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>>;
-    method_origin: z.ZodOptional<z.ZodObject<{
+    build_plan_origin: z.ZodOptional<z.ZodObject<{
         selected: z.ZodString;
         local_draft: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
@@ -108,7 +247,7 @@ export declare const SourceFolderConfigSchema: z.ZodObject<{
         name: z.ZodString;
         path: z.ZodString;
         about: z.ZodOptional<z.ZodString>;
-        method: z.ZodOptional<z.ZodString>;
+        build_plan: z.ZodOptional<z.ZodString>;
         max_attempts: z.ZodOptional<z.ZodNumber>;
         max_loops: z.ZodOptional<z.ZodNumber>;
         checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -124,12 +263,66 @@ export declare const SourceFolderConfigSchema: z.ZodObject<{
             }, z.core.$strip>>;
             strictness: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>>;
+        requested_artifacts: z.ZodOptional<z.ZodArray<z.ZodPreprocess<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            title: z.ZodString;
+            purpose: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            checks: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                label: z.ZodString;
+            }, z.core.$loose>]>>>;
+            output: z.ZodOptional<z.ZodObject<{
+                path: z.ZodOptional<z.ZodString>;
+                shape: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodLiteral<"path">;
+                    path: z.ZodString;
+                    artifact_kind: z.ZodEnum<{
+                        file: "file";
+                        directory: "directory";
+                    }>;
+                }, z.core.$strict>>;
+                checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    kind: z.ZodEnum<{
+                        file_exists: "file_exists";
+                        min_file_count: "min_file_count";
+                        min_file_count_matches_source: "min_file_count_matches_source";
+                        frontmatter_valid: "frontmatter_valid";
+                        frontmatter_required_keys: "frontmatter_required_keys";
+                        wikilinks_valid: "wikilinks_valid";
+                        must_not_contain: "must_not_contain";
+                        must_contain: "must_contain";
+                        qa_match: "qa_match";
+                    }>;
+                    description: z.ZodOptional<z.ZodString>;
+                    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    required: z.ZodDefault<z.ZodBoolean>;
+                }, z.core.$strict>>>;
+                stage_hint: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>>;
+        source_profile: z.ZodOptional<z.ZodObject<{
+            summary: z.ZodOptional<z.ZodString>;
+            items: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodOptional<z.ZodString>;
+                path: z.ZodOptional<z.ZodString>;
+                kind: z.ZodOptional<z.ZodString>;
+                page_count: z.ZodOptional<z.ZodNumber>;
+                note: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>>>;
+            observations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            limitations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$loose>>;
     }, z.core.$strict>>>;
 }, z.core.$strict>;
 export type SourceFolderBinding = z.infer<typeof SourceFolderBindingSchema>;
+export type RequestedArtifactCheck = z.infer<typeof RequestedArtifactCheckSchema>;
+export type RequestedArtifact = z.infer<typeof RequestedArtifactSchema>;
+export type RequestedArtifactOutput = z.infer<typeof RequestedArtifactOutputSchema>;
 export type SourceReadinessCheck = z.infer<typeof SourceReadinessCheckSchema>;
+export type SourceProfile = z.infer<typeof SourceProfileSchema>;
 export type PreparationName = z.infer<typeof PreparationNameSchema>;
-export type MethodId = z.infer<typeof MethodIdSchema>;
+export type BuildPlanId = z.infer<typeof BuildPlanIdSchema>;
 export type SourcePreparationConfig = z.infer<typeof SourcePreparationConfigSchema>;
 export type InterfConfig = z.infer<typeof InterfConfigSchema>;
 export type SourceFolderConfig = z.infer<typeof SourceFolderConfigSchema>;

package/dist/packages/project/lib/schema.js

@@ -1,10 +1,10 @@
 import { z } from "zod";
 import { isAbsolute, normalize } from "node:path";
-import { InterfIdPattern, MethodIdSchema, PreparationNameSchema, SourceCompiledMaxAttemptsSchema, SourceCompiledMaxLoopsSchema, TestCaseExpectSchema, } from "../../contracts/lib/schema.js";
-export { MethodIdSchema, PreparationNameSchema, } from "../../contracts/lib/schema.js";
+import { ArtifactPathShapeSchema, CheckSchema, InterfIdPattern, BuildPlanIdSchema, PreparationNameSchema, SourceBuildMaxAttemptsSchema, SourceBuildMaxLoopsSchema, TestCaseExpectSchema, } from "../../contracts/lib/schema.js";
+export { BuildPlanIdSchema, PreparationNameSchema, } from "../../contracts/lib/schema.js";
 /**
  * Absolute paths that an attacker-controlled config must never reach. The
- * compiler treats `preparation.path` as a filesystem instruction — letting
+ * build runtime treats `preparation.path` as a filesystem instruction — letting
  * a browser-tab forge `/etc` or `/sys` could mutate or read system state.
  * The list mirrors the CSO review allowlist.
  */
@@ -45,6 +45,49 @@ export const SourceReadinessCheckSchema = z.object({
         });
     }
 });
+export const RequestedArtifactCheckSchema = z.object({
+    label: z.string().min(1),
+}).passthrough();
+export const RequestedArtifactOutputSchema = z.object({
+    path: z.string().min(1).optional(),
+    shape: ArtifactPathShapeSchema.optional(),
+    checks: z.array(CheckSchema).default([]),
+    stage_hint: z.string().min(1).optional(),
+}).strict();
+const RequestedArtifactObjectSchema = z.object({
+    id: z.string().min(1).optional(),
+    title: z.string().min(1),
+    purpose: z.string().min(1).optional(),
+    description: z.string().min(1).optional(),
+    checks: z.array(z.union([z.string().min(1), RequestedArtifactCheckSchema])).default([]),
+    output: RequestedArtifactOutputSchema.optional(),
+}).strict();
+export const RequestedArtifactSchema = z.preprocess((value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const record = value;
+    if (typeof record.title === "string" && record.title.trim().length > 0)
+        return value;
+    const title = typeof record.label === "string"
+        ? record.label
+        : typeof record.name === "string"
+            ? record.name
+            : null;
+    return title ? { ...record, title } : value;
+}, RequestedArtifactObjectSchema);
+export const SourceProfileItemSchema = z.object({
+    name: z.string().min(1).optional(),
+    path: z.string().min(1).optional(),
+    kind: z.string().min(1).optional(),
+    page_count: z.number().int().nonnegative().optional(),
+    note: z.string().min(1).optional(),
+}).passthrough();
+export const SourceProfileSchema = z.object({
+    summary: z.string().min(1).optional(),
+    items: z.array(SourceProfileItemSchema).default([]),
+    observations: z.array(z.string().min(1)).default([]),
+    limitations: z.array(z.string().min(1)).default([]),
+}).passthrough();
 export const SourcePreparationConfigSchema = z.object({
     id: z.string().regex(InterfIdPattern).optional(),
     name: PreparationNameSchema,
@@ -58,24 +101,26 @@ export const SourcePreparationConfigSchema = z.object({
         message: "Preparation path may not contain `..` segments.",
     }),
     about: z.string().min(1).optional(),
-    method: MethodIdSchema.optional(),
-    max_attempts: SourceCompiledMaxAttemptsSchema.optional(),
-    max_loops: SourceCompiledMaxLoopsSchema.optional(),
+    build_plan: BuildPlanIdSchema.optional(),
+    max_attempts: SourceBuildMaxAttemptsSchema.optional(),
+    max_loops: SourceBuildMaxLoopsSchema.optional(),
     checks: z.array(SourceReadinessCheckSchema).default([]),
+    requested_artifacts: z.array(RequestedArtifactSchema).optional(),
+    source_profile: SourceProfileSchema.optional(),
 }).strict();
 export const SourceFolderBindingSchema = z.object({
     path: z.string().min(1),
 }).passthrough();
-export const CompiledInterfConfigSchema = z.object({
-    type: z.literal("compiled"),
+export const VerifiableContextInterfConfigSchema = z.object({
+    type: z.literal("verifiable-context"),
     name: PreparationNameSchema,
     about: z.string().optional(),
-    method: MethodIdSchema,
-    max_attempts: SourceCompiledMaxAttemptsSchema.optional(),
-    max_loops: SourceCompiledMaxLoopsSchema.optional(),
+    build_plan: BuildPlanIdSchema,
+    max_attempts: SourceBuildMaxAttemptsSchema.optional(),
+    max_loops: SourceBuildMaxLoopsSchema.optional(),
     checks: z.array(SourceReadinessCheckSchema).default([]),
-    method_origin: z.object({
-        selected: MethodIdSchema,
+    build_plan_origin: z.object({
+        selected: BuildPlanIdSchema,
         local_draft: z.boolean().optional(),
     }).optional(),
     source: z.object({
@@ -84,7 +129,7 @@ export const CompiledInterfConfigSchema = z.object({
         preparation_path: z.string().optional(),
     }),
 }).passthrough();
-export const InterfConfigSchema = CompiledInterfConfigSchema;
+export const InterfConfigSchema = VerifiableContextInterfConfigSchema;
 export const SourceFolderConfigSchema = z.object({
     source_folder: SourceFolderBindingSchema.optional(),
     preparations: z.array(SourcePreparationConfigSchema).default([]),

package/dist/packages/project/preparation-entries.d.ts

@@ -5,7 +5,7 @@ export interface SavedPreparationEntry {
     localDraft: boolean;
 }
 export declare function listSavedPreparationEntries(prepDataDir: string): SavedPreparationEntry[];
-export declare function findBuiltPortableContextPath(prepDataDir: string, preparationName: string): string | null;
+export declare function findBuiltVerifiableContextPath(prepDataDir: string, preparationName: string): string | null;
 export declare function findSavedPreparationConfig(prepDataDir: string, preparationName: string): SourcePreparationConfig | null;
-export declare function createPortableContextFromConfig(prepDataDir: string, preparationConfig: SourcePreparationConfig): string;
-export declare function ensurePortableContextFromConfig(prepDataDir: string, preparationConfig: SourcePreparationConfig): string;
+export declare function createVerifiableContextFromConfig(prepDataDir: string, preparationConfig: SourcePreparationConfig): string;
+export declare function ensureVerifiableContextFromConfig(prepDataDir: string, preparationConfig: SourcePreparationConfig): string;

package/dist/packages/project/preparation-entries.js

@@ -1,16 +1,16 @@
-import { listPortableContextsForSourceFolder, } from "./interf-detect.js";
-import { createCompiled, ensurePortableContextScaffold, } from "./interf-scaffold.js";
-import { listSourcePreparationConfigs, loadCompiledPreparationConfig, loadSourceFolderConfig, resolveSourcePreparationPath, sourcePreparationConfigFromInterfConfig, syncCompiledInterfConfigFromSourcePreparationConfig, } from "./source-config.js";
-import { DEFAULT_METHOD_ID, methodIdForSourcePreparationConfig, } from "../methods/method-resolution.js";
+import { listVerifiableContextsForSourceFolder, } from "./interf-detect.js";
+import { createVerifiableContext, ensureVerifiableContextScaffold, } from "./interf-scaffold.js";
+import { listSourcePreparationConfigs, loadVerifiableContextPreparationConfig, loadSourceFolderConfig, resolveSourcePreparationPath, sourcePreparationConfigFromInterfConfig, syncVerifiableContextInterfConfigFromSourcePreparationConfig, } from "./source-config.js";
+import { DEFAULT_BUILD_PLAN_ID, buildPlanIdForSourcePreparationConfig, } from "../build-plans/build-plan-resolution.js";
 export function listSavedPreparationEntries(prepDataDir) {
     const builtEntries = new Map();
-    for (const builtContext of listPortableContextsForSourceFolder(prepDataDir)) {
-        const preparationConfig = loadCompiledPreparationConfig(builtContext.path)
+    for (const builtContext of listVerifiableContextsForSourceFolder(prepDataDir)) {
+        const preparationConfig = loadVerifiableContextPreparationConfig(builtContext.path)
             ?? sourcePreparationConfigFromInterfConfig(builtContext.config);
         builtEntries.set(builtContext.config.name, {
             config: preparationConfig,
             path: builtContext.path,
-            localDraft: builtContext.config.method_origin?.local_draft === true,
+            localDraft: builtContext.config.build_plan_origin?.local_draft === true,
         });
     }
     const entries = new Map();
@@ -24,26 +24,26 @@ export function listSavedPreparationEntries(prepDataDir) {
     }
     return Array.from(entries.values()).sort((left, right) => left.config.name.localeCompare(right.config.name));
 }
-export function findBuiltPortableContextPath(prepDataDir, preparationName) {
+export function findBuiltVerifiableContextPath(prepDataDir, preparationName) {
     return listSavedPreparationEntries(prepDataDir).find((entry) => entry.config.name === preparationName)?.path ?? null;
 }
 export function findSavedPreparationConfig(prepDataDir, preparationName) {
     return listSavedPreparationEntries(prepDataDir).find((entry) => entry.config.name === preparationName)?.config ?? null;
 }
-export function createPortableContextFromConfig(prepDataDir, preparationConfig) {
-    const methodId = methodIdForSourcePreparationConfig(preparationConfig) ?? DEFAULT_METHOD_ID;
+export function createVerifiableContextFromConfig(prepDataDir, preparationConfig) {
+    const buildPlanId = buildPlanIdForSourcePreparationConfig(preparationConfig) ?? DEFAULT_BUILD_PLAN_ID;
     const sourceFolderPath = resolveSourcePreparationPath(prepDataDir, preparationConfig);
-    const compiledPath = createCompiled(preparationConfig.name, prepDataDir, methodId, preparationConfig.about, sourceFolderPath);
-    syncCompiledInterfConfigFromSourcePreparationConfig(compiledPath, preparationConfig);
-    return compiledPath;
+    const verifiableContextPath = createVerifiableContext(preparationConfig.name, prepDataDir, buildPlanId, preparationConfig.about, sourceFolderPath);
+    syncVerifiableContextInterfConfigFromSourcePreparationConfig(verifiableContextPath, preparationConfig);
+    return verifiableContextPath;
 }
-export function ensurePortableContextFromConfig(prepDataDir, preparationConfig) {
-    const methodId = methodIdForSourcePreparationConfig(preparationConfig) ?? DEFAULT_METHOD_ID;
-    const existingPath = findBuiltPortableContextPath(prepDataDir, preparationConfig.name);
+export function ensureVerifiableContextFromConfig(prepDataDir, preparationConfig) {
+    const buildPlanId = buildPlanIdForSourcePreparationConfig(preparationConfig) ?? DEFAULT_BUILD_PLAN_ID;
+    const existingPath = findBuiltVerifiableContextPath(prepDataDir, preparationConfig.name);
     if (existingPath) {
-        ensurePortableContextScaffold(prepDataDir, preparationConfig.name, methodId);
-        syncCompiledInterfConfigFromSourcePreparationConfig(existingPath, preparationConfig);
+        ensureVerifiableContextScaffold(prepDataDir, preparationConfig.name, buildPlanId);
+        syncVerifiableContextInterfConfigFromSourcePreparationConfig(existingPath, preparationConfig);
         return existingPath;
     }
-    return createPortableContextFromConfig(prepDataDir, preparationConfig);
+    return createVerifiableContextFromConfig(prepDataDir, preparationConfig);
 }

package/dist/packages/project/source-config.d.ts

@@ -14,10 +14,10 @@ export interface WritableSourceProjectConfig {
     source_folder?: SourceFolderBinding;
     preparations?: SourcePreparationConfig[];
 }
-export { DEFAULT_METHOD_ID, methodIdForSourcePreparationConfig } from "../methods/method-resolution.js";
+export { DEFAULT_BUILD_PLAN_ID, buildPlanIdForSourcePreparationConfig } from "../build-plans/build-plan-resolution.js";
 export declare function listSourcePreparationConfigs(config: SourceFolderConfig | null): SourcePreparationConfig[];
-export declare function resolvePreparationCompileMaxAttempts(preparationConfig: Pick<SourcePreparationConfig, "max_attempts">, override?: number | null): number | null;
-export declare function resolvePreparationCompileMaxLoops(preparationConfig: Pick<SourcePreparationConfig, "max_loops">, override?: number | null): number | null;
+export declare function resolvePreparationBuildMaxAttempts(preparationConfig: Pick<SourcePreparationConfig, "max_attempts">, override?: number | null): number | null;
+export declare function resolvePreparationBuildMaxLoops(preparationConfig: Pick<SourcePreparationConfig, "max_loops">, override?: number | null): number | null;
 export declare function getDefaultSourcePreparationConfig(config: SourceFolderConfig | null): SourcePreparationConfig | null;
 export declare function findSourcePreparationConfig(config: SourceFolderConfig | null, preparationName: string): SourcePreparationConfig | null;
 export declare function configuredSourceFolderPath(config: SourceFolderConfig | WritableSourceProjectConfig | null | undefined): string | null;
@@ -28,19 +28,19 @@ export declare function upsertSourcePreparationConfig(prepDataDir: string, prepa
     matchName?: string;
 }): void;
 export declare function removeSourcePreparationConfig(prepDataDir: string, preparationName: string): boolean;
-export declare function compiledMaxAttempts(maxAttempts: number | null | undefined): number | undefined;
-export declare function compiledMaxLoops(maxLoops: number | null | undefined): number | undefined;
+export declare function buildMaxAttempts(maxAttempts: number | null | undefined): number | undefined;
+export declare function buildMaxLoops(maxLoops: number | null | undefined): number | undefined;
 export declare function sourcePreparationConfigFromInterfConfig(config: InterfConfig, preparationPath?: string): SourcePreparationConfig;
-export declare function loadCompiledPreparationConfig(compiledPath: string): SourcePreparationConfig | null;
-export declare function saveCompiledInterfConfig(compiledPath: string, config: InterfConfig): InterfConfig;
-export declare function syncCompiledInterfConfigFromSourcePreparationConfig(compiledPath: string, preparationConfig: SourcePreparationConfig): InterfConfig;
+export declare function loadVerifiableContextPreparationConfig(verifiableContextPath: string): SourcePreparationConfig | null;
+export declare function saveVerifiableContextInterfConfig(verifiableContextPath: string, config: InterfConfig): InterfConfig;
+export declare function syncVerifiableContextInterfConfigFromSourcePreparationConfig(verifiableContextPath: string, preparationConfig: SourcePreparationConfig): InterfConfig;
 export declare function buildTestSpecFromSourceFolderConfig(options: {
     prepDataDir: string;
     targetName?: string | null;
     targetType?: TestTargetType;
 }): LoadedSourceTestSpec | null;
-export declare function buildTestSpecFromCompiledPreparationConfig(options: {
-    compiledPath: string;
+export declare function buildTestSpecFromPreparationConfig(options: {
+    verifiableContextPath: string;
     targetType?: TestTargetType;
 }): LoadedSourceTestSpec | null;
 export declare function resolveSourcePreparationPath(prepDataDir: string, preparationConfig: Pick<SourcePreparationConfig, "path">): string;