@interf/compiler 0.5.1 → 0.6.3

package/dist/packages/project-model/compiled-paths.js

@@ -0,0 +1,106 @@
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
+export const COMPILED_INTERF_DIR = ".interf";
+export const COMPILED_CONFIG_FILE = "interf.json";
+export const COMPILED_WORKFLOW_DIR = "workflow";
+export const COMPILED_TEST_DIR = "tests";
+export const COMPILED_TEST_TARGETS_DIR = "targets";
+export const COMPILED_RUNTIME_DIR = "runtime";
+export const COMPILED_RUNTIME_STATE_FILE = "state.json";
+export const COMPILED_RUNTIME_HEALTH_FILE = "health.json";
+export const COMPILED_RUNTIME_VIEW_SPEC_FILE = "view-spec.json";
+export const COMPILED_RUNTIME_RAW_SNAPSHOT_FILE = "raw-snapshot.json";
+export const COMPILED_RUNTIME_INVENTORY_FILE = "inventory.json";
+export const COMPILED_RUNTIME_RUN_FILE = "run.json";
+export const COMPILED_RUNTIME_RUN_HISTORY_FILE = "run-history.jsonl";
+export const COMPILED_RUNTIME_STAGE_CONTRACT_FILE = "stage-contract.json";
+export function compiledRuntimeRoot(compiledPath) {
+    return join(compiledPath, COMPILED_INTERF_DIR, COMPILED_RUNTIME_DIR);
+}
+export function compiledRuntimeFilePath(compiledPath, fileName) {
+    return join(compiledRuntimeRoot(compiledPath), fileName);
+}
+export function compiledInterfRoot(compiledPath) {
+    return join(compiledPath, COMPILED_INTERF_DIR);
+}
+export function compiledInterfConfigPath(compiledPath) {
+    return join(compiledInterfRoot(compiledPath), COMPILED_CONFIG_FILE);
+}
+export function workflowPackagePathForCompiled(compiledPath) {
+    return join(compiledInterfRoot(compiledPath), COMPILED_WORKFLOW_DIR);
+}
+export function testRootForCompiled(compiledPath) {
+    return join(compiledInterfRoot(compiledPath), COMPILED_TEST_DIR);
+}
+export function testTargetsRootForCompiled(compiledPath) {
+    return join(testRootForCompiled(compiledPath), COMPILED_TEST_TARGETS_DIR);
+}
+export function stageExecutionShellsRoot(compiledPath) {
+    return join(compiledRuntimeRoot(compiledPath), "execution-shells");
+}
+export function workflowImprovementLoopsRoot(compiledPath) {
+    return join(compiledRuntimeRoot(compiledPath), "improvement-loops");
+}
+export function workflowImprovementRunRoot(compiledPath, runId) {
+    return join(workflowImprovementLoopsRoot(compiledPath), runId);
+}
+export function workflowImprovementLoopRoot(compiledPath, runId, loopIndex) {
+    return join(workflowImprovementRunRoot(compiledPath, runId), `loop-${String(loopIndex).padStart(2, "0")}`);
+}
+export function targetTestRunsRootForCompiled(compiledPath) {
+    return join(testTargetsRootForCompiled(compiledPath), "runs");
+}
+export function targetTestSandboxesRootForCompiled(compiledPath) {
+    return join(testTargetsRootForCompiled(compiledPath), "sandboxes");
+}
+export function compiledRuntimeLogsRoot(compiledPath) {
+    return join(compiledRuntimeRoot(compiledPath), "logs");
+}
+export function compiledRuntimeArchivedStageContractPath(compiledPath, runId) {
+    return join(compiledRuntimeLogsRoot(compiledPath), `${runId}.stage-contract.json`);
+}
+export function compiledQueryAcceptanceRoot(compiledPath) {
+    return join(compiledRuntimeRoot(compiledPath), "query-acceptance");
+}
+export function compiledRuntimeStatePath(compiledPath) {
+    return compiledRuntimeFilePath(compiledPath, COMPILED_RUNTIME_STATE_FILE);
+}
+export function compiledRuntimeHealthPath(compiledPath) {
+    return compiledRuntimeFilePath(compiledPath, COMPILED_RUNTIME_HEALTH_FILE);
+}
+export function compiledRuntimeViewSpecPath(compiledPath) {
+    return compiledRuntimeFilePath(compiledPath, COMPILED_RUNTIME_VIEW_SPEC_FILE);
+}
+export function compiledRawSnapshotMetadataPath(compiledPath) {
+    return compiledRuntimeFilePath(compiledPath, COMPILED_RUNTIME_RAW_SNAPSHOT_FILE);
+}
+export function compiledRuntimeInventoryPath(compiledPath) {
+    return compiledRuntimeFilePath(compiledPath, COMPILED_RUNTIME_INVENTORY_FILE);
+}
+export function compiledRuntimeRunPath(compiledPath) {
+    return compiledRuntimeFilePath(compiledPath, COMPILED_RUNTIME_RUN_FILE);
+}
+export function compiledRuntimeRunHistoryPath(compiledPath) {
+    return compiledRuntimeFilePath(compiledPath, COMPILED_RUNTIME_RUN_HISTORY_FILE);
+}
+export function compiledRuntimeStageContractPath(compiledPath) {
+    return compiledRuntimeFilePath(compiledPath, COMPILED_RUNTIME_STAGE_CONTRACT_FILE);
+}
+export function resolveSourceControlPathForCompiled(compiledPath) {
+    let cursor = resolve(compiledPath);
+    while (true) {
+        const parent = dirname(cursor);
+        if (basename(parent) === "interf" &&
+            basename(cursor) !== "tests" &&
+            basename(cursor) !== "workflows") {
+            return dirname(parent);
+        }
+        if (parent === cursor)
+            break;
+        cursor = parent;
+    }
+    throw new Error(`Context folder is not under the canonical project layout: ${compiledPath}`);
+}
+export function defaultControlPathForCompiled(compiledPath) {
+    const relativePath = relative(compiledPath, resolveSourceControlPathForCompiled(compiledPath));
+    return relativePath.length > 0 ? relativePath.split(sep).join("/") : ".";
+}

