@contentbit/core 0.1.0 → 0.2.0

package/dist/analyze.d.ts

@@ -0,0 +1,87 @@
+export interface OutlineEntry {
+    /** ATX heading level, 1-6. */
+    level: number;
+    text: string;
+    /** 1-based source line. */
+    line: number;
+    /** Prose words from this heading (inclusive) until the next heading of any level. */
+    words: number;
+}
+export interface BlockInstance {
+    name: string;
+    /** 1-based line of the opening fence. */
+    line: number;
+    /** 1 for top-level blocks, +1 per nesting level. */
+    depth: number;
+}
+export interface LinkItem {
+    url: string;
+    text: string;
+    line: number;
+    external: boolean;
+}
+export interface DocumentStats {
+    file: {
+        path: string | null;
+        bytes: number;
+        lines: number;
+    };
+    frontmatter: {
+        present: boolean;
+        keys: string[];
+        data: Record<string, unknown>;
+        lines: {
+            start: number;
+            end: number;
+        } | null;
+    };
+    length: {
+        /** Prose words only: frontmatter, code, and markup syntax are excluded. */
+        words: number;
+        /** Characters of the full source, frontmatter included. */
+        characters: number;
+        /** ceil(words / 200). */
+        readingMinutes: number;
+        /** Rough heuristic: ceil(characters / 4). */
+        approxTokens: number;
+    };
+    outline: OutlineEntry[];
+    blocks: {
+        total: number;
+        byName: Record<string, number>;
+        maxDepth: number;
+        instances: BlockInstance[];
+    };
+    links: {
+        total: number;
+        external: number;
+        internal: number;
+        domains: string[];
+        items: LinkItem[];
+    };
+    images: {
+        total: number;
+        missingAlt: number;
+    };
+    code: {
+        fences: number;
+        languages: string[];
+        inlineSpans: number;
+    };
+    structure: {
+        listItems: number;
+        tables: number;
+        blockquotes: number;
+    };
+}
+export interface AnalyzeOptions {
+    /** Reported back in `file.path`; analyze never touches the filesystem. */
+    path?: string;
+}
+/**
+ * Scan a document and return structured stats: prose length, heading outline,
+ * block census, links, images, code, and structure counts. Purely syntactic
+ * and deterministic — no registry, no validation, no filesystem access.
+ */
+export declare function analyzeDocument(source: string, options?: AnalyzeOptions): DocumentStats;
+//# sourceMappingURL=analyze.d.ts.map

package/dist/analyze.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze.d.ts","sourceRoot":"","sources":["../src/analyze.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,YAAY;IAC3B,8BAA8B;IAC9B,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,2BAA2B;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,qFAAqF;IACrF,KAAK,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,yCAAyC;IACzC,IAAI,EAAE,MAAM,CAAA;IACZ,oDAAoD;IACpD,KAAK,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,QAAQ;IACvB,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,OAAO,CAAA;CAClB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;IAC3D,WAAW,EAAE;QACX,OAAO,EAAE,OAAO,CAAA;QAChB,IAAI,EAAE,MAAM,EAAE,CAAA;QACd,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QAC7B,KAAK,EAAE;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,GAAG,EAAE,MAAM,CAAA;SAAE,GAAG,IAAI,CAAA;KAC7C,CAAA;IACD,MAAM,EAAE;QACN,2EAA2E;QAC3E,KAAK,EAAE,MAAM,CAAA;QACb,2DAA2D;QAC3D,UAAU,EAAE,MAAM,CAAA;QAClB,yBAAyB;QACzB,cAAc,EAAE,MAAM,CAAA;QACtB,6CAA6C;QAC7C,YAAY,EAAE,MAAM,CAAA;KACrB,CAAA;IACD,OAAO,EAAE,YAAY,EAAE,CAAA;IACvB,MAAM,EAAE;QACN,KAAK,EAAE,MAAM,CAAA;QACb,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;QAC9B,QAAQ,EAAE,MAAM,CAAA;QAChB,SAAS,EAAE,aAAa,EAAE,CAAA;KAC3B,CAAA;IACD,KAAK,EAAE;QACL,KAAK,EAAE,MAAM,CAAA;QACb,QAAQ,EAAE,MAAM,CAAA;QAChB,QAAQ,EAAE,MAAM,CAAA;QAChB,OAAO,EAAE,MAAM,EAAE,CAAA;QACjB,KAAK,EAAE,QAAQ,EAAE,CAAA;KAClB,CAAA;IACD,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAA;IAC7C,IAAI,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,EAAE,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAA;IAClE,SAAS,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAA;CACtE;AAED,MAAM,WAAW,cAAc;IAC7B,0EAA0E;IAC1E,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAsBD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,cAAmB,GAAG,aAAa,CA4L3F"}

