@omgbase/core 0.1.0

package/dist/src/format/markdown.js

@@ -0,0 +1,217 @@
+// Markdown format adapter — wraps existing parse/render/extract modules.
+import { AdapterCapability } from "./adapter.js";
+import { parseTree, assertFullCoverage } from "../core/parse/tree.js";
+import { render } from "../core/parse/render.js";
+import { extractFromBlock, extractFromFrontmatter, maskCode } from "../graph/extract.js";
+import { parse as parseYaml } from "yaml";
+export const MARKDOWN_FORMAT = "markdown";
+function toAdapterEdge(e) {
+    return {
+        srcBlock: e.srcBlock,
+        srcField: e.srcField,
+        predicate: e.predicate,
+        dstKind: e.dstKind,
+        target: e.target,
+        anchor: e.anchor,
+        provenance: e.provenance,
+    };
+}
+export const markdownAdapter = {
+    format: MARKDOWN_FORMAT,
+    extensions: [".md", ".markdown"],
+    capabilities: new Set([
+        AdapterCapability.Parse,
+        AdapterCapability.Render,
+        AdapterCapability.ExtractEdges,
+        AdapterCapability.ExtractMetadata,
+        AdapterCapability.ComputeProperties,
+        AdapterCapability.StructuralMutation,
+        AdapterCapability.ProjectNodes,
+    ]),
+    parse(source) {
+        return parseTree(source);
+    },
+    render(tree) {
+        return render(tree);
+    },
+    extractEdges(blocks, metadata) {
+        const edges = [];
+        // Walk every block (recursing into list/blockquote/table nesting) and scan
+        // its raw for links. srcBlock is the block's OWN assigned id — the caller
+        // passes id-assigned blocks (blockId zipped on), mirroring projectNodes; a
+        // block-grain edge without it is useless, so fall back to "" only for the
+        // pre-identity callers. extractFromBlock returns [] for link-free blocks, so
+        // no per-block gate is needed (matches the non-adapter fallback path).
+        const walk = (list) => {
+            for (const block of list) {
+                for (const e of extractFromBlock(block.blockId ?? "", block.type, block.raw)) {
+                    edges.push(toAdapterEdge(e));
+                }
+                if (block.children.length > 0)
+                    walk(block.children);
+            }
+        };
+        walk(blocks);
+        if (metadata) {
+            for (const e of extractFromFrontmatter(metadata))
+                edges.push(toAdapterEdge(e));
+        }
+        return edges;
+    },
+    extractMetadata(source) {
+        const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(source);
+        if (!match)
+            return null;
+        try {
+            const parsed = parseYaml(match[1]);
+            return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+                ? parsed
+                : null;
+        }
+        catch {
+            return null;
+        }
+    },
+    projectNodes(blocks) {
+        const nodes = [];
+        // Byte span of a regex match within the block's raw bytes (node-locates the
+        // feature inside its block; disambiguates multiple same-kind nodes — 13/nodes).
+        const span = (m) => ({
+            spanStart: m.index ?? 0,
+            spanEnd: (m.index ?? 0) + m[0].length,
+        });
+        const walk = (list, parentId) => {
+            for (const b of list) {
+                // Anchor to the block's OWN assigned id (zipped on by ingest); fall back
+                // to the parent's id, then "root", for pre-identity/parse-time callers.
+                const id = b.blockId || parentId || "root";
+                // Code is not prose (extraction_version x2): a code_fence block projects
+                // no link/anchor/field nodes, and inline code spans are masked before the
+                // regex scans below. Same rule as graph/extract.ts so the md:link /
+                // md:wikilink nodes and the `references` edges agree. maskCode is
+                // length-preserving, so spans still index the ORIGINAL raw.
+                const scan = b.type === "code_fence" ? "" : maskCode(b.raw);
+                // Links: [text](target)
+                for (const m of scan.matchAll(/\[([^\]]*)\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g)) {
+                    nodes.push({ kind: "md:link", name: m[1], value: m[2], blockId: id, ...span(m) });
+                }
+                // Wikilinks: [[target]]
+                for (const m of scan.matchAll(/\[\[([^\]]+)\]\]/g)) {
+                    nodes.push({ kind: "md:wikilink", value: m[1], blockId: id, ...span(m) });
+                }
+                // Tasks: checkbox items (the whole block; span covers its raw)
+                if (b.type === "task") {
+                    const checked = b.attrs.checked === true;
+                    nodes.push({ kind: "md:task", value: b.text, blockId: id, attrs: { checked }, spanStart: 0, spanEnd: b.raw.length });
+                }
+                // Anchors: ^ref
+                const anchorRe = /\^([a-zA-Z0-9_-]+)/g;
+                for (const m of scan.matchAll(anchorRe)) {
+                    nodes.push({ kind: "md:anchor", name: m[1], blockId: id, ...span(m) });
+                }
+                // Inline fields (dataview forms). Two shapes, so a multi-word value is
+                // captured whole instead of truncated at the first space:
+                //   line form  `key:: value`  — key at line start, value to end of line
+                //   bracketed  `[key:: value]` / `(key:: value)` — value ends at closer
+                // Bracketed matches first; the line form is anchored to a line start
+                // (leading whitespace only), so a `[key:: …]`/`(key:: …)` sitting on its
+                // own line is not double-counted (a bracket is not `[a-z]`).
+                for (const m of scan.matchAll(/[[(]([a-z][a-z0-9_]*)::[ \t]*([^\]\n)]*?)[ \t]*[\])]/gi)) {
+                    nodes.push({ kind: "md:inline_field", name: m[1], value: m[2], blockId: id, ...span(m) });
+                }
+                for (const m of scan.matchAll(/^[ \t]*([a-z][a-z0-9_]*)::[ \t]*([^\n]*?)[ \t]*$/gim)) {
+                    const start = (m.index ?? 0) + (m[0].match(/^[ \t]*/)?.[0].length ?? 0);
+                    const end = (m.index ?? 0) + m[0].replace(/[ \t]+$/, "").length;
+                    nodes.push({ kind: "md:inline_field", name: m[1], value: m[2], blockId: id, spanStart: start, spanEnd: end });
+                }
+                if (b.children.length > 0)
+                    walk(b.children, id);
+            }
+        };
+        walk(blocks, "");
+        return nodes;
+    },
+    // Editable node properties (node-editability). Each editor rewrites ONLY the
+    // node's own span within the block's raw bytes, then returns a block `update`
+    // (markdown or attrs). The span pins the exact occurrence, so editing the
+    // first of several same-kind nodes in one block is unambiguous.
+    nodeEditors: {
+        "md:link": {
+            // Retype the link text: [OLD](target) → [NEW](target), this occurrence only.
+            name: ({ blockRaw, span, node }, newValue) => {
+                if (!span)
+                    throw new Error("md:link.name requires a recorded span");
+                const seg = blockRaw.slice(span.start, span.end);
+                const rebuilt = seg.replace(/^\[[^\]]*\]/, `[${newValue}]`);
+                if (rebuilt === seg)
+                    throw new Error(`could not locate link text in ${JSON.stringify(seg)}`);
+                void node;
+                return { markdown: blockRaw.slice(0, span.start) + rebuilt + blockRaw.slice(span.end) };
+            },
+            // Retarget the link: [text](OLD) → [text](NEW), this occurrence only.
+            value: ({ blockRaw, span }, newValue) => {
+                if (!span)
+                    throw new Error("md:link.value requires a recorded span");
+                const seg = blockRaw.slice(span.start, span.end);
+                const rebuilt = seg.replace(/\]\(([^)\s]+)(\s+"[^"]*")?\)$/, (_m, _url, title) => `](${newValue}${title ?? ""})`);
+                if (rebuilt === seg)
+                    throw new Error(`could not locate link target in ${JSON.stringify(seg)}`);
+                return { markdown: blockRaw.slice(0, span.start) + rebuilt + blockRaw.slice(span.end) };
+            },
+        },
+        "md:task": {
+            // A task's checkbox is a typed block attribute, not a byte edit.
+            checked: (_ctx, newValue) => ({ attrs: { checked: newValue === "true" || newValue === "1" } }),
+        },
+    },
+    // Computed properties surfaced as $-intrinsics (12 §4). These are engine-
+    // derived and never claim the authored `title`/`tags` keys.
+    //   $title — text of the first level-1 heading
+    //   $tags  — distinct #hashtags found in body text (order-preserving)
+    computeProperties(blocks) {
+        const out = {};
+        const findH1 = (list) => {
+            for (const b of list) {
+                if (b.type === "heading" && b.attrs.level === 1 && b.text.trim())
+                    return b.text.trim();
+                const nested = findH1(b.children);
+                if (nested)
+                    return nested;
+            }
+            return undefined;
+        };
+        const title = findH1(blocks);
+        if (title)
+            out.$title = title;
+        const tags = [];
+        const seen = new Set();
+        const scan = (list) => {
+            for (const b of list) {
+                // #tag — a hash followed by a word char, not inside a heading marker or
+                // a code fence. Matches Obsidian-style inline tags in prose.
+                if (b.type !== "heading" && b.type !== "code_fence") {
+                    for (const m of b.raw.matchAll(/(?:^|\s)#([a-zA-Z][\w/-]*)/g)) {
+                        const t = m[1];
+                        if (!seen.has(t)) {
+                            seen.add(t);
+                            tags.push(t);
+                        }
+                    }
+                }
+                scan(b.children);
+            }
+        };
+        scan(blocks);
+        if (tags.length > 0)
+            out.$tags = tags;
+        return out;
+    },
+    reconcileHints() {
+        return {
+            anchorEvidenceKeys: ["lang", "info"],
+            smallBlockTokens: 8,
+        };
+    },
+};
+export { assertFullCoverage };
+//# sourceMappingURL=markdown.js.map

