@interf/compiler 0.6.1 → 0.6.4

package/dist/lib/execution-profile.js

@@ -1,84 +1 @@
-const INTERNAL_ACCEPTANCE_DEFAULTS = {
-    "claude-code": {
-        model: "claude-sonnet-4-6",
-        effort: "low",
-    },
-    codex: {
-        model: "gpt-5.4-mini",
-        effort: "low",
-    },
-};
-function readAgentName(agent) {
-    if (!agent)
-        return null;
-    return typeof agent === "string" ? agent : agent.name;
-}
-function normalizeOptionalString(value) {
-    if (typeof value !== "string")
-        return null;
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : null;
-}
-function normalizeOptionalTimeout(value) {
-    if (value === undefined || value === null || value === "")
-        return null;
-    const parsed = typeof value === "number" ? value : Number.parseInt(String(value), 10);
-    if (!Number.isFinite(parsed) || parsed <= 0) {
-        throw new Error(`Invalid timeout: ${String(value)}`);
-    }
-    return parsed;
-}
-export function addExecutionProfileOptions(yargs) {
-    return yargs
-        .option("model", {
-        type: "string",
-        describe: "Override the local executor model for this run",
-    })
-        .option("profile", {
-        type: "string",
-        describe: "Executor-specific profile override for this run",
-    })
-        .option("effort", {
-        type: "string",
-        describe: "Override the model reasoning effort for this run",
-    })
-        .option("timeout-ms", {
-        type: "number",
-        describe: "Interrupt the local executor after this much inactivity",
-    });
-}
-export function executionProfileFromArgv(argv) {
-    return {
-        model: normalizeOptionalString(argv.model),
-        profile: normalizeOptionalString(argv.profile),
-        effort: normalizeOptionalString(argv.effort),
-        timeoutMs: normalizeOptionalTimeout(argv.timeoutMs ?? argv["timeout-ms"]),
-    };
-}
-export function applyInternalAcceptanceExecutionProfileDefaults(agent, overrides = {}) {
-    const defaults = INTERNAL_ACCEPTANCE_DEFAULTS[readAgentName(agent) ?? ""];
-    const profile = overrides.profile ?? null;
-    const explicitEffort = overrides.effort ?? null;
-    return {
-        model: overrides.model ?? defaults?.model ?? null,
-        profile,
-        effort: explicitEffort ?? (profile ? null : defaults?.effort ?? null),
-        timeoutMs: overrides.timeoutMs ?? null,
-    };
-}
-export function hasWorkflowExecutionProfile(profile) {
-    return Boolean(profile?.model ||
-        profile?.profile ||
-        profile?.effort ||
-        profile?.timeoutMs);
-}
-export function formatWorkflowExecutionProfile(profile) {
-    if (!hasWorkflowExecutionProfile(profile))
-        return null;
-    return JSON.stringify({
-        ...(profile?.model ? { model: profile.model } : {}),
-        ...(profile?.profile ? { profile: profile.profile } : {}),
-        ...(profile?.effort ? { effort: profile.effort } : {}),
-        ...(profile?.timeoutMs ? { timeout_ms: profile.timeoutMs } : {}),
-    });
-}
+export * from "../packages/agents/lib/execution-profile.js";

package/dist/lib/executors.d.ts

@@ -1,32 +1 @@
-import type { Agent } from "./agents.js";
-import type { RuntimeExecutorInfo } from "./schema.js";
-export type WorkflowExecutorKind = "local-agent" | "connected-provider" | "managed";
-export interface WorkflowExecutionProfile {
-    model?: string | null;
-    effort?: string | null;
-    profile?: string | null;
-    timeoutMs?: number | null;
-}
-export interface WorkflowExecuteOptions {
-    eventLogPath?: string | null;
-    statusLogPath?: string | null;
-    completionCheck?: (() => boolean) | null;
-}
-export interface WorkflowExecutor {
-    kind: WorkflowExecutorKind;
-    name: string;
-    displayName: string;
-    command?: string | null;
-    executionProfile?: WorkflowExecutionProfile;
-    execute(rootPath: string, prompt: string, options?: WorkflowExecuteOptions): Promise<number>;
-}
-export type { RuntimeExecutorInfo } from "./schema.js";
-export declare function buildRuntimeExecutorInfo(executor: WorkflowExecutor): RuntimeExecutorInfo;
-export declare function createLocalAgentExecutor(agent: Agent, executionProfile?: WorkflowExecutionProfile): WorkflowExecutor;
-export declare function resolveLocalExecutor(options?: {
-    preflight?: boolean;
-    executionProfile?: WorkflowExecutionProfile;
-}): {
-    executor: WorkflowExecutor | null;
-    error?: string;
-};
+export * from "../packages/agents/lib/executors.js";

