@friehub/blueprint 0.1.0

package/dist/core/collectors.js

@@ -0,0 +1,126 @@
+import { classifySectionBody, parseSectionBody } from "./section-body.js";
+export function collectFunctions(file, sections, mode) {
+    const items = [];
+    for (const section of sections) {
+        const body = classifySectionBody(section.content, section.startLine, section.endLine);
+        const parsed = parseSectionBody("functions", body, { file: section.file, startLine: section.startLine, endLine: section.endLine });
+        if (parsed.kind === "functions")
+            items.push(...parsed.items);
+    }
+    return { items, issues: [] };
+}
+export function collectTypes(file, sections, mode) {
+    const items = [];
+    for (const section of sections) {
+        const body = classifySectionBody(section.content, section.startLine, section.endLine);
+        const parsed = parseSectionBody("types", body, { file: section.file, startLine: section.startLine, endLine: section.endLine });
+        if (parsed.kind === "types")
+            items.push(...parsed.items);
+    }
+    return { items, issues: [] };
+}
+export function collectTextSections(sections, _sectionName) {
+    const items = [];
+    for (const section of sections) {
+        const body = classifySectionBody(section.content, section.startLine, section.endLine);
+        items.push(...body.lines.map((line) => stripTextLine(line)).filter(Boolean));
+    }
+    return items;
+}
+export function collectProviders(sections) {
+    const items = [];
+    for (const section of sections) {
+        const body = classifySectionBody(section.content, section.startLine, section.endLine);
+        for (const line of body.lines) {
+            const text = stripTextLine(line);
+            if (!text)
+                continue;
+            for (const chunk of text.split(",")) {
+                if (chunk.trim())
+                    items.push(chunk.trim());
+            }
+        }
+    }
+    return items;
+}
+export function parseDepList(raw) {
+    return raw.split(",").map((item) => item.replace(/\(.*?\)/g, "").trim()).filter(Boolean);
+}
+export function groupSections(sections) {
+    const grouped = new Map();
+    for (const section of sections) {
+        const list = grouped.get(section.name) ?? [];
+        list.push(section);
+        grouped.set(section.name, list);
+    }
+    return grouped;
+}
+export function extractSummary(preamble) {
+    if (!preamble)
+        return null;
+    const lines = preamble.split(/\r?\n/).map((line) => line.trim());
+    return lines.find((line) => line && !line.startsWith("#") && line !== "---" && !line.includes("**Version:**") && !line.includes("**Part:**")) ?? null;
+}
+export function extractVersion(preamble) {
+    if (!preamble)
+        return null;
+    const match = preamble.match(/\*\*Version:\*\*\s*([\d.]+)/);
+    return match ? match[1] ?? null : null;
+}
+export function stripTextLine(line) {
+    return line.trim().replace(/^[-*+]\s+/, "").trim();
+}
+export function extractDependencies(sections) {
+    const hardDeps = [];
+    const softDeps = [];
+    for (const section of sections) {
+        const body = classifySectionBody(section.content, section.startLine, section.endLine);
+        for (const line of body.lines) {
+            const text = stripTextLine(line);
+            if (!text)
+                continue;
+            const dependsMatch = text.match(/\*\*Depends On:\*\*\s*(.+)/i);
+            if (dependsMatch) {
+                const raw = dependsMatch[1]?.trim() ?? "";
+                if (raw && !raw.startsWith("(none"))
+                    hardDeps.push(...parseDepList(raw));
+                continue;
+            }
+            const recommendsMatch = text.match(/\*\*Recommends:\*\*\s*(.+)/i);
+            if (recommendsMatch) {
+                const raw = recommendsMatch[1]?.trim() ?? "";
+                if (raw && !raw.startsWith("(none"))
+                    softDeps.push(...parseDepList(raw));
+            }
+        }
+    }
+    return { hardDeps, softDeps };
+}
+export function extractCoreInherits(sections) {
+    const inherits = [];
+    for (const section of sections) {
+        const body = classifySectionBody(section.content, section.startLine, section.endLine);
+        for (const line of body.lines) {
+            const text = stripTextLine(line);
+            if (!text)
+                continue;
+            const runtimeMatch = text.match(/\*\*Runtime Standards:\*\*\s*Inherits\s+`([^`]+)`/i);
+            if (runtimeMatch) {
+                const name = (runtimeMatch[1] ?? "").replace(/.*\//, "").replace(/\.md$/i, "");
+                if (name && !inherits.includes(name))
+                    inherits.push(name);
+                continue;
+            }
+            const globalMatch = text.match(/\*\*Global Standards:\*\*\s*Inherits\s+`([^`]+)`/i);
+            if (globalMatch) {
+                const name = (globalMatch[1] ?? "").replace(/.*\//, "").replace(/\.md$/i, "");
+                if (name && !inherits.includes(name))
+                    inherits.push(name);
+            }
+        }
+    }
+    return inherits;
+}
+export function issue(file, section, startLine, endLine, message, code, mode) {
+    return { code, file, section, startLine, endLine, message, severity: mode === "strict" ? "error" : "warning" };
+}

package/dist/core/discovery.js

@@ -0,0 +1,57 @@
+import { readdir, stat } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+export async function discoverContractFiles(rootDir) {
+    const contractsDir = join(rootDir, "contracts");
+    const warnings = [];
+    if (!(await dirExists(contractsDir))) {
+        warnings.push({ message: `contracts directory not found: ${contractsDir}` });
+        return { files: [], warnings };
+    }
+    const files = await walkMarkdown(contractsDir);
+    return {
+        files: files.map((file) => {
+            const rel = relative(contractsDir, file);
+            const isCore = rel.startsWith("core" + sep) || rel.startsWith("core/");
+            return {
+                file,
+                kind: (isCore ? "core" : "module"),
+                name: basenameWithoutExtension(file),
+            };
+        }),
+        warnings,
+    };
+}
+async function dirExists(dir) {
+    try {
+        const s = await stat(dir);
+        return s.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function walkMarkdown(dir) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const results = [];
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...(await walkMarkdown(fullPath)));
+        }
+        else if (entry.isFile() && entry.name.endsWith(".md")) {
+            results.push(fullPath);
+        }
+    }
+    return results.sort();
+}
+function basenameWithoutExtension(file) {
+    const parts = file.split(/[\\/]/);
+    const filename = parts[parts.length - 1] ?? file;
+    return filename.replace(/\.md$/i, "");
+}

