@geml/geml 1.7.8 → 1.8.1

package/dist/geml.js

@@ -91,17 +91,26 @@ function jsonErrorLine(e, text, openLineNo) {
 export { SEVERITY } from "./diagnostics.js";
 // Type registry: which body mode each typed block uses. Unknown types are a
 // warning and fall back to `raw` (forward compatibility, §3/§8).
-const REGISTRY = {
-    code: "raw",
-    diagram: "raw",
-    math: "raw",
-    table: "raw", // structured table parsing lands in M3
-    data: "raw", // GEP-0005: value tree — a format engine parses the raw body in a second stage
-    embed: "raw", // block transclusion: `src=` points at the content, body unused
-    note: "flow",
-    text: "flow", // addressable prose container: an id/attrs for a run of flow, no callout chrome
-    meta: "data",
-};
+//
+// A Map, not an object, because the key is the type name off a fence head — i.e.
+// document-controlled. Indexing a plain object with it answered for the whole
+// prototype chain: `=== constructor` (also toString, valueOf, hasOwnProperty,
+// isPrototypeOf, propertyIsEnumerable, toLocaleString) returned an inherited
+// FUNCTION, which is not undefined, so the unknown-block-type warning never
+// fired and a function reached the model's `mode` field — a value the published
+// `BodyMode` type says cannot occur, and one JSON.stringify silently drops.
+// Every other document-keyed registry here is already a Set or a Map.
+const REGISTRY = new Map([
+    ["code", "raw"],
+    ["diagram", "raw"],
+    ["math", "raw"],
+    ["table", "raw"], // structured table parsing lands in M3
+    ["data", "raw"], // GEP-0005: value tree — a format engine parses the raw body in a second stage
+    ["embed", "raw"], // block transclusion: `src=` points at the content, body unused
+    ["note", "flow"],
+    ["text", "flow"], // addressable prose container: an id/attrs for a run of flow, no callout chrome
+    ["meta", "data"],
+]);
 // §7: built-in diagram renderer registry. Unknown formats are a warning (the
 // processor keeps the body raw rather than interpreting it).
 const DIAGRAM_RENDERERS = new Set(["mermaid", "graphviz", "dot", "d2", "plantuml", "geml-chart", "geml-code-graph"]);
@@ -184,7 +193,7 @@ function slug(text) {
     return text
         .toLowerCase()
         .replace(/`[^`]*`/g, "")
-        .replace(/[^\p{L}\p{N}\s-]/gu, "")
+        .replace(/[^\p{L}\p{N}\s\-_]/gu, "")
         .trim()
         .replace(/\s+/g, "-");
 }
@@ -439,7 +448,7 @@ function scanBlocks(lines, base, ctx, depth = 0) {
                 const how = attrs.id !== undefined ? `${"=".repeat(openLen)} or \`=== #${attrs.id}\`` : "=".repeat(openLen);
                 diags.push({ severity: "error", code: "unterminated-block", message: `unterminated \`${type}\` block (no matching ${how})`, line: openLineNo });
             }
-            let mode = REGISTRY[type];
+            let mode = REGISTRY.get(type);
             if (mode === undefined) {
                 diags.push({ severity: "warning", code: "unknown-block-type", message: `unknown block type \`${type}\`; body kept as raw`, line: openLineNo });
                 mode = "raw";
@@ -1111,8 +1120,9 @@ function gatherIds(source) {
 }
 // Pre-scan for `=== meta` blocks (at any fence depth) and merge their
 // `key=val` lines, so `{{key}}` interpolation can resolve forward references.
-function collectMeta(lines) {
+function collectMeta(lines, diags) {
     const meta = new Map();
+    const firstLine = new Map(); // key → 1-based line of the defining fence
     for (let i = 0; i < lines.length; i++) {
         const open = FENCE_OPEN.exec(lines[i]);
         if (!open || open[2] !== "meta")
@@ -1122,8 +1132,17 @@ function collectMeta(lines) {
         let j = i + 1;
         for (; j < lines.length && !isCloseFence(lines[j], len); j++)
             body.push(lines[j]);
-        for (const [k, v] of Object.entries(parseData(body)))
-            meta.set(k, String(v));
+        for (const [k, v] of Object.entries(parseData(body))) {
+            if (meta.has(k)) {
+                diags?.push({ severity: "warning", code: "duplicate-meta-key",
+                    message: `meta key \`${k}\` already defined at line ${firstLine.get(k)}; later definition at line ${i + 1} is ignored`,
+                    line: i + 1 });
+            }
+            else {
+                meta.set(k, String(v));
+                firstLine.set(k, i + 1);
+            }
+        }
         i = j;
     }
     return meta;
@@ -1283,13 +1302,14 @@ function resolveCodeSources(ctx, opts) {
         if (slice === null)
             continue;
         const hasBody = (block.raw ?? []).some((l) => l.trim() !== "");
-        if (!hasBody) {
-            block.raw = slice;
+        if (hasBody) {
+            // A code block must not carry both src= and an inline body (§3.3).
+            ctx.diags.push({ severity: "error", code: "code-src-and-body",
+                message: `code: carries both \`src=\` and an inline body; exactly one is permitted`,
+                line });
         }
-        else if ((block.raw ?? []).join("\n") !== slice.join("\n")) {
-            // A body alongside `src=` is a cached snapshot, kept for offline reading.
-            // Silence would let the two drift — the very thing the route prevents.
-            ctx.diags.push({ severity: "warning", code: "stale-code-snapshot", message: `code block body differs from its source \`${target}\` — the body is a snapshot and is now out of date`, line });
+        else {
+            block.raw = slice;
         }
     }
 }
@@ -1547,7 +1567,8 @@ function resolveCharts(ctx, opts) {
 }
 export function parse(source, opts = {}) {
     const lines = normalizeSource(source).split("\n");
-    const ctx = { diags: [], ids: new Map(), refs: [], meta: collectMeta(lines), resolveDoc: opts.resolveDoc };
+    const diags = [];
+    const ctx = { diags, ids: new Map(), refs: [], meta: collectMeta(lines, diags), resolveDoc: opts.resolveDoc };
     const children = scanBlocks(lines, 0, ctx);
     // Table sources first: a chart reads the build-time model of the table it
     // charts, so that model has to be filled before charts are resolved.
@@ -1659,7 +1680,7 @@ units) {
             // Only a flow body is scanned for nested blocks (raw/data bodies are
             // opaque), so an id inside a `code` body is *not* addressable — exactly
             // the parser's contract.
-            if ((REGISTRY[type] ?? "raw") === "flow" && depth < MAX_NESTING) {
+            if ((REGISTRY.get(type) ?? "raw") === "flow" && depth < MAX_NESTING) {
                 collectSpans(lines.slice(i + 1, closed ? end - 1 : end), base + i + 1, out, ctx, depth + 1, units);
             }
             i = end;

package/dist/inline.d.ts

@@ -70,4 +70,10 @@ export interface RefSink {
 export declare const META_REF_SRC = "\\{\\{\\s*([A-Za-z_][A-Za-z0-9_-]*)\\s*\\}\\}";
 export declare function schemeOf(url: string): string | null;
 export declare function isSafeUrl(url: string, allowDataImage?: boolean): boolean;
-export declare function parseInline(s: string, line: number, sink: RefSink, depth?: number): Inline[];
+interface Pairs {
+    br: Int32Array;
+    pa: Int32Array;
+    off: number;
+}
+export declare function parseInline(s: string, line: number, sink: RefSink, depth?: number, pairs?: Pairs): Inline[];
+export {};