package/dist/packages/project-model/compiled-raw.d.ts

@@ -0,0 +1,49 @@
+import type { InterfConfig } from "./lib/schema.js";
+export interface CompiledRawSyncResult {
+    sourceTotal: number;
+    copied: number;
+    removed: number;
+}
+type RawSnapshotMaterializeMode = "copy" | "link-or-copy";
+export declare function resolveCompiledRawPath(compiledPath: string, config?: {
+    [x: string]: unknown;
+    type: "compiled";
+    name: string;
+    workflow: string;
+    checks: {
+        question: string;
+        id?: string | undefined;
+        answer?: string | undefined;
+        expect?: {
+            must_include?: string[] | undefined;
+            must_include_one_of?: string[][] | undefined;
+            must_not_include?: string[] | undefined;
+            min_words?: number | undefined;
+            max_words?: number | undefined;
+        } | undefined;
+        strictness?: string | undefined;
+    }[];
+    source: {
+        path: string;
+        dataset_path: string;
+        control_path?: string | undefined;
+    };
+    about?: string | undefined;
+    max_attempts?: number | undefined;
+    max_loops?: number | undefined;
+    workflow_origin?: {
+        selected: string;
+        local_draft?: boolean | undefined;
+    } | undefined;
+} | null): string;
+export declare function syncCompiledRawSnapshot(compiledPath: string, sourcePath?: string): CompiledRawSyncResult;
+export declare function ensureCompiledRawBinding(compiledPath: string): InterfConfig | null;
+export declare function projectRawSnapshot(options: {
+    sourcePath: string;
+    destinationPath: string;
+    compiledPath: string;
+    mode?: RawSnapshotMaterializeMode;
+    prune?: boolean;
+    preserveTimestamps?: boolean;
+}): CompiledRawSyncResult;
+export {};

package/dist/packages/project-model/compiled-raw.js

