flex-md 2.0.0 → 3.0.0

package/dist/strictness/types.js

@@ -0,0 +1,106 @@
+export function strictnessDefaults(level) {
+    const common = {
+        tablesGuidance: "auto",
+        listsGuidance: "auto",
+        emptyNoneGuidance: "auto",
+        containerGuidance: "auto",
+        typedJsonGuidance: "auto",
+        acceptAnyHeadingLevel: true,
+        duplicateSectionStrategy: "merge",
+    };
+    if (level === 0) {
+        return {
+            ...common,
+            level,
+            container: "none",
+            requireOfs: false,
+            requireAllSections: false,
+            policy: {
+                outsideContainer: "ignore",
+                missingContainer: "ignore",
+                multipleContainers: "ignore",
+                missingRequiredSection: "warn",
+                missingOptionalSection: "ignore",
+                wrongSectionKindRequired: "warn",
+                wrongSectionKindOptional: "ignore",
+                emptySectionWithoutNoneRequired: "warn",
+                emptySectionWithoutNoneOptional: "ignore",
+                missingRequiredTable: "warn",
+                missingOptionalTable: "ignore",
+                orderedTableViolationsRequired: "warn",
+                orderedTableViolationsOptional: "ignore",
+            }
+        };
+    }
+    if (level === 1) {
+        return {
+            ...common,
+            level,
+            container: "none",
+            requireOfs: true,
+            requireAllSections: true,
+            policy: {
+                missingRequiredSection: "error",
+                missingOptionalSection: "ignore",
+                wrongSectionKindRequired: "error",
+                wrongSectionKindOptional: "warn",
+                emptySectionWithoutNoneRequired: "error",
+                emptySectionWithoutNoneOptional: "warn",
+                missingRequiredTable: "error",
+                missingOptionalTable: "ignore",
+                orderedTableViolationsRequired: "error",
+                orderedTableViolationsOptional: "warn",
+            }
+        };
+    }
+    if (level === 2) {
+        return {
+            ...common,
+            level,
+            container: "markdown_fence",
+            requireSingleContainer: true,
+            requireOfs: true,
+            requireAllSections: true,
+            policy: {
+                outsideContainer: "error",
+                missingContainer: "error",
+                multipleContainers: "error",
+                missingRequiredSection: "error",
+                missingOptionalSection: "ignore",
+                wrongSectionKindRequired: "error",
+                wrongSectionKindOptional: "warn",
+                emptySectionWithoutNoneRequired: "error",
+                emptySectionWithoutNoneOptional: "warn",
+                missingRequiredTable: "error",
+                missingOptionalTable: "ignore",
+                orderedTableViolationsRequired: "error",
+                orderedTableViolationsOptional: "warn",
+            }
+        };
+    }
+    return {
+        ...common,
+        level: 3,
+        container: "markdown_fence",
+        requireSingleContainer: true,
+        requireOfs: true,
+        requireAllSections: true,
+        requireTypedJson: true,
+        policy: {
+            outsideContainer: "error",
+            missingContainer: "error",
+            multipleContainers: "error",
+            missingRequiredSection: "error",
+            missingOptionalSection: "ignore",
+            wrongSectionKindRequired: "error",
+            wrongSectionKindOptional: "warn",
+            emptySectionWithoutNoneRequired: "error",
+            emptySectionWithoutNoneOptional: "warn",
+            missingRequiredTable: "error",
+            missingOptionalTable: "ignore",
+            orderedTableViolationsRequired: "error",
+            orderedTableViolationsOptional: "warn",
+            jsonPayloadMissing: "error"
+        }
+    };
+}

package/dist/test-pipeline.d.ts

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

package/dist/test-pipeline.js

