flex-md 4.7.2 → 4.7.4

package/dist-cjs/detect/json/detectPresence.cjs

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectJsonContainers = detectJsonContainers;
+exports.detectJsonPresence = detectJsonPresence;
+const RX_JSON_FENCE = /```json\s*\n([\s\S]*?)\n```/gi;
+const RX_JSON_MARKER = /(BEGIN_JSON|BEGIN\s+JSON)\s*\n([\s\S]*?)\n(END_JSON|END\s+JSON)/gi;
+// Very conservative raw JSON: must be only whitespace + object/array + whitespace
+const RX_RAW_JSON = /^\s*(\{[\s\S]*\}|\[[\s\S]*\])\s*$/;
+// Inline candidate finder
+const RX_INLINE_CANDIDATE = /(\{|\[)/g;
+function detectJsonContainers(md) {
+    const fences = [];
+    const markers = [];
+    RX_JSON_FENCE.lastIndex = 0;
+    RX_JSON_MARKER.lastIndex = 0;
+    let m;
+    while ((m = RX_JSON_FENCE.exec(md)) !== null) {
+        fences.push({
+            start: m.index,
+            end: m.index + m[0].length,
+            kind: "fence",
+            snippet: preview(m[0]),
+        });
+    }
+    while ((m = RX_JSON_MARKER.exec(md)) !== null) {
+        markers.push({
+            start: m.index,
+            end: m.index + m[0].length,
+            kind: "marker",
+            snippet: preview(m[0]),
+        });
+    }
+    return {
+        hasJsonFence: fences.length > 0,
+        hasJsonMarkers: markers.length > 0,
+        fences,
+        markers,
+    };
+}
+function detectJsonPresence(text, opts) {
+    const spans = [];
+    const kinds = new Set();
+    // 1) fenced json blocks
+    let m;
+    RX_JSON_FENCE.lastIndex = 0;
+    while ((m = RX_JSON_FENCE.exec(text)) !== null) {
+        kinds.add("fenced_json");
+        spans.push({
+            start: m.index,
+            end: m.index + m[0].length,
+            kind: "fence",
+            snippet: preview(m[0]),
+        });
+    }
+    // 2) BEGIN_JSON / END_JSON
+    RX_JSON_MARKER.lastIndex = 0;
+    while ((m = RX_JSON_MARKER.exec(text)) !== null) {
+        kinds.add("fenced_json");
+        spans.push({
+            start: m.index,
+            end: m.index + m[0].length,
+            kind: "marker",
+            snippet: preview(m[0]),
+        });
+    }
+    // 3) raw json (standalone)
+    if (RX_RAW_JSON.test(text) && looksLikeJson(text)) {
+        kinds.add("raw_json");
+        spans.push({ start: 0, end: text.length, kind: "raw", snippet: preview(text) });
+    }
+    else {
+        // 4) inline json-ish occurrences (best effort)
+        const inlineSpans = findInlineJsonishSpans(text);
+        if (inlineSpans.length) {
+            kinds.add("inline_json");
+            for (const s of inlineSpans)
+                spans.push(s);
+        }
+    }
+    const present = kinds.size > 0;
+    // Optional parse
+    const parse = !!opts?.parse;
+    if (!parse || !present) {
+        return { present, kinds: Array.from(kinds), spans };
+    }
+    const maxParses = opts?.maxParses ?? 3;
+    const parsedValues = [];
+    const errors = [];
+    const parseCandidates = spans
+        .map((s, i) => ({ s, i }))
+        .filter(x => x.s.kind === "fence" || x.s.kind === "raw" || x.s.kind === "inline")
+        .slice(0, maxParses);
+    for (const { s, i } of parseCandidates) {
+        const content = extractJsonText(text, s);
+        try {
+            parsedValues.push(JSON.parse(content));
+        }
+        catch (e) {
+            errors.push({ spanIndex: i, message: String(e?.message ?? e) });
+            if (looksLikeJson(content))
+                kinds.add("json_like");
+        }
+    }
+    return {
+        present,
+        kinds: Array.from(kinds),
+        spans,
+        parsed: {
+            ok: errors.length === 0 && parsedValues.length > 0,
+            values: parsedValues,
+            errors: errors.length ? errors : undefined,
+        },
+    };
+}
+function extractJsonText(full, span) {
+    const slice = full.slice(span.start, span.end);
+    if (span.kind === "fence") {
+        const m = slice.match(/^```json\s*\n([\s\S]*?)\n```$/i);
+        if (m)
+            return m[1] ?? "";
+    }
+    if (span.kind === "marker") {
+        const m = slice.match(/(BEGIN_JSON|BEGIN\s+JSON)\s*\n([\s\S]*?)\n(END_JSON|END\s+JSON)/i);
+        if (m)
+            return m[2] ?? "";
+    }
+    return slice;
+}
+function looksLikeJson(s) {
+    const t = s.trim();
+    if (!t)
+        return false;
+    if ((t.startsWith("{") && t.endsWith("}")) || (t.startsWith("[") && t.endsWith("]")))
+        return true;
+    return false;
+}
+function findInlineJsonishSpans(text) {
+    const spans = [];
+    const maxLen = 5000;
+    const masked = maskNonJsonCodeFences(text);
+    let m;
+    RX_INLINE_CANDIDATE.lastIndex = 0;
+    while ((m = RX_INLINE_CANDIDATE.exec(masked)) !== null) {
+        const start = m.index;
+        const open = masked[start];
+        const close = open === "{" ? "}" : "]";
+        let depth = 0;
+        let end = -1;
+        for (let i = start; i < Math.min(masked.length, start + maxLen); i++) {
+            const ch = masked[i];
+            if (ch === open)
+                depth++;
+            else if (ch === close) {
+                depth--;
+                if (depth === 0) {
+                    end = i + 1;
+                    break;
+                }
+            }
+        }
+        if (end > start) {
+            const snippet = text.slice(start, Math.min(end, start + 300));
+            if (snippet.trim().length >= 5) {
+                spans.push({ start, end, kind: "inline", snippet: preview(text.slice(start, end)) });
+            }
+            RX_INLINE_CANDIDATE.lastIndex = end;
+        }
+    }
+    return squashOverlaps(spans);
+}
+function maskNonJsonCodeFences(text) {
+    const rx = /```(\w+)?\s*\n([\s\S]*?)\n```/g;
+    return text.replace(rx, (full, lang) => {
+        const l = String(lang ?? "").toLowerCase();
+        if (l === "json")
+            return full;
+        return " ".repeat(full.length);
+    });
+}
+function squashOverlaps(spans) {
+    spans.sort((a, b) => a.start - b.start || (b.end - b.start) - (a.end - a.start));
+    const out = [];
+    let last = null;
+    for (const s of spans) {
+        if (!last || s.start >= last.end) {
+            out.push(s);
+            last = s;
+        }
+    }
+    return out;
+}
+function preview(s, n = 160) {
+    const t = s.replace(/\s+/g, " ").trim();
+    return t.length > n ? t.slice(0, n - 1) + "…" : t;
+}

package/dist-cjs/detect/json/index.cjs

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectJsonPresence = exports.detectJsonContainers = exports.detectJsonIntent = void 0;
+exports.detectJsonAll = detectJsonAll;
+const detectIntent_js_1 = require("./detectIntent.cjs");
+const detectPresence_js_1 = require("./detectPresence.cjs");
+__exportStar(require("./types.cjs"), exports);
+var detectIntent_js_2 = require("./detectIntent.cjs");
+Object.defineProperty(exports, "detectJsonIntent", { enumerable: true, get: function () { return detectIntent_js_2.detectJsonIntent; } });
+var detectPresence_js_2 = require("./detectPresence.cjs");
+Object.defineProperty(exports, "detectJsonContainers", { enumerable: true, get: function () { return detectPresence_js_2.detectJsonContainers; } });
+Object.defineProperty(exports, "detectJsonPresence", { enumerable: true, get: function () { return detectPresence_js_2.detectJsonPresence; } });
+__exportStar(require("./detectMarkdown.cjs"), exports);
+function detectJsonAll(textOrMd, opts) {
+    return {
+        intent: (0, detectIntent_js_1.detectJsonIntent)(textOrMd),
+        containers: (0, detectPresence_js_1.detectJsonContainers)(textOrMd),
+        presence: (0, detectPresence_js_1.detectJsonPresence)(textOrMd, { parse: !!opts?.parseJson }),
+    };
+}

package/dist-cjs/detect/json/types.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist-cjs/extract/extract.cjs

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractFromMarkdown = extractFromMarkdown;
+const parse_js_1 = require("../md/parse.cjs");
+/**
+ * Extracts sections, lists, and tables from Markdown based on the OFS.
+ */
+function extractFromMarkdown(md, spec) {
+    // 0. Robustness: check for fenced block that might contain the target content
+    // Highly relevant for LLM responses where the model occasionally wraps everything in a container
+    // even if not strictly asked, or if the user provided unframed content but we have L2+ expectations elsewhere.
+    const rxFence = /```(?:markdown|flexmd)?\s*\n([\s\S]*?)\n```/gi;
+    const matches = Array.from(md.matchAll(rxFence));
+    let workingContent = md;
+    if (matches.length === 1) {
+        const content = matches[0][1];
+        // If the content inside the fence has more required sections than outside, use it
+        const parsedOutside = (0, parse_js_1.parseHeadingsAndSections)(md);
+        const parsedInside = (0, parse_js_1.parseHeadingsAndSections)(content);
+        const specNorms = new Set(spec.sections.map(s => (0, parse_js_1.normalizeName)(s.name)));
+        const countOutside = parsedOutside.filter(p => specNorms.has((0, parse_js_1.normalizeName)(p.heading.name))).length;
+        const countInside = parsedInside.filter(p => specNorms.has((0, parse_js_1.normalizeName)(p.heading.name))).length;
+        if (countInside >= countOutside && countInside > 0) {
+            workingContent = content;
+        }
+    }
+    const bulletNames = spec.sections.map(s => s.name);
+    const parsed = (0, parse_js_1.parseHeadingsAndSections)(workingContent, { bulletNames });
+    const sectionsByName = {};
+    const tables = [];
+    const specMap = new Map(spec.sections.map(s => [(0, parse_js_1.normalizeName)(s.name), s]));
+    for (const p of parsed) {
+        const norm = (0, parse_js_1.normalizeName)(p.heading.name);
+        const sSpec = specMap.get(norm);
+        if (sSpec) {
+            const body = p.body.trim();
+            let list;
+            if (sSpec.kind === "list" || sSpec.kind === "ordered_list") {
+                const bullets = (0, parse_js_1.extractBullets)(body);
+                if (bullets.length > 0) {
+                    list = {
+                        kind: "list",
+                        ordered: sSpec.kind === "ordered_list",
+                        items: bullets.map(b => ({ text: b, children: [] }))
+                    };
+                }
+            }
+            // Merge if duplicate heading (standard policy for extraction)
+            if (sectionsByName[sSpec.name]) {
+                sectionsByName[sSpec.name].md += "\n\n" + body;
+                if (list && sectionsByName[sSpec.name].list) {
+                    sectionsByName[sSpec.name].list.items.push(...list.items);
+                }
+            }
+            else {
+                sectionsByName[sSpec.name] = {
+                    nodeKey: norm,
+                    nodeLevel: p.heading.level,
+                    md: body,
+                    list
+                };
+            }
+        }
+    }
+    // Table extraction logic (simplified for now)
+    // In a full impl, we'd search section bodies for tables.
+    return {
+        outline: { type: "md_outline", nodes: [] }, // Simplified outline
+        sectionsByName,
+        tables
+    };
+}

package/dist-cjs/extract/types.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist-cjs/flex-md-loader.cjs

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * Flex-MD Loader - ES Module Compatible Dynamic Import
+ *
+ * This module provides ES module compatible dynamic loading of the flex-md library,
+ * handling the case where dependencies might use require() in ES module environments.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractJsonFromFlexMd = extractJsonFromFlexMd;
+exports.extractWithOfs = extractWithOfs;
+exports.loadFlexMd = loadFlexMd;
+/**
+ * Dynamically loads the flex-md library with ES module compatibility.
+ * Handles both ES module and CommonJS loading patterns.
+ */
+async function loadFlexMd() {
+    try {
+        // First, try direct ES module import (preferred for modern environments)
+        const flexMdModule = await Promise.resolve().then(() => require('flex-md'));
+        return flexMdModule;
+    }
+    catch (esError) {
+        try {
+            // Fallback: Use Node.js createRequire for CommonJS compatibility
+            // This handles cases where flex-md or its dependencies use require()
+            const { createRequire } = await Promise.resolve().then(() => require('module'));
+            const require = createRequire(import.meta.url);
+            const flexMdModule = require('flex-md');
+            return flexMdModule;
+        }
+        catch (cjsError) {
+            // If both fail, try the dynamic Function approach as last resort
+            try {
+                const importFunc = new Function('specifier', 'return import(specifier)');
+                const flexMdModule = await importFunc('flex-md');
+                return flexMdModule;
+            }
+            catch (dynamicError) {
+                throw new Error(`flex-md import failed: ES module error: ${esError instanceof Error ? esError.message : String(esError)}, ` +
+                    `CommonJS fallback error: ${cjsError instanceof Error ? cjsError.message : String(cjsError)}, ` +
+                    `Dynamic import error: ${dynamicError instanceof Error ? dynamicError.message : String(dynamicError)}`);
+            }
+        }
+    }
+}
+/**
+ * Extracts structured JSON from markdown content using flex-md.
+ *
+ * @param content - The markdown content to parse
+ * @param spec - Optional Output Format Specification
+ * @param options - Extraction options
+ * @returns Promise resolving to extraction result
+ */
+async function extractJsonFromFlexMd(content, spec, options = {}) {
+    try {
+        // Load flex-md library with compatibility handling
+        const flexMd = await loadFlexMd();
+        // Use the markdownToJson function for basic structured extraction
+        // This handles markdown with sections like # Short answer, # Full answer, etc.
+        const json = flexMd.markdownToJson(content);
+        return {
+            json,
+            success: true
+        };
+    }
+    catch (error) {
+        console.warn('Flex-md extraction failed - flex-md library compatibility issue');
+        console.warn('Error:', error instanceof Error ? error.message : String(error));
+        console.warn('Issue: flex-md uses require() in ES module context - needs fixing in flex-md-loader.ts');
+        return {
+            json: { rawText: content },
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown extraction error'
+        };
+    }
+}
+/**
+ * Alternative extraction using transformWithOfs if a spec is provided.
+ * This provides more structured extraction when an Output Format Spec is available.
+ */
+async function extractWithOfs(content, spec, options = {}) {
+    try {
+        const flexMd = await loadFlexMd();
+        // If spec is provided, use the more advanced transformWithOfs
+        if (spec && flexMd.transformWithOfs) {
+            const result = flexMd.transformWithOfs(content, spec);
+            return {
+                json: result,
+                success: true
+            };
+        }
+        else {
+            // Fallback to basic markdownToJson
+            return extractJsonFromFlexMd(content, spec, options);
+        }
+    }
+    catch (error) {
+        console.warn('Flex-md OFS extraction failed:', error instanceof Error ? error.message : String(error));
+        // Fallback to basic extraction
+        return extractJsonFromFlexMd(content, spec, options);
+    }
+}

package/dist-cjs/index.cjs

@@ -0,0 +1,79 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonToMarkdown = exports.Schema = exports.MarkdownParser = exports.JSONTransformer = exports.enforceFlexMd = exports.repairToMarkdownLevel = exports.detectResponseKind = exports.buildIssuesEnvelopeAuto = exports.buildIssuesEnvelope = exports.parseIssuesEnvelope = exports.processResponseMarkdown = exports.extractFromMarkdown = exports.checkConnection = exports.hasFlexMdContract = exports.checkCompliance = exports.validateMarkdownAgainstOfs = exports.enrichInstructionsWithFlexMd = exports.enrichInstructions = exports.buildMarkdownGuidance = exports.stringifyOutputFormatSpec = exports.recall = exports.remember = exports.transformWithOfs = exports.ofsToSchema = exports.validateFormat = exports.parseFormatSpecs = exports.parseInputFormatSpec = exports.parseOutputFormatSpec = exports.buildOutline = exports.logger = void 0;
+// Core SFMD Types
+__exportStar(require("./types.cjs"), exports);
+__exportStar(require("./strictness/types.cjs"), exports);
+// Logging
+var logger_js_1 = require("./logger.cjs");
+Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return logger_js_1.logger; } });
+// Shared MD Parsing
+__exportStar(require("./md/parse.cjs"), exports);
+var outline_js_1 = require("./md/outline.cjs");
+Object.defineProperty(exports, "buildOutline", { enumerable: true, get: function () { return outline_js_1.buildOutline; } });
+// Output Format Spec (OFS)
+var parser_js_1 = require("./ofs/parser.cjs");
+Object.defineProperty(exports, "parseOutputFormatSpec", { enumerable: true, get: function () { return parser_js_1.parseOutputFormatSpec; } });
+Object.defineProperty(exports, "parseInputFormatSpec", { enumerable: true, get: function () { return parser_js_1.parseInputFormatSpec; } });
+Object.defineProperty(exports, "parseFormatSpecs", { enumerable: true, get: function () { return parser_js_1.parseFormatSpecs; } });
+Object.defineProperty(exports, "validateFormat", { enumerable: true, get: function () { return parser_js_1.validateFormat; } });
+var adapter_js_1 = require("./ofs/adapter.cjs");
+Object.defineProperty(exports, "ofsToSchema", { enumerable: true, get: function () { return adapter_js_1.ofsToSchema; } });
+Object.defineProperty(exports, "transformWithOfs", { enumerable: true, get: function () { return adapter_js_1.transformWithOfs; } });
+var memory_js_1 = require("./ofs/memory.cjs");
+Object.defineProperty(exports, "remember", { enumerable: true, get: function () { return memory_js_1.remember; } });
+Object.defineProperty(exports, "recall", { enumerable: true, get: function () { return memory_js_1.recall; } });
+var stringify_js_1 = require("./ofs/stringify.cjs");
+Object.defineProperty(exports, "stringifyOutputFormatSpec", { enumerable: true, get: function () { return stringify_js_1.stringifyOutputFormatSpec; } });
+var enricher_js_1 = require("./ofs/enricher.cjs");
+Object.defineProperty(exports, "buildMarkdownGuidance", { enumerable: true, get: function () { return enricher_js_1.buildMarkdownGuidance; } });
+Object.defineProperty(exports, "enrichInstructions", { enumerable: true, get: function () { return enricher_js_1.enrichInstructions; } });
+Object.defineProperty(exports, "enrichInstructionsWithFlexMd", { enumerable: true, get: function () { return enricher_js_1.enrichInstructionsWithFlexMd; } });
+// Validation & Extraction
+var validate_js_1 = require("./validate/validate.cjs");
+Object.defineProperty(exports, "validateMarkdownAgainstOfs", { enumerable: true, get: function () { return validate_js_1.validateMarkdownAgainstOfs; } });
+var compliance_js_1 = require("./validate/compliance.cjs");
+Object.defineProperty(exports, "checkCompliance", { enumerable: true, get: function () { return compliance_js_1.checkCompliance; } });
+Object.defineProperty(exports, "hasFlexMdContract", { enumerable: true, get: function () { return compliance_js_1.hasFlexMdContract; } });
+var connection_js_1 = require("./validate/connection.cjs");
+Object.defineProperty(exports, "checkConnection", { enumerable: true, get: function () { return connection_js_1.checkConnection; } });
+var extract_js_1 = require("./extract/extract.cjs");
+Object.defineProperty(exports, "extractFromMarkdown", { enumerable: true, get: function () { return extract_js_1.extractFromMarkdown; } });
+// Processor & Fallback
+var processor_js_1 = require("./strictness/processor.cjs");
+Object.defineProperty(exports, "processResponseMarkdown", { enumerable: true, get: function () { return processor_js_1.processResponseMarkdown; } });
+var issuesEnvelope_js_1 = require("./ofs/issuesEnvelope.cjs");
+Object.defineProperty(exports, "parseIssuesEnvelope", { enumerable: true, get: function () { return issuesEnvelope_js_1.parseIssuesEnvelope; } });
+Object.defineProperty(exports, "buildIssuesEnvelope", { enumerable: true, get: function () { return issuesEnvelope_js_1.buildIssuesEnvelope; } });
+Object.defineProperty(exports, "buildIssuesEnvelopeAuto", { enumerable: true, get: function () { return issuesEnvelope_js_1.buildIssuesEnvelopeAuto; } });
+// Pipeline
+var kind_js_1 = require("./pipeline/kind.cjs");
+Object.defineProperty(exports, "detectResponseKind", { enumerable: true, get: function () { return kind_js_1.detectResponseKind; } });
+var repair_js_1 = require("./pipeline/repair.cjs");
+Object.defineProperty(exports, "repairToMarkdownLevel", { enumerable: true, get: function () { return repair_js_1.repairToMarkdownLevel; } });
+var enforce_js_1 = require("./pipeline/enforce.cjs");
+Object.defineProperty(exports, "enforceFlexMd", { enumerable: true, get: function () { return enforce_js_1.enforceFlexMd; } });
+// JSON Detection
+__exportStar(require("./detect/json/index.cjs"), exports);
+// Token Estimation
+__exportStar(require("./tokens/index.cjs"), exports);
+// NX-MD-Parser Integration (Structured MD -> JSON)
+var nx_md_parser_1 = require("nx-md-parser");
+Object.defineProperty(exports, "JSONTransformer", { enumerable: true, get: function () { return nx_md_parser_1.JSONTransformer; } });
+Object.defineProperty(exports, "MarkdownParser", { enumerable: true, get: function () { return nx_md_parser_1.MarkdownParser; } });
+Object.defineProperty(exports, "Schema", { enumerable: true, get: function () { return nx_md_parser_1.Schema; } });
+Object.defineProperty(exports, "jsonToMarkdown", { enumerable: true, get: function () { return nx_md_parser_1.jsonToMarkdown; } });

