@interf/compiler 0.6.1 → 0.6.4

package/dist/lib/local-workflows.js

@@ -1,422 +1 @@
-import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, } from "node:fs";
-import { dirname, join, relative } from "node:path";
-import { z } from "zod";
-import { PACKAGE_ROOT } from "./config.js";
-import { isMarkdownFile } from "./util.js";
-import { listFilesRecursive } from "./filesystem.js";
-import { warnInterf } from "./logger.js";
-import { readJsonFileUnchecked, readJsonFileWithSchema } from "./parse.js";
-import { listBuiltinCompiledZoneSpecs, } from "./builtin-compiled-workflow.js";
-import { WorkflowCompilerApiSchema, RuntimeContractTypeSchema, RuntimeStageAcceptanceSchema, WorkflowPurposeSchema, WorkflowStageZoneAccessSchema, WorkflowIdPattern, } from "./schema.js";
-import { WORKFLOW_SCHEMA_FILE, workflowSchemaExists, writeWorkflowSchemaDocument, workflowSchemaFilePath, readWorkflowSchemaFile, } from "./compiled-schema.js";
-import { mergeStagePolicyNotesForStages } from "./workflow-stage-policy.js";
-const LocalWorkflowStageDefinitionSchema = z.object({
-    id: z.string().regex(WorkflowIdPattern),
-    label: z.string().min(1),
-    contract_type: RuntimeContractTypeSchema,
-    skill_dir: z.string().regex(WorkflowIdPattern).optional(),
-    description: z.string().min(1).optional(),
-    reads: WorkflowStageZoneAccessSchema,
-    writes: WorkflowStageZoneAccessSchema,
-    acceptance: RuntimeStageAcceptanceSchema.optional(),
-});
-const LocalWorkflowDefinitionSchema = z.object({
-    id: z.string().regex(WorkflowIdPattern),
-    type: z.literal("compiled"),
-    compiler_api: WorkflowCompilerApiSchema.optional(),
-    purpose: WorkflowPurposeSchema.optional(),
-    label: z.string().min(1),
-    hint: z.string().min(1),
-    extends: z.string().regex(WorkflowIdPattern).optional(),
-    stages: z.array(LocalWorkflowStageDefinitionSchema).min(1).optional(),
-    stage_policy_notes: z.record(z.string(), z.array(z.string())).optional(),
-});
-function workflowRootPath(sourcePath) {
-    return join(sourcePath, "interf", "workflows");
-}
-function builtinWorkflowRootPath(workflowId) {
-    return join(PACKAGE_ROOT, "builtin-workflows", workflowId);
-}
-export function workflowDefinitionPath(sourcePath, id) {
-    return join(workflowRootPath(sourcePath), id);
-}
-function isSupportedWorkflowStarterDocPath(relativePath) {
-    if (relativePath === "README.md")
-        return true;
-    if (relativePath.startsWith("improve/"))
-        return true;
-    if (relativePath.startsWith("use/query/"))
-        return true;
-    if (relativePath.startsWith("compile/stages/"))
-        return true;
-    return false;
-}
-function collectStarterDocs(dirPath) {
-    return listFilesRecursive(dirPath, isMarkdownFile)
-        .map((filePath) => relative(dirPath, filePath).replaceAll("\\", "/"))
-        .filter((relativePath) => isSupportedWorkflowStarterDocPath(relativePath))
-        .map((relativePath) => ({
-        relativePath,
-        content: readFileSync(join(dirPath, relativePath), "utf8"),
-    }))
-        .sort((a, b) => a.relativePath.localeCompare(b.relativePath));
-}
-function workflowPackageCopyPaths(dirPath) {
-    return [
-        "workflow.json",
-        WORKFLOW_SCHEMA_FILE,
-        ...collectStarterDocs(dirPath).map((doc) => doc.relativePath),
-    ];
-}
-function copyRelativeFile(sourceRoot, targetRoot, relativePath) {
-    const sourcePath = join(sourceRoot, relativePath);
-    if (!existsSync(sourcePath))
-        return;
-    const targetPath = join(targetRoot, relativePath);
-    mkdirSync(dirname(targetPath), { recursive: true });
-    cpSync(sourcePath, targetPath, { force: true });
-}
-function copyWorkflowPackageFiles(sourceWorkflowPath, targetWorkflowPath) {
-    rmSync(targetWorkflowPath, { recursive: true, force: true });
-    mkdirSync(targetWorkflowPath, { recursive: true });
-    for (const relativePath of workflowPackageCopyPaths(sourceWorkflowPath)) {
-        copyRelativeFile(sourceWorkflowPath, targetWorkflowPath, relativePath);
-    }
-}
-export function loadWorkflowDefinitionFromDir(dirPath) {
-    const workflowPath = existsSync(join(dirPath, "workflow.json"))
-        ? join(dirPath, "workflow.json")
-        : null;
-    if (!workflowPath)
-        return null;
-    const definition = readJsonFileWithSchema(workflowPath, "local workflow definition", LocalWorkflowDefinitionSchema);
-    if (!definition)
-        return null;
-    const workflowSchema = readWorkflowSchemaFile(dirPath);
-    if (!workflowSchema)
-        return null;
-    if (definition.type !== "compiled") {
-        warnInterf(`Warning: local workflow definition at ${workflowPath} has unexpected type "${definition.type}".`);
-        return null;
-    }
-    return {
-        ...definition,
-        workflow_schema: workflowSchema,
-        starter_docs: collectStarterDocs(dirPath),
-        directoryPath: dirPath,
-        workflowPath,
-        workflowSchemaPath: workflowSchemaFilePath(dirPath),
-    };
-}
-export function listLocalWorkflowDefinitions(sourcePath) {
-    const root = workflowRootPath(sourcePath);
-    if (!existsSync(root))
-        return [];
-    return readdirSync(root)
-        .map((entry) => join(root, entry))
-        .filter((entryPath) => {
-        try {
-            return statSync(entryPath).isDirectory();
-        }
-        catch {
-            return false;
-        }
-    })
-        .map((entryPath) => loadWorkflowDefinitionFromDir(entryPath))
-        .filter((definition) => definition !== null)
-        .sort((a, b) => a.label.localeCompare(b.label));
-}
-export function loadLocalWorkflowDefinition(sourcePath, id) {
-    return loadWorkflowDefinitionFromDir(workflowDefinitionPath(sourcePath, id));
-}
-export function resolveWorkflowPackageSourcePath(sourcePath, workflowId) {
-    const builtinPath = builtinWorkflowRootPath(workflowId);
-    if (workflowId === "interf" && existsSync(join(builtinPath, "workflow.json")))
-        return builtinPath;
-    const localPath = workflowDefinitionPath(sourcePath, workflowId);
-    if (existsSync(join(localPath, "workflow.json")))
-        return localPath;
-    if (existsSync(join(builtinPath, "workflow.json")))
-        return builtinPath;
-    return null;
-}
-export function isWorkflowId(value) {
-    return WorkflowIdPattern.test(value);
-}
-function readWorkflowJsonObject(dirPath) {
-    const workflowPath = join(dirPath, "workflow.json");
-    const raw = readJsonFileUnchecked(workflowPath, "workflow package");
-    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-        throw new Error(`Workflow package at ${dirPath} is missing a valid workflow.json.`);
-    }
-    return { ...raw };
-}
-export function patchWorkflowPackageMetadata(dirPath, options = {}) {
-    const workflowPath = join(dirPath, "workflow.json");
-    const workflowJson = readWorkflowJsonObject(dirPath);
-    const normalizedStages = Array.isArray(workflowJson.stages) && workflowJson.stages.length > 0
-        ? workflowJson.stages
-        : null;
-    if (!normalizedStages) {
-        throw new Error(`Cannot patch workflow package at ${dirPath}: workflow.json must declare explicit stages before it can be copied or rewritten.`);
-    }
-    const nextWorkflowJson = {
-        ...workflowJson,
-        type: "compiled",
-        compiler_api: workflowJson.compiler_api ?? {
-            kind: "compiled",
-            version: 1,
-        },
-        stages: normalizedStages,
-        ...(options.id ? { id: options.id } : {}),
-        ...(options.label ? { label: options.label } : {}),
-        ...(options.hint ? { hint: options.hint } : {}),
-    };
-    delete nextWorkflowJson.extends;
-    const mergedStagePolicyNotes = mergeStagePolicyNotesForStages(normalizedStages, workflowJson.stage_policy_notes, options.stagePolicyNotes);
-    if (mergedStagePolicyNotes) {
-        nextWorkflowJson.stage_policy_notes = mergedStagePolicyNotes;
-    }
-    else {
-        delete nextWorkflowJson.stage_policy_notes;
-    }
-    writeFileSync(workflowPath, JSON.stringify(nextWorkflowJson, null, 2) + "\n");
-    const schemaLabel = `${String(nextWorkflowJson.label ?? workflowJson.label ?? options.id ?? "Workflow")} workflow schema`;
-    const existingSchema = readWorkflowSchemaFile(dirPath);
-    if (!existingSchema) {
-        throw new Error(`Cannot patch workflow package at ${dirPath}: missing ${WORKFLOW_SCHEMA_FILE}. Restore or reseed the package instead of regenerating a schema from workflow.json.`);
-    }
-    writeWorkflowSchemaDocument(dirPath, {
-        ...existingSchema,
-        label: schemaLabel,
-    });
-}
-function collectWorkflowPackageStructureIssues(dirPath, stages) {
-    const issues = [];
-    const workflowPath = join(dirPath, "workflow.json");
-    if (!existsSync(workflowPath))
-        issues.push("missing workflow.json");
-    if (!workflowSchemaExists(dirPath))
-        issues.push("missing workflow.schema.json");
-    if (!existsSync(join(dirPath, "README.md")))
-        issues.push("missing README.md");
-    if (!existsSync(join(dirPath, "improve", "SKILL.md")))
-        issues.push("missing improve/SKILL.md");
-    if (!existsSync(join(dirPath, "use", "query", "SKILL.md")))
-        issues.push("missing use/query/SKILL.md");
-    if (!stages)
-        return issues;
-    for (const stage of stages) {
-        const skillDir = typeof stage.skill_dir === "string" && stage.skill_dir.trim().length > 0
-            ? stage.skill_dir
-            : stage.id;
-        if (!existsSync(join(dirPath, "compile", "stages", skillDir, "SKILL.md"))) {
-            issues.push(`missing compile/stages/${skillDir}/SKILL.md`);
-        }
-    }
-    return issues;
-}
-function collectWorkflowStageSkillIssues(dirPath, stages) {
-    if (!stages)
-        return [];
-    const issues = [];
-    for (const stage of stages) {
-        const skillDir = typeof stage.skill_dir === "string" && stage.skill_dir.trim().length > 0
-            ? stage.skill_dir
-            : stage.id;
-        if (!existsSync(join(dirPath, "compile", "stages", skillDir, "SKILL.md"))) {
-            issues.push(`missing compile/stages/${skillDir}/SKILL.md`);
-        }
-    }
-    return issues;
-}
-export function describeWorkflowPackagePortability(dirPath) {
-    const issues = collectWorkflowPackageStructureIssues(dirPath, null);
-    if (issues.length > 0)
-        return issues;
-    let workflowJson;
-    try {
-        workflowJson = readWorkflowJsonObject(dirPath);
-    }
-    catch (error) {
-        issues.push(error instanceof Error ? error.message : String(error));
-        return issues;
-    }
-    const parsed = LocalWorkflowDefinitionSchema.safeParse(workflowJson);
-    if (!parsed.success) {
-        issues.push(...parsed.error.issues.map((issue) => issue.path.length > 0
-            ? `workflow.json ${issue.path.join(".")}: ${issue.message}`
-            : `workflow.json: ${issue.message}`));
-        return issues;
-    }
-    if (typeof parsed.data.extends === "string" && parsed.data.extends.trim().length > 0) {
-        issues.push("workflow.json uses legacy extends; portable workflow packages must be materialized standalone");
-    }
-    if (!parsed.data.stages || parsed.data.stages.length === 0) {
-        issues.push("workflow.json must declare explicit stages for a portable workflow package");
-        return issues;
-    }
-    return [
-        ...issues,
-        ...collectWorkflowStageSkillIssues(dirPath, parsed.data.stages ?? null),
-    ];
-}
-export function isPortableWorkflowPackage(dirPath) {
-    return describeWorkflowPackagePortability(dirPath).length === 0;
-}
-export function copyWorkflowPackageDirectory(sourceWorkflowPath, targetWorkflowPath) {
-    const portabilityIssues = describeWorkflowPackagePortability(sourceWorkflowPath);
-    if (portabilityIssues.length > 0) {
-        throw new Error(`Workflow package at ${sourceWorkflowPath} is not directly copyable: ${portabilityIssues.join("; ")}.`);
-    }
-    mkdirSync(dirname(targetWorkflowPath), { recursive: true });
-    copyWorkflowPackageFiles(sourceWorkflowPath, targetWorkflowPath);
-}
-export function validateWorkflowPackage(dirPath) {
-    const workflowPath = join(dirPath, "workflow.json");
-    if (!existsSync(workflowPath)) {
-        return {
-            ok: false,
-            summary: `No workflow.json found at ${dirPath}`,
-            errors: ["Missing workflow.json"],
-            counts: {},
-        };
-    }
-    const raw = readJsonFileUnchecked(workflowPath, "workflow package");
-    if (!raw) {
-        return {
-            ok: false,
-            summary: `Failed to parse workflow.json at ${workflowPath}`,
-            errors: ["Invalid JSON in workflow.json"],
-            counts: {},
-        };
-    }
-    const parsed = LocalWorkflowDefinitionSchema.safeParse(raw);
-    if (!parsed.success) {
-        const issues = parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`);
-        return {
-            ok: false,
-            summary: `workflow.json failed validation: ${issues.length} issue(s)`,
-            errors: issues,
-            counts: {},
-        };
-    }
-    const def = parsed.data;
-    const errors = [];
-    if (typeof def.extends === "string" && def.extends.trim().length > 0) {
-        errors.push("workflow.json uses legacy extends. Portable workflow packages must be materialized as standalone packages.");
-    }
-    if (!def.stages || def.stages.length === 0) {
-        errors.push("workflow.json must declare explicit stages. Legacy inherited packages are not portable.");
-    }
-    if (def.stage_policy_notes && def.stages) {
-        const stageIds = new Set(def.stages.map((stage) => stage.id));
-        for (const stageId of Object.keys(def.stage_policy_notes)) {
-            if (!stageIds.has(stageId)) {
-                errors.push(`workflow.json stage_policy_notes references unknown stage "${stageId}".`);
-            }
-        }
-    }
-    for (const issue of collectWorkflowPackageStructureIssues(dirPath, def.stages ?? null)) {
-        const formatted = issue.startsWith("missing ")
-            ? `Missing ${issue.slice("missing ".length)}.`
-            : issue;
-        errors.push(formatted);
-    }
-    const workflowSchema = readWorkflowSchemaFile(dirPath);
-    if (!workflowSchema) {
-        errors.push("workflow.schema.json is missing or invalid.");
-    }
-    if (workflowSchema) {
-        const stages = def.stages ?? [];
-        const stageIds = new Set(stages.map((stage) => stage.id));
-        const seenPaths = new Map();
-        const seenZoneIds = new Set();
-        const zoneById = new Map(workflowSchema.zones.map((zone) => [zone.id, zone]));
-        const normalizedParts = (value) => value.replaceAll("\\", "/").split("/").filter(Boolean);
-        const hasOverlappingPath = (value, other) => {
-            const a = normalizedParts(value);
-            const b = normalizedParts(other);
-            const shorter = a.length <= b.length ? a : b;
-            const longer = a.length <= b.length ? b : a;
-            return shorter.every((part, index) => longer[index] === part);
-        };
-        for (const zone of workflowSchema.zones) {
-            if (seenZoneIds.has(zone.id)) {
-                errors.push(`workflow.schema.json repeats zone id "${zone.id}".`);
-            }
-            seenZoneIds.add(zone.id);
-            const existingPathOwner = seenPaths.get(zone.path);
-            if (existingPathOwner) {
-                errors.push(`workflow.schema.json repeats zone path "${zone.path}".`);
-            }
-            for (const [existingPath, existingZoneId] of seenPaths.entries()) {
-                if (existingPath === zone.path)
-                    continue;
-                if (hasOverlappingPath(zone.path, existingPath)) {
-                    errors.push(`workflow.schema.json zones "${zone.id}" and "${existingZoneId}" overlap on path "${zone.path}" / "${existingPath}".`);
-                }
-            }
-            seenPaths.set(zone.path, zone.id);
-            if ((zone.role === "input" || zone.role === "runtime") && zone.owned_by.length > 0) {
-                errors.push(`workflow.schema.json zone "${zone.id}" cannot declare owners because its role is "${zone.role}".`);
-            }
-            for (const owner of zone.owned_by) {
-                if (!stageIds.has(owner)) {
-                    errors.push(`workflow.schema.json references unknown stage "${owner}" for zone "${zone.path}".`);
-                }
-            }
-        }
-        for (const stage of stages) {
-            for (const zoneId of stage.reads) {
-                if (!zoneById.has(zoneId)) {
-                    errors.push(`Stage "${stage.id}" reads unknown zone "${zoneId}".`);
-                }
-            }
-            for (const zoneId of stage.writes) {
-                const zone = zoneById.get(zoneId);
-                if (!zone) {
-                    errors.push(`Stage "${stage.id}" writes unknown zone "${zoneId}".`);
-                    continue;
-                }
-                if (zone.role === "input" || zone.role === "runtime") {
-                    errors.push(`Stage "${stage.id}" writes zone "${zoneId}" but zones with role "${zone.role}" are engine-owned inputs, not writable stage outputs.`);
-                }
-                if (!zone.owned_by.includes(stage.id)) {
-                    errors.push(`Stage "${stage.id}" writes zone "${zoneId}" but that zone is not owned by the stage in workflow.schema.json.`);
-                }
-            }
-        }
-        for (const requiredZone of listBuiltinCompiledZoneSpecs().filter((zone) => zone.id === "raw" || zone.id === "runtime")) {
-            const match = zoneById.get(requiredZone.id);
-            if (!match) {
-                errors.push(`workflow.schema.json is missing required zone "${requiredZone.id}".`);
-                continue;
-            }
-            if (match.kind !== requiredZone.kind) {
-                errors.push(`workflow.schema.json zone "${requiredZone.id}" should be kind "${requiredZone.kind}".`);
-            }
-            if (match.role !== requiredZone.role) {
-                errors.push(`workflow.schema.json zone "${requiredZone.id}" should have role "${requiredZone.role}".`);
-            }
-        }
-    }
-    const stageDirs = existsSync(join(dirPath, "compile", "stages"))
-        ? listFilesRecursive(join(dirPath, "compile", "stages"), (filePath) => basename(filePath) === "SKILL.md")
-        : [];
-    const counts = {
-        starter_docs: collectStarterDocs(dirPath).length,
-        compile_stage_docs: stageDirs.length,
-        compiled_zones: workflowSchema?.zones.length ?? 0,
-        workflow_zones: workflowSchema?.zones.length ?? 0,
-    };
-    return {
-        ok: errors.length === 0,
-        summary: errors.length === 0 ? "Workflow package is valid." : `Workflow package has ${errors.length} issue(s).`,
-        errors,
-        counts,
-    };
-}
-function basename(filePath) {
-    return filePath.split(/[\\/]/).pop() ?? filePath;
-}
+export * from "../packages/workflow-package/local-workflows.js";

package/dist/lib/logger.d.ts

@@ -1,3 +1 @@
-export type InterfWarningHandler = (message: string) => void;
-export declare function setInterfWarningHandler(handler?: InterfWarningHandler): void;
-export declare function warnInterf(message: string): void;
+export * from "../packages/shared/logger.js";

package/dist/lib/logger.js

@@ -1,10 +1 @@
-const defaultWarningHandler = (message) => {
-    console.warn(message);
-};
-let currentWarningHandler = defaultWarningHandler;
-export function setInterfWarningHandler(handler) {
-    currentWarningHandler = handler ?? defaultWarningHandler;
-}
-export function warnInterf(message) {
-    currentWarningHandler(message);
-}
+export * from "../packages/shared/logger.js";

package/dist/lib/package-root.d.ts

@@ -0,0 +1 @@
+export * from "../packages/workflow-package/lib/package-root.js";

package/dist/lib/package-root.js

@@ -0,0 +1 @@
+export * from "../packages/workflow-package/lib/package-root.js";

package/dist/lib/parse.d.ts

@@ -1,8 +1 @@
-import type { ZodType } from "zod";
-export declare function readJsonFileUnchecked<T>(filePath: string, label: string): T | null;
-export declare function readJsonFileWithSchema<T>(filePath: string, label: string, schema: ZodType<T>): T | null;
-export declare function renderJsonFrontmatter(frontmatter: Record<string, unknown>): string;
-export declare function parseJsonFrontmatter(content: string): {
-    frontmatter: Record<string, unknown>;
-    body: string;
-} | null;
+export * from "../packages/shared/parse.js";

package/dist/lib/parse.js

@@ -1,145 +1 @@
-import { readFileSync } from "node:fs";
-import { warnInterf } from "./logger.js";
-function formatError(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-export function readJsonFileUnchecked(filePath, label) {
-    try {
-        return JSON.parse(readFileSync(filePath, "utf-8"));
-    }
-    catch (error) {
-        warnInterf(`Warning: failed to parse ${label} at ${filePath}: ${formatError(error)}`);
-        return null;
-    }
-}
-export function readJsonFileWithSchema(filePath, label, schema) {
-    const raw = readJsonFileUnchecked(filePath, label);
-    if (raw === null)
-        return null;
-    const parsed = schema.safeParse(raw);
-    if (!parsed.success) {
-        warnInterf(`Warning: failed to validate ${label} at ${filePath}: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
-        return null;
-    }
-    return parsed.data;
-}
-export function renderJsonFrontmatter(frontmatter) {
-    return [
-        "---",
-        JSON.stringify(frontmatter, null, 2),
-        "---",
-    ].join("\n");
-}
-function parseQuotedString(value) {
-    if (value.length < 2)
-        return null;
-    const quote = value[0];
-    if ((quote !== "\"" && quote !== "'") || value[value.length - 1] !== quote)
-        return null;
-    const inner = value.slice(1, -1);
-    if (quote === "\"") {
-        try {
-            return JSON.parse(value);
-        }
-        catch {
-            return null;
-        }
-    }
-    return inner.replace(/\\'/g, "'");
-}
-function parseYamlScalar(value) {
-    const trimmed = value.trim();
-    if (trimmed.length === 0)
-        return "";
-    const quoted = parseQuotedString(trimmed);
-    if (quoted !== null)
-        return quoted;
-    if (trimmed === "true")
-        return true;
-    if (trimmed === "false")
-        return false;
-    if (trimmed === "null")
-        return null;
-    if (/^-?\d+(?:\.\d+)?$/.test(trimmed))
-        return Number(trimmed);
-    if ((trimmed.startsWith("[") && trimmed.endsWith("]"))
-        || (trimmed.startsWith("{") && trimmed.endsWith("}"))) {
-        try {
-            return JSON.parse(trimmed);
-        }
-        catch {
-            return trimmed;
-        }
-    }
-    return trimmed;
-}
-function parseYamlFrontmatter(frontmatterText) {
-    const lines = frontmatterText.split("\n");
-    const frontmatter = {};
-    for (let index = 0; index < lines.length; index += 1) {
-        const line = lines[index] ?? "";
-        const trimmed = line.trim();
-        if (trimmed.length === 0 || trimmed.startsWith("#"))
-            continue;
-        const match = line.match(/^([A-Za-z0-9_-]+):(?:\s+(.*))?$/);
-        if (!match)
-            return null;
-        const [, key, inlineValue] = match;
-        if (!key)
-            return null;
-        if (inlineValue && inlineValue.trim().length > 0) {
-            frontmatter[key] = parseYamlScalar(inlineValue);
-            continue;
-        }
-        const items = [];
-        let cursor = index + 1;
-        while (cursor < lines.length) {
-            const nextLine = lines[cursor] ?? "";
-            const nextTrimmed = nextLine.trim();
-            if (nextTrimmed.length === 0) {
-                cursor += 1;
-                continue;
-            }
-            const itemMatch = nextLine.match(/^\s*-\s+(.*)$/);
-            if (!itemMatch || !/^\s+/.test(nextLine))
-                break;
-            items.push(parseYamlScalar(itemMatch[1] ?? ""));
-            cursor += 1;
-        }
-        if (items.length > 0) {
-            frontmatter[key] = items;
-            index = cursor - 1;
-            continue;
-        }
-        frontmatter[key] = "";
-    }
-    return Object.keys(frontmatter).length > 0 ? frontmatter : null;
-}
-export function parseJsonFrontmatter(content) {
-    const normalized = content.replace(/\r\n/g, "\n");
-    const match = normalized.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-    if (!match)
-        return null;
-    const [, frontmatterText, body = ""] = match;
-    if (frontmatterText === undefined)
-        return null;
-    try {
-        const frontmatter = JSON.parse(frontmatterText);
-        if (!frontmatter || typeof frontmatter !== "object" || Array.isArray(frontmatter)) {
-            return null;
-        }
-        return {
-            frontmatter: frontmatter,
-            body,
-        };
-    }
-    catch {
-        const frontmatter = parseYamlFrontmatter(frontmatterText);
-        if (!frontmatter)
-            return null;
-        return {
-            frontmatter,
-            body,
-        };
-    }
-}
+export * from "../packages/shared/parse.js";

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

@@ -1,11 +1 @@
-export declare const PROJECT_INTERF_DIR = "interf";
-export declare const PROJECT_TESTS_DIR = "tests";
-export declare function projectInterfRoot(projectPath: string): string;
-export declare function compiledCompiledPathForDataset(projectPath: string, datasetName: string): string;
-export declare function datasetTestsRoot(projectPath: string, datasetName: string): string;
-export type DatasetTestTargetLabel = "file-as-is" | "compiled";
-export declare function datasetTestRunsRoot(projectPath: string, datasetName: string, target: DatasetTestTargetLabel): string;
-export declare function datasetLatestTestStatePath(projectPath: string, datasetName: string): string;
-export declare function datasetLatestTestSummaryPath(projectPath: string, datasetName: string): string;
-export declare function normalizeDatasetTestRunId(input: string): string;
-export declare function datasetTestRunPath(projectPath: string, datasetName: string, target: DatasetTestTargetLabel, generatedAt: string, runId: string, runSuffix?: string | null): string;
+export * from "../packages/project-model/project-paths.js";

package/dist/lib/project-paths.js

@@ -1,32 +1,3 @@
-import { join } from "node:path";
-export const PROJECT_INTERF_DIR = "interf";
-export const PROJECT_TESTS_DIR = "tests";
-export function projectInterfRoot(projectPath) {
-    return join(projectPath, PROJECT_INTERF_DIR);
-}
-export function compiledCompiledPathForDataset(projectPath, datasetName) {
-    return join(projectInterfRoot(projectPath), datasetName);
-}
-export function datasetTestsRoot(projectPath, datasetName) {
-    return join(projectInterfRoot(projectPath), PROJECT_TESTS_DIR, datasetName);
-}
-export function datasetTestRunsRoot(projectPath, datasetName, target) {
-    return join(datasetTestsRoot(projectPath, datasetName), target, "runs");
-}
-export function datasetLatestTestStatePath(projectPath, datasetName) {
-    return join(datasetTestsRoot(projectPath, datasetName), "latest.json");
-}
-export function datasetLatestTestSummaryPath(projectPath, datasetName) {
-    return join(datasetTestsRoot(projectPath, datasetName), "latest.md");
-}
-export function normalizeDatasetTestRunId(input) {
-    return input
-        .toLowerCase()
-        .trim()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "")
-        .slice(0, 80);
-}
-export function datasetTestRunPath(projectPath, datasetName, target, generatedAt, runId, runSuffix) {
-    return join(datasetTestRunsRoot(projectPath, datasetName, target), `${generatedAt.replace(/[:.]/g, "-")}-${runId}${runSuffix ? `-${normalizeDatasetTestRunId(runSuffix)}` : ""}.json`);
-}
+// Compatibility shim for historical `src/lib/project-paths.ts` imports.
+// Source of truth: `src/packages/project-model/project-paths.ts`.
+export * from "../packages/project-model/project-paths.js";

package/dist/lib/runtime-acceptance.d.ts

@@ -1,9 +1 @@
-import { type CompiledState, type RuntimeStageAcceptance, type RuntimeStageContract } from "./schema.js";
-import { type RuntimeStageAcceptanceValidation } from "./runtime-types.js";
-export declare function stageRecordFromState(state: CompiledState | null, stageId: string): Record<string, unknown> | null;
-export declare function validateResolvedStageAcceptance(dirPath: string, options: {
-    stageId: string;
-    acceptance?: RuntimeStageAcceptance;
-    counts?: Record<string, number>;
-}): RuntimeStageAcceptanceValidation;
-export declare function validateStageContractAcceptance(dirPath: string, contract?: RuntimeStageContract | null): RuntimeStageAcceptanceValidation;
+export * from "../packages/compiler/runtime-acceptance.js";