package/dist/core/edge-cases.test.js

@@ -0,0 +1,147 @@
+import { strict as assert } from "node:assert";
+import { describe, it } from "node:test";
+import { parseDocument } from "./parse-document.js";
+import { resolve, detectCycles } from "./resolve.js";
+import { implicitCores } from "./catalog.js";
+describe("parser edge cases", () => {
+    it("handles empty markdown file", () => {
+        const result = parseDocument("empty.md", "", "loose");
+        assert.notEqual(result.value, null, "should not crash on empty file");
+        assert.ok(result.issues.length >= 0, "may have issues for empty file");
+    });
+    it("handles file with only a heading", () => {
+        const result = parseDocument("minimal.md", "# Hello", "loose");
+        assert.notEqual(result.value, null, "should not crash on heading-only file");
+    });
+    it("handles malformed function signatures gracefully", () => {
+        const content = `# Test\n\n**Functions**\n\`\`\`\nnotAFunction\nbroken( → \ngoodOne(x) → string\n\`\`\``;
+        const result = parseDocument("bad.md", content, "loose");
+        assert.notEqual(result.value, null);
+        const fnCount = result.value && "functions" in result.value ? result.value.functions.length : 0;
+        assert.ok(fnCount >= 0, "should handle malformed signatures without crashing");
+    });
+    it("handles duplicate section names", () => {
+        const content = `# Duplicate\n\n## Functions\nfoo() → string\n\n## Functions\nbar() → string`;
+        const result = parseDocument("dup.md", content, "loose");
+        assert.ok(result.issues.length > 0, "should report duplicate sections");
+    });
+    it("handles missing required sections", () => {
+        const content = `# NoFunctions\n\n**Types**\n\`\`\`\nFoo = string\n\`\`\``;
+        const result = parseDocument("missing.md", content, "strict");
+        assert.ok(result.issues.some((i) => i.severity === "error"), "should fail strict on missing functions");
+    });
+    it("handles very long contract names", () => {
+        const longName = "a".repeat(200);
+        const content = `# ${longName}\n\n**Functions**\n\`\`\`\nfoo() → string\n\`\`\``;
+        const result = parseDocument(`${longName}.md`, content, "loose");
+        assert.notEqual(result.value, null, "should handle long names");
+    });
+    it("handles types section with no types", () => {
+        const content = `# EmptyTypes\n\n**Functions**\n\`\`\`\nfoo() → void\n\`\`\`\n\n**Types**\n\`\`\`\n\`\`\``;
+        const result = parseDocument("empty-types.md", content, "loose");
+        assert.notEqual(result.value, null);
+        const typeCount = result.value && "types" in result.value ? result.value.types.length : 0;
+        assert.equal(typeCount, 0, "should handle empty types section");
+    });
+    it("handles file with no preamble", () => {
+        const content = `## Functions\nfoo() → string\n\n## Types\nBar = string`;
+        const result = parseDocument("no-preamble.md", content, "loose");
+        assert.notEqual(result.value, null, "should not crash without preamble");
+    });
+    it("handles multiple system-integrations sections", () => {
+        const content = `# Multi\n\n**Functions**\n\`\`\`\nfoo() → string\n\`\`\`\n\n**System-Level Integrations & Constraints**\nSome text\n\n**System-Level Integrations**\nMore text`;
+        const result = parseDocument("multi-sys.md", content, "loose");
+        assert.ok(result.issues.length > 0, "should report duplicate system-integrations");
+    });
+});
+describe("resolver edge cases", () => {
+    it("handles empty module list", () => {
+        const catalog = { modules: [], core: [] };
+        const result = resolve(catalog, []);
+        assert.equal(result.modules.length, 0);
+        assert.equal(result.errors.length, 0);
+    });
+    it("handles all unknown modules", () => {
+        const catalog = { modules: [], core: [] };
+        const result = resolve(catalog, ["nonexistent", "also-gone"]);
+        assert.equal(result.modules.length, 0);
+        assert.equal(result.errors.length, 2);
+    });
+    it("handles chain of 50 hard deps", () => {
+        const modules = [];
+        for (let i = 0; i < 50; i++) {
+            modules.push({
+                name: `mod_${i}`,
+                title: `mod_${i}`,
+                version: null,
+                summary: null,
+                functions: [{ name: "test", params: [], returns: "void", signature: "test()", raw: "test()", source: { file: "", startLine: 1, endLine: 1 } }],
+                types: [],
+                hardDeps: i > 0 ? [`mod_${i - 1}`] : [],
+                softDeps: [],
+                coreInherits: [],
+                invariants: [],
+                providers: [],
+                integrations: [],
+                rawSections: [],
+                profile: "module-v1",
+                source: { file: "", startLine: 1, endLine: 1 },
+            });
+        }
+        const catalog = { modules, core: [] };
+        const result = resolve(catalog, ["mod_49"]);
+        assert.equal(result.modules.length, 50, "should resolve 50-module chain");
+        assert.equal(result.errors.length, 0);
+    });
+    it("handles self-referencing module gracefully", () => {
+        const modules = [{
+                name: "self",
+                title: "self",
+                version: null,
+                summary: null,
+                functions: [{ name: "test", params: [], returns: "void", signature: "test()", raw: "test()", source: { file: "", startLine: 1, endLine: 1 } }],
+                types: [],
+                hardDeps: ["self"],
+                softDeps: [],
+                coreInherits: [],
+                invariants: [],
+                providers: [],
+                integrations: [],
+                rawSections: [],
+                profile: "module-v1",
+                source: { file: "", startLine: 1, endLine: 1 },
+            }];
+        const catalog = { modules, core: [] };
+        const cycles = detectCycles(catalog);
+        assert.ok(cycles.length > 0, "should detect self-reference cycle");
+        const result = resolve(catalog, ["self"]);
+        assert.ok(result.modules.length >= 1, "should still resolve self-referencing module");
+    });
+    it("handles dependency on nonexistent module with error", () => {
+        const modules = [{
+                name: "real",
+                title: "real",
+                version: null,
+                summary: null,
+                functions: [{ name: "test", params: [], returns: "void", signature: "test()", raw: "test()", source: { file: "", startLine: 1, endLine: 1 } }],
+                types: [],
+                hardDeps: ["ghost"],
+                softDeps: [],
+                coreInherits: [],
+                invariants: [],
+                providers: [],
+                integrations: [],
+                rawSections: [],
+                profile: "module-v1",
+                source: { file: "", startLine: 1, endLine: 1 },
+            }];
+        const catalog = { modules, core: [] };
+        const result = resolve(catalog, ["real"]);
+        assert.equal(result.modules.length, 1);
+        assert.ok(result.errors.length > 0, "should error on missing hard dep");
+    });
+    it("implicitCores returns empty when no implicit cores", () => {
+        const catalog = { modules: [], core: [{ name: "sagas", title: "", version: null, implicit: false, summary: null, sections: [], rawSections: [], profile: "core-v1", source: { file: "", startLine: 1, endLine: 1 } }] };
+        assert.equal(implicitCores(catalog).length, 0);
+    });
+});

