@interf/compiler 0.4.0 → 0.5.0

package/dist/lib/state.d.ts

@@ -1,6 +1,6 @@
-export type { RuntimeStatus, WorkspaceStage, WorkspaceState, WorkspaceHealth, ViewSection, ViewCard, WorkspaceViewSpec, WorkspaceRawSnapshot, } from "./schema.js";
+export type { RuntimeStatus, CompiledStage, CompiledState, CompiledHealth, ViewSection, ViewCard, CompiledViewSpec, CompiledRawSnapshot, } from "./schema.js";
 export { statePath, healthPath, viewSpecPath, rawSnapshotPath, } from "./state-paths.js";
-export { loadState, saveState, loadWorkspaceHealth, saveWorkspaceHealth, loadWorkspaceViewSpec, loadWorkspaceRawSnapshot, saveWorkspaceViewSpec, initWorkspaceState, } from "./state-io.js";
-export { refreshWorkspaceArtifacts, } from "./state-artifacts.js";
-export { computeWorkspaceHealth, resolveWorkspaceStatus, resolveWorkspaceStage, } from "./state-health.js";
-export { ensureWorkspaceViewSpec, ensureWorkspaceRawSnapshot, normalizeWorkspaceViewSpec, } from "./state-view.js";
+export { loadState, saveState, loadCompiledHealth, saveCompiledHealth, loadCompiledViewSpec, loadCompiledRawSnapshot, saveCompiledViewSpec, initCompiledState, } from "./state-io.js";
+export { refreshCompiledArtifacts, } from "./state-artifacts.js";
+export { computeCompiledHealth, resolveCompiledStatus, resolveCompiledStage, } from "./state-health.js";
+export { ensureCompiledViewSpec, ensureCompiledRawSnapshot, normalizeCompiledViewSpec, } from "./state-view.js";

package/dist/lib/state.js

@@ -1,5 +1,5 @@
 export { statePath, healthPath, viewSpecPath, rawSnapshotPath, } from "./state-paths.js";
-export { loadState, saveState, loadWorkspaceHealth, saveWorkspaceHealth, loadWorkspaceViewSpec, loadWorkspaceRawSnapshot, saveWorkspaceViewSpec, initWorkspaceState, } from "./state-io.js";
-export { refreshWorkspaceArtifacts, } from "./state-artifacts.js";
-export { computeWorkspaceHealth, resolveWorkspaceStatus, resolveWorkspaceStage, } from "./state-health.js";
-export { ensureWorkspaceViewSpec, ensureWorkspaceRawSnapshot, normalizeWorkspaceViewSpec, } from "./state-view.js";
+export { loadState, saveState, loadCompiledHealth, saveCompiledHealth, loadCompiledViewSpec, loadCompiledRawSnapshot, saveCompiledViewSpec, initCompiledState, } from "./state-io.js";
+export { refreshCompiledArtifacts, } from "./state-artifacts.js";
+export { computeCompiledHealth, resolveCompiledStatus, resolveCompiledStage, } from "./state-health.js";
+export { ensureCompiledViewSpec, ensureCompiledRawSnapshot, normalizeCompiledViewSpec, } from "./state-view.js";

package/dist/lib/summarize-plan.d.ts

@@ -12,5 +12,6 @@ export interface SummarizePlan {
     targetCount: number;
     targets: SummarizeTarget[];
 }
-export declare function buildSummarizePlan(sourcePath: string, workspacePath: string, mode?: "pending" | "all"): SummarizePlan;
-export declare function writeSummarizePlan(workspacePath: string, plan: SummarizePlan): string;
+export declare const SUMMARIZE_PLAN_RELATIVE_PATH: string;
+export declare function buildSummarizePlan(sourcePath: string, compiledPath: string, mode?: "pending" | "all"): SummarizePlan;
+export declare function writeSummarizePlan(compiledPath: string, plan: SummarizePlan): string;

package/dist/lib/summarize-plan.js

@@ -1,21 +1,22 @@
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { join, relative } from "node:path";
 import { listFilesRecursive } from "./filesystem.js";
+import { builtinCompiledZoneRelativePath, compiledSummariesPath, BUILTIN_COMPILED_ZONE_IDS, } from "./compiled-schema.js";
 import { discoverSourceFiles } from "./discovery.js";
 import { loadState } from "./state.js";
 import { parseJsonFrontmatter } from "./parse.js";
