flex-md 4.5.3 → 4.5.5

package/dist/ofs/enricher.js

@@ -1,8 +1,13 @@
+"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.
  */
-export function buildMarkdownGuidance(spec, strict, opts) {
+function buildMarkdownGuidance(spec, strict, opts) {
     const level = strict.level ?? 0;
     const fence = opts?.containerFence === "flexmd" ? "```flexmd" : "```markdown";
     // L0 - Minimal Markdown
@@ -80,14 +85,14 @@ export function buildMarkdownGuidance(spec, strict, opts) {
 /**
  * @deprecated Use buildMarkdownGuidance
  */
-export function enrichInstructions(spec, strict) {
+function enrichInstructions(spec, strict) {
     return buildMarkdownGuidance(spec, strict);
 }
 /**
  * Enrich instructions with flex-md compliance guidance.
  * Returns detailed information about what was changed.
  */
-export async function enrichInstructionsWithFlexMd(instructions, strictnessLevel, spec // Optional spec, if provided will include section guidance
+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,8 +1,11 @@
-import { parseHeadingsAndSections, extractBullets } from "../md/parse.js";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferOfsFromMarkdown = inferOfsFromMarkdown;
+const parse_js_1 = require("../md/parse.js");
 /**
  * Infers an OutputFormatSpec from a Markdown string.
  */
-export function inferOfsFromMarkdown(md) {
+function inferOfsFromMarkdown(md) {
     // Collect all bullet names that look like headers ("- Name")
     const lines = md.split("\n");
     const bulletNames = [];
@@ -13,13 +16,13 @@ export function inferOfsFromMarkdown(md) {
             bulletNames.push(m[1].trim());
         }
     }
-    const sections = parseHeadingsAndSections(md, { bulletNames });
+    const sections = (0, parse_js_1.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 = extractBullets(body);
+        const bullets = (0, parse_js_1.extractBullets)(body);
         if (bullets.length > 0) {
             specSections.push({
                 name,

package/dist/ofs/issuesEnvelope.js

@@ -1,8 +1,13 @@
-import { isIssuesEnvelopeCheck } from "../md/parse.js";
-export function parseIssuesEnvelope(md) {
-    return isIssuesEnvelopeCheck(md);
+"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);
 }
-export function buildIssuesEnvelope(args) {
+function buildIssuesEnvelope(args) {
     const issues = args.validation.issues
         .filter(i => i.severity === "warn" || i.severity === "error")
         .map(i => `- ${i.message}`);
@@ -27,7 +32,7 @@ export function buildIssuesEnvelope(args) {
         "",
     ].join("\n");
 }
-export function buildIssuesEnvelopeAuto(args) {
+function buildIssuesEnvelopeAuto(args) {
     const v = args.validation;
     const expected = [];
     const found = [];

package/dist/ofs/memory.js

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

package/dist/ofs/parser.js

@@ -1,9 +1,13 @@
-import { normalizeName } from "../md/parse.js";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateFormat = validateFormat;
+exports.parseOutputFormatSpec = parseOutputFormatSpec;
+const parse_js_1 = require("../md/parse.js");
 /**
  * Validate a format specification.
  * Returns detailed validation results.
  */
-export async function validateFormat(formatSpec, formatType = "flex-md") {
+async function validateFormat(formatSpec, formatType = "flex-md") {
     const issues = [];
     const suggestions = [];
     if (formatType === "json-schema") {
@@ -69,7 +73,7 @@ export async function validateFormat(formatSpec, formatType = "flex-md") {
         }
     };
 }
-export function parseOutputFormatSpec(md, opts = {}) {
+function parseOutputFormatSpec(md, opts = {}) {
     const headingRx = opts.headingRegex ?? /^##\s*Output format\b/i;
     const lines = md.split("\n");
     // find OFS start
@@ -144,7 +148,7 @@ export 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 (normalizeName(name) !== "output format") {
+            if ((0, parse_js_1.normalizeName)(name) !== "output format") {
                 const s = { name, kind: "text" };
                 sections.push(s);
                 currentSection = s;

package/dist/ofs/stringify.js

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

package/dist/pipeline/enforce.js

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

package/dist/pipeline/kind.js

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

package/dist/strictness/container.js

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

package/dist/strictness/processor.js

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

package/dist/strictness/types.js

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

package/dist/tokens/auto-fix.js

@@ -1,7 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoFix = autoFix;
 /**
  * Automatically apply fixable improvements
  */
-export function autoFix(spec, improvements, options = {}) {
+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,9 +1,13 @@
-import { parseSystemPart } from './parser.js';
-import { detectSystemPartLevel } from './compliance.js';
+"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");
 /**
  * Calculate cognitive cost of creating/maintaining spec
  */
-export function calculateCognitiveCost(spec) {
+function calculateCognitiveCost(spec) {
     const perSection = [];
     let totalCost = 0;
     let complexityCost = 0;
@@ -34,8 +38,8 @@ export function calculateCognitiveCost(spec) {
  */
 function calculateSectionCost(section) {
     const kind = section.kind || 'text';
-    const systemPart = parseSystemPart(section.instruction, kind);
-    const level = systemPart ? detectSystemPartLevel(systemPart, kind) : null;
+    const systemPart = (0, parser_js_1.parseSystemPart)(section.instruction, kind);
+    const level = systemPart ? (0, compliance_js_1.detectSystemPartLevel)(systemPart, kind) : null;
     const factors = [];
     let cost = 0;
     // Base cost by level
@@ -166,7 +170,7 @@ function generateCostRecommendation(totalCost, sectionCount) {
 /**
  * Compare cognitive cost across different compliance levels
  */
-export function compareLevelCosts(spec) {
+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,8 +1,12 @@
-import { parseSystemPart } from './parser.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectSystemPartLevel = detectSystemPartLevel;
+exports.checkSpecCompliance = checkSpecCompliance;
+const parser_js_1 = require("./parser.js");
 /**
  * Detect the compliance level of a system part
  */
-export function detectSystemPartLevel(systemPart, kind) {
+function detectSystemPartLevel(systemPart, kind) {
     const { parsed } = systemPart;
     switch (parsed.type) {
         case 'length':
@@ -31,13 +35,13 @@ export function detectSystemPartLevel(systemPart, kind) {
 /**
  * Check if a spec complies with a target level
  */
-export function checkSpecCompliance(spec, targetLevel = 2) {
+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 = parseSystemPart(section.instruction, kind);
+        const systemPart = (0, parser_js_1.parseSystemPart)(section.instruction, kind);
         const level = systemPart ? detectSystemPartLevel(systemPart, kind) : 0;
         totalLevel += level;
         if (level >= targetLevel) {

package/dist/tokens/confidence.js

@@ -1,9 +1,12 @@
-import { parseSystemPart } from './parser.js';
-import { detectSystemPartLevel } from './compliance.js';
+"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");
 /**
  * Calculate confidence in token estimation
  */
-export function calculateConfidence(spec) {
+function calculateConfidence(spec) {
     const bySection = [];
     const factors = [];
     let totalConfidence = 0;
@@ -49,9 +52,9 @@ export function calculateConfidence(spec) {
  */
 function analyzeSectionConfidence(section) {
     const kind = section.kind || 'text';
-    const systemPart = parseSystemPart(section.instruction, kind);
+    const systemPart = (0, parser_js_1.parseSystemPart)(section.instruction, kind);
     const hasSystemPart = systemPart !== null;
-    const level = systemPart ? detectSystemPartLevel(systemPart, kind) : null;
+    const level = systemPart ? (0, compliance_js_1.detectSystemPartLevel)(systemPart, kind) : null;
     let confidence = 0;
     let quality = 'none';
     if (systemPart && level !== null) {
@@ -137,7 +140,7 @@ function getConfidenceAdjustment(systemPart, _section) {
  */
 function calculateCoverageFactor(spec) {
     const total = spec.sections.length;
-    const withSystemParts = spec.sections.filter(s => parseSystemPart(s.instruction, s.kind || 'text') !== null).length;
+    const withSystemParts = spec.sections.filter(s => (0, parser_js_1.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,5 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOKEN_CONSTANTS = void 0;
+exports.estimateTokens = estimateTokens;
+exports.getFallbackEstimate = getFallbackEstimate;
 // Calibrated token constants
-export const TOKEN_CONSTANTS = {
+exports.TOKEN_CONSTANTS = {
     // Text lengths (enumerated)
     lengths: {
         '1 sentence': 25,
@@ -19,7 +24,7 @@ export const TOKEN_CONSTANTS = {
     headingOverhead: 10,
     baseOverhead: 50
 };
-export function estimateTokens(systemPart) {
+function estimateTokens(systemPart) {
     const { parsed } = systemPart;
     switch (parsed.type) {
         case 'length':
@@ -33,7 +38,7 @@ export function estimateTokens(systemPart) {
     }
 }
 function estimateTextLength(value) {
-    const estimated = TOKEN_CONSTANTS.lengths[value];
+    const estimated = exports.TOKEN_CONSTANTS.lengths[value];
     return {
         estimated,
         min: Math.floor(estimated * 0.7),
@@ -46,26 +51,26 @@ function estimateItems(parsed) {
     if (max !== null) {
         // Range: "3-5" → use average
         const avg = (min + max) / 2;
-        const estimated = Math.round(avg * TOKEN_CONSTANTS.perItem);
+        const estimated = Math.round(avg * exports.TOKEN_CONSTANTS.perItem);
         return {
             estimated,
-            min: min * TOKEN_CONSTANTS.perItem,
-            max: max * TOKEN_CONSTANTS.perItem,
+            min: min * exports.TOKEN_CONSTANTS.perItem,
+            max: max * exports.TOKEN_CONSTANTS.perItem,
             confidence: 'high'
         };
     }
     if (atLeast) {
         // "at least 3" → estimate at min + 50%
-        const estimated = Math.round(min * 1.5 * TOKEN_CONSTANTS.perItem);
+        const estimated = Math.round(min * 1.5 * exports.TOKEN_CONSTANTS.perItem);
         return {
             estimated,
-            min: min * TOKEN_CONSTANTS.perItem,
-            max: min * 3 * TOKEN_CONSTANTS.perItem,
+            min: min * exports.TOKEN_CONSTANTS.perItem,
+            max: min * 3 * exports.TOKEN_CONSTANTS.perItem,
             confidence: 'medium'
         };
     }
     // Exact: "3" → use exact value
-    const estimated = min * TOKEN_CONSTANTS.perItem;
+    const estimated = min * exports.TOKEN_CONSTANTS.perItem;
     return {
         estimated,
         min: Math.floor(estimated * 0.8),
@@ -84,15 +89,15 @@ function estimateTable(parsed) {
         : parsed.columns.atLeast
             ? parsed.columns.min * 1.5
             : parsed.columns.min;
-    const estimated = Math.round(rowAvg * colAvg * TOKEN_CONSTANTS.perTableCell);
+    const estimated = Math.round(rowAvg * colAvg * exports.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 * TOKEN_CONSTANTS.perTableCell,
-        max: maxCells * TOKEN_CONSTANTS.perTableCell,
+        min: minCells * exports.TOKEN_CONSTANTS.perTableCell,
+        max: maxCells * exports.TOKEN_CONSTANTS.perTableCell,
         confidence: (parsed.rows.max && parsed.columns.max) ? 'high' : 'medium'
     };
 }
@@ -101,16 +106,16 @@ function estimateCodeLines(parsed) {
     if (max !== null) {
         // Range: "10-20"
         const avg = (min + max) / 2;
-        const estimated = Math.round(avg * TOKEN_CONSTANTS.perCodeLine);
+        const estimated = Math.round(avg * exports.TOKEN_CONSTANTS.perCodeLine);
         return {
             estimated,
-            min: min * TOKEN_CONSTANTS.perCodeLine,
-            max: max * TOKEN_CONSTANTS.perCodeLine,
+            min: min * exports.TOKEN_CONSTANTS.perCodeLine,
+            max: max * exports.TOKEN_CONSTANTS.perCodeLine,
             confidence: 'high'
         };
     }
     // Exact or approximate: "10" or "~10"
-    const estimated = min * TOKEN_CONSTANTS.perCodeLine;
+    const estimated = min * exports.TOKEN_CONSTANTS.perCodeLine;
     const variance = approximate ? 0.3 : 0.15;
     return {
         estimated,
@@ -120,7 +125,7 @@ function estimateCodeLines(parsed) {
     };
 }
 // Fallback for sections without system parts
-export function getFallbackEstimate(kind, required) {
+function getFallbackEstimate(kind, required) {
     const fallbacks = {
         text: 150,
         list: 200,