package/dist/core/envelope.js

@@ -0,0 +1 @@
+export {};

package/dist/core/graph.js

@@ -0,0 +1,123 @@
+export function buildGraph(catalog, moduleName) {
+    const moduleByName = new Map();
+    for (const mod of catalog.modules) {
+        moduleByName.set(mod.name, mod);
+    }
+    const nodes = new Map();
+    const edges = [];
+    const mod = moduleByName.get(moduleName);
+    if (!mod) {
+        return { nodes: [], edges: [] };
+    }
+    nodes.set(moduleName, { name: moduleName, kind: "module", source: "explicit" });
+    for (const dep of mod.hardDeps) {
+        if (!nodes.has(dep)) {
+            nodes.set(dep, { name: dep, kind: "module", source: "hard-dep" });
+        }
+        edges.push({ from: moduleName, to: dep, kind: "hard" });
+    }
+    for (const dep of mod.softDeps) {
+        if (!nodes.has(dep)) {
+            nodes.set(dep, { name: dep, kind: "module", source: "soft-dep" });
+        }
+        edges.push({ from: moduleName, to: dep, kind: "soft" });
+    }
+    for (const coreName of mod.coreInherits) {
+        if (!nodes.has(coreName)) {
+            nodes.set(coreName, { name: coreName, kind: "core", source: "inherited" });
+        }
+        edges.push({ from: moduleName, to: coreName, kind: "inherit" });
+    }
+    for (const dep of mod.hardDeps) {
+        const depMod = moduleByName.get(dep);
+        if (!depMod)
+            continue;
+        for (const transitive of depMod.hardDeps) {
+            if (!nodes.has(transitive)) {
+                nodes.set(transitive, { name: transitive, kind: "module", source: "hard-dep" });
+            }
+            edges.push({ from: dep, to: transitive, kind: "hard" });
+        }
+        for (const coreName of depMod.coreInherits) {
+            if (!nodes.has(coreName)) {
+                nodes.set(coreName, { name: coreName, kind: "core", source: "inherited" });
+            }
+            edges.push({ from: dep, to: coreName, kind: "inherit" });
+        }
+    }
+    return {
+        nodes: [...nodes.values()],
+        edges,
+    };
+}
+export function renderAscii(graph, rootName) {
+    const lines = [];
+    const nodeMap = new Map(graph.nodes.map((n) => [n.name, n]));
+    lines.push(`Dependency graph for: ${rootName}`);
+    lines.push("");
+    const hardChildren = graph.edges
+        .filter((e) => e.from === rootName && e.kind === "hard")
+        .map((e) => e.to);
+    const softChildren = graph.edges
+        .filter((e) => e.from === rootName && e.kind === "soft")
+        .map((e) => e.to);
+    const inheritChildren = graph.edges
+        .filter((e) => e.from === rootName && e.kind === "inherit")
+        .map((e) => e.to);
+    const allChildren = [];
+    for (const c of hardChildren)
+        allChildren.push({ name: c, kind: "hard" });
+    for (const c of softChildren)
+        allChildren.push({ name: c, kind: "soft" });
+    for (const c of inheritChildren)
+        allChildren.push({ name: c, kind: "inherit" });
+    const seen = new Set();
+    const uniqueChildren = allChildren.filter((c) => {
+        if (seen.has(c.name))
+            return false;
+        seen.add(c.name);
+        return true;
+    });
+    lines.push(`${rootName} *`);
+    for (let i = 0; i < uniqueChildren.length; i++) {
+        const child = uniqueChildren[i];
+        const isLast = i === uniqueChildren.length - 1;
+        const prefix = isLast ? "└── " : "├── ";
+        const label = child.kind === "hard" ? " (hard)" : child.kind === "soft" ? " (soft)" : " [core]";
+        lines.push(`${prefix}${child.name}${label}`);
+    }
+    lines.push("");
+    lines.push("* = explicitly requested");
+    return lines.join("\n");
+}
+export function renderMermaid(graph, rootName) {
+    const lines = [];
+    lines.push("graph TD");
+    for (const node of graph.nodes) {
+        const id = node.name.replace(/[^a-zA-Z0-9]/g, "_");
+        if (node.kind === "core") {
+            lines.push(`  ${id}["${node.name}\\n[core]"]`);
+        }
+        else if (node.source === "explicit") {
+            lines.push(`  ${id}["${node.name}"]`);
+        }
+        else {
+            lines.push(`  ${id}("${node.name}")`);
+        }
+    }
+    lines.push("");
+    for (const edge of graph.edges) {
+        const fromId = edge.from.replace(/[^a-zA-Z0-9]/g, "_");
+        const toId = edge.to.replace(/[^a-zA-Z0-9]/g, "_");
+        if (edge.kind === "hard") {
+            lines.push(`  ${fromId} -->|hard| ${toId}`);
+        }
+        else if (edge.kind === "soft") {
+            lines.push(`  ${fromId} -.->|soft| ${toId}`);
+        }
+        else {
+            lines.push(`  ${fromId} -.->|inherits| ${toId}`);
+        }
+    }
+    return lines.join("\n");
+}