@@ -0,0 +1,53 @@
+import { enforceFlexMd, parseOutputFormatSpec, detectResponseKind } from "./index.js";
+function assert(condition, message) {
+    if (!condition) {
+        throw new Error(`Assertion failed: ${message}`);
+    }
+}
+console.log("🧪 Running Pipeline & JSON Detection Tests\n");
+const spec = parseOutputFormatSpec(`
+## Output format
+- Answer — prose (required)
+- Reasoning — ordered list (optional)
+`);
+// 1. Detection Kind
+console.log("--- Detection Kind ---");
+const mdResp = "## Answer\nThis is an answer.";
+const kind1 = detectResponseKind(mdResp, spec);
+console.log("FlexMD Kind:", kind1.kind);
+assert(kind1.kind === "flexmd", "Should detect flexmd");
+const issuesResp = "## Status\n- status: error\n- code: fail\n- message: fail\n\n## Issues\n- issue: x";
+const kind2 = detectResponseKind(issuesResp, spec);
+console.log("Issues Kind:", kind2.kind);
+assert(kind2.kind === "issues", "Should detect issues");
+const plainResp = "Just some text.";
+const kind3 = detectResponseKind(plainResp, spec);
+console.log("Markdown Kind:", kind3.kind);
+assert(kind3.kind === "markdown", "Should detect markdown");
+// 2. JSON fixing
+console.log("\n--- JSON Fixing ---");
+const jsonResp = "```json\n{\n  \"Answer\": \"Parsed from JSON\",\n  \"Reasoning\": [\"Step 1\", \"Step 2\"]\n}\n```";
+const resultJson = enforceFlexMd(jsonResp, spec, { level: 1 });
+console.log("JSON Fixed OK:", resultJson.ok);
+console.log("JSON Fixed Content:\n", resultJson.extracted?.sectionsByName["Answer"]?.md);
+assert(resultJson.ok === true, "Enforce should succeed with fixed JSON");
+assert(!!resultJson.extracted?.sectionsByName["Answer"]?.md.includes("Parsed from JSON"), "Should extract from fixed JSON");
+assert(resultJson.extracted?.sectionsByName["Reasoning"]?.list?.items.length === 2, "Should extract list from fixed JSON");
+// 3. Raw JSON object
+console.log("\n--- Raw JSON Object ---");
+const rawJson = "{\"Answer\": \"Raw JSON\"}";
+const resultRaw = enforceFlexMd(rawJson, spec, { level: 1 });
+console.log("Raw JSON Fixed OK:", resultRaw.ok);
+assert(resultRaw.ok === true, "Should fix raw JSON");
+// 4. Missing sections fixing
+console.log("\n--- Missing Sections ---");
+// The fixer (repairToMarkdownLevel) SHOULD add missing required sections.
+const failingResp = "## SomeOtherSection\nContent";
+const resultFixed = enforceFlexMd(failingResp, spec, { level: 1 });
+console.log("Auto-Repaired OK:", resultFixed.ok);
+console.log("Repaired Content Contains 'Answer':", resultFixed.outputText.includes("## Answer"));
+console.log("Repaired Content Contains 'None':", resultFixed.outputText.includes("None"));
+assert(resultFixed.ok === true, "Should be ok if required sections are auto-repaired");
+assert(resultFixed.outputText.includes("## Answer"), "Should have added 'Answer' heading");
+assert(resultFixed.outputText.includes("None"), "Should have filled with 'None'");
+console.log("\n✅ Pipeline Tests Passed");

package/dist/test-runner.js

@@ -2,11 +2,13 @@ import {
 // Layer A
 parseFlexMd, stringifyFlexMd, validateFlexMd, 
 // Layer B
-parseOutputFormatSpec, stringifyOutputFormatSpec, enrichInstructions, validateOutput, extractOutput, 
+parseOutputFormatSpec, stringifyOutputFormatSpec, enrichInstructions, validateMarkdownAgainstOfs as validateOutput, extractFromMarkdown as extractOutput, 
 // Outline
 buildOutline, renderOutline, 
 // Parsers
-parseList, parsePipeTable, extractAllTables, 
+parseNestedList as parseList, parsePipeTable, extractPipeTables as extractAllTables, enforceOrderedTable, 
+// Strictness
+strictnessDefaults, 
 // Layer C
 detectObjects, parseAny } from "./index.js";
 let passed = 0;
@@ -90,6 +92,7 @@ Include these sections somewhere (order does not matter):
 - Assumptions — list
 `;
     const spec = parseOutputFormatSpec(md);
+    assert(spec !== null, "Spec should not be null");
     assert(spec.sections.length === 3, "Should have 3 sections");
     assert(spec.sections[0].name === "Short answer", "First section name");
     assert(spec.sections[0].kind === "prose", "First section kind");
@@ -124,7 +127,7 @@ test("Enrich instructions", () => {
         tables: [],
         emptySectionValue: "None"
     };
-    const instructions = enrichInstructions(spec);
+    const instructions = enrichInstructions(spec, strictnessDefaults(1));
     assert(instructions.includes("numbered items"), "Should mention ordered lists");
     assert(instructions.includes("bullets"), "Should mention lists");
     assert(instructions.includes("None"), "Should mention empty value");
@@ -141,7 +144,7 @@ test("Validate output against OFS", () => {
         tables: []
     };
     const md = `## Answer\nThe answer is 42.`;