-import { workspaceRuntimeRoot } from "./workspace-paths.js";
-const PLAN_PATH = join(".interf", "runtime", "summarize-targets.json");
-export function buildSummarizePlan(sourcePath, workspacePath, mode = "pending") {
-    const discovery = discoverSourceFiles(sourcePath, workspacePath);
+import { compiledRuntimeRoot } from "./compiled-paths.js";
+export const SUMMARIZE_PLAN_RELATIVE_PATH = join(".interf", "runtime", "summarize-targets.json");
+export function buildSummarizePlan(sourcePath, compiledPath, mode = "pending") {
+    const discovery = discoverSourceFiles(sourcePath, compiledPath);
     const sourceFiles = discovery.sourceFiles;
-    const summariesDir = join(workspacePath, "summaries");
-    const summaryFiles = listSummaryFiles(summariesDir, workspacePath);
-    const state = loadState(workspacePath);
+    const summariesDir = compiledSummariesPath(compiledPath);
+    const summaryFiles = listSummaryFiles(summariesDir, compiledPath);
+    const state = loadState(compiledPath);
     const pending = new Set((state?.pending ?? []).filter((value) => typeof value === "string" && sourceFiles.includes(value)));
     const summaryIndex = new Map();
     for (const summary of summaryFiles) {
-        const source = readSourceReference(join(workspacePath, summary));
+        const source = readSourceReference(join(compiledPath, summary));
         if (source)
             summaryIndex.set(source, summary);
     }
@@ -63,7 +64,7 @@ export function buildSummarizePlan(sourcePath, workspacePath, mode = "pending")
         if (targets.has(src))
             continue;
         const sourceFile = join(sourcePath, src);
-        const synthFile = join(workspacePath, summary);
+        const synthFile = join(compiledPath, summary);
         if (!existsSync(sourceFile) || !existsSync(synthFile))
             continue;
         try {
@@ -91,14 +92,14 @@ export function buildSummarizePlan(sourcePath, workspacePath, mode = "pending")
         targets: Array.from(targets.values()).sort((a, b) => a.source.localeCompare(b.source)),
     };
 }
-export function writeSummarizePlan(workspacePath, plan) {
-    const planPath = join(workspacePath, PLAN_PATH);
-    mkdirSync(workspaceRuntimeRoot(workspacePath), { recursive: true });
+export function writeSummarizePlan(compiledPath, plan) {
+    const planPath = join(compiledPath, SUMMARIZE_PLAN_RELATIVE_PATH);
+    mkdirSync(compiledRuntimeRoot(compiledPath), { recursive: true });
     writeFileSync(planPath, JSON.stringify(plan, null, 2) + "\n");
     return planPath;
 }
-function listSummaryFiles(summariesDir, workspacePath) {
-    return listFilesRecursive(summariesDir, (filePath) => filePath.endsWith(".md")).map((filePath) => relative(workspacePath, filePath));
+function listSummaryFiles(summariesDir, compiledPath) {
+    return listFilesRecursive(summariesDir, (filePath) => filePath.endsWith(".md")).map((filePath) => relative(compiledPath, filePath));
 }
 function readSourceReference(synthPath) {
     if (!existsSync(synthPath))
@@ -115,8 +116,9 @@ function readSourceReference(synthPath) {
     return source?.trim() ?? null;
 }
 function defaultSummaryPath(sourcePath) {
+    const summariesRoot = builtinCompiledZoneRelativePath(BUILTIN_COMPILED_ZONE_IDS.SUMMARIES);
     if (sourcePath.endsWith(".md"))
-        return `summaries/${sourcePath}`;
+        return `${summariesRoot}/${sourcePath}`;
     const replaced = sourcePath.replace(/\.[^.]+$/, ".md");
-    return `summaries/${replaced === sourcePath ? `${sourcePath}.md` : replaced}`;
+    return `${summariesRoot}/${replaced === sourcePath ? `${sourcePath}.md` : replaced}`;
 }

package/dist/lib/test-execution.js

@@ -195,23 +195,23 @@ async function runTargetTestsJudge(testCase, executor, candidateLabel, candidate
     return { verdict, error: executionError };
 }
 function buildTestQueryPrompt(target, testCase, answerPath, tracePath) {
-    const header = target.type === "workspace"
+    const header = target.type === "compiled"
         ? [
-            "You are running an Interf test inside an isolated sandboxed compiled workspace.",
+            "You are running an Interf test inside an isolated sandboxed compiled dataset.",
             "Read `AGENTS.md` first.",
-            "Use the local native `interf-query` skill available in this workspace.",
-            "Answer the truth-check question the same way you would answer a real user inside this compiled workspace.",
-            "Prefer `home.md`, `knowledge/`, and `summaries/` before raw fallback.",
-            "This sandbox is self-contained: the copied workspace has its own sanitized `raw/` fallback via `.interf/interf.json` `source.path`.",
-            "The source-folder control plane is intentionally absent from this sandbox. Work only from this sandboxed workspace and its embedded raw files.",
+            "Use the local native `interf-query` skill available in this compiled dataset.",
+            "Answer the truth-check question the same way you would answer a real user inside this compiled dataset.",
+            "Prefer the workflow-declared compiled outputs before raw fallback.",
+            "This sandbox is self-contained: the copied compiled dataset has its own sanitized `raw/` fallback via `.interf/interf.json` `source.path`.",
+            "The project control plane is intentionally absent from this sandbox. Work only from this sandboxed compiled dataset and its embedded raw files.",
         ]
         : [
             "You are running an Interf baseline test inside an isolated raw test shell.",
             "Read `AGENTS.md` first.",
             "Use the local native `interf-query` skill available in this shell.",
-            "There is no compiled workspace in this sandbox.",
+            "There is no compiled dataset in this sandbox.",
             "Answer only from `raw/` inside this shell.",
-            "The source-folder control plane is intentionally absent from this sandbox.",
+            "The project control plane is intentionally absent from this sandbox.",
         ];
     return [
         ...header,

package/dist/lib/test-matrices.d.ts

@@ -40,7 +40,7 @@ export declare const TestMatrixProfileSchema: z.ZodPipe<z.ZodObject<{
 export declare const TestMatrixRetryPolicySchema: z.ZodObject<{
     max_attempts_per_profile: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
-export declare const TestMatrixWorkspaceSchema: z.ZodString;
+export declare const TestMatrixDatasetSchema: z.ZodString;
 export declare const TestMatrixSchema: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;
@@ -81,10 +81,10 @@ export declare const TestMatrixSchema: z.ZodObject<{
     retry_policy: z.ZodOptional<z.ZodObject<{
         max_attempts_per_profile: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
-    workspaces: z.ZodArray<z.ZodString>;
+    datasets: z.ZodArray<z.ZodString>;
 }, z.core.$strip>;
 export type TestMatrixProfile = z.infer<typeof TestMatrixProfileSchema>;
 export type TestMatrixRetryPolicy = z.infer<typeof TestMatrixRetryPolicySchema>;
-export type TestMatrixWorkspace = z.infer<typeof TestMatrixWorkspaceSchema>;
+export type TestMatrixDataset = z.infer<typeof TestMatrixDatasetSchema>;
 export type TestMatrix = z.infer<typeof TestMatrixSchema>;
 export declare function testMatrixProfileToExecutionProfile(profile: TestMatrixProfile): WorkflowExecutionProfile;

package/dist/lib/test-matrices.js

@@ -50,14 +50,14 @@ export const TestMatrixProfileSchema = TestMatrixProfileInputSchema.transform((v
 export const TestMatrixRetryPolicySchema = z.object({
     max_attempts_per_profile: z.number().int().min(1).max(5).optional(),
 });
-export const TestMatrixWorkspaceSchema = z.string().regex(WorkflowIdPattern);
+export const TestMatrixDatasetSchema = z.string().regex(WorkflowIdPattern);
 export const TestMatrixSchema = z.object({
     id: z.string().regex(WorkflowIdPattern),
     name: z.string().min(1),
     source_path: z.string().min(1),
     compile_profiles: z.array(TestMatrixProfileSchema).min(1),
     retry_policy: TestMatrixRetryPolicySchema.optional(),
-    workspaces: z.array(TestMatrixWorkspaceSchema).min(1),
+    datasets: z.array(TestMatrixDatasetSchema).min(1),
 }).superRefine((value, ctx) => {
     const duplicateProfileIds = findDuplicates(value.compile_profiles.map((profile) => profile.id));
     for (const id of duplicateProfileIds) {
@@ -67,12 +67,12 @@ export const TestMatrixSchema = z.object({
             message: `Duplicate compile profile id in test matrix: ${id}`,
         });
     }
-    const duplicateWorkspaceIds = findDuplicates(value.workspaces);
-    for (const id of duplicateWorkspaceIds) {
+    const duplicateCompiledIds = findDuplicates(value.datasets);
+    for (const id of duplicateCompiledIds) {
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
-            path: ["workspaces"],
-            message: `Duplicate workspace name in test matrix: ${id}`,
+            path: ["datasets"],
+            message: `Duplicate dataset id in test matrix: ${id}`,
         });
     }
 });

package/dist/lib/test-paths.d.ts

@@ -2,10 +2,10 @@ import type { TestTargetType } from "./test-types.js";
 export declare const TEST_SPEC_EXTENSIONS: Set<string>;
 export declare function testSpecRootPath(sourcePath: string): string;
 export declare function testSpecTypePath(sourcePath: string, type: TestTargetType): string;
-export declare function targetTestRunsPath(workspacePath: string, type: TestTargetType): string;
-export declare function targetTestRunGitignorePath(workspacePath: string, type: TestTargetType): string;
-export declare function targetTestSandboxesPath(workspacePath: string, type: TestTargetType): string;
-export declare function targetTestSandboxGitignorePath(workspacePath: string, type: TestTargetType): string;
+export declare function targetTestRunsPath(compiledPath: string, type: TestTargetType): string;
+export declare function targetTestRunGitignorePath(compiledPath: string, type: TestTargetType): string;
+export declare function targetTestSandboxesPath(compiledPath: string, type: TestTargetType): string;
+export declare function targetTestSandboxGitignorePath(compiledPath: string, type: TestTargetType): string;
 export declare function testSpecFilePath(sourcePath: string, type: TestTargetType, id: string): string;
 export declare function normalizeTestId(input: string): string;
 export declare function assertTestId(id: string): void;

package/dist/lib/test-paths.js

@@ -1,25 +1,31 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
-import { targetTestRunsRootForWorkspace, targetTestSandboxesRootForWorkspace, } from "./workspace-paths.js";
+import { targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, compiledInterfConfigPath, } from "./compiled-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");
+    return join(sourcePath, "interf", "tests", "internal", "specs");
 }
 export function testSpecTypePath(sourcePath, type) {
     return join(testSpecRootPath(sourcePath), type);
 }
-export function targetTestRunsPath(workspacePath, type) {
-    return join(targetTestRunsRootForWorkspace(workspacePath), type);
+export function targetTestRunsPath(compiledPath, type) {
+    if (existsSync(compiledInterfConfigPath(compiledPath))) {
+        return join(targetTestRunsRootForCompiled(compiledPath), type);
+    }
+    return join(compiledPath, "tests", type === "raw" ? "file-as-is" : "compiled", "runs");
 }
-export function targetTestRunGitignorePath(workspacePath, type) {
-    return join(targetTestRunsPath(workspacePath, type), ".gitignore");
+export function targetTestRunGitignorePath(compiledPath, type) {
+    return join(targetTestRunsPath(compiledPath, type), ".gitignore");
 }
-export function targetTestSandboxesPath(workspacePath, type) {
-    return join(targetTestSandboxesRootForWorkspace(workspacePath), type);
+export function targetTestSandboxesPath(compiledPath, type) {
+    if (existsSync(compiledInterfConfigPath(compiledPath))) {
+        return join(targetTestSandboxesRootForCompiled(compiledPath), type);
+    }
+    return join(compiledPath, "tests", type === "raw" ? "file-as-is" : "compiled", "sandboxes");
 }
-export function targetTestSandboxGitignorePath(workspacePath, type) {
-    return join(targetTestSandboxesPath(workspacePath, type), ".gitignore");
+export function targetTestSandboxGitignorePath(compiledPath, type) {
+    return join(targetTestSandboxesPath(compiledPath, type), ".gitignore");
 }
 export function testSpecFilePath(sourcePath, type, id) {
     return join(testSpecTypePath(sourcePath, type), `${id}.json`);

package/dist/lib/test-sandbox.d.ts

@@ -4,7 +4,7 @@ export interface TestSandbox {
     rootPath: string;
     rawPath: string;
     targetPath: string;
-    workspacePath: string | null;
+    compiledPath: string | null;
     preserve(destinationPath: string): string;
     cleanup(): void;
 }

package/dist/lib/test-sandbox.js

@@ -1,24 +1,25 @@
 import { cpSync, existsSync, mkdirSync, mkdtempSync, renameSync, rmSync, } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join, relative, sep } from "node:path";
-import { refreshWorkspaceBootstrapGuidance } from "./interf-bootstrap.js";
-import { readInterfConfig, resolveSourceControlPath, resolveWorkspaceRawPath } from "./interf.js";
+import { refreshCompiledBootstrapGuidance } from "./interf-bootstrap.js";
+import { readInterfConfig, resolveSourceControlPath, resolveCompiledRawPath } from "./interf.js";
 import { projectRawTestQueryShell } from "./agent-shells.js";
-import { saveWorkspaceInterfConfig } from "./source-config.js";
-import { refreshWorkspaceArtifacts } from "./state.js";
-import { projectRawSnapshot } from "./workspace-raw.js";
-import { testRootForWorkspace, stageExecutionShellsRoot, targetTestSandboxesRootForWorkspace, workflowImprovementLoopsRoot, workspaceQueryAcceptanceRoot, workspaceRuntimeLogsRoot, } from "./workspace-paths.js";
+import { compiledCompiledPathForDataset } from "./project-paths.js";
+import { findSourceDatasetConfig, loadSourceFolderConfig, resolveSourceDatasetPath, saveCompiledInterfConfig, } from "./source-config.js";
+import { refreshCompiledArtifacts } from "./state.js";
+import { projectRawSnapshot } from "./compiled-raw.js";
+import { testRootForCompiled, stageExecutionShellsRoot, targetTestSandboxesRootForCompiled, workflowImprovementLoopsRoot, compiledQueryAcceptanceRoot, compiledRuntimeLogsRoot, } from "./compiled-paths.js";
 function toPortableRelativePath(fromPath, toPath) {
     return relative(fromPath, toPath).split(sep).join("/");
 }
-function sanitizeWorkspaceArtifacts(workspacePath) {
+function sanitizeCompiledArtifacts(compiledPath) {
     for (const absolutePath of [
-        testRootForWorkspace(workspacePath),
-        targetTestSandboxesRootForWorkspace(workspacePath),
-        stageExecutionShellsRoot(workspacePath),
-        workflowImprovementLoopsRoot(workspacePath),
-        workspaceRuntimeLogsRoot(workspacePath),
-        workspaceQueryAcceptanceRoot(workspacePath),
+        testRootForCompiled(compiledPath),
+        targetTestSandboxesRootForCompiled(compiledPath),
+        stageExecutionShellsRoot(compiledPath),
+        workflowImprovementLoopsRoot(compiledPath),
+        compiledRuntimeLogsRoot(compiledPath),
+        compiledQueryAcceptanceRoot(compiledPath),
     ]) {
         rmSync(absolutePath, { recursive: true, force: true });
     }
@@ -26,50 +27,56 @@ function sanitizeWorkspaceArtifacts(workspacePath) {
 export function createTestSandbox(target) {
     let sandboxRoot = mkdtempSync(join(tmpdir(), "interf-test-sandbox-"));
     let preserved = false;
-    const sandboxWorkspacePath = () => (target.type === "workspace"
-        ? join(sandboxRoot, "interf", "workspaces", target.name)
+    const sandboxCompiledPath = () => (target.type === "compiled"
+        ? compiledCompiledPathForDataset(sandboxRoot, target.name)
         : null);
-    const sandboxRawPath = () => (target.type === "workspace"
-        ? join(sandboxRoot, "interf", "workspaces", target.name, "raw")
+    const sandboxRawPath = () => (target.type === "compiled"
+        ? join(compiledCompiledPathForDataset(sandboxRoot, target.name), "raw")
         : join(sandboxRoot, "raw"));
-    const sandboxTargetPath = () => (target.type === "workspace"
-        ? join(sandboxRoot, "interf", "workspaces", target.name)
+    const sandboxTargetPath = () => (target.type === "compiled"
+        ? compiledCompiledPathForDataset(sandboxRoot, target.name)
         : sandboxRoot);
     try {
-        if (target.type === "workspace") {
+        if (target.type === "compiled") {
             mkdirSync(dirname(sandboxTargetPath()), { recursive: true });
             cpSync(target.path, sandboxTargetPath(), { recursive: true });
-            sanitizeWorkspaceArtifacts(sandboxTargetPath());
+            sanitizeCompiledArtifacts(sandboxTargetPath());
             const sandboxConfig = readInterfConfig(sandboxTargetPath());
             if (!sandboxConfig) {
-                throw new Error(`Sandbox workspace is missing interf.json: ${sandboxTargetPath()}`);
+                throw new Error(`Sandbox compiled is missing interf.json: ${sandboxTargetPath()}`);
             }
-            if (!existsSync(resolveWorkspaceRawPath(sandboxTargetPath(), sandboxConfig))) {
-                const controlSourcePath = resolveSourceControlPath(target.path);
+            if (!existsSync(resolveCompiledRawPath(sandboxTargetPath(), sandboxConfig))) {
+                const projectPath = resolveSourceControlPath(target.path);
+                const projectConfig = loadSourceFolderConfig(projectPath);
+                const datasetConfig = findSourceDatasetConfig(projectConfig, sandboxConfig.name);
+                if (!datasetConfig) {
+                    throw new Error(`Sandbox compiled is missing a trusted dataset binding for "${sandboxConfig.name}": ${target.path}`);
+                }
+                const controlSourcePath = resolveSourceDatasetPath(projectPath, datasetConfig);
                 projectRawSnapshot({
                     sourcePath: controlSourcePath,
                     destinationPath: sandboxRawPath(),
-                    workspacePath: target.path,
+                    compiledPath: target.path,
                     mode: "link-or-copy",
                     prune: false,
                     preserveTimestamps: false,
                 });
             }
-            saveWorkspaceInterfConfig(sandboxTargetPath(), {
+            saveCompiledInterfConfig(sandboxTargetPath(), {
                 ...sandboxConfig,
                 checks: [],
                 source: {
                     path: toPortableRelativePath(sandboxTargetPath(), sandboxRawPath()),
                 },
             });
-            refreshWorkspaceBootstrapGuidance(sandboxTargetPath());
-            refreshWorkspaceArtifacts(sandboxTargetPath(), { ensureViewSpec: true });
+            refreshCompiledBootstrapGuidance(sandboxTargetPath());
+            refreshCompiledArtifacts(sandboxTargetPath(), { ensureViewSpec: true });
         }
         else {
             projectRawSnapshot({
                 sourcePath: target.path,
                 destinationPath: sandboxRawPath(),
-                workspacePath: target.path,
+                compiledPath: target.path,
                 mode: "link-or-copy",
                 prune: false,
                 preserveTimestamps: false,
@@ -91,8 +98,8 @@ export function createTestSandbox(target) {
         get targetPath() {
             return sandboxTargetPath();
         },
-        get workspacePath() {
-            return sandboxWorkspacePath();
+        get compiledPath() {
+            return sandboxCompiledPath();
         },
         preserve(destinationPath) {
             mkdirSync(dirname(destinationPath), { recursive: true });

package/dist/lib/test-targets.d.ts

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

package/dist/lib/test-targets.js

@@ -1,19 +1,19 @@
-import { listWorkspacesForSourceFolder } from "./interf.js";
-import { computeWorkspaceHealth } from "./state.js";
+import { listCompiledDatasetsForSourceFolder } from "./interf.js";
+import { computeCompiledHealth } from "./state.js";
 function summarizeTargetSortKey(target) {
     return `${target.name}\u0000${target.workflow}`;
 }
-export function listWorkspaceTestTargets(sourcePath) {
-    return listWorkspacesForSourceFolder(sourcePath)
-        .map(({ path, config }) => createWorkspaceTestTarget(path, config.name, config.workflow ?? "interf"))
+export function listCompiledTestTargets(sourcePath) {
+    return listCompiledDatasetsForSourceFolder(sourcePath)
+        .map(({ path, config }) => createCompiledTestTarget(path, config.name, config.workflow ?? "interf"))
         .sort((left, right) => summarizeTargetSortKey(left).localeCompare(summarizeTargetSortKey(right)));
 }
-export function createWorkspaceTestTarget(workspacePath, workspaceName, workflowId = "interf") {
-    const health = computeWorkspaceHealth(workspacePath);
+export function createCompiledTestTarget(compiledPath, compiledName, workflowId = "interf") {
+    const health = computeCompiledHealth(compiledPath);
     return {
-        type: "workspace",
-        name: workspaceName,
-        path: workspacePath,
+        type: "compiled",
+        name: compiledName,
+        path: compiledPath,
         workflow: workflowId,
         status: health.status,
         stage: health.stage,
@@ -34,5 +34,5 @@ export function createRawTestTarget(sourcePath) {
     };
 }
 export function listTestTargets(sourcePath) {
-    return listWorkspaceTestTargets(sourcePath);
+    return listCompiledTestTargets(sourcePath);
 }

package/dist/lib/test-types.d.ts

@@ -1,6 +1,6 @@
 import type { TestSpec } from "./schema.js";
 export type { TestCaseExpect, TestCase, TestSpec, TestCheckResult, TestCaseResult, TestTargetResult, TestTargetRun, } from "./schema.js";
-export type TestTargetType = "workspace" | "raw";
+export type TestTargetType = "compiled" | "raw";
 export interface LoadedTestSpec extends TestSpec {
     id: string;
     filePath: string;

package/dist/lib/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, createWorkspaceTestTarget, listWorkspaceTestTargets, listTestTargets, } from "./test-targets.js";
+export { createRawTestTarget, createCompiledTestTarget, listCompiledTestTargets, listTestTargets, } from "./test-targets.js";
 export { runTargetTests, runTargetTestsWithJudge, runTargetTestsAuto, saveTargetTestRun, } from "./test-execution.js";

package/dist/lib/test.js

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

package/dist/lib/util.d.ts

@@ -1,2 +1,4 @@
 export declare function slugify(input: string): string;
 export declare function isMarkdownFile(filePath: string): boolean;
+export declare function isPathWithinRoot(rootPath: string, candidatePath: string): boolean;
+export declare function assertPathWithinRoot(rootPath: string, candidatePath: string, label: string): string;

package/dist/lib/util.js

@@ -1,4 +1,4 @@
-import { extname } from "node:path";
+import { extname, isAbsolute, relative, resolve, sep } from "node:path";
 export function slugify(input) {
     return input
         .toLowerCase()
@@ -10,3 +10,16 @@ export function slugify(input) {
 export function isMarkdownFile(filePath) {
     return extname(filePath).toLowerCase() === ".md";
 }
+export function isPathWithinRoot(rootPath, candidatePath) {
+    const root = resolve(rootPath);
+    const candidate = resolve(candidatePath);
+    const relativePath = relative(root, candidate);
+    return relativePath === "" || (!isAbsolute(relativePath) && relativePath !== ".." && !relativePath.startsWith(`..${sep}`));
+}
+export function assertPathWithinRoot(rootPath, candidatePath, label) {
+    const resolvedPath = resolve(candidatePath);
+    if (!isPathWithinRoot(rootPath, resolvedPath)) {
+        throw new Error(`${label} must stay inside ${resolve(rootPath)}: ${resolvedPath}`);
+    }
+    return resolvedPath;
+}

package/dist/lib/validate-compiled.d.ts

@@ -0,0 +1,27 @@
+export interface CompiledValidationSummary {
+    config_present: boolean;
+    config_valid: boolean;
+    config_type_match: boolean;
+    workflow_present: boolean;
+    workflow_valid: boolean;
+    schema_present: boolean;
+    schema_valid: boolean;
+}
+export interface CompiledStageValidation {
+    ok: boolean;
+    required: boolean;
+    stage: string;
+    summary: string;
+    counts: Record<string, number>;
+    checks: Record<string, boolean>;
+    errors: string[];
+}
+export interface CompiledWorkflowValidation extends CompiledStageValidation {
+    stage_results: Record<string, boolean>;
+}
+export declare function validateCompiled(dirPath: string): CompiledValidationSummary;
+export declare function validateCompiledStage(dirPath: string, stageId: string): CompiledStageValidation;
+export declare function validateCompiledWorkflow(dirPath: string): CompiledWorkflowValidation;
+export declare function validateCompiledSummarize(dirPath: string): CompiledStageValidation;
+export declare function validateCompiledStructure(dirPath: string): CompiledStageValidation;
+export declare function validateCompiledCompile(dirPath: string): CompiledWorkflowValidation;