package/dist/core/graph.test.js

@@ -0,0 +1,62 @@
+import { strict as assert } from "node:assert";
+import { describe, it } from "node:test";
+import { loadCatalogFromRoot } from "./index.js";
+import { buildGraph, renderAscii, renderMermaid } from "./graph.js";
+import { fileURLToPath } from "node:url";
+const ROOT = fileURLToPath(new URL("../../", import.meta.url));
+describe("graph", () => {
+    it("builds graph for a module with deps", async () => {
+        const result = await loadCatalogFromRoot(ROOT, "loose");
+        assert.notEqual(result.value, null);
+        const graph = buildGraph(result.value, "billing");
+        assert.ok(graph.nodes.length > 0, "should have nodes");
+        assert.ok(graph.edges.length > 0, "should have edges");
+        const nodeNames = graph.nodes.map((n) => n.name);
+        assert.ok(nodeNames.includes("billing"), "should include root module");
+        assert.ok(nodeNames.includes("payments"), "should include hard dep");
+        assert.ok(nodeNames.includes("users"), "should include hard dep");
+    });
+    it("builds graph for a module with no deps", async () => {
+        const result = await loadCatalogFromRoot(ROOT, "loose");
+        assert.notEqual(result.value, null);
+        const graph = buildGraph(result.value, "catalog");
+        const nodeNames = graph.nodes.map((n) => n.name);
+        assert.ok(nodeNames.includes("catalog"), "should include root module");
+        assert.ok(!nodeNames.includes("payments"), "should not include unrelated modules");
+    });
+    it("returns empty graph for unknown module", async () => {
+        const result = await loadCatalogFromRoot(ROOT, "loose");
+        assert.notEqual(result.value, null);
+        const graph = buildGraph(result.value, "nonexistent");
+        assert.equal(graph.nodes.length, 0);
+        assert.equal(graph.edges.length, 0);
+    });
+    it("renders ASCII graph", async () => {
+        const result = await loadCatalogFromRoot(ROOT, "loose");
+        assert.notEqual(result.value, null);
+        const graph = buildGraph(result.value, "billing");
+        const ascii = renderAscii(graph, "billing");
+        assert.ok(ascii.includes("billing"), "should include root module name");
+        assert.ok(ascii.includes("payments"), "should include hard dep");
+        assert.ok(ascii.includes("users"), "should include hard dep");
+        assert.ok(ascii.includes("hard"), "should label hard deps");
+    });
+    it("renders Mermaid graph", async () => {
+        const result = await loadCatalogFromRoot(ROOT, "loose");
+        assert.notEqual(result.value, null);
+        const graph = buildGraph(result.value, "billing");
+        const mermaid = renderMermaid(graph, "billing");
+        assert.ok(mermaid.includes("graph TD"), "should start with graph TD");
+        assert.ok(mermaid.includes("-->"), "should have directed edges");
+        assert.ok(mermaid.includes("hard"), "should label hard deps");
+    });
+    it("includes core inheritance in graph", async () => {
+        const result = await loadCatalogFromRoot(ROOT, "loose");
+        assert.notEqual(result.value, null);
+        const graph = buildGraph(result.value, "assignments");
+        const nodeNames = graph.nodes.map((n) => n.name);
+        assert.ok(nodeNames.includes("runtime_standards"), "should include inherited core");
+        const coreNode = graph.nodes.find((n) => n.name === "runtime_standards");
+        assert.equal(coreNode?.kind, "core", "runtime_standards should be marked as core");
+    });
+});

