flex-md 4.7.2 → 4.7.4

package/dist/ofs/enricher.js

@@ -1,13 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildMarkdownGuidance = buildMarkdownGuidance;
-exports.enrichInstructions = enrichInstructions;
-exports.enrichInstructionsWithFlexMd = enrichInstructionsWithFlexMd;
 /**
  * Generates Markdown guidance instructions for the LLM based on the OFS and contract level.
  * Strictly avoids the word "flex-md" and remains "tax-aware" by only including relevant rules.
  */
-function buildMarkdownGuidance(spec, strict, opts) {
+export function buildMarkdownGuidance(spec, strict, opts) {
     const level = strict.level ?? 0;
     const fence = opts?.containerFence === "flexmd" ? "```flexmd" : "```markdown";
     // L0 - Minimal Markdown
@@ -85,14 +80,14 @@ function buildMarkdownGuidance(spec, strict, opts) {
 /**
  * @deprecated Use buildMarkdownGuidance
  */
-function enrichInstructions(spec, strict) {
+export function enrichInstructions(spec, strict) {
     return buildMarkdownGuidance(spec, strict);
 }
 /**
  * Enrich instructions with flex-md compliance guidance.
  * Returns detailed information about what was changed.
  */
-async function enrichInstructionsWithFlexMd(instructions, strictnessLevel, spec // Optional spec, if provided will include section guidance
+export async function enrichInstructionsWithFlexMd(instructions, strictnessLevel, spec // Optional spec, if provided will include section guidance
 ) {
     const originalLength = instructions.length;
     const level = parseInt(strictnessLevel.slice(1));

package/dist/ofs/infer.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.inferOfsFromMarkdown = inferOfsFromMarkdown;
-const parse_js_1 = require("../md/parse.js");
+import { parseHeadingsAndSections, extractBullets } from "../md/parse.js";
 /**
  * Infers an OutputFormatSpec from a Markdown string.
  */
-function inferOfsFromMarkdown(md) {
+export function inferOfsFromMarkdown(md) {
     // Collect all bullet names that look like headers ("- Name")
     const lines = md.split("\n");
     const bulletNames = [];
@@ -16,13 +13,13 @@ function inferOfsFromMarkdown(md) {
             bulletNames.push(m[1].trim());
         }
     }
-    const sections = (0, parse_js_1.parseHeadingsAndSections)(md, { bulletNames });
+    const sections = parseHeadingsAndSections(md, { bulletNames });
     const specSections = [];
     for (const sec of sections) {
         const name = sec.heading.name;
         const body = sec.body.trim();
         // 1. Detect list
-        const bullets = (0, parse_js_1.extractBullets)(body);
+        const bullets = extractBullets(body);
         if (bullets.length > 0) {
             specSections.push({
                 name,

package/dist/ofs/issuesEnvelope.js

@@ -1,13 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseIssuesEnvelope = parseIssuesEnvelope;
-exports.buildIssuesEnvelope = buildIssuesEnvelope;
-exports.buildIssuesEnvelopeAuto = buildIssuesEnvelopeAuto;
-const parse_js_1 = require("../md/parse.js");
-function parseIssuesEnvelope(md) {
-    return (0, parse_js_1.isIssuesEnvelopeCheck)(md);
+import { isIssuesEnvelopeCheck } from "../md/parse.js";
+export function parseIssuesEnvelope(md) {
+    return isIssuesEnvelopeCheck(md);
 }
-function buildIssuesEnvelope(args) {
+export function buildIssuesEnvelope(args) {
     const issues = args.validation.issues
         .filter(i => i.severity === "warn" || i.severity === "error")
         .map(i => `- ${i.message}`);
@@ -32,7 +27,7 @@ function buildIssuesEnvelope(args) {
         "",
     ].join("\n");
 }
-function buildIssuesEnvelopeAuto(args) {
+export function buildIssuesEnvelopeAuto(args) {
     const v = args.validation;
     const expected = [];
     const found = [];

package/dist/ofs/memory.js

@@ -1,26 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.remember = remember;
-exports.recall = recall;
-const parser_js_1 = require("./parser.js");
-const node_crypto_1 = require("node:crypto");
+import { parseOutputFormatSpec } from "./parser.js";
+import { randomUUID } from "node:crypto";
 const specMemory = new Map();
 /**
  * Parses Flex-MD instructions and "remembers" the Output Format Spec.
  * Returns a unique recallId that can be used later.
  */
-function remember(instructions) {
-    const spec = (0, parser_js_1.parseOutputFormatSpec)(instructions);
+export function remember(instructions) {
+    const spec = parseOutputFormatSpec(instructions);
     if (!spec) {
         throw new Error("No valid Output Format Spec found in instructions.");
     }
-    const id = (0, node_crypto_1.randomUUID)();
+    const id = randomUUID();
     specMemory.set(id, spec);
     return id;
 }
 /**
  * Recalls a previously remembered Output Format Spec.
  */
-function recall(id) {
+export function recall(id) {
     return specMemory.get(id);
 }

package/dist/ofs/parser.js

@@ -1,15 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateFormat = validateFormat;
-exports.parseOutputFormatSpec = parseOutputFormatSpec;
-exports.parseInputFormatSpec = parseInputFormatSpec;
-exports.parseFormatSpecs = parseFormatSpecs;
-const parse_js_1 = require("../md/parse.js");
+import { normalizeName } from "../md/parse.js";
 /**
  * Validate a format specification.
  * Returns detailed validation results.
  */
-async function validateFormat(formatSpec, formatType = "flex-md") {
+export async function validateFormat(formatSpec, formatType = "flex-md") {
     const issues = [];
     const suggestions = [];
     if (formatType === "json-schema") {
@@ -75,7 +69,7 @@ async function validateFormat(formatSpec, formatType = "flex-md") {
         }
     };
 }
-function parseOutputFormatSpec(md, opts = {}) {
+export function parseOutputFormatSpec(md, opts = {}) {
     const headingRx = opts.headingRegex ?? /^##\s*Output format\b/i;
     const lines = md.split("\n");
     // find OFS start
@@ -150,7 +144,7 @@ function parseOutputFormatSpec(md, opts = {}) {
         if (headingMatch) {
             const name = headingMatch[1].trim();
             // Don't re-parse "Output format" itself if it somehow gets in here
-            if ((0, parse_js_1.normalizeName)(name) !== "output format") {
+            if (normalizeName(name) !== "output format") {
                 const s = { name, kind: "text" };
                 sections.push(s);
                 currentSection = s;
@@ -252,7 +246,7 @@ function parseRequiredOptional(s) {
  * Parse an Input Format Spec block from Markdown.
  * Uses the same parsing logic as Output Format Spec.
  */
-function parseInputFormatSpec(md, opts = {}) {
+export function parseInputFormatSpec(md, opts = {}) {
     const headingRx = opts.headingRegex ?? /^##\s*Input format\b/i;
     const lines = md.split("\n");
     // find Input Format Spec start
@@ -327,7 +321,7 @@ function parseInputFormatSpec(md, opts = {}) {
         if (headingMatch) {
             const name = headingMatch[1].trim();
             // Don't re-parse "Input format" itself if it somehow gets in here
-            if ((0, parse_js_1.normalizeName)(name) !== "input format") {
+            if (normalizeName(name) !== "input format") {
                 const s = { name, kind: "text" };
                 sections.push(s);
                 currentSection = s;
@@ -363,7 +357,7 @@ function parseInputFormatSpec(md, opts = {}) {
  * Extract both Input and Output Format Specs from instructions text.
  * This function searches for both "## Input format" and "## Output format" sections.
  */
-function parseFormatSpecs(instructions, opts = {}) {
+export function parseFormatSpecs(instructions, opts = {}) {
     const input = parseInputFormatSpec(instructions, opts);
     const output = parseOutputFormatSpec(instructions, opts);
     return {

package/dist/ofs/stringify.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringifyOutputFormatSpec = stringifyOutputFormatSpec;
 /**
  * Convert an OutputFormatSpec to a formal "Instructions Output Format Block".
  */
-function stringifyOutputFormatSpec(spec) {
+export function stringifyOutputFormatSpec(spec) {
     const lines = [];
     lines.push(`## Output format (Markdown)`);
     if (spec.description) {

package/dist/pipeline/enforce.js

@@ -1,23 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.enforceFlexMd = enforceFlexMd;
-const types_js_1 = require("../strictness/types.js");
-const kind_js_1 = require("./kind.js");
-const repair_js_1 = require("./repair.js");
-const processor_js_1 = require("../strictness/processor.js");
-const issuesEnvelope_js_1 = require("../ofs/issuesEnvelope.js");
+import { strictnessDefaults } from "../strictness/types.js";
+import { detectResponseKind } from "./kind.js";
+import { repairToMarkdownLevel } from "./repair.js";
+import { processResponseMarkdown } from "../strictness/processor.js";
+import { buildIssuesEnvelopeAuto } from "../ofs/issuesEnvelope.js";
 /**
  * Main pipeline: detect, optionally repair, and enforce Markdown contract constraints.
  */
-function enforceFlexMd(text, spec, strictInput = {}, options = {}) {
+export function enforceFlexMd(text, spec, strictInput = {}, options = {}) {
     const level = strictInput.level ?? 0;
-    const strict = { ...(0, types_js_1.strictnessDefaults)(level), ...strictInput };
+    const strict = { ...strictnessDefaults(level), ...strictInput };
     const autoFix = options.autoFix ?? true;
     // 1. Kind detection
-    const detected = (0, kind_js_1.detectResponseKind)(text, spec);
+    const detected = detectResponseKind(text, spec);
     if (detected.kind === "issues") {
         return {
-            ...(0, processor_js_1.processResponseMarkdown)(text, spec, strict),
+            ...processResponseMarkdown(text, spec, strict),
             kind: "issues",
             outputText: text
         };
@@ -26,15 +23,15 @@ function enforceFlexMd(text, spec, strictInput = {}, options = {}) {
     let currentText = text;
     let repairedInfo;
     if (autoFix) {
-        repairedInfo = (0, repair_js_1.repairToMarkdownLevel)(currentText, spec, level);
+        repairedInfo = repairToMarkdownLevel(currentText, spec, level);
         currentText = repairedInfo.output;
     }
     // 3. Enforce
-    const result = (0, processor_js_1.processResponseMarkdown)(currentText, spec, strict);
+    const result = processResponseMarkdown(currentText, spec, strict);
     // 4. Mode B Fallback
     let outputText = currentText;
     if (!result.ok && level >= 1) {
-        outputText = (0, issuesEnvelope_js_1.buildIssuesEnvelopeAuto)({
+        outputText = buildIssuesEnvelopeAuto({
             validation: result.validation,
             level,
             requiredSectionNames: spec.sections.filter(s => s.required !== false).map(s => s.name)

package/dist/pipeline/kind.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectResponseKind = detectResponseKind;
-const parse_js_1 = require("../md/parse.js");
-function detectResponseKind(text, spec) {
-    const issuesResult = (0, parse_js_1.isIssuesEnvelopeCheck)(text);
+import { isIssuesEnvelopeCheck } from "../md/parse.js";
+export function detectResponseKind(text, spec) {
+    const issuesResult = isIssuesEnvelopeCheck(text);
     const hasIssues = issuesResult.isIssuesEnvelope;
     // Use more robust detection: check for both #+ Name and ===Name
     const hasSections = spec.sections.some(s => {

package/dist/pipeline/repair.js

@@ -1,22 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.repairToMarkdownLevel = repairToMarkdownLevel;
-const parse_js_1 = require("../md/parse.js");
+import { extractFencedBlocks, parseHeadingsAndSections, normalizeName, isIssuesEnvelopeCheck } from "../md/parse.js";
 /**
  * Deterministic 9-step repair plan to transform input into the required Markdown structure.
  */
-function repairToMarkdownLevel(input, spec, level, opts) {
+export function repairToMarkdownLevel(input, spec, level, opts) {
     const applied = [];
     const noneValue = opts?.noneValue ?? spec.emptySectionValue ?? "None";
     const preferHeadingLevel = opts?.preferHeadingLevel ?? 2;
     // Step 0 — If Issues envelope, return as-is
-    if ((0, parse_js_1.isIssuesEnvelopeCheck)(input).isIssuesEnvelope) {
+    if (isIssuesEnvelopeCheck(input).isIssuesEnvelope) {
         return { output: input, applied: [] };
     }
     // Step 1 — Normalize container (L2+ only)
     let workingMd = input;
     if (level >= 2) {
-        const fences = (0, parse_js_1.extractFencedBlocks)(workingMd);
+        const fences = extractFencedBlocks(workingMd);
         if (fences.length === 0) {
             workingMd = `\`\`\`markdown\n${workingMd.trim()}\n\`\`\`\n`;
             applied.push("CONTAINER_WRAPPED");
@@ -44,7 +41,7 @@ function repairToMarkdownLevel(input, spec, level, opts) {
     let contentToRepair = workingMd;
     let isWrapped = false;
     if (level >= 2) {
-        const fences = (0, parse_js_1.extractFencedBlocks)(workingMd);
+        const fences = extractFencedBlocks(workingMd);
         if (fences.length === 1) {
             contentToRepair = fences[0].content;
             isWrapped = true;
@@ -63,14 +60,14 @@ function repairToMarkdownLevel(input, spec, level, opts) {
         catch (e) { }
     }
     // Step 4 — Ensure required section headings exist (L1+)
-    let sections = (0, parse_js_1.parseHeadingsAndSections)(contentToRepair);
+    let sections = parseHeadingsAndSections(contentToRepair);
     const existingNorms = new Set(sections.map(s => s.heading.norm));
     for (const sSpec of spec.sections) {
-        if (sSpec.required !== false && !existingNorms.has((0, parse_js_1.normalizeName)(sSpec.name))) {
+        if (sSpec.required !== false && !existingNorms.has(normalizeName(sSpec.name))) {
             const hashes = "#".repeat(preferHeadingLevel);
             contentToRepair = contentToRepair.trim() + `\n\n${hashes} ${sSpec.name}\n${noneValue}\n`;
             applied.push(`SECTION_ADDED:${sSpec.name}`);
-            existingNorms.add((0, parse_js_1.normalizeName)(sSpec.name));
+            existingNorms.add(normalizeName(sSpec.name));
         }
     }
     // Step 5 — Move stray content (L1+)

package/dist/strictness/container.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractSingleFence = extractSingleFence;
 /**
  * Extracts content from exactly one fenced block of the specified language.
  */
-function extractSingleFence(text, fenceLang) {
+export function extractSingleFence(text, fenceLang) {
     const issues = [];
     // Find first occurrence of opening fence
     const startMarker = "```" + fenceLang;

package/dist/strictness/processor.js

@@ -1,16 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.processResponseMarkdown = processResponseMarkdown;
-const validate_js_1 = require("../validate/validate.js");
-const extract_js_1 = require("../extract/extract.js");
-const issuesEnvelope_js_1 = require("../ofs/issuesEnvelope.js");
+import { validateMarkdownAgainstOfs } from "../validate/validate.js";
+import { extractFromMarkdown } from "../extract/extract.js";
+import { parseIssuesEnvelope } from "../ofs/issuesEnvelope.js";
 /**
  * Unified entry point for processing a response against an OFS.
  */
-function processResponseMarkdown(text, spec, strict // StrictnessOptions
+export function processResponseMarkdown(text, spec, strict // StrictnessOptions
 ) {
     const level = strict.level ?? 0;
-    const validation = (0, validate_js_1.validateMarkdownAgainstOfs)(text, spec, level, strict.policy);
+    const validation = validateMarkdownAgainstOfs(text, spec, level, strict.policy);
     const result = {
         ok: validation.ok,
         strictness: strict,
@@ -20,10 +17,10 @@ function processResponseMarkdown(text, spec, strict // StrictnessOptions
         issues: validation.issues,
     };
     if (validation.ok) {
-        result.extracted = (0, extract_js_1.extractFromMarkdown)(text, spec);
+        result.extracted = extractFromMarkdown(text, spec);
     }
     else {
-        const issuesEnv = (0, issuesEnvelope_js_1.parseIssuesEnvelope)(text);
+        const issuesEnv = parseIssuesEnvelope(text);
         if (issuesEnv.isIssuesEnvelope) {
             result.issuesEnvelope = issuesEnv;
         }

package/dist/strictness/types.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.strictnessDefaults = strictnessDefaults;
-function strictnessDefaults(level) {
+export function strictnessDefaults(level) {
     const common = {
         tablesGuidance: "auto",
         listsGuidance: "auto",

package/dist/tokens/auto-fix.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.autoFix = autoFix;
 /**
  * Automatically apply fixable improvements
  */
-function autoFix(spec, improvements, options = {}) {
+export function autoFix(spec, improvements, options = {}) {
     const { applyQuickWinsOnly = false, maxPriority = 'low', skipManual = true } = options;
     const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
     const maxPriorityLevel = priorityOrder[maxPriority] ?? 3;

package/dist/tokens/cognitive-cost.js

@@ -1,13 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateCognitiveCost = calculateCognitiveCost;
-exports.compareLevelCosts = compareLevelCosts;
-const parser_js_1 = require("./parser.js");
-const compliance_js_1 = require("./compliance.js");
+import { parseSystemPart } from './parser.js';
+import { detectSystemPartLevel } from './compliance.js';
 /**
  * Calculate cognitive cost of creating/maintaining spec
  */
-function calculateCognitiveCost(spec) {
+export function calculateCognitiveCost(spec) {
     const perSection = [];
     let totalCost = 0;
     let complexityCost = 0;
@@ -38,8 +34,8 @@ function calculateCognitiveCost(spec) {
  */
 function calculateSectionCost(section) {
     const kind = section.kind || 'text';
-    const systemPart = (0, parser_js_1.parseSystemPart)(section.instruction, kind);
-    const level = systemPart ? (0, compliance_js_1.detectSystemPartLevel)(systemPart, kind) : null;
+    const systemPart = parseSystemPart(section.instruction, kind);
+    const level = systemPart ? detectSystemPartLevel(systemPart, kind) : null;
     const factors = [];
     let cost = 0;
     // Base cost by level
@@ -170,7 +166,7 @@ function generateCostRecommendation(totalCost, sectionCount) {
 /**
  * Compare cognitive cost across different compliance levels
  */
-function compareLevelCosts(spec) {
+export function compareLevelCosts(spec) {
     const costs = { 0: 0, 1: 0, 2: 0, 3: 0 };
     // Simulate cost at each level
     for (let level = 0; level <= 3; level++) {

package/dist/tokens/compliance.js

@@ -1,12 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectSystemPartLevel = detectSystemPartLevel;
-exports.checkSpecCompliance = checkSpecCompliance;
-const parser_js_1 = require("./parser.js");
+import { parseSystemPart } from './parser.js';
 /**
  * Detect the compliance level of a system part
  */
-function detectSystemPartLevel(systemPart, kind) {
+export function detectSystemPartLevel(systemPart, kind) {
     const { parsed } = systemPart;
     switch (parsed.type) {
         case 'length':
@@ -35,13 +31,13 @@ function detectSystemPartLevel(systemPart, kind) {
 /**
  * Check if a spec complies with a target level
  */
-function checkSpecCompliance(spec, targetLevel = 2) {
+export function checkSpecCompliance(spec, targetLevel = 2) {
     const violations = [];
     let totalLevel = 0;
     let compliantCount = 0;
     for (const section of spec.sections) {
         const kind = section.kind || 'text';
-        const systemPart = (0, parser_js_1.parseSystemPart)(section.instruction, kind);
+        const systemPart = parseSystemPart(section.instruction, kind);
         const level = systemPart ? detectSystemPartLevel(systemPart, kind) : 0;
         totalLevel += level;
         if (level >= targetLevel) {

package/dist/tokens/confidence.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateConfidence = calculateConfidence;
-const parser_js_1 = require("./parser.js");
-const compliance_js_1 = require("./compliance.js");
+import { parseSystemPart } from './parser.js';
+import { detectSystemPartLevel } from './compliance.js';
 /**
  * Calculate confidence in token estimation
  */
-function calculateConfidence(spec) {
+export function calculateConfidence(spec) {
     const bySection = [];
     const factors = [];
     let totalConfidence = 0;
@@ -52,9 +49,9 @@ function calculateConfidence(spec) {
  */
 function analyzeSectionConfidence(section) {
     const kind = section.kind || 'text';
-    const systemPart = (0, parser_js_1.parseSystemPart)(section.instruction, kind);
+    const systemPart = parseSystemPart(section.instruction, kind);
     const hasSystemPart = systemPart !== null;
-    const level = systemPart ? (0, compliance_js_1.detectSystemPartLevel)(systemPart, kind) : null;
+    const level = systemPart ? detectSystemPartLevel(systemPart, kind) : null;
     let confidence = 0;
     let quality = 'none';
     if (systemPart && level !== null) {
@@ -140,7 +137,7 @@ function getConfidenceAdjustment(systemPart, _section) {
  */
 function calculateCoverageFactor(spec) {
     const total = spec.sections.length;
-    const withSystemParts = spec.sections.filter(s => (0, parser_js_1.parseSystemPart)(s.instruction, s.kind || 'text') !== null).length;
+    const withSystemParts = spec.sections.filter(s => parseSystemPart(s.instruction, s.kind || 'text') !== null).length;
     const coverage = total > 0 ? (withSystemParts / total) * 100 : 0;
     let score = 0;
     let impact = 'neutral';

package/dist/tokens/estimator.js

@@ -1,11 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TOKEN_CONSTANTS = void 0;
-exports.estimateTokens = estimateTokens;
-exports.getFallbackEstimate = getFallbackEstimate;
-exports.estimateTextTokens = estimateTextTokens;
 // Calibrated token constants
-exports.TOKEN_CONSTANTS = {
+export const TOKEN_CONSTANTS = {
     // Text lengths (enumerated)
     lengths: {
         '1 sentence': 25,
@@ -27,7 +21,7 @@ exports.TOKEN_CONSTANTS = {
     // Text token estimation (rough approximation: 1 token ≈ 4 characters)
     charsPerToken: 4
 };
-function estimateTokens(systemPart) {
+export function estimateTokens(systemPart) {
     const { parsed } = systemPart;
     switch (parsed.type) {
         case 'length':
@@ -41,7 +35,7 @@ function estimateTokens(systemPart) {
     }
 }
 function estimateTextLength(value) {
-    const estimated = exports.TOKEN_CONSTANTS.lengths[value];
+    const estimated = TOKEN_CONSTANTS.lengths[value];
     return {
         estimated,
         min: Math.floor(estimated * 0.7),
@@ -54,26 +48,26 @@ function estimateItems(parsed) {
     if (max !== null) {
         // Range: "3-5" → use average
         const avg = (min + max) / 2;
-        const estimated = Math.round(avg * exports.TOKEN_CONSTANTS.perItem);
+        const estimated = Math.round(avg * TOKEN_CONSTANTS.perItem);
         return {
             estimated,
-            min: min * exports.TOKEN_CONSTANTS.perItem,
-            max: max * exports.TOKEN_CONSTANTS.perItem,
+            min: min * TOKEN_CONSTANTS.perItem,
+            max: max * TOKEN_CONSTANTS.perItem,
             confidence: 'high'
         };
     }
     if (atLeast) {
         // "at least 3" → estimate at min + 50%
-        const estimated = Math.round(min * 1.5 * exports.TOKEN_CONSTANTS.perItem);
+        const estimated = Math.round(min * 1.5 * TOKEN_CONSTANTS.perItem);
         return {
             estimated,
-            min: min * exports.TOKEN_CONSTANTS.perItem,
-            max: min * 3 * exports.TOKEN_CONSTANTS.perItem,
+            min: min * TOKEN_CONSTANTS.perItem,
+            max: min * 3 * TOKEN_CONSTANTS.perItem,
             confidence: 'medium'
         };
     }
     // Exact: "3" → use exact value
-    const estimated = min * exports.TOKEN_CONSTANTS.perItem;
+    const estimated = min * TOKEN_CONSTANTS.perItem;
     return {
         estimated,
         min: Math.floor(estimated * 0.8),
@@ -92,15 +86,15 @@ function estimateTable(parsed) {
         : parsed.columns.atLeast
             ? parsed.columns.min * 1.5
             : parsed.columns.min;
-    const estimated = Math.round(rowAvg * colAvg * exports.TOKEN_CONSTANTS.perTableCell);
+    const estimated = Math.round(rowAvg * colAvg * TOKEN_CONSTANTS.perTableCell);
     const minCells = parsed.rows.min * parsed.columns.min;
     const maxRows = parsed.rows.max || (parsed.rows.atLeast ? parsed.rows.min * 2 : parsed.rows.min);
     const maxCols = parsed.columns.max || (parsed.columns.atLeast ? parsed.columns.min * 2 : parsed.columns.min);
     const maxCells = maxRows * maxCols;
     return {
         estimated,
-        min: minCells * exports.TOKEN_CONSTANTS.perTableCell,
-        max: maxCells * exports.TOKEN_CONSTANTS.perTableCell,
+        min: minCells * TOKEN_CONSTANTS.perTableCell,
+        max: maxCells * TOKEN_CONSTANTS.perTableCell,
         confidence: (parsed.rows.max && parsed.columns.max) ? 'high' : 'medium'
     };
 }
@@ -109,16 +103,16 @@ function estimateCodeLines(parsed) {
     if (max !== null) {
         // Range: "10-20"
         const avg = (min + max) / 2;
-        const estimated = Math.round(avg * exports.TOKEN_CONSTANTS.perCodeLine);
+        const estimated = Math.round(avg * TOKEN_CONSTANTS.perCodeLine);
         return {
             estimated,
-            min: min * exports.TOKEN_CONSTANTS.perCodeLine,
-            max: max * exports.TOKEN_CONSTANTS.perCodeLine,
+            min: min * TOKEN_CONSTANTS.perCodeLine,
+            max: max * TOKEN_CONSTANTS.perCodeLine,
             confidence: 'high'
         };
     }
     // Exact or approximate: "10" or "~10"
-    const estimated = min * exports.TOKEN_CONSTANTS.perCodeLine;
+    const estimated = min * TOKEN_CONSTANTS.perCodeLine;
     const variance = approximate ? 0.3 : 0.15;
     return {
         estimated,
@@ -128,7 +122,7 @@ function estimateCodeLines(parsed) {
     };
 }
 // Fallback for sections without system parts
-function getFallbackEstimate(kind, required) {
+export function getFallbackEstimate(kind, required) {
     const fallbacks = {
         text: 150,
         list: 200,
@@ -148,10 +142,10 @@ function getFallbackEstimate(kind, required) {
  * Estimate tokens from plain text using character-based approximation.
  * Uses a rule of thumb: ~4 characters per token (varies by model, but good approximation).
  */
-function estimateTextTokens(text) {
+export function estimateTextTokens(text) {
     if (!text || text.length === 0)
         return 0;
     // Rough approximation: 1 token ≈ 4 characters for English text
     // This is a common rule of thumb and works reasonably well for most cases
-    return Math.ceil(text.length / exports.TOKEN_CONSTANTS.charsPerToken);
+    return Math.ceil(text.length / TOKEN_CONSTANTS.charsPerToken);
 }