@interf/compiler 0.9.5 → 0.16.0

package/dist/packages/{project-model → project}/interf-detect.js

@@ -1,11 +1,11 @@
 import { existsSync, readdirSync, statSync, } from "node:fs";
 import { join, resolve } from "node:path";
-import { warnInterf } from "../shared/logger.js";
-import { readJsonFileUnchecked } from "../shared/parse.js";
-import { portableContextPath, projectInterfRoot, } from "./project-paths.js";
-import { resolveSourceControlPathForCompiled, compiledInterfConfigPath, } from "../compiler/compiled-paths.js";
+import { warnInterf } from "../contracts/utils/logger.js";
+import { readJsonFileUnchecked } from "../contracts/utils/parse.js";
+import { asPreparationDataDir, preparationPortableContextPath, } from "../contracts/lib/preparation-paths.js";
+import { resolveSourceControlPathForCompiled, compiledInterfConfigPath, } from "../engine/compile/compiled-paths.js";
 import { InterfConfigSchema, } from "./lib/schema.js";
-import { assertPathWithinRoot } from "../shared/path-guards.js";
+import { assertPathWithinRoot } from "../contracts/utils/path-guards.js";
 export const INTERF_CONTAINER_NAME = "interf";
 export const METHOD_CONTAINER_NAME = "methods";
 export const TEST_CONTAINER_NAME = "tests";