package/dist/core/implement.js

@@ -0,0 +1,48 @@
+import { camelCase } from "../generators/types.js";
+export function generateImplementPrompts(catalog, adapters, moduleName, adapterName) {
+    const mod = catalog.modules.find((m) => m.name === moduleName);
+    if (!mod)
+        return [];
+    const adapter = adapters.find((a) => a.name === adapterName && a.module === moduleName);
+    if (!adapter)
+        return [];
+    const prompts = [];
+    for (const fn of mod.functions) {
+        if (!adapter.implements.includes(fn.name))
+            continue;
+        if (adapter.does_not_implement?.includes(fn.name))
+            continue;
+        prompts.push({
+            module: moduleName,
+            adapter: adapterName,
+            function: fn.name,
+            prompt: buildPrompt(fn, adapter, mod),
+        });
+    }
+    return prompts;
+}
+function buildPrompt(fn, adapter, mod) {
+    const params = fn.params.map((p) => {
+        const typeStr = p.type ? `: ${p.type}` : "";
+        return `${p.name}${p.optional ? "?" : ""}${typeStr}`;
+    }).join(", ");
+    const signature = `${camelCase(fn.name)}(${params}) → ${fn.returns}`;
+    const config = adapter.config.required.map((f) => `${f.name}: ${f.type}`).join(", ");
+    let prompt = `// Implement: ${mod.name}.${fn.name}
+// Contract: contracts/${mod.name}.md v${mod.version ?? "0.1.0"}
+// Adapter: ${adapter.name} → ${mod.name}
+// Signature: ${signature}
+
+Instructions:
+1. Implement ${camelCase(fn.name)} using the ${adapter.name} SDK
+2. The adapter is configured with: { ${config} }
+3. Follow the contract rules in contracts/${mod.name}.md
+4. Returns must match the contract type exactly`;
+    if (fn.returns !== "void") {
+        prompt += `\n5. Return type: ${fn.returns}`;
+    }
+    if (fn.params.length > 0) {
+        prompt += `\n6. Parameters: ${fn.params.map((p) => p.name).join(", ")}`;
+    }
+    return prompt;
+}