package/dist/src/format/registry.d.ts

@@ -0,0 +1,6 @@
+import type { FormatAdapter } from "./adapter.js";
+export declare function registerAdapter(adapter: FormatAdapter): void;
+export declare function adapterForFormat(format: string): FormatAdapter | undefined;
+export declare function adapterForPath(filePath: string): FormatAdapter | undefined;
+export declare function registeredFormats(): string[];
+export declare function detectFormat(filePath: string): string | undefined;

package/dist/src/format/registry.js

@@ -0,0 +1,24 @@
+// Format adapter registry. Maps file extensions and format names to adapters.
+import { extname } from "node:path";
+const byFormat = new Map();
+const byExtension = new Map();
+export function registerAdapter(adapter) {
+    byFormat.set(adapter.format, adapter);
+    for (const ext of adapter.extensions) {
+        byExtension.set(ext.toLowerCase(), adapter);
+    }
+}
+export function adapterForFormat(format) {
+    return byFormat.get(format);
+}
+export function adapterForPath(filePath) {
+    const ext = extname(filePath).toLowerCase();
+    return byExtension.get(ext);
+}
+export function registeredFormats() {
+    return [...byFormat.keys()];
+}
+export function detectFormat(filePath) {
+    return adapterForPath(filePath)?.format;
+}
+//# sourceMappingURL=registry.js.map