@@ -0,0 +1,102 @@
+import { cpSync, existsSync, linkSync, mkdirSync, rmSync, statSync, } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { listFilesRecursive } from "../../lib/filesystem.js";
+import { discoverSourceFiles } from "../../lib/discovery.js";
+import { readInterfConfig, resolveSourceInputPath, } from "./interf-detect.js";
+import { saveCompiledInterfConfig } from "./source-config.js";
+import { defaultControlPathForCompiled, } from "./compiled-paths.js";
+import { assertPathWithinRoot } from "../../lib/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 assertPathWithinRoot(compiledPath, resolve(compiledPath, configuredPath), "Compiled raw path");
+}
+export function syncCompiledRawSnapshot(compiledPath, sourcePath = resolveSourceInputPath(compiledPath)) {
+    ensureCompiledRawBinding(compiledPath);
+    const rawPath = resolveCompiledRawPath(compiledPath);
+    return projectRawSnapshot({
+        sourcePath,
+        destinationPath: rawPath,
+        compiledPath,
+        mode: "copy",
+        prune: true,
+        preserveTimestamps: true,
+    });
+}
+export function ensureCompiledRawBinding(compiledPath) {
+    const config = readInterfConfig(compiledPath);
+    if (!config)
+        return null;
+    if (config.source?.path === "./raw")
+        return config;
+    const nextConfig = {
+        ...config,
+        source: {
+            ...(config.source ?? {}),
+            path: "./raw",
+            control_path: config.source?.control_path ?? defaultControlPathForCompiled(compiledPath),
+            ...(config.source?.dataset_path ? { dataset_path: config.source.dataset_path } : {}),
+        },
+    };
+    return saveCompiledInterfConfig(compiledPath, nextConfig);
+}
+function filesMatch(sourcePath, targetPath) {
+    if (!existsSync(targetPath))
+        return false;
+    try {
+        const sourceStat = statSync(sourcePath);
+        const targetStat = statSync(targetPath);
+        return sourceStat.size === targetStat.size && sourceStat.mtimeMs === targetStat.mtimeMs;
+    }
+    catch {
+        return false;
+    }
+}
+function materializeRawSnapshotFile(sourcePath, targetPath, options) {
+    mkdirSync(dirname(targetPath), { recursive: true });
+    rmSync(targetPath, { force: true });
+    if (options.mode === "link-or-copy") {
+        try {
+            linkSync(sourcePath, targetPath);
+            return;
+        }
+        catch {
+            // fall through to copy
+        }
+    }
+    cpSync(sourcePath, targetPath, { preserveTimestamps: options.preserveTimestamps });
+}
+export function projectRawSnapshot(options) {
+    const discovery = discoverSourceFiles(options.sourcePath, options.compiledPath);
+    const expectedFiles = new Set(discovery.sourceFiles);
+    mkdirSync(options.destinationPath, { recursive: true });
+    let removed = 0;
+    if (options.prune !== false) {
+        for (const existingPath of listFilesRecursive(options.destinationPath)) {
+            const relativePath = relative(options.destinationPath, existingPath);
+            if (expectedFiles.has(relativePath))
+                continue;
+            rmSync(existingPath, { force: true });
+            removed += 1;
+        }
+    }
+    let copied = 0;
+    for (const relativePath of discovery.sourceFiles) {
+        const sourceFilePath = join(options.sourcePath, relativePath);
+        const targetFilePath = join(options.destinationPath, relativePath);
+        if (filesMatch(sourceFilePath, targetFilePath)) {
+            continue;
+        }
+        materializeRawSnapshotFile(sourceFilePath, targetFilePath, {
+            mode: options.mode ?? "copy",
+            preserveTimestamps: options.preserveTimestamps ?? true,
+        });
+        copied += 1;
+    }
+    return {
+        sourceTotal: discovery.totalCount,
+        copied,
+        removed,
+    };
+}

package/dist/packages/project-model/compiled-reset.d.ts

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

package/dist/packages/project-model/compiled-reset.js

