@interf/compiler 0.6.1 → 0.6.4

package/dist/lib/validate.js

@@ -1,249 +1 @@
-import { existsSync, readFileSync, statSync, } from "node:fs";
-import { basename, extname, join } from "node:path";
-import { readCompiledSchemaFile } from "./compiled-schema.js";
-import { compiledKnowledgeRootPath } from "./compiled-schema.js";
-import { workflowPackagePathForCompiled } from "./compiled-paths.js";
-import { listFilesRecursive } from "./filesystem.js";
-import { readInterfConfig } from "./interf.js";
-import { parseJsonFrontmatter } from "./parse.js";
-import { compiledInterfConfigPath } from "./compiled-paths.js";
-const MIN_ABSTRACT_WORDS = 5;
-const WIKILINK_PATTERN = /!?\[\[([^[\]]+)\]\]/g;
-export function readCompiledConfig(dirPath) {
-    const configPath = compiledInterfConfigPath(dirPath);
-    const value = readInterfConfig(dirPath);
-    const present = existsSync(configPath);
-    if (!present) {
-        return {
-            present: false,
-            valid: false,
-            value: null,
-            typeMatch: () => false,
-        };
-    }
-    return {
-        present: true,
-        valid: value !== null,
-        value,
-        typeMatch() {
-            return value?.type === "compiled" && typeof value?.source?.path === "string";
-        },
-    };
-}
-export function validateSynthFiles(files, options) {
-    let invalidFrontmatter = 0;
-    let shortAbstracts = 0;
-    for (const filePath of files) {
-        const content = safeReadText(filePath);
-        if (content === null)
-            continue;
-        const parsed = parseJsonFrontmatter(content);
-        if (!parsed || !hasRequiredFrontmatterKeys(parsed.frontmatter, options?.requiredFrontmatterKeys)) {
-            invalidFrontmatter += 1;
-            continue;
-        }
-        const abstractWords = countSynthAbstractWords(parsed.frontmatter, parsed.body);
-        if (abstractWords < MIN_ABSTRACT_WORDS) {
-            shortAbstracts += 1;
-        }
-    }
-    return {
-        invalid_frontmatter: invalidFrontmatter,
-        short_abstracts: shortAbstracts,
-    };
-}
-export function countBrokenWikilinks(compiledRoot, noteIndexRoots, linkScanRoots) {
-    const zonePathById = compiledZoneDirectoryPaths(compiledRoot);
-    const knowledgeRelativePrefixes = compiledKnowledgeRelativePrefixes(zonePathById);
-    const noteIndex = new Set();
-    for (const filePath of dedupeFiles(noteIndexRoots)) {
-        for (const target of collectWikilinkTargets(filePath)) {
-            noteIndex.add(target.toLowerCase());
-        }
-    }
-    let brokenLinks = 0;
-    for (const filePath of dedupeFiles(linkScanRoots)) {
-        const content = safeReadText(filePath);
-        if (content === null)
-            continue;
-        const matches = content.matchAll(WIKILINK_PATTERN);
-        for (const match of matches) {
-            const rawTarget = match[1]?.trim();
-            if (!rawTarget)
-                continue;
-            const target = rawTarget.split("|")[0]?.split("#")[0]?.trim();
-            if (!target)
-                continue;
-            if (target.includes("/")) {
-                if (!wikilinkPathExists(compiledRoot, target, zonePathById, knowledgeRelativePrefixes)) {
-                    brokenLinks += 1;
-                }
-                continue;
-            }
-            if (!noteIndex.has(target.toLowerCase()) &&
-                !noteIndex.has(noteName(target).toLowerCase()) &&
-                !wikilinkPathExists(compiledRoot, target, zonePathById, knowledgeRelativePrefixes) &&
-                !wikilinkPathExists(compiledRoot, noteName(target), zonePathById, knowledgeRelativePrefixes)) {
-                brokenLinks += 1;
-            }
-        }
-    }
-    return brokenLinks;
-}
-export function asNumber(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : 0;
-}
-export function isOutputMarkdownFile(filePath) {
-    return extname(filePath) === ".md" && basename(filePath) !== "AGENTS.md";
-}
-export function safeReadText(filePath) {
-    try {
-        return readFileSync(filePath, "utf-8");
-    }
-    catch {
-        return null;
-    }
-}
-function dedupeFiles(dirPaths) {
-    const seen = new Set();
-    const files = [];
-    for (const dirPath of dirPaths) {
-        if (existsSync(dirPath)) {
-            try {
-                const stat = statSync(dirPath);
-                if (stat.isFile()) {
-                    if (!seen.has(dirPath) && isOutputMarkdownFile(dirPath)) {
-                        seen.add(dirPath);
-                        files.push(dirPath);
-                    }
-                    continue;
-                }
-            }
-            catch {
-                continue;
-            }
-        }
-        for (const filePath of listFilesRecursive(dirPath, isOutputMarkdownFile)) {
-            if (seen.has(filePath))
-                continue;
-            seen.add(filePath);
-            files.push(filePath);
-        }
-    }
-    return files;
-}
-function hasRequiredFrontmatterKeys(frontmatter, requiredKeys) {
-    return (requiredKeys ?? []).every((field) => field in frontmatter);
-}
-function extractBodyAbstract(body) {
-    const lines = body.split(/\r?\n/);
-    const abstractHeadingIndex = lines.findIndex((line) => /^#{1,2}\s+Abstract\s*$/.test(line.trim()));
-    if (abstractHeadingIndex < 0)
-        return null;
-    const abstractLines = [];
-    for (let index = abstractHeadingIndex + 1; index < lines.length; index += 1) {
-        const line = lines[index] ?? "";
-        if (/^#{1,2}\s+\S/.test(line.trim()))
-            break;
-        abstractLines.push(line);
-    }
-    const abstractText = abstractLines.join("\n").trim();
-    return abstractText.length > 0 ? abstractText : null;
-}
-export function extractSynthAbstract(frontmatter, body) {
-    const frontmatterAbstract = typeof frontmatter.abstract === "string" ? frontmatter.abstract.trim() : "";
-    if (frontmatterAbstract.length > 0) {
-        return frontmatterAbstract;
-    }
-    return extractBodyAbstract(body);
-}
-export function countSynthAbstractWords(frontmatter, body) {
-    const abstract = extractSynthAbstract(frontmatter, body);
-    if (!abstract)
-        return 0;
-    return countWords(abstract);
-}
-function countWords(text) {
-    return text
-        .split(/\s+/)
-        .map((word) => word.trim())
-        .filter((word) => /[A-Za-z0-9]/.test(word)).length;
-}
-function noteName(filePath) {
-    return basename(filePath, extname(filePath));
-}
-function wikilinkPathExists(compiledRoot, target, zonePathById, knowledgeRelativePrefixes) {
-    return linkPathCandidates(compiledRoot, target, zonePathById, knowledgeRelativePrefixes)
-        .some((candidate) => existsSync(candidate));
-}
-function linkPathCandidates(compiledRoot, target, zonePathById, knowledgeRelativePrefixes) {
-    const candidates = new Set();
-    addPathCandidate(candidates, join(compiledRoot, target));
-    const [firstSegment] = target.split("/");
-    if (firstSegment && knowledgeRelativePrefixes.has(firstSegment)) {
-        addPathCandidate(candidates, join(compiledKnowledgeRootPath(compiledRoot), target));
-    }
-    if (firstSegment) {
-        const normalizedPrefix = zonePathById.get(firstSegment);
-        if (normalizedPrefix) {
-            const remainder = target.slice(firstSegment.length).replace(/^\/+/, "");
-            addPathCandidate(candidates, join(compiledRoot, normalizedPrefix, remainder));
-        }
-    }
-    return Array.from(candidates);
-}
-function addPathCandidate(candidates, absolutePath) {
-    candidates.add(absolutePath);
-    if (!absolutePath.endsWith(".md")) {
-        candidates.add(`${absolutePath}.md`);
-    }
-}
-function compiledZoneDirectoryPaths(compiledRoot) {
-    const workflowRoot = workflowPackagePathForCompiled(compiledRoot);
-    const schema = readCompiledSchemaFile(workflowRoot);
-    if (!schema)
-        return new Map();
-    return new Map(schema.zones
-        .filter((zone) => zone.kind === "directory")
-        .map((zone) => [zone.id, zone.path]));
-}
-function compiledKnowledgeRelativePrefixes(zonePathById) {
-    const prefixes = new Set();
-    for (const zonePath of zonePathById.values()) {
-        const [root, leaf, ...rest] = zonePath.split("/");
-        if (root !== "knowledge" || !leaf || rest.length > 0)
-            continue;
-        prefixes.add(leaf);
-    }
-    return prefixes;
-}
-function collectWikilinkTargets(filePath) {
-    const targets = new Set();
-    targets.add(noteName(filePath));
-    const content = safeReadText(filePath);
-    if (content === null)
-        return Array.from(targets);
-    const parsed = parseJsonFrontmatter(content);
-    const frontmatter = parsed?.frontmatter;
-    if (!frontmatter)
-        return Array.from(targets);
-    addFrontmatterLinkTarget(targets, frontmatter.label);
-    addFrontmatterLinkTarget(targets, frontmatter.title);
-    addFrontmatterLinkTarget(targets, frontmatter.alias);
-    addFrontmatterLinkTarget(targets, frontmatter.aliases);
-    return Array.from(targets);
-}
-function addFrontmatterLinkTarget(targets, value) {
-    if (typeof value === "string") {
-        const trimmed = value.trim();
-        if (trimmed.length > 0)
-            targets.add(trimmed);
-        return;
-    }
-    if (Array.isArray(value)) {
-        for (const entry of value) {
-            addFrontmatterLinkTarget(targets, entry);
-        }
-    }
-}
-export { validateCompiled, validateCompiledStage, validateCompiledWorkflow, validateCompiledSummarize, validateCompiledStructure, validateCompiledCompile, } from "./validate-compiled.js";
+export * from "../packages/compiler/validate.js";

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

@@ -1,26 +1 @@
-import type { WorkflowExecutor } from "./executors.js";
-import { validateWorkflowPackage } from "./local-workflows.js";
-import type { SourceTruthCheck } from "./schema.js";
-import { type WorkflowReporter } from "./workflows.js";
-export interface WorkflowAuthoringRunResult {
-    status: "updated" | "no-change" | "invalid" | "executor-failed";
-    changed: boolean;
-    summary: string;
-    validation: ReturnType<typeof validateWorkflowPackage> | null;
-    workflowPath: string;
-    shellPath: string;
-}
-export declare function runWorkflowAuthoringDraft(options: {
-    sourcePath: string;
-    datasetPath: string;
-    baseWorkflowId: string;
-    workflowId: string;
-    label: string;
-    hint: string;
-    taskPrompt: string;
-    checks?: SourceTruthCheck[];
-    executor: WorkflowExecutor;
-    preparePreview?: boolean;
-    previewReporter?: WorkflowReporter | null;
-}): Promise<WorkflowAuthoringRunResult>;
-export declare function resolveWorkflowDraftPath(sourcePath: string, workflowId: string): string;
+export * from "../packages/workflow-authoring/workflow-authoring.js";

package/dist/lib/workflow-authoring.js

@@ -1,119 +1 @@
-import { mkdtempSync, rmSync, } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { createWorkflowAuthoringShell } from "./agent-shells.js";
-import { WORKFLOW_SCHEMA_FILE } from "./compiled-schema.js";
-import { projectRawSnapshot } from "./compiled-raw.js";
-import { seedLocalWorkflowPackageFromBase } from "./interf-workflow-package.js";
-import { validateWorkflowPackage, workflowDefinitionPath } from "./local-workflows.js";
-import { runWorkflowEditSession } from "./workflow-edit-session.js";
-import { copyDirectory } from "./workflow-edit-utils.js";
-import { createCompiled, compileCompiled } from "./workflows.js";
-function buildWorkflowAuthoringPrompt() {
-    return [
-        "This is an automated Interf workflow-authoring run, not an open-ended chat session.",
-        "Execute it now.",
-        "Read `runtime/authoring-context.json` first.",
-        `Then read \`workflow/README.md\`, \`workflow/workflow.json\`, and \`workflow/${WORKFLOW_SCHEMA_FILE}\`.`,
-        "Review `artifacts/source-dataset/raw/` and any `artifacts/preview-compiled/` notes before editing the package.",
-        "Prefer direct file-reading and search tools over shell commands for routine file inspection.",
-        "Do not use shell helpers like `cat`, `sed`, `ls`, or `find` when a native read/search tool can inspect the same files.",
-        "Edit only files under `workflow/`.",
-        "Keep the workflow valid for the current compiler API and workflow schema.",
-        "Make the package materially more specific to this dataset task than the seeded base workflow. A no-op copy is not acceptable.",
-        "Prefer explicit stage-doc, stage-policy, purpose, and zone-contract edits over vague rewrites.",
-        "Do not introduce wikilinks unless the workflow also creates the target note by exact basename or explicit relative path.",
-        "Respect stage boundaries: a stage may only introduce links that resolve within that stage's declared writes or already-existing read zones.",
-        "Do not make one stage point at files or notes that are only created later by another stage.",
-        "Prefer conservative retrieval routing over speculative note sprawl.",
-        "Do not narrate plans or ask follow-up questions.",
-        "Only emit user-visible updates that begin with STATUS:, DONE:, BLOCKED:, or ERROR:.",
-        "As soon as the workflow edits are complete, stop.",
-    ].join("\n");
-}
-async function prepareWorkflowAuthoringPreview(options) {
-    const tempRoot = mkdtempSync(join(tmpdir(), "interf-workflow-preview-"));
-    projectRawSnapshot({
-        sourcePath: options.datasetPath,
-        destinationPath: tempRoot,
-        compiledPath: tempRoot,
-        mode: "copy",
-        prune: true,
-        preserveTimestamps: true,
-    });
-    copyDirectory(options.workflowPath, workflowDefinitionPath(tempRoot, options.workflowId));
-    const compiledPath = createCompiled("preview", tempRoot, options.workflowId, options.about, tempRoot);
-    const result = await compileCompiled({
-        executor: options.executor,
-        compiledPath,
-        ...(options.reporter ? { reporter: options.reporter } : {}),
-        preserveStageShells: "on-failure",
-    });
-    return {
-        tempRoot,
-        compiledPath,
-        compileResult: {
-            ok: result.ok,
-            failedStage: result.failedStage,
-        },
-    };
-}
-export async function runWorkflowAuthoringDraft(options) {
-    const workflowPath = seedLocalWorkflowPackageFromBase({
-        sourcePath: options.sourcePath,
-        baseWorkflowId: options.baseWorkflowId,
-        workflowId: options.workflowId,
-        label: options.label,
-        hint: options.hint,
-    });
-    let preview = null;
-    try {
-        if (options.preparePreview !== false) {
-            preview = await prepareWorkflowAuthoringPreview({
-                datasetPath: options.datasetPath,
-                about: options.taskPrompt,
-                workflowId: options.workflowId,
-                workflowPath,
-                executor: options.executor,
-                reporter: options.previewReporter ?? null,
-            });
-        }
-        const shell = createWorkflowAuthoringShell({
-            workflowPath,
-            workflowId: options.workflowId,
-            label: options.label,
-            baseWorkflowId: options.baseWorkflowId,
-            datasetPath: options.datasetPath,
-            taskPrompt: options.taskPrompt,
-            checks: options.checks ?? [],
-            preview,
-        });
-        if (preview) {
-            rmSync(preview.tempRoot, { recursive: true, force: true });
-            preview = null;
-        }
-        const session = await runWorkflowEditSession({
-            executor: options.executor,
-            workflowPath,
-            shell,
-            prompt: buildWorkflowAuthoringPrompt(),
-            validate: validateWorkflowPackage,
-        });
-        return {
-            status: session.status,
-            changed: session.changed,
-            summary: session.summary,
-            validation: session.validation,
-            workflowPath,
-            shellPath: shell.rootPath,
-        };
-    }
-    finally {
-        if (preview) {
-            rmSync(preview.tempRoot, { recursive: true, force: true });
-        }
-    }
-}
-export function resolveWorkflowDraftPath(sourcePath, workflowId) {
-    return workflowDefinitionPath(sourcePath, workflowId);
-}
+export * from "../packages/workflow-authoring/workflow-authoring.js";

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

@@ -1,78 +1 @@
-import type { RuntimeContractType, RuntimeStageAcceptance, WorkflowCompilerApi, WorkflowCompiledSchema, WorkflowId, WorkflowZoneId } from "./schema.js";
-export interface WorkflowStarterDoc {
-    relativePath: string;
-    content: string;
-}
-export interface WorkflowStageDefinition {
-    id: string;
-    label: string;
-    description: string;
-    contractType: RuntimeContractType;
-    skillDir: string;
-    reads: WorkflowZoneId[];
-    writes: WorkflowZoneId[];
-    acceptance?: RuntimeStageAcceptance;
-}
-export interface WorkflowDefinition<TId extends string> {
-    id: TId;
-    compilerApi?: WorkflowCompilerApi;
-    purpose?: {
-        label: string;
-        taskHint: string;
-    };
-    label: string;
-    hint: string;
-    recommended?: boolean;
-    schema?: WorkflowCompiledSchema;
-    stages: WorkflowStageDefinition[];
-    stagePolicyNotes?: Record<string, string[]>;
-    starterDocs?: WorkflowStarterDoc[];
-    scope?: "builtin" | "local";
-}
-export type CompiledWorkflowId = string;
-export declare function standaloneWorkflowDefinitionFromLocalPackage(local: {
-    id: string;
-    compiler_api?: WorkflowCompilerApi;
-    purpose?: {
-        label: string;
-        task_hint: string;
-    };
-    label: string;
-    hint: string;
-    stages?: Array<{
-        id: string;
-        label: string;
-        description?: string;
-        contract_type: RuntimeContractType;
-        skill_dir?: string;
-        reads: WorkflowZoneId[];
-        writes: WorkflowZoneId[];
-        acceptance?: RuntimeStageAcceptance;
-    }>;
-    stage_policy_notes?: Record<string, string[]>;
-    workflow_schema?: WorkflowCompiledSchema;
-    starter_docs: WorkflowStarterDoc[];
-}): WorkflowDefinition<string>;
-export declare function listCompiledWorkflowChoices(sourcePath?: string): WorkflowDefinition<string>[];
-export declare function getCompiledWorkflow(workflowId: CompiledWorkflowId, options?: {
-    sourcePath?: string;
-}): WorkflowDefinition<string>;
-export declare function getActiveCompiledWorkflow(compiledPath: string, fallbackWorkflowId: CompiledWorkflowId): WorkflowDefinition<string>;
-export declare function resolveCompiledWorkflowId(value: unknown): CompiledWorkflowId | null;
-export declare function resolveCompiledWorkflowFromConfig(config: unknown): CompiledWorkflowId | null;
-export declare function resolveRequiredCompiledWorkflowFromConfig(config: unknown, label?: string): CompiledWorkflowId;
-export declare function formatCompiledWorkflowStageStep(workflowId: CompiledWorkflowId, stage: string, options?: {
-    sourcePath?: string;
-}): string;
-export declare function getWorkflowStageDefinition(workflowId: WorkflowId, stage: string, sourcePath?: string): WorkflowStageDefinition | null;
-export declare function getWorkflowStagePosition(workflowId: WorkflowId, stage: string, sourcePath?: string): {
-    stageIndex: number;
-    stageTotal: number;
-    stages: string[];
-} | null;
-export declare function getWorkflowStages(workflowId: WorkflowId, sourcePath?: string): string[];
-export declare function getActiveCompiledStages(compiledPath: string, fallbackWorkflowId: WorkflowId): string[];
-export declare function getWorkflowStagePolicyNotes(workflowId: WorkflowId, stage: string, sourcePath?: string): string[];
-export declare function getActiveCompiledStagePolicyNotes(compiledPath: string, fallbackWorkflowId: WorkflowId, stage: string): string[];
-export declare function resolveActiveCompiledStageAcceptance(compiledPath: string, fallbackWorkflowId: WorkflowId, stage: string): WorkflowStageDefinition["acceptance"] | undefined;
-export declare function formatActiveCompiledWorkflowStageStep(compiledPath: string, fallbackWorkflowId: CompiledWorkflowId, stage: string): string;
+export * from "../packages/workflow-package/workflow-definitions.js";

package/dist/lib/workflow-definitions.js

@@ -1,203 +1 @@
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { isWorkflowId, listLocalWorkflowDefinitions, loadLocalWorkflowDefinition, loadWorkflowDefinitionFromDir, } from "./local-workflows.js";
-import { PACKAGE_ROOT } from "./config.js";
-import { resolveSourceControlPath } from "./interf.js";
-import { warnInterf } from "./logger.js";
-import { workflowPackagePathForCompiled } from "./compiled-paths.js";
-import { mergeStagePolicyNotesForStages } from "./workflow-stage-policy.js";
-let builtinInterfWorkflowCache = null;
-function toWorkflowStages(stages, fallbackStages) {
-    if (!stages || stages.length === 0)
-        return [...fallbackStages];
-    return stages.map((stage) => ({
-        id: stage.id,
-        label: stage.label,
-        description: stage.description ?? stage.label,
-        contractType: stage.contract_type,
-        skillDir: stage.skill_dir ?? stage.id,
-        reads: [...stage.reads],
-        writes: [...stage.writes],
-        ...(stage.acceptance ? { acceptance: stage.acceptance } : {}),
-    }));
-}
-export function standaloneWorkflowDefinitionFromLocalPackage(local) {
-    if (!local.stages || local.stages.length === 0) {
-        throw new Error(`Workflow package "${local.id}" is missing explicit stages. Compiled-local and portable workflow packages must be standalone.`);
-    }
-    const stages = toWorkflowStages(local.stages, []);
-    return {
-        id: local.id,
-        compilerApi: local.compiler_api ?? {
-            kind: "compiled",
-            version: 1,
-        },
-        ...(local.purpose
-            ? {
-                purpose: {
-                    label: local.purpose.label,
-                    taskHint: local.purpose.task_hint,
-                },
-            }
-            : {}),
-        label: local.label,
-        hint: local.hint,
-        recommended: false,
-        ...(local.workflow_schema ? { schema: local.workflow_schema } : {}),
-        stages,
-        stagePolicyNotes: mergeStagePolicyNotesForStages(stages, undefined, local.stage_policy_notes),
-        starterDocs: [...local.starter_docs],
-        scope: "local",
-    };
-}
-function builtinWorkflowPackagePath(workflowId) {
-    return join(PACKAGE_ROOT, "builtin-workflows", workflowId);
-}
-function getBuiltinInterfWorkflow() {
-    if (builtinInterfWorkflowCache)
-        return builtinInterfWorkflowCache;
-    const local = loadWorkflowDefinitionFromDir(builtinWorkflowPackagePath("interf"));
-    if (!local) {
-        throw new Error("Missing built-in Interf workflow package at builtin-workflows/interf.");
-    }
-    const resolved = standaloneWorkflowDefinitionFromLocalPackage(local);
-    builtinInterfWorkflowCache = {
-        ...resolved,
-        id: "interf",
-        recommended: true,
-        scope: "builtin",
-    };
-    return builtinInterfWorkflowCache;
-}
-function listBuiltinCompiledWorkflows() {
-    return [getBuiltinInterfWorkflow()];
-}
-function resolveCompiledWorkflowFromLocal(workflowId, sourcePath) {
-    const local = loadLocalWorkflowDefinition(sourcePath, workflowId);
-    if (!local)
-        return null;
-    if (local.extends) {
-        throw new Error(`Workflow "${workflowId}" uses legacy extends. Rewrite it as a standalone package before creating or compiling a compiled dataset.`);
-    }
-    const resolved = standaloneWorkflowDefinitionFromLocalPackage(local);
-    return resolved;
-}
-export function listCompiledWorkflowChoices(sourcePath) {
-    const builtins = listBuiltinCompiledWorkflows();
-    if (!sourcePath)
-        return builtins;
-    const locals = listLocalWorkflowDefinitions(sourcePath)
-        .filter((definition) => definition.id !== "interf")
-        .map((definition) => {
-        try {
-            return resolveCompiledWorkflowFromLocal(definition.id, sourcePath);
-        }
-        catch (error) {
-            warnInterf(`Warning: skipping local workflow "${definition.id}" because it could not be resolved cleanly: ${error instanceof Error ? error.message : String(error)}`);
-            return null;
-        }
-    })
-        .filter((definition) => definition !== null);
-    return [...builtins, ...locals];
-}
-export function getCompiledWorkflow(workflowId, options = {}) {
-    const builtin = listBuiltinCompiledWorkflows().find((candidate) => candidate.id === workflowId);
-    if (builtin)
-        return builtin;
-    if (options.sourcePath) {
-        const local = resolveCompiledWorkflowFromLocal(workflowId, options.sourcePath);
-        if (local)
-            return local;
-        throw new Error(`No local workflow package found for "${workflowId}" under ${join(options.sourcePath, "interf", "workflows", workflowId)}.`);
-    }
-    throw new Error(`Workflow "${workflowId}" is not built-in. Provide a source path so Interf can resolve a local workflow package.`);
-}
-export function getActiveCompiledWorkflow(compiledPath, fallbackWorkflowId) {
-    const workflowPath = workflowPackagePathForCompiled(compiledPath);
-    if (existsSync(join(workflowPath, "workflow.json"))) {
-        const local = loadWorkflowDefinitionFromDir(workflowPath);
-        if (!local) {
-            throw new Error(`Dataset-local workflow package at ${workflowPath} is missing or invalid. Interf compile runs the local package directly; recreate or reseed this compiled dataset instead of relying on source-root fallback.`);
-        }
-        if (local.extends) {
-            throw new Error(`Dataset-local workflow package at ${workflowPath} still uses legacy extends. Materialize it as a standalone package before compiling this compiled dataset.`);
-        }
-        return standaloneWorkflowDefinitionFromLocalPackage(local);
-    }
-    throw new Error(`Missing local workflow package at ${workflowPath}. Interf compile runs the local package directly, so recreate or reseed this compiled dataset instead of relying on source-root workflow "${fallbackWorkflowId}" under ${resolveSourceControlPath(compiledPath)}.`);
-}
-export function resolveCompiledWorkflowId(value) {
-    if (typeof value === "string" && isWorkflowId(value)) {
-        return value;
-    }
-    return null;
-}
-export function resolveCompiledWorkflowFromConfig(config) {
-    if (!config || typeof config !== "object")
-        return null;
-    const raw = config;
-    return resolveCompiledWorkflowId(raw.workflow);
-}
-export function resolveRequiredCompiledWorkflowFromConfig(config, label = "compiled config") {
-    const workflowId = resolveCompiledWorkflowFromConfig(config);
-    if (!workflowId) {
-        throw new Error(`Missing or invalid workflow in ${label}.`);
-    }
-    return workflowId;
-}
-export function formatCompiledWorkflowStageStep(workflowId, stage, options = {}) {
-    return formatWorkflowStageStep(getCompiledWorkflow(workflowId, options), stage);
-}
-function resolveWorkflowDefinitionForStageMetadata(workflowId, sourcePath) {
-    if (sourcePath &&
-        existsSync(join(workflowPackagePathForCompiled(sourcePath), "workflow.json"))) {
-        return getActiveCompiledWorkflow(sourcePath, workflowId);
-    }
-    return getCompiledWorkflow(workflowId, { sourcePath });
-}
-function formatWorkflowStageStep(workflow, stage) {
-    const stageIndex = workflow.stages.findIndex((candidate) => candidate.id === stage);
-    if (stageIndex === -1) {
-        throw new Error(`Stage "${stage}" is not part of the compiled runtime.`);
-    }
-    const stageDefinition = workflow.stages[stageIndex];
-    if (!stageDefinition) {
-        throw new Error(`Stage "${stage}" is not part of the compiled runtime.`);
-    }
-    return `Step ${stageIndex + 1}/${workflow.stages.length} - ${stageDefinition.label}`;
-}
-export function getWorkflowStageDefinition(workflowId, stage, sourcePath) {
-    const workflow = resolveWorkflowDefinitionForStageMetadata(workflowId, sourcePath);
-    return workflow.stages.find((candidate) => candidate.id === stage) ?? null;
-}
-export function getWorkflowStagePosition(workflowId, stage, sourcePath) {
-    const stages = getWorkflowStages(workflowId, sourcePath);
-    const stageIndex = stages.findIndex((candidate) => candidate === stage);
-    if (stageIndex === -1)
-        return null;
-    return {
-        stageIndex: stageIndex + 1,
-        stageTotal: stages.length,
-        stages: [...stages],
-    };
-}
-export function getWorkflowStages(workflowId, sourcePath) {
-    return resolveWorkflowDefinitionForStageMetadata(workflowId, sourcePath).stages.map((definition) => definition.id);
-}
-export function getActiveCompiledStages(compiledPath, fallbackWorkflowId) {
-    return getActiveCompiledWorkflow(compiledPath, fallbackWorkflowId).stages.map((definition) => definition.id);
-}
-export function getWorkflowStagePolicyNotes(workflowId, stage, sourcePath) {
-    const workflow = resolveWorkflowDefinitionForStageMetadata(workflowId, sourcePath);
-    return [...(workflow.stagePolicyNotes?.[stage] ?? [])];
-}
-export function getActiveCompiledStagePolicyNotes(compiledPath, fallbackWorkflowId, stage) {
-    const workflow = getActiveCompiledWorkflow(compiledPath, fallbackWorkflowId);
-    return [...(workflow.stagePolicyNotes?.[stage] ?? [])];
-}
-export function resolveActiveCompiledStageAcceptance(compiledPath, fallbackWorkflowId, stage) {
-    return getActiveCompiledWorkflow(compiledPath, fallbackWorkflowId).stages.find((candidate) => candidate.id === stage)?.acceptance;
-}
-export function formatActiveCompiledWorkflowStageStep(compiledPath, fallbackWorkflowId, stage) {
-    return formatWorkflowStageStep(getActiveCompiledWorkflow(compiledPath, fallbackWorkflowId), stage);
-}
+export * from "../packages/workflow-package/workflow-definitions.js";