package/dist/lib/executors.js

@@ -1,43 +1 @@
-import { ensureAgentAutomatedRunReady, resolveAgent, spawnAgent } from "./agents.js";
-export function buildRuntimeExecutorInfo(executor) {
-    return {
-        kind: executor.kind,
-        name: executor.name,
-        display_name: executor.displayName,
-        command: executor.command ?? null,
-        model: executor.executionProfile?.model ?? null,
-        effort: executor.executionProfile?.effort ?? null,
-        profile: executor.executionProfile?.profile ?? null,
-        timeout_ms: executor.executionProfile?.timeoutMs ?? null,
-    };
-}
-export function createLocalAgentExecutor(agent, executionProfile = {}) {
-    return {
-        kind: "local-agent",
-        name: agent.name,
-        displayName: agent.displayName,
-        command: agent.command,
-        executionProfile,
-        execute(rootPath, prompt, options) {
-            return spawnAgent(agent, rootPath, prompt, {
-                eventLogPath: options?.eventLogPath,
-                statusLogPath: options?.statusLogPath,
-                executionProfile,
-                completionCheck: options?.completionCheck,
-            });
-        },
-    };
-}
-export function resolveLocalExecutor(options = {}) {
-    const { agent, error } = resolveAgent();
-    if (!agent) {
-        return { executor: null, error };
-    }
-    if (options.preflight !== false) {
-        const readiness = ensureAgentAutomatedRunReady(agent);
-        if (!readiness.ok) {
-            return { executor: null, error: readiness.error };
-        }
-    }
-    return { executor: createLocalAgentExecutor(agent, options.executionProfile) };
-}
+export * from "../packages/agents/lib/executors.js";

package/dist/lib/filesystem.d.ts

@@ -1,2 +1 @@
-export declare function countFilesRecursive(dirPath: string): number;
-export declare function listFilesRecursive(dirPath: string, predicate?: (filePath: string) => boolean): string[];
+export * from "../packages/shared/filesystem.js";

package/dist/lib/filesystem.js

@@ -1,55 +1 @@
-import { existsSync, readdirSync, realpathSync, statSync } from "node:fs";
-import { join } from "node:path";
-export function countFilesRecursive(dirPath) {
-    if (!existsSync(dirPath))
-        return 0;
-    let total = 0;
-    walkFilesRecursive(dirPath, () => {
-        total += 1;
-    });
-    return total;
-}
-export function listFilesRecursive(dirPath, predicate) {
-    const files = [];
-    if (!existsSync(dirPath))
-        return files;
-    walkFilesRecursive(dirPath, (filePath) => {
-        if (!predicate || predicate(filePath)) {
-            files.push(filePath);
-        }
-    });
-    return files;
-}
-function walkFilesRecursive(dirPath, onFile, visitedDirs = new Set()) {
-    if (!existsSync(dirPath))
-        return;
-    walkFilesRecursiveInternal(dirPath, onFile, visitedDirs);
-}
-function walkFilesRecursiveInternal(dirPath, onFile, visitedDirs) {
-    let resolvedDir;
-    try {
-        resolvedDir = realpathSync(dirPath);
-    }
-    catch {
-        return;
-    }
-    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 {
-            continue;
-        }
-        if (stat.isDirectory()) {
-            walkFilesRecursiveInternal(fullPath, onFile, visitedDirs);
-        }
-        else if (stat.isFile()) {
-            onFile(fullPath);
-        }
-    }
-}
+export * from "../packages/shared/filesystem.js";

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

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

package/dist/lib/interf-bootstrap.js

@@ -1,18 +1,3 @@
-import { basename } from "node:path";
-import { readInterfConfig } from "./interf-detect.js";
-import { projectCompiledQueryShell, renderClaudeBootstrap } from "./agent-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,
-    });
-}
+// Compatibility shim for historical `src/lib/interf-bootstrap.ts` imports.
+// Source of truth: `src/packages/project-model/interf-bootstrap.ts`.
+export * from "../packages/project-model/interf-bootstrap.js";

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