@@ -33,6 +33,9 @@ export function readInterfConfig(dirPath) {
 export function hasSourceFolderInput(config) {
     return typeof config?.source?.path === "string" && config.source.path.length > 0;
 }
+export function hasSourcePreparationInput(config) {
+    return typeof config?.source?.preparation_path === "string" && config.source.preparation_path.length > 0;
+}
 export function detectInterf(cwd) {
     const config = readInterfConfig(cwd);
     if (config)
@@ -44,49 +47,48 @@ export function resolveCompiled(cwd) {
     if (!detected)
         return null;
     return {
-        sourcePath: resolveSourceControlPath(detected.path),
+        prepDataDir: resolveSourceControlPath(detected.path),
         compiledPath: detected.path,
         config: detected.config,
     };
 }
 export function resolveSourceFolderPath(compiledPath, config = null) {
     const resolvedConfig = config ?? readInterfConfig(compiledPath);
+    if (hasSourcePreparationInput(resolvedConfig)) {
+        return resolve(compiledPath, resolvedConfig.source.preparation_path);
+    }
     if (hasSourceFolderInput(resolvedConfig)) {
-        return assertPathWithinRoot(compiledPath, resolve(compiledPath, resolvedConfig.source.path), "Compiled raw source path");
+        return assertPathWithinRoot(compiledPath, resolve(compiledPath, resolvedConfig.source.path), "Compiled source path");
     }
-    return resolve(compiledPath, "raw");
+    throw new Error(`Portable Context at ${compiledPath} is missing source.preparation_path or source.path in ${compiledInterfConfigPath(compiledPath)}.`);
 }
 export function resolveSourceControlPath(compiledPath) {
     return resolveSourceControlPathForCompiled(compiledPath);
 }
 export function resolveSourceInputPath(compiledPath) {
     const config = readInterfConfig(compiledPath);
-    const sourceBinding = typeof config?.source?.preparation_path === "string" && config.source.preparation_path.length > 0
-        ? config.source.preparation_path
-        : null;
-    if (sourceBinding) {
-        return resolve(compiledPath, sourceBinding);
+    if (hasSourcePreparationInput(config)) {
+        return resolve(compiledPath, config.source.preparation_path);
     }
     throw new Error(`Portable context is missing source.preparation_path in ${compiledInterfConfigPath(compiledPath)}.`);
 }
-export function listPortableContextsForSourceFolder(sourcePath) {
-    const interfRoot = projectInterfRoot(sourcePath);
-    if (!existsSync(interfRoot))
+export function listPortableContextsForSourceFolder(prepDataDir) {
+    if (!existsSync(prepDataDir))
         return [];
     try {
-        if (!statSync(interfRoot).isDirectory())
+        if (!statSync(prepDataDir).isDirectory())
             return [];
     }
     catch (error) {
-        warnInterf(`Warning: failed to inspect Interf container at ${interfRoot}: ${error instanceof Error ? error.message : String(error)}`);
+        warnInterf(`Warning: failed to inspect Interf Workspace at ${prepDataDir}: ${error instanceof Error ? error.message : String(error)}`);
         return [];
     }
-    return readdirSync(interfRoot)
+    return readdirSync(prepDataDir)
         .filter((entry) => !entry.startsWith(".") &&
         entry !== METHOD_CONTAINER_NAME &&
         entry !== TEST_CONTAINER_NAME &&
         entry !== INTERF_CONFIG_FILE)
-        .map((entry) => portableContextPath(sourcePath, entry))
+        .map((entry) => preparationPortableContextPath(asPreparationDataDir(prepDataDir), entry))
         .filter((compiledPath) => existsSync(compiledPath))
         .map((compiledPath) => {
         const config = readInterfConfig(compiledPath);
@@ -94,17 +96,16 @@ export function listPortableContextsForSourceFolder(sourcePath) {
     })
         .filter((value) => value !== null);
 }
-export function assertCompiledContainer(sourcePath) {
-    const interfRoot = projectInterfRoot(sourcePath);
-    if (existsSync(interfRoot)) {
-        const stat = statSync(interfRoot);
+export function assertCompiledContainer(prepDataDir) {
+    if (existsSync(prepDataDir)) {
+        const stat = statSync(prepDataDir);
         if (!stat.isDirectory()) {
-            throw new Error(`Interf container exists and is not a directory: ${interfRoot}`);
+            throw new Error(`Interf Workspace exists and is not a directory: ${prepDataDir}`);
         }
-        const unexpectedRootEntries = readdirSync(interfRoot).filter((entry) => {
+        const unexpectedRootEntries = readdirSync(prepDataDir).filter((entry) => {
             if (entry.startsWith("."))
                 return false;
-            const entryPath = join(interfRoot, entry);
+            const entryPath = join(prepDataDir, entry);
             if (entry === INTERF_CONFIG_FILE) {
                 try {
                     return !statSync(entryPath).isFile();
@@ -133,22 +134,21 @@ export function assertCompiledContainer(sourcePath) {
             }
         });
         if (unexpectedRootEntries.length > 0) {
-            throw new Error(`Interf container contains unexpected entries: ${interfRoot}`);
+            throw new Error(`Interf Workspace contains unexpected entries: ${prepDataDir}`);
         }
     }
-    const containerPath = interfRoot;
-    if (!existsSync(containerPath)) {
-        return containerPath;
+    if (!existsSync(prepDataDir)) {
+        return prepDataDir;
     }
-    const stat = statSync(containerPath);
+    const stat = statSync(prepDataDir);
     if (!stat.isDirectory()) {
-        throw new Error(`Interf container exists and is not a directory: ${containerPath}`);
+        throw new Error(`Interf Workspace exists and is not a directory: ${prepDataDir}`);
     }
-    const unexpectedEntries = readdirSync(containerPath).filter((entry) => {
+    const unexpectedEntries = readdirSync(prepDataDir).filter((entry) => {
         if (entry.startsWith("."))
             return false;
         if (entry === INTERF_CONFIG_FILE) {
-            const entryPath = join(containerPath, entry);
+            const entryPath = join(prepDataDir, entry);
             try {
                 return !statSync(entryPath).isFile();
             }
@@ -160,7 +160,7 @@ export function assertCompiledContainer(sourcePath) {
         if (entry === METHOD_CONTAINER_NAME ||
             entry === TEST_CONTAINER_NAME)
             return false;
-        const entryPath = join(containerPath, entry);
+        const entryPath = join(prepDataDir, entry);
         try {
             if (!statSync(entryPath).isDirectory())
                 return true;
@@ -172,9 +172,9 @@ export function assertCompiledContainer(sourcePath) {
         return false;
     });
     if (unexpectedEntries.length > 0) {
-        throw new Error(`Interf container contains invalid Preparation entries: ${containerPath}`);
+        throw new Error(`Interf Workspace contains invalid Preparation entries: ${prepDataDir}`);
     }
-    return containerPath;
+    return prepDataDir;
 }
 export function assertWritableTargetDir(dirPath, label) {
     if (!existsSync(dirPath))

package/dist/packages/project/interf-scaffold.d.ts

@@ -0,0 +1,3 @@
+export declare function ensurePortableContextScaffold(prepDataDir: string, preparationName: string, methodId?: string): string;
+export declare function createCompiled(name: string, prepDataDir: string, methodId: string | undefined, about: string | undefined, sourceFolderPath: string): string;
+export declare function defaultCompiledNameForSource(prepDataDir: string): string;

package/dist/packages/{project-model → project}/interf-scaffold.js

@@ -1,16 +1,15 @@
 import { mkdirSync, existsSync, writeFileSync, } from "node:fs";
 import { basename, join, relative, sep } from "node:path";
-import { getCompiledMethod } from "../method-package/method-definitions.js";
-import { loadMethodDefinitionFromDir, seedLocalDefaultMethod } from "../method-package/local-methods.js";
-import { initializeCompiledRuntimeState, } from "../compiler/state.js";
-import { refreshCompiledBootstrapGuidance } from "../agents/lib/compiled-bootstrap.js";
-import { syncCompiledRawSnapshot } from "../compiler/raw-snapshot.js";
+import { getCompiledMethod } from "../methods/package/method-definitions.js";
+import { loadMethodDefinitionFromDir, seedLocalDefaultMethod } from "../methods/package/local-methods.js";
+import { initializeCompiledRuntimeState, } from "../engine/compile/state.js";
+import { refreshCompiledBootstrapGuidance } from "../engine/agents/lib/compiled-bootstrap.js";
 import { assertCompiledContainer, assertCompiledName, } from "./interf-detect.js";
-import { seedCompiledMethodPackage } from "../method-package/interf-method-package.js";
-import { portableContextPath } from "./project-paths.js";
-import { ensureCompiledZoneTargets, readCompiledSchemaFile } from "../compiler/compiled-schema.js";
-import { findSourcePreparationConfig, listSourcePreparationConfigs, loadSourceFolderConfig, methodIdForSourcePreparationConfig, resolveSourcePreparationPath, saveCompiledInterfConfig, } from "./source-config.js";
-import { defaultControlPathForCompiled, testRootForCompiled, methodPackagePathForCompiled } from "../compiler/compiled-paths.js";
+import { seedCompiledMethodPackage } from "../methods/package/interf-method-package.js";
+import { asPreparationDataDir, preparationPortableContextPath, } from "../contracts/lib/preparation-paths.js";
+import { ensureCompiledZoneTargets, readCompiledSchemaFile } from "../engine/compile/compiled-schema.js";
+import { findSourcePreparationConfig, loadSourceFolderConfig, methodIdForSourcePreparationConfig, resolveSourcePreparationPath, saveCompiledInterfConfig, } from "./source-config.js";
+import { defaultControlPathForCompiled, testRootForCompiled, methodPackagePathForCompiled } from "../engine/compile/compiled-paths.js";
 import { DEFAULT_METHOD_ID } from "../methods/method-resolution.js";
 const DEFAULT_INTERFIGNORE = [
     ".claude/",
@@ -67,20 +66,20 @@ function localMethodMatches(compiledPath, methodId) {
     const localMethod = loadMethodDefinitionFromDir(methodPackagePathForCompiled(compiledPath));
     return localMethod?.id === methodId;
 }
-export function ensurePortableContextScaffold(sourcePath, preparationName, methodId = DEFAULT_METHOD_ID) {
+export function ensurePortableContextScaffold(prepDataDir, preparationName, methodId = DEFAULT_METHOD_ID) {
     assertCompiledName(preparationName, "Portable context");
-    assertCompiledContainer(sourcePath);
-    const compiledPath = portableContextPath(sourcePath, preparationName);
+    assertCompiledContainer(prepDataDir);
+    const compiledPath = preparationPortableContextPath(asPreparationDataDir(prepDataDir), preparationName);
     mkdirSync(compiledPath, { recursive: true });
     mkdirSync(testRootForCompiled(compiledPath), { recursive: true });
     if (methodId === "interf-default") {
-        seedLocalDefaultMethod({ sourcePath });
+        seedLocalDefaultMethod({ prepDataDir });
     }
-    const selectedMethod = getCompiledMethod(methodId, { sourcePath });
+    const selectedMethod = getCompiledMethod(methodId, { prepDataDir });
     if (!localMethodMatches(compiledPath, selectedMethod.id)) {
         seedCompiledMethodPackage({
             compiledPath,
-            sourcePath,
+            prepDataDir,
             methodId: selectedMethod.id,
         });
     }
@@ -89,26 +88,20 @@ export function ensurePortableContextScaffold(sourcePath, preparationName, metho
     }
     return compiledPath;
 }
-export function createCompiled(name, sourcePath, methodId = DEFAULT_METHOD_ID, about, sourceFolderPath) {
+export function createCompiled(name, prepDataDir, methodId = DEFAULT_METHOD_ID, about, sourceFolderPath) {
     assertCompiledName(name, "Portable context");
-    const savedCompiled = findSourcePreparationConfig(loadSourceFolderConfig(sourcePath), name);
+    if (!sourceFolderPath || typeof sourceFolderPath !== "string") {
+        throw new Error("createCompiled requires an explicit sourceFolderPath. Pass the absolute Source Folder path the portable context binds to.");
+    }
+    const savedCompiled = findSourcePreparationConfig(loadSourceFolderConfig(prepDataDir), name);
     const effectiveMethodId = methodIdForSourcePreparationConfig(savedCompiled) ?? methodId;
-    const selectedMethod = getCompiledMethod(effectiveMethodId, { sourcePath });
-    const compiledPath = ensurePortableContextScaffold(sourcePath, name, selectedMethod.id);
+    const selectedMethod = getCompiledMethod(effectiveMethodId, { prepDataDir });
+    const compiledPath = ensurePortableContextScaffold(prepDataDir, name, selectedMethod.id);
     const resolvedAbout = about ?? savedCompiled?.about;
-    const resolvedSourceFolderPath = (() => {
-        if (savedCompiled) {
-            return resolveSourcePreparationPath(sourcePath, savedCompiled);
-        }
-        if (sourceFolderPath) {
-            return sourceFolderPath;
-        }
-        const configuredPreparations = listSourcePreparationConfigs(loadSourceFolderConfig(sourcePath));
-        if (configuredPreparations.length === 1) {
-            return resolveSourcePreparationPath(sourcePath, configuredPreparations[0]);
-        }
-        throw new Error("Cannot infer the source folder for this portable context. Select a source folder first or pass an explicit source folder path.");
-    })();
+    const resolvedSourceFolderPath = savedCompiled
+        ? resolveSourcePreparationPath(prepDataDir, savedCompiled)
+        : sourceFolderPath;
+    const sourceRelativePath = relative(compiledPath, resolvedSourceFolderPath).split(sep).join("/") || ".";
     saveCompiledInterfConfig(compiledPath, {
         type: "compiled",
         name,
@@ -126,13 +119,11 @@ export function createCompiled(name, sourcePath, methodId = DEFAULT_METHOD_ID, a
             local_draft: false,
         },
         source: {
-            path: "./raw",
+            path: sourceRelativePath,
             control_path: defaultControlPathForCompiled(compiledPath),
-            preparation_path: relative(compiledPath, resolvedSourceFolderPath).split(sep).join("/") || ".",
+            preparation_path: sourceRelativePath,
         },
     });
-    mkdirSync(join(compiledPath, "raw"), { recursive: true });
-    syncCompiledRawSnapshot(compiledPath, resolvedSourceFolderPath);
     writeFileSync(join(compiledPath, ".interfignore"), DEFAULT_INTERFIGNORE);
     scaffoldCompiledOutputs(compiledPath, name, about);
     refreshCompiledBootstrapGuidance(compiledPath);
@@ -140,6 +131,6 @@ export function createCompiled(name, sourcePath, methodId = DEFAULT_METHOD_ID, a
     initializeCompiledRuntimeState(compiledPath);
     return compiledPath;
 }
-export function defaultCompiledNameForSource(sourcePath) {
-    return basename(sourcePath);
+export function defaultCompiledNameForSource(prepDataDir) {
+    return basename(prepDataDir);
 }

package/dist/packages/{project-model → project}/lib/schema.d.ts

@@ -38,7 +38,7 @@ export declare const SourcePreparationConfigSchema: z.ZodObject<{
 }, z.core.$strict>;
 export declare const SourceFolderBindingSchema: z.ZodObject<{
     path: z.ZodString;
-}, z.core.$strict>;
+}, z.core.$loose>;
 export declare const CompiledInterfConfigSchema: z.ZodObject<{
     type: z.ZodLiteral<"compiled">;
     name: z.ZodString;
@@ -102,7 +102,7 @@ export declare const InterfConfigSchema: z.ZodObject<{
 export declare const SourceFolderConfigSchema: z.ZodObject<{
     source_folder: z.ZodOptional<z.ZodObject<{
         path: z.ZodString;
-    }, z.core.$strict>>;
+    }, z.core.$loose>>;
     preparations: z.ZodDefault<z.ZodArray<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
         name: z.ZodString;

package/dist/packages/{project-model → project}/lib/schema.js

@@ -1,6 +1,35 @@
 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";
+/**
+ * Absolute paths that an attacker-controlled config must never reach. The
+ * compiler 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.
+ */
+const FORBIDDEN_ABSOLUTE_PATH_PREFIXES = [
+    "/etc",
+    "/sys",
+    "/proc",
+    "/dev",
+    "/var/run",
+    "/var/lib",
+    "/usr",
+    "/bin",
+    "/sbin",
+    "/boot",
+];
+function isForbiddenAbsolutePath(value) {
+    if (!isAbsolute(value))
+        return false;
+    const normalized = normalize(value);
+    for (const prefix of FORBIDDEN_ABSOLUTE_PATH_PREFIXES) {
+        if (normalized === prefix || normalized.startsWith(`${prefix}/`))
+            return true;
+    }
+    return false;
+}
 export const SourceReadinessCheckSchema = z.object({
     id: z.string().regex(InterfIdPattern).optional(),
     question: z.string().min(1),
@@ -19,7 +48,15 @@ export const SourceReadinessCheckSchema = z.object({
 export const SourcePreparationConfigSchema = z.object({
     id: z.string().regex(InterfIdPattern).optional(),
     name: PreparationNameSchema,
-    path: z.string().min(1),
+    path: z
+        .string()
+        .min(1)
+        .refine((value) => !isForbiddenAbsolutePath(value), {
+        message: "Preparation path may not target system directories (/etc, /sys, /proc, /dev, /usr, /bin, /sbin, /boot, /var/run, /var/lib).",
+    })
+        .refine((value) => !value.split(/[/\\]/).some((segment) => segment === ".."), {
+        message: "Preparation path may not contain `..` segments.",
+    }),
     about: z.string().min(1).optional(),
     method: MethodIdSchema.optional(),
     max_attempts: SourceCompiledMaxAttemptsSchema.optional(),
@@ -28,7 +65,7 @@ export const SourcePreparationConfigSchema = z.object({
 }).strict();
 export const SourceFolderBindingSchema = z.object({
     path: z.string().min(1),
-}).strict();
+}).passthrough();
 export const CompiledInterfConfigSchema = z.object({
     type: z.literal("compiled"),
     name: PreparationNameSchema,

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

@@ -0,0 +1,11 @@
+import type { SourcePreparationConfig } from "./lib/schema.js";
+export interface SavedPreparationEntry {
+    config: SourcePreparationConfig;
+    path: string | null;
+    localDraft: boolean;
+}
+export declare function listSavedPreparationEntries(prepDataDir: string): SavedPreparationEntry[];
+export declare function findBuiltPortableContextPath(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;

package/dist/packages/{project-model → project}/preparation-entries.js

@@ -2,9 +2,9 @@ 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";
-export function listSavedPreparationEntries(sourcePath) {
+export function listSavedPreparationEntries(prepDataDir) {
     const builtEntries = new Map();
-    for (const builtContext of listPortableContextsForSourceFolder(sourcePath)) {
+    for (const builtContext of listPortableContextsForSourceFolder(prepDataDir)) {
         const preparationConfig = loadCompiledPreparationConfig(builtContext.path)
             ?? sourcePreparationConfigFromInterfConfig(builtContext.config);
         builtEntries.set(builtContext.config.name, {
@@ -14,7 +14,7 @@ export function listSavedPreparationEntries(sourcePath) {
         });
     }
     const entries = new Map();
-    for (const config of listSourcePreparationConfigs(loadSourceFolderConfig(sourcePath))) {
+    for (const config of listSourcePreparationConfigs(loadSourceFolderConfig(prepDataDir))) {
         const built = builtEntries.get(config.name);
         entries.set(config.name, {
             config,
@@ -24,26 +24,26 @@ export function listSavedPreparationEntries(sourcePath) {
     }
     return Array.from(entries.values()).sort((left, right) => left.config.name.localeCompare(right.config.name));
 }
-export function findBuiltPortableContextPath(sourcePath, preparationName) {
-    return listSavedPreparationEntries(sourcePath).find((entry) => entry.config.name === preparationName)?.path ?? null;
+export function findBuiltPortableContextPath(prepDataDir, preparationName) {
+    return listSavedPreparationEntries(prepDataDir).find((entry) => entry.config.name === preparationName)?.path ?? null;
 }
-export function findSavedPreparationConfig(sourcePath, preparationName) {
-    return listSavedPreparationEntries(sourcePath).find((entry) => entry.config.name === preparationName)?.config ?? null;
+export function findSavedPreparationConfig(prepDataDir, preparationName) {
+    return listSavedPreparationEntries(prepDataDir).find((entry) => entry.config.name === preparationName)?.config ?? null;
 }
-export function createPortableContextFromConfig(sourcePath, preparationConfig) {
+export function createPortableContextFromConfig(prepDataDir, preparationConfig) {
     const methodId = methodIdForSourcePreparationConfig(preparationConfig) ?? DEFAULT_METHOD_ID;
-    const sourceFolderPath = resolveSourcePreparationPath(sourcePath, preparationConfig);
-    const compiledPath = createCompiled(preparationConfig.name, sourcePath, methodId, preparationConfig.about, sourceFolderPath);
+    const sourceFolderPath = resolveSourcePreparationPath(prepDataDir, preparationConfig);
+    const compiledPath = createCompiled(preparationConfig.name, prepDataDir, methodId, preparationConfig.about, sourceFolderPath);
     syncCompiledInterfConfigFromSourcePreparationConfig(compiledPath, preparationConfig);
     return compiledPath;
 }
-export function ensurePortableContextFromConfig(sourcePath, preparationConfig) {
+export function ensurePortableContextFromConfig(prepDataDir, preparationConfig) {
     const methodId = methodIdForSourcePreparationConfig(preparationConfig) ?? DEFAULT_METHOD_ID;
-    const existingPath = findBuiltPortableContextPath(sourcePath, preparationConfig.name);
+    const existingPath = findBuiltPortableContextPath(prepDataDir, preparationConfig.name);
     if (existingPath) {
-        ensurePortableContextScaffold(sourcePath, preparationConfig.name, methodId);
+        ensurePortableContextScaffold(prepDataDir, preparationConfig.name, methodId);
         syncCompiledInterfConfigFromSourcePreparationConfig(existingPath, preparationConfig);
         return existingPath;
     }
-    return createPortableContextFromConfig(sourcePath, preparationConfig);
+    return createPortableContextFromConfig(prepDataDir, preparationConfig);
 }

package/dist/packages/{project-model → project}/source-config.d.ts

@@ -1,15 +1,15 @@
 import { type InterfConfig, type SourceFolderBinding, type SourceReadinessCheck, type SourcePreparationConfig, type SourceFolderConfig } from "./lib/schema.js";
-import type { TestSpec, TestTargetType } from "../testing/lib/schema.js";
+import type { TestSpec, TestTargetType } from "../engine/verify/lib/schema.js";
 export declare const SOURCE_FOLDER_CONFIG_FILE = "interf.json";
-export declare const SOURCE_FOLDER_CONFIG_PATH = "interf/interf.json";
+export declare const SOURCE_FOLDER_CONFIG_PATH = "interf.json";
 export interface LoadedSourceTestSpec extends TestSpec {
     id: string;
     filePath: string;
 }
-export declare function sourceFolderConfigPath(sourcePath: string): string;
-export declare function resolveSourceFolderConfigPath(sourcePath: string): string;
+export declare function sourceFolderConfigPath(prepDataDir: string): string;
+export declare function resolveSourceFolderConfigPath(prepDataDir: string): string;
 export declare function fingerprintReadinessChecks(checks: SourceReadinessCheck[]): string;
-export declare function loadSourceFolderConfig(sourcePath: string): SourceFolderConfig | null;
+export declare function loadSourceFolderConfig(prepDataDir: string): SourceFolderConfig | null;
 export interface WritableSourceProjectConfig {
     source_folder?: SourceFolderBinding;
     preparations?: SourcePreparationConfig[];
@@ -21,13 +21,13 @@ export declare function resolvePreparationCompileMaxLoops(preparationConfig: Pic
 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;
-export declare function resolveConfiguredSourceFolderPath(sourcePath: string, config?: SourceFolderConfig | WritableSourceProjectConfig | null | undefined): string | null;
-export declare function saveSourceFolderConfig(sourcePath: string, config: WritableSourceProjectConfig): void;
-export declare function appendSourcePreparationChecks(sourcePath: string, preparationName: string, checks: SourceReadinessCheck[]): void;
-export declare function upsertSourcePreparationConfig(sourcePath: string, preparationConfig: SourcePreparationConfig, options?: {
+export declare function resolveConfiguredSourceFolderPath(prepDataDir: string, config?: SourceFolderConfig | WritableSourceProjectConfig | null | undefined): string | null;
+export declare function saveSourceFolderConfig(prepDataDir: string, config: WritableSourceProjectConfig): void;
+export declare function appendSourcePreparationChecks(prepDataDir: string, preparationName: string, checks: SourceReadinessCheck[]): void;
+export declare function upsertSourcePreparationConfig(prepDataDir: string, preparationConfig: SourcePreparationConfig, options?: {
     matchName?: string;
 }): void;
-export declare function removeSourcePreparationConfig(sourcePath: string, preparationName: string): boolean;
+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 sourcePreparationConfigFromInterfConfig(config: InterfConfig, preparationPath?: string): SourcePreparationConfig;
@@ -35,7 +35,7 @@ export declare function loadCompiledPreparationConfig(compiledPath: string): Sou
 export declare function saveCompiledInterfConfig(compiledPath: string, config: InterfConfig): InterfConfig;
 export declare function syncCompiledInterfConfigFromSourcePreparationConfig(compiledPath: string, preparationConfig: SourcePreparationConfig): InterfConfig;
 export declare function buildTestSpecFromSourceFolderConfig(options: {
-    sourcePath: string;
+    prepDataDir: string;
     targetName?: string | null;
     targetType?: TestTargetType;
 }): LoadedSourceTestSpec | null;
@@ -43,4 +43,4 @@ export declare function buildTestSpecFromCompiledPreparationConfig(options: {
     compiledPath: string;
     targetType?: TestTargetType;
 }): LoadedSourceTestSpec | null;
-export declare function resolveSourcePreparationPath(projectPath: string, preparationConfig: Pick<SourcePreparationConfig, "path">): string;
+export declare function resolveSourcePreparationPath(prepDataDir: string, preparationConfig: Pick<SourcePreparationConfig, "path">): string;