@interf/compiler 0.4.0 → 0.5.0

package/dist/lib/{workspace-raw.js → compiled-raw.js}

@@ -2,29 +2,30 @@ import { cpSync, existsSync, linkSync, mkdirSync, rmSync, statSync, } from "node
 import { dirname, join, relative, resolve } from "node:path";
 import { listFilesRecursive } from "./filesystem.js";
 import { discoverSourceFiles } from "./discovery.js";
-import { readInterfConfig, resolveSourceControlPath, } from "./interf-detect.js";
-import { saveWorkspaceInterfConfig } from "./source-config.js";
-import { defaultControlPathForWorkspace, } from "./workspace-paths.js";
-export function resolveWorkspaceRawPath(workspacePath, config = readInterfConfig(workspacePath)) {
+import { readInterfConfig, resolveSourceInputPath, } from "./interf-detect.js";
+import { saveCompiledInterfConfig } from "./source-config.js";
+import { defaultControlPathForCompiled, } from "./compiled-paths.js";
+import { assertPathWithinRoot } from "./util.js";
+export function resolveCompiledRawPath(compiledPath, config = readInterfConfig(compiledPath)) {
     const configuredPath = typeof config?.source?.path === "string" && config.source.path.length > 0
         ? config.source.path
         : "raw";
-    return resolve(workspacePath, configuredPath);
+    return assertPathWithinRoot(compiledPath, resolve(compiledPath, configuredPath), "Compiled raw path");
 }
-export function syncWorkspaceRawSnapshot(workspacePath, sourcePath = resolveSourceControlPath(workspacePath)) {
-    ensureWorkspaceRawBinding(workspacePath);
-    const rawPath = resolveWorkspaceRawPath(workspacePath);
+export function syncCompiledRawSnapshot(compiledPath, sourcePath = resolveSourceInputPath(compiledPath)) {
+    ensureCompiledRawBinding(compiledPath);
+    const rawPath = resolveCompiledRawPath(compiledPath);
     return projectRawSnapshot({
         sourcePath,
         destinationPath: rawPath,
-        workspacePath,
+        compiledPath,
         mode: "copy",
         prune: true,
         preserveTimestamps: true,
     });
 }
-export function ensureWorkspaceRawBinding(workspacePath) {
-    const config = readInterfConfig(workspacePath);
+export function ensureCompiledRawBinding(compiledPath) {
+    const config = readInterfConfig(compiledPath);
     if (!config)
         return null;
     if (config.source?.path === "./raw")
@@ -34,10 +35,11 @@ export function ensureWorkspaceRawBinding(workspacePath) {
         source: {
             ...(config.source ?? {}),
             path: "./raw",
-            control_path: config.source?.control_path ?? defaultControlPathForWorkspace(workspacePath),
+            control_path: config.source?.control_path ?? defaultControlPathForCompiled(compiledPath),
+            ...(config.source?.dataset_path ? { dataset_path: config.source.dataset_path } : {}),
         },
     };
-    return saveWorkspaceInterfConfig(workspacePath, nextConfig);
+    return saveCompiledInterfConfig(compiledPath, nextConfig);
 }
 function filesMatch(sourcePath, targetPath) {
     if (!existsSync(targetPath))
@@ -66,7 +68,7 @@ function materializeRawSnapshotFile(sourcePath, targetPath, options) {
     cpSync(sourcePath, targetPath, { preserveTimestamps: options.preserveTimestamps });
 }
 export function projectRawSnapshot(options) {
-    const discovery = discoverSourceFiles(options.sourcePath, options.workspacePath);
+    const discovery = discoverSourceFiles(options.sourcePath, options.compiledPath);
     const expectedFiles = new Set(discovery.sourceFiles);
     mkdirSync(options.destinationPath, { recursive: true });
     let removed = 0;

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

@@ -0,0 +1 @@
+export declare function resetCompiledGeneratedState(compiledPath: string, scope?: "compile" | "all"): void;

package/dist/lib/compiled-reset.js

@@ -0,0 +1,44 @@
+import { existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { compiledKnowledgeRootPath, compiledSummariesPath, } from "./compiled-schema.js";
+import { initCompiledState, refreshCompiledArtifacts, saveState, } from "./state.js";
+import { saveEmptyCompiledInventory } from "./state-io.js";
+import { stageExecutionShellsRoot, testRootForCompiled, testTargetsRootForCompiled, workflowImprovementLoopsRoot, compiledQueryAcceptanceRoot, compiledRuntimeRoot, compiledRuntimeLogsRoot, } from "./compiled-paths.js";
+function removeIfExists(path) {
+    if (existsSync(path)) {
+        rmSync(path, { recursive: true, force: true });
+    }
+}
+const COMPILE_RUNTIME_RESET_ENTRIES = [
+    "state.json",
+    "health.json",
+    "view-spec.json",
+    "inventory.json",
+    "run.json",
+    "stage-contract.json",
+    "summarize-targets.json",
+];
+function resetCompiledRuntimeFiles(compiledPath) {
+    const runtimeRoot = compiledRuntimeRoot(compiledPath);
+    for (const entry of COMPILE_RUNTIME_RESET_ENTRIES) {
+        removeIfExists(join(runtimeRoot, entry));
+    }
+    removeIfExists(compiledQueryAcceptanceRoot(compiledPath));
+}
+export function resetCompiledGeneratedState(compiledPath, scope = "compile") {
+    removeIfExists(compiledSummariesPath(compiledPath));
+    removeIfExists(compiledKnowledgeRootPath(compiledPath));
+    removeIfExists(join(compiledPath, ".obsidian"));
+    resetCompiledRuntimeFiles(compiledPath);
+    saveState(compiledPath, initCompiledState());
+    saveEmptyCompiledInventory(compiledPath);
+    refreshCompiledArtifacts(compiledPath, { ensureViewSpec: true });
+    if (scope === "all") {
+        removeIfExists(stageExecutionShellsRoot(compiledPath));
+        removeIfExists(workflowImprovementLoopsRoot(compiledPath));
+        removeIfExists(compiledRuntimeLogsRoot(compiledPath));
+        removeIfExists(join(compiledRuntimeRoot(compiledPath), "run-history.jsonl"));
+        removeIfExists(testRootForCompiled(compiledPath));
+        removeIfExists(testTargetsRootForCompiled(compiledPath));
+    }
+}

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

@@ -0,0 +1,27 @@
+import { type BuiltinCompiledZoneId } from "./workflow-abi.js";
+import { type WorkflowCompiledSchema, type WorkflowCompiledZone, type WorkflowZoneId } from "./schema.js";
+export interface WorkflowSchemaStageLike {
+    id: string;
+    writes: readonly string[];
+}
+export { BUILTIN_COMPILED_ZONE_IDS } from "./workflow-abi.js";
+export declare const COMPILED_SCHEMA_FILE = "compiled.schema.json";
+export declare function compiledSchemaFilePath(rootPath: string): string;
+export declare function compiledSchemaRelativePath(): string;
+export declare function listCompiledSchemaZones(schema: WorkflowCompiledSchema): WorkflowCompiledZone[];
+export declare function findCompiledSchemaZone(schema: WorkflowCompiledSchema, zoneId: WorkflowZoneId): WorkflowCompiledZone | null;
+export declare function compiledZoneAbsolutePath(compiledPath: string, zone: Pick<WorkflowCompiledZone, "path">): string;
+export declare function compiledContractArtifactPath(zone: Pick<WorkflowCompiledZone, "path" | "kind">): string;
+export declare function compiledContractArtifactPathsForZoneIds(schema: WorkflowCompiledSchema, zoneIds: readonly WorkflowZoneId[]): string[];
+export declare function builtinCompiledZoneRelativePath(zoneId: BuiltinCompiledZoneId): string;
+export declare function builtinCompiledZoneAbsolutePath(compiledPath: string, zoneId: BuiltinCompiledZoneId): string;
+export declare function compiledSummariesPath(compiledPath: string): string;
+export declare function compiledKnowledgeEntitiesPath(compiledPath: string): string;
+export declare function compiledKnowledgeClaimsPath(compiledPath: string): string;
+export declare function compiledKnowledgeIndexesPath(compiledPath: string): string;
+export declare function compiledKnowledgeRootPath(compiledPath: string): string;
+export declare function compiledHomePath(compiledPath: string): string;
+export declare function ensureCompiledZoneTargets(compiledPath: string, schema: WorkflowCompiledSchema): void;
+export declare function buildCompiledSchema(stages: WorkflowSchemaStageLike[], label?: string): WorkflowCompiledSchema;
+export declare function writeCompiledSchemaFile(rootPath: string, stages: WorkflowSchemaStageLike[], label?: string): WorkflowCompiledSchema;
+export declare function readCompiledSchemaFile(rootPath: string): WorkflowCompiledSchema | null;

package/dist/lib/compiled-schema.js

@@ -0,0 +1,110 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { readJsonFileWithSchema } from "./parse.js";
+import { BUILTIN_COMPILED_ZONE_IDS, listBuiltinCompiledZoneSpecs, requiredCompiledZoneOwners, } from "./workflow-abi.js";
+import { WorkflowCompiledSchemaSchema, } from "./schema.js";
+export { BUILTIN_COMPILED_ZONE_IDS } from "./workflow-abi.js";
+export const COMPILED_SCHEMA_FILE = "compiled.schema.json";
+const BUILTIN_COMPILED_ZONE_SPEC_BY_ID = new Map(listBuiltinCompiledZoneSpecs().map((zone) => [zone.id, zone]));
+export function compiledSchemaFilePath(rootPath) {
+    return join(rootPath, COMPILED_SCHEMA_FILE);
+}
+export function compiledSchemaRelativePath() {
+    return `workflow/${COMPILED_SCHEMA_FILE}`;
+}
+export function listCompiledSchemaZones(schema) {
+    return [...schema.zones];
+}
+export function findCompiledSchemaZone(schema, zoneId) {
+    return schema.zones.find((zone) => zone.id === zoneId) ?? null;
+}
+export function compiledZoneAbsolutePath(compiledPath, zone) {
+    return join(compiledPath, zone.path);
+}
+export function compiledContractArtifactPath(zone) {
+    if (zone.kind === "file")
+        return zone.path;
+    return zone.path.endsWith("/") ? zone.path : `${zone.path}/`;
+}
+export function compiledContractArtifactPathsForZoneIds(schema, zoneIds) {
+    return zoneIds.map((zoneId) => {
+        const zone = findCompiledSchemaZone(schema, zoneId);
+        if (!zone) {
+            throw new Error(`Compiled schema is missing declared zone "${zoneId}".`);
+        }
+        return compiledContractArtifactPath(zone);
+    });
+}
+export function builtinCompiledZoneRelativePath(zoneId) {
+    const zone = BUILTIN_COMPILED_ZONE_SPEC_BY_ID.get(zoneId);
+    if (!zone) {
+        throw new Error(`Missing built-in compiled zone "${zoneId}".`);
+    }
+    return zone.path;
+}
+export function builtinCompiledZoneAbsolutePath(compiledPath, zoneId) {
+    return join(compiledPath, builtinCompiledZoneRelativePath(zoneId));
+}
+export function compiledSummariesPath(compiledPath) {
+    return builtinCompiledZoneAbsolutePath(compiledPath, BUILTIN_COMPILED_ZONE_IDS.SUMMARIES);
+}
+export function compiledKnowledgeEntitiesPath(compiledPath) {
+    return builtinCompiledZoneAbsolutePath(compiledPath, BUILTIN_COMPILED_ZONE_IDS.KNOWLEDGE_ENTITIES);
+}
+export function compiledKnowledgeClaimsPath(compiledPath) {
+    return builtinCompiledZoneAbsolutePath(compiledPath, BUILTIN_COMPILED_ZONE_IDS.KNOWLEDGE_CLAIMS);
+}
+export function compiledKnowledgeIndexesPath(compiledPath) {
+    return builtinCompiledZoneAbsolutePath(compiledPath, BUILTIN_COMPILED_ZONE_IDS.KNOWLEDGE_INDEXES);
+}
+export function compiledKnowledgeRootPath(compiledPath) {
+    return dirname(compiledKnowledgeEntitiesPath(compiledPath));
+}
+export function compiledHomePath(compiledPath) {
+    return builtinCompiledZoneAbsolutePath(compiledPath, BUILTIN_COMPILED_ZONE_IDS.HOME);
+}
+export function ensureCompiledZoneTargets(compiledPath, schema) {
+    for (const zone of schema.zones) {
+        if (zone.kind === "directory" || zone.kind === "runtime") {
+            mkdirSync(compiledZoneAbsolutePath(compiledPath, zone), { recursive: true });
+            continue;
+        }
+        mkdirSync(dirname(compiledZoneAbsolutePath(compiledPath, zone)), { recursive: true });
+    }
+}
+function pushZone(zones, zone) {
+    if (zones.some((existing) => existing.path === zone.path))
+        return;
+    zones.push(zone);
+}
+export function buildCompiledSchema(stages, label = "Compiled dataset schema") {
+    const zones = [];
+    for (const zone of listBuiltinCompiledZoneSpecs()) {
+        pushZone(zones, {
+            id: zone.id,
+            path: zone.path,
+            kind: zone.kind,
+            required: zone.required,
+            owned_by: requiredCompiledZoneOwners(stages, zone.id),
+            description: zone.description,
+        });
+    }
+    return {
+        kind: "compiled-schema",
+        version: 1,
+        target_type: "compiled",
+        label,
+        zones,
+    };
+}
+export function writeCompiledSchemaFile(rootPath, stages, label) {
+    const schema = buildCompiledSchema(stages, label);
+    writeFileSync(compiledSchemaFilePath(rootPath), `${JSON.stringify(schema, null, 2)}\n`);
+    return schema;
+}
+export function readCompiledSchemaFile(rootPath) {
+    const path = compiledSchemaFilePath(rootPath);
+    if (!existsSync(path))
+        return null;
+    return readJsonFileWithSchema(path, "compiled schema", WorkflowCompiledSchemaSchema);
+}

package/dist/lib/config.d.ts

@@ -1,3 +1,2 @@
 export declare const PACKAGE_ROOT: string;
 export declare const INTERF_HOME: string;
-export declare const REGISTRY_PATH: string;

package/dist/lib/config.js

@@ -7,4 +7,3 @@ const __dirname = dirname(__filename);
 export const PACKAGE_ROOT = join(__dirname, "..", "..");
 // User config
 export const INTERF_HOME = join(homedir(), ".interf");
-export const REGISTRY_PATH = join(INTERF_HOME, "registry.json");

package/dist/lib/discovery.d.ts

@@ -3,5 +3,5 @@ export interface DiscoveryResult {
     totalCount: number;
     ignoredCount: number;
 }
-export declare function discoverSourceFiles(sourcePath: string, workspacePath: string): DiscoveryResult;
+export declare function discoverSourceFiles(sourcePath: string, compiledPath: string): DiscoveryResult;
 export declare function loadIgnorePatterns(knowledgeBasePath: string): string[];

package/dist/lib/discovery.js

@@ -10,10 +10,10 @@ const DEFAULT_IGNORE_DIRS = new Set([
     "node_modules",
 ]);
 const DEFAULT_IGNORE_FILES = new Set([
-    "interf.config.json",
+    "interf.json",
 ]);
-export function discoverSourceFiles(sourcePath, workspacePath) {
-    const userPatterns = loadIgnorePatterns(workspacePath);
+export function discoverSourceFiles(sourcePath, compiledPath) {
+    const userPatterns = loadIgnorePatterns(compiledPath);
     let ignoredCount = 0;
     const allFiles = listFilesRecursive(sourcePath, (filePath) => {
         const rel = relative(sourcePath, filePath);

package/dist/lib/interf-bootstrap.d.ts

@@ -1,3 +1,3 @@
 import { renderClaudeBootstrap } from "./agent-shells.js";
 export { renderClaudeBootstrap };
-export declare function refreshWorkspaceBootstrapGuidance(dirPath: string): boolean;
+export declare function refreshCompiledBootstrapGuidance(dirPath: string): boolean;

package/dist/lib/interf-bootstrap.js

@@ -1,17 +1,17 @@
 import { basename } from "node:path";
 import { readInterfConfig } from "./interf-detect.js";
-import { projectWorkspaceQueryShell, renderClaudeBootstrap } from "./agent-shells.js";
+import { projectCompiledQueryShell, renderClaudeBootstrap } from "./agent-shells.js";
 export { renderClaudeBootstrap };
-export function refreshWorkspaceBootstrapGuidance(dirPath) {
+export function refreshCompiledBootstrapGuidance(dirPath) {
     const config = readInterfConfig(dirPath);
     if (!config)
         return false;
-    const workspaceName = config.name ?? basename(dirPath);
+    const compiledName = config.name ?? basename(dirPath);
     const workflowId = config.workflow ?? "interf";
     const workflowOriginSelected = config.workflow_origin?.selected ?? workflowId;
     const workflowLocalDraft = config.workflow_origin?.local_draft === true;
     const about = typeof config.about === "string" && config.about.length > 0 ? config.about : undefined;
-    return projectWorkspaceQueryShell(dirPath, workspaceName, workflowId, about, {
+    return projectCompiledQueryShell(dirPath, compiledName, workflowId, about, {
         workflowOriginSelected,
         workflowLocalDraft,
     });

package/dist/lib/interf-detect.d.ts

@@ -1,17 +1,16 @@
 import { type InterfConfig } from "./schema.js";
 export type { InterfConfig } from "./schema.js";
-export interface ResolvedWorkspace {
+export interface ResolvedCompiled {
     sourcePath: string;
-    workspacePath: string;
+    compiledPath: string;
     config: InterfConfig;
 }
 export declare const INTERF_CONTAINER_NAME = "interf";
-export declare const WORKSPACE_CONTAINER_NAME = "workspaces";
 export declare const WORKFLOW_CONTAINER_NAME = "workflows";
 export declare const TEST_CONTAINER_NAME = "tests";
 export declare const INTERF_CONFIG_FILE = "interf.json";
 export declare const WORKFLOW_PACKAGE_DIR = "workflow";
-export declare function prepareWorkspaceLayout(dirPath: string): boolean;
+export declare function prepareCompiledLayout(dirPath: string): boolean;
 export declare function readInterfConfig(dirPath: string): InterfConfig | null;
 export declare function hasSourceFolderInput(config: InterfConfig | null | undefined): config is InterfConfig & {
     source: {
@@ -22,13 +21,14 @@ export declare function detectInterf(cwd: string): {
     path: string;
     config: InterfConfig;
 } | null;
-export declare function resolveWorkspace(cwd: string): ResolvedWorkspace | null;
-export declare function resolveSourceFolderPath(workspacePath: string, config?: InterfConfig | null): string;
-export declare function resolveSourceControlPath(workspacePath: string): string;
-export declare function listWorkspacesForSourceFolder(sourcePath: string): Array<{
+export declare function resolveCompiled(cwd: string): ResolvedCompiled | null;
+export declare function resolveSourceFolderPath(compiledPath: string, config?: InterfConfig | null): string;
+export declare function resolveSourceControlPath(compiledPath: string): string;
+export declare function resolveSourceInputPath(compiledPath: string): string;
+export declare function listCompiledDatasetsForSourceFolder(sourcePath: string): Array<{
     path: string;
     config: InterfConfig;
 }>;
-export declare function assertWorkspaceContainer(sourcePath: string): string;
+export declare function assertCompiledContainer(sourcePath: string): string;
 export declare function assertWritableTargetDir(dirPath: string, label: string): void;
-export declare function assertWorkspaceName(name: string, label: string): void;
+export declare function assertCompiledName(name: string, label: string): void;

package/dist/lib/interf-detect.js

@@ -1,98 +1,108 @@
 import { existsSync, readdirSync, statSync, } from "node:fs";
 import { join, resolve } from "node:path";
 import { warnInterf } from "./logger.js";
-import { readJsonFileWithSchema } from "./parse.js";
-import { resolveSourceControlPathForWorkspace, workspaceInterfConfigPath, } from "./workspace-paths.js";
-import { normalizeLegacyWorkspaceLayout, workspaceNeedsLegacyLayoutNormalization, } from "./workspace-layout.js";
+import { readJsonFileUnchecked } from "./parse.js";
+import { compiledCompiledPathForDataset, projectInterfRoot, } from "./project-paths.js";
+import { resolveSourceControlPathForCompiled, compiledInterfConfigPath, } from "./compiled-paths.js";
+import { normalizeLegacyCompiledLayout, compiledNeedsLegacyLayoutNormalization, } from "./compiled-layout.js";
 import { InterfConfigSchema, } from "./schema.js";
+import { assertPathWithinRoot } from "./util.js";
 export const INTERF_CONTAINER_NAME = "interf";
-export const WORKSPACE_CONTAINER_NAME = "workspaces";
 export const WORKFLOW_CONTAINER_NAME = "workflows";
 export const TEST_CONTAINER_NAME = "tests";
 export const INTERF_CONFIG_FILE = "interf.json";
 export const WORKFLOW_PACKAGE_DIR = "workflow";
-export function prepareWorkspaceLayout(dirPath) {
-    if (!workspaceNeedsLegacyLayoutNormalization(dirPath)) {
+export function prepareCompiledLayout(dirPath) {
+    if (!compiledNeedsLegacyLayoutNormalization(dirPath)) {
         return false;
     }
-    return normalizeLegacyWorkspaceLayout(dirPath);
+    return normalizeLegacyCompiledLayout(dirPath);
 }
 export function readInterfConfig(dirPath) {
-    const configPath = workspaceInterfConfigPath(dirPath);
+    const configPath = compiledInterfConfigPath(dirPath);
     if (!existsSync(configPath))
         return null;
-    return readJsonFileWithSchema(configPath, "Interf config", InterfConfigSchema);
+    const raw = readJsonFileUnchecked(configPath, "Interf config");
+    if (raw === null)
+        return null;
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    if (raw.type !== "compiled") {
+        return null;
+    }
+    const parsed = InterfConfigSchema.safeParse(raw);
+    if (!parsed.success) {
+        warnInterf(`Warning: failed to validate Interf config at ${configPath}: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
+        return null;
+    }
+    return parsed.data;
 }
 export function hasSourceFolderInput(config) {
     return typeof config?.source?.path === "string" && config.source.path.length > 0;
 }
 export function detectInterf(cwd) {
-    prepareWorkspaceLayout(cwd);
+    prepareCompiledLayout(cwd);
     const config = readInterfConfig(cwd);
     if (config)
         return { path: cwd, config };
     return null;
 }
-export function resolveWorkspace(cwd) {
+export function resolveCompiled(cwd) {
     const detected = detectInterf(cwd);
     if (!detected)
         return null;
     return {
         sourcePath: resolveSourceControlPath(detected.path),
-        workspacePath: detected.path,
+        compiledPath: detected.path,
         config: detected.config,
     };
 }
-export function resolveSourceFolderPath(workspacePath, config = null) {
-    prepareWorkspaceLayout(workspacePath);
-    const resolvedConfig = config ?? readInterfConfig(workspacePath);
+export function resolveSourceFolderPath(compiledPath, config = null) {
+    prepareCompiledLayout(compiledPath);
+    const resolvedConfig = config ?? readInterfConfig(compiledPath);
     if (hasSourceFolderInput(resolvedConfig)) {
-        return resolve(workspacePath, resolvedConfig.source.path);
+        return assertPathWithinRoot(compiledPath, resolve(compiledPath, resolvedConfig.source.path), "Compiled raw source path");
     }
-    return resolve(workspacePath, "raw");
+    return resolve(compiledPath, "raw");
 }
-export function resolveSourceControlPath(workspacePath) {
-    prepareWorkspaceLayout(workspacePath);
-    const config = readInterfConfig(workspacePath);
-    if (typeof config?.source?.control_path === "string" && config.source.control_path.length > 0) {
-        return resolve(workspacePath, config.source.control_path);
+export function resolveSourceControlPath(compiledPath) {
+    prepareCompiledLayout(compiledPath);
+    return resolveSourceControlPathForCompiled(compiledPath);
+}
+export function resolveSourceInputPath(compiledPath) {
+    prepareCompiledLayout(compiledPath);
+    const projectPath = resolveSourceControlPathForCompiled(compiledPath);
+    const config = readInterfConfig(compiledPath);
+    if (typeof config?.source?.dataset_path === "string" && config.source.dataset_path.length > 0) {
+        return assertPathWithinRoot(projectPath, resolve(compiledPath, config.source.dataset_path), "Dataset source path");
     }
-    return resolveSourceControlPathForWorkspace(workspacePath);
+    return projectPath;
 }
-function listWorkspaceEntries(containerPath) {
-    if (!existsSync(containerPath))
+export function listCompiledDatasetsForSourceFolder(sourcePath) {
+    const interfRoot = projectInterfRoot(sourcePath);
+    if (!existsSync(interfRoot))
         return [];
     try {
-        if (!statSync(containerPath).isDirectory())
+        if (!statSync(interfRoot).isDirectory())
             return [];
     }
     catch (error) {
-        warnInterf(`Warning: failed to inspect Interf container at ${containerPath}: ${error instanceof Error ? error.message : String(error)}`);
+        warnInterf(`Warning: failed to inspect Interf container at ${interfRoot}: ${error instanceof Error ? error.message : String(error)}`);
         return [];
     }
-    return readdirSync(containerPath)
-        .map((entry) => join(containerPath, entry))
-        .filter((entryPath) => {
-        try {
-            return statSync(entryPath).isDirectory();
-        }
-        catch (error) {
-            warnInterf(`Warning: failed to inspect workspace candidate at ${entryPath}: ${error instanceof Error ? error.message : String(error)}`);
-            return false;
-        }
-    })
-        .map((entryPath) => {
-        prepareWorkspaceLayout(entryPath);
-        const config = readInterfConfig(entryPath);
-        return config ? { path: entryPath, config } : null;
+    return readdirSync(interfRoot)
+        .filter((entry) => !entry.startsWith(".") && entry !== WORKFLOW_CONTAINER_NAME)
+        .map((entry) => compiledCompiledPathForDataset(sourcePath, entry))
+        .filter((compiledPath) => existsSync(compiledPath))
+        .map((compiledPath) => {
+        prepareCompiledLayout(compiledPath);
+        const config = readInterfConfig(compiledPath);
+        return config ? { path: compiledPath, config } : null;
     })
         .filter((value) => value !== null);
 }
-export function listWorkspacesForSourceFolder(sourcePath) {
-    return listWorkspaceEntries(join(sourcePath, INTERF_CONTAINER_NAME, WORKSPACE_CONTAINER_NAME));
-}
-export function assertWorkspaceContainer(sourcePath) {
-    const interfRoot = join(sourcePath, INTERF_CONTAINER_NAME);
+export function assertCompiledContainer(sourcePath) {
+    const interfRoot = projectInterfRoot(sourcePath);
     if (existsSync(interfRoot)) {
         const stat = statSync(interfRoot);
         if (!stat.isDirectory()) {
@@ -102,9 +112,7 @@ export function assertWorkspaceContainer(sourcePath) {
             if (entry.startsWith("."))
                 return false;
             const entryPath = join(interfRoot, entry);
-            if (entry === WORKSPACE_CONTAINER_NAME ||
-                entry === WORKFLOW_CONTAINER_NAME ||
-                entry === TEST_CONTAINER_NAME) {
+            if (entry === WORKFLOW_CONTAINER_NAME) {
                 try {
                     return !statSync(entryPath).isDirectory();
                 }
@@ -113,13 +121,21 @@ export function assertWorkspaceContainer(sourcePath) {
                     return true;
                 }
             }
-            return true;
+            try {
+                if (!statSync(entryPath).isDirectory())
+                    return true;
+            }
+            catch (error) {
+                warnInterf(`Warning: failed to inspect Interf entry at ${entryPath}: ${error instanceof Error ? error.message : String(error)}`);
+                return true;
+            }
+            return false;
         });
         if (unexpectedRootEntries.length > 0) {
             throw new Error(`Interf container contains unexpected entries: ${interfRoot}`);
         }
     }
-    const containerPath = join(interfRoot, WORKSPACE_CONTAINER_NAME);
+    const containerPath = interfRoot;
     if (!existsSync(containerPath)) {
         return containerPath;
     }
@@ -130,6 +146,8 @@ export function assertWorkspaceContainer(sourcePath) {
     const unexpectedEntries = readdirSync(containerPath).filter((entry) => {
         if (entry.startsWith("."))
             return false;
+        if (entry === WORKFLOW_CONTAINER_NAME)
+            return false;
         const entryPath = join(containerPath, entry);
         try {
             if (!statSync(entryPath).isDirectory())
@@ -139,11 +157,15 @@ export function assertWorkspaceContainer(sourcePath) {
             warnInterf(`Warning: failed to inspect Interf entry at ${entryPath}: ${error instanceof Error ? error.message : String(error)}`);
             return true;
         }
-        prepareWorkspaceLayout(entryPath);
-        return !readInterfConfig(entryPath);
+        const compiledPath = compiledCompiledPathForDataset(sourcePath, entry);
+        if (!existsSync(compiledPath)) {
+            return false;
+        }
+        prepareCompiledLayout(compiledPath);
+        return !readInterfConfig(compiledPath);
     });
     if (unexpectedEntries.length > 0) {
-        throw new Error(`Interf container contains invalid workspace entries: ${containerPath}`);
+        throw new Error(`Interf container contains invalid dataset entries: ${containerPath}`);
     }
     return containerPath;
 }
@@ -158,7 +180,7 @@ export function assertWritableTargetDir(dirPath, label) {
         throw new Error(`${label} target already exists and is not empty: ${dirPath}`);
     }
 }
-export function assertWorkspaceName(name, label) {
+export function assertCompiledName(name, label) {
     if (!/^[a-z0-9][a-z0-9-]*$/.test(name)) {
         throw new Error(`${label} name must be a safe slug with lowercase letters, numbers, and dashes only: ${name}`);
     }

package/dist/lib/interf-scaffold.d.ts

@@ -1,2 +1,2 @@
-export declare function createWorkspace(name: string, sourcePath: string, workflowId?: string, about?: string): string;
-export declare function defaultWorkspaceNameForSource(sourcePath: string): string;
+export declare function createCompiled(name: string, sourcePath: string, workflowId?: string, about?: string, datasetPath?: string): string;
+export declare function defaultCompiledNameForSource(sourcePath: string): string;