@@ -0,0 +1,72 @@
+import { existsSync, readdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { readCompiledSchemaFile, } from "../compiler/compiled-schema.js";
+import { initializeCompiledRuntimeState, } from "../compiler/state.js";
+import { stageExecutionShellsRoot, testRootForCompiled, testTargetsRootForCompiled, workflowImprovementLoopsRoot, compiledQueryAcceptanceRoot, compiledRuntimeRoot, compiledRuntimeLogsRoot, workflowPackagePathForCompiled, } 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",
+    "raw-snapshot.json",
+    "stage-contract.json",
+];
+const PRESERVED_COMPILED_ROOTS = new Set([
+    ".agents",
+    ".claude",
+    ".codex",
+    ".cursor",
+    ".gitignore",
+    ".interf",
+    ".interfignore",
+    "AGENTS.md",
+    "CLAUDE.md",
+]);
+export function clearCompiledRuntimeDerivedArtifacts(compiledPath) {
+    const runtimeRoot = compiledRuntimeRoot(compiledPath);
+    for (const entry of COMPILE_RUNTIME_RESET_ENTRIES) {
+        removeIfExists(join(runtimeRoot, entry));
+    }
+    removeIfExists(compiledQueryAcceptanceRoot(compiledPath));
+}
+function activeCompiledInputRoots(compiledPath) {
+    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
+    const roots = new Set();
+    for (const zone of schema?.zones ?? []) {
+        if (zone.role !== "input")
+            continue;
+        const root = zone.path.split("/")[0]?.trim();
+        if (root)
+            roots.add(root);
+    }
+    return roots;
+}
+function resetCompiledGeneratedOutputs(compiledPath) {
+    const preservedInputRoots = activeCompiledInputRoots(compiledPath);
+    for (const entry of readdirSync(compiledPath)) {
+        if (PRESERVED_COMPILED_ROOTS.has(entry))
+            continue;
+        if (preservedInputRoots.has(entry))
+            continue;
+        removeIfExists(join(compiledPath, entry));
+    }
+}
+export function resetCompiledGeneratedState(compiledPath, scope = "compile") {
+    resetCompiledGeneratedOutputs(compiledPath);
+    clearCompiledRuntimeDerivedArtifacts(compiledPath);
+    initializeCompiledRuntimeState(compiledPath);
+    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/packages/project-model/index.d.ts

@@ -0,0 +1,11 @@
+export * as schema from "./lib/schema.js";
+export * as sourceConfig from "./source-config.js";
+export * as interf from "./interf.js";
+export * as detect from "./interf-detect.js";
+export * as bootstrap from "./interf-bootstrap.js";
+export * as scaffold from "./interf-scaffold.js";
+export * as compiledPaths from "./compiled-paths.js";
+export * as projectPaths from "./project-paths.js";
+export * as compiledRaw from "./compiled-raw.js";
+export * as compiledReset from "./compiled-reset.js";
+export type { InterfConfig, SourceDatasetConfig, SourceFolderConfig, SourceTruthCheck, } from "./lib/schema.js";

package/dist/packages/project-model/index.js

@@ -0,0 +1,10 @@
+export * as schema from "./lib/schema.js";
+export * as sourceConfig from "./source-config.js";
+export * as interf from "./interf.js";
+export * as detect from "./interf-detect.js";
+export * as bootstrap from "./interf-bootstrap.js";
+export * as scaffold from "./interf-scaffold.js";
+export * as compiledPaths from "./compiled-paths.js";
+export * as projectPaths from "./project-paths.js";
+export * as compiledRaw from "./compiled-raw.js";
+export * as compiledReset from "./compiled-reset.js";

package/dist/packages/project-model/interf-bootstrap.d.ts

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

package/dist/packages/project-model/interf-bootstrap.js

@@ -0,0 +1,18 @@
+import { basename } from "node:path";
+import { readInterfConfig } from "./interf-detect.js";
+import { projectCompiledQueryShell, renderClaudeBootstrap } from "../agents/lib/shells.js";
+export { renderClaudeBootstrap };
+export function refreshCompiledBootstrapGuidance(dirPath) {
+    const config = readInterfConfig(dirPath);
+    if (!config)
+        return false;
+    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 projectCompiledQueryShell(dirPath, compiledName, workflowId, about, {
+        workflowOriginSelected,
+        workflowLocalDraft,
+    });
+}

package/dist/packages/project-model/interf-detect.d.ts

@@ -0,0 +1,33 @@
+import { type InterfConfig } from "./lib/schema.js";
+export type { InterfConfig } from "./lib/schema.js";
+export interface ResolvedCompiled {
+    sourcePath: string;
+    compiledPath: string;
+    config: InterfConfig;
+}
+export declare const INTERF_CONTAINER_NAME = "interf";
+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 readInterfConfig(dirPath: string): InterfConfig | null;
+export declare function hasSourceFolderInput(config: InterfConfig | null | undefined): config is InterfConfig & {
+    source: {
+        path: string;
+    };
+};
+export declare function detectInterf(cwd: string): {
+    path: string;
+    config: InterfConfig;
+} | null;
+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 assertCompiledContainer(sourcePath: string): string;
+export declare function assertWritableTargetDir(dirPath: string, label: string): void;
+export declare function assertCompiledName(name: string, label: string): void;

package/dist/packages/project-model/interf-detect.js

@@ -0,0 +1,176 @@
+import { existsSync, readdirSync, statSync, } from "node:fs";
+import { join, resolve } from "node:path";
+import { warnInterf } from "../../lib/logger.js";
+import { readJsonFileUnchecked } from "../../lib/parse.js";
+import { compiledCompiledPathForDataset, projectInterfRoot, } from "./project-paths.js";
+import { resolveSourceControlPathForCompiled, compiledInterfConfigPath, } from "./compiled-paths.js";
+import { InterfConfigSchema, } from "./lib/schema.js";
+import { assertPathWithinRoot } from "../../lib/util.js";
+export const INTERF_CONTAINER_NAME = "interf";
+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 readInterfConfig(dirPath) {
+    const configPath = compiledInterfConfigPath(dirPath);
+    if (!existsSync(configPath))
+        return null;
+    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) {
+    const config = readInterfConfig(cwd);
+    if (config)
+        return { path: cwd, config };
+    return null;
+}
+export function resolveCompiled(cwd) {
+    const detected = detectInterf(cwd);
+    if (!detected)
+        return null;
+    return {
+        sourcePath: resolveSourceControlPath(detected.path),
+        compiledPath: detected.path,
+        config: detected.config,
+    };
+}
+export function resolveSourceFolderPath(compiledPath, config = null) {
+    const resolvedConfig = config ?? readInterfConfig(compiledPath);
+    if (hasSourceFolderInput(resolvedConfig)) {
+        return assertPathWithinRoot(compiledPath, resolve(compiledPath, resolvedConfig.source.path), "Compiled raw source path");
+    }
+    return resolve(compiledPath, "raw");
+}
+export function resolveSourceControlPath(compiledPath) {
+    return resolveSourceControlPathForCompiled(compiledPath);
+}
+export function resolveSourceInputPath(compiledPath) {
+    const config = readInterfConfig(compiledPath);
+    if (typeof config?.source?.dataset_path === "string" && config.source.dataset_path.length > 0) {
+        const projectPath = resolveSourceControlPathForCompiled(compiledPath);
+        return assertPathWithinRoot(projectPath, resolve(compiledPath, config.source.dataset_path), "Dataset source path");
+    }
+    throw new Error(`Context folder is missing source.dataset_path in ${compiledInterfConfigPath(compiledPath)}.`);
+}
+export function listCompiledDatasetsForSourceFolder(sourcePath) {
+    const interfRoot = projectInterfRoot(sourcePath);
+    if (!existsSync(interfRoot))
+        return [];
+    try {
+        if (!statSync(interfRoot).isDirectory())
+            return [];
+    }
+    catch (error) {
+        warnInterf(`Warning: failed to inspect Interf container at ${interfRoot}: ${error instanceof Error ? error.message : String(error)}`);
+        return [];
+    }
+    return readdirSync(interfRoot)
+        .filter((entry) => !entry.startsWith(".") &&
+        entry !== WORKFLOW_CONTAINER_NAME &&
+        entry !== TEST_CONTAINER_NAME)
+        .map((entry) => compiledCompiledPathForDataset(sourcePath, entry))
+        .filter((compiledPath) => existsSync(compiledPath))
+        .map((compiledPath) => {
+        const config = readInterfConfig(compiledPath);
+        return config ? { path: compiledPath, config } : null;
+    })
+        .filter((value) => value !== null);
+}
+export function assertCompiledContainer(sourcePath) {
+    const interfRoot = projectInterfRoot(sourcePath);
+    if (existsSync(interfRoot)) {
+        const stat = statSync(interfRoot);
+        if (!stat.isDirectory()) {
+            throw new Error(`Interf container exists and is not a directory: ${interfRoot}`);
+        }
+        const unexpectedRootEntries = readdirSync(interfRoot).filter((entry) => {
+            if (entry.startsWith("."))
+                return false;
+            const entryPath = join(interfRoot, entry);
+            if (entry === WORKFLOW_CONTAINER_NAME || entry === TEST_CONTAINER_NAME) {
+                try {
+                    return !statSync(entryPath).isDirectory();
+                }
+                catch (error) {
+                    warnInterf(`Warning: failed to inspect Interf control-plane path at ${entryPath}: ${error instanceof Error ? error.message : String(error)}`);
+                    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 = interfRoot;
+    if (!existsSync(containerPath)) {
+        return containerPath;
+    }
+    const stat = statSync(containerPath);
+    if (!stat.isDirectory()) {
+        throw new Error(`Interf container exists and is not a directory: ${containerPath}`);
+    }
+    const unexpectedEntries = readdirSync(containerPath).filter((entry) => {
+        if (entry.startsWith("."))
+            return false;
+        if (entry === WORKFLOW_CONTAINER_NAME || entry === TEST_CONTAINER_NAME)
+            return false;
+        const entryPath = join(containerPath, entry);
+        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;
+        }
+        const compiledPath = compiledCompiledPathForDataset(sourcePath, entry);
+        if (!existsSync(compiledPath)) {
+            return false;
+        }
+        return !readInterfConfig(compiledPath);
+    });
+    if (unexpectedEntries.length > 0) {
+        throw new Error(`Interf container contains invalid dataset entries: ${containerPath}`);
+    }
+    return containerPath;
+}
+export function assertWritableTargetDir(dirPath, label) {
+    if (!existsSync(dirPath))
+        return;
+    const stat = statSync(dirPath);
+    if (!stat.isDirectory()) {
+        throw new Error(`${label} target exists and is not a directory: ${dirPath}`);
+    }
+    if (readdirSync(dirPath).length > 0) {
+        throw new Error(`${label} target already exists and is not empty: ${dirPath}`);
+    }
+}
+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/packages/project-model/interf-scaffold.d.ts

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