@@ -1,33 +1 @@
-import { type InterfConfig } from "./schema.js";
-export type { InterfConfig } from "./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;
+export * from "../packages/project-model/interf-detect.js";

package/dist/lib/interf-detect.js

@@ -1,176 +1,3 @@
-import { existsSync, readdirSync, statSync, } from "node:fs";
-import { join, resolve } from "node:path";
-import { warnInterf } from "./logger.js";
-import { readJsonFileUnchecked } from "./parse.js";
-import { compiledCompiledPathForDataset, projectInterfRoot, } from "./project-paths.js";
-import { resolveSourceControlPathForCompiled, compiledInterfConfigPath, } from "./compiled-paths.js";
-import { InterfConfigSchema, } from "./schema.js";
-import { assertPathWithinRoot } from "./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(`Compiled dataset 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}`);
-    }
-}
+// Compatibility shim for historical `src/lib/interf-detect.ts` imports.
+// Source of truth: `src/packages/project-model/interf-detect.ts`.
+export * from "../packages/project-model/interf-detect.js";

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

@@ -1,2 +1 @@
-export declare function createCompiled(name: string, sourcePath: string, workflowId?: string, about?: string, datasetPath?: string): string;
-export declare function defaultCompiledNameForSource(sourcePath: string): string;
+export * from "../packages/project-model/interf-scaffold.js";

package/dist/lib/interf-scaffold.js

