@geml/geml 1.1.1 → 1.4.2

package/dist/serialize.js

@@ -9,7 +9,7 @@
 //     parse(serialize(parse(src)))  ≅  parse(src)
 //
 // verified over the conformance corpus by test/roundtrip.test.mjs.
-import { parseInline } from "./inline.js";
+import { META_REF_SRC, parseInline } from "./inline.js";
 // ---------------------------------------------------------------------------
 // Values & attributes (§4)
 // ---------------------------------------------------------------------------
@@ -61,6 +61,26 @@ function serDataValue(v) {
 function escText(s) {
     return s.replace(/[\\`*~$\[\]]/g, (c) => "\\" + c);
 }
+// A literal `{{name}}` in a text run would be re-read as a §4 metadata
+// reference by the next document-level parse — a layer serInlines's
+// parseInline check cannot see — so it is escaped unconditionally, in both the
+// lazy and the escalated pass. Applied after escText, which would otherwise
+// escape the inserted backslash itself.
+//
+// The inserted escape must survive interpolate()'s left-to-right `\x`
+// pairing: when the emitted text directly before the reference ends in an ODD
+// run of backslashes, a single inserted `\` would itself be consumed as that
+// run's escapee, re-exposing `{{` — so double it (`\\{`), which pairs as
+// escaped-backslash + escaped-brace and parses back to the same model text.
+const META_REF_G = new RegExp(META_REF_SRC, "g");
+function escMetaRef(s) {
+    return s.replace(META_REF_G, (m, _key, offset) => {
+        let bs = 0;
+        for (let k = offset - 1; k >= 0 && s[k] === "\\"; k--)
+            bs++;
+        return (bs % 2 === 1 ? "\\\\{" : "\\{") + m.slice(1);
+    });
+}
 function longestRun(s, ch) {
     let max = 0;
     let run = 0;
@@ -91,7 +111,7 @@ function linkDest(n) {
 // when the verbatim form does not round-trip.
 function serInline(n, esc) {
     switch (n.type) {
-        case "text": return esc ? escText(n.value) : n.value;
+        case "text": return escMetaRef(esc ? escText(n.value) : n.value);
         case "emph": return `*${serSeq(n.children, esc)}*`;
         case "strong": return `**${serSeq(n.children, esc)}**`;
         case "strike": return `~~${serSeq(n.children, esc)}~~`;

package/dist/table.js

@@ -312,10 +312,7 @@ export function parseTable(body, attrs, line, sink) {
         const ci = colIndex(name);
         return ci < 0 ? null : cellNum(ci, row);
     };
-    const aggResolve = (fn, name) => {
-        const ci = colIndex(name);
-        if (ci < 0)
-            return null;
+    const computeAgg = (fn, ci) => {
         const vals = [];
         for (let r = 0; r < model.rows.length; r++) {
             const v = cellNum(ci, r);
@@ -336,6 +333,30 @@ export function parseTable(body, attrs, line, sink) {
             return Math.max(...vals);
         return null;
     };
+    // A given aggregate over a given column is constant across rows, yet the
+    // per-row `evalExpr` below used to recompute it with a full-table scan every
+    // time — O(R²·M) for a table with R rows and M aggregate uses, so a 5000-row
+    // ×100-`sum()` sheet took ~a minute. Memoize each `(fn, column)` result once
+    // per formula (`aggReset` clears it). The ONE column whose values genuinely
+    // change mid-loop is the column the current formula is writing (`aggBypassCi`)
+    // — an aggregate over it is row-dependent, so that one is never cached, which
+    // preserves the exact behaviour of in-place / self-referential formulas.
+    let aggCache = new Map();
+    let aggBypassCi = -1;
+    const aggReset = (bypassCi) => { aggCache = new Map(); aggBypassCi = bypassCi; };
+    const aggResolve = (fn, name) => {
+        const ci = colIndex(name);
+        if (ci < 0)
+            return null;
+        if (ci === aggBypassCi)
+            return computeAgg(fn, ci);
+        const key = `${fn}:${ci}`;
+        if (aggCache.has(key))
+            return aggCache.get(key);
+        const val = computeAgg(fn, ci);
+        aggCache.set(key, val);
+        return val;
+    };
     // `compute="Name = expr; Name2 = expr2"` — `;`-separated; may also appear as
     // compute, compute2, … Each formula adds/overwrites a per-row column.
     const formulas = Object.entries(attrs)
@@ -367,6 +388,9 @@ export function parseTable(body, attrs, line, sink) {
             columns.push(name);
             ci = columns.length - 1;
         }
+        // Fresh aggregate cache per formula; the target column is being written
+        // row-by-row so aggregates over it stay uncached.
+        aggReset(ci);
         let failed = false;
         for (let r = 0; r < model.rows.length && !failed; r++) {
             try {
@@ -399,6 +423,9 @@ export function parseTable(body, attrs, line, sink) {
         const summary = columns.map(() => ({ text: "", inlines: [] }));
         // In the summary row a bare column has no value: only aggregates resolve.
         const noRow = () => null;
+        // No column is mutated while building the summary row, so every aggregate is
+        // cacheable against the final table state (no bypass column).
+        aggReset(-1);
         for (const s of summaryDecls) {
             const eq = s.indexOf("=");
             if (eq <= 0) {
@@ -458,7 +485,15 @@ export function parseTable(body, attrs, line, sink) {
             diagnostics.push({ severity: "warning", message: `span \`${sd}\` targets a cell outside the table` });
             continue;
         }
-        cell.span = { rows: sp.rows, cols: sp.cols };
+        // 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 };
 }

package/dist/to-md.js

@@ -127,6 +127,10 @@ function typedToMd(b, notes) {
             return `[^${b.id}]: ${text}`;
         }
         const inner = (b.children ?? []).map((c) => block(c, notes)).filter(Boolean).join("\n\n");
+        // `text` is an addressable prose container, not a callout: its children
+        // project as plain paragraphs. Only `note` carries blockquote semantics.
+        if (b.type === "text")
+            return inner;
         return inner.split("\n").map((l) => (l ? `> ${l}` : ">")).join("\n");
     }
     // raw modes

package/package.json

@@ -1,58 +1,62 @@
-{
-  "name": "@geml/geml",
-  "version": "1.1.1",
-  "publishConfig": {
-    "access": "public"
-  },
-  "description": "Reference parser, validator, renderer and CLI for GEML (General Expressive Markup Language) — a plain-text document format that stays legible to people and reliable for machines.",
-  "type": "module",
-  "bin": {
-    "geml": "dist/geml.js"
-  },
-  "main": "dist/geml.js",
-  "types": "dist/geml.d.ts",
-  "files": [
-    "dist",
-    "codemap",
-    "README.md",
-    "LICENSE"
-  ],
-  "engines": {
-    "node": ">=18"
-  },
-  "keywords": [
-    "geml",
-    "markup",
-    "markdown",
-    "parser",
-    "cli",
-    "document",
-    "typed-block",
-    "ai",
-    "agent"
-  ],
-  "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/m2.test.mjs && node test/m3.test.mjs && node test/m4.test.mjs && node test/convert.test.mjs && node test/fixtures.test.mjs && node test/features.test.mjs && node test/render.test.mjs && node test/conformance.test.mjs && node test/second-impl.test.mjs && node test/roundtrip.test.mjs && node test/to-md.test.mjs && node test/history.test.mjs && node test/render-html.test.mjs && node test/codemap.test.mjs && node test/cli.test.mjs && node test/get-set.test.mjs && node test/revert.test.mjs",
-    "convert": "node dist/geml.js convert",
-    "parse": "node dist/geml.js",
-    "coverage": "c8 --all --include=dist/**/*.js --reporter=text --reporter=text-summary npm test",
-    "coverage:check": "c8 --all --include=dist/**/*.js --check-coverage --lines 90 --statements 90 --functions 92 --branches 80 npm test",
-    "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.4.2",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "GEML(General Expressive Markup Language) — one format, two readers. People and AI agents co-write the same document: plain text that stays legible for people, and addressable, verifiable, and versioned for machines. Reference parser, validator, renderer & CLI for GEML.",
+  "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",
+    "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"
+  }
+}