@interf/compiler 0.9.4 → 0.13.0

package/dist/packages/project-model/source-config.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { isAbsolute, relative, resolve, sep } from "node:path";
 import { refreshCompiledBootstrapGuidance } from "../agents/lib/compiled-bootstrap.js";
 import { readInterfConfig, } from "./interf.js";
 import { seedCompiledMethodPackage } from "../method-package/interf-method-package.js";
@@ -11,14 +11,14 @@ import { SourceFolderConfigSchema, } from "./lib/schema.js";
 import { slugify } from "../shared/naming.js";
 import { assertPathWithinRoot, isPathWithinRoot } from "../shared/path-guards.js";
 import { defaultControlPathForCompiled, resolveSourceControlPathForCompiled, compiledInterfConfigPath, compiledInterfRoot, } from "../compiler/compiled-paths.js";
-import { projectInterfRoot, PROJECT_INTERF_DIR } from "./project-paths.js";
-export const SOURCE_FOLDER_CONFIG_FILE = "interf.json";
-export const SOURCE_FOLDER_CONFIG_PATH = `${PROJECT_INTERF_DIR}/${SOURCE_FOLDER_CONFIG_FILE}`;
-export function sourceFolderConfigPath(sourcePath) {
-    return join(projectInterfRoot(sourcePath), SOURCE_FOLDER_CONFIG_FILE);
+import { asPreparationDataDir, preparationConfigPath, PREPARATION_CONFIG_FILENAME, } from "../contracts/lib/preparation-paths.js";
+export const SOURCE_FOLDER_CONFIG_FILE = PREPARATION_CONFIG_FILENAME;
+export const SOURCE_FOLDER_CONFIG_PATH = SOURCE_FOLDER_CONFIG_FILE;
+export function sourceFolderConfigPath(prepDataDir) {
+    return preparationConfigPath(asPreparationDataDir(prepDataDir));
 }
-export function resolveSourceFolderConfigPath(sourcePath) {
-    return sourceFolderConfigPath(sourcePath);
+export function resolveSourceFolderConfigPath(prepDataDir) {
+    return sourceFolderConfigPath(prepDataDir);
 }
 function readSourceFolderConfigFile(filePath) {
     return readJsonFileWithSchema(filePath, "Interf project config", SourceFolderConfigSchema);
@@ -55,8 +55,8 @@ export function fingerprintReadinessChecks(checks) {
         .digest("hex")
         .slice(0, 16);
 }
-export function loadSourceFolderConfig(sourcePath) {
-    const filePath = resolveSourceFolderConfigPath(sourcePath);
+export function loadSourceFolderConfig(prepDataDir) {
+    const filePath = resolveSourceFolderConfigPath(prepDataDir);
     if (!existsSync(filePath))
         return null;
     return readSourceFolderConfigFile(filePath);
@@ -100,9 +100,9 @@ export function findSourcePreparationConfig(config, preparationName) {
 export function configuredSourceFolderPath(config) {
     return config?.source_folder?.path ?? null;
 }
-export function resolveConfiguredSourceFolderPath(sourcePath, config = loadSourceFolderConfig(sourcePath)) {
+export function resolveConfiguredSourceFolderPath(prepDataDir, config = loadSourceFolderConfig(prepDataDir)) {
     const configuredPath = configuredSourceFolderPath(config);
-    return configuredPath ? resolve(sourcePath, configuredPath) : null;
+    return configuredPath ? resolve(prepDataDir, configuredPath) : null;
 }
 function toWritableSourceProjectConfig(config) {
     const preparations = config?.preparations ?? [];
@@ -124,23 +124,23 @@ function toWritableSourcePreparationConfig(preparation) {
         name: preparation.name,
         path: preparation.path,
         ...(preparation.about ? { about: preparation.about } : {}),
-        method: method ?? DEFAULT_METHOD_ID,
+        ...(method ? { method } : {}),
         ...(typeof preparation.max_attempts === "number" ? { max_attempts: preparation.max_attempts } : {}),
         ...(typeof preparation.max_loops === "number" ? { max_loops: preparation.max_loops } : {}),
         checks: preparation.checks,
     };
 }
-export function saveSourceFolderConfig(sourcePath, config) {
-    const existing = loadSourceFolderConfig(sourcePath);
+export function saveSourceFolderConfig(prepDataDir, config) {
+    const existing = loadSourceFolderConfig(prepDataDir);
     const mergedConfig = {
         ...(existing?.source_folder && !config.source_folder ? { source_folder: existing.source_folder } : {}),
         ...config,
     };
-    mkdirSync(projectInterfRoot(sourcePath), { recursive: true });
-    writeFileSync(sourceFolderConfigPath(sourcePath), JSON.stringify(toWritableSourceProjectConfig(mergedConfig), null, 2) + "\n");
+    mkdirSync(prepDataDir, { recursive: true });
+    writeFileSync(sourceFolderConfigPath(prepDataDir), JSON.stringify(toWritableSourceProjectConfig(mergedConfig), null, 2) + "\n");
 }
-export function appendSourcePreparationChecks(sourcePath, preparationName, checks) {
-    const existing = loadSourceFolderConfig(sourcePath);
+export function appendSourcePreparationChecks(prepDataDir, preparationName, checks) {
+    const existing = loadSourceFolderConfig(prepDataDir);
     const currentPreparation = findSourcePreparationConfig(existing, preparationName);
     const otherPreparations = listSourcePreparationConfigs(existing).filter((preparation) => preparation.name !== preparationName);
     const currentChecks = currentPreparation?.checks ?? [];
@@ -152,15 +152,15 @@ export function appendSourcePreparationChecks(sourcePath, preparationName, check
         }),
         checks: [...currentChecks, ...checks],
     };
-    saveSourceFolderConfig(sourcePath, {
+    saveSourceFolderConfig(prepDataDir, {
         preparations: [
             nextPreparation,
             ...otherPreparations,
         ],
     });
 }
-export function upsertSourcePreparationConfig(sourcePath, preparationConfig, options = {}) {
-    const existing = loadSourceFolderConfig(sourcePath);
+export function upsertSourcePreparationConfig(prepDataDir, preparationConfig, options = {}) {
+    const existing = loadSourceFolderConfig(prepDataDir);
     const preparations = listSourcePreparationConfigs(existing);
     const candidateNames = Array.from(new Set([preparationConfig.name, options.matchName].filter((value) => Boolean(value))));
     const existingIndex = preparations.findIndex((entry) => candidateNames.includes(entry.name));
@@ -170,10 +170,21 @@ export function upsertSourcePreparationConfig(sourcePath, preparationConfig, opt
     else {
         preparations.push(normalizeSourcePreparationConfig(preparationConfig));
     }
-    saveSourceFolderConfig(sourcePath, {
+    saveSourceFolderConfig(prepDataDir, {
         preparations,
     });
 }
+export function removeSourcePreparationConfig(prepDataDir, preparationName) {
+    const existing = loadSourceFolderConfig(prepDataDir);
+    const preparations = listSourcePreparationConfigs(existing);
+    const nextPreparations = preparations.filter((entry) => entry.name !== preparationName);
+    if (nextPreparations.length === preparations.length)
+        return false;
+    saveSourceFolderConfig(prepDataDir, {
+        preparations: nextPreparations,
+    });
+    return true;
+}
 export function compiledMaxAttempts(maxAttempts) {
     if (maxAttempts == null)
         return undefined;
@@ -203,8 +214,8 @@ export function loadCompiledPreparationConfig(compiledPath) {
     const config = readInterfConfig(compiledPath);
     if (!config)
         return null;
-    const projectPath = resolveSourceControlPathForCompiled(compiledPath);
-    const configuredPreparations = listSourcePreparationConfigs(loadSourceFolderConfig(projectPath));
+    const prepDataDir = resolveSourceControlPathForCompiled(compiledPath);
+    const configuredPreparations = listSourcePreparationConfigs(loadSourceFolderConfig(prepDataDir));
     const defaultPreparationPath = configuredPreparations.length === 1
         ? configuredPreparations[0].path
         : `./${config.name}`;
@@ -214,10 +225,10 @@ export function loadCompiledPreparationConfig(compiledPath) {
     const preparationPath = sourceBinding
         ? (() => {
             const sourceAbsolutePath = resolve(compiledPath, sourceBinding);
-            if (!isPathWithinRoot(projectPath, sourceAbsolutePath)) {
+            if (!isPathWithinRoot(prepDataDir, sourceAbsolutePath)) {
                 return sourceAbsolutePath;
             }
-            return relative(projectPath, sourceAbsolutePath).split(sep).join("/") || defaultPreparationPath;
+            return relative(prepDataDir, sourceAbsolutePath).split(sep).join("/") || defaultPreparationPath;
         })()
         : defaultPreparationPath;
     return sourcePreparationConfigFromInterfConfig(config, preparationPath);
@@ -229,8 +240,8 @@ export function saveCompiledInterfConfig(compiledPath, config) {
 }
 export function syncCompiledInterfConfigFromSourcePreparationConfig(compiledPath, preparationConfig) {
     const current = readInterfConfig(compiledPath);
-    const projectPath = resolveSourceControlPathForCompiled(compiledPath);
-    const preparationAbsolutePath = resolveSourcePreparationPath(projectPath, preparationConfig);
+    const prepDataDir = resolveSourceControlPathForCompiled(compiledPath);
+    const preparationAbsolutePath = resolveSourcePreparationPath(prepDataDir, preparationConfig);
     const preparationRelativePath = relative(compiledPath, preparationAbsolutePath).split(sep).join("/") || ".";
     const methodId = methodIdForSourcePreparationConfig(preparationConfig)
         ?? methodIdForSourcePreparationConfig(current)
@@ -248,7 +259,7 @@ export function syncCompiledInterfConfigFromSourcePreparationConfig(compiledPath
         ...(!current ? {
             type: "compiled",
             source: {
-                path: "./raw",
+                path: preparationRelativePath,
             },
         } : {}),
         type: "compiled",
@@ -264,18 +275,17 @@ export function syncCompiledInterfConfigFromSourcePreparationConfig(compiledPath
         checks: preparationConfig.checks,
         method_origin: methodOrigin,
         source: {
-            path: current?.source?.path ?? "./raw",
+            path: preparationRelativePath,
             control_path: defaultControlPathForCompiled(compiledPath),
             preparation_path: preparationRelativePath,
         },
     };
     const saved = saveCompiledInterfConfig(compiledPath, nextConfig);
     if (methodChanged) {
-        const sourcePath = projectPath;
-        const selectedMethod = getCompiledMethod(methodId, { sourcePath });
+        const selectedMethod = getCompiledMethod(methodId, { prepDataDir });
         seedCompiledMethodPackage({
             compiledPath,
-            sourcePath,
+            prepDataDir,
             methodId: selectedMethod.id,
         });
     }
@@ -287,7 +297,7 @@ function buildLoadedTestSpec(options) {
         return null;
     const testId = options.id ?? slugify(options.name);
     return {
-        id: options.targetType === "raw" ? `${testId}-raw` : testId,
+        id: options.targetType === "source-files" ? `${testId}-source-files` : testId,
         filePath: options.filePath,
         type: options.targetType,
         name: options.name,
@@ -296,8 +306,8 @@ function buildLoadedTestSpec(options) {
     };
 }
 export function buildTestSpecFromSourceFolderConfig(options) {
-    const { sourcePath, targetName, targetType = "compiled" } = options;
-    const config = loadSourceFolderConfig(sourcePath);
+    const { prepDataDir, targetName, targetType = "compiled" } = options;
+    const config = loadSourceFolderConfig(prepDataDir);
     if (!config)
         return null;
     const preparations = listSourcePreparationConfigs(config);
@@ -310,14 +320,14 @@ export function buildTestSpecFromSourceFolderConfig(options) {
             : getDefaultSourcePreparationConfig(config);
     if (!match)
         return null;
-    const configPath = resolveSourceFolderConfigPath(sourcePath);
+    const configPath = resolveSourceFolderConfigPath(prepDataDir);
     return buildLoadedTestSpec({
         id: match.id,
         name: match.name,
         about: match.about,
         checks: match.checks,
         targetType,
-        filePath: targetType === "raw"
+        filePath: targetType === "source-files"
             ? `${configPath}#preparations/${match.name}:source-files`
             : `${configPath}#preparations/${match.name}:portable-context`,
         defaultDescription: `Derived from saved Preparation checks in ${SOURCE_FOLDER_CONFIG_PATH}`,
@@ -334,17 +344,46 @@ export function buildTestSpecFromCompiledPreparationConfig(options) {
         about: config.about,
         checks: config.checks ?? [],
         targetType,
-        filePath: targetType === "raw"
-            ? `${configPath}#checks:file-as-is`
+        filePath: targetType === "source-files"
+            ? `${configPath}#checks:source-files`
             : `${configPath}#checks:compiled`,
         defaultDescription: "Derived from checks in the portable context config.",
     });
 }
-export function resolveSourcePreparationPath(projectPath, preparationConfig) {
+/**
+ * System path prefixes the runtime must never operate on, even when an
+ * absolute `preparation.path` was authored by hand. The schema-level
+ * refinement in `SourcePreparationConfigSchema` is the primary line of
+ * defense; this is the in-process backstop for callers that hand-craft a
+ * SourcePreparationConfig at runtime (e.g. method authoring helpers that
+ * construct a config from an InterfConfig).
+ */
+const FORBIDDEN_PREPARATION_PATH_PREFIXES = [
+    "/etc",
+    "/sys",
+    "/proc",
+    "/dev",
+    "/var/run",
+    "/var/lib",
+    "/usr",
+    "/bin",
+    "/sbin",
+    "/boot",
+];
+function rejectForbiddenPreparationPath(absolutePath) {
+    for (const prefix of FORBIDDEN_PREPARATION_PATH_PREFIXES) {
+        if (absolutePath === prefix || absolutePath.startsWith(`${prefix}/`)) {
+            throw new Error(`Preparation path may not target system directory ${prefix}: ${absolutePath}`);
+        }
+    }
+}
+export function resolveSourcePreparationPath(prepDataDir, preparationConfig) {
     const configuredPath = preparationConfig.path.trim();
-    const resolvedPath = resolve(projectPath, configuredPath);
+    const resolvedPath = resolve(prepDataDir, configuredPath);
     if (isAbsolute(configuredPath)) {
+        rejectForbiddenPreparationPath(resolvedPath);
         return resolvedPath;
     }
-    return assertPathWithinRoot(projectPath, resolvedPath, "Source folder path");
+    rejectForbiddenPreparationPath(resolvedPath);
+    return assertPathWithinRoot(prepDataDir, resolvedPath, "Source folder path");
 }

package/dist/packages/project-model/source-folders.d.ts

@@ -1,11 +1,11 @@
-export declare function listVisibleSourceFolders(projectPath: string): string[];
+export declare function listVisibleSourceFolders(prepDataDir: string): string[];
 export declare function isReservedSourcePreparationPath(relativePath: string): boolean;
-export declare function normalizeSourcePreparationPathForConfig(projectPath: string, value: string): string;
+export declare function normalizeSourcePreparationPathForConfig(prepDataDir: string, value: string): string;
 export declare function defaultPreparationNameForPath(sourceFolderPath: string): string;
-export declare function findSingleSourceFolderCandidate(projectPath: string): string | null;
-export declare function listSourceFolderChoices(projectPath?: string): Array<{
+export declare function findSingleSourceFolderCandidate(prepDataDir: string): string | null;
+export declare function listSourceFolderChoices(prepDataDir?: string): Array<{
     value: string;
     label: string;
     hint: string;
 }>;
-export declare function defaultSourcePreparationPathForPrompt(name: string, introStyle: "first" | "additional" | "edit", projectPath?: string): string;
+export declare function defaultSourcePreparationPathForPrompt(name: string, introStyle: "first" | "additional" | "edit", prepDataDir?: string): string;

package/dist/packages/project-model/source-folders.js

@@ -12,10 +12,10 @@ const IGNORED_SOURCE_FOLDER_ENTRIES = new Set([
     "interf.json",
     "node_modules",
 ]);
-export function listVisibleSourceFolders(projectPath) {
+export function listVisibleSourceFolders(prepDataDir) {
     let rootEntries = [];
     try {
-        rootEntries = readdirSync(projectPath);
+        rootEntries = readdirSync(prepDataDir);
     }
     catch {
         return [];
@@ -24,7 +24,7 @@ export function listVisibleSourceFolders(projectPath) {
     const visibleDirectories = [];
     for (const entry of visibleEntries) {
         try {
-            const entryPath = join(projectPath, entry);
+            const entryPath = join(prepDataDir, entry);
             if (statSync(entryPath).isDirectory()) {
                 visibleDirectories.push(entry);
             }
@@ -42,14 +42,14 @@ export function isReservedSourcePreparationPath(relativePath) {
         normalized === ".interf" ||
         normalized.startsWith(".interf/");
 }
-export function normalizeSourcePreparationPathForConfig(projectPath, value) {
+export function normalizeSourcePreparationPathForConfig(prepDataDir, value) {
     const trimmedValue = value.trim();
-    const resolvedPath = resolveSourcePreparationPath(projectPath, { path: trimmedValue });
-    const relativePath = relative(projectPath, resolvedPath).split(sep).join("/") || ".";
+    const resolvedPath = resolveSourcePreparationPath(prepDataDir, { path: trimmedValue });
+    const relativePath = relative(prepDataDir, resolvedPath).split(sep).join("/") || ".";
     if (relativePath === ".") {
         throw new Error("Pick a Source Folder, not the Interf Workspace itself.");
     }
-    if (isAbsolute(trimmedValue) && !isPathWithinRoot(projectPath, resolvedPath)) {
+    if (isAbsolute(trimmedValue) && !isPathWithinRoot(prepDataDir, resolvedPath)) {
         if (!existsSync(resolvedPath)) {
             throw new Error("Pick an existing source folder.");
         }
@@ -77,22 +77,22 @@ export function defaultPreparationNameForPath(sourceFolderPath) {
         .filter((segment) => segment.length > 0 && segment !== ".");
     return slugify(segments[segments.length - 1] ?? "") || DEFAULT_PREPARATION_NAME;
 }
-export function findSingleSourceFolderCandidate(projectPath) {
-    const visibleDirectories = listVisibleSourceFolders(projectPath);
+export function findSingleSourceFolderCandidate(prepDataDir) {
+    const visibleDirectories = listVisibleSourceFolders(prepDataDir);
     if (visibleDirectories.length !== 1) {
         return null;
     }
     return `./${visibleDirectories[0]}`;
 }
-export function listSourceFolderChoices(projectPath = process.cwd()) {
-    return listVisibleSourceFolders(projectPath).map((entry) => ({
+export function listSourceFolderChoices(prepDataDir = process.cwd()) {
+    return listVisibleSourceFolders(prepDataDir).map((entry) => ({
         value: `./${entry}`,
         label: entry,
         hint: `Use ./${entry} as the source folder`,
     }));
 }
-export function defaultSourcePreparationPathForPrompt(name, introStyle, projectPath = process.cwd()) {
-    const namedFolderPath = join(projectPath, name);
+export function defaultSourcePreparationPathForPrompt(name, introStyle, prepDataDir = process.cwd()) {
+    const namedFolderPath = join(prepDataDir, name);
     if (existsSync(namedFolderPath)) {
         try {
             if (statSync(namedFolderPath).isDirectory()) {
@@ -104,7 +104,7 @@ export function defaultSourcePreparationPathForPrompt(name, introStyle, projectP
         }
     }
     if (introStyle === "first") {
-        return findSingleSourceFolderCandidate(projectPath) ?? `./${name}`;
+        return findSingleSourceFolderCandidate(prepDataDir) ?? `./${name}`;
     }
     return `./${name}`;
 }

package/dist/packages/shared/filesystem.d.ts

@@ -1,2 +1,9 @@
 export declare function countFilesRecursive(dirPath: string): number;
 export declare function listFilesRecursive(dirPath: string, predicate?: (filePath: string) => boolean): string[];
+/**
+ * Async variant of {@link listFilesRecursive}. Uses promise-based
+ * `readdir` + `realpath` so directory walks on large source folders do
+ * not block the event loop. Symlink cycles are skipped via a
+ * canonical-path visited set, matching the sync variant.
+ */
+export declare function listFilesRecursiveAsync(dirPath: string, predicate?: (filePath: string) => boolean): Promise<string[]>;

package/dist/packages/shared/filesystem.js

@@ -1,4 +1,5 @@
-import { existsSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { existsSync, readdirSync, realpathSync } from "node:fs";
+import { readdir, realpath } from "node:fs/promises";
 import { join } from "node:path";
 export function countFilesRecursive(dirPath) {
     if (!existsSync(dirPath))
@@ -20,6 +21,23 @@ export function listFilesRecursive(dirPath, predicate) {
     });
     return files;
 }
+/**
+ * Async variant of {@link listFilesRecursive}. Uses promise-based
+ * `readdir` + `realpath` so directory walks on large source folders do
+ * not block the event loop. Symlink cycles are skipped via a
+ * canonical-path visited set, matching the sync variant.
+ */
+export async function listFilesRecursiveAsync(dirPath, predicate) {
+    const files = [];
+    if (!existsSync(dirPath))
+        return files;
+    await walkFilesRecursiveAsync(dirPath, (filePath) => {
+        if (!predicate || predicate(filePath)) {
+            files.push(filePath);
+        }
+    });
+    return files;
+}
 function walkFilesRecursive(dirPath, onFile, visitedDirs = new Set()) {
     if (!existsSync(dirPath))
         return;
@@ -36,19 +54,88 @@ function walkFilesRecursiveInternal(dirPath, onFile, visitedDirs) {
     if (visitedDirs.has(resolvedDir))
         return;
     visitedDirs.add(resolvedDir);
-    for (const entry of readdirSync(dirPath)) {
-        const fullPath = join(dirPath, entry);
-        let stat;
-        try {
-            stat = statSync(fullPath);
-        }
-        catch {
+    // `withFileTypes` returns Dirent entries that already encode whether
+    // each name is a file/dir/symlink; using them avoids the per-entry
+    // statSync that previously dominated the walk on large source folders.
+    let entries;
+    try {
+        entries = readdirSync(dirPath, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const fullPath = join(dirPath, entry.name);
+        if (entry.isSymbolicLink()) {
+            // Symlinks need realpath to detect cycles; if the target reads as
+            // a directory we recurse, otherwise treat the link as a file.
+            try {
+                const target = realpathSync(fullPath);
+                if (visitedDirs.has(target))
+                    continue;
+                try {
+                    readdirSync(target);
+                    walkFilesRecursiveInternal(fullPath, onFile, visitedDirs);
+                }
+                catch {
+                    onFile(fullPath);
+                }
+            }
+            catch {
+                // Broken or inaccessible link.
+            }
             continue;
         }
-        if (stat.isDirectory()) {
+        if (entry.isDirectory()) {
             walkFilesRecursiveInternal(fullPath, onFile, visitedDirs);
         }
-        else if (stat.isFile()) {
+        else if (entry.isFile()) {
+            onFile(fullPath);
+        }
+    }
+}
+async function walkFilesRecursiveAsync(dirPath, onFile, visitedDirs = new Set()) {
+    let resolvedDir;
+    try {
+        resolvedDir = await realpath(dirPath);
+    }
+    catch {
+        return;
+    }
+    if (visitedDirs.has(resolvedDir))
+        return;
+    visitedDirs.add(resolvedDir);
+    let entries;
+    try {
+        entries = await readdir(dirPath, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const fullPath = join(dirPath, entry.name);
+        if (entry.isSymbolicLink()) {
+            try {
+                const target = await realpath(fullPath);
+                if (visitedDirs.has(target))
+                    continue;
+                try {
+                    await readdir(target);
+                    await walkFilesRecursiveAsync(fullPath, onFile, visitedDirs);
+                }
+                catch {
+                    onFile(fullPath);
+                }
+            }
+            catch {
+                // Broken or inaccessible link.
+            }
+            continue;
+        }
+        if (entry.isDirectory()) {
+            await walkFilesRecursiveAsync(fullPath, onFile, visitedDirs);
+        }
+        else if (entry.isFile()) {
             onFile(fullPath);
         }
     }

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

@@ -16,8 +16,8 @@ export declare const TestCaseSchema: z.ZodObject<{
 }, z.core.$strip>;
 export declare const TestSpecSchema: z.ZodObject<{
     type: z.ZodEnum<{
+        "source-files": "source-files";
         compiled: "compiled";
-        raw: "raw";
     }>;
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
@@ -60,8 +60,8 @@ export declare const TestCaseResultSchema: z.ZodObject<{
 export declare const TestTargetResultSchema: z.ZodObject<{
     target: z.ZodObject<{
         type: z.ZodEnum<{
+            "source-files": "source-files";
             compiled: "compiled";
-            raw: "raw";
         }>;
         name: z.ZodString;
         path: z.ZodString;
@@ -98,8 +98,8 @@ export declare const TestTargetRunSchema: z.ZodObject<{
         id: z.ZodString;
         name: z.ZodString;
         type: z.ZodEnum<{
+            "source-files": "source-files";
             compiled: "compiled";
-            raw: "raw";
         }>;
         file: z.ZodString;
         description: z.ZodOptional<z.ZodString>;
@@ -138,8 +138,8 @@ export declare const TestTargetRunSchema: z.ZodObject<{
     results: z.ZodArray<z.ZodObject<{
         target: z.ZodObject<{
             type: z.ZodEnum<{
+                "source-files": "source-files";
                 compiled: "compiled";
-                raw: "raw";
             }>;
             name: z.ZodString;
             path: z.ZodString;
@@ -170,8 +170,8 @@ export declare const TestTargetRunSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const TestRunModeSchema: z.ZodEnum<{
+    "source-files": "source-files";
     compiled: "compiled";
-    raw: "raw";
     both: "both";
 }>;
 export declare const TestRunTargetSummarySchema: z.ZodObject<{
@@ -184,8 +184,8 @@ export declare const TestRunTargetSummarySchema: z.ZodObject<{
     total_checks: z.ZodNumber;
     target: z.ZodObject<{
         type: z.ZodEnum<{
+            "source-files": "source-files";
             compiled: "compiled";
-            raw: "raw";
         }>;
         name: z.ZodString;
         path: z.ZodString;
@@ -197,8 +197,8 @@ export declare const ReadinessCheckRunSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     generated_at: z.ZodString;
     mode: z.ZodEnum<{
+        "source-files": "source-files";
         compiled: "compiled";
-        raw: "raw";
         both: "both";
     }>;
     source_path: z.ZodString;
@@ -207,7 +207,7 @@ export declare const ReadinessCheckRunSchema: z.ZodObject<{
         name: z.ZodString;
         portable_context_path: z.ZodNullable<z.ZodString>;
     }, z.core.$strip>;
-    raw: z.ZodNullable<z.ZodObject<{
+    source_files: z.ZodNullable<z.ZodObject<{
         label: z.ZodString;
         run_path: z.ZodString;
         ok: z.ZodBoolean;
@@ -217,8 +217,8 @@ export declare const ReadinessCheckRunSchema: z.ZodObject<{
         total_checks: z.ZodNumber;
         target: z.ZodObject<{
             type: z.ZodEnum<{
+                "source-files": "source-files";
                 compiled: "compiled";
-                raw: "raw";
             }>;
             name: z.ZodString;
             path: z.ZodString;
@@ -235,8 +235,8 @@ export declare const ReadinessCheckRunSchema: z.ZodObject<{
         total_checks: z.ZodNumber;
         target: z.ZodObject<{
             type: z.ZodEnum<{
+                "source-files": "source-files";
                 compiled: "compiled";
-                raw: "raw";
             }>;
             name: z.ZodString;
             path: z.ZodString;
@@ -244,9 +244,8 @@ export declare const ReadinessCheckRunSchema: z.ZodObject<{
         }, z.core.$strip>;
     }, z.core.$strip>>;
     summary: z.ZodObject<{
-        raw_pass_rate: z.ZodNullable<z.ZodNumber>;
-        compiled_pass_rate: z.ZodNullable<z.ZodNumber>;
-        pass_rate_delta: z.ZodNullable<z.ZodNumber>;
+        source_files_pass_rate: z.ZodNullable<z.ZodNumber>;
+        portable_context_pass_rate: z.ZodNullable<z.ZodNumber>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 export type { TestCaseExpect, TestTargetType };

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

@@ -81,7 +81,7 @@ export const TestTargetRunSchema = z.object({
     target_count: z.number(),
     results: z.array(TestTargetResultSchema),
 });
-export const TestRunModeSchema = z.enum(["raw", "compiled", "both"]);
+export const TestRunModeSchema = z.enum(["source-files", "compiled", "both"]);
 export const TestRunTargetSummarySchema = z.object({
     label: z.string(),
     run_path: z.string(),
@@ -108,11 +108,10 @@ export const ReadinessCheckRunSchema = z.object({
         name: PreparationNameSchema,
         portable_context_path: z.string().nullable(),
     }),
-    raw: TestRunTargetSummarySchema.nullable(),
+    source_files: TestRunTargetSummarySchema.nullable(),
     compiled: TestRunTargetSummarySchema.nullable(),
     summary: z.object({
-        raw_pass_rate: z.number().nullable(),
-        compiled_pass_rate: z.number().nullable(),
-        pass_rate_delta: z.number().nullable(),
+        source_files_pass_rate: z.number().nullable(),
+        portable_context_pass_rate: z.number().nullable(),
     }),
 });