flex-md 4.5.3 → 4.5.4

package/dist/__tests__/diagnostics.test.js

@@ -1,59 +1,61 @@
-import { describe, it, expect } from "vitest";
-import { checkCompliance, hasFlexMdContract, enrichInstructionsWithFlexMd, validateFormat } from "../index.js";
-describe("Diagnostics", () => {
-    describe("checkCompliance", () => {
-        it("should return meetsCompliance: true for L0 if Markdown is mentioned", async () => {
-            const res = await checkCompliance("Reply in Markdown.", "L0");
-            expect(res.meetsCompliance).toBe(true);
-            expect(res.issues).toHaveLength(0);
-        });
-        it("should return issues for L2 if container is missing", async () => {
-            const res = await checkCompliance("Reply in Markdown. Include headings.", "L2");
-            expect(res.meetsCompliance).toBe(false);
-            expect(res.issues.some(i => i.type === "missing-container")).toBe(true);
-        });
-        it("should return false for hasFlexMdContract if requirements not met", async () => {
-            const ok = await hasFlexMdContract("Hello", "L0");
-            expect(ok).toBe(false);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const index_js_1 = require("../index.js");
+(0, vitest_1.describe)("Diagnostics", () => {
+    (0, vitest_1.describe)("checkCompliance", () => {
+        (0, vitest_1.it)("should return meetsCompliance: true for L0 if Markdown is mentioned", async () => {
+            const res = await (0, index_js_1.checkCompliance)("Reply in Markdown.", "L0");
+            (0, vitest_1.expect)(res.meetsCompliance).toBe(true);
+            (0, vitest_1.expect)(res.issues).toHaveLength(0);
+        });
+        (0, vitest_1.it)("should return issues for L2 if container is missing", async () => {
+            const res = await (0, index_js_1.checkCompliance)("Reply in Markdown. Include headings.", "L2");
+            (0, vitest_1.expect)(res.meetsCompliance).toBe(false);
+            (0, vitest_1.expect)(res.issues.some(i => i.type === "missing-container")).toBe(true);
+        });
+        (0, vitest_1.it)("should return false for hasFlexMdContract if requirements not met", async () => {
+            const ok = await (0, index_js_1.hasFlexMdContract)("Hello", "L0");
+            (0, vitest_1.expect)(ok).toBe(false);
         });
     });
-    describe("enrichInstructionsWithFlexMd", () => {
-        it("should append guidance to existing instructions", async () => {
-            const res = await enrichInstructionsWithFlexMd("Do a good job.", "L0");
-            expect(res.enriched).toContain("Do a good job.");
-            expect(res.enriched).toContain("Reply in Markdown.");
-            expect(res.changes).toHaveLength(1);
-            expect(res.metadata?.guidanceAdded).toBe(true);
-        });
-        it("should track container addition for L2", async () => {
-            const res = await enrichInstructionsWithFlexMd("Do a good job.", "L2");
-            expect(res.changes.some(c => c.type === "added-container")).toBe(true);
-            expect(res.metadata?.containerAdded).toBe(true);
+    (0, vitest_1.describe)("enrichInstructionsWithFlexMd", () => {
+        (0, vitest_1.it)("should append guidance to existing instructions", async () => {
+            const res = await (0, index_js_1.enrichInstructionsWithFlexMd)("Do a good job.", "L0");
+            (0, vitest_1.expect)(res.enriched).toContain("Do a good job.");
+            (0, vitest_1.expect)(res.enriched).toContain("Reply in Markdown.");
+            (0, vitest_1.expect)(res.changes).toHaveLength(1);
+            (0, vitest_1.expect)(res.metadata?.guidanceAdded).toBe(true);
+        });
+        (0, vitest_1.it)("should track container addition for L2", async () => {
+            const res = await (0, index_js_1.enrichInstructionsWithFlexMd)("Do a good job.", "L2");
+            (0, vitest_1.expect)(res.changes.some(c => c.type === "added-container")).toBe(true);
+            (0, vitest_1.expect)(res.metadata?.containerAdded).toBe(true);
         });
     });
-    describe("validateFormat", () => {
-        it("should validate a correct flex-md OFS", async () => {
+    (0, vitest_1.describe)("validateFormat", () => {
+        (0, vitest_1.it)("should validate a correct flex-md OFS", async () => {
             const ofs = `## Output format\n- Summary — prose\n- Actions — list`;
-            const res = await validateFormat(ofs);
-            expect(res.valid).toBe(true);
-            expect(res.metadata?.sectionCount).toBe(2);
+            const res = await (0, index_js_1.validateFormat)(ofs);
+            (0, vitest_1.expect)(res.valid).toBe(true);
+            (0, vitest_1.expect)(res.metadata?.sectionCount).toBe(2);
         });
-        it("should return errors for missing heading", async () => {
+        (0, vitest_1.it)("should return errors for missing heading", async () => {
             const ofs = `- Summary — prose`;
-            const res = await validateFormat(ofs);
-            expect(res.valid).toBe(false);
-            expect(res.issues.some(i => i.type === "missing-heading")).toBe(true);
+            const res = await (0, index_js_1.validateFormat)(ofs);
+            (0, vitest_1.expect)(res.valid).toBe(false);
+            (0, vitest_1.expect)(res.issues.some(i => i.type === "missing-heading")).toBe(true);
         });
-        it("should validate JSON schema", async () => {
+        (0, vitest_1.it)("should validate JSON schema", async () => {
             const schema = `{"type": "object"}`;
-            const res = await validateFormat(schema, "json-schema");
-            expect(res.valid).toBe(true);
+            const res = await (0, index_js_1.validateFormat)(schema, "json-schema");
+            (0, vitest_1.expect)(res.valid).toBe(true);
         });
-        it("should fail on invalid JSON schema", async () => {
+        (0, vitest_1.it)("should fail on invalid JSON schema", async () => {
             const schema = `{"type": "object"`;
-            const res = await validateFormat(schema, "json-schema");
-            expect(res.valid).toBe(false);
-            expect(res.issues[0].type).toBe("syntax-error");
+            const res = await (0, index_js_1.validateFormat)(schema, "json-schema");
+            (0, vitest_1.expect)(res.valid).toBe(false);
+            (0, vitest_1.expect)(res.issues[0].type).toBe("syntax-error");
         });
     });
 });

package/dist/__tests__/ofs.test.js

@@ -1,7 +1,9 @@
-import { describe, it, expect } from "vitest";
-import { stringifyOutputFormatSpec } from "../ofs/stringify.js";
-import { buildMarkdownGuidance } from "../ofs/enricher.js";
-describe("Instructions Output Format Block Generation", () => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const stringify_js_1 = require("../ofs/stringify.js");
+const enricher_js_1 = require("../ofs/enricher.js");
+(0, vitest_1.describe)("Instructions Output Format Block Generation", () => {
     const spec = {
         description: "Standard report format for technical analysis.",
         sections: [
@@ -21,31 +23,31 @@ describe("Instructions Output Format Block Generation", () => {
         ],
         emptySectionValue: "N/A"
     };
-    it("should stringify an OFS object correctly", () => {
-        const md = stringifyOutputFormatSpec(spec);
-        expect(md).toContain("## Output format (Markdown)");
-        expect(md).toContain("Standard report format for technical analysis.");
-        expect(md).toContain("- Summary — text (required)");
-        expect(md).toContain("Description: A brief summary of the topic.");
-        expect(md).toContain("Instruction: Keep it under 3 sentences.");
-        expect(md).toContain("- Key Points — list (optional)");
-        expect(md).toContain("Description: Important takeaways.");
-        expect(md).toContain("If a section is empty, write `N/A`.");
+    (0, vitest_1.it)("should stringify an OFS object correctly", () => {
+        const md = (0, stringify_js_1.stringifyOutputFormatSpec)(spec);
+        (0, vitest_1.expect)(md).toContain("## Output format (Markdown)");
+        (0, vitest_1.expect)(md).toContain("Standard report format for technical analysis.");
+        (0, vitest_1.expect)(md).toContain("- Summary — text (required)");
+        (0, vitest_1.expect)(md).toContain("Description: A brief summary of the topic.");
+        (0, vitest_1.expect)(md).toContain("Instruction: Keep it under 3 sentences.");
+        (0, vitest_1.expect)(md).toContain("- Key Points — list (optional)");
+        (0, vitest_1.expect)(md).toContain("Description: Important takeaways.");
+        (0, vitest_1.expect)(md).toContain("If a section is empty, write `N/A`.");
     });
-    it("should build markdown guidance (L1) correctly", () => {
-        const guidance = buildMarkdownGuidance(spec, { level: 1 });
-        expect(guidance).toContain("Include these section headings somewhere");
-        expect(guidance).toContain("- Summary");
-        expect(guidance).toContain("Description: A brief summary of the topic.");
-        expect(guidance).toContain("Instruction: Keep it under 3 sentences.");
-        expect(guidance).toContain("- Key Points");
-        expect(guidance).toContain("Description: Important takeaways.");
+    (0, vitest_1.it)("should build markdown guidance (L1) correctly", () => {
+        const guidance = (0, enricher_js_1.buildMarkdownGuidance)(spec, { level: 1 });
+        (0, vitest_1.expect)(guidance).toContain("Include these section headings somewhere");
+        (0, vitest_1.expect)(guidance).toContain("- Summary");
+        (0, vitest_1.expect)(guidance).toContain("Description: A brief summary of the topic.");
+        (0, vitest_1.expect)(guidance).toContain("Instruction: Keep it under 3 sentences.");
+        (0, vitest_1.expect)(guidance).toContain("- Key Points");
+        (0, vitest_1.expect)(guidance).toContain("Description: Important takeaways.");
     });
-    it("should build markdown guidance (L3) correctly", () => {
-        const guidance = buildMarkdownGuidance(spec, { level: 3 });
-        expect(guidance).toContain("Return your entire answer inside a single ```markdown fenced block");
-        expect(guidance).toContain("- Summary");
-        expect(guidance).toContain("- Key Points (list)");
-        expect(guidance).toContain("Do not return JSON");
+    (0, vitest_1.it)("should build markdown guidance (L3) correctly", () => {
+        const guidance = (0, enricher_js_1.buildMarkdownGuidance)(spec, { level: 3 });
+        (0, vitest_1.expect)(guidance).toContain("Return your entire answer inside a single ```markdown fenced block");
+        (0, vitest_1.expect)(guidance).toContain("- Summary");
+        (0, vitest_1.expect)(guidance).toContain("- Key Points (list)");
+        (0, vitest_1.expect)(guidance).toContain("Do not return JSON");
     });
 });

package/dist/__tests__/structural.test.js

@@ -1,28 +1,30 @@
-import { describe, it, expect } from "vitest";
-import { buildOutline, checkConnection } from "../index.js";
-describe("Structural Diagnostics", () => {
-    describe("===key support", () => {
-        it("should parse ===key as a top-level section", () => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const index_js_1 = require("../index.js");
+(0, vitest_1.describe)("Structural Diagnostics", () => {
+    (0, vitest_1.describe)("===key support", () => {
+        (0, vitest_1.it)("should parse ===key as a top-level section", () => {
             const md = `===skills\nThis is the skills section.\n\n## Subskill\nDetails.`;
-            const outline = buildOutline(md);
-            expect(outline.nodes).toHaveLength(1);
-            expect(outline.nodes[0].title).toBe("skills");
-            expect(outline.nodes[0].children).toHaveLength(1);
-            expect(outline.nodes[0].children[0].title).toBe("Subskill");
+            const outline = (0, index_js_1.buildOutline)(md);
+            (0, vitest_1.expect)(outline.nodes).toHaveLength(1);
+            (0, vitest_1.expect)(outline.nodes[0].title).toBe("skills");
+            (0, vitest_1.expect)(outline.nodes[0].children).toHaveLength(1);
+            (0, vitest_1.expect)(outline.nodes[0].children[0].title).toBe("Subskill");
         });
     });
-    describe("checkConnection", () => {
-        it("should find a section by name", () => {
+    (0, vitest_1.describe)("checkConnection", () => {
+        (0, vitest_1.it)("should find a section by name", () => {
             const md = `# Overview\n## Details\n===skills\nContent.`;
-            const res = checkConnection(md, "skills");
-            expect(res.connected).toBe(true);
-            expect(res.path).toContain("skills");
+            const res = (0, index_js_1.checkConnection)(md, "skills");
+            (0, vitest_1.expect)(res.connected).toBe(true);
+            (0, vitest_1.expect)(res.path).toContain("skills");
         });
-        it("should fail gracefully for missing sections", () => {
+        (0, vitest_1.it)("should fail gracefully for missing sections", () => {
             const md = `# Overview`;
-            const res = checkConnection(md, "missing");
-            expect(res.connected).toBe(false);
-            expect(res.suggestion).toContain("Overview");
+            const res = (0, index_js_1.checkConnection)(md, "missing");
+            (0, vitest_1.expect)(res.connected).toBe(false);
+            (0, vitest_1.expect)(res.suggestion).toContain("Overview");
         });
     });
 });

package/dist/__tests__/validate.test.js

@@ -1,6 +1,8 @@
-import { describe, it, expect } from "vitest";
-import { validateMarkdownAgainstOfs } from "../validate/validate.js";
-import { parseIssuesEnvelope } from "../ofs/issuesEnvelope.js";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const validate_js_1 = require("../validate/validate.js");
+const issuesEnvelope_js_1 = require("../ofs/issuesEnvelope.js");
 const SPEC = {
     emptySectionValue: "None",
     sections: [
@@ -30,8 +32,8 @@ function mdL1Good() {
         "- U",
     ].join("\n");
 }
-describe("parseIssuesEnvelope()", () => {
-    it("detects envelope and extracts bullets", () => {
+(0, vitest_1.describe)("parseIssuesEnvelope()", () => {
+    (0, vitest_1.it)("detects envelope and extracts bullets", () => {
         const env = [
             "## Status",
             "Non-compliant output (cannot be repaired to the required format).",
@@ -48,17 +50,17 @@ describe("parseIssuesEnvelope()", () => {
             "## How to fix",
             "- Do X",
         ].join("\n");
-        const parsed = parseIssuesEnvelope(env);
-        expect(parsed.isIssuesEnvelope).toBe(true);
-        expect(parsed.sections["issues"].bullets[0]).toContain("Missing required section");
+        const parsed = (0, issuesEnvelope_js_1.parseIssuesEnvelope)(env);
+        (0, vitest_1.expect)(parsed.isIssuesEnvelope).toBe(true);
+        (0, vitest_1.expect)(parsed.sections["issues"].bullets[0]).toContain("Missing required section");
     });
 });
-describe("validateMarkdownAgainstOfs()", () => {
-    it("L0 accepts anything", () => {
-        const r = validateMarkdownAgainstOfs("whatever", SPEC, 0);
-        expect(r.ok).toBe(true);
+(0, vitest_1.describe)("validateMarkdownAgainstOfs()", () => {
+    (0, vitest_1.it)("L0 accepts anything", () => {
+        const r = (0, validate_js_1.validateMarkdownAgainstOfs)("whatever", SPEC, 0);
+        (0, vitest_1.expect)(r.ok).toBe(true);
     });
-    it("L1 fails when required section missing", () => {
+    (0, vitest_1.it)("L1 fails when required section missing", () => {
         const md = [
             "## Short answer",
             "Yes.",
@@ -66,21 +68,21 @@ describe("validateMarkdownAgainstOfs()", () => {
             "## Reasoning",
             "1. A",
         ].join("\n");
-        const r = validateMarkdownAgainstOfs(md, SPEC, 1);
-        expect(r.ok).toBe(false);
-        expect(r.issues.some(i => i.code === "MISSING_SECTION")).toBe(true);
+        const r = (0, validate_js_1.validateMarkdownAgainstOfs)(md, SPEC, 1);
+        (0, vitest_1.expect)(r.ok).toBe(false);
+        (0, vitest_1.expect)(r.issues.some(i => i.code === "MISSING_SECTION")).toBe(true);
     });
-    it("L2 requires a single fenced markdown block", () => {
-        const r = validateMarkdownAgainstOfs(mdL1Good(), SPEC, 2);
-        expect(r.ok).toBe(false);
-        expect(r.issues.some(i => i.code === "CONTAINER_MISSING")).toBe(true);
+    (0, vitest_1.it)("L2 requires a single fenced markdown block", () => {
+        const r = (0, validate_js_1.validateMarkdownAgainstOfs)(mdL1Good(), SPEC, 2);
+        (0, vitest_1.expect)(r.ok).toBe(false);
+        (0, vitest_1.expect)(r.issues.some(i => i.code === "CONTAINER_MISSING")).toBe(true);
     });
-    it("L2 passes with one fence containing valid L1", () => {
+    (0, vitest_1.it)("L2 passes with one fence containing valid L1", () => {
         const md = ["```markdown", mdL1Good(), "```"].join("\n");
-        const r = validateMarkdownAgainstOfs(md, SPEC, 2);
-        expect(r.ok).toBe(true);
+        const r = (0, validate_js_1.validateMarkdownAgainstOfs)(md, SPEC, 2);
+        (0, vitest_1.expect)(r.ok).toBe(true);
     });
-    it("L3 enforces section kinds (Reasoning must be ordered list)", () => {
+    (0, vitest_1.it)("L3 enforces section kinds (Reasoning must be ordered list)", () => {
         const bad = [
             "```markdown",
             [
@@ -101,8 +103,8 @@ describe("validateMarkdownAgainstOfs()", () => {
             ].join("\n"),
             "```",
         ].join("\n");
-        const r = validateMarkdownAgainstOfs(bad, SPEC, 3);
-        expect(r.ok).toBe(false);
-        expect(r.issues.some(i => i.code === "WRONG_SECTION_KIND")).toBe(true);
+        const r = (0, validate_js_1.validateMarkdownAgainstOfs)(bad, SPEC, 3);
+        (0, vitest_1.expect)(r.ok).toBe(false);
+        (0, vitest_1.expect)(r.issues.some(i => i.code === "WRONG_SECTION_KIND")).toBe(true);
     });
 });

package/dist/cli/index.js

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
-import { readFileSync, writeFileSync, existsSync } from "fs";
-import { resolve } from "path";
-import { checkCompliance, checkConnection } from "../index.js";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const path_1 = require("path");
+const index_js_1 = require("../index.js");
 const [, , command, ...args] = process.argv;
 async function main() {
     if (!command || command === "--help" || command === "-h") {
@@ -55,8 +57,8 @@ async function handleCheck(args) {
     if (!file)
         throw new Error("Missing file argument.");
     const level = (args.includes("--level") ? args[args.indexOf("--level") + 1] : "L2");
-    const content = readFileSync(resolve(file), "utf-8");
-    const result = await checkCompliance(content, level);
+    const content = (0, fs_1.readFileSync)((0, path_1.resolve)(file), "utf-8");
+    const result = await (0, index_js_1.checkCompliance)(content, level);
     if (result.meetsCompliance) {
         console.log("✅ Content meets compliance.");
     }
@@ -72,10 +74,10 @@ async function handleDiagnose(args) {
     const key = args[1];
     if (!file || !key)
         throw new Error("Usage: flex-md diagnose <file> <key>");
-    if (!existsSync(file))
+    if (!(0, fs_1.existsSync)(file))
         throw new Error(`File not found: ${file}`);
-    const content = readFileSync(resolve(file), "utf-8");
-    const result = checkConnection(content, key);
+    const content = (0, fs_1.readFileSync)((0, path_1.resolve)(file), "utf-8");
+    const result = (0, index_js_1.checkConnection)(content, key);
     if (result.connected) {
         console.log(`✅ Key "${key}" found at path: ${result.path?.join(" -> ")}`);
     }
@@ -89,9 +91,9 @@ async function handleCreate(args) {
     const key = args[1];
     if (!file || !key)
         throw new Error("Usage: flex-md create <file> <key>");
-    const content = existsSync(file) ? readFileSync(file, "utf-8") : "";
+    const content = (0, fs_1.existsSync)(file) ? (0, fs_1.readFileSync)(file, "utf-8") : "";
     const newContent = content + `\n\n## ${key}\n\n[Content for ${key}]\n`;
-    writeFileSync(file, newContent);
+    (0, fs_1.writeFileSync)(file, newContent);
     console.log(`✅ Section "${key}" created in ${file}`);
 }
 async function handleSync(args) {
@@ -99,10 +101,10 @@ async function handleSync(args) {
     const target = args[1];
     if (!source || !target)
         throw new Error("Usage: flex-md sync <source> <target>");
-    if (!existsSync(source))
+    if (!(0, fs_1.existsSync)(source))
         throw new Error(`Source file not found: ${source}`);
-    const content = readFileSync(source, "utf-8");
-    writeFileSync(target, content);
+    const content = (0, fs_1.readFileSync)(source, "utf-8");
+    (0, fs_1.writeFileSync)(target, content);
     console.log(`✅ Content synced from ${source} to ${target}`);
 }
 main();

package/dist/detect/json/detectIntent.js

@@ -1,3 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectJsonIntent = detectJsonIntent;
 const HARD_PATTERNS = [
     /\breturn\s+only\s+json\b/i,
     /\boutput\s+only\s+json\b/i,
@@ -25,7 +28,7 @@ const TOOLING_PATTERNS = [
     /\btool\s+call\b/i,
     /\barguments\b.*\bjson\b/i,
 ];
-export function detectJsonIntent(text) {
+function detectJsonIntent(text) {
     const signals = [];
     const add = (rx, strength, idx, len) => {
         signals.push({

package/dist/detect/json/detectMarkdown.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Helpers for "framed vs frameless" Markdown handling before Flex-MD.
  *
@@ -8,24 +9,29 @@
  * Notes:
  * - This is heuristic by design; tune thresholds as you learn your data.
  */
-import { logger } from "../../logger.js";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectMarkdown = detectMarkdown;
+exports.stripSingleFence = stripSingleFence;
+exports.forceWrapAsMarkdown = forceWrapAsMarkdown;
+exports.normalizeForFlexMd = normalizeForFlexMd;
+const logger_js_1 = require("../../logger.js");
 const SINGLE_FENCE_BLOCK_RE = /^```([a-zA-Z0-9_-]+)?([^\n]*)\n([\s\S]*?)\n```$/;
 const FENCE_OPEN_RE = /(^|\n)```/g;
-export function detectMarkdown(text) {
-    logger.debug("Starting markdown detection", {
+function detectMarkdown(text) {
+    logger_js_1.logger.debug("Starting markdown detection", {
         inputType: typeof text,
         inputLength: typeof text === "string" ? text.length : JSON.stringify(text ?? "").length
     });
     const reasons = [];
     const raw = typeof text === "string" ? text : JSON.stringify(text ?? "");
     const s = raw.replace(/\r\n/g, "\n");
-    logger.verbose("Input normalized for processing", {
+    logger_js_1.logger.verbose("Input normalized for processing", {
         originalType: typeof text,
         normalizedLength: s.length,
         hasNewlines: s.includes('\n')
     });
     const codeFences = [...s.matchAll(FENCE_OPEN_RE)].length;
-    logger.debug("Code fence analysis", {
+    logger_js_1.logger.debug("Code fence analysis", {
         totalFences: codeFences,
         fenceRegex: FENCE_OPEN_RE.source
     });
@@ -33,7 +39,7 @@ export function detectMarkdown(text) {
     const m = s.match(SINGLE_FENCE_BLOCK_RE);
     const isFramed = !!m && codeFences === 2;
     const frameLanguage = isFramed ? (m?.[1] ?? null) : null;
-    logger.debug("Framed markdown detection", {
+    logger_js_1.logger.debug("Framed markdown detection", {
         regexMatch: !!m,
         expectedFences: 2,
         actualFences: codeFences,
@@ -47,24 +53,24 @@ export function detectMarkdown(text) {
     });
     if (isFramed) {
         reasons.push("Single fenced code block detected (framed payload).");
-        logger.info("Detected framed markdown", { language: frameLanguage });
+        logger_js_1.logger.info("Detected framed markdown", { language: frameLanguage });
     }
     else if (codeFences > 2) {
         reasons.push("Multiple fenced code blocks detected.");
-        logger.debug("Multiple fences detected, not treating as single framed block", { fenceCount: codeFences });
+        logger_js_1.logger.debug("Multiple fences detected, not treating as single framed block", { fenceCount: codeFences });
     }
     else if (codeFences === 1) {
         reasons.push("Single fence marker found but not properly framed.");
-        logger.debug("Single fence found but regex didn't match", {
+        logger_js_1.logger.debug("Single fence found but regex didn't match", {
             regex: SINGLE_FENCE_BLOCK_RE.source,
             hasMatch: !!m
         });
     }
     else {
-        logger.debug("No fence markers detected");
+        logger_js_1.logger.debug("No fence markers detected");
     }
     const lines = s.split("\n");
-    logger.verbose("Line-by-line analysis started", { totalLines: lines.length });
+    logger_js_1.logger.verbose("Line-by-line analysis started", { totalLines: lines.length });
     const atxHeadings = lines.filter((l) => /^#{1,6}\s+\S/.test(l.trim())).length;
     let setextHeadings = 0;
     for (let i = 0; i < lines.length - 1; i++) {
@@ -89,7 +95,7 @@ export function detectMarkdown(text) {
         (s.match(/__[^_\n]+__/g) ?? []).length +
         (s.match(/(^|[^*])\*[^*\n]+\*([^*]|$)/g) ?? []).length +
         (s.match(/(^|[^_])_[^_\n]+_([^_]|$)/g) ?? []).length;
-    logger.debug("Markdown structure analysis", {
+    logger_js_1.logger.debug("Markdown structure analysis", {
         atxHeadings,
         setextHeadings,
         totalHeadings: headings,
@@ -104,7 +110,7 @@ export function detectMarkdown(text) {
     const hasList = unorderedListLines + orderedListLines >= 2;
     const hasTable = tableRows >= 2;
     const hasOtherSignals = inlineCodeSpans + mdLinks + emphasisTokens >= 2;
-    logger.debug("Heuristic analysis", {
+    logger_js_1.logger.debug("Heuristic analysis", {
         hasList,
         hasTable,
         hasOtherSignals,
@@ -115,17 +121,17 @@ export function detectMarkdown(text) {
     let isMarkdownLikely = false;
     if (isFramed) {
         isMarkdownLikely = true;
-        logger.debug("Markdown likelihood determined: framed content is always considered markdown");
+        logger_js_1.logger.debug("Markdown likelihood determined: framed content is always considered markdown");
     }
     else if (headings >= 2) {
         isMarkdownLikely = true;
         reasons.push(`Detected ${headings} markdown heading(s) (>=2).`);
-        logger.debug("Markdown likelihood: sufficient headings detected", { headingCount: headings });
+        logger_js_1.logger.debug("Markdown likelihood: sufficient headings detected", { headingCount: headings });
     }
     else if (headings >= 1 && (hasList || hasTable)) {
         isMarkdownLikely = true;
         reasons.push(`Detected heading(s) plus ${hasList ? "list" : "table"} structure.`);
-        logger.debug("Markdown likelihood: heading plus structural element", {
+        logger_js_1.logger.debug("Markdown likelihood: heading plus structural element", {
             hasHeading: headings >= 1,
             hasList,
             hasTable
@@ -134,7 +140,7 @@ export function detectMarkdown(text) {
     else if ((hasList && hasTable) || (hasTable && hasOtherSignals) || (hasList && hasOtherSignals)) {
         isMarkdownLikely = true;
         reasons.push("Detected multiple markdown structural signals (lists/tables/links/code/emphasis).");
-        logger.debug("Markdown likelihood: multiple structural signals", {
+        logger_js_1.logger.debug("Markdown likelihood: multiple structural signals", {
             listAndTable: hasList && hasTable,
             tableAndOther: hasTable && hasOtherSignals,
             listAndOther: hasList && hasOtherSignals
@@ -142,7 +148,7 @@ export function detectMarkdown(text) {
     }
     else {
         reasons.push("Insufficient markdown structure signals; treating as plain text.");
-        logger.debug("Markdown likelihood: insufficient signals, treating as plain text", {
+        logger_js_1.logger.debug("Markdown likelihood: insufficient signals, treating as plain text", {
             headings,
             hasList,
             hasTable,
@@ -152,7 +158,7 @@ export function detectMarkdown(text) {
     if (/^\s*#{1,6}\s+\S/.test(lines[0] ?? "")) {
         reasons.push("Text starts with an ATX heading (#...).");
         isMarkdownLikely = true;
-        logger.debug("Additional check: starts with heading, upgrading to markdown");
+        logger_js_1.logger.debug("Additional check: starts with heading, upgrading to markdown");
     }
     return {
         isMarkdownLikely,
@@ -179,7 +185,7 @@ export function detectMarkdown(text) {
  *
  * - Also handles ```md / ```markdown / ```json etc.
  */
-export function stripSingleFence(input) {
+function stripSingleFence(input) {
     const s = input.replace(/\r\n/g, "\n").trim();
     const fenceCount = [...s.matchAll(FENCE_OPEN_RE)].length;
     if (fenceCount !== 2) {
@@ -199,7 +205,7 @@ export function stripSingleFence(input) {
  * Choose a heading that exists in your OFS to maximize alignment.
  * Default: "Full Answer" (common sink section).
  */
-export function forceWrapAsMarkdown(plainText, opts) {
+function forceWrapAsMarkdown(plainText, opts) {
     const heading = opts?.heading ?? "Full Answer";
     const level = opts?.level ?? 3;
     const hashes = "#".repeat(level);
@@ -215,15 +221,15 @@ export function forceWrapAsMarkdown(plainText, opts) {
  * - Else: if markdown-likely: keep as-is
  * - Else: wrap as markdown under a chosen heading
  */
-export function normalizeForFlexMd(input, opts) {
-    logger.info("Starting Flex-MD normalization", {
+function normalizeForFlexMd(input, opts) {
+    logger_js_1.logger.info("Starting Flex-MD normalization", {
         inputType: typeof input,
         inputLength: typeof input === "string" ? input.length : JSON.stringify(input ?? "").length,
         options: opts
     });
     const raw = typeof input === "string" ? input : JSON.stringify(input ?? "");
     const detection = detectMarkdown(raw);
-    logger.debug("Detection completed", {
+    logger_js_1.logger.debug("Detection completed", {
         isFramed: detection.isFramed,
         isMarkdownLikely: detection.isMarkdownLikely,
         frameLanguage: detection.frameLanguage,
@@ -231,14 +237,14 @@ export function normalizeForFlexMd(input, opts) {
     });
     // 1) Strip if framed
     const { stripped, wasFramed, language } = stripSingleFence(raw);
-    logger.debug("Strip fence check", {
+    logger_js_1.logger.debug("Strip fence check", {
         wasFramed,
         language,
         strippedLength: stripped.length,
         originalLength: raw.length
     });
     if (wasFramed) {
-        logger.info("Normalization: stripped framed markdown", {
+        logger_js_1.logger.info("Normalization: stripped framed markdown", {
             language,
             contentLength: stripped.length
         });
@@ -252,7 +258,7 @@ export function normalizeForFlexMd(input, opts) {
     }
     // 2) Keep if markdown-likely
     if (detection.isMarkdownLikely) {
-        logger.info("Normalization: keeping as-is (markdown-likely)", {
+        logger_js_1.logger.info("Normalization: keeping as-is (markdown-likely)", {
             reasons: detection.reasons
         });
         return {
@@ -266,7 +272,7 @@ export function normalizeForFlexMd(input, opts) {
     // 3) Wrap if not markdown-likely
     const fallbackHeading = opts?.fallbackHeading ?? "Full Answer";
     const fallbackLevel = opts?.fallbackHeadingLevel ?? 3;
-    logger.info("Normalization: wrapping as markdown", {
+    logger_js_1.logger.info("Normalization: wrapping as markdown", {
         fallbackHeading,
         fallbackLevel,
         reasons: detection.reasons
@@ -275,7 +281,7 @@ export function normalizeForFlexMd(input, opts) {
         heading: fallbackHeading,
         level: fallbackLevel,
     });
-    logger.debug("Wrapping completed", {
+    logger_js_1.logger.debug("Wrapping completed", {
         wrappedLength: wrapped.length,
         originalLength: raw.length
     });