@geml/geml 1.4.6 → 1.5.1

package/dist/serialize.js

@@ -124,6 +124,7 @@ function serInline(n, esc) {
         case "image": return `![${n.alt}](${n.src})${serAttrs({ attrs: n.attrs })}`;
         case "link": return `[${serSeq(n.children, esc)}](${linkDest(n)})${serAttrs({ attrs: n.attrs })}`;
         case "autoref": return `[[${n.doc !== undefined ? `${n.doc}#${n.anchor}` : `#${n.anchor}`}]]`;
+        case "project": return `![[${n.doc !== undefined ? `${n.doc}#${n.anchor}` : `#${n.anchor}`}]]`;
         case "footnote": return `[^${n.ref}]`;
     }
 }
@@ -138,7 +139,14 @@ function serInlines(ns) {
     const lazy = serSeq(ns, false);
     if (JSON.stringify(parseInline(lazy, 0, { refs: [] })) === JSON.stringify(ns))
         return lazy;
-    return serSeq(ns, true);
+    const escaped = serSeq(ns, true);
+    if (JSON.stringify(parseInline(escaped, 0, { refs: [] })) === JSON.stringify(ns))
+        return escaped;
+    // Neither form round-trips on its own. The case this exists for: a text run
+    // ending in `!` immediately before an auto-reference re-reads as an inline
+    // projection (`!` + `[[` is one atom since §5.3), so the bang has to be escaped
+    // even though nothing about the text itself is a metacharacter.
+    return serSeq(ns, true).replace(/!(?=\[\[)/g, "\\!");
 }
 // ---------------------------------------------------------------------------
 // Blocks

package/dist/table.d.ts

@@ -8,10 +8,6 @@ export interface TableCell {
     align?: Align;
     value?: number;
     computed?: boolean;
-    span?: {
-        rows: number;
-        cols: number;
-    };
 }
 export interface TableModel {
     caption?: string;

package/dist/table.js

@@ -127,22 +127,34 @@ function lexExpr(s) {
 // Display format: a `[printf]` spec bound to a column/cell name (§6).
 //   `FY [%.1f]` → name "FY", fmt "%.1f";  `YoY [%.1f%%]` → "%.1f%%"
 // ---------------------------------------------------------------------------
+// The bracket suffix has to contain a `%` to be a format (§6). Without that
+// test, a column whose own name is bracketed — `[Data] = …` — parses as an
+// empty name plus the format `Data`, and the formula silently targets nothing.
 function splitName(lhs) {
-    const m = /^(.*?)\s*\[([^\]]*)\]\s*$/.exec(lhs.trim());
+    const m = /^(.*?)\s*\[([^\]]*%[^\]]*)\]\s*$/.exec(lhs.trim());
     let name = (m ? m[1] : lhs).trim();
     if (name.startsWith('"') && name.endsWith('"'))
         name = name.slice(1, -1);
     return m ? { name, fmt: m[2] } : { name };
 }
+// A result IEEE-754 produces but a table cannot hold (§6): `x / 0` is ±∞, `0 / 0`
+// is NaN. The cell keeps no value and displays `-`, which is what a reader sees;
+// naming the cause is the difference between "this row had no data" and "this
+// row divided by zero", so it is said out loud like a substituted cell is.
+const nanMsg = (where, v) => `${where}: ${Number.isNaN(v) ? "result is not a number (0/0)" : "division by zero"}; the cell holds no value and shows \`-\``;
 // Default rendering for an unformatted computed number: drop IEEE-754 display
 // noise (0.1+0.2 → "0.3", sum of 1-dp inputs → "263.6") without altering the
 // stored numeric value.
 function defaultNum(v) {
+    if (!isFinite(v))
+        return "-";
     return String(parseFloat(v.toPrecision(12)));
 }
 // Minimal printf for a single numeric value: handles %f/%e/%d/%g with optional
 // precision, and `%%` as a literal percent. Width/flags are not padded.
 function applyFormat(fmt, v) {
+    if (!isFinite(v))
+        return "-";
     return fmt.replace(/%%|%[-+ 0]*\d*(?:\.\d+)?[fFeEgGd]/g, (m) => {
         if (m === "%%")
             return "%";
@@ -232,24 +244,16 @@ function evalExpr(toks, row, col, agg) {
     return v;
 }
 // ---------------------------------------------------------------------------
-// Spans
-// ---------------------------------------------------------------------------
-// Parse `r2c1:2x1` → target cell (1-based row/col over body) + size.
-function parseSpan(s) {
-    const m = /^r(\d+)c(\d+):(\d+)x(\d+)$/.exec(s.trim());
-    if (!m)
-        return null;
-    return { row: +m[1], col: +m[2], rows: +m[3], cols: +m[4] };
-}
-// ---------------------------------------------------------------------------
 // Public entry
 // ---------------------------------------------------------------------------
 export function parseTable(body, attrs, line, sink) {
     const diagnostics = [];
     const fmt = typeof attrs["format"] === "string" ? attrs["format"] : undefined;
-    // External data source (§6): `src=` points at a CSV/TSV file or URL, loaded at
-    // render time — not read here. So compute/chart column-name checking for an
-    // src table also happens at render time, and the inline body must be empty.
+    // Data from elsewhere (§6): the caller has normalised `src=`/`data=` into `src`.
+    // A local or cross-document target is resolved after the scan (resolveTableSources
+    // in geml.ts calls back into this function with the resolved lines, so format,
+    // header, compute and summary behave identically); only an `http(s)` URL is still
+    // a render-time fetch. Either way the inline body must be empty.
     const src = typeof attrs["src"] === "string" ? attrs["src"] : undefined;
     if (src !== undefined) {
         if (body.some((l) => l.trim() !== "")) {
@@ -308,19 +312,47 @@ export function parseTable(body, attrs, line, sink) {
         const v = model.rows[row]?.[ci]?.value;
         return typeof v === "number" ? v : null;
     };
+    // A cell a formula reads but cannot read as a number (`x`, `N/A`, `TBD`, an
+    // empty cell) counts as 0, so one dirty row does not void the whole column.
+    // But counting it silently is how a table quietly reports the wrong total, so
+    // say which cell was substituted. One warning per cell, not per mention: a
+    // formula naming the same column twice describes one substitution.
+    const substituted = new Set();
     const colResolve = (name, row) => {
         const ci = colIndex(name);
-        return ci < 0 ? null : cellNum(ci, row);
+        if (ci < 0)
+            return null;
+        const n = cellNum(ci, row);
+        if (n !== null)
+            return n;
+        const key = `${ci}\0${row}`;
+        if (!substituted.has(key)) {
+            substituted.add(key);
+            const text = model.rows[row]?.[ci]?.text ?? "";
+            diagnostics.push({
+                severity: "warning",
+                code: "compute-non-numeric-cell",
+                message: `column \`${name}\` row ${row + 1} is not a number (${text === "" ? "empty" : `\`${text}\``}); counted as 0`,
+            });
+        }
+        return 0;
     };
     const computeAgg = (fn, ci) => {
+        if (fn === "count") {
+            let c = 0;
+            for (let r = 0; r < model.rows.length; r++) {
+                const text = model.rows[r]?.[ci]?.text;
+                if (text !== undefined && text !== "")
+                    c++;
+            }
+            return c;
+        }
         const vals = [];
         for (let r = 0; r < model.rows.length; r++) {
             const v = cellNum(ci, r);
             if (v !== null)
                 vals.push(v);
         }
-        if (fn === "count")
-            return vals.length;
         if (vals.length === 0)
             return 0;
         if (fn === "sum")
@@ -396,13 +428,14 @@ export function parseTable(body, attrs, line, sink) {
             try {
                 const v = evalExpr(toks, r, colResolve, aggResolve);
                 const cell = ensureCell(model.rows[r], ci);
-                if (Number.isFinite(v)) {
-                    const text = fmt ? applyFormat(fmt, v) : defaultNum(v);
+                const text = fmt ? applyFormat(fmt, v) : defaultNum(v);
+                cell.text = text;
+                cell.computed = true;
+                cell.inlines = [{ type: "text", value: text }];
+                if (Number.isFinite(v))
                     cell.value = v;
-                    cell.text = text;
-                    cell.computed = true;
-                    cell.inlines = [{ type: "text", value: text }];
-                }
+                else
+                    diagnostics.push({ severity: "warning", code: "compute-not-a-number", message: nanMsg(`compute \`${name}\` row ${r + 1}`, v) });
             }
             catch (e) {
                 diagnostics.push({ severity: "error", code: "compute-error", message: `compute \`${name}\`: ${e.message}` });
@@ -456,10 +489,12 @@ export function parseTable(body, attrs, line, sink) {
             }
             try {
                 const v = evalExpr(toks, 0, noRow, aggResolve);
-                if (Number.isFinite(v)) {
-                    const text = fmt ? applyFormat(fmt, v) : defaultNum(v);
-                    summary[ci] = { text, inlines: [{ type: "text", value: text }], value: v, computed: true };
-                }
+                const text = fmt ? applyFormat(fmt, v) : defaultNum(v);
+                summary[ci] = { text, inlines: [{ type: "text", value: text }], computed: true };
+                if (Number.isFinite(v))
+                    summary[ci].value = v;
+                else
+                    diagnostics.push({ severity: "warning", code: "compute-not-a-number", message: nanMsg(`summary \`${name}\``, v) });
             }
             catch (e) {
                 const msg = /unknown column `(.+)`/.exec(e.message);
@@ -469,32 +504,6 @@ export function parseTable(body, attrs, line, sink) {
         }
         model.summary = summary;
     }
-    // Spans: `span="r2c1:2x1"` (one or many: span, span2, …).
-    const spanDecls = Object.entries(attrs)
-        .filter(([k]) => k === "span" || /^span\d+$/.test(k))
-        .map(([, v]) => v)
-        .filter((v) => typeof v === "string");
-    for (const sd of spanDecls) {
-        const sp = parseSpan(sd);
-        if (!sp) {
-            diagnostics.push({ severity: "error", code: "bad-span", message: `bad span \`${sd}\` (want \`rNcM:RxC\`)` });
-            continue;
-        }
-        const cell = model.rows[sp.row - 1]?.[sp.col - 1];
-        if (!cell) {
-            diagnostics.push({ severity: "warning", code: "span-outside-table", message: `span \`${sd}\` targets a cell outside the table` });
-            continue;
-        }
-        // A span can never extend past the grid: clamp its extent to the rows/cols
-        // actually available from the target cell. Without this, `span="r1c1:9e6x9e6"`
-        // makes the renderer's O(rows×cols) coverage sweep hang (DoS). Every row has
-        // exactly `columns.length` cells (built above), so the column bound is exact.
-        const maxRows = model.rows.length - (sp.row - 1);
-        const maxCols = columns.length - (sp.col - 1);
-        const rows = Math.max(1, Math.min(sp.rows, maxRows));
-        const cols = Math.max(1, Math.min(sp.cols, maxCols));
-        cell.span = { rows, cols };
-    }
     return { model, diagnostics };
 }
 function ensureCell(row, ci) {

package/dist/to-md.js

@@ -38,6 +38,10 @@ function inline(n) {
         case "link": return `[${seq(n.children)}](${linkDest(n)})`;
         // Markdown has no auto-reference; project to a plain link to the anchor.
         case "autoref": return n.doc !== undefined ? `[${n.doc}#${n.anchor}](${n.doc}#${n.anchor})` : `[#${n.anchor}](#${n.anchor})`;
+        // An inline projection needs the target's body, which this projection has no
+        // resolver for. The link keeps the reference reachable; the loss is reported
+        // once for the document by gemlToMd.
+        case "project": return n.doc !== undefined ? `[${n.doc}#${n.anchor}](${n.doc}#${n.anchor})` : `[#${n.anchor}](#${n.anchor})`;
         case "footnote": return `[^${n.ref}]`;
     }
 }
@@ -121,7 +125,10 @@ function typedToMd(b, notes) {
         return "";
     }
     if (b.mode === "flow") {
-        // Footnote definition: a `note.footnote` carrying its ref as the id.
+        // A note the author marked `.footnote` projects to a Markdown footnote
+        // definition. The parser no longer synthesizes this class — the `[^id]: text`
+        // definition line was withdrawn from §5.2 — but an author still writes it,
+        // and it is the only way this projection can be produced.
         if (b.type === "note" && b.classes.includes("footnote") && b.id) {
             const text = (b.children ?? []).map((c) => block(c, notes)).join(" ").replace(/\n+/g, " ").trim();
             return `[^${b.id}]: ${text}`;
@@ -139,8 +146,6 @@ function typedToMd(b, notes) {
         return fence(attr(b, "lang") ?? "", raw);
     if (b.type === "math")
         return ["$$", ...raw, "$$"].join("\n");
-    if (b.type === "output")
-        return fence("", raw);
     if (b.type === "table" && b.table)
         return tableToMd(b.table, notes);
     if (b.type === "diagram") {
@@ -153,6 +158,15 @@ function typedToMd(b, notes) {
         }
         return fence(fmt, raw); // mermaid renders on GitHub; others stay as a code block
     }
+    if (b.type === "embed") {
+        // Markdown has no transclusion, and the content lives in another file, so
+        // there is nothing to inline. A link to the target at least keeps the
+        // reference reachable; the unknown-type fallback below would emit an empty
+        // fence, which tells a reader nothing.
+        const target = typeof b.attrs["src"] === "string" ? b.attrs["src"].trim() : "";
+        notes.add("block transclusion projected as a link; the referenced content is not inlined (Markdown has no transclusion)");
+        return target === "" ? "" : `[${target}](${target})`;
+    }
     // Unknown raw type: preserve the body in a fenced block tagged with the type.
     notes.add(`unknown block type \`${b.type}\` emitted as a fenced code block`);
     return fence(b.type, raw);

package/package.json

@@ -1,66 +1,66 @@
-{
-  "name": "@geml/geml",
-  "version": "1.4.6",
-  "mcpName": "io.github.geml-spec/geml",
-  "publishConfig": {
-    "access": "public"
-  },
-  "description": "CLI and parser for GEML, a plain-text document format where every block has an id — so an AI patches one block instead of rewriting the file; edits, reference checks and rollbacks are all per block. Ships an MCP server.",
-  "type": "module",
-  "bin": {
-    "geml": "dist/geml.js"
-  },
-  "main": "dist/geml.js",
-  "types": "dist/geml.d.ts",
-  "files": [
-    "dist",
-    "codemap",
-    "README.md",
-    "LICENSE"
-  ],
-  "engines": {
-    "node": ">=22"
-  },
-  "keywords": [
-    "geml",
-    "general expressive markup language",
-    "mcp",
-    "mcp-server",
-    "markup",
-    "markdown",
-    "parser",
-    "cli",
-    "document",
-    "typed-block",
-    "ai",
-    "agent",
-    "llm",
-    "addressable",
-    "versioning",
-    "docs",
-    "code-graph"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/geml-spec/geml.git",
-    "directory": "geml-parser"
-  },
-  "homepage": "https://github.com/geml-spec/geml#readme",
-  "bugs": {
-    "url": "https://github.com/geml-spec/geml/issues"
-  },
-  "scripts": {
-    "build": "tsc",
-    "test": "tsc && node test/all.mjs",
-    "parse": "node dist/geml.js",
-    "coverage": "tsc && c8 --all --include=dist/**/*.js --include=codemap/**/*.mjs --reporter=text --reporter=text-summary node test/all.mjs",
-    "coverage:check": "tsc && c8 --all --include=dist/**/*.js --include=codemap/**/*.mjs --check-coverage --lines 95 --statements 95 --functions 95 --branches 95 node test/all.mjs",
-    "prepublishOnly": "npm run build"
-  },
-  "license": "MIT",
-  "devDependencies": {
-    "@types/node": "^22.19.21",
-    "c8": "^10.1.3",
-    "typescript": "^5.9.3"
-  }
-}
+{
+  "name": "@geml/geml",
+  "version": "1.5.1",
+  "mcpName": "io.github.geml-spec/geml",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "CLI and parser for GEML, a plain-text document format where every block has an id — so an AI patches one block instead of rewriting the file; edits, reference checks and rollbacks are all per block. Ships an MCP server.",
+  "type": "module",
+  "bin": {
+    "geml": "dist/geml.js"
+  },
+  "main": "dist/geml.js",
+  "types": "dist/geml.d.ts",
+  "files": [
+    "dist",
+    "codemap",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "keywords": [
+    "geml",
+    "general expressive markup language",
+    "mcp",
+    "mcp-server",
+    "markup",
+    "markdown",
+    "parser",
+    "cli",
+    "document",
+    "typed-block",
+    "ai",
+    "agent",
+    "llm",
+    "addressable",
+    "versioning",
+    "docs",
+    "code-graph"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/geml-spec/geml.git",
+    "directory": "geml-parser"
+  },
+  "homepage": "https://github.com/geml-spec/geml#readme",
+  "bugs": {
+    "url": "https://github.com/geml-spec/geml/issues"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "tsc && node test/all.mjs",
+    "parse": "node dist/geml.js",
+    "coverage": "tsc && c8 --all --include=dist/**/*.js --include=codemap/**/*.mjs --reporter=text --reporter=text-summary node test/all.mjs",
+    "coverage:check": "tsc && c8 --all --include=dist/**/*.js --include=codemap/**/*.mjs --check-coverage --lines 95 --statements 95 --functions 95 --branches 95 node test/all.mjs",
+    "prepublishOnly": "npm run build"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^22.19.21",
+    "c8": "^10.1.3",
+    "typescript": "^5.9.3"
+  }
+}