package/dist/src/format/yaml.d.ts

@@ -0,0 +1,5 @@
+import { type FormatAdapter, type AdapterEdge } from "./adapter.js";
+export declare const YAML_FORMAT = "yaml";
+declare function extractYamlEdges(source: string): AdapterEdge[];
+export declare const yamlAdapter: FormatAdapter;
+export { extractYamlEdges };

package/dist/src/format/yaml.js

@@ -0,0 +1,413 @@
+// YAML format adapter. Decomposes YAML files into blocks with yaml:-prefixed
+// kinds, extracts $ref/extends/$schema edges, and projects top-level mapping
+// entries as metadata.
+import { parseDocument, isMap, isSeq, isScalar, } from "yaml";
+import { AdapterCapability } from "./adapter.js";
+import { normalizeText } from "../core/hash.js";
+export const YAML_FORMAT = "yaml";
+// Block kinds for YAML structures.
+const K = {
+    mapping: "yaml:mapping",
+    mapping_entry: "yaml:mapping_entry",
+    sequence: "yaml:sequence",
+    sequence_item: "yaml:sequence_item",
+    scalar: "yaml:scalar",
+};
+function span(start, end) {
+    return { start, end };
+}
+function emptyBlock(kind, s, raw) {
+    return {
+        type: kind,
+        span: s,
+        raw,
+        text: normalizeText(raw),
+        attrs: {},
+        children: [],
+        trivia: "",
+        anchors: [],
+        outLinks: [],
+    };
+}
+// Build a block from a Pair (key: value mapping entry).
+function blockFromPair(pair, source, depth) {
+    const keyNode = pair.key;
+    const valNode = pair.value;
+    // Determine the span covering the full pair (key + value).
+    let start = Infinity;
+    let end = 0;
+    for (const n of [keyNode, valNode]) {
+        if (n && isScalar(n) && n.range) {
+            start = Math.min(start, n.range[0]);
+            end = Math.max(end, n.range[2] ?? n.range[1]);
+        }
+        else if (n && (isMap(n) || isSeq(n)) && n.range) {
+            start = Math.min(start, n.range[0]);
+            end = Math.max(end, n.range[2] ?? n.range[1]);
+        }
+    }
+    // If we can't determine span (shouldn't happen with parsed YAML), skip.
+    if (!isFinite(start) || end === 0)
+        return null;
+    const raw = source.slice(start, end);
+    const keyStr = isScalar(keyNode) ? String(keyNode.value) : "";
+    const attrs = { key: keyStr };
+    const children = [];
+    // Recurse into nested maps/seqs as child blocks.
+    if (isMap(valNode)) {
+        for (const item of valNode.items) {
+            const child = blockFromPair(item, source, depth + 1);
+            if (child)
+                children.push(child);
+        }
+    }
+    else if (isSeq(valNode)) {
+        for (let i = 0; i < valNode.items.length; i++) {
+            const item = valNode.items[i];
+            if (isScalar(item) && item.range) {
+                const iStart = item.range[0];
+                const iEnd = item.range[2] ?? item.range[1];
+                const iRaw = source.slice(iStart, iEnd);
+                const child = emptyBlock(K.sequence_item, span(iStart, iEnd), iRaw);
+                child.attrs = { index: i, value: item.value };
+                children.push(child);
+            }
+            else if (isMap(item) && item.range) {
+                const iStart = item.range[0];
+                const iEnd = item.range[2] ?? item.range[1];
+                const iRaw = source.slice(iStart, iEnd);
+                const child = emptyBlock(K.mapping, span(iStart, iEnd), iRaw);
+                for (const sub of item.items) {
+                    const subBlock = blockFromPair(sub, source, depth + 2);
+                    if (subBlock)
+                        child.children.push(subBlock);
+                }
+                children.push(child);
+            }
+            else if (isSeq(item) && item.range) {
+                const iStart = item.range[0];
+                const iEnd = item.range[2] ?? item.range[1];
+                const iRaw = source.slice(iStart, iEnd);
+                const child = emptyBlock(K.sequence, span(iStart, iEnd), iRaw);
+                children.push(child);
+            }
+        }
+    }
+    const block = emptyBlock(K.mapping_entry, span(start, end), raw);
+    block.attrs = attrs;
+    block.children = children;
+    return block;
+}
+function parseYamlBlocks(source) {
+    let doc;
+    try {
+        doc = parseDocument(source, { keepSourceTokens: true });
+    }
+    catch {
+        // Malformed YAML: return a single opaque block.
+        return [emptyBlock("yaml:opaque", span(0, source.length), source)];
+    }
+    const contents = doc.contents;
+    if (!contents) {
+        return source.trim().length > 0
+            ? [emptyBlock(K.scalar, span(0, source.length), source)]
+            : [];
+    }
+    const blocks = [];
+    if (isMap(contents)) {
+        for (const pair of contents.items) {
+            const block = blockFromPair(pair, source, 0);
+            if (block)
+                blocks.push(block);
+        }
+    }
+    else if (isSeq(contents)) {
+        for (let i = 0; i < contents.items.length; i++) {
+            const item = contents.items[i];
+            if (isScalar(item) && item.range) {
+                const start = item.range[0];
+                const end = item.range[2] ?? item.range[1];
+                const block = emptyBlock(K.sequence_item, span(start, end), source.slice(start, end));
+                block.attrs = { index: i, value: item.value };
+                blocks.push(block);
+            }
+            else if (isMap(item) && item.range) {
+                const start = item.range[0];
+                const end = item.range[2] ?? item.range[1];
+                const block = emptyBlock(K.mapping, span(start, end), source.slice(start, end));
+                for (const sub of item.items) {
+                    const child = blockFromPair(sub, source, 1);
+                    if (child)
+                        block.children.push(child);
+                }
+                blocks.push(block);
+            }
+        }
+    }
+    else if (isScalar(contents) && contents.range) {
+        const start = contents.range[0];
+        const end = contents.range[2] ?? contents.range[1];
+        blocks.push(emptyBlock(K.scalar, span(start, end), source.slice(start, end)));
+    }
+    return blocks;
+}
+// Attach trivia (inter-block whitespace) to blocks, same algorithm as markdown.
+function buildTree(source) {
+    const children = parseYamlBlocks(source);
+    const leadingTrivia = children.length === 0 ? source : source.slice(0, children[0].span.start);
+    for (let i = 0; i < children.length; i++) {
+        const block = children[i];
+        const next = children[i + 1];
+        const triviaEnd = next ? next.span.start : source.length;
+        block.trivia = source.slice(block.span.end, triviaEnd);
+    }
+    return { source, leadingTrivia, children };
+}
+// Edge extraction: $ref, extends, $schema, and path-like string values.
+function extractYamlEdges(source) {
+    let doc;
+    try {
+        doc = parseDocument(source);
+    }
+    catch {
+        return [];
+    }
+    const edges = [];
+    const seen = new Set();
+    function push(e) {
+        const k = `${e.predicate}|${e.target}|${e.provenance}`;
+        if (seen.has(k))
+            return;
+        seen.add(k);
+        edges.push(e);
+    }
+    function walkValue(key, value) {
+        if (typeof value !== "string")
+            return;
+        if (key === "$ref" || key === "\\$ref") {
+            const target = value.startsWith("#") ? "" : value.split("#")[0];
+            if (target) {
+                push({
+                    srcBlock: null,
+                    srcField: "$ref",
+                    predicate: "references",
+                    dstKind: isExternalUri(target) ? "external" : "document",
+                    target,
+                    anchor: value.includes("#") ? value.split("#")[1] : null,
+                    provenance: "yaml_ref",
+                });
+            }
+            return;
+        }
+        if (key === "$schema") {
+            push({
+                srcBlock: null,
+                srcField: "$schema",
+                predicate: "schema",
+                dstKind: isExternalUri(value) ? "external" : "document",
+                target: value,
+                anchor: null,
+                provenance: "yaml_schema",
+            });
+            return;
+        }
+        if (key === "extends") {
+            push({
+                srcBlock: null,
+                srcField: "extends",
+                predicate: "extends",
+                dstKind: isExternalUri(value) ? "external" : "document",
+                target: value,
+                anchor: null,
+                provenance: "yaml_extends",
+            });
+            return;
+        }
+        // Path-like string values: ./path or /path (not URLs, not bare words).
+        if ((value.startsWith("./") || value.startsWith("../") || value.startsWith("/")) && !value.includes(" ")) {
+            push({
+                srcBlock: null,
+                srcField: key,
+                predicate: key,
+                dstKind: "document",
+                target: value,
+                anchor: null,
+                provenance: "yaml_ref",
+            });
+        }
+    }
+    function walkNode(node, parentKey) {
+        if (isMap(node)) {
+            for (const pair of node.items) {
+                const key = isScalar(pair.key) ? String(pair.key.value) : parentKey;
+                if (isScalar(pair.value)) {
+                    walkValue(key, pair.value.value);
+                }
+                else {
+                    walkNode(pair.value, key);
+                }
+            }
+        }
+        else if (isSeq(node)) {
+            for (const item of node.items) {
+                if (isScalar(item)) {
+                    walkValue(parentKey, item.value);
+                }
+                else {
+                    walkNode(item, parentKey);
+                }
+            }
+        }
+    }
+    walkNode(doc.contents, "");
+    return edges;
+}
+function isExternalUri(s) {
+    return /^https?:\/\//.test(s);
+}
+export const yamlAdapter = {
+    format: YAML_FORMAT,
+    extensions: [".yaml", ".yml"],
+    capabilities: new Set([
+        AdapterCapability.Parse,
+        AdapterCapability.Render,
+        AdapterCapability.ExtractEdges,
+        AdapterCapability.ExtractMetadata,
+        AdapterCapability.ProjectNodes,
+        AdapterCapability.StructuralMutation,
+    ]),
+    parse(source) {
+        return buildTree(source);
+    },
+    render(tree) {
+        // Splice renderer: untouched blocks emit raw verbatim, preserving comments
+        // and formatting. Same strategy as the markdown adapter.
+        const out = [tree.leadingTrivia];
+        for (const block of tree.children) {
+            out.push(block.raw);
+            out.push(block.trivia);
+        }
+        return out.join("");
+    },
+    extractEdges(_blocks, metadata) {
+        // YAML edge extraction works from the parsed document, not individual blocks,
+        // since references can appear at any nesting depth. We re-extract from the
+        // full source stored in blocks[0]'s parent tree, but since we receive
+        // metadata (the parsed top-level mapping), we walk that instead.
+        if (!metadata)
+            return [];
+        // Walk the metadata object for edges. For full extraction we'd need the
+        // source, so we implement a lightweight object-walking extractor here.
+        const edges = [];
+        const seen = new Set();
+        function push(e) {
+            const k = `${e.predicate}|${e.target}|${e.provenance}`;
+            if (seen.has(k))
+                return;
+            seen.add(k);
+            edges.push(e);
+        }
+        function walk(obj, parentKey) {
+            if (typeof obj === "string") {
+                walkStringValue(parentKey, obj, push);
+            }
+            else if (Array.isArray(obj)) {
+                for (const item of obj)
+                    walk(item, parentKey);
+            }
+            else if (obj && typeof obj === "object") {
+                for (const [k, v] of Object.entries(obj)) {
+                    walk(v, k);
+                }
+            }
+        }
+        walk(metadata, "");
+        return edges;
+    },
+    projectNodes(blocks) {
+        const nodes = [];
+        const walk = (list) => {
+            for (const b of list) {
+                const id = b.blockId ?? "";
+                // $ref values
+                if (b.type === "yaml:mapping_entry" && b.attrs.key === "$ref") {
+                    const val = b.raw.replace(/^[^:]*:\s*/, "").trim();
+                    nodes.push({ kind: "yaml:ref", name: "$ref", value: val, blockId: id });
+                }
+                // $schema values
+                if (b.type === "yaml:mapping_entry" && b.attrs.key === "$schema") {
+                    const val = b.raw.replace(/^[^:]*:\s*/, "").trim();
+                    nodes.push({ kind: "yaml:schema", name: "$schema", value: val, blockId: id });
+                }
+                // YAML anchors &name
+                for (const m of b.raw.matchAll(/&([a-zA-Z_][a-zA-Z0-9_]*)/g)) {
+                    nodes.push({ kind: "yaml:anchor", name: m[1], blockId: id });
+                }
+                // YAML aliases *name
+                for (const m of b.raw.matchAll(/\*([a-zA-Z_][a-zA-Z0-9_]*)/g)) {
+                    nodes.push({ kind: "yaml:alias", name: m[1], blockId: id });
+                }
+                // Environment variable references ${VAR}
+                for (const m of b.raw.matchAll(/\$\{([A-Z_][A-Z0-9_]*)\}/g)) {
+                    nodes.push({ kind: "yaml:env_var", name: m[1], blockId: id });
+                }
+                if (b.children.length > 0)
+                    walk(b.children);
+            }
+        };
+        walk(blocks);
+        return nodes;
+    },
+    extractMetadata(source) {
+        try {
+            const doc = parseDocument(source);
+            const obj = doc.toJS();
+            if (obj && typeof obj === "object" && !Array.isArray(obj)) {
+                return obj;
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    },
+};
+function walkStringValue(key, value, push) {
+    if (key === "$ref") {
+        const target = value.startsWith("#") ? "" : value.split("#")[0];
+        if (target) {
+            push({
+                srcBlock: null, srcField: "$ref", predicate: "references",
+                dstKind: isExternalUri(target) ? "external" : "document",
+                target, anchor: value.includes("#") ? value.split("#")[1] : null,
+                provenance: "yaml_ref",
+            });
+        }
+        return;
+    }
+    if (key === "$schema") {
+        push({
+            srcBlock: null, srcField: "$schema", predicate: "schema",
+            dstKind: isExternalUri(value) ? "external" : "document",
+            target: value, anchor: null, provenance: "yaml_schema",
+        });
+        return;
+    }
+    if (key === "extends") {
+        push({
+            srcBlock: null, srcField: "extends", predicate: "extends",
+            dstKind: isExternalUri(value) ? "external" : "document",
+            target: value, anchor: null, provenance: "yaml_extends",
+        });
+        return;
+    }
+    if ((value.startsWith("./") || value.startsWith("../") || value.startsWith("/")) && !value.includes(" ")) {
+        push({
+            srcBlock: null, srcField: key, predicate: key,
+            dstKind: "document", target: value, anchor: null, provenance: "yaml_ref",
+        });
+    }
+}
+// Also export the standalone source-based extractor for direct use.
+export { extractYamlEdges };
+//# sourceMappingURL=yaml.js.map