package/dist/core/index.js

@@ -0,0 +1,9 @@
+export * from "./catalog.js";
+export * from "./sections.js";
+export * from "./envelope.js";
+export * from "./section-body.js";
+export * from "./scanner.js";
+export * from "./discovery.js";
+export * from "./parse-document.js";
+export * from "./load-catalog.js";
+export * from "./collectors.js";

package/dist/core/load-catalog.js

@@ -0,0 +1,24 @@
+import { readFile } from "node:fs/promises";
+import { discoverContractFiles } from "./discovery.js";
+import { parseCatalogFromDocuments } from "./parse-document.js";
+export async function loadCatalogFromRoot(rootDir, mode) {
+    const { files, warnings: discoveryWarnings } = await discoverContractFiles(rootDir);
+    const documents = await Promise.all(files.map(async (file) => ({
+        file: file.file,
+        text: await readFile(file.file, "utf8"),
+    })));
+    const result = parseCatalogFromDocuments(documents, mode);
+    const discoveryIssues = discoveryWarnings.map((w) => ({
+        code: "UNSUPPORTED_SECTION",
+        file: "",
+        startLine: 0,
+        endLine: 0,
+        message: w.message,
+        severity: "warning",
+    }));
+    return {
+        value: result.value,
+        issues: [...discoveryIssues, ...result.issues],
+        discoveryWarnings,
+    };
+}