@dinoxx/dinox-cli 1.0.19 → 1.0.21

package/dist/commands/notes/contentEngine.js

@@ -0,0 +1,652 @@
+import crypto from 'node:crypto';
+import { DinoxError } from '../../utils/errors.js';
+import { generateId } from '../../utils/id.js';
+import { convertMarkdownToNoteContent } from '../../utils/tiptapMarkdown.js';
+const CONTENT_TEXT_MAX_LENGTH = 300;
+const MAX_REPLACE_BLOCK_RANGE = 50;
+const ANCHOR_ATTRIBUTE_KEYS = ['anchorKey', 'data-toc-id', 'id', 'uniqueId'];
+const TEXT_BLOCK_TYPES = new Set([
+    'paragraph',
+    'heading',
+    'bulletList',
+    'orderedList',
+    'taskList',
+    'blockquote',
+    'codeBlock',
+    'horizontalRule',
+]);
+const ATOMIC_BLOCK_TYPES = new Set([
+    'image',
+    'video',
+    'audio',
+    'file',
+    'bookmark',
+    'iframe',
+    'mermaid',
+    'mindgraph',
+    'blockMath',
+    'math',
+    'frontmatter',
+]);
+const CONTAINER_BLOCK_TYPES = new Set(['table', 'audiosegment', 'pdfAnnotation']);
+export function parseStoredNoteDocument(input) {
+    const parsed = parseMaybeJson(input.contentJson);
+    if (isNode(parsed)) {
+        const document = normalizeDocument(parsed);
+        if (hasMeaningfulDocumentContent(document) || !(input.contentMd ?? '').trim()) {
+            return document;
+        }
+    }
+    return normalizeDocument(convertMarkdownToNoteContent(input.contentMd ?? '').contentJson);
+}
+export function buildNoteContentBlocks(document) {
+    return topLevelNodes(document).map((node, index) => {
+        const anchorId = resolveAnchorId(node);
+        const text = extractPlainText(node).trim();
+        return {
+            anchorId: anchorId ?? `pos-${index}`,
+            hasStableAnchor: Boolean(anchorId),
+            nodeIndex: index,
+            nodeRange: `${index}:${index + 1}`,
+            type: node.type,
+            editMode: getNodeEditMode(node.type),
+            level: node.type === 'heading' ? normalizeHeadingLevel(node.attrs?.level) : null,
+            text,
+            textPreview: text.slice(0, 1000),
+            textHash: hashText(text),
+            nodeHash: hashNode(node),
+            charCount: text.length,
+            attrs: safeAttrs(node),
+        };
+    });
+}
+export function buildNoteContentOutline(document) {
+    const blocks = buildNoteContentBlocks(document);
+    return buildHeadingRanges(document).map((heading) => ({
+        path: heading.path,
+        level: heading.level,
+        nodeRange: `${heading.index}:${heading.endIndex}`,
+        contentHash: hashStableValue(blocks.slice(heading.index, heading.endIndex).map((block) => block.nodeHash)),
+    }));
+}
+export function getNoteContentHash(document) {
+    return hashStableValue(normalizeDocument(document));
+}
+export function serializeNoteContentMarkdown(document) {
+    return topLevelNodes(document).map((node) => blockToMarkdown(node, 0)).filter(Boolean).join('\n\n').trim();
+}
+export function projectNoteContent(document, options = {}) {
+    const normalized = normalizeHashtagReferences(normalizeDocument(document), options.resolveHashtagReference);
+    const contentMd = serializeNoteContentMarkdown(normalized);
+    const metadata = extractMetadata(normalized);
+    return {
+        document: normalized,
+        contentJson: stableStringify(normalized),
+        contentMd,
+        contentText: normalizeContentText(extractPlainText(normalized), CONTENT_TEXT_MAX_LENGTH),
+        hashtags: metadata.hashtags,
+        images: metadata.images,
+        bidLinks: metadata.bidLinks,
+    };
+}
+export function applyJsonPatchToDocument(document, operation, options = {}) {
+    const beforeDocument = normalizeDocument(document);
+    const beforeProjection = projectNoteContent(beforeDocument, options);
+    const beforeHash = getNoteContentHash(beforeDocument);
+    const result = patchDocument(beforeDocument, operation);
+    const afterDocument = normalizeDocument({ ...beforeDocument, content: result.nodes });
+    const afterProjection = projectNoteContent(afterDocument, options);
+    const afterHash = getNoteContentHash(afterProjection.document);
+    return {
+        operation: operation.kind,
+        changed: beforeHash !== afterHash,
+        beforeHash,
+        afterHash,
+        beforeContent: beforeProjection.contentMd,
+        afterContent: afterProjection.contentMd,
+        beforeBlocks: buildNoteContentBlocks(beforeDocument),
+        afterBlocks: buildNoteContentBlocks(afterProjection.document),
+        beforeProjection,
+        afterProjection,
+        target: result.target,
+    };
+}
+export function withStableBlockAnchors(document) {
+    const content = topLevelNodes(document).map((node) => {
+        if (resolveAnchorId(node)) {
+            return node;
+        }
+        return {
+            ...node,
+            attrs: {
+                ...(node.attrs ?? {}),
+                anchorKey: generateId(),
+            },
+        };
+    });
+    return normalizeDocument({ ...document, content });
+}
+function patchDocument(document, operation) {
+    const nodes = topLevelNodes(document);
+    switch (operation.kind) {
+        case 'appendSection':
+            return appendSection(nodes, operation.heading, operation.content);
+        case 'appendToHeading':
+            return appendToHeading(document, nodes, operation.headingPath, operation.content);
+        case 'replaceSection':
+            return replaceSection(document, nodes, operation);
+        case 'replaceBlock':
+            return replaceBlock(nodes, operation);
+    }
+}
+function appendSection(nodes, heading, markdown) {
+    const normalizedHeading = heading.trim();
+    if (!normalizedHeading) {
+        throw new DinoxError('--append-section requires a heading');
+    }
+    if (/^(#{1,6})\s+/.test(normalizedHeading)) {
+        throw new DinoxError('--append-section expects heading text without leading # markers');
+    }
+    return {
+        nodes: [
+            ...nodes,
+            headingNode(normalizedHeading, 2),
+            ...markdownToBlocks(markdown),
+        ],
+        target: { heading: normalizedHeading, nodeRange: `${nodes.length}:${nodes.length + 1}` },
+    };
+}
+function appendToHeading(document, nodes, headingPath, markdown) {
+    const heading = findHeadingRange(document, headingPath);
+    const insertAt = heading.endIndex;
+    const blocks = markdownToBlocks(markdown);
+    return {
+        nodes: [...nodes.slice(0, insertAt), ...blocks, ...nodes.slice(insertAt)],
+        target: { headingPath: heading.path, nodeRange: `${heading.index}:${heading.endIndex}` },
+    };
+}
+function replaceSection(document, nodes, operation) {
+    const heading = findHeadingRange(document, operation.headingPath);
+    const start = heading.index + 1;
+    const end = heading.endIndex;
+    assertProtectedReplacementAllowed(nodes.slice(start, end), Boolean(operation.allowProtectedReplace));
+    return {
+        nodes: [...nodes.slice(0, start), ...markdownToBlocks(operation.content), ...nodes.slice(end)],
+        target: { headingPath: heading.path, nodeRange: `${start}:${end}` },
+    };
+}
+function replaceBlock(nodes, operation) {
+    const match = normalizeMarkdownMatch(operation.match);
+    if (!match) {
+        throw new DinoxError('--match requires non-empty content for replace-block');
+    }
+    const ranges = findSerializedBlockRanges(nodes, match);
+    if (ranges.length === 0) {
+        throw new DinoxError('Block match was not found');
+    }
+    if (ranges.length > 1) {
+        throw new DinoxError('Block match is ambiguous; provide a larger exact match');
+    }
+    const range = ranges[0];
+    assertProtectedReplacementAllowed(nodes.slice(range.start, range.end), Boolean(operation.allowProtectedReplace));
+    return {
+        nodes: [...nodes.slice(0, range.start), ...markdownToBlocks(operation.content), ...nodes.slice(range.end)],
+        target: { nodeRange: `${range.start}:${range.end}`, matchHash: hashText(match) },
+    };
+}
+function findSerializedBlockRanges(nodes, match) {
+    const ranges = [];
+    for (let start = 0; start < nodes.length; start += 1) {
+        const maxEnd = Math.min(nodes.length, start + MAX_REPLACE_BLOCK_RANGE);
+        for (let end = start + 1; end <= maxEnd; end += 1) {
+            const markdown = normalizeMarkdownMatch(serializeNoteContentMarkdown({ type: 'doc', content: nodes.slice(start, end) }));
+            if (markdown === match) {
+                ranges.push({ start, end });
+            }
+        }
+    }
+    return ranges;
+}
+function assertProtectedReplacementAllowed(nodes, allowed) {
+    const protectedNodes = nodes.filter((node) => isProtectedBlock(node.type));
+    if (!protectedNodes.length || allowed) {
+        return;
+    }
+    const types = Array.from(new Set(protectedNodes.map((node) => node.type))).join(', ');
+    throw new DinoxError(`Target includes protected block(s): ${types}. Re-run with --allow-protected-replace after content-read if this replacement is intentional.`);
+}
+function buildHeadingRanges(document) {
+    const headings = [];
+    const stack = [];
+    const nodes = topLevelNodes(document);
+    nodes.forEach((node, index) => {
+        if (node.type !== 'heading') {
+            return;
+        }
+        const level = normalizeHeadingLevel(node.attrs?.level);
+        const title = extractPlainText(node).trim();
+        if (!title) {
+            return;
+        }
+        while (stack.length > 0 && stack[stack.length - 1].level >= level) {
+            stack.pop();
+        }
+        stack.push({ level, title });
+        headings.push({ path: stack.map((item) => item.title).join('/'), level, index, endIndex: nodes.length });
+    });
+    return headings.map((heading, index) => {
+        const boundary = headings.slice(index + 1).find((candidate) => candidate.level <= heading.level);
+        return { ...heading, endIndex: boundary?.index ?? nodes.length };
+    });
+}
+function findHeadingRange(document, headingPath) {
+    const normalized = normalizeHeadingPath(headingPath);
+    if (!normalized) {
+        throw new DinoxError('Heading path is required');
+    }
+    const matches = buildHeadingRanges(document).filter((heading) => normalizeHeadingPath(heading.path) === normalized);
+    if (matches.length === 0) {
+        throw new DinoxError(`Heading not found: ${headingPath}`);
+    }
+    if (matches.length > 1) {
+        throw new DinoxError(`Heading path is ambiguous: ${headingPath}`);
+    }
+    return matches[0];
+}
+function markdownToBlocks(markdown) {
+    const contentJson = convertMarkdownToNoteContent(normalizeLineEndings(markdown)).contentJson;
+    return topLevelNodes(normalizeDocument(contentJson));
+}
+function headingNode(text, level) {
+    return {
+        type: 'heading',
+        attrs: { level },
+        content: text ? [{ type: 'text', text }] : [],
+    };
+}
+function normalizeDocument(node) {
+    if (!node || node.type !== 'doc') {
+        return { type: 'doc', content: [node].filter(isNode) };
+    }
+    const content = Array.isArray(node.content) ? node.content.filter(isNode) : [];
+    return { ...node, type: 'doc', content };
+}
+function normalizeHashtagReferences(node, resolve) {
+    if (!resolve) {
+        return node;
+    }
+    const walk = (current) => {
+        const content = Array.isArray(current.content) ? current.content.filter(isNode).map(walk) : undefined;
+        let next = content ? { ...current, content } : current;
+        if (next.type !== 'hashtag') {
+            return next;
+        }
+        const id = stringAttr(next, 'id');
+        const path = canonicalPath(stringAttr(next, 'fullPath') ||
+            stringAttr(next, 'path') ||
+            stringAttr(next, 'label') ||
+            id);
+        const resolved = resolve({ id, path });
+        const nextPath = resolved?.path ?? path;
+        if (!nextPath) {
+            return next;
+        }
+        next = {
+            ...next,
+            attrs: {
+                ...(next.attrs ?? {}),
+                id: (resolved?.id ?? id) || nextPath,
+                label: nextPath,
+                path: nextPath,
+                fullPath: nextPath,
+            },
+        };
+        return next;
+    };
+    return walk(node);
+}
+function topLevelNodes(document) {
+    return Array.isArray(document.content) ? document.content.filter(isNode) : [];
+}
+function hasMeaningfulDocumentContent(document) {
+    const nodes = topLevelNodes(document);
+    if (nodes.length === 0)
+        return false;
+    if (nodes.length > 1)
+        return true;
+    const only = nodes[0];
+    if (only.type !== 'paragraph')
+        return true;
+    return extractPlainText(only).trim().length > 0;
+}
+function parseMaybeJson(raw, depth = 0) {
+    const text = raw?.trim() ?? '';
+    if (!text || text === 'null' || text === 'undefined') {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(text);
+        return typeof parsed === 'string' && depth < 2 ? parseMaybeJson(parsed, depth + 1) : parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function isNode(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value) && typeof value.type === 'string');
+}
+function getNodeEditMode(type) {
+    if (TEXT_BLOCK_TYPES.has(type))
+        return 'text';
+    if (ATOMIC_BLOCK_TYPES.has(type))
+        return 'atomicBlock';
+    if (CONTAINER_BLOCK_TYPES.has(type))
+        return 'container';
+    if (['text', 'hardBreak', 'mention', 'emoji', 'bidlink', 'hashtag', 'location', 'time', 'inlineMath'].includes(type))
+        return 'inlineAtom';
+    return 'unsupported';
+}
+function isProtectedBlock(type) {
+    const mode = getNodeEditMode(type);
+    return mode === 'atomicBlock' || mode === 'container' || mode === 'unsupported';
+}
+function resolveAnchorId(node) {
+    for (const key of ANCHOR_ATTRIBUTE_KEYS) {
+        const value = node.attrs?.[key];
+        if (typeof value === 'string' && value.trim()) {
+            return value.trim();
+        }
+    }
+    return null;
+}
+function safeAttrs(node) {
+    const attrs = node.attrs;
+    if (!attrs || typeof attrs !== 'object') {
+        return undefined;
+    }
+    const allowed = safeAttrKeys(node.type);
+    const safe = {};
+    for (const key of allowed) {
+        const value = attrs[key];
+        if (typeof value === 'string' && value.trim())
+            safe[key] = value.trim().slice(0, 2000);
+        if (typeof value === 'number' && Number.isFinite(value))
+            safe[key] = value;
+        if (typeof value === 'boolean')
+            safe[key] = value;
+    }
+    return Object.keys(safe).length ? safe : undefined;
+}
+function safeAttrKeys(type) {
+    const common = ['anchorKey', 'id', 'uniqueId'];
+    if (type === 'heading')
+        return [...common, 'level'];
+    if (type === 'image')
+        return [...common, 'src', 'resourceId', 'storageKey', 'alt', 'title', 'caption', 'showCaption'];
+    if (type === 'video')
+        return [...common, 'src', 'resourceId', 'storageKey', 'poster', 'title', 'autoplay', 'loop', 'muted', 'playsInline'];
+    if (type === 'audio')
+        return [...common, 'src', 'resourceId', 'storageKey', 'title', 'preload'];
+    if (type === 'file')
+        return [...common, 'src', 'resourceId', 'storageKey', 'name', 'type', 'mimeType', 'size'];
+    if (type === 'bookmark')
+        return [...common, 'url', 'title', 'description', 'siteName', 'domain', 'imageUrl', 'iconUrl'];
+    if (type === 'iframe')
+        return [...common, 'src'];
+    if (type === 'mermaid')
+        return [...common, 'code'];
+    if (type === 'mindgraph')
+        return [...common, 'markdown'];
+    if (type === 'audiosegment')
+        return [...common, 'text', 't0', 't1', 'speaker'];
+    if (type === 'pdfAnnotation')
+        return [...common, 'resourceId', 'pdfUrl', 'page', 'text', 'note'];
+    return common;
+}
+function extractPlainText(node) {
+    if (!node)
+        return '';
+    if (Array.isArray(node))
+        return node.map(extractPlainText).filter(Boolean).join('\n');
+    if (node.type === 'text')
+        return typeof node.text === 'string' ? node.text : '';
+    if (node.type === 'hardBreak')
+        return '\n';
+    const semantic = semanticNodeText(node);
+    if (semantic)
+        return semantic;
+    const children = Array.isArray(node.content) ? node.content : [];
+    const separator = joinsInlineContent(node.type) ? '' : isBlockNode(node.type) ? '\n' : '';
+    return children.map(extractPlainText).filter(Boolean).join(separator);
+}
+function blockToMarkdown(node, depth) {
+    const text = inlineMarkdown(node.content ?? []);
+    switch (node.type) {
+        case 'heading': return `${'#'.repeat(normalizeHeadingLevel(node.attrs?.level))} ${text}`.trim();
+        case 'paragraph': return text;
+        case 'blockquote': return childBlocks(node).map((child) => blockToMarkdown(child, depth)).join('\n').split('\n').map((line) => `> ${line}`).join('\n').trim();
+        case 'codeBlock': return `\`\`\`${stringAttr(node, 'language') || stringAttr(node, 'lang')}\n${extractPlainText(node)}\n\`\`\``;
+        case 'bulletList': return listToMarkdown(node, depth, '-');
+        case 'orderedList': return listToMarkdown(node, depth, '1.');
+        case 'taskList': return taskListToMarkdown(node, depth);
+        case 'horizontalRule': return '---';
+        case 'table': return tableToMarkdown(node);
+        case 'image': return imageToMarkdown(node);
+        case 'mermaid': return fencedAttrMarkdown('mermaid', stringAttr(node, 'code'));
+        case 'mindgraph': return fencedAttrMarkdown('mindgraph', stringAttr(node, 'markdown'));
+        case 'blockMath': return fencedAttrMarkdown('math', stringAttr(node, 'text') || stringAttr(node, 'latex') || stringAttr(node, 'code'));
+        case 'frontmatter': return stringAttr(node, 'raw') ? `---\n${stringAttr(node, 'raw')}\n---` : '';
+        default: return atomicReferenceMarkdown(node) || text || childBlocks(node).map((child) => blockToMarkdown(child, depth)).filter(Boolean).join('\n\n');
+    }
+}
+function inlineMarkdown(nodes) {
+    return nodes.map((node) => {
+        if (node.type === 'text')
+            return markedText(node);
+        if (node.type === 'hardBreak')
+            return '\n';
+        if (node.type === 'hashtag')
+            return `#${stringAttr(node, 'fullPath') || stringAttr(node, 'path') || stringAttr(node, 'label') || stringAttr(node, 'id')}`;
+        if (node.type === 'bidlink') {
+            const id = stringAttr(node, 'id');
+            const label = stringAttr(node, 'label');
+            return label && id ? `[[${label}|${id}]]` : label || `[[${id}]]`;
+        }
+        if (node.type === 'location')
+            return [stringAttr(node, 'name'), stringAttr(node, 'address')].filter(Boolean).join(' ');
+        if (node.type === 'time')
+            return stringAttr(node, 'iso') || stringAttr(node, 'displayFormat');
+        if (node.type === 'inlineMath')
+            return `$${stringAttr(node, 'text') || stringAttr(node, 'latex') || stringAttr(node, 'code') || extractPlainText(node)}$`;
+        return extractPlainText(node);
+    }).join('');
+}
+function markedText(node) {
+    let text = node.text ?? '';
+    for (const mark of Array.isArray(node.marks) ? node.marks : []) {
+        if (mark?.type === 'bold')
+            text = `**${text}**`;
+        if (mark?.type === 'italic')
+            text = `*${text}*`;
+        if (mark?.type === 'strike')
+            text = `~~${text}~~`;
+        if (mark?.type === 'code')
+            text = `\`${text.replace(/`/g, '\\`')}\``;
+        if (mark?.type === 'link') {
+            const href = stringFromAttrs(mark.attrs, 'href');
+            const title = stringFromAttrs(mark.attrs, 'title');
+            if (href)
+                text = `[${text}](${href}${title ? ` "${title.replace(/"/g, '\\"')}"` : ''})`;
+        }
+    }
+    return text;
+}
+function listToMarkdown(node, depth, marker) {
+    return childBlocks(node).map((item) => {
+        const [first, ...rest] = childBlocks(item);
+        const prefix = `${'  '.repeat(depth)}${marker} `;
+        const head = first ? blockToMarkdown(first, depth + 1).replace(/\n/g, '\n  ') : '';
+        const tail = rest.map((child) => blockToMarkdown(child, depth + 1)).filter(Boolean).join('\n');
+        return [prefix + head, tail].filter(Boolean).join('\n');
+    }).join('\n');
+}
+function taskListToMarkdown(node, depth) {
+    return childBlocks(node).map((item) => {
+        const checked = item.attrs?.checked === true ? 'x' : ' ';
+        const [first, ...rest] = childBlocks(item);
+        const prefix = `${'  '.repeat(depth)}- [${checked}] `;
+        const head = first ? blockToMarkdown(first, depth + 1).replace(/\n/g, '\n  ') : '';
+        const tail = rest.map((child) => blockToMarkdown(child, depth + 1)).filter(Boolean).join('\n');
+        return [prefix + head, tail].filter(Boolean).join('\n');
+    }).join('\n');
+}
+function tableToMarkdown(node) {
+    const matrix = childBlocks(node).filter((row) => row.type === 'tableRow').map((row) => childBlocks(row).filter((cell) => cell.type === 'tableCell' || cell.type === 'tableHeader'));
+    const width = Math.max(0, ...matrix.map((row) => row.length));
+    if (!width)
+        return '';
+    const rows = matrix.map((row) => Array.from({ length: width }, (_, index) => cellToMarkdown(row[index] ?? { type: 'tableCell', content: [] })));
+    return [rows[0], Array.from({ length: width }, () => '---'), ...rows.slice(1)].map((row) => `| ${row.join(' | ')} |`).join('\n');
+}
+function cellToMarkdown(cell) {
+    return childBlocks(cell).map((child) => blockToMarkdown(child, 0)).filter(Boolean).join('<br>').replace(/\|/g, '\\|').trim();
+}
+function imageToMarkdown(node) {
+    const src = stringAttr(node, 'src');
+    const alt = stringAttr(node, 'alt') || stringAttr(node, 'title') || inlineMarkdown(node.content ?? []);
+    const caption = stringAttr(node, 'caption') || inlineMarkdown(node.content ?? []);
+    return [src ? `![${alt}](${src})` : placeholderMarkdown('image', node), caption && caption !== alt ? caption : ''].filter(Boolean).join('\n');
+}
+function atomicReferenceMarkdown(node) {
+    if (node.type === 'video' || node.type === 'audio' || node.type === 'file' || node.type === 'bookmark' || node.type === 'iframe' || node.type === 'audiosegment' || node.type === 'pdfAnnotation') {
+        return placeholderMarkdown(node.type, node, semanticNodeText({ ...node, content: [] }));
+    }
+    return '';
+}
+function fencedAttrMarkdown(language, text) {
+    return text ? `\`\`\`${language}\n${text}\n\`\`\`` : `[${language}]`;
+}
+function placeholderMarkdown(type, node, label) {
+    const attrs = [
+        ['id', stringAttr(node, 'id')],
+        ['resourceId', stringAttr(node, 'resourceId')],
+        ['url', stringAttr(node, 'url') || stringAttr(node, 'src')],
+        ['title', stringAttr(node, 'title') || stringAttr(node, 'name')],
+    ].filter(([, value]) => value).map(([key, value]) => `${key}="${String(value).replace(/"/g, '\\"')}"`).join(' ');
+    return `[${type}${attrs ? ` ${attrs}` : ''}]${label ? ` ${label}` : ''}`;
+}
+function extractMetadata(document) {
+    const hashtags = new Set();
+    const images = new Set();
+    const bidLinks = new Map();
+    visit(document, (node) => {
+        if (node.type === 'hashtag') {
+            const tag = canonicalPath(stringAttr(node, 'fullPath') || stringAttr(node, 'path') || stringAttr(node, 'label') || stringAttr(node, 'id'));
+            if (tag)
+                hashtags.add(tag);
+        }
+        if ((node.type === 'image' || node.type === 'video') && /^https?:\/\//i.test(stringAttr(node, 'src'))) {
+            images.add(stripUrlQuery(stringAttr(node, 'src')));
+        }
+        if (node.type === 'bidlink') {
+            const id = stringAttr(node, 'id');
+            const type = stringAttr(node, 'type') || 'reference';
+            if (id)
+                bidLinks.set(`${id}::${type}`, { id, type: type === 'note' ? 'reference' : type });
+        }
+    });
+    return { hashtags: Array.from(hashtags), images: Array.from(images), bidLinks: Array.from(bidLinks.values()) };
+}
+function visit(node, callback) {
+    callback(node);
+    for (const child of Array.isArray(node.content) ? node.content : [])
+        visit(child, callback);
+}
+function semanticNodeText(node) {
+    switch (node.type) {
+        case 'hashtag': return stringAttr(node, 'fullPath') || stringAttr(node, 'path') || stringAttr(node, 'label') || stringAttr(node, 'id');
+        case 'bidlink': return stringAttr(node, 'label') || stringAttr(node, 'id');
+        case 'image': return stringAttr(node, 'caption') || stringAttr(node, 'alt') || stringAttr(node, 'title') || inlineMarkdown(node.content ?? []);
+        case 'video':
+        case 'audio': return stringAttr(node, 'title') || stringAttr(node, 'src');
+        case 'file': return stringAttr(node, 'name') || stringAttr(node, 'src');
+        case 'bookmark': return stringAttr(node, 'title') || stringAttr(node, 'description') || stringAttr(node, 'url');
+        case 'iframe': return stringAttr(node, 'src');
+        case 'mermaid': return stringAttr(node, 'code');
+        case 'mindgraph': return stringAttr(node, 'markdown');
+        case 'blockMath':
+        case 'inlineMath':
+        case 'math': return stringAttr(node, 'text') || stringAttr(node, 'latex') || stringAttr(node, 'code');
+        case 'audiosegment': return [stringAttr(node, 'speaker'), stringAttr(node, 'text'), extractPlainText(node.content)].filter(Boolean).join(' ');
+        case 'pdfAnnotation': return [stringAttr(node, 'text'), stringAttr(node, 'note'), extractPlainText(node.content)].filter(Boolean).join('\n');
+        default: return '';
+    }
+}
+function normalizeContentText(value, maxLength) {
+    const cleaned = normalizeLineEndings(value).split('\n').map((line) => line.trim()).filter(Boolean).join(' ').replace(/\bhttps?:\/\/\S+/gi, '').replace(/\s{2,}/g, ' ').trim();
+    return cleaned.length > maxLength ? cleaned.slice(0, maxLength) : cleaned;
+}
+function stableStringify(value) {
+    return JSON.stringify(stableValue(value));
+}
+function hashStableValue(value) {
+    return hashText(stableStringify(value));
+}
+function hashNode(node) {
+    return hashStableValue(node);
+}
+function hashText(value) {
+    return crypto.createHash('sha256').update(value, 'utf8').digest('hex');
+}
+function stableValue(value) {
+    if (Array.isArray(value))
+        return value.map(stableValue);
+    if (!value || typeof value !== 'object')
+        return value;
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, stableValue(item)]));
+}
+function childBlocks(node) {
+    return Array.isArray(node.content) ? node.content.filter(isNode) : [];
+}
+function stringAttr(node, key) {
+    return stringFromAttrs(node.attrs, key);
+}
+function stringFromAttrs(attrs, key) {
+    if (!attrs || typeof attrs !== 'object' || Array.isArray(attrs))
+        return '';
+    const value = attrs[key];
+    return typeof value === 'string' ? value.trim() : '';
+}
+function normalizeHeadingLevel(value) {
+    const level = Number(value);
+    return Number.isInteger(level) && level >= 1 && level <= 6 ? level : 1;
+}
+function normalizeHeadingPath(value) {
+    return value.split('/').map((segment) => segment.trim()).filter(Boolean).join('/');
+}
+function normalizeLineEndings(value) {
+    return String(value ?? '').replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+}
+function normalizeMarkdownMatch(value) {
+    return normalizeLineEndings(value).trim();
+}
+function canonicalPath(value) {
+    return value.split('/').map((segment) => segment.trim()).filter(Boolean).join('/');
+}
+function stripUrlQuery(input) {
+    try {
+        const url = new URL(input);
+        url.search = '';
+        url.hash = '';
+        return url.toString();
+    }
+    catch {
+        return input;
+    }
+}
+function joinsInlineContent(type) {
+    return ['paragraph', 'heading', 'text', 'blockquote'].includes(type);
+}
+function isBlockNode(type) {
+    return TEXT_BLOCK_TYPES.has(type) || ATOMIC_BLOCK_TYPES.has(type) || CONTAINER_BLOCK_TYPES.has(type);
+}