fix: order graph edges by source then target in buffered encoder (SPEC 16.1)

The buffered graph encoder emitted edges in input order; SPEC 16.1 requires
ordering by source ID then target ID. Edges are now sorted by (source ID, target
ID, edge type) before emitting. Decode-invariant (edges are a set) and does not
affect pack_root (which sorts edge records independently), so no content addresses
change. Streaming edges remain in producer-arrival order. Pinned by shared fixture
graph-encode/003.

Author: blackwell-systems

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 ### Fixes
 
+- Buffered graph encoder: order edges by source ID, then target ID, then edge type (SPEC 16.1), instead of emitting them in input order. Decode-invariant (edges are a set) and does not affect `pack_root` (which sorts edge records independently), so no content addresses change. Pinned by shared fixture `graph-encode/003`. Streaming edges remain in producer-arrival order.
 - Decoder: reject an orphan `.field` attachment (a `.field` whose name is neither a `^`-marked column of its row nor a `>`-containing field name, SPEC 7.4.6.1.4) instead of silently absorbing it as an undeclared extra field. Such a stray attachment previously decoded to a record no encoder produces, silently injecting a field onto the last-parsed row (a lossless round-trip hole); now rejected per SPEC 16.5 (`orphan_attachment`).
 - Decoder: reject an orphan positional inline body (a pipe-delimited line with no eligible `^{}` attachment-marker cell) instead of silently dropping it. The object-body parser previously skipped any unrecognized line, so a stray positional body (e.g. a second `Bob|b@t.com` after a row's one inline cell was filled) vanished with no error (silent data loss); now rejected per SPEC 16.5 (`orphan_inline_attachment`).
 - Graph streaming trailer: the edge count is now always the last `counts` entry, even when the stream has no edges (positional `counts=2,1,0`; labeled `counts=…,edges:0`). A zero-edge stream previously dropped it, violating the SPEC §8.4 / §8.4.1 rule that the edge count is always present and last (the invariant that keeps the positional form unambiguous). The graph trailer is decoder-ignored, so this changes producer output only.

src/encode.ts

@@ -81,15 +81,34 @@ export function encode(p: Payload): string {
     }
   }
 
-  // Edges section.
+  // Edges section. Order edges by source ID then target ID (then edge type for
+  // parallel edges) so the wire is canonical regardless of the order edges were
+  // provided (SPEC 16.1). Edge reordering is decode-invariant (edges are a set)
+  // and does not affect pack_root, which sorts edge records independently.
   if (p.edges.length > 0) {
-    lines.push(`## edges [${validEdges}]`);
+    interface ResolvedEdge {
+      srcIdx: number;
+      tgtIdx: number;
+      edgeType: string;
+      status?: string;
+    }
+    const resolved: ResolvedEdge[] = [];
     for (const e of p.edges) {
       const srcIdx = symIndex.get(e.source);
       const tgtIdx = symIndex.get(e.target);
       if (srcIdx === undefined || tgtIdx === undefined) continue;
+      resolved.push({ srcIdx, tgtIdx, edgeType: e.edgeType, status: e.status });
+    }
+    // Stable sort (Array.prototype.sort is stable in modern Node).
+    resolved.sort((a, b) => {
+      if (a.srcIdx !== b.srcIdx) return a.srcIdx - b.srcIdx;
+      if (a.tgtIdx !== b.tgtIdx) return a.tgtIdx - b.tgtIdx;
+      return a.edgeType < b.edgeType ? -1 : a.edgeType > b.edgeType ? 1 : 0;
+    });
 
-      let line = `@${tgtIdx}<@${srcIdx} ${e.edgeType}`;
+    lines.push(`## edges [${validEdges}]`);
+    for (const e of resolved) {
+      let line = `@${e.tgtIdx}<@${e.srcIdx} ${e.edgeType}`;
       if (e.status && e.status !== 'unchanged') {
         line += ` ${e.status}`;
       }