@geml/geml 1.0.0 → 1.1.1

package/dist/history.d.ts

@@ -15,6 +15,7 @@ interface Revision {
     author?: string;
     summary?: string;
     hash: string;
+    newline?: string;
     ops: Op[];
 }
 interface History {
@@ -52,4 +53,33 @@ export interface RestoreOpts {
     force?: boolean;
 }
 export declare function restore(o: RestoreOpts): string;
+export interface RevisionInfo {
+    id: string;
+    parent?: string;
+    author?: string;
+    summary?: string;
+    hash: string;
+    offset: number;
+    current: boolean;
+}
+/** Is the working file byte-identical to the sidecar's tip revision? False
+ *  means uncommitted drift (e.g. an earlier commit attempt was refused). */
+export declare function isCurrent(historyPath: string, gemlPath: string): boolean;
+/** Revisions newest-first, each tagged with the `-N` offset that selects it. */
+export declare function listRevisions(historyPath: string): RevisionInfo[];
+/** Resolve a revision selector to its id + reconstructed full text. Selectors:
+ *  `-N` (N revisions back from current; `-0` is the tip), `latest`/`current`, or
+ *  an unambiguous id prefix/suffix (the same forms `restore` accepts). */
+export declare function resolveContent(historyPath: string, selector: string): {
+    id: string;
+    text: string;
+};
+/** Walk the chain newest→oldest; return the first revision whose block (as
+ *  extracted by `pick`) differs from `currentBlock` — i.e. the block's previous
+ *  *distinct* version, skipping revisions that never touched it. Used by
+ *  `revert --changed`. `undefined` if no earlier revision changed the block. */
+export declare function firstChangedContent(historyPath: string, currentBlock: string, pick: (fullText: string) => string | undefined): {
+    id: string;
+    text: string;
+} | undefined;
 export {};

package/dist/history.js

@@ -80,9 +80,12 @@ function fenceFor(contentLf) {
 // ---------------------------------------------------------------------------
 // Document units & reverse-patch engine (gap-aware)
 // ---------------------------------------------------------------------------
-// Unit-key = `#id` (explicit), or `@<8hex content hash>` (derived) with `~n`
-// disambiguating equal-content units by document-order occurrence (§4).
-const KEY = String.raw `(#[A-Za-z][A-Za-z0-9_-]*|@[0-9a-f]+(?:~\d+)?)`;
+// Unit-key = `#id` (explicit), or `@<8hex content hash>` (derived), with `~n`
+// disambiguating equal keys by document-order occurrence (§4). `~n` on an #id
+// key only arises for OUT-OF-SPEC documents that repeat an id — without it the
+// key is ambiguous, reverse-patch ops hit the wrong occurrence, and commit()'s
+// round-trip gate (correctly) aborts. Well-formed documents never emit it.
+const KEY = String.raw `(#[A-Za-z][A-Za-z0-9_-]*(?:~\d+)?|@[0-9a-f]+(?:~\d+)?)`;
 function sha8(s) {
     return createHash("sha256").update(Buffer.from(s, "utf8")).digest("hex").slice(0, 8);
 }
@@ -127,9 +130,11 @@ function tile(lines) {
 function keyedUnits(lines) {
     const counts = new Map();
     return tile(lines).map((u) => {
-        if (u.id)
-            return { u, key: `#${u.id}` };
-        const base = `@${sha8(lines.slice(u.start, u.bodyEnd).join("\n"))}`;
+        // Both key kinds get the ~n occurrence suffix: content keys collide by
+        // nature (equal blank runs, repeated paragraphs); #id keys only collide in
+        // out-of-spec documents that repeat an id — but those exist in the wild,
+        // and an ambiguous key sends reverse-patch ops to the wrong occurrence.
+        const base = u.id ? `#${u.id}` : `@${sha8(lines.slice(u.start, u.bodyEnd).join("\n"))}`;
         const n = counts.get(base) ?? 0;
         counts.set(base, n + 1);
         return { u, key: n === 0 ? base : `${base}~${n}` };
@@ -221,14 +226,59 @@ function applyReverse(textLf, ops, blobs) {
     }
     return lines.join("\n");
 }
-/** LCS alignment of unit-key sequences; aMatch[i] = matched index in b, or -1. */
+/** LCS alignment of unit-key sequences; aMatch[i] = matched index in b, or -1.
+ *
+ * Fast path: content-keyed units (`@hash~n`) are unique by construction, and in
+ * a well-formed document `#id` keys are unique too — and the LCS of two
+ * all-unique sequences is exactly the longest increasing subsequence of a's
+ * keys mapped to b's positions: O(n log n) instead of the O(n·m) DP table.
+ * That difference is GEP-0002's measured bottleneck (seconds at 10⁴ units,
+ * minutes at 10⁵ — code-graph documents live there).
+ *
+ * A document with DUPLICATE `#id`s (a GEML error, but history never parses) can
+ * break uniqueness, so the DP remains as the fallback for that case. Either
+ * path yields *a* maximal alignment; commit()'s byte-exact round-trip gate
+ * rejects any diff that fails to reproduce the parent, whichever path ran. */
 function lcsMatch(a, b) {
     const n = a.length, m = b.length;
+    const aMatch = new Array(n).fill(-1);
+    if (new Set(a).size === n && new Set(b).size === m) {
+        const posInB = new Map();
+        for (let j = 0; j < m; j++)
+            posInB.set(b[j], j);
+        const ai = [], bj = []; // a-index / b-position of common keys, in a-order
+        for (let i = 0; i < n; i++) {
+            const j = posInB.get(a[i]);
+            if (j !== undefined) {
+                ai.push(i);
+                bj.push(j);
+            }
+        }
+        // Patience LIS over bj (strictly increasing) with predecessor links.
+        const tails = []; // index into bj of the smallest tail per LIS length
+        const prev = new Array(bj.length).fill(-1);
+        for (let x = 0; x < bj.length; x++) {
+            let lo = 0, hi = tails.length;
+            while (lo < hi) {
+                const mid = (lo + hi) >> 1;
+                if (bj[tails[mid]] < bj[x])
+                    lo = mid + 1;
+                else
+                    hi = mid;
+            }
+            prev[x] = lo > 0 ? tails[lo - 1] : -1;
+            tails[lo] = x;
+        }
+        for (let cur = tails.length ? tails[tails.length - 1] : -1; cur >= 0; cur = prev[cur]) {
+            aMatch[ai[cur]] = bj[cur];
+        }
+        return aMatch;
+    }
+    // Fallback (duplicate keys): classic DP.
     const dp = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
     for (let i = n - 1; i >= 0; i--)
         for (let j = m - 1; j >= 0; j--)
             dp[i][j] = a[i] === b[j] ? dp[i + 1][j + 1] + 1 : Math.max(dp[i + 1][j], dp[i][j + 1]);
-    const aMatch = new Array(n).fill(-1);
     let i = 0, j = 0;
     while (i < n && j < m) {
         if (a[i] === b[j]) {
@@ -289,6 +339,22 @@ function opLine(op) {
         return `insert <- blob:${op.blob} ${anchorStr(op.anchor)}`;
     return `move ${op.key} ${anchorStr(op.anchor)}`;
 }
+// §8 hashes are over "the exact UTF-8 bytes of that version" — which includes
+// its newline style. The sidecar's file-level nl is a SINGLE value that later
+// commits overwrite, so a document whose line endings flipped (LF↔CRLF is
+// routine on Windows) would leave older revisions' recorded hashes
+// unreproducible. Each revision therefore records its own `newline`; for
+// legacy revisions that never recorded one, accept either byte encoding of
+// the reconstructed text — both still pin the CONTENT exactly.
+const nlNamed = (nl) => (nl === "\r\n" ? "crlf" : "lf");
+const nlOf = (name) => name === "crlf" ? "\r\n" : name === "lf" ? "\n" : undefined;
+function hashMatchesRecorded(lf, r, fileNl) {
+    const own = nlOf(r.newline);
+    if (own)
+        return fullHash(lf, own) === r.hash;
+    return fullHash(lf, fileNl) === r.hash
+        || fullHash(lf, fileNl === "\r\n" ? "\n" : "\r\n") === r.hash;
+}
 function parseHistory(path) {
     const { lf, nl } = loadBytes(path);
     const lines = lf.split("\n");
@@ -315,6 +381,7 @@ function parseHistory(path) {
                 author: attr(b.attrLine, "author"),
                 summary: attr(b.attrLine, "summary"),
                 hash: attr(b.attrLine, "hash") ?? "",
+                newline: attr(b.attrLine, "newline"),
                 ops: parseOps(body),
             });
         }
@@ -386,6 +453,7 @@ function renderHistory(h, baseName) {
             r.author ? `author="${r.author}"` : "",
             r.summary ? `summary="${r.summary}"` : "",
             `hash="${r.hash}"`,
+            r.newline ? `newline="${r.newline}"` : "",
         ].filter(Boolean).join(" ");
         parts.push(`=== revision {${at}}\n${r.ops.map(opLine).join("\n")}${r.ops.length ? "\n" : ""}===\n`);
         // blobs referenced by this revision
@@ -417,9 +485,23 @@ export function commit(o) {
         if (bytesOf(back, nl).compare(bytesOf(prevContent, nl)) !== 0) {
             throw new Error("history: reverse patch does NOT round-trip to the previous revision; aborting commit");
         }
+        // Blob ids are minted per-diff (b1, b2, …). Renumber this commit's blobs to
+        // start past the highest id already stored, so a later commit never reuses
+        // an earlier revision's blob id — an overwrite in the shared store silently
+        // corrupts reconstruction of older revisions, whose `replace … <- blob:bN`
+        // would then resolve to the wrong (newer) content.
+        let maxBlob = 0;
+        for (const k of h.blobs.keys()) {
+            const mm = /^b(\d+)$/.exec(k);
+            if (mm)
+                maxBlob = Math.max(maxBlob, Number(mm[1]));
+        }
+        const remap = new Map(patch.blobs.map((b, i) => [b.id, `b${maxBlob + i + 1}`]));
+        patch.ops = patch.ops.map((op) => (op.blob ? { ...op, blob: remap.get(op.blob) } : op));
+        patch.blobs = patch.blobs.map((b) => ({ id: remap.get(b.id), payload: b.payload }));
         for (const b of patch.blobs)
             h.blobs.set(b.id, b.payload);
-        h.revisions.set(id, { id, parent: prevId, author: o.author, summary: o.summary, hash, ops: patch.ops });
+        h.revisions.set(id, { id, parent: prevId, author: o.author, summary: o.summary, hash, newline: nlNamed(nl), ops: patch.ops });
         h.keyframes.delete(prevId); // demote previous tip mirror (keyframes at intervals only)
         h.keyframes.set(id, working);
         h.current = id;
@@ -428,7 +510,7 @@ export function commit(o) {
         h = {
             nl, current: id,
             keyframes: new Map([[id, working]]),
-            revisions: new Map([[id, { id, author: o.author, summary: o.summary, hash, ops: [] }]]),
+            revisions: new Map([[id, { id, author: o.author, summary: o.summary, hash, newline: nlNamed(nl), ops: [] }]]),
             blobs: new Map(),
         };
     }
@@ -450,9 +532,9 @@ export function verify(historyPath, gemlPath) {
     for (const r of chain) {
         try {
             const content = reconstruct(h, r.id);
-            const got = fullHash(content, h.nl);
-            if (got !== r.hash)
-                errors.push(`revision ${r.id}: reconstructed hash ${got} != recorded ${r.hash}`);
+            if (!hashMatchesRecorded(content, r, h.nl)) {
+                errors.push(`revision ${r.id}: reconstructed hash ${fullHash(content, nlOf(r.newline) ?? h.nl)} != recorded ${r.hash}`);
+            }
             checked++;
         }
         catch (e) {
@@ -505,3 +587,61 @@ export function restore(o) {
     }
     return content;
 }
+/** Is the working file byte-identical to the sidecar's tip revision? False
+ *  means uncommitted drift (e.g. an earlier commit attempt was refused). */
+export function isCurrent(historyPath, gemlPath) {
+    const h = parseHistory(historyPath);
+    const tip = h.revisions.get(h.current);
+    if (!tip)
+        return false;
+    const { lf, nl } = loadBytes(gemlPath);
+    return fullHash(lf, nl) === tip.hash;
+}
+/** Revisions newest-first, each tagged with the `-N` offset that selects it. */
+export function listRevisions(historyPath) {
+    const h = parseHistory(historyPath);
+    return chainFrom(h).map((r, i) => ({
+        id: r.id, parent: r.parent, author: r.author, summary: r.summary, hash: r.hash,
+        offset: i, current: i === 0,
+    }));
+}
+/** Resolve a revision selector to its id + reconstructed full text. Selectors:
+ *  `-N` (N revisions back from current; `-0` is the tip), `latest`/`current`, or
+ *  an unambiguous id prefix/suffix (the same forms `restore` accepts). */
+export function resolveContent(historyPath, selector) {
+    const h = parseHistory(historyPath);
+    const chain = chainFrom(h); // chain[0] = current tip
+    let id;
+    const off = /^-(\d+)$/.exec(selector);
+    if (off) {
+        const n = Number(off[1]);
+        if (n >= chain.length)
+            throw new Error(`history: offset -${n} is out of range (only ${chain.length} revision(s))`);
+        id = chain[n].id;
+    }
+    else if (selector === "latest" || selector === "current") {
+        id = chain[0].id;
+    }
+    else {
+        const ids = [...h.revisions.keys()];
+        const matches = ids.filter((x) => x === selector || x.startsWith(selector) || x.endsWith(selector));
+        if (matches.length !== 1)
+            throw new Error(`history: revision selector "${selector}" matched ${matches.length} revisions`);
+        id = matches[0];
+    }
+    return { id, text: reconstruct(h, id) };
+}
+/** Walk the chain newest→oldest; return the first revision whose block (as
+ *  extracted by `pick`) differs from `currentBlock` — i.e. the block's previous
+ *  *distinct* version, skipping revisions that never touched it. Used by
+ *  `revert --changed`. `undefined` if no earlier revision changed the block. */
+export function firstChangedContent(historyPath, currentBlock, pick) {
+    const h = parseHistory(historyPath);
+    for (const r of chainFrom(h)) {
+        const text = reconstruct(h, r.id);
+        const b = pick(text);
+        if (b !== undefined && b !== currentBlock)
+            return { id: r.id, text };
+    }
+    return undefined;
+}

package/dist/render.d.ts

@@ -2,5 +2,64 @@ import { type Document } from "./geml.js";
 export interface RenderOptions {
     title?: string;
     source?: string;
+    loadDoc?: (relPath: string) => string | null;
+    parseDoc?: (source: string) => Document;
+    tableRows?: number;
+    liveGraph?: string;
+    graphSidecar?: string;
 }
+interface CGNode {
+    n: string;
+    doc?: string;
+    src?: string;
+    leaf?: boolean | number;
+    test?: boolean;
+    acc?: boolean;
+    more?: boolean;
+    grp?: string[];
+    ext?: number;
+}
+interface CGData {
+    start: string;
+    depth: number;
+    roots: string[];
+    nodes: Record<string, CGNode>;
+    edges: [string, string, string, string][];
+    mode?: "modules";
+    module?: string;
+    dir?: "up";
+    focus?: string;
+    partial?: number;
+    mods?: {
+        p: string;
+        doc: string;
+        m?: number;
+    }[];
+    medges?: [string, string, number][];
+    entryDocs?: string[];
+    gpath?: string[];
+}
+declare function buildCodeGraph(startRel: string, opts: RenderOptions, view?: {
+    dir?: "up" | "down";
+    node?: string;
+}): {
+    data?: CGData;
+    error?: string;
+    truncated?: boolean;
+};
+export declare function codeGraphRuntime(root: {
+    querySelectorAll(sel: string): ArrayLike<Element>;
+}): void;
+export declare function codeGraphWaves(fetchDoc: (rel: string) => Promise<string | null>, parseFn: (s: string) => Document): {
+    build: (src: string, view?: {
+        dir?: "up" | "down";
+        node?: string;
+    }) => Promise<{
+        data?: CGData;
+        error?: string;
+        truncated?: boolean;
+    }>;
+    seed: (name: string, text: string | null) => void;
+};
+export { buildCodeGraph };
 export declare function renderHtml(doc: Document, opts?: RenderOptions): string;