-    const result = validateOutput(md, spec);
+    const result = validateOutput(md, spec, strictnessDefaults(1));
     assert(result.ok === true, "Should validate successfully");
 });
 test("Extract output from OFS", () => {
@@ -163,7 +166,7 @@ The answer is 42.
 1. First step
 2. Second step
 `;
-    const extracted = extractOutput(md, spec);
+    const extracted = extractOutput(md, spec, strictnessDefaults(1));
     assert(extracted.sectionsByName["Answer"].md.includes("42"), "Should extract answer");
     assert(extracted.sectionsByName["Steps"].list?.ordered === true, "Should parse ordered list");
     assert(extracted.sectionsByName["Steps"].list?.items.length === 2, "Should have 2 items");
@@ -249,7 +252,6 @@ test("Parse pipe table", () => {
     assert(table !== null, "Should parse table");
     assert(table.columns.length === 2, "Should have 2 columns");
     assert(table.rows.length === 2, "Should have 2 rows");
-    assert(table.kind === "table", "Should be regular table");
 });
 test("Parse ordered table", () => {
     const md = `| # | Task | Status |
@@ -259,7 +261,8 @@ test("Parse ordered table", () => {
 `;
     const table = parsePipeTable(md);
     assert(table !== null, "Should parse table");
-    assert(table.kind === "ordered_table", "Should be ordered table");
+    const issues = enforceOrderedTable(table);
+    assert(issues.length === 0, "Should have no ordered table issues");
     assert(table.columns[0] === "#", "First column should be #");
 });
 test("Extract all tables", () => {

package/dist/test-strictness.d.ts

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

package/dist/test-strictness.js

@@ -0,0 +1,213 @@
+import { parseOutputFormatSpec, processResponseMarkdown, strictnessDefaults } from "../src/index.js";
+const specText = `
+## Output format (Markdown)
+Include these sections somewhere (order does not matter):
+
+- Short answer — prose
+- Long answer — prose
+- Reasoning — ordered list
+- Assumptions — list
+- Unknowns — list
+
+tables:
+- (property, value — table)
+
+empty sections:
+- If a section is empty, write \`None\`.
+`;
+const spec = parseOutputFormatSpec(specText);
+// --- L0 Test ---
+console.log("--- Level 0 Test ---");
+const l0Response = `
+I thought about it.
+## Short answer
+Yes, it works.
+
+## Unknowns
+- None so far.
+`;
+const l0Result = processResponseMarkdown(l0Response, spec, strictnessDefaults(0));
+console.log("L0 OK:", l0Result.ok);
+console.log("L0 Issues:", l0Result.issues);
+// --- L1 Test ---
+console.log("\n--- Level 1 Test ---");
+const l1Response = `
+## Short answer
+Yes.
+
+## Long answer
+Full details.
+
+## Reasoning
+1. Step one.
+2. Step two.
+
+## Assumptions
+- Assumption A.
+
+## Unknowns
+None
+`;
+const l1Result = processResponseMarkdown(l1Response, spec, strictnessDefaults(1));
+console.log("L1 OK:", l1Result.ok);
+console.log("L1 Issues:", l1Result.issues);
+// --- L2 Test ---
+console.log("\n--- Level 2 Test ---");
+const l2Response = `
+Some chatter before.
+\`\`\`markdown
+## Short answer
+Yes.
+## Long answer
+None
+## Reasoning
+1. A
+## Assumptions
+None
+## Unknowns
+None
+\`\`\`
+Some chatter after.
+`;
+const l2Result = processResponseMarkdown(l2Response, spec, strictnessDefaults(2));
+console.log("L2 OK (should be false if chatter exists):", l2Result.ok);
+console.log("L2 Issues (should include 'content_outside_container'):", l2Result.issues);
+const l2ResponseClean = `\`\`\`markdown
+## Short answer
+Yes.
+## Long answer
+None
+## Reasoning
+1. A
+## Assumptions
+None
+## Unknowns
+None
+\`\`\``;
+const l2ResultClean = processResponseMarkdown(l2ResponseClean, spec, strictnessDefaults(2));
+console.log("L2 Clean OK:", l2ResultClean.ok);
+// --- L3 Test ---
+console.log("\n--- Level 3 Test ---");
+const l3Response = `\`\`\`markdown
+## Short answer
+Data processed.
+## Long answer
+None
+## Reasoning
+1. Step
+## Assumptions
+None
+## Unknowns
+None
+
+\`\`\`json
+{ "status": "success", "val": 42 }
+\`\`\`
+\`\`\``;
+// The regex in processor.ts is: /```json\s*\n([\s\S]*?)\n```/i
+// Let's see why it failed. Ah, the innerMarkdown was extracted but maybe the nested blocks were messed up.
+// Actually, l3Result returned issues: [ 'content_outside_container', 'json_payload_missing' ]
+// content_outside_container is due to the trailing \`\`\` outside if the first one was matched greedily? 
+// No, regex is non-greedy in container.ts: /\`\`\`" + fenceLang + "\\s*\\n([\\s\\S]*?)\\n\`\`\`/i
+// Wait, the container extractor in container.ts uses: /\`\`\`" + fenceLang + "\\s*\\n([\\s\\S]*?)\\n\`\`\`/i
+// In my L3 test:
+// \`\`\`markdown
+// ...
+// \`\`\`json
+// ...
+// \`\`\`
+// \`\`\`
+// The second to last \`\`\` matches the end of the markdown block. The last \`\`\` is "outside".
+const l3ResponseFixed = `\`\`\`markdown
+## Short answer
+Data processed.
+## Long answer
+None
+## Reasoning
+1. Step
+## Assumptions
+None
+## Unknowns
+None
+
+\`\`\`json
+{ "status": "success", "val": 42 }
+\`\`\`
+\`\`\``;
+// In this one there are two closing fences.
+const l3ResponseSimple = `\`\`\`markdown
+## Short answer
+Data processed.
+## Long answer
+None
+## Reasoning
+1. Step
+## Assumptions
+None
+## Unknowns
+None
+
+\`\`\`json
+{ "status": "success", "val": 42 }
+\`\`\`
+\`\`\``;
+// Let's try again with a simpler L3 mock
+const l3ResponseSuccess = `\`\`\`markdown
+## Short answer
+Done.
+## Long answer
+None
+## Reasoning
+1. A
+## Assumptions
+None
+## Unknowns
+None
+
+\`\`\`json
+{"ok": true}
+\`\`\`
+\`\`\``;
+const lResult3 = processResponseMarkdown(l3ResponseSuccess, spec, strictnessDefaults(3));
+console.log("L3 Success OK:", lResult3.ok);
+console.log("L3 Issues:", lResult3.issues);
+// --- Semi-Strict Test ---
+console.log("\n--- Semi-Strict Test ---");
+const semiStrictSpecText = `
+## Output format
+- Answer — prose (required)
+- Extra — list (optional)
+`;
+const semiStrictSpec = parseOutputFormatSpec(semiStrictSpecText);
+const semiStrictResponse = `
+## Answer
+This is the answer.
+`;
+// Level 1 defaults to requireAllSections: true. 
+// But "Extra" is marked (optional).
+const semiStrictResult = processResponseMarkdown(semiStrictResponse, semiStrictSpec, { level: 1 });
+console.log("Semi-Strict Missing Optional OK:", semiStrictResult.ok); // Should be true
+console.log("Semi-Strict Issues:", semiStrictResult.issues);
+const semiStrictResponseError = `
+## Extra
+- Something
+`;
+const semiStrictResultError = processResponseMarkdown(semiStrictResponseError, semiStrictSpec, { level: 1 });
+console.log("Semi-Strict Missing Required OK:", semiStrictResultError.ok); // Should be false
+console.log("Semi-Strict Issues (should have missing_section:Answer):", semiStrictResultError.issues.map((i) => i.code));
+// --- Mode B (Issues Envelope) Test ---
+console.log("\n--- Mode B Test ---");
+const modeBResponse = `
+## Status
+- status: error
+- code: missing_input
+- message: The user forgot the org_id.
+
+## Issues
+- issue: missing_org_id
+  hint: please provide org_id
+`;
+const modeBResult = processResponseMarkdown(modeBResponse, semiStrictSpec, { level: 1 });
+console.log("Mode B Detected:", !!modeBResult.issuesEnvelope);
+console.log("Mode B Status Code:", modeBResult.issuesEnvelope?.status.code);
+console.log("Mode B OK (should be false for error status):", modeBResult.ok);

package/dist/types.d.ts

@@ -1,12 +1,8 @@
 export type FlexMetaValue = string | string[] | number | boolean | null;
 export interface FlexPayload {
-    /** Language from the fenced block, e.g. "json", "yaml", "text" */
     lang?: string;
-    /** Parsed value for json fences; otherwise a string raw value */
     value: unknown;
-    /** Raw text inside the fence (no surrounding ``` lines) */
     raw: string;
-    /** If lang=json but parsing failed */
     parseError?: string;
 }
 export interface FlexFrame {
@@ -14,11 +10,8 @@ export interface FlexFrame {
     role?: string;
     id?: string;
     ts?: string;
-    /** Metadata from @key: lines */
     meta?: Record<string, FlexMetaValue>;
-    /** Body markdown between header/meta and next frame header */
     body_md?: string;
-    /** Payloads keyed by @payload:name: X */
     payloads?: Record<string, FlexPayload>;
 }
 export interface FlexDocument {
@@ -27,38 +20,13 @@ export interface FlexDocument {
     frames: FlexFrame[];
 }
 export interface ParseOptions {
-    /**
-     * Which metadata keys should be split by commas into string[]
-     * Default: ["tags", "refs"]
-     */
     arrayMetaKeys?: string[];
-    /**
-     * How to parse metadata values:
-     * - "strings": all values remain strings (default)
-     * - "infer": safely infer boolean, null, number
-     * - "schema": use metaSchema to determine types
-     */
     metaTypeMode?: "strings" | "infer" | "schema";
-    /**
-     * Schema for metadata value types (used when metaTypeMode="schema")
-     * Example: { priority: "number", enabled: "boolean" }
-     */
     metaSchema?: Record<string, "string" | "number" | "boolean" | "null">;
 }
 export interface StringifyOptions {
-    /**
-     * If true, omit empty sections when converting JSON -> FlexMD.
-     * Default: true
-     */
     skipEmpty?: boolean;
-    /**
-     * Which meta keys should be rendered as comma-separated lists if arrays.
-     * Default: ["tags", "refs"]
-     */
     arrayMetaKeys?: string[];
-    /**
-     * Preferred fence marker. Default: "```"
-     */
     fence?: "```" | "~~~";
 }
 export interface FlexValidationError {
@@ -70,26 +38,76 @@ export interface FlexValidationResult {
     valid: boolean;
     errors: FlexValidationError[];
 }
-export type SectionKind = "prose" | "list" | "ordered_list";
-export interface OfsSection {
+export type ResponseKind = "flexmd" | "issues" | "markdown";
+export type Enforcement = "ignore" | "warn" | "error";
+export interface ValidationPolicy {
+    missingSection?: Enforcement;
+    emptyRequiredSection?: Enforcement;
+    wrongSectionKind?: Enforcement;
+    containerMissing?: Enforcement;
+    containerMultiple?: Enforcement;
+    containerOutsideText?: Enforcement;
+    duplicateSection?: Enforcement;
+    malformedTable?: Enforcement;
+    malformedOrderedTable?: Enforcement;
+    noneIsAcceptableContent?: boolean;
+}
+export type Severity = "info" | "warn" | "error";
+export type IssueCode = "ISSUES_ENVELOPE_PRESENT" | "CONTAINER_MISSING" | "CONTAINER_MULTIPLE" | "CONTAINER_OUTSIDE_TEXT" | "MISSING_SECTION" | "EMPTY_REQUIRED_SECTION" | "DUPLICATE_SECTION" | "WRONG_SECTION_KIND" | "MALFORMED_TABLE" | "MALFORMED_ORDERED_TABLE";
+export interface ValidationIssue {
+    code: IssueCode;
+    severity: Severity;
+    message: string;
+    sectionName?: string;
+    span?: {
+        start: number;
+        end: number;
+    };
+}
+export interface ValidationResult {
+    ok: boolean;
+    level: 0 | 1 | 2 | 3;
+    issues: ValidationIssue[];
+    stats?: {
+        detectedKind: "markdown" | "issues" | "sectioned" | "fenced";
+        sectionCount: number;
+        missingRequired: string[];
+        duplicates: string[];
+        container: {
+            fenceCount: number;
+            hasOutsideText: boolean;
+            fenceLangs: string[];
+        };
+    };
+}
+export type SectionKind = "text" | "list" | "ordered_list" | "table" | "ordered_table";
+export interface OutputSectionSpec {
     name: string;
-    kind: SectionKind;
+    kind?: SectionKind;
+    required?: boolean;
+    columns?: string[];
+}
+/**
+ * @deprecated Use OutputSectionSpec
+ */
+export interface OfsSection extends OutputSectionSpec {
     hint?: string;
+    emptyAllowed?: boolean;
 }
-export type TableKind = "table" | "ordered_table";
 export interface OfsTable {
     columns: string[];
-    kind: TableKind;
+    kind: "table" | "ordered_table";
     by?: string;
+    required?: boolean;
 }
 export interface OutputFormatSpec {
-    descriptorType: "output_format_spec";
-    format: "markdown";
-    sectionOrderMatters: false;
-    sections: OfsSection[];
-    tablesOptional: boolean;
-    tables: OfsTable[];
+    sections: OutputSectionSpec[];
     emptySectionValue?: string;
+    descriptorType?: "output_format_spec";
+    format?: "markdown";
+    sectionOrderMatters?: boolean;
+    tablesOptional?: boolean;
+    tables?: OfsTable[];
 }
 export interface MdNode {
     title: string;
@@ -129,6 +147,16 @@ export interface ExtractedResult {
     }>;
     tables: ParsedTable[];
 }
+export interface ProcessResponseResult {
+    ok: boolean;
+    strictness: any;
+    usedContainer: boolean;
+    innerMarkdown: string;
+    validation: ValidationResult;
+    extracted?: ExtractedResult;
+    issues: ValidationIssue[];
+    issuesEnvelope?: IssuesEnvelope;
+}
 export type DetectedKind = "flexmd_fence" | "flexdoc_json_fence" | "raw_flexmd" | "markdown_snippet" | "none";
 export interface DetectedObject {
     kind: DetectedKind;
@@ -138,3 +166,11 @@ export interface DetectedObject {
     raw: string;
     inner?: string;
 }
+export interface IssuesEnvelope {
+    isIssuesEnvelope: boolean;
+    sections: Record<string, {
+        heading: string;
+        body: string;
+        bullets: string[];
+    }>;
+}

package/dist/validate/policy.d.ts

@@ -0,0 +1,10 @@
+import { Enforcement, SemiStrictPolicy } from "../strictness/types.js";
+import { ValidationIssue } from "./types.js";
+export declare function enforcementToSeverity(e: Enforcement): "error" | "warning";
+/**
+ * Decide whether to emit an issue:
+ * - "ignore" => return null
+ * - "warn"/"error" => return ValidationIssue with chosen severity
+ */
+export declare function makeIssue(policy: SemiStrictPolicy | undefined, key: keyof SemiStrictPolicy, fallback: Enforcement, issue: Omit<ValidationIssue, "severity">): ValidationIssue | null;
+export declare function hasErrors(issues: ValidationIssue[]): boolean;

package/dist/validate/policy.js

@@ -0,0 +1,17 @@
+export function enforcementToSeverity(e) {
+    return e === "error" ? "error" : "warning";
+}
+/**
+ * Decide whether to emit an issue:
+ * - "ignore" => return null
+ * - "warn"/"error" => return ValidationIssue with chosen severity
+ */
+export function makeIssue(policy, key, fallback, issue) {
+    const enforcement = (policy?.[key] ?? fallback);
+    if (enforcement === "ignore")
+        return null;
+    return { severity: enforcementToSeverity(enforcement), ...issue };
+}
+export function hasErrors(issues) {
+    return issues.some(i => i.severity === "error");
+}

package/dist/validate/types.d.ts

@@ -0,0 +1,11 @@
+export type ValidationSeverity = "error" | "warning";
+export interface ValidationIssue {
+    severity: ValidationSeverity;
+    code: string;
+    message: string;
+    path?: string;
+}
+export interface ValidationResult {
+    ok: boolean;
+    issues: ValidationIssue[];
+}

package/dist/validate/types.js

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

package/dist/validate/validate.d.ts

@@ -0,0 +1,2 @@
+import { OutputFormatSpec, ValidationPolicy, ValidationResult } from "../types.js";
+export declare function validateMarkdownAgainstOfs(input: string, spec: OutputFormatSpec, level: 0 | 1 | 2 | 3, policyOverride?: ValidationPolicy): ValidationResult;