package/dist/analyze.js

@@ -0,0 +1,204 @@
+import { extractFrontmatter, stripFrontmatter } from './frontmatter.js';
+import { parseDocument } from './parser.js';
+/** UTF-8 byte length without Node Buffer or TextEncoder (core is environment-agnostic). */
+function utf8Length(source) {
+    let bytes = 0;
+    for (const ch of source) {
+        const cp = ch.codePointAt(0);
+        bytes += cp <= 0x7f ? 1 : cp <= 0x7ff ? 2 : cp <= 0xffff ? 3 : 4;
+    }
+    return bytes;
+}
+const CODE_FENCE_RE = /^(`{3,}|~{3,})(.*)$/;
+const HEADING_RE = /^(#{1,6})\s+(.*)$/;
+const LIST_ITEM_RE = /^\s*(?:[-*+]|\d+[.)])\s+/;
+const TABLE_SEPARATOR_RE = /^\|?[\s:|-]+$/;
+const CODE_SPAN_RE = /`[^`]+`/g;
+const IMAGE_RE = /!\[([^\]]*)\]\(([^)]*)\)/g;
+const LINK_RE = /\[([^\]]+)\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g;
+const AUTOLINK_RE = /<(https?:\/\/[^>\s]+)>/g;
+const EXTERNAL_URL_RE = /^(?:https?:)?\/\//i;
+/**
+ * Scan a document and return structured stats: prose length, heading outline,
+ * block census, links, images, code, and structure counts. Purely syntactic
+ * and deterministic — no registry, no validation, no filesystem access.
+ */
+export function analyzeDocument(source, options = {}) {
+    const frontmatter = extractFrontmatter(source);
+    const { document } = parseDocument(stripFrontmatter(source));
+    const outline = [];
+    const blocks = { total: 0, byName: {}, maxDepth: 0, instances: [] };
+    const links = {
+        total: 0,
+        external: 0,
+        internal: 0,
+        domains: [],
+        items: [],
+    };
+    const images = { total: 0, missingAlt: 0 };
+    const code = { fences: 0, languages: [], inlineSpans: 0 };
+    const structure = { listItems: 0, tables: 0, blockquotes: 0 };
+    const languages = new Set();
+    const domains = new Set();
+    let words = 0;
+    function addWords(count) {
+        words += count;
+        const section = outline[outline.length - 1];
+        if (section)
+            section.words += count;
+    }
+    function recordLink(url, text, line) {
+        const external = EXTERNAL_URL_RE.test(url);
+        links.total++;
+        if (external) {
+            links.external++;
+            const host = url.match(/^(?:https?:)?\/\/(?:[^/?#@]*@)?([^/?#:]+)/i);
+            if (host)
+                domains.add(host[1].toLowerCase());
+        }
+        else {
+            links.internal++;
+        }
+        links.items.push({ url, text, line, external });
+    }
+    /** Replace inline markup with its prose equivalent, recording links/images/spans. */
+    function inlineToProse(text, line) {
+        return text
+            .replace(CODE_SPAN_RE, () => {
+            code.inlineSpans++;
+            return ' ';
+        })
+            .replace(IMAGE_RE, (_, alt) => {
+            images.total++;
+            if (alt.trim() === '')
+                images.missingAlt++;
+            return ' ';
+        })
+            .replace(LINK_RE, (_, label, url) => {
+            recordLink(url, label, line);
+            return label;
+        })
+            .replace(AUTOLINK_RE, (_, url) => {
+            recordLink(url, url, line);
+            return ' ';
+        });
+    }
+    function countWords(text) {
+        return text.split(/\s+/).filter((token) => /[\p{L}\p{N}]/u.test(token)).length;
+    }
+    function scanMarkdown(value, startLine) {
+        let fence = null;
+        let inBlockquote = false;
+        let prevLineHasPipe = false;
+        const lines = value.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const lineNo = startLine + i;
+            const trimmed = line.trim();
+            const fenceMatch = trimmed.match(CODE_FENCE_RE);
+            if (fence !== null) {
+                if (fenceMatch && fenceMatch[1][0] === fence[0] && fenceMatch[1].length >= fence.length) {
+                    fence = null;
+                }
+                continue;
+            }
+            if (fenceMatch) {
+                fence = fenceMatch[1];
+                code.fences++;
+                const lang = fenceMatch[2].trim().split(/\s+/)[0];
+                if (lang)
+                    languages.add(lang);
+                inBlockquote = false;
+                prevLineHasPipe = false;
+                continue;
+            }
+            if (trimmed === '') {
+                inBlockquote = false;
+                prevLineHasPipe = false;
+                continue;
+            }
+            const heading = trimmed.match(HEADING_RE);
+            if (heading) {
+                const raw = heading[2].replace(/\s+#+\s*$/, '');
+                const text = inlineToProse(raw, lineNo).replace(/\s+/g, ' ').trim();
+                outline.push({ level: heading[1].length, text, line: lineNo, words: 0 });
+                addWords(countWords(text));
+                inBlockquote = false;
+                prevLineHasPipe = false;
+                continue;
+            }
+            let content = trimmed;
+            if (content.startsWith('>')) {
+                if (!inBlockquote) {
+                    structure.blockquotes++;
+                    inBlockquote = true;
+                }
+                content = content.replace(/^(>\s*)+/, '');
+            }
+            else {
+                inBlockquote = false;
+            }
+            if (LIST_ITEM_RE.test(content)) {
+                structure.listItems++;
+                content = content.replace(LIST_ITEM_RE, '');
+            }
+            if (content.includes('|')) {
+                if (TABLE_SEPARATOR_RE.test(content) && content.includes('-') && prevLineHasPipe) {
+                    structure.tables++;
+                }
+                prevLineHasPipe = true;
+                content = inlineToProse(content, lineNo).replaceAll('|', ' ');
+            }
+            else {
+                prevLineHasPipe = false;
+                content = inlineToProse(content, lineNo);
+            }
+            addWords(countWords(content));
+        }
+    }
+    function walk(nodes, depth) {
+        for (const node of nodes) {
+            if (node.type === 'block') {
+                blocks.total++;
+                blocks.byName[node.name] = (blocks.byName[node.name] ?? 0) + 1;
+                blocks.maxDepth = Math.max(blocks.maxDepth, depth);
+                blocks.instances.push({ name: node.name, line: node.openPosition.start.line, depth });
+                walk(node.children, depth + 1);
+            }
+            else {
+                scanMarkdown(node.value, node.position.start.line);
+            }
+        }
+    }
+    walk(document.children, 1);
+    code.languages = [...languages];
+    links.domains = [...domains].sort();
+    const sourceLines = source === '' ? 0 : source.split('\n').length - (source.endsWith('\n') ? 1 : 0);
+    return {
+        file: {
+            path: options.path ?? null,
+            bytes: utf8Length(source),
+            lines: sourceLines,
+        },
+        frontmatter: frontmatter
+            ? {
+                present: true,
+                keys: frontmatter.keys,
+                data: frontmatter.data,
+                lines: frontmatter.lines,
+            }
+            : { present: false, keys: [], data: {}, lines: null },
+        length: {
+            words,
+            characters: source.length,
+            readingMinutes: Math.ceil(words / 200),
+            approxTokens: Math.ceil(source.length / 4),
+        },
+        outline,
+        blocks,
+        links,
+        images,
+        code,
+        structure,
+    };
+}

package/dist/authoring.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"authoring.d.ts","sourceRoot":"","sources":["../src/authoring.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAEpD,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,EAAE,KAAK,GAAG,OAAO,CAAA;IAC1B,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC5B;AAWD,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,eAAe,CAAC,OAAO,CAAC,EAAE,EAChC,IAAI,GAAE,qBAA0B,GAC/B,MAAM,CA0BR"}
+{"version":3,"file":"authoring.d.ts","sourceRoot":"","sources":["../src/authoring.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAkEpD,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,EAAE,KAAK,GAAG,OAAO,CAAA;IAC1B,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC5B;AAWD,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,eAAe,CAAC,OAAO,CAAC,EAAE,EAChC,IAAI,GAAE,qBAA0B,GAC/B,MAAM,CA8BR"}

package/dist/authoring.js

@@ -1,3 +1,50 @@
+function typeLabel(def) {
+    switch (def.type) {
+        case 'enum':
+            return `one of ${Object.values(def.entries ?? {}).join('|')}`;
+        case 'literal':
+            return `one of ${(def.values ?? []).map(String).join('|')}`;
+        case 'union':
+            return `one of ${(def.options ?? [])
+                .map((o) => typeLabel(o.def).replace(/^one of /, ''))
+                .join('|')}`;
+        default:
+            return def.type;
+    }
+}
+/** One `- name: type (required|optional[, default: x]) [— description]` line per prop. */
+function describeProps(schema) {
+    const root = schema.def;
+    if (root.type !== 'object' || !root.shape)
+        return [];
+    const lines = [];
+    for (const [name, field] of Object.entries(root.shape)) {
+        // Unwrap optional/default/nullable wrappers; .describe() may sit on any layer.
+        let current = field;
+        let optional = false;
+        let defaultValue;
+        let description = current.description;
+        while (['optional', 'default', 'nullable'].includes(current.def.type)) {
+            optional = true;
+            if (current.def.type === 'default') {
+                const dv = current.def.defaultValue;
+                defaultValue = typeof dv === 'function' ? dv() : dv;
+            }
+            if (!current.def.innerType)
+                break;
+            current = current.def.innerType;
+            description ??= current.description;
+        }
+        const presence = defaultValue !== undefined
+            ? `(optional, default: ${String(defaultValue)})`
+            : optional
+                ? '(optional)'
+                : '(required)';
+        const suffix = description ? ` — ${description}` : '';
+        lines.push(`- ${name}: ${typeLabel(current.def)} ${presence}${suffix}`);
+    }
+    return lines;
+}
 const LLM_PREAMBLE = `# Content block authoring rules
 
 - write regular Markdown by default; use blocks only when they improve scanning or structure
@@ -17,6 +64,11 @@ export function generateAuthoringGuide(defs, opts = {}) {
         lines.push(def.childOnly
             ? `${def.description} (child block — only inside a parent that allows it)`
             : def.description);
+        if (def.props) {
+            const props = describeProps(def.props);
+            if (props.length > 0)
+                lines.push('', 'Props:', ...props);
+        }
         lines.push('', `Content: ${def.content.describe()}`);
         if (def.authoring.useWhen.length > 0) {
             lines.push('', 'Use when:', ...def.authoring.useWhen.map((u) => `- ${u}`));

package/dist/frontmatter.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Blank out a leading YAML frontmatter block so block syntax inside it is
+ * never parsed as content. Every line is replaced by an empty line (the
+ * newlines stay), so diagnostic positions in the remaining document are
+ * unchanged. Sources without frontmatter are returned as-is.
+ */
+export declare function stripFrontmatter(source: string): string;
+export interface Frontmatter {
+    /** Raw YAML between the fences (fences excluded). */
+    raw: string;
+    /** Best-effort parsed data; values the subset parser can't handle stay raw strings. */
+    data: Record<string, unknown>;
+    /** Top-level keys in document order. */
+    keys: string[];
+    /** 1-based fence lines, inclusive. */
+    lines: {
+        start: number;
+        end: number;
+    };
+}
+/**
+ * Extract and parse a leading YAML frontmatter block. Parsing covers the flat
+ * subset real content frontmatter uses: `key: value` scalars (quoted/plain
+ * strings, numbers, booleans, null), inline arrays, dash lists, and block
+ * scalars. Nested mappings and anything else fall back to the raw text of the
+ * value, so no input ever throws. Returns null when there is no frontmatter.
+ */
+export declare function extractFrontmatter(source: string): Frontmatter | null;
+//# sourceMappingURL=frontmatter.d.ts.map

package/dist/frontmatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontmatter.d.ts","sourceRoot":"","sources":["../src/frontmatter.ts"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAIvD;AAED,MAAM,WAAW,WAAW;IAC1B,qDAAqD;IACrD,GAAG,EAAE,MAAM,CAAA;IACX,uFAAuF;IACvF,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC7B,wCAAwC;IACxC,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,sCAAsC;IACtC,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAA;CACtC;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAOrE"}

package/dist/frontmatter.js

@@ -0,0 +1,136 @@
+// A YAML frontmatter block at the very start of the file: an opening ---
+// fence, an optional body (empty frontmatter is legal), and a closing ---
+// fence. Both fences tolerate trailing spaces/tabs, which editors and CMS
+// exports routinely leave behind.
+const FM_RE = /^---[ \t]*\r?\n(?:[\s\S]*?\r?\n)?---[ \t]*(?:\r?\n|$)/;
+/**
+ * Blank out a leading YAML frontmatter block so block syntax inside it is
+ * never parsed as content. Every line is replaced by an empty line (the
+ * newlines stay), so diagnostic positions in the remaining document are
+ * unchanged. Sources without frontmatter are returned as-is.
+ */
+export function stripFrontmatter(source) {
+    const match = FM_RE.exec(source);
+    if (!match)
+        return source;
+    return match[0].replace(/[^\n]+/g, '') + source.slice(match[0].length);
+}
+/**
+ * Extract and parse a leading YAML frontmatter block. Parsing covers the flat
+ * subset real content frontmatter uses: `key: value` scalars (quoted/plain
+ * strings, numbers, booleans, null), inline arrays, dash lists, and block
+ * scalars. Nested mappings and anything else fall back to the raw text of the
+ * value, so no input ever throws. Returns null when there is no frontmatter.
+ */
+export function extractFrontmatter(source) {
+    const match = source.match(FM_RE);
+    if (!match)
+        return null;
+    const blockLines = match[0].replace(/\r?\n$/, '').split(/\r?\n/);
+    const inner = blockLines.slice(1, -1);
+    const { data, keys } = parseYamlSubset(inner);
+    return { raw: inner.join('\n'), data, keys, lines: { start: 1, end: blockLines.length } };
+}
+const KEY_RE = /^([A-Za-z0-9_.-]+):(.*)$/;
+function parseYamlSubset(lines) {
+    const data = {};
+    const keys = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (trimmed === '' || trimmed.startsWith('#') || /^[ \t]/.test(line)) {
+            i++;
+            continue;
+        }
+        const m = line.match(KEY_RE);
+        if (!m) {
+            i++;
+            continue;
+        }
+        const [, key, rawValue] = m;
+        const value = rawValue.trim();
+        i++;
+        const indented = [];
+        while (i < lines.length && /^[ \t]/.test(lines[i]) && lines[i].trim() !== '') {
+            indented.push(lines[i]);
+            i++;
+        }
+        keys.push(key);
+        data[key] = parseValue(value, indented);
+    }
+    return { data, keys };
+}
+function parseValue(value, indented) {
+    if (/^[|>][+-]?$/.test(value))
+        return dedent(indented).join('\n');
+    if (value === '') {
+        if (indented.length === 0)
+            return null;
+        const items = dedent(indented);
+        if (items.every((l) => l.startsWith('- ')))
+            return items.map((l) => parseScalar(l.slice(2).trim()));
+        return items.join('\n');
+    }
+    return parseScalar(value);
+}
+function dedent(lines) {
+    const indent = Math.min(...lines.map((l) => l.match(/^[ \t]*/)[0].length));
+    return lines.map((l) => l.slice(indent));
+}
+function parseScalar(value) {
+    if (value === '' || value === 'null' || value === '~')
+        return null;
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    if (/^[+-]?\d+$/.test(value))
+        return Number.parseInt(value, 10);
+    if (/^[+-]?\d*\.\d+$/.test(value))
+        return Number.parseFloat(value);
+    if (value.startsWith('"') && value.endsWith('"') && value.length >= 2) {
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return value.slice(1, -1);
+        }
+    }
+    if (value.startsWith("'") && value.endsWith("'") && value.length >= 2) {
+        return value.slice(1, -1).replace(/''/g, "'");
+    }
+    if (value.startsWith('[') && value.endsWith(']')) {
+        const inner = value.slice(1, -1).trim();
+        if (inner === '')
+            return [];
+        return splitInlineItems(inner).map((item) => parseScalar(item.trim()));
+    }
+    return value;
+}
+/** Split inline array items on top-level commas, respecting quotes. */
+function splitInlineItems(inner) {
+    const items = [];
+    let current = '';
+    let quote = null;
+    for (const ch of inner) {
+        if (quote) {
+            current += ch;
+            if (ch === quote)
+                quote = null;
+        }
+        else if (ch === '"' || ch === "'") {
+            current += ch;
+            quote = ch;
+        }
+        else if (ch === ',') {
+            items.push(current);
+            current = '';
+        }
+        else {
+            current += ch;
+        }
+    }
+    items.push(current);
+    return items;
+}

package/dist/index.d.ts

@@ -3,6 +3,8 @@ export type { SourcePoint, SourceRange, Severity, Diagnostic } from './diagnosti
 export { formatDiagnostic } from './diagnostics.js';
 export type { DocumentNode, ContentNode, MarkdownNode, BlockNode } from './ast.js';
 export { parseDocument, type ParseResult } from './parser.js';
+export { stripFrontmatter, extractFrontmatter, type Frontmatter } from './frontmatter.js';
+export { analyzeDocument, type AnalyzeOptions, type DocumentStats, type OutlineEntry, type BlockInstance, type LinkItem, } from './analyze.js';
 export { parseProps } from './props.js';
 export { bodyLineRange } from './position.js';
 export { createBlockRegistry, defineBlock, BlockRegistry, type BlockDefinition, type ContentModel, type AuthoringMeta, type Report, } from './registry.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AACtF,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AACnD,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAClF,OAAO,EAAE,aAAa,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAA;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,EACL,mBAAmB,EACnB,WAAW,EACX,aAAa,EACb,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,MAAM,GACZ,MAAM,eAAe,CAAA;AACtB,OAAO,EACL,YAAY,EACZ,QAAQ,EACR,SAAS,EACT,WAAW,EACX,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,QAAQ,EACb,KAAK,eAAe,GACrB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,GACxB,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,sBAAsB,EAAE,KAAK,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AACnF,OAAO,EACL,gBAAgB,EAChB,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC1B,KAAK,uBAAuB,GAC7B,MAAM,sBAAsB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AACtF,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AACnD,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAClF,OAAO,EAAE,aAAa,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAA;AAC7D,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAA;AACzF,OAAO,EACL,eAAe,EACf,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,QAAQ,GACd,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,EACL,mBAAmB,EACnB,WAAW,EACX,aAAa,EACb,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,MAAM,GACZ,MAAM,eAAe,CAAA;AACtB,OAAO,EACL,YAAY,EACZ,QAAQ,EACR,SAAS,EACT,WAAW,EACX,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,QAAQ,EACb,KAAK,eAAe,GACrB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,GACxB,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,sBAAsB,EAAE,KAAK,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AACnF,OAAO,EACL,gBAAgB,EAChB,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC1B,KAAK,uBAAuB,GAC7B,MAAM,sBAAsB,CAAA"}

package/dist/index.js

@@ -1,6 +1,8 @@
 export { VERSION } from './version.js';
 export { formatDiagnostic } from './diagnostics.js';
 export { parseDocument } from './parser.js';
+export { stripFrontmatter, extractFrontmatter } from './frontmatter.js';
+export { analyzeDocument, } from './analyze.js';
 export { parseProps } from './props.js';
 export { bodyLineRange } from './position.js';
 export { createBlockRegistry, defineBlock, BlockRegistry, } from './registry.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentbit/core",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Parser, validator, and registry for Content Blocks: structured Markdown components without framework lock-in.",
   "keywords": [
     "ast",