@geml/geml 1.5.0 → 1.5.1

package/dist/geml.js

@@ -154,7 +154,7 @@ function registerId(ctx, id, line) {
     }
 }
 // §5: a list marker — `-`/`*` (unordered) or `N.` (ordered) — capturing the
-// leading indent (in spaces; a tab counts as one) and the item content. Nesting
+// leading indent (in spaces; a tab counts as 4) and the item content. Nesting
 // is decided by that indent.
 const MARKER = /^([ \t]*)(?:[-*]|(\d+)\.)[ \t]+(.*)$/;
 function matchMarker(line) {
@@ -162,7 +162,14 @@ function matchMarker(line) {
     if (!m)
         return null;
     const ordered = m[2] !== undefined;
-    const mk = { indent: m[1].length, ordered, rest: m[3] };
+    let indent = 0;
+    for (const ch of m[1]) {
+        if (ch === '\t')
+            indent += 4;
+        else
+            indent += 1;
+    }
+    const mk = { indent, ordered, rest: m[3] };
     if (ordered)
         mk.start = parseInt(m[2], 10);
     return mk;
@@ -249,7 +256,26 @@ function scanBlocks(lines, base, ctx, depth = 0) {
     const diags = ctx.diags;
     let i = 0;
     while (i < lines.length) {
-        const line = lines[i];
+        let line = lines[i];
+        let consumed = 1;
+        // C-01: Attribute line continuation via `\`.
+        // If a line looks like a fence or heading and ends with `\`, fold subsequent lines.
+        if ((line.startsWith("===") || line.startsWith("#")) && line.endsWith("\\")) {
+            let folded = line.slice(0, -1).trimEnd();
+            while (i + consumed < lines.length) {
+                const next = lines[i + consumed].trim();
+                if (next.endsWith("\\")) {
+                    folded += " " + next.slice(0, -1).trimEnd();
+                    consumed++;
+                }
+                else {
+                    folded += " " + next;
+                    consumed++;
+                    break;
+                }
+            }
+            line = folded;
+        }
         if (line.trim() === "") {
             i++;
             continue;
@@ -259,24 +285,7 @@ function scanBlocks(lines, base, ctx, depth = 0) {
         const hid = /^[ \t]*%%[ \t]?(.*)$/.exec(line);
         if (hid) {
             blocks.push({ kind: "hidden", text: hid[1] });
-            i++;
-            continue;
-        }
-        // §5.2: a Markdown-style footnote definition `[^id]: text` defines the
-        // target a `[^id]` reference points at — recorded as a note block with that
-        // id, so the reference resolves. (A model that reaches for Markdown
-        // footnotes by habit then "just works" instead of leaving a dangling ref.)
-        const fndef = /^\[\^([^\]]+)\]:[ \t]?(.*)$/.exec(line);
-        if (fndef) {
-            const id = fndef[1].trim();
-            const lineNo = base + i + 1;
-            registerId(ctx, id, lineNo);
-            const text = interpolate(fndef[2], lineNo, ctx);
-            blocks.push({
-                kind: "block", type: "note", mode: "flow", id, classes: ["footnote"], attrs: {},
-                children: [{ kind: "paragraph", text, inlines: parseInline(text, lineNo, ctx) }],
-            });
-            i++;
+            i += consumed;
             continue;
         }
         const open = FENCE_OPEN.exec(line);
@@ -292,7 +301,7 @@ function scanBlocks(lines, base, ctx, depth = 0) {
             // safe way to nest (§3).
             const labeled = attrs.id !== undefined ? new RegExp(`^={3,}[ \\t]+#${reLit(attrs.id)}[ \\t]*$`) : null;
             const body = [];
-            let j = i + 1;
+            let j = i + consumed;
             let closed = false;
             for (; j < lines.length; j++) {
                 if (isCloseFence(lines[j], openLen) || (labeled && labeled.test(lines[j]))) {
@@ -310,6 +319,31 @@ function scanBlocks(lines, base, ctx, depth = 0) {
                 diags.push({ severity: "warning", code: "unknown-block-type", message: `unknown block type \`${type}\`; body kept as raw`, line: openLineNo });
                 mode = "raw";
             }
+            else {
+                // `hidden` (§4) and `caption` (§4, and the label an auto-reference takes
+                // per §5.2) are not type-specific: every typed block may carry them. Only
+                // the extras below are per type.
+                let validRe;
+                if (type === "table")
+                    validRe = /^(src|format|header|format-data|compute\d*|summary\d*|span\d*)$/;
+                else if (type === "embed")
+                    validRe = /^(src)$/;
+                else if (type === "diagram")
+                    validRe = /^(src|data|format|type|rows|x|y|size|series)$/;
+                // `src`/`anchor` on a `code` block are the code-graph profile's
+                // (docs/codemap-profile.md): every document `geml codemap build` writes
+                // carries them, so warning on them would warn on our own output.
+                else if (type === "code")
+                    validRe = /^(lang|src|anchor|name|entry-via)$/;
+                else
+                    validRe = /^$/;
+                const universal = /^(hidden|caption)$/;
+                for (const key of Object.keys(attrs.attrs)) {
+                    if (!universal.test(key) && !validRe.test(key)) {
+                        diags.push({ severity: "warning", code: "unknown-attribute", message: `unknown attribute \`${key}\` for block type \`${type}\``, line: openLineNo });
+                    }
+                }
+            }
             const block = {
                 kind: "block", type, mode, classes: attrs.classes, attrs: attrs.attrs,
             };
@@ -382,18 +416,11 @@ function scanBlocks(lines, base, ctx, depth = 0) {
             else {
                 block.raw = body;
                 if (type === "table") {
-                    // `src=` and `data=` are one attribute in two spellings: where this
-                    // table's data comes from. Recorded for the post-scan pass.
                     const srcAttr = typeof attrs.attrs["src"] === "string" ? attrs.attrs["src"].trim() : undefined;
-                    const dataAttr = typeof attrs.attrs["data"] === "string" ? attrs.attrs["data"].trim() : undefined;
-                    if (srcAttr !== undefined && dataAttr !== undefined) {
-                        diags.push({ severity: "error", code: "source-attr-conflict", message: "table has both `src=` and `data=`; they mean the same thing — use one", line: openLineNo });
-                    }
-                    const target = srcAttr ?? dataAttr;
                     // §6: parse the raw body (visual or csv/tsv) into one table model.
-                    const { model, diagnostics } = parseTable(body, target === undefined ? attrs.attrs : { ...attrs.attrs, src: target }, openLineNo, ctx);
-                    if (target !== undefined)
-                        (ctx.tableSources ??= []).push({ block, line: openLineNo, target });
+                    const { model, diagnostics } = parseTable(body, attrs.attrs, openLineNo, ctx);
+                    if (srcAttr !== undefined)
+                        (ctx.tableSources ??= []).push({ block, line: openLineNo, target: srcAttr });
                     block.table = model;
                     for (const d of diagnostics)
                         diags.push({ ...d, line: openLineNo });
@@ -442,9 +469,10 @@ function scanBlocks(lines, base, ctx, depth = 0) {
         if (h) {
             const lineNo = base + i + 1;
             const level = h[1].length;
-            const a = h[3] ? parseAttrs(h[3]) : { classes: [], attrs: {} };
-            const text = interpolate(h[2], lineNo, ctx);
-            const id = a.id ?? slug(text);
+            const rawText = h[2];
+            const a = parseAttrs(h[3] ?? "");
+            const text = interpolate(rawText, lineNo, ctx);
+            const id = a.id ?? slug(rawText);
             registerId(ctx, id, lineNo);
             const block = {
                 kind: "heading", level, text, inlines: parseInline(text, lineNo, ctx), id, classes: a.classes, attrs: a.attrs,
@@ -452,7 +480,7 @@ function scanBlocks(lines, base, ctx, depth = 0) {
             if (a.attrs["hidden"] === true)
                 block.hidden = true;
             blocks.push(block);
-            i++;
+            i += consumed;
             continue;
         }
         if (LIST_ITEM.test(line)) {
@@ -711,7 +739,7 @@ function gatherEmbeds(source) {
     scanBlocks(normalizeSource(source).split("\n"), 0, ctx);
     return (ctx.embeds ?? []).map((e) => (e.anchor === undefined ? { doc: e.doc } : { doc: e.doc, anchor: e.anchor }));
 }
-// One rule for "where this data comes from", shared by a table's `src=`/`data=`
+// One rule for "where this data comes from", shared by a table's `src=`
 // and a chart's `data=`. Three target forms: a data file, `#id` naming a table
 // block in this document, or `doc.geml#id` naming one in another document. An
 // unresolvable target is an error — a table whose source silently produced no
@@ -773,11 +801,10 @@ function resolveTableSources(ctx, opts) {
             err(line, "unresolvable-table-source", `cannot resolve table source \`${target}\``);
             continue;
         }
-        // Reuse the body parser: with `src`/`data` dropped, the file's lines are just
+        // Reuse the body parser: with `src` dropped, the file's lines are just
         // this table's body, so format/header/compute/summary all behave identically.
         const attrs = { ...block.attrs };
         delete attrs["src"];
-        delete attrs["data"];
         const { model, diagnostics } = parseTable(normalizeSource(text).split("\n"), attrs, line, ctx);
         model.src = target;
         block.table = model;
@@ -1004,13 +1031,11 @@ export function parse(source, opts = {}) {
 }
 // The id that a fence/heading line defines, matching how scanBlocks derives it
 // (parseAttrs for the attribute object; heading text slug when no explicit id).
-// The slug MUST come from the INTERPOLATED text — scanBlocks slugs after
-// interpolate(), so `# {{title}} Setup` registers the substituted slug; slugging
-// the raw text here would create a phantom id the parser never registered and
-// make the real one unaddressable. `ctx` is an inert context carrying the
-// document's meta (diagnostics are discarded — spans never report).
+// The slug MUST come from the RAW text, before interpolation, so that changing
+// a meta variable does not silently change the block's addressable id.
+// `ctx` is passed just in case future features need context.
 function idOfHeading(braces, text, line, ctx) {
-    return (braces ? parseAttrs(braces).id : undefined) ?? slug(interpolate(text, line, ctx));
+    return (braces ? parseAttrs(braces).id : undefined) ?? slug(text);
 }
 // The matching close of the fence opened at lines[i] (equal-length run, or the
 // labeled `=== #id` close when the block carries an id): the index just past
@@ -1047,7 +1072,7 @@ function sectionEnd(lines, i, level) {
 }
 // Walk `lines` exactly as scanBlocks does — same fence close rules (equal-length
 // or labeled `=== #id`), same flow-only recursion via REGISTRY — recording the
-// source span of every addressable id (typed block, heading, footnote def).
+// source span of every addressable id (typed block, heading).
 // First definition wins, mirroring ctx.ids (a duplicate id is a build error, so
 // `get`/`set` operate on the one the parser actually registered). `base` is the
 // absolute line offset of this slice within the whole document.
@@ -1115,8 +1140,8 @@ types) {
 export function blockSpans(source) {
     const out = new Map();
     const lines = normalizeSource(source).split("\n");
-    // Inert context: heading auto-ids slug the interpolated text (parser parity);
-    // its diagnostics are discarded — the span scan never reports.
+    // Inert context: heading auto-ids slug the raw text, but parseDoc still
+    // requires a valid context to parse the document.
     const ctx = { diags: [], ids: new Map(), refs: [], meta: collectMeta(lines) };
     collectSpans(lines, 0, out, ctx);
     return out;
@@ -1153,8 +1178,8 @@ function toNewline(text, nl) {
     return nl === "\n" ? lf : lf.replace(/\n/g, nl);
 }
 // `--head`: narrow any id's span to its HEAD line — the single declaring line
-// (a heading's `# … {#id}` line, a typed block's opening fence, a footnote's
-// `[^id]:` line). The head is by construction the FIRST line of the span, so
+// (a heading's `# … {#id}` line, or a typed block's opening fence). The head is
+// by construction the FIRST line of the span, so
 // the narrowing is parse-free and needs no type check. Main use: `set --head`
 // edits a block's attributes (caption/compute/lang/…) without re-sending its
 // body, or renames a heading without rewriting its section.
@@ -1247,54 +1272,54 @@ export const PARSER_VERSION = (() => {
     }
     return "0.0.0";
 })();
-const USAGE = `geml — GEML reference CLI
-
-Usage:
-  geml <file.geml|-> [--to <fmt>] [--from <fmt>] [--root d] [-o out]   transform a document (default: --to json)
-                                             (--root widens cross-doc resolution to dir d, as on check — an
-                                              === embed whose target sits above the file's own directory
-                                              needs it, or it renders unresolved)
-                                             --to  <output>: json | html | md | geml
-                                               --to md    -> Markdown (lossy)
-                                               --to html  -> self-contained HTML
-                                               --to geml  -> canonical re-format
-                                               --to json  -> document-model JSON (default)
-                                             --from <input>: geml | md | json   (overrides extension; html is output-only)
-                                               geml notes.md                -> GEML   (md inferred from extension)
-                                               geml model.json --to geml    -> GEML   (round-trips a prior --to json)
-                                               geml - --from md             read Markdown on stdin
-  geml get    <file.geml|-> [#id] [--json] [--head]   with #id: print that block
-                                             (a heading id = its whole section; --head = head line;
-                                             --json = model node). Without #id: list all addressable
-                                             ids (--json = array).
-  geml set    <file.geml|-> #id [--head|--body] [--in f[#src]|-] [-o f]   replace ONE block by id
-                                             (--in F takes F's block #id, F#src takes #src, else stdin raw;
-                                              default = whole block · --head = head line · --body = body)
-  geml add    <file.geml|-> (--append | --before #id | --after #id) [--in f[#src]|-] [-o f]   insert a fragment
-                                             (1+ blocks and/or prose; content keeps its own ids, a clash is refused)
-  geml delete <file.geml|-> #id [#id2 …] [-o f]   remove one or more blocks
-                                             (a missing id is skipped; a dangling reference is a warning, not a refusal)
-  geml rename <file.geml|-> #old #new [-o f]   rename an id and every reference to it (id-boundary safe)
-  geml revert <file.geml> #id [--rev <sel>] [--head]   undo one block to a past revision (splice / resurrect / remove)
-                                             (sel: 0 | -N | id-prefix | changed; default -1)
-  geml check  <file.geml|-> [--root d] [--json]   validate only: diagnostics + exit code
-                                             (--root widens cross-doc refs to dir d, e.g. the repo root)
-  geml history <commit|verify|show|restore|log> <file.geml> [...]   .gemlhistory version sidecar
-  geml codemap <build|verify|render|serve|refresh|find> [...]       code-graph toolkit (alias: codegraph)
-  geml mcp    --root <dir> [--graph <dir>] [--no-history]   serve documents (and the code graph) over MCP (stdio)
-                                             (10 tools, each geml_ + its CLI verb: list/get/check/history/to +
-                                              set/add/delete/rename/revert; every write is validated before it
-                                              reaches disk. A code graph under --root adds four read-only
-                                              geml_codemap_* tools to the same server)
-  geml --help | --version [--json]
-
-Use '-' as the file to read from stdin.
-Mutations (set/add/delete/rename) write the whole updated document in place for a
-file, or to stdout for '-' input; -o redirects it (-o - = stdout).
-Exit codes:
-  0 ok
-  1 document/operation error
-  2 command usage error.
+const USAGE = `geml — GEML reference CLI
+
+Usage:
+  geml <file.geml|-> [--to <fmt>] [--from <fmt>] [--root d] [-o out]   transform a document (default: --to json)
+                                             (--root widens cross-doc resolution to dir d, as on check — an
+                                              === embed whose target sits above the file's own directory
+                                              needs it, or it renders unresolved)
+                                             --to  <output>: json | html | md | geml
+                                               --to md    -> Markdown (lossy)
+                                               --to html  -> self-contained HTML
+                                               --to geml  -> canonical re-format
+                                               --to json  -> document-model JSON (default)
+                                             --from <input>: geml | md | json   (overrides extension; html is output-only)
+                                               geml notes.md                -> GEML   (md inferred from extension)
+                                               geml model.json --to geml    -> GEML   (round-trips a prior --to json)
+                                               geml - --from md             read Markdown on stdin
+  geml get    <file.geml|-> [#id] [--json] [--head]   with #id: print that block
+                                             (a heading id = its whole section; --head = head line;
+                                             --json = model node). Without #id: list all addressable
+                                             ids (--json = array).
+  geml set    <file.geml|-> #id [--head|--body] [--in f[#src]|-] [-o f]   replace ONE block by id
+                                             (--in F takes F's block #id, F#src takes #src, else stdin raw;
+                                              default = whole block · --head = head line · --body = body)
+  geml add    <file.geml|-> (--append | --before #id | --after #id) [--in f[#src]|-] [-o f]   insert a fragment
+                                             (1+ blocks and/or prose; content keeps its own ids, a clash is refused)
+  geml delete <file.geml|-> #id [#id2 …] [-o f]   remove one or more blocks
+                                             (a missing id is skipped; a dangling reference is a warning, not a refusal)
+  geml rename <file.geml|-> #old #new [-o f]   rename an id and every reference to it (id-boundary safe)
+  geml revert <file.geml> #id [--rev <sel>] [--head]   undo one block to a past revision (splice / resurrect / remove)
+                                             (sel: 0 | -N | id-prefix | changed; default -1)
+  geml check  <file.geml|-> [--root d] [--json]   validate only: diagnostics + exit code
+                                             (--root widens cross-doc refs to dir d, e.g. the repo root)
+  geml history <commit|verify|show|restore|log> <file.geml> [...]   .gemlhistory version sidecar
+  geml codemap <build|verify|render|serve|refresh|find> [...]       code-graph toolkit (alias: codegraph)
+  geml mcp    --root <dir> [--graph <dir>] [--no-history]   serve documents (and the code graph) over MCP (stdio)
+                                             (10 tools, each geml_ + its CLI verb: list/get/check/history/to +
+                                              set/add/delete/rename/revert; every write is validated before it
+                                              reaches disk. A code graph under --root adds four read-only
+                                              geml_codemap_* tools to the same server)
+  geml --help | --version [--json]
+
+Use '-' as the file to read from stdin.
+Mutations (set/add/delete/rename) write the whole updated document in place for a
+file, or to stdout for '-' input; -o redirects it (-o - = stdout).
+Exit codes:
+  0 ok
+  1 document/operation error
+  2 command usage error.
 `;
 // One-line usage for each subcommand — the single source for both the error
 // shown on misuse and the `<cmd> --help` text.
@@ -1307,35 +1332,35 @@ const SUBHELP = {
     check: "usage: geml check <file.geml|-> [--root <dir>] [--json]  (--root: resolve cross-doc refs within <dir> instead of the file's own directory)",
     revert: "usage: geml revert <file.geml> #id [--rev <sel>] [--append|--before #x|--after #x] [--head] [--dry-run] [-o out]  (reconcile #id to a revision: splice / resurrect / remove; sel: 0 | -N | id-prefix | changed; default -1)",
     history: "usage: geml history <commit|verify|show|restore|log> <file.geml> [...]",
-    codemap: `usage: geml codemap build  [--root <repo>]   # auto-detect languages, run the indexer(s), and merge into one codemap (--root defaults to the current directory)
-       geml codemap build  (--db <graph.db> | --adapter joern|scip --raw <in>)+ [--root <repo>] [--out .geml-code-graph] [--container module|dir|file] [--lang <JAVASRC|NEWC|…>] [--joern <path>] [--history [-m msg]]
-       geml codemap verify [dir]                 geml check + profile reference checks
-       geml codemap render [dir]                 every doc -> sibling .html (open index.html from disk)
-       geml codemap serve  [dir] [--port 8140] [--watch] [--background|--stop]   live viewer: pages render from .geml on request; --watch re-runs the recipe when sources change
-       geml codemap refresh [dir] [--force] [--commit] [--background|--hook]   re-run the recorded build recipe (_index/refresh.json); --commit lands it as its own commit
-       geml codemap find <name> [dir]            locate a symbol by substring name -> doc#id + src (stdout, no browser)
+    codemap: `usage: geml codemap build  [--root <repo>]   # auto-detect languages, run the indexer(s), and merge into one codemap (--root defaults to the current directory)
+       geml codemap build  (--db <graph.db> | --adapter joern|scip --raw <in>)+ [--root <repo>] [--out .geml-code-graph] [--container module|dir|file] [--lang <JAVASRC|NEWC|…>] [--joern <path>] [--history [-m msg]]
+       geml codemap verify [dir]                 geml check + profile reference checks
+       geml codemap render [dir]                 every doc -> sibling .html (open index.html from disk)
+       geml codemap serve  [dir] [--port 8140] [--watch] [--background|--stop]   live viewer: pages render from .geml on request; --watch re-runs the recipe when sources change
+       geml codemap refresh [dir] [--force] [--commit] [--background|--hook]   re-run the recorded build recipe (_index/refresh.json); --commit lands it as its own commit
+       geml codemap find <name> [dir]            locate a symbol by substring name -> doc#id + src (stdout, no browser)
        (<dir> for verify/render/serve/refresh/find defaults to ./.geml-code-graph; codegraph and code-graph are accepted as aliases of codemap)`,
-    mcp: `usage: geml mcp --root <dir> [--graph <dir>] [--no-history]
-
-  Serve GEML document CRUD over the MCP stdio transport (JSON-RPC 2.0).
-  Every tool is geml_ + its CLI verb, so the terminal and the assistant share
-  one vocabulary.
-  Ten tools: geml_list · geml_get · geml_check · geml_history · geml_to
-             geml_set · geml_add · geml_delete · geml_rename · geml_revert
-  With a code graph under --root, four more (read-only), so one client entry
-  covers both: geml_codemap_search · geml_codemap_callchain
-               geml_codemap_list · geml_codemap_node
-
-  --root <dir>        REQUIRED. Root holding the .geml documents. Every path a
-                      client names is confined here; a client cannot widen it.
-  --graph <dir>       Code-graph directory, inside --root. Defaults to
-                      <root>/.geml-code-graph when it holds an index.geml; with
-                      no graph the four graph tools are not served at all.
-  --no-history        Skip the .gemlhistory commit taken before each write
-                      (default: commit, so geml_revert always has a revision to
-                      undo to).
-
-  Register with a client:
+    mcp: `usage: geml mcp --root <dir> [--graph <dir>] [--no-history]
+
+  Serve GEML document CRUD over the MCP stdio transport (JSON-RPC 2.0).
+  Every tool is geml_ + its CLI verb, so the terminal and the assistant share
+  one vocabulary.
+  Ten tools: geml_list · geml_get · geml_check · geml_history · geml_to
+             geml_set · geml_add · geml_delete · geml_rename · geml_revert
+  With a code graph under --root, four more (read-only), so one client entry
+  covers both: geml_codemap_search · geml_codemap_callchain
+               geml_codemap_list · geml_codemap_node
+
+  --root <dir>        REQUIRED. Root holding the .geml documents. Every path a
+                      client names is confined here; a client cannot widen it.
+  --graph <dir>       Code-graph directory, inside --root. Defaults to
+                      <root>/.geml-code-graph when it holds an index.geml; with
+                      no graph the four graph tools are not served at all.
+  --no-history        Skip the .gemlhistory commit taken before each write
+                      (default: commit, so geml_revert always has a revision to
+                      undo to).
+
+  Register with a client:
     claude mcp add geml -- geml mcp --root /abs/path/to/repo`,
 };
 // Set from argv at dispatch time; when true, errors are emitted as a JSON
@@ -1794,7 +1819,8 @@ function resolveSelector(source, file, raw) {
 // a heading, its level and text); `--json` is a machine-readable array so an
 // agent can pick its next `get #id` target. Ids are listed in document order
 // (the registration order parse() records), covering the same set `get #id`
-// resolves against: typed blocks, headings, and footnote definitions.
+// resolves against: typed blocks and headings. A `[^id]` reference names one
+// of those (§5.2); the `[^id]: text` definition line was withdrawn.
 function listIds(source, file, json) {
     const doc = parse(source, { resolveDoc: resolverFor(file), self: file === "-" ? undefined : basename(file) });
     const rows = doc.ids.map((id) => {
@@ -1804,8 +1830,10 @@ function listIds(source, file, json) {
             return { id, kind: "heading", level: b.level, text: b.text };
         if (b?.kind === "block") {
             const row = { id, kind: b.type };
+            // `.footnote` is authored, not synthesized (the `[^id]: text` definition
+            // line was withdrawn) — but it still marks a block meant as a footnote.
             if (b.classes.includes("footnote"))
-                row.footnote = true; // §5.2 footnote definition
+                row.footnote = true;
             return row;
         }
         return { id, kind: b?.kind ?? "unknown" };

package/dist/inline.js

@@ -315,8 +315,13 @@ function scanAtoms(s, line, sink, depth = 0) {
 // guesswork. Delimiters pair only *within* one text run: they never reach across
 // a code span, inline math, a link or image (atoms from phase A), or a block
 // boundary. Any delimiter left unpaired is literal text.
-const ASCII_PUNCT = /[!-\/:-@\[-`{-~]/;
-const isPunct = (c) => c !== undefined && ASCII_PUNCT.test(c);
+// Unicode punctuation, not just ASCII (§5.3). With an ASCII-only test, `“` and
+// `，` count as ordinary letters, and a run hugged by CJK punctuation on the
+// outside and ASCII punctuation on the inside stops flanking: `“*(foo)*”` loses
+// its emphasis. CommonMark's rule is Unicode-wide, and the algorithm here is
+// meant to be that rule restricted to `*` and `~~` — not a narrower one.
+const PUNCT = /[\p{P}\p{S}]/u;
+const isPunct = (c) => c !== undefined && PUNCT.test(c);
 const isWS = (c) => c === undefined || /\s/.test(c);
 // Left/right-flanking for a delimiter run, given the chars on either side.
 function flank(before, after) {

package/dist/mcp.js

@@ -619,25 +619,25 @@ export function handleLine(line, write = (s) => process.stdout.write(s)) {
 // ---------------------------------------------------------------------------
 // Entry
 // ---------------------------------------------------------------------------
-export const MCP_USAGE = `usage: geml mcp --root <dir> [--graph <dir>] [--no-history]
-
-  Serve GEML document CRUD over the MCP stdio transport (JSON-RPC 2.0), plus the
-  read-only code-graph tools when the root holds a code graph.
-
-  --root <dir>        REQUIRED. Root directory holding the .geml documents.
-                      Relative paths resolve against the server process's CWD,
-                      which the CLIENT chooses — pass an absolute path.
-                      Every path a client names is confined to this directory;
-                      a client cannot widen or override it.
-  --graph <dir>       Code-graph directory, inside --root. Defaults to
-                      <root>/.geml-code-graph when that holds an index.geml.
-                      With no graph, the code-graph tools are not served
-                      at all (a client sees only the document tools).
-  --no-history        Do not auto-commit a .gemlhistory revision before each
-                      write. Default is to commit, so geml_revert always
-                      has a revision to undo to.
-
-  Register with a client:
+export const MCP_USAGE = `usage: geml mcp --root <dir> [--graph <dir>] [--no-history]
+
+  Serve GEML document CRUD over the MCP stdio transport (JSON-RPC 2.0), plus the
+  read-only code-graph tools when the root holds a code graph.
+
+  --root <dir>        REQUIRED. Root directory holding the .geml documents.
+                      Relative paths resolve against the server process's CWD,
+                      which the CLIENT chooses — pass an absolute path.
+                      Every path a client names is confined to this directory;
+                      a client cannot widen or override it.
+  --graph <dir>       Code-graph directory, inside --root. Defaults to
+                      <root>/.geml-code-graph when that holds an index.geml.
+                      With no graph, the code-graph tools are not served
+                      at all (a client sees only the document tools).
+  --no-history        Do not auto-commit a .gemlhistory revision before each
+                      write. Default is to commit, so geml_revert always
+                      has a revision to undo to.
+
+  Register with a client:
     claude mcp add geml -- geml mcp --root /abs/path/to/repo`;
 export function parseArgs(args) {
     let root;

package/dist/render-html.js

@@ -36,43 +36,43 @@ function page(title, body, ctx, source) {
         ? `<script type="importmap">{"imports":{"node:fs":"${lg}_node-stub.js","node:path":"${lg}_node-stub.js","node:crypto":"${lg}_node-stub.js","node:url":"${lg}_node-stub.js","node:child_process":"${lg}_node-stub.js"}}</script>\n`
         : "";
     const liveJs = wantLive
-        ? `<script type="module">
-globalThis.process ??= { argv: [], env: {} };
-const { parse } = await import("${lg}geml.js");
-const { codeGraphWaves } = await import("${lg}render.js");
-const w = codeGraphWaves(async (rel) => {
-  try { const r = await fetch(rel, { cache: "no-cache" }); return r.ok ? await r.text() : null; } catch { return null; }
-}, parse);
-for (const m of document.querySelectorAll(".cg-mount[data-start]")) {
-  const start = m.getAttribute("data-start");
-  m._cgView = async (view) => {
-    // A directed view builds from the node's OWN document (its meta names the
-    // module and graph-depth); {doc} opens that document; else the mount's.
-    const src = view && view.doc ? view.doc
-      : view && view.node ? view.node.slice(0, view.node.lastIndexOf("#"))
-      : start;
-    const r = await w.build(src, view && view.doc ? undefined : view);
-    return r.error !== undefined ? null : r.data;
-  };
-}
+        ? `<script type="module">
+globalThis.process ??= { argv: [], env: {} };
+const { parse } = await import("${lg}geml.js");
+const { codeGraphWaves } = await import("${lg}render.js");
+const w = codeGraphWaves(async (rel) => {
+  try { const r = await fetch(rel, { cache: "no-cache" }); return r.ok ? await r.text() : null; } catch { return null; }
+}, parse);
+for (const m of document.querySelectorAll(".cg-mount[data-start]")) {
+  const start = m.getAttribute("data-start");
+  m._cgView = async (view) => {
+    // A directed view builds from the node's OWN document (its meta names the
+    // module and graph-depth); {doc} opens that document; else the mount's.
+    const src = view && view.doc ? view.doc
+      : view && view.node ? view.node.slice(0, view.node.lastIndexOf("#"))
+      : start;
+    const r = await w.build(src, view && view.doc ? undefined : view);
+    return r.error !== undefined ? null : r.data;
+  };
+}
 </script>\n`
         : "";
-    return `<!doctype html>
-<html lang="en">
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1">
-<title>${esc(title)}</title>
-<style>${CSS}</style>
-${importMap}${mathHead}${mermaidHead}</head>
-<body>
-<main>
-${body}
-</main>
-${footer}
-<script>${JS}</script>
-${ctx.usedCodeGraph ? `<script>${CODE_GRAPH_JS}</script>\n` : ""}${liveJs}</body>
-</html>
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${esc(title)}</title>
+<style>${CSS}</style>
+${importMap}${mathHead}${mermaidHead}</head>
+<body>
+<main>
+${body}
+</main>
+${footer}
+<script>${JS}</script>
+${ctx.usedCodeGraph ? `<script>${CODE_GRAPH_JS}</script>\n` : ""}${liveJs}</body>
+</html>
 `;
 }
 export function renderHtml(doc, opts = {}) {