@dotit/core 1.0.0

package/dist/parser.js

@@ -0,0 +1,1562 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SAFE_PARSE_OPTIONS = void 0;
+exports._resetIdCounter = _resetIdCounter;
+exports.detectHistoryBoundary = detectHistoryBoundary;
+exports.parseIntentText = parseIntentText;
+exports.parseIntentTextSafe = parseIntentTextSafe;
+const types_1 = require("./types");
+const aliases_1 = require("./aliases");
+const language_registry_1 = require("./language-registry");
+let _idCounter = 0;
+function nextId() {
+    return `b-${++_idCounter}`;
+}
+function _resetIdCounter() {
+    _idCounter = 0;
+}
+const MAX_INPUT_LENGTH = 10000000;
+const MAX_LINE_COUNT = 500000;
+const MAX_INLINE_LENGTH = 100000;
+const DANGEROUS_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+const AGENTIC_BLOCK_TYPES = new Set([
+    "step",
+    "decision",
+    "trigger",
+    "loop",
+    "checkpoint",
+    "audit",
+    "error",
+    "import",
+    "export",
+    "progress",
+    "context",
+    "tool",
+    "prompt",
+    "memory",
+    "result",
+    "handoff",
+    "wait",
+    "parallel",
+    "retry",
+    "gate",
+    "call",
+    "signal",
+    "policy",
+    "assert",
+    "secret",
+]);
+const V21_BLOCK_TYPES = new Set([
+    "result",
+    "handoff",
+    "wait",
+    "parallel",
+    "retry",
+]);
+const V22_BLOCK_TYPES = new Set(["gate", "call", "signal"]);
+const DOCGEN_LAYOUT_TYPES = new Set([
+    "font",
+    "page",
+    "break",
+    "header",
+    "footer",
+    "watermark",
+    "signline",
+]);
+const DOCGEN_WRITER_TYPES = new Set([
+    "byline",
+    "epigraph",
+    "caption",
+    "footnote",
+    "toc",
+    "dedication",
+]);
+const METADATA_KEYWORDS = new Set(["agent", "model"]);
+const TRUST_KEYWORDS = new Set([
+    "approve",
+    "sign",
+    "freeze",
+    "amendment",
+    "history",
+]);
+const DOCUMENT_IDENTITY_KEYWORDS = new Set([
+    "title",
+    "summary",
+    "track",
+]);
+const HISTORY_KEYWORDS = new Set(["revision"]);
+const V211_BLOCK_TYPES = new Set([
+    "def",
+    "metric",
+    "amendment",
+    "figure",
+    "signline",
+    "contact",
+    "deadline",
+]);
+function detectHistoryBoundary(lines) {
+    for (let i = 0; i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        if (trimmed === "history:" || trimmed === "history: ") {
+            return i;
+        }
+        if (trimmed === "---" && i < lines.length - 1) {
+            const next = lines[i + 1]?.trim();
+            if (next === "// history" || next?.startsWith("// history")) {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+function parseHistorySectionText(raw) {
+    const lines = raw.split("\n");
+    const registry = [];
+    const revisions = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("//"))
+            continue;
+        if (trimmed.startsWith("revision:")) {
+            const content = trimmed.replace(/^revision:\s*\|?\s*/, "");
+            const props = Object.create(null);
+            const segments = content.split(" | ");
+            for (const seg of segments) {
+                const colonIdx = seg.indexOf(":");
+                if (colonIdx > -1) {
+                    props[seg.slice(0, colonIdx).trim()] = seg.slice(colonIdx + 1).trim();
+                }
+            }
+            revisions.push({
+                version: props.version || "",
+                at: props.at || "",
+                by: props.by || "",
+                change: (props.change || "added"),
+                id: props.id || "",
+                block: props.block || "",
+                section: props.section,
+                was: props.was,
+                now: props.now,
+                wasSection: props["was-section"],
+                nowSection: props["now-section"],
+            });
+        }
+        else if (/^[a-z0-9]{5}\s*\|/.test(trimmed)) {
+            const parts = trimmed.split("|").map((p) => p.trim());
+            if (parts.length >= 4) {
+                registry.push({
+                    id: parts[0],
+                    blockType: parts[1],
+                    section: parts[2],
+                    fingerprint: parts[3],
+                    dead: parts[4] === "dead" || undefined,
+                });
+            }
+        }
+    }
+    return { registry, revisions, raw };
+}
+function parseContextKeyValuePairs(rawContent) {
+    const result = Object.create(null);
+    let content = rawContent.trim();
+    if (content.startsWith("|")) {
+        content = content.substring(1).trim();
+    }
+    const pairs = splitPipeMetadata(content);
+    for (const pair of pairs) {
+        const trimmed = pair.trim();
+        const cleaned = trimmed.startsWith("|")
+            ? trimmed.substring(1).trim()
+            : trimmed;
+        const kvMatch = cleaned.match(/^([\w]+)\s*=\s*"([^"]*)"/) ||
+            cleaned.match(/^([\w]+)\s*=\s*(\S+)/);
+        if (kvMatch) {
+            const key = kvMatch[1];
+            if (!DANGEROUS_KEYS.has(key))
+                result[key] = kvMatch[2];
+            continue;
+        }
+        const pipeMatch = cleaned.match(/^([\p{L}\p{N}_][\p{L}\p{N}_-]*):\s*(.*)$/u);
+        if (pipeMatch) {
+            const key = pipeMatch[1].trim();
+            if (!DANGEROUS_KEYS.has(key))
+                result[key] = pipeMatch[2].trim();
+        }
+    }
+    return result;
+}
+function detectArabic(text) {
+    const arabicRegex = /[\u0600-\u06FF]/;
+    return arabicRegex.test(text);
+}
+function splitPipeMetadata(rest) {
+    const parts = [];
+    let current = "";
+    for (let i = 0; i < rest.length; i++) {
+        if (i + 2 < rest.length &&
+            rest[i] === " " &&
+            rest[i + 1] === "|" &&
+            rest[i + 2] === " ") {
+            let backslashes = 0;
+            for (let j = i; j - 1 >= 0 && rest[j - 1] === "\\"; j--)
+                backslashes++;
+            const escaped = backslashes % 2 === 1;
+            if (!escaped) {
+                parts.push(current);
+                current = "";
+                i += 2;
+                continue;
+            }
+        }
+        current += rest[i];
+    }
+    parts.push(current);
+    return parts;
+}
+function splitTableRow(text) {
+    const cells = [];
+    let current = "";
+    let escaping = false;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (escaping) {
+            current += ch;
+            escaping = false;
+            continue;
+        }
+        if (ch === "\\") {
+            current += ch;
+            escaping = true;
+            continue;
+        }
+        if (ch === "|") {
+            cells.push(unescapeIntentText(current.trim()));
+            current = "";
+            continue;
+        }
+        current += ch;
+    }
+    cells.push(unescapeIntentText(current.trim()));
+    return cells.filter((c) => c !== "");
+}
+function parseInlineNodes(text) {
+    if (!text || text.length > MAX_INLINE_LENGTH) {
+        return {
+            content: text || "",
+            inline: [{ type: "text", value: text || "" }],
+        };
+    }
+    const inline = [];
+    let content = "";
+    let currentText = "";
+    const flushText = () => {
+        if (currentText) {
+            inline.push({ type: "text", value: currentText });
+            content += currentText;
+            currentText = "";
+        }
+    };
+    const addNode = (node) => {
+        flushText();
+        inline.push(node);
+        content += node.value;
+    };
+    const resolveDateToken = (token) => {
+        const lower = token.toLowerCase();
+        if (lower === "today") {
+            return new Date().toISOString().slice(0, 10);
+        }
+        if (lower === "tomorrow") {
+            const d = new Date();
+            d.setDate(d.getDate() + 1);
+            return d.toISOString().slice(0, 10);
+        }
+        if (/^\d{4}-\d{2}-\d{2}$/.test(token)) {
+            return token;
+        }
+        return null;
+    };
+    let i = 0;
+    while (i < text.length) {
+        if (text[i] === "[") {
+            const fnRefMatch = text.slice(i).match(/^\[\^(\d+)\]/);
+            if (fnRefMatch) {
+                addNode({ type: "footnote-ref", value: fnRefMatch[1] });
+                i += fnRefMatch[0].length;
+                continue;
+            }
+            const linkEnd = text.indexOf("](", i);
+            const urlEnd = linkEnd >= 0 ? text.indexOf(")", linkEnd + 2) : -1;
+            if (linkEnd > i && urlEnd > linkEnd) {
+                const linkText = text.slice(i + 1, linkEnd);
+                const linkUrl = text.slice(linkEnd + 2, urlEnd);
+                addNode({ type: "link", value: linkText, href: linkUrl });
+                i = urlEnd + 1;
+                continue;
+            }
+            if (text[i + 1] !== "[") {
+                const close = text.indexOf("]", i + 1);
+                if (close > i && text[close + 1] === "{") {
+                    const braceEnd = text.indexOf("}", close + 2);
+                    if (braceEnd > close + 1 && text[braceEnd + 1] !== "}") {
+                        const props = {};
+                        for (const seg of text.slice(close + 2, braceEnd).split(";")) {
+                            const c = seg.indexOf(":");
+                            if (c > 0) {
+                                const k = seg.slice(0, c).trim();
+                                if (k)
+                                    props[k] = seg.slice(c + 1).trim();
+                            }
+                        }
+                        if (Object.keys(props).length > 0) {
+                            addNode({ type: "styled", value: text.slice(i + 1, close), props });
+                            i = braceEnd + 1;
+                            continue;
+                        }
+                    }
+                }
+            }
+        }
+        if (text.startsWith("[[", i)) {
+            const end = text.indexOf("]]", i + 2);
+            if (end > i + 2) {
+                const noteText = text.slice(i + 2, end).trim();
+                const pipeAt = noteText.indexOf("|");
+                if (pipeAt > 0 && pipeAt < noteText.length - 1) {
+                    const label = noteText.slice(0, pipeAt).trim();
+                    const href = noteText.slice(pipeAt + 1).trim();
+                    if (label && href) {
+                        addNode({ type: "link", value: label, href });
+                        i = end + 2;
+                        continue;
+                    }
+                }
+                addNode({ type: "inline-note", value: noteText });
+                i = end + 2;
+                continue;
+            }
+        }
+        if (text.startsWith("==", i)) {
+            const end = text.indexOf("==", i + 2);
+            if (end > i + 2) {
+                const quoteText = text.slice(i + 2, end);
+                addNode({ type: "inline-quote", value: quoteText });
+                i = end + 2;
+                continue;
+            }
+        }
+        if (text.startsWith("```", i)) {
+            const end = text.indexOf("```", i + 3);
+            if (end === -1) {
+                currentText += "```";
+                i += 3;
+                continue;
+            }
+            const codeText = text.slice(i + 3, end);
+            addNode({ type: "code", value: codeText });
+            i = end + 3;
+            continue;
+        }
+        if (text[i] === "`") {
+            const end = text.indexOf("`", i + 1);
+            if (end > i + 1) {
+                const labelText = text.slice(i + 1, end);
+                addNode({ type: "label", value: labelText });
+                i = end + 1;
+                continue;
+            }
+            currentText += "`";
+            i++;
+            continue;
+        }
+        const ch = text[i];
+        if (ch === "*" || ch === "_" || ch === "~" || ch === "^") {
+            const end = text.indexOf(ch, i + 1);
+            if (end === -1) {
+                currentText += ch;
+                i++;
+                continue;
+            }
+            const innerText = text.slice(i + 1, end);
+            const type = ch === "*"
+                ? "bold"
+                : ch === "_"
+                    ? "italic"
+                    : ch === "~"
+                        ? "strike"
+                        : "highlight";
+            addNode({ type, value: innerText });
+            i = end + 1;
+            continue;
+        }
+        const dateTokenMatch = text
+            .slice(i)
+            .match(/^@(today|tomorrow|\d{4}-\d{2}-\d{2})\b/i);
+        if (dateTokenMatch) {
+            const token = dateTokenMatch[1];
+            const iso = resolveDateToken(token);
+            if (iso) {
+                addNode({ type: "date", value: `@${token}`, iso });
+                i += dateTokenMatch[0].length;
+                continue;
+            }
+        }
+        const mentionMatch = text.slice(i).match(/^@([A-Za-z0-9_-]+)/);
+        if (mentionMatch) {
+            addNode({ type: "mention", value: mentionMatch[1] });
+            i += mentionMatch[0].length;
+            continue;
+        }
+        const tagMatch = text.slice(i).match(/^#([A-Za-z0-9_-]+)/);
+        if (tagMatch) {
+            addNode({ type: "tag", value: tagMatch[1] });
+            i += tagMatch[0].length;
+            continue;
+        }
+        if (text[i] === "{" &&
+            text[i + 1] !== "{" &&
+            (i === 0 || text[i - 1] !== "{")) {
+            const end = text.indexOf("}", i + 1);
+            if (end > i + 1 && text[end + 1] !== "}") {
+                const labelText = text.slice(i + 1, end).trim();
+                if (labelText && !labelText.includes("{")) {
+                    addNode({ type: "label", value: labelText });
+                    i = end + 1;
+                    continue;
+                }
+            }
+        }
+        currentText += text[i];
+        i++;
+    }
+    flushText();
+    return { content, inline };
+}
+function expandPropertyShortcuts(content) {
+    const shortcuts = Object.create(null);
+    content = content.replace(/!low\b/gi, () => {
+        shortcuts.priority = "low";
+        return "";
+    });
+    content = content.replace(/!medium\b/gi, () => {
+        shortcuts.priority = "medium";
+        return "";
+    });
+    content = content.replace(/!high\b/gi, () => {
+        shortcuts.priority = "high";
+        return "";
+    });
+    content = content.replace(/!critical\b/gi, () => {
+        shortcuts.priority = "critical";
+        return "";
+    });
+    content = content.replace(/@(\w+)/g, (_match, username) => {
+        shortcuts.owner = username;
+        return "";
+    });
+    content = content.replace(/🚨/g, () => {
+        shortcuts.priority = "urgent";
+        return "";
+    });
+    content = content.replace(/📅\s*(\S.*)/g, (_match, dateText) => {
+        shortcuts.due = dateText.trim();
+        return "";
+    });
+    content = content.replace(/✅/g, () => {
+        shortcuts.status = "completed";
+        return "";
+    });
+    content = content.replace(/⏰\s*(\S.*)/g, (_match, timeText) => {
+        shortcuts.time = timeText.trim();
+        return "";
+    });
+    content = content.replace(/\s+/g, " ").trim();
+    return { content, shortcuts };
+}
+function unescapeIntentText(text) {
+    let result = "";
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === "\\" && i + 1 < text.length) {
+            const next = text[i + 1];
+            if (next === "\\" || next === "|") {
+                result += next;
+                i++;
+                continue;
+            }
+        }
+        result += ch;
+    }
+    return result;
+}
+function parseLine(line, ctx) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return null;
+    const xNsMatch = trimmed.match(/^x-([a-z]+):\s*(.*)$/);
+    const fullXKeyword = xNsMatch ? `x-${xNsMatch[1]}` : "";
+    const extensionOwnsKeyword = ctx.extensions.some((ext) => (ext.keywords || []).some((k) => k.toLowerCase() === fullXKeyword));
+    if (xNsMatch && !extensionOwnsKeyword) {
+        const namespace = xNsMatch[1];
+        const afterColon = xNsMatch[2];
+        const parts = splitPipeMetadata(afterColon);
+        const xType = (parts[0] || "").trim();
+        const properties = Object.create(null);
+        let blockContent = "";
+        for (let i = 1; i < parts.length; i++) {
+            const segment = parts[i];
+            const propMatch = segment.match(/^([^:]+):\s*(.*)$/);
+            if (propMatch) {
+                const key = propMatch[1].trim();
+                const rawValue = propMatch[2].trim();
+                if (!DANGEROUS_KEYS.has(key)) {
+                    if (key === "content") {
+                        blockContent = unescapeIntentText(rawValue);
+                    }
+                    else {
+                        properties[key] = unescapeIntentText(rawValue);
+                    }
+                }
+            }
+        }
+        const { content: cleanContent, inline } = ctx.parseInline(blockContent);
+        const isKnownExt = language_registry_1.EXTENSION_KEYWORDS.has(xType);
+        if (isKnownExt) {
+            return {
+                id: nextId(),
+                type: xType,
+                content: cleanContent,
+                originalContent: afterColon,
+                properties: Object.keys(properties).length > 0 ? properties : undefined,
+                inline,
+            };
+        }
+        properties["x-type"] = xType;
+        properties["x-ns"] = namespace;
+        return {
+            id: nextId(),
+            type: "extension",
+            content: cleanContent,
+            originalContent: afterColon,
+            properties,
+            inline,
+        };
+    }
+    const keywordMatch = trimmed.match(/^(\p{L}[\p{L}\p{N}-]*):\s*(.*)$/u);
+    if (keywordMatch) {
+        const keyword = keywordMatch[1].toLowerCase();
+        const rest = keywordMatch[2];
+        const isKnown = ctx.keywords.has(keyword);
+        const isCoreKeyword = types_1.KEYWORDS.includes(keyword);
+        const looksLikeExtension = keyword.startsWith("x-") || keyword.startsWith("ext-");
+        if (!isKnown) {
+            if (looksLikeExtension) {
+                ctx.diagnostics.push({
+                    severity: "warning",
+                    code: "UNKNOWN_EXTENSION_KEYWORD",
+                    message: `Unknown extension keyword '${keyword}:'`,
+                    line: ctx.lineNumber,
+                    column: 1,
+                });
+                const { content: cleanContent, inline } = ctx.parseInline(trimmed);
+                return {
+                    id: nextId(),
+                    type: "extension",
+                    content: cleanContent,
+                    originalContent: trimmed,
+                    inline,
+                    properties: { keyword },
+                };
+            }
+            const customParts = splitPipeMetadata(rest);
+            const customContent = unescapeIntentText(customParts[0] || "");
+            const customProps = Object.create(null);
+            customProps["keyword"] = keyword;
+            for (let i = 1; i < customParts.length; i++) {
+                const seg = customParts[i];
+                const pm = seg.match(/^([^:]+):\s*(.*)$/);
+                if (pm) {
+                    const k = pm[1].trim();
+                    if (!k.includes("\\") && !k.includes("|") && !DANGEROUS_KEYS.has(k)) {
+                        customProps[k] = unescapeIntentText(pm[2].trim());
+                    }
+                }
+            }
+            const { content: parsedContent, inline } = ctx.parseInline(customContent);
+            return {
+                id: nextId(),
+                type: "custom",
+                content: parsedContent,
+                originalContent: trimmed,
+                inline,
+                properties: customProps,
+            };
+        }
+        let content;
+        const properties = Object.create(null);
+        const tableResolved = (aliases_1.ALIASES[keyword] ?? keyword);
+        if (keyword === "headers" ||
+            tableResolved === "columns" ||
+            tableResolved === "row") {
+            content = rest;
+        }
+        else {
+            const parts = splitPipeMetadata(rest);
+            content = unescapeIntentText(parts[0] || "");
+            let propStart = 1;
+            const trimmedContent = content.trim();
+            if (trimmedContent.startsWith("|")) {
+                const firstProp = trimmedContent.substring(1).trim();
+                const propMatch = firstProp.match(/^([^:]+):\s*(.*)$/);
+                if (propMatch) {
+                    const key = propMatch[1].trim();
+                    const rawValue = propMatch[2].trim();
+                    if (!key.includes("\\") &&
+                        !key.includes("|") &&
+                        !DANGEROUS_KEYS.has(key)) {
+                        properties[key] = unescapeIntentText(rawValue);
+                        content = "";
+                    }
+                }
+            }
+            for (let i = 1; i < parts.length; i++) {
+                const segment = parts[i];
+                const propMatch = segment.match(/^([^:]+):\s*(.*)$/);
+                if (propMatch) {
+                    const key = propMatch[1].trim();
+                    const rawValue = propMatch[2].trim();
+                    if (key.includes("\\") ||
+                        key.includes("|") ||
+                        DANGEROUS_KEYS.has(key)) {
+                        ctx.diagnostics.push({
+                            severity: "warning",
+                            code: "INVALID_PROPERTY_SEGMENT",
+                            message: `Invalid property key '${key}'. Property keys must not contain escapes.`,
+                            line: ctx.lineNumber,
+                            column: 1,
+                        });
+                        content += ` | ${unescapeIntentText(segment)}`;
+                        continue;
+                    }
+                    properties[key] = unescapeIntentText(rawValue);
+                }
+                else {
+                    ctx.diagnostics.push({
+                        severity: "warning",
+                        code: "INVALID_PROPERTY_SEGMENT",
+                        message: `Invalid property segment '${segment.trim()}'. Expected 'key: value'.`,
+                        line: ctx.lineNumber,
+                        column: 1,
+                    });
+                    content += ` | ${unescapeIntentText(segment)}`;
+                }
+            }
+        }
+        const { content: cleanContent, inline } = ctx.parseInline(content);
+        let handledByExtension = false;
+        for (const ext of ctx.extensions) {
+            const wantsKeyword = (ext.keywords || []).some((k) => k.toLowerCase() === keyword);
+            if (!wantsKeyword || !ext.parseBlock)
+                continue;
+            const overridden = ext.parseBlock({
+                keyword,
+                content,
+                properties: Object.keys(properties).length > 0 ? properties : undefined,
+                line: ctx.lineNumber,
+                column: 1,
+                parseInline: ctx.parseInline,
+            });
+            handledByExtension = true;
+            if (overridden)
+                return overridden;
+            if (overridden === null)
+                return null;
+        }
+        if (!isCoreKeyword && (handledByExtension || looksLikeExtension)) {
+            return {
+                id: nextId(),
+                type: "extension",
+                content: cleanContent,
+                originalContent: content,
+                properties: {
+                    ...(Object.keys(properties).length > 0 ? properties : {}),
+                    keyword,
+                },
+                inline,
+            };
+        }
+        const resolvedType = (aliases_1.ALIASES[keyword] ?? keyword);
+        if (language_registry_1.DEPRECATED_ALIASES.has(keyword)) {
+            ctx.diagnostics.push({
+                severity: "warning",
+                code: "DEPRECATED_KEYWORD",
+                message: `'${keyword}:' is deprecated. Use '${resolvedType}:' instead.`,
+                line: ctx.lineNumber,
+                column: 1,
+            });
+        }
+        if (language_registry_1.CALLOUT_ALIAS_MAP[keyword] && resolvedType === "info") {
+            properties.type = language_registry_1.CALLOUT_ALIAS_MAP[keyword];
+        }
+        if (keyword === "done" || resolvedType === "done") {
+            properties.status = "done";
+        }
+        if (resolvedType === "context") {
+            const kvPairs = parseContextKeyValuePairs(rest);
+            for (const [k, v] of Object.entries(kvPairs)) {
+                properties[k] = v;
+            }
+        }
+        if (resolvedType === "step" && !properties.status) {
+            properties.status = "pending";
+        }
+        if (resolvedType === "retry") {
+            if (properties.max)
+                properties.max = Number(properties.max);
+            if (properties.delay)
+                properties.delay = Number(properties.delay);
+            if (properties.retries)
+                properties.retries = Number(properties.retries);
+        }
+        if (resolvedType === "wait" && !properties.status) {
+            properties.status = "waiting";
+        }
+        if (resolvedType === "result" && !properties.status) {
+            properties.status = "success";
+        }
+        if (resolvedType === "gate" && !properties.status) {
+            properties.status = "blocked";
+        }
+        if (resolvedType === "parallel" && !properties.join) {
+            properties.join = "all";
+        }
+        if (resolvedType === "call" && !properties.status) {
+            properties.status = "pending";
+        }
+        if (resolvedType === "signal") {
+            if (!properties.level) {
+                properties.level = "info";
+            }
+        }
+        if (resolvedType === "image" && properties.at && !properties.src) {
+            ctx.diagnostics.push({
+                severity: "warning",
+                code: "DEPRECATED_PROPERTY",
+                message: "'at:' is deprecated on image: blocks. Use 'src:' instead.",
+                line: ctx.lineNumber,
+                column: 1,
+            });
+            properties.src = properties.at;
+            delete properties.at;
+        }
+        if (properties.timeout && !isNaN(Number(properties.timeout))) {
+            properties.timeout = Number(properties.timeout);
+        }
+        if (properties.priority && !isNaN(Number(properties.priority))) {
+            properties.priority = Number(properties.priority);
+        }
+        if (properties.retries && !isNaN(Number(properties.retries))) {
+            properties.retries = Number(properties.retries);
+        }
+        if (properties.delay && !isNaN(Number(properties.delay))) {
+            properties.delay = Number(properties.delay);
+        }
+        if (resolvedType === "font") {
+            if (properties.leading)
+                properties.leading = Number(properties.leading);
+        }
+        if (resolvedType === "page") {
+            if (properties.columns)
+                properties.columns = Number(properties.columns);
+            if (properties.numbering !== undefined) {
+                properties.numbering = properties.numbering === "true" ? 1 : 0;
+            }
+        }
+        if (resolvedType === "toc") {
+            if (properties.depth) {
+                properties.depth = Number(properties.depth);
+            }
+            else {
+                properties.depth = 2;
+            }
+            if (!properties.title) {
+                properties.title = "Contents";
+            }
+        }
+        if (resolvedType === "break") {
+            return {
+                id: nextId(),
+                type: "break",
+                content: "",
+                properties: Object.keys(properties).length > 0 ? properties : undefined,
+            };
+        }
+        return {
+            id: nextId(),
+            type: resolvedType,
+            ...(keyword !== resolvedType ? { keywordAlias: keyword } : {}),
+            content: cleanContent,
+            originalContent: content,
+            properties: Object.keys(properties).length > 0 ? properties : undefined,
+            inline,
+        };
+    }
+    const checkboxMatch = trimmed.match(/^(\[ \]|\[x\])\s*(.+)$/);
+    if (checkboxMatch) {
+        const isDone = checkboxMatch[1] === "[x]";
+        let content = unescapeIntentText(checkboxMatch[2]);
+        const { content: cleanContent, shortcuts } = expandPropertyShortcuts(content);
+        content = cleanContent;
+        const { content: finalContent, inline } = ctx.parseInline(content);
+        if (isDone)
+            shortcuts.status = "done";
+        return {
+            id: nextId(),
+            type: "task",
+            content: finalContent,
+            originalContent: content,
+            properties: Object.keys(shortcuts).length > 0 ? shortcuts : undefined,
+            inline,
+        };
+    }
+    if (trimmed.startsWith("- ") || trimmed.startsWith("* ")) {
+        const payload = trimmed.substring(2);
+        const depth = ctx.embedDepth ?? 0;
+        const embedded = depth < 2
+            ? parseLine(payload, {
+                ...ctx,
+                embedDepth: depth + 1,
+            })
+            : null;
+        if (embedded &&
+            embedded.type !== "list-item" &&
+            embedded.type !== "step-item") {
+            return {
+                id: nextId(),
+                type: "list-item",
+                content: embedded.content,
+                originalContent: embedded.originalContent,
+                properties: embedded.properties,
+                inline: embedded.inline,
+                children: [embedded],
+            };
+        }
+        const unescaped = unescapeIntentText(payload);
+        const { content: cleanContent, inline } = ctx.parseInline(unescaped);
+        return {
+            id: nextId(),
+            type: "list-item",
+            content: cleanContent,
+            originalContent: unescaped,
+            inline,
+        };
+    }
+    const orderedMatch = trimmed.match(/^(\d+)\.\s+(.+)$/);
+    if (orderedMatch) {
+        const content = unescapeIntentText(orderedMatch[2]);
+        const { content: cleanContent, inline } = ctx.parseInline(content);
+        return {
+            id: nextId(),
+            type: "step-item",
+            content: cleanContent,
+            originalContent: content,
+            inline,
+        };
+    }
+    const unescaped = unescapeIntentText(trimmed);
+    const { content: cleanContent, inline } = ctx.parseInline(unescaped);
+    return {
+        id: nextId(),
+        type: "text",
+        content: cleanContent,
+        originalContent: unescaped,
+        inline,
+    };
+}
+function parseIntentText(fileContent, options) {
+    if (typeof fileContent !== "string") {
+        return { version: "1.4", blocks: [], metadata: {}, diagnostics: [] };
+    }
+    if (fileContent.length === 0) {
+        return { version: "1.4", blocks: [], metadata: {}, diagnostics: [] };
+    }
+    if (fileContent.length > MAX_INPUT_LENGTH) {
+        return {
+            version: "1.4",
+            blocks: [],
+            metadata: {},
+            diagnostics: [
+                {
+                    severity: "error",
+                    code: "UNTERMINATED_CODE_BLOCK",
+                    message: `Input exceeds maximum allowed length of ${MAX_INPUT_LENGTH} characters.`,
+                    line: 1,
+                    column: 1,
+                },
+            ],
+        };
+    }
+    _resetIdCounter();
+    const lines = fileContent.split(/\r?\n/);
+    if (lines.length > MAX_LINE_COUNT) {
+        return {
+            version: "1.4",
+            blocks: [],
+            metadata: {},
+            diagnostics: [
+                {
+                    severity: "error",
+                    code: "UNTERMINATED_CODE_BLOCK",
+                    message: `Input exceeds maximum allowed line count of ${MAX_LINE_COUNT}.`,
+                    line: 1,
+                    column: 1,
+                },
+            ],
+        };
+    }
+    const blocks = [];
+    const diagnostics = [];
+    let currentSection = null;
+    let codeCaptureMode = false;
+    let codeCaptureType = "keyword";
+    let codeContent = [];
+    let codeStartLine = 0;
+    let pendingCodeProperties = null;
+    const historyBoundaryIdx = detectHistoryBoundary(lines);
+    const parseLines = historyBoundaryIdx === -1 ? lines : lines.slice(0, historyBoundaryIdx);
+    let historySection;
+    if (options?.includeHistorySection && historyBoundaryIdx !== -1) {
+        const historyRaw = lines.slice(historyBoundaryIdx).join("\n");
+        historySection = parseHistorySectionText(historyRaw);
+    }
+    if (historyBoundaryIdx !== -1 && lines[historyBoundaryIdx].trim() === "---") {
+        diagnostics.push({
+            severity: "warning",
+            code: "LEGACY_HISTORY_BOUNDARY",
+            message: "Legacy history boundary detected: '---' followed by '// history'. " +
+                "Use 'history:' keyword instead (v2.12+).",
+            line: historyBoundaryIdx + 1,
+            column: 1,
+        });
+    }
+    const signatureBlocks = [];
+    let trackingMeta;
+    let freezeMeta;
+    let stepAutoIdCounter = 0;
+    let seenSectionBlock = false;
+    const agenticMetadata = {};
+    const extensions = options?.extensions || [];
+    const keywords = new Set(types_1.KEYWORDS);
+    for (const alias of Object.keys(aliases_1.ALIASES)) {
+        keywords.add(alias);
+    }
+    for (const ext of extensions) {
+        for (const k of ext.keywords || []) {
+            keywords.add(k.toLowerCase());
+        }
+    }
+    const metaAccumulator = Object.create(null);
+    const defaultParseInline = (text) => parseInlineNodes(text);
+    const parseInline = (text) => {
+        for (const ext of extensions) {
+            if (!ext.parseInline)
+                continue;
+            const result = ext.parseInline({ text, defaultParseInline });
+            if (result)
+                return result;
+        }
+        return defaultParseInline(text);
+    };
+    let pendingTable = null;
+    let previousLineWasBlank = false;
+    function appendBlockWithProseMerge(target, block) {
+        const last = target[target.length - 1];
+        if (!previousLineWasBlank &&
+            last &&
+            (last.type === "text" || last.type === "body-text") &&
+            (block.type === "text" || block.type === "body-text")) {
+            const mergedOriginal = `${last.originalContent || last.content} ${block.originalContent || block.content}`;
+            const parsed = parseInline(mergedOriginal);
+            last.originalContent = mergedOriginal;
+            last.content = parsed.content;
+            last.inline = parsed.inline;
+            return;
+        }
+        target.push(block);
+    }
+    function flushPendingTable() {
+        if (!pendingTable)
+            return;
+        if (pendingTable.headers &&
+            pendingTable.headers.length > 0 &&
+            pendingTable.rows.length === 0) {
+            diagnostics.push({
+                severity: "warning",
+                code: "HEADERS_WITHOUT_ROWS",
+                message: "Table headers found with no following rows.",
+                line: pendingTable.headerLine || 1,
+                column: 1,
+            });
+        }
+        const block = {
+            id: nextId(),
+            type: "table",
+            content: pendingTable.originalHeaders || "",
+            table: {
+                headers: pendingTable.headers,
+                rows: pendingTable.rows,
+                headersKeyword: pendingTable.headersKeyword,
+                rowKeyword: pendingTable.rowKeyword,
+            },
+        };
+        if (currentSection && currentSection.children) {
+            currentSection.children.push(block);
+        }
+        else {
+            blocks.push(block);
+        }
+        pendingTable = null;
+    }
+    for (let i = 0; i < parseLines.length; i++) {
+        const line = parseLines[i];
+        const trimmed = line.trim();
+        if (codeCaptureMode) {
+            const isEndFence = codeCaptureType === "fence" && trimmed.startsWith("```");
+            if (isEndFence) {
+                const afterClosingFence = trimmed.replace(/^```/, "").trim();
+                if (afterClosingFence.startsWith("|")) {
+                    if (!pendingCodeProperties)
+                        pendingCodeProperties = Object.create(null);
+                    const fenceProps = splitPipeMetadata(afterClosingFence.substring(1).trim());
+                    for (const fp of fenceProps) {
+                        const fpm = fp.trim().match(/^([\p{L}\p{N}_][\p{L}\p{N}_-]*):\s*(.*)$/u);
+                        if (fpm && !pendingCodeProperties[fpm[1].trim()]) {
+                            pendingCodeProperties[fpm[1].trim()] = fpm[2].trim();
+                        }
+                    }
+                }
+                const codeBlock = {
+                    id: nextId(),
+                    type: "code",
+                    content: codeContent.join("\n"),
+                    ...(pendingCodeProperties
+                        ? { properties: pendingCodeProperties }
+                        : {}),
+                };
+                if (currentSection && currentSection.children) {
+                    currentSection.children.push(codeBlock);
+                }
+                else {
+                    blocks.push(codeBlock);
+                }
+                codeCaptureMode = false;
+                codeCaptureType = "keyword";
+                codeContent = [];
+                codeStartLine = 0;
+                pendingCodeProperties = null;
+            }
+            else {
+                codeContent.push(line);
+            }
+            previousLineWasBlank = false;
+            continue;
+        }
+        if (trimmed.startsWith("//"))
+            continue;
+        if (!trimmed) {
+            previousLineWasBlank = true;
+            continue;
+        }
+        const isMdPipeRow = /^\|.+\|$/.test(trimmed);
+        const rowKwMatch = trimmed.match(/^(\p{L}[\p{L}\p{N}-]*):/u);
+        const isRowLine = !!rowKwMatch &&
+            (aliases_1.ALIASES[rowKwMatch[1].toLowerCase()] ?? rowKwMatch[1].toLowerCase()) ===
+                "row";
+        if (pendingTable && !isRowLine && !isMdPipeRow) {
+            flushPendingTable();
+        }
+        if (trimmed.startsWith("```")) {
+            const fenceLang = trimmed.replace(/^```/, "").trim();
+            if (fenceLang) {
+                pendingCodeProperties = { lang: fenceLang };
+            }
+            codeCaptureMode = true;
+            codeCaptureType = "fence";
+            codeStartLine = i + 1;
+            previousLineWasBlank = false;
+            continue;
+        }
+        if (trimmed === "---") {
+            const dividerBlock = {
+                id: nextId(),
+                type: "divider",
+                content: "",
+            };
+            if (currentSection && currentSection.children) {
+                currentSection.children.push(dividerBlock);
+            }
+            else {
+                blocks.push(dividerBlock);
+                currentSection = null;
+            }
+            previousLineWasBlank = false;
+            continue;
+        }
+        const codeMatch = trimmed.match(/^code:\s*(.*)$/);
+        if (codeMatch) {
+            const afterCode = codeMatch[1].trim();
+            if (afterCode.startsWith("```")) {
+                const afterOpen = afterCode.substring(3);
+                const closeIdx = afterOpen.indexOf("```");
+                if (closeIdx !== -1) {
+                    const codeValue = afterOpen.substring(0, closeIdx);
+                    const afterClose = afterOpen.substring(closeIdx + 3).trim();
+                    const props = Object.create(null);
+                    if (afterClose.startsWith("|")) {
+                        const parts = splitPipeMetadata(afterClose.substring(1).trim());
+                        for (const part of parts) {
+                            const pm = part.trim().match(/^([\p{L}\p{N}_][\p{L}\p{N}_-]*):\s*(.*)$/u);
+                            if (pm)
+                                props[pm[1].trim()] = pm[2].trim();
+                        }
+                    }
+                    const codeBlock = {
+                        id: nextId(),
+                        type: "code",
+                        content: codeValue,
+                        ...(Object.keys(props).length > 0 ? { properties: props } : {}),
+                    };
+                    if (currentSection && currentSection.children) {
+                        currentSection.children.push(codeBlock);
+                    }
+                    else {
+                        blocks.push(codeBlock);
+                    }
+                    previousLineWasBlank = false;
+                    continue;
+                }
+                else {
+                    if (afterOpen.trim()) {
+                        codeContent.push(afterOpen);
+                    }
+                    codeCaptureMode = true;
+                    codeCaptureType = "fence";
+                    codeStartLine = i + 1;
+                    previousLineWasBlank = false;
+                    continue;
+                }
+            }
+            if (!afterCode || afterCode.startsWith("|")) {
+                const props = Object.create(null);
+                if (afterCode.startsWith("|")) {
+                    const parts = splitPipeMetadata(afterCode.substring(1).trim());
+                    for (const part of parts) {
+                        const propMatch = part.trim().match(/^([\p{L}\p{N}_][\p{L}\p{N}_-]*):\s*(.*)$/u);
+                        if (propMatch) {
+                            props[propMatch[1].trim()] = propMatch[2].trim();
+                        }
+                    }
+                }
+                let nextIdx = i + 1;
+                while (nextIdx < lines.length && !lines[nextIdx].trim())
+                    nextIdx++;
+                if (nextIdx < lines.length && lines[nextIdx].trim().startsWith("```")) {
+                    const fenceLang = lines[nextIdx].trim().replace(/^```/, "").trim();
+                    if (fenceLang && !props.lang) {
+                        props.lang = fenceLang;
+                    }
+                    pendingCodeProperties = Object.keys(props).length > 0 ? props : null;
+                    codeCaptureMode = true;
+                    codeCaptureType = "fence";
+                    codeStartLine = i + 1;
+                    i = nextIdx;
+                    previousLineWasBlank = false;
+                    continue;
+                }
+            }
+            const codeBlock = {
+                id: nextId(),
+                type: "code",
+                content: afterCode,
+            };
+            if (currentSection && currentSection.children) {
+                currentSection.children.push(codeBlock);
+            }
+            else {
+                blocks.push(codeBlock);
+            }
+            previousLineWasBlank = false;
+            continue;
+        }
+        const block = parseLine(line, {
+            keywords,
+            extensions,
+            lineNumber: i + 1,
+            diagnostics,
+            parseInline,
+        });
+        if (!block)
+            continue;
+        const mdTableMatch = trimmed.match(/^\|(.+)\|$/);
+        if (mdTableMatch && trimmed.includes("|")) {
+            const cells = trimmed
+                .split("|")
+                .slice(1, -1)
+                .map((cell) => cell.trim())
+                .filter((cell) => cell !== "");
+            const isSeparator = cells.every((cell) => /^[-:]+$/.test(cell));
+            if (!isSeparator && cells.length > 0) {
+                if (!pendingTable) {
+                    pendingTable = {
+                        headers: cells,
+                        rows: [],
+                        originalHeaders: trimmed,
+                        headerLine: i + 1,
+                    };
+                }
+                else {
+                    pendingTable.rows.push(cells);
+                }
+                continue;
+            }
+            else if (isSeparator && pendingTable) {
+                continue;
+            }
+        }
+        if (block.type === "columns") {
+            flushPendingTable();
+            pendingTable = {
+                headers: splitTableRow(block.originalContent || block.content),
+                rows: [],
+                originalHeaders: block.originalContent || block.content,
+                headerLine: i + 1,
+                headersKeyword: block.keywordAlias,
+            };
+            previousLineWasBlank = false;
+            continue;
+        }
+        if (block.type === "row") {
+            const rowCells = splitTableRow(block.originalContent || block.content);
+            if (pendingTable) {
+                pendingTable.rows.push(rowCells);
+                if (block.keywordAlias && !pendingTable.rowKeyword)
+                    pendingTable.rowKeyword = block.keywordAlias;
+            }
+            else {
+                diagnostics.push({
+                    severity: "warning",
+                    code: "ROW_WITHOUT_HEADERS",
+                    message: "Table row found without preceding headers.",
+                    line: i + 1,
+                    column: 1,
+                });
+                pendingTable = { rows: [rowCells] };
+                flushPendingTable();
+            }
+            previousLineWasBlank = false;
+            continue;
+        }
+        if (block.type === "section") {
+            seenSectionBlock = true;
+        }
+        if (block.type === "meta") {
+            if (!seenSectionBlock) {
+                const metaProps = block.properties || {};
+                for (const [k, v] of Object.entries(metaProps)) {
+                    metaAccumulator[k] = String(v);
+                }
+                continue;
+            }
+        }
+        const xType = block.type === "extension" ? block.properties?.["x-type"] : undefined;
+        if ((METADATA_KEYWORDS.has(block.type) ||
+            xType === "agent" ||
+            xType === "model") &&
+            !seenSectionBlock) {
+            if (block.type === "agent" || xType === "agent") {
+                agenticMetadata.agent = block.content;
+                if (block.properties?.model) {
+                    agenticMetadata.model = String(block.properties.model);
+                }
+            }
+            else if (block.type === "model" || xType === "model") {
+                agenticMetadata.model = block.content;
+            }
+            continue;
+        }
+        if (block.type === "context" && !seenSectionBlock) {
+            const ctxProps = block.properties || {};
+            if (!agenticMetadata.context)
+                agenticMetadata.context = {};
+            for (const [k, v] of Object.entries(ctxProps)) {
+                agenticMetadata.context[k] = String(v);
+            }
+        }
+        if (block.type === "track") {
+            trackingMeta = {
+                version: block.properties?.version
+                    ? String(block.properties.version)
+                    : "1.0",
+                by: block.properties?.by ? String(block.properties.by) : "",
+                active: true,
+            };
+            continue;
+        }
+        if (block.type === "history") {
+            continue;
+        }
+        if (block.type === "sign") {
+            signatureBlocks.push({
+                signer: block.content,
+                role: block.properties?.role
+                    ? String(block.properties.role)
+                    : undefined,
+                at: block.properties?.at ? String(block.properties.at) : "",
+                hash: block.properties?.hash ? String(block.properties.hash) : "",
+            });
+        }
+        if (block.type === "freeze") {
+            freezeMeta = {
+                at: block.properties?.at ? String(block.properties.at) : "",
+                hash: block.properties?.hash ? String(block.properties.hash) : "",
+                status: "locked",
+            };
+        }
+        if (block.type === "step") {
+            stepAutoIdCounter++;
+            if (block.properties?.id) {
+                block.id = String(block.properties.id);
+            }
+            else {
+                block.id = `step-${stepAutoIdCounter}`;
+                if (!block.properties)
+                    block.properties = {};
+                block.properties.id = `step-${stepAutoIdCounter}`;
+            }
+        }
+        if (block.type === "section") {
+            currentSection = block;
+            currentSection.children = [];
+            blocks.push(currentSection);
+        }
+        else if (block.type === "sub") {
+            if (currentSection) {
+                block.children = [];
+                appendBlockWithProseMerge(currentSection.children, block);
+            }
+            else {
+                appendBlockWithProseMerge(blocks, block);
+            }
+        }
+        else if (block.type === "title" || block.type === "summary") {
+            appendBlockWithProseMerge(blocks, block);
+        }
+        else if (block.type === "divider" ||
+            block.type === "image" ||
+            block.type === "link" ||
+            block.type === "code" ||
+            block.type === "table" ||
+            block.type === "body-text" ||
+            block.type === "text" ||
+            block.type === "page" ||
+            block.type === "break" ||
+            block.type === "toc" ||
+            (block.type === "extension" &&
+                (DOCGEN_LAYOUT_TYPES.has(String(block.properties?.["x-type"])) ||
+                    String(block.properties?.["x-type"]) === "ref" ||
+                    String(block.properties?.["x-type"]) === "embed" ||
+                    String(block.properties?.["x-type"]) === "dedication" ||
+                    String(block.properties?.["x-type"]) === "toc"))) {
+            appendBlockWithProseMerge(blocks, block);
+            currentSection = null;
+        }
+        else {
+            let target = currentSection;
+            if (target) {
+                const lastSub = target.children?.[target.children.length - 1];
+                if (lastSub?.type === "sub") {
+                    target = lastSub;
+                }
+                if (!target.children)
+                    target.children = [];
+                appendBlockWithProseMerge(target.children, block);
+            }
+            else {
+                appendBlockWithProseMerge(blocks, block);
+            }
+        }
+        previousLineWasBlank = false;
+    }
+    flushPendingTable();
+    if (codeCaptureMode) {
+        diagnostics.push({
+            severity: "error",
+            code: "UNTERMINATED_CODE_BLOCK",
+            message: "Unterminated code block. Expected closing ``` before end of file.",
+            line: codeStartLine || lines.length,
+            column: 1,
+        });
+        const codeBlock = {
+            id: nextId(),
+            type: "code",
+            content: codeContent.join("\n"),
+            ...(pendingCodeProperties ? { properties: pendingCodeProperties } : {}),
+        };
+        pendingCodeProperties = null;
+        if (currentSection && currentSection.children) {
+            currentSection.children.push(codeBlock);
+        }
+        else {
+            blocks.push(codeBlock);
+        }
+    }
+    const titleBlock = blocks.find((b) => b.type === "title");
+    const summaryBlock = blocks.find((b) => b.type === "summary");
+    const hasArabic = blocks.some((b) => detectArabic(b.content));
+    const allBlocks = blocks.flatMap(function collect(b) {
+        return [b, ...(b.children ?? []).flatMap(collect)];
+    });
+    const hasDocgenContent = allBlocks.some((b) => DOCGEN_LAYOUT_TYPES.has(b.type) || DOCGEN_WRITER_TYPES.has(b.type));
+    const hasTrustContent = trackingMeta != null ||
+        signatureBlocks.length > 0 ||
+        freezeMeta != null ||
+        allBlocks.some((b) => TRUST_KEYWORDS.has(b.type));
+    const hasV22Content = allBlocks.some((b) => V22_BLOCK_TYPES.has(b.type));
+    const hasV21Content = allBlocks.some((b) => V21_BLOCK_TYPES.has(b.type));
+    const hasAgenticContent = allBlocks.some((b) => AGENTIC_BLOCK_TYPES.has(b.type)) ||
+        agenticMetadata.agent != null ||
+        agenticMetadata.model != null ||
+        agenticMetadata.context != null;
+    const metadata = {
+        title: titleBlock?.content,
+        summary: summaryBlock?.content,
+        language: hasArabic ? "rtl" : "ltr",
+        ...(agenticMetadata.agent != null && { agent: agenticMetadata.agent }),
+        ...(agenticMetadata.model != null && { model: agenticMetadata.model }),
+        ...(agenticMetadata.context != null && {
+            context: agenticMetadata.context,
+        }),
+        ...(trackingMeta != null && { tracking: trackingMeta }),
+        ...(signatureBlocks.length > 0 && { signatures: signatureBlocks }),
+        ...(freezeMeta != null && { freeze: freezeMeta }),
+        ...(Object.keys(metaAccumulator).length > 0 && { meta: metaAccumulator }),
+    };
+    const hasV212Content = (historyBoundaryIdx !== -1 &&
+        lines[historyBoundaryIdx].trim().startsWith("history:")) ||
+        allBlocks.some((b) => b.type === "history");
+    const document = {
+        version: hasV212Content
+            ? "2.12"
+            : allBlocks.some((b) => V211_BLOCK_TYPES.has(b.type))
+                ? "2.11"
+                : hasTrustContent
+                    ? "2.8"
+                    : hasDocgenContent
+                        ? "2.5"
+                        : hasV22Content
+                            ? "2.2"
+                            : hasV21Content
+                                ? "2.1"
+                                : hasAgenticContent
+                                    ? "2.0"
+                                    : "1.4",
+        blocks,
+        metadata,
+        diagnostics: diagnostics.length > 0 ? diagnostics : undefined,
+        ...(historySection != null && { history: historySection }),
+    };
+    for (const ext of extensions) {
+        if (!ext.validate)
+            continue;
+        const extDiags = ext.validate(document);
+        if (extDiags && extDiags.length > 0) {
+            if (!document.diagnostics)
+                document.diagnostics = [];
+            document.diagnostics.push(...extDiags);
+        }
+    }
+    return document;
+}
+exports.DEFAULT_SAFE_PARSE_OPTIONS = {
+    unknownKeyword: "note",
+    maxBlocks: 10000,
+    maxLineLength: 50000,
+    strict: false,
+};
+function parseIntentTextSafe(source, options) {
+    const opts = { ...exports.DEFAULT_SAFE_PARSE_OPTIONS, ...options };
+    const warnings = [];
+    const errors = [];
+    if (typeof source !== "string" || source.length === 0) {
+        return {
+            document: { version: "1.4", blocks: [], metadata: {}, diagnostics: [] },
+            warnings: [],
+            errors: [],
+        };
+    }
+    try {
+        const rawLines = source.split(/\r?\n/);
+        const processedLines = [];
+        const knownKeywords = new Set(types_1.KEYWORDS);
+        for (let i = 0; i < rawLines.length; i++) {
+            let line = rawLines[i];
+            if (line.length > opts.maxLineLength) {
+                warnings.push({
+                    line: i + 1,
+                    message: `Line truncated from ${line.length} to ${opts.maxLineLength} characters`,
+                    code: "LINE_TRUNCATED",
+                    original: line.slice(0, 200) + "...",
+                });
+                line = line.slice(0, opts.maxLineLength);
+            }
+            const kwMatch = line.match(/^(\s*)([a-zA-Z_-]+)\s*:/);
+            if (kwMatch) {
+                const kw = kwMatch[2].toLowerCase();
+                if (!knownKeywords.has(kw) && !line.trim().startsWith("//")) {
+                    const entry = {
+                        line: i + 1,
+                        message: `Unknown keyword: "${kw}"`,
+                        code: "UNKNOWN_KEYWORD",
+                        original: line,
+                    };
+                    if (opts.strict || opts.unknownKeyword === "throw") {
+                        errors.push(entry);
+                    }
+                    else {
+                        warnings.push(entry);
+                    }
+                    if (opts.unknownKeyword === "skip") {
+                        continue;
+                    }
+                }
+            }
+            processedLines.push(line);
+        }
+        const processedSource = processedLines.join("\n");
+        const document = parseIntentText(processedSource);
+        if (document.blocks.length > opts.maxBlocks) {
+            warnings.push({
+                line: 0,
+                message: `Document has ${document.blocks.length} blocks, truncated to ${opts.maxBlocks}`,
+                code: "MAX_BLOCKS_REACHED",
+                original: "",
+            });
+            document.blocks = document.blocks.slice(0, opts.maxBlocks);
+        }
+        return { document, warnings, errors };
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : "Unknown parser error";
+        errors.push({
+            line: 0,
+            message,
+            code: "PARSE_EXCEPTION",
+            original: "",
+        });
+        return {
+            document: { version: "1.4", blocks: [], metadata: {}, diagnostics: [] },
+            warnings,
+            errors,
+        };
+    }
+}