@@ -1,114 +1,3 @@
-import { mkdirSync, existsSync, writeFileSync, } from "node:fs";
-import { basename, join, relative, sep } from "node:path";
-import { getCompiledWorkflow } from "./workflow-definitions.js";
-import { initializeCompiledRuntimeState, } from "./state.js";
-import { assertCompiledContainer, assertWritableTargetDir, assertCompiledName, } from "./interf-detect.js";
-import { refreshCompiledBootstrapGuidance } from "./interf-bootstrap.js";
-import { seedCompiledWorkflowPackage } from "./interf-workflow-package.js";
-import { compiledCompiledPathForDataset } from "./project-paths.js";
-import { syncCompiledRawSnapshot } from "./compiled-raw.js";
-import { ensureCompiledZoneTargets, readCompiledSchemaFile } from "./compiled-schema.js";
-import { findSourceDatasetConfig, loadSourceFolderConfig, resolveSourceDatasetPath, saveCompiledInterfConfig, } from "./source-config.js";
-import { defaultControlPathForCompiled, workflowPackagePathForCompiled } from "./compiled-paths.js";
-const DEFAULT_INTERFIGNORE = [
-    ".claude/",
-    ".codex/",
-    ".agents/",
-    ".cursor/",
-    ".interf/tests/",
-    ".interf/tests/targets/sandboxes/",
-    ".interf/runtime/",
-    "",
-].join("\n");
-const UNCOMPILED_COMPILED_PLACEHOLDER = "Not yet compiled. Run `interf compile` to build the compiled dataset.";
-function renderUncompiledCompiledFile(compiledName, relativePath, about) {
-    return [
-        `# ${compiledName} — ${relativePath}`,
-        "",
-        UNCOMPILED_COMPILED_PLACEHOLDER,
-        ...(about ? ["", `About: ${about}`] : []),
-        "",
-    ].join("\n");
-}
-function compiledGitignoreEntries(compiledPath) {
-    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
-    const zoneEntries = (schema?.zones ?? [])
-        .filter((zone) => zone.kind !== "runtime")
-        .map((zone) => zone.kind === "file" ? zone.path : `${zone.path}/`);
-    return [
-        ...zoneEntries,
-        ".claude/",
-        ".codex/",
-        ".agents/",
-        ".cursor/",
-        ".interf/tests/",
-        ".interf/tests/targets/sandboxes/",
-        ".interf/runtime/",
-    ];
-}
-function scaffoldCompiledOutputs(compiledPath, compiledName, about) {
-    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
-    if (!schema) {
-        throw new Error(`Missing workflow schema at ${workflowPackagePathForCompiled(compiledPath)}.`);
-    }
-    ensureCompiledZoneTargets(compiledPath, schema);
-    for (const zone of schema.zones) {
-        if (!zone.required || zone.kind !== "file" || zone.role !== "output")
-            continue;
-        const targetPath = join(compiledPath, zone.path);
-        if (existsSync(targetPath))
-            continue;
-        writeFileSync(targetPath, renderUncompiledCompiledFile(compiledName, zone.path, about));
-    }
-}
-export function createCompiled(name, sourcePath, workflowId = "interf", about, datasetPath = sourcePath) {
-    assertCompiledName(name, "Compiled");
-    assertCompiledContainer(sourcePath);
-    const compiledPath = compiledCompiledPathForDataset(sourcePath, name);
-    assertWritableTargetDir(compiledPath, "Compiled");
-    mkdirSync(compiledPath, { recursive: true });
-    const savedCompiled = findSourceDatasetConfig(loadSourceFolderConfig(sourcePath), name);
-    const selectedWorkflow = getCompiledWorkflow(workflowId, { sourcePath });
-    const resolvedAbout = about ?? savedCompiled?.about;
-    const resolvedDatasetPath = savedCompiled
-        ? resolveSourceDatasetPath(sourcePath, savedCompiled)
-        : datasetPath;
-    saveCompiledInterfConfig(compiledPath, {
-        type: "compiled",
-        name,
-        ...(resolvedAbout ? { about: resolvedAbout } : {}),
-        workflow: selectedWorkflow.id,
-        ...(typeof savedCompiled?.max_attempts === "number"
-            ? { max_attempts: savedCompiled.max_attempts }
-            : {}),
-        ...(typeof savedCompiled?.max_loops === "number"
-            ? { max_loops: savedCompiled.max_loops }
-            : {}),
-        checks: savedCompiled?.checks ?? [],
-        workflow_origin: {
-            selected: selectedWorkflow.id,
-            local_draft: false,
-        },
-        source: {
-            path: "./raw",
-            control_path: defaultControlPathForCompiled(compiledPath),
-            dataset_path: relative(compiledPath, resolvedDatasetPath).split(sep).join("/") || ".",
-        },
-    });
-    mkdirSync(join(compiledPath, "raw"), { recursive: true });
-    syncCompiledRawSnapshot(compiledPath, resolvedDatasetPath);
-    writeFileSync(join(compiledPath, ".interfignore"), DEFAULT_INTERFIGNORE);
-    seedCompiledWorkflowPackage({
-        compiledPath,
-        sourcePath,
-        workflowId: selectedWorkflow.id,
-    });
-    scaffoldCompiledOutputs(compiledPath, name, about);
-    refreshCompiledBootstrapGuidance(compiledPath);
-    writeFileSync(join(compiledPath, ".gitignore"), [...compiledGitignoreEntries(compiledPath), ""].join("\n"));
-    initializeCompiledRuntimeState(compiledPath);
-    return compiledPath;
-}
-export function defaultCompiledNameForSource(sourcePath) {
-    return basename(sourcePath);
-}
+// Compatibility shim for historical `src/lib/interf-scaffold.ts` imports.
+// Source of truth: `src/packages/project-model/interf-scaffold.ts`.
+export * from "../packages/project-model/interf-scaffold.js";

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

@@ -1,25 +1 @@
-import { type WorkflowDefinition } from "./workflow-definitions.js";
-export declare function writeCompiledWorkflowPackage(compiledPath: string, workflow: WorkflowDefinition<string>): void;
-export declare function writeWorkflowPackageToDir(workflowDir: string, workflow: WorkflowDefinition<string>, options?: {
-    overwrite?: boolean;
-}): void;
-export declare function seedCompiledWorkflowPackage(options: {
-    compiledPath: string;
-    sourcePath: string;
-    workflowId: string;
-}): void;
-export declare function createLocalWorkflowPackageFromTemplate(options: {
-    sourcePath: string;
-    baseWorkflowId: string;
-    workflowId: string;
-    label: string;
-    hint: string;
-    stagePolicyNotes: Record<string, string[]>;
-}): string;
-export declare function seedLocalWorkflowPackageFromBase(options: {
-    sourcePath: string;
-    baseWorkflowId: string;
-    workflowId: string;
-    label: string;
-    hint: string;
-}): string;
+export * from "../packages/workflow-package/interf-workflow-package.js";