package/dist-cjs/logger.cjs

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.threshold = exports.logger = void 0;
+const micro_logs_1 = require("micro-logs");
+// Get DEBUG_LEVEL from environment, default to 'info'
+const debugLevel = process.env.DEBUG_LEVEL || 'info';
+// Map string levels to micro-logs levels
+const levelMapping = {
+    'verbose': 'verbose',
+    'debug': 'debug',
+    'info': 'info',
+    'warn': 'warn',
+    'error': 'error'
+};
+// Default to 'info' if invalid level provided
+const threshold = levelMapping[debugLevel.toLowerCase()] || 'info';
+exports.threshold = threshold;
+exports.logger = new micro_logs_1.Logger({
+    packageName: 'flex-md',
+    envPrefix: 'FLEX_MD',
+    debugNamespace: 'flex-md:*'
+});

package/dist-cjs/md/match.cjs

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchSections = matchSections;
+/**
+ * Matches sections from the outline against required section names.
+ * Supports merging multiple nodes of the same name and selecting highest-level matches.
+ */
+function matchSections(outline, sectionNames, strategy = "merge") {
+    const normalizedTargets = new Map(sectionNames.map(n => [norm(n), n]));
+    const found = new Map();
+    walk(outline.nodes, (node) => {
+        const k = norm(node.title);
+        if (normalizedTargets.has(k)) {
+            if (!found.has(k))
+                found.set(k, []);
+            found.get(k).push(node);
+        }
+    });
+    const res = new Map();
+    for (const [nk, originalName] of normalizedTargets.entries()) {
+        const nodes = found.get(nk) ?? [];
+        if (!nodes.length)
+            continue;
+        // choose highest-level (smallest level number)
+        const minLevel = Math.min(...nodes.map(n => n.level));
+        const top = nodes.filter(n => n.level === minLevel);
+        let chosen;
+        if (strategy === "first") {
+            chosen = [top[0]];
+        }
+        else {
+            chosen = top; // merge same-level matches
+        }
+        const merged = chosen.map(n => n.content_md).join("\n").trimEnd() + "\n";
+        res.set(originalName, { name: originalName, nodes, chosen, mergedContent: merged });
+    }
+    return res;
+}
+function walk(nodes, fn) {
+    for (const n of nodes) {
+        fn(n);
+        walk(n.children, fn);
+    }
+}
+function norm(s) {
+    return s.trim().replace(/[:\-–—]\s*$/, "").trim().toLowerCase();
+}

package/dist-cjs/md/normalize.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeMarkdownInput = normalizeMarkdownInput;
+/**
+ * Centralized normalization for Markdown input.
+ * Handles common LLM output artifacts like literal \n.
+ */
+function normalizeMarkdownInput(md) {
+    if (!md)
+        return "";
+    // Handle literal \n common in LLM outputs delivered via JSON
+    return md.replace(/\\n/g, "\n");
+}

package/dist-cjs/md/outline.cjs

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildOutline = buildOutline;
+exports.slugify = slugify;
+const parse_js_1 = require("./parse.cjs");
+/**
+ * Builds a nested tree of headings (outline) from Markdown text.
+ */
+function buildOutline(md) {
+    const sections = (0, parse_js_1.parseHeadingsAndSections)(md);
+    const roots = [];
+    const stack = [];
+    for (const s of sections) {
+        const h = s.heading;
+        const node = {
+            title: h.name,
+            level: h.level,
+            key: h.norm,
+            content_md: s.body,
+            children: []
+        };
+        // Pop from stack until we find a parent (level < node.level)
+        while (stack.length > 0 && stack[stack.length - 1].level >= node.level) {
+            stack.pop();
+        }
+        if (stack.length === 0) {
+            roots.push(node);
+        }
+        else {
+            stack[stack.length - 1].children.push(node);
+        }
+        stack.push(node);
+    }
+    return {
+        type: "md_outline",
+        nodes: roots
+    };
+}
+/**
+ * Slugifies a string into an internal key.
+ */
+function slugify(text) {
+    return text
+        .toLowerCase()
+        .trim()
+        .replace(/[^\w\s-]/g, "")
+        .replace(/[\s_-]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}