@blackwell-systems/gcf 2.1.0 → 2.1.1

package/dist/cjs/index.cjs

@@ -0,0 +1,1841 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  GenericStreamEncoder: () => GenericStreamEncoder,
+  KIND_ABBREV: () => KIND_ABBREV,
+  KIND_EXPAND: () => KIND_EXPAND,
+  Session: () => Session,
+  StreamEncoder: () => StreamEncoder,
+  decode: () => decode,
+  decodeGeneric: () => decodeGeneric,
+  encode: () => encode,
+  encodeDelta: () => encodeDelta,
+  encodeGeneric: () => encodeGeneric,
+  encodeWithSession: () => encodeWithSession,
+  formatKey: () => formatKey,
+  formatScalar: () => formatScalar,
+  needsQuote: () => needsQuote,
+  parseScalar: () => parseScalar,
+  quoteString: () => quoteString,
+  verifyDelta: () => verifyDelta
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/constants.ts
+var KIND_ABBREV = {
+  function: "fn",
+  type: "type",
+  method: "method",
+  interface: "iface",
+  var: "var",
+  const: "const",
+  resource: "resource",
+  table: "table",
+  class: "class",
+  selector: "selector",
+  field: "field",
+  route_handler: "route",
+  external: "ext",
+  file: "file",
+  package: "pkg",
+  service: "svc"
+};
+var KIND_EXPAND = {
+  fn: "function",
+  type: "type",
+  method: "method",
+  iface: "interface",
+  var: "var",
+  const: "const",
+  resource: "resource",
+  table: "table",
+  class: "class",
+  selector: "selector",
+  field: "field",
+  route: "route_handler",
+  ext: "external",
+  file: "file",
+  pkg: "package",
+  svc: "service"
+};
+
+// src/encode.ts
+function groupByDistance(symbols) {
+  if (symbols.length === 0) return [];
+  const sorted = [...symbols].sort((a, b) => {
+    if (a.distance !== b.distance) return a.distance - b.distance;
+    return b.score - a.score;
+  });
+  const groups = [];
+  let current = null;
+  for (const s of sorted) {
+    if (current === null || current.distance !== s.distance) {
+      current = { distance: s.distance, symbols: [] };
+      groups.push(current);
+    }
+    current.symbols.push(s);
+  }
+  return groups;
+}
+function encode(p) {
+  const lines = [];
+  const groups = groupByDistance(p.symbols);
+  const symIndex = /* @__PURE__ */ new Map();
+  let nextID = 0;
+  for (const g of groups) {
+    for (const s of g.symbols) {
+      symIndex.set(s.qualifiedName, nextID++);
+    }
+  }
+  const validEdges = p.edges.filter(
+    (e) => symIndex.has(e.source) && symIndex.has(e.target)
+  ).length;
+  let header = `GCF profile=graph tool=${p.tool}`;
+  if (p.tokenBudget) header += ` budget=${p.tokenBudget}`;
+  if (p.tokensUsed) header += ` tokens=${p.tokensUsed}`;
+  header += ` symbols=${p.symbols.length}`;
+  if (validEdges > 0) header += ` edges=${validEdges}`;
+  if (p.packRoot) {
+    header += ` pack_root=${p.packRoot}`;
+  }
+  lines.push(header);
+  const groupNames = ["targets", "related", "extended"];
+  for (const g of groups) {
+    if (g.symbols.length === 0) continue;
+    let name;
+    if (g.distance < groupNames.length) {
+      name = groupNames[g.distance];
+    } else {
+      name = `distance_${g.distance}`;
+    }
+    lines.push(`## ${name}`);
+    for (const s of g.symbols) {
+      const idx = symIndex.get(s.qualifiedName);
+      const kind = KIND_ABBREV[s.kind] || s.kind;
+      lines.push(`@${idx} ${kind} ${s.qualifiedName} ${s.score.toFixed(2)} ${s.provenance}`);
+    }
+  }
+  if (p.edges.length > 0) {
+    lines.push(`## edges [${validEdges}]`);
+    for (const e of p.edges) {
+      const srcIdx = symIndex.get(e.source);
+      const tgtIdx = symIndex.get(e.target);
+      if (srcIdx === void 0 || tgtIdx === void 0) continue;
+      let line = `@${tgtIdx}<@${srcIdx} ${e.edgeType}`;
+      if (e.status && e.status !== "unchanged") {
+        line += ` ${e.status}`;
+      }
+      lines.push(line);
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+
+// src/decode.ts
+function decode(input) {
+  const lines = input.split("\n");
+  if (lines.length === 0) {
+    throw new Error("gcf: empty input");
+  }
+  const header = lines[0];
+  if (!header.startsWith("GCF ")) {
+    throw new Error(`gcf: invalid header, expected 'GCF ...' got "${header}"`);
+  }
+  const p = {
+    tool: "",
+    tokenBudget: 0,
+    tokensUsed: 0,
+    symbols: [],
+    edges: []
+  };
+  parseHeader(header.slice(4), p);
+  const isDelta = header.includes(" delta=true");
+  const validDeltaSections = /* @__PURE__ */ new Set(["removed", "added", "edges_removed", "edges_added"]);
+  const symbols = [];
+  const symByID = /* @__PURE__ */ new Map();
+  let currentDistance = 0;
+  let inEdges = false;
+  for (let i = 1; i < lines.length; i++) {
+    let line = lines[i].replace(/\r$/, "");
+    if (line === "") continue;
+    if (line.startsWith("##! ")) continue;
+    if (line.startsWith("## ")) {
+      let group = line.slice(3);
+      const bracketIdx = group.indexOf(" [");
+      if (bracketIdx >= 0) {
+        group = group.slice(0, bracketIdx);
+      }
+      if (isDelta && !validDeltaSections.has(group)) {
+        throw new Error(`malformed_delta: invalid delta section "${group}"`);
+      }
+      inEdges = group === "edges";
+      if (!inEdges) {
+        switch (group) {
+          case "targets":
+            currentDistance = 0;
+            break;
+          case "related":
+            currentDistance = 1;
+            break;
+          case "extended":
+            currentDistance = 2;
+            break;
+          default:
+            if (group.startsWith("distance_")) {
+              const d = parseInt(group.slice(9), 10);
+              if (!isNaN(d)) {
+                currentDistance = d;
+              }
+            }
+            break;
+        }
+      }
+      continue;
+    }
+    if (line.startsWith("# ")) {
+      continue;
+    }
+    if (inEdges) {
+      const edge = parseEdgeLine(line, symByID);
+      p.edges.push(edge);
+    } else {
+      const { symbol, id } = parseSymbolLine(line, currentDistance);
+      symbols.push(symbol);
+      symByID.set(id, symbol);
+    }
+  }
+  p.symbols = symbols;
+  return p;
+}
+function parseHeader(fields, p) {
+  const parts = fields.split(/\s+/);
+  for (const part of parts) {
+    const eqIdx = part.indexOf("=");
+    if (eqIdx < 0) continue;
+    const key = part.slice(0, eqIdx);
+    const value = part.slice(eqIdx + 1);
+    switch (key) {
+      case "tool":
+        p.tool = value;
+        break;
+      case "budget": {
+        const v = parseInt(value, 10);
+        if (isNaN(v)) throw new Error(`gcf: invalid budget "${value}"`);
+        p.tokenBudget = v;
+        break;
+      }
+      case "tokens": {
+        const v = parseInt(value, 10);
+        if (isNaN(v)) throw new Error(`gcf: invalid tokens "${value}"`);
+        p.tokensUsed = v;
+        break;
+      }
+      case "pack_root":
+        p.packRoot = value;
+        break;
+      case "symbols":
+        break;
+    }
+  }
+}
+function parseSymbolLine(line, distance) {
+  if (!line.startsWith("@")) {
+    throw new Error(`gcf: expected symbol line starting with @, got "${line}"`);
+  }
+  const parts = line.split(/\s+/);
+  if (parts.length < 5) {
+    throw new Error(
+      `invalid_node_line: symbol line needs at least 5 fields, got ${parts.length} in "${line}"`
+    );
+  }
+  const idStr = parts[0].slice(1);
+  const id = parseInt(idStr, 10);
+  if (isNaN(id)) {
+    throw new Error(`invalid_symbol_id: invalid symbol id "${idStr}"`);
+  }
+  let kind = parts[1];
+  if (KIND_EXPAND[kind]) {
+    kind = KIND_EXPAND[kind];
+  }
+  const qname = parts[2];
+  const score = parseFloat(parts[3]);
+  if (isNaN(score)) {
+    throw new Error(`invalid_score: invalid score "${parts[3]}"`);
+  }
+  const provenance = parts[4];
+  return {
+    symbol: {
+      qualifiedName: qname,
+      kind,
+      score,
+      provenance,
+      distance
+    },
+    id
+  };
+}
+function parseEdgeLine(line, symByID) {
+  const parts = line.split(/\s+/);
+  if (parts.length < 2) {
+    throw new Error(`gcf: edge line needs at least 2 fields, got "${line}"`);
+  }
+  const ref = parts[0];
+  const ltIdx = ref.indexOf("<");
+  if (ltIdx < 0) {
+    throw new Error(`invalid_edge_syntax: edge line missing '<' separator in "${ref}"`);
+  }
+  const targetIDStr = ref.slice(1, ltIdx);
+  const sourceIDStr = ref.slice(ltIdx + 2);
+  const targetID = parseInt(targetIDStr, 10);
+  if (isNaN(targetID)) {
+    throw new Error(`gcf: invalid target id "${targetIDStr}"`);
+  }
+  const sourceID = parseInt(sourceIDStr, 10);
+  if (isNaN(sourceID)) {
+    throw new Error(`gcf: invalid source id "${sourceIDStr}"`);
+  }
+  const targetSym = symByID.get(targetID);
+  const sourceSym = symByID.get(sourceID);
+  if (!targetSym || !sourceSym) {
+    throw new Error(
+      `unknown_edge_reference: edge references unknown symbol id(s): target=${targetID} source=${sourceID}`
+    );
+  }
+  const edgeType = parts[1];
+  const status = parts.length >= 3 ? parts[2] : void 0;
+  return {
+    source: sourceSym.qualifiedName,
+    target: targetSym.qualifiedName,
+    edgeType,
+    status
+  };
+}
+
+// src/session.ts
+var Session = class {
+  symbols = /* @__PURE__ */ new Map();
+  nextID = 0;
+  /** Returns true if the symbol has been sent in a previous response. */
+  transmitted(qname) {
+    return this.symbols.has(qname);
+  }
+  /** Returns the session-global ID for a previously transmitted symbol, or -1 if not found. */
+  getID(qname) {
+    const id = this.symbols.get(qname);
+    return id !== void 0 ? id : -1;
+  }
+  /**
+   * Record marks symbols as transmitted and assigns session-global IDs.
+   * Call this after a successful encode to register newly-sent symbols.
+   */
+  record(symbols) {
+    for (const sym of symbols) {
+      if (!this.symbols.has(sym.qualifiedName)) {
+        this.symbols.set(sym.qualifiedName, this.nextID);
+        this.nextID++;
+      }
+    }
+  }
+  /** Returns the number of symbols tracked in this session. */
+  size() {
+    return this.symbols.size;
+  }
+  /** Clears the session state. */
+  reset() {
+    this.symbols.clear();
+    this.nextID = 0;
+  }
+};
+function groupByDistance2(symbols) {
+  if (symbols.length === 0) return [];
+  const groups = [];
+  let current = null;
+  for (const s of symbols) {
+    if (current === null || current.distance !== s.distance) {
+      current = { distance: s.distance, symbols: [] };
+      groups.push(current);
+    }
+    current.symbols.push(s);
+  }
+  return groups;
+}
+function encodeWithSession(p, sess) {
+  if (!sess) {
+    return encode(p);
+  }
+  const lines = [];
+  let header = `GCF profile=graph tool=${p.tool}`;
+  if (p.tokenBudget) header += ` budget=${p.tokenBudget}`;
+  if (p.tokensUsed) header += ` tokens=${p.tokensUsed}`;
+  header += ` symbols=${p.symbols.length}`;
+  if (p.edges.length > 0) header += ` edges=${p.edges.length}`;
+  header += " session=true";
+  if (p.packRoot) {
+    header += ` pack_root=${p.packRoot}`;
+  }
+  lines.push(header);
+  const localIndex = /* @__PURE__ */ new Map();
+  for (let i = 0; i < p.symbols.length; i++) {
+    localIndex.set(p.symbols[i].qualifiedName, i);
+  }
+  const newSymbols = [];
+  const groups = groupByDistance2(p.symbols);
+  const groupNames = ["targets", "related", "extended"];
+  for (const g of groups) {
+    if (g.symbols.length === 0) continue;
+    let name;
+    if (g.distance < groupNames.length) {
+      name = groupNames[g.distance];
+    } else {
+      name = `distance_${g.distance}`;
+    }
+    lines.push(`## ${name}`);
+    for (const s of g.symbols) {
+      const idx = localIndex.get(s.qualifiedName);
+      if (sess.transmitted(s.qualifiedName)) {
+        lines.push(`@${idx}  # previously transmitted`);
+      } else {
+        const kind = KIND_ABBREV[s.kind] || s.kind;
+        lines.push(`@${idx} ${kind} ${s.qualifiedName} ${s.score.toFixed(2)} ${s.provenance}`);
+        newSymbols.push(s);
+      }
+    }
+  }
+  if (p.edges.length > 0) {
+    lines.push(`## edges [${p.edges.length}]`);
+    for (const e of p.edges) {
+      const srcIdx = localIndex.get(e.source);
+      const tgtIdx = localIndex.get(e.target);
+      if (srcIdx === void 0 || tgtIdx === void 0) continue;
+      let line = `@${tgtIdx}<@${srcIdx} ${e.edgeType}`;
+      if (e.status && e.status !== "unchanged") {
+        line += ` ${e.status}`;
+      }
+      lines.push(line);
+    }
+  }
+  sess.record(newSymbols);
+  return lines.join("\n") + "\n";
+}
+
+// src/packroot.ts
+var import_node_crypto = require("node:crypto");
+
+// src/scalar.ts
+var JSON_NUMBER_RE = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+var NUMERIC_LIKE_RE = /^[+-]\.?\d|^\.\d|^0\d/;
+function needsQuote(s) {
+  if (s === "") return true;
+  if (s === "-" || s === "~" || s === "^" || s === "true" || s === "false") return true;
+  if (JSON_NUMBER_RE.test(s)) return true;
+  if (NUMERIC_LIKE_RE.test(s)) return true;
+  if (s[0] === " " || s[s.length - 1] === " ") return true;
+  if (s[0] === "#" || s[0] === "@" || s[0] === ".") return true;
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c === 34 || c === 92 || c < 32 || c === 10 || c === 13 || c === 124 || c === 44) return true;
+    if (c >= 128 && c <= 159) return true;
+    if (c > 127 && (c === 160 || c === 8232 || c === 8233 || c === 65279 || c === 5760 || c >= 8192 && c <= 8202 || c === 8239 || c === 8287 || c === 12288)) return true;
+  }
+  return false;
+}
+function quoteString(s) {
+  let out = '"';
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    switch (c) {
+      case 34:
+        out += '\\"';
+        break;
+      case 92:
+        out += "\\\\";
+        break;
+      case 8:
+        out += "\\b";
+        break;
+      case 12:
+        out += "\\f";
+        break;
+      case 10:
+        out += "\\n";
+        break;
+      case 13:
+        out += "\\r";
+        break;
+      case 9:
+        out += "\\t";
+        break;
+      default:
+        if (c < 32) {
+          out += "\\u" + c.toString(16).padStart(4, "0");
+        } else {
+          out += s[i];
+        }
+    }
+  }
+  return out + '"';
+}
+function formatScalar(v, delimiter = 0) {
+  if (v === null || v === void 0) return "-";
+  if (typeof v === "boolean") return v ? "true" : "false";
+  if (typeof v === "number") return formatNumber(v);
+  const s = String(v);
+  if (needsQuote(s) || delimiter && s.includes(String.fromCharCode(delimiter))) {
+    return quoteString(s);
+  }
+  return s;
+}
+function formatNumber(f) {
+  if (Object.is(f, -0)) return "-0";
+  if (f === 0) return "0";
+  const abs = Math.abs(f);
+  if (abs >= 1e-6 && abs < 1e21) {
+    return toPreciseDecimal(f);
+  }
+  let s = f.toExponential();
+  s = s.replace(/[eE]\+?0*(\d)/, "e+$1").replace(/[eE]-0*(\d)/, "e-$1");
+  return s;
+}
+function toPreciseDecimal(f) {
+  return String(f);
+}
+var BARE_KEY_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+function isBareKey(s) {
+  return BARE_KEY_RE.test(s);
+}
+function formatKey(s) {
+  return isBareKey(s) ? s : quoteString(s);
+}
+function parseScalar(s, tabularContext) {
+  if (s === "") return "";
+  if (s[0] === '"') return parseQuotedString(s);
+  if (s === "-") return null;
+  if (s === "~") {
+    if (!tabularContext) throw new Error("invalid_missing: ~ outside tabular row cell");
+    return MISSING;
+  }
+  if (s === "^" || s.startsWith("^{") && s.endsWith("}")) {
+    if (!tabularContext) throw new Error("invalid_attachment_marker: ^ outside tabular row cell");
+    if (s === "^") return ATTACHMENT;
+    return { __inlineSchema: s.slice(1) };
+  }
+  if (s === "true") return true;
+  if (s === "false") return false;
+  if (JSON_NUMBER_RE.test(s)) {
+    const f = Number(s);
+    if (!isNaN(f)) return f;
+  }
+  return s;
+}
+var MISSING = Symbol("missing");
+var ATTACHMENT = Symbol("attachment");
+function parseQuotedString(s) {
+  if (s.length < 2 || s[0] !== '"') throw new Error("unterminated_quote");
+  let out = "";
+  let i = 1;
+  while (i < s.length) {
+    if (s[i] === '"') {
+      if (i + 1 !== s.length) throw new Error("trailing_characters: after closing quote");
+      return out;
+    }
+    if (s[i] === "\\") {
+      if (i + 1 >= s.length) throw new Error("unterminated_quote");
+      i++;
+      switch (s[i]) {
+        case '"':
+          out += '"';
+          break;
+        case "\\":
+          out += "\\";
+          break;
+        case "/":
+          out += "/";
+          break;
+        case "b":
+          out += "\b";
+          break;
+        case "f":
+          out += "\f";
+          break;
+        case "n":
+          out += "\n";
+          break;
+        case "r":
+          out += "\r";
+          break;
+        case "t":
+          out += "	";
+          break;
+        case "u": {
+          if (i + 4 >= s.length) throw new Error("invalid_escape: incomplete unicode");
+          const hex = s.slice(i + 1, i + 5);
+          const code = parseInt(hex, 16);
+          if (isNaN(code)) throw new Error(`invalid_escape: invalid unicode \\u${hex}`);
+          if (code >= 55296 && code <= 56319) {
+            if (i + 10 >= s.length || s[i + 5] !== "\\" || s[i + 6] !== "u") {
+              throw new Error("invalid_surrogate: isolated high surrogate");
+            }
+            const hex2 = s.slice(i + 7, i + 11);
+            const low = parseInt(hex2, 16);
+            if (isNaN(low) || low < 56320 || low > 57343) {
+              throw new Error("invalid_surrogate: invalid low surrogate");
+            }
+            out += String.fromCodePoint(65536 + (code - 55296) * 1024 + (low - 56320));
+            i += 11;
+            continue;
+          }
+          if (code >= 56320 && code <= 57343) {
+            throw new Error("invalid_surrogate: isolated low surrogate");
+          }
+          out += String.fromCharCode(code);
+          i += 5;
+          continue;
+        }
+        default:
+          throw new Error(`invalid_escape: unknown \\${s[i]}`);
+      }
+      i++;
+      continue;
+    }
+    if (s.charCodeAt(i) < 32) {
+      throw new Error(`invalid_escape: unescaped control U+${s.charCodeAt(i).toString(16).padStart(4, "0")}`);
+    }
+    out += s[i];
+    i++;
+  }
+  throw new Error("unterminated_quote");
+}
+function splitRespectingQuotes(s, delim) {
+  const parts = [];
+  let current = "";
+  let inQuote = false;
+  let escaped = false;
+  for (let i = 0; i < s.length; i++) {
+    if (escaped) {
+      current += s[i];
+      escaped = false;
+      continue;
+    }
+    if (s[i] === "\\" && inQuote) {
+      current += s[i];
+      escaped = true;
+      continue;
+    }
+    if (s[i] === '"') {
+      inQuote = !inQuote;
+      current += s[i];
+      continue;
+    }
+    if (s[i] === delim && !inQuote) {
+      parts.push(current);
+      current = "";
+      continue;
+    }
+    current += s[i];
+  }
+  parts.push(current);
+  return parts;
+}
+function splitFieldDecl(s) {
+  if (s.length < 2 || s[0] !== "{") throw new Error("invalid field declaration");
+  const closeIdx = findClosingBrace(s);
+  if (closeIdx < 0) throw new Error("invalid field declaration");
+  const inner = s.slice(1, closeIdx);
+  if (!inner) return [];
+  const raw = splitRespectingQuotes(inner, ",");
+  const fields = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const f of raw) {
+    const trimmed = f.trim();
+    let name;
+    if (trimmed.length >= 2 && trimmed[0] === '"' && trimmed[trimmed.length - 1] === '"') {
+      name = parseQuotedString(trimmed);
+    } else {
+      if (!isBareKey(trimmed)) throw new Error(`invalid field name: ${trimmed}`);
+      name = trimmed;
+    }
+    if (seen.has(name)) throw new Error(`duplicate_field_name: ${name}`);
+    seen.add(name);
+    fields.push(name);
+  }
+  return fields;
+}
+function findClosingBrace(s) {
+  let inQuote = false;
+  let escaped = false;
+  for (let i = 0; i < s.length; i++) {
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (s[i] === "\\" && inQuote) {
+      escaped = true;
+      continue;
+    }
+    if (s[i] === '"') {
+      inQuote = !inQuote;
+      continue;
+    }
+    if (s[i] === "}" && !inQuote) return i;
+  }
+  return -1;
+}
+
+// src/packroot.ts
+function packRoot(symbols, edges, symbolKinds) {
+  const symRecords = [];
+  const edgeRecords = [];
+  for (const s of symbols) {
+    const kind = KIND_ABBREV[s.kind] || s.kind;
+    symRecords.push(`S	${kind}	${s.qualifiedName}	${formatNumber(s.score)}	${s.provenance}	${s.distance}
+`);
+  }
+  const kindMap = symbolKinds ?? /* @__PURE__ */ new Map();
+  if (!symbolKinds) {
+    for (const s of symbols) {
+      const kind = KIND_ABBREV[s.kind] || s.kind;
+      kindMap.set(s.qualifiedName, kind);
+    }
+  }
+  for (const e of edges) {
+    const srcKind = kindMap.get(e.source) || "fn";
+    const tgtKind = kindMap.get(e.target) || "fn";
+    edgeRecords.push(`E	${srcKind}	${e.source}	${tgtKind}	${e.target}	${e.edgeType}
+`);
+  }
+  symRecords.sort();
+  edgeRecords.sort();
+  const data = symRecords.join("") + edgeRecords.join("");
+  const hash = (0, import_node_crypto.createHash)("sha256").update(data, "utf8").digest("hex");
+  return `sha256:${hash}`;
+}
+
+// src/delta.ts
+function encodeDelta(d) {
+  const lines = [];
+  let savings = 0;
+  if (d.fullTokens > 0) {
+    savings = Math.round(100 * (1 - d.deltaTokens / d.fullTokens));
+  }
+  lines.push(
+    `GCF profile=graph tool=${d.tool} delta=true base_root=${d.baseRoot} new_root=${d.newRoot} tokens=${d.deltaTokens} savings=${savings}%`
+  );
+  if (d.removed.length > 0) {
+    lines.push("## removed");
+    for (const s of d.removed) {
+      const kind = KIND_ABBREV[s.kind] || s.kind;
+      lines.push(`${kind} ${s.qualifiedName}`);
+    }
+  }
+  if (d.added.length > 0) {
+    lines.push("## added");
+    for (let i = 0; i < d.added.length; i++) {
+      const s = d.added[i];
+      const kind = KIND_ABBREV[s.kind] || s.kind;
+      lines.push(`@${i} ${kind} ${s.qualifiedName} ${s.score.toFixed(2)} ${s.provenance}`);
+    }
+  }
+  if (d.removedEdges.length > 0) {
+    lines.push("## edges_removed");
+    for (const e of d.removedEdges) {
+      lines.push(`${e.source} -> ${e.target} ${e.edgeType}`);
+    }
+  }
+  if (d.addedEdges.length > 0) {
+    lines.push("## edges_added");
+    for (const e of d.addedEdges) {
+      lines.push(`${e.source} -> ${e.target} ${e.edgeType}`);
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+function verifyDelta(baseSymbols, baseEdges, removedSymbols, addedSymbols, removedEdges, addedEdges, expectedNewRoot) {
+  const removedNames = new Set(removedSymbols.map((s) => s.qualifiedName));
+  const newSymbols = baseSymbols.filter((s) => !removedNames.has(s.qualifiedName)).concat(addedSymbols);
+  const removedEdgeKeys = new Set(
+    removedEdges.map((e) => `${e.source}	${e.target}	${e.edgeType}`)
+  );
+  const newEdges = baseEdges.filter((e) => !removedEdgeKeys.has(`${e.source}	${e.target}	${e.edgeType}`)).concat(addedEdges);
+  const computed = packRoot(newSymbols, newEdges);
+  if (computed !== expectedNewRoot) {
+    throw new Error(
+      `pack root mismatch: expected ${expectedNewRoot}, computed ${computed}`
+    );
+  }
+  return { symbols: newSymbols, edges: newEdges };
+}
+
+// src/generic.ts
+function indent(depth) {
+  return "  ".repeat(depth);
+}
+function encodeGeneric(data) {
+  let out = "GCF profile=generic\n";
+  out += encodeRootValue(data);
+  return out;
+}
+function encodeRootValue(v) {
+  if (v === null || v === void 0) return "=-\n";
+  if (Array.isArray(v)) return encodeRootArray(v);
+  if (typeof v === "object") return encodeObject(v, 0);
+  return `=${formatScalar(v, 0)}
+`;
+}
+function encodeObject(obj, depth) {
+  const prefix = indent(depth);
+  let out = "";
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
+    const fk = formatKey(key);
+    if (Array.isArray(value)) {
+      out += encodeNamedArray(fk, value, depth);
+    } else if (typeof value === "object" && value !== null) {
+      out += `${prefix}## ${fk}
+`;
+      out += encodeObject(value, depth + 1);
+    } else {
+      out += `${prefix}${fk}=${formatScalar(value, 0)}
+`;
+    }
+  }
+  return out;
+}
+function encodeRootArray(arr) {
+  if (arr.length === 0) return "## [0]\n";
+  if (allPrimitives(arr)) {
+    const vals = arr.map((v) => formatScalar(v, 44));
+    return `## [${arr.length}]: ${vals.join(",")}
+`;
+  }
+  const fields = tabularFields(arr);
+  if (fields) return encodeTabular("## ", arr, fields, 0);
+  return encodeExpanded("## ", arr, 0);
+}
+function encodeNamedArray(name, arr, depth) {
+  const prefix = indent(depth);
+  if (arr.length === 0) return `${prefix}## ${name} [0]
+`;
+  if (allPrimitives(arr)) {
+    const vals = arr.map((v) => formatScalar(v, 44));
+    return `${prefix}${name}[${arr.length}]: ${vals.join(",")}
+`;
+  }
+  const fields = tabularFields(arr);
+  if (fields) return encodeTabular(`${prefix}## ${name} `, arr, fields, depth);
+  return encodeExpanded(`${prefix}## ${name} `, arr, depth);
+}
+function tabularFields(arr) {
+  if (arr.length === 0) return null;
+  const fieldOrder = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of arr) {
+    if (typeof item !== "object" || item === null || Array.isArray(item)) return null;
+    for (const k of Object.keys(item)) {
+      if (!seen.has(k)) {
+        fieldOrder.push(k);
+        seen.add(k);
+      }
+    }
+  }
+  return fieldOrder.length > 0 ? fieldOrder : null;
+}
+function inlineSchemaFields(arr, fieldName) {
+  const first = arr[0];
+  if (!first || !(fieldName in first)) return null;
+  const firstVal = first[fieldName];
+  if (firstVal === null || firstVal === void 0 || typeof firstVal !== "object" || Array.isArray(firstVal)) return null;
+  let canonicalKeys = null;
+  for (const item of arr) {
+    const obj = item;
+    if (!(fieldName in obj) || obj[fieldName] === null || obj[fieldName] === void 0) continue;
+    const v = obj[fieldName];
+    if (typeof v !== "object" || Array.isArray(v)) return null;
+    const keys = Object.keys(v);
+    for (const k of keys) {
+      const val = v[k];
+      if (val !== null && val !== void 0 && typeof val === "object") return null;
+    }
+    if (!canonicalKeys) {
+      canonicalKeys = keys;
+    } else {
+      if (keys.length !== canonicalKeys.length) return null;
+      for (let i = 0; i < keys.length; i++) {
+        if (keys[i] !== canonicalKeys[i]) return null;
+      }
+    }
+  }
+  if (!canonicalKeys || canonicalKeys.length < 3) return null;
+  return canonicalKeys;
+}
+function sharedArraySchema(arr, fieldName) {
+  const first = arr[0];
+  if (!first || !(fieldName in first)) return null;
+  const firstVal = first[fieldName];
+  if (!Array.isArray(firstVal)) return null;
+  let canonicalFields = null;
+  for (const item of arr) {
+    const obj = item;
+    if (!(fieldName in obj) || obj[fieldName] === null || obj[fieldName] === void 0) continue;
+    const v = obj[fieldName];
+    if (!Array.isArray(v)) return null;
+    const fields = tabularFields(v);
+    if (!fields) return null;
+    for (const arrItem of v) {
+      if (typeof arrItem !== "object" || arrItem === null) return null;
+      for (const val of Object.values(arrItem)) {
+        if (val !== null && val !== void 0 && typeof val === "object") return null;
+      }
+    }
+    if (!canonicalFields) {
+      canonicalFields = fields;
+    } else {
+      if (fields.length !== canonicalFields.length) return null;
+      for (let i = 0; i < fields.length; i++) {
+        if (fields[i] !== canonicalFields[i]) return null;
+      }
+    }
+  }
+  return canonicalFields;
+}
+function encodeTabular(headerPrefix, arr, fields, depth) {
+  const prefix = indent(depth);
+  const inlineSchemas = /* @__PURE__ */ new Map();
+  const sharedArrSchemas = /* @__PURE__ */ new Map();
+  for (const f of fields) {
+    const ifs = inlineSchemaFields(arr, f);
+    if (ifs) inlineSchemas.set(f, ifs);
+    const sas = sharedArraySchema(arr, f);
+    if (sas) sharedArrSchemas.set(f, sas);
+  }
+  const fmtFields = fields.map((f) => formatKey(f));
+  let out = `${headerPrefix}[${arr.length}]{${fmtFields.join(",")}}
+`;
+  for (let i = 0; i < arr.length; i++) {
+    const obj = arr[i];
+    const cells = [];
+    const attachments = [];
+    let rowHasAttachment = false;
+    for (const f of fields) {
+      if (!(f in obj)) {
+        cells.push("~");
+        continue;
+      }
+      const v = obj[f];
+      if (v === null || v === void 0) {
+        cells.push("-");
+        continue;
+      }
+      if (typeof v === "object") {
+        const ifs = inlineSchemas.get(f);
+        if (ifs && !Array.isArray(v)) {
+          if (i === 0) {
+            const fmtIF = ifs.map((k) => formatKey(k));
+            cells.push(`^{${fmtIF.join(",")}}`);
+          } else {
+            cells.push("^");
+          }
+          attachments.push({ name: f, value: v, inline: true, inlineFields: ifs });
+        } else {
+          cells.push("^");
+          attachments.push({ name: f, value: v, inline: false });
+        }
+        rowHasAttachment = true;
+      } else {
+        cells.push(formatScalar(v, 124));
+      }
+    }
+    const row = cells.join("|");
+    if (rowHasAttachment) {
+      out += `${prefix}@${i} ${row}
+`;
+    } else {
+      out += `${prefix}${row}
+`;
+    }
+    for (const att of attachments) {
+      const fk = formatKey(att.name);
+      if (att.inline && att.inlineFields) {
+        const vals = att.inlineFields.map((inf) => {
+          const val = att.value[inf];
+          if (val === void 0) return "~";
+          return formatScalar(val, 124);
+        });
+        out += `${prefix}${vals.join("|")}
+`;
+      } else if (Array.isArray(att.value)) {
+        const sas = sharedArrSchemas.get(att.name);
+        if (sas && i > 0) {
+          out += encodeAttachmentArrayShared(prefix, fk, att.value, depth + 2, sas);
+        } else {
+          out += encodeAttachmentArray(prefix, fk, att.value, depth + 2);
+        }
+      } else {
+        out += `${prefix}.${fk} {}
+`;
+        out += encodeObject(att.value, depth + 2);
+      }
+    }
+  }
+  return out;
+}
+function encodeAttachmentArray(attPrefix, fk, arr, depth) {
+  if (arr.length === 0) return `${attPrefix}.${fk} [0]
+`;
+  if (allPrimitives(arr)) {
+    const vals = arr.map((v) => formatScalar(v, 44));
+    return `${attPrefix}.${fk} [${arr.length}]: ${vals.join(",")}
+`;
+  }
+  const fields = tabularFields(arr);
+  if (fields) return encodeTabular(`${attPrefix}.${fk} `, arr, fields, depth);
+  return encodeExpanded(`${attPrefix}.${fk} `, arr, depth);
+}
+function encodeAttachmentArrayShared(attPrefix, fk, arr, depth, sharedFields) {
+  if (arr.length === 0) return `${attPrefix}.${fk} [0]
+`;
+  if (allPrimitives(arr)) {
+    const vals = arr.map((v) => formatScalar(v, 44));
+    return `${attPrefix}.${fk} [${arr.length}]: ${vals.join(",")}
+`;
+  }
+  const fields = tabularFields(arr);
+  if (fields && fields.length === sharedFields.length && fields.every((f, i) => f === sharedFields[i])) {
+    const prefix = indent(depth);
+    let out = `${attPrefix}.${fk} [${arr.length}]
+`;
+    for (const item of arr) {
+      const obj = item;
+      const cells = sharedFields.map((f) => {
+        if (!(f in obj)) return "~";
+        if (obj[f] === null || obj[f] === void 0) return "-";
+        return formatScalar(obj[f], 124);
+      });
+      out += `${prefix}${cells.join("|")}
+`;
+    }
+    return out;
+  }
+  return encodeAttachmentArray(attPrefix, fk, arr, depth);
+}
+function encodeExpanded(headerPrefix, arr, depth) {
+  const prefix = indent(depth);
+  let out = `${headerPrefix}[${arr.length}]
+`;
+  for (let i = 0; i < arr.length; i++) {
+    const item = arr[i];
+    if (Array.isArray(item)) {
+      out += encodeExpandedArrayItem(prefix, i, item, depth);
+    } else if (typeof item === "object" && item !== null) {
+      out += `${prefix}@${i} {}
+`;
+      out += encodeObject(item, depth + 1);
+    } else {
+      out += `${prefix}@${i} =${formatScalar(item, 0)}
+`;
+    }
+  }
+  return out;
+}
+function encodeExpandedArrayItem(prefix, idx, arr, depth) {
+  if (arr.length === 0) return `${prefix}@${idx} [0]
+`;
+  if (allPrimitives(arr)) {
+    const vals = arr.map((v) => formatScalar(v, 44));
+    return `${prefix}@${idx} [${arr.length}]: ${vals.join(",")}
+`;
+  }
+  const fields = tabularFields(arr);
+  if (fields) return encodeTabular(`${prefix}@${idx} `, arr, fields, depth + 1);
+  return encodeExpanded(`${prefix}@${idx} `, arr, depth + 1);
+}
+function allPrimitives(arr) {
+  return arr.every((v) => typeof v !== "object" || v === null);
+}
+
+// src/decode_generic.ts
+function decodeGeneric(input) {
+  input = input.trimEnd();
+  if (!input) throw new Error("missing_header: empty input");
+  const lines = input.split("\n");
+  const header = lines[0].replace(/\r$/, "");
+  if (!header.startsWith("GCF ")) throw new Error("missing_header: first line does not begin with GCF");
+  const profile = parseHeaderProfile(header);
+  if (profile === "graph") {
+    const p = decode(input);
+    return {
+      tool: p.tool,
+      tokenBudget: p.tokenBudget,
+      tokensUsed: p.tokensUsed,
+      packRoot: p.packRoot ?? "",
+      symbols: p.symbols.map((s) => ({
+        qualifiedName: s.qualifiedName,
+        kind: s.kind,
+        score: s.score,
+        provenance: s.provenance,
+        distance: s.distance
+      })),
+      edges: p.edges.map((e) => ({
+        source: e.source,
+        target: e.target,
+        edgeType: e.edgeType,
+        status: e.status ?? ""
+      }))
+    };
+  }
+  if (profile !== "generic") throw new Error(`unknown_profile: ${profile}`);
+  const contentLines = [];
+  let summaryLine = "";
+  let deferredSectionCount = 0;
+  for (let i = 1; i < lines.length; i++) {
+    const l = lines[i].replace(/\r$/, "");
+    if (l === "") continue;
+    for (let j = 0; j < l.length; j++) {
+      if (l[j] === "	") throw new Error("tab_indentation: tabs in leading whitespace");
+      if (l[j] !== " ") break;
+    }
+    const trimmed = l.trimStart();
+    if (trimmed.startsWith("# ")) continue;
+    if (trimmed.startsWith("##! ")) {
+      summaryLine = trimmed;
+      continue;
+    }
+    if (trimmed.startsWith("## ") && trimmed.includes("[?]")) deferredSectionCount++;
+    contentLines.push(l);
+  }
+  if (summaryLine && deferredSectionCount > 0) {
+    validateSummaryCounts(summaryLine, deferredSectionCount, contentLines);
+  }
+  if (contentLines.length === 0) return {};
+  const first = contentLines[0].trimStart();
+  if (first.startsWith("=")) {
+    if (contentLines.length > 1) throw new Error("trailing_characters: extra lines after root scalar");
+    return parseScalar(first.slice(1), false);
+  }
+  if (first.startsWith("## [")) {
+    const [arr] = parseArrayFromHeader(contentLines, 0, 0, first.slice(3));
+    return arr;
+  }
+  const result = {};
+  parseObjectBody(contentLines, 0, 0, result);
+  return result;
+}
+function parseHeaderProfile(header) {
+  const parts = header.split(/\s+/);
+  if (parts.length < 2) throw new Error("missing_profile");
+  const seen = /* @__PURE__ */ new Set();
+  let profile = "";
+  for (let i = 1; i < parts.length; i++) {
+    const eq = parts[i].indexOf("=");
+    if (eq < 0) throw new Error(`malformed_header_field: ${parts[i]}`);
+    const key = parts[i].slice(0, eq);
+    if (seen.has(key)) throw new Error(`duplicate_header_field: ${key}`);
+    seen.add(key);
+    if (key === "profile") profile = parts[i].slice(eq + 1);
+  }
+  if (!profile) throw new Error("missing_profile");
+  return profile;
+}
+function parseObjectBody(lines, start, depth, out) {
+  const ind = "  ".repeat(depth);
+  let i = start;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (depth > 0 && !line.startsWith(ind)) break;
+    const content = depth > 0 ? line.slice(ind.length) : line;
+    if (content.length > 0 && content[0] === " ") {
+      throw new Error("invalid_indent: indentation increases by more than one level");
+    }
+    if (content.startsWith("## ")) {
+      const hdr = content.slice(3);
+      const bi = hdr.indexOf(" [");
+      if (bi >= 0) {
+        const name2 = parseKeyFromHeader(hdr.slice(0, bi));
+        checkDup(out, name2);
+        const [arr, consumed2] = parseArrayFromHeader(lines, i, depth, hdr.slice(bi));
+        out[name2] = arr;
+        i += consumed2;
+        continue;
+      }
+      const name = parseKeyFromHeader(hdr);
+      checkDup(out, name);
+      i++;
+      const nested = {};
+      const consumed = parseObjectBody(lines, i, depth + 1, nested);
+      out[name] = nested;
+      i += consumed;
+      continue;
+    }
+    if (!content.startsWith("@") && !content.startsWith("##")) {
+      const bracketIdx = content.indexOf("[");
+      if (bracketIdx > 0) {
+        const rest = content.slice(bracketIdx);
+        const closeIdx = rest.indexOf("]");
+        if (closeIdx >= 0) {
+          const after = rest.slice(closeIdx + 1);
+          if (after.startsWith(": ") || after === ":") {
+            const name = parseKeyFromHeader(content.slice(0, bracketIdx));
+            checkDup(out, name);
+            const [arr] = parseArrayFromHeader(lines, i, depth, rest);
+            out[name] = arr;
+            i++;
+            continue;
+          }
+        }
+      }
+    }
+    const eqIdx = findKeyValueSplit(content);
+    if (eqIdx > 0) {
+      const name = parseKeyFromHeader(content.slice(0, eqIdx));
+      checkDup(out, name);
+      out[name] = parseScalar(content.slice(eqIdx + 1), false);
+      i++;
+      continue;
+    }
+    i++;
+  }
+  return i - start;
+}
+function findKeyValueSplit(s) {
+  if (!s.length) return -1;
+  if (s[0] === '"') {
+    for (let i = 1; i < s.length; i++) {
+      if (s[i] === "\\") {
+        i++;
+        continue;
+      }
+      if (s[i] === '"') return i + 1 < s.length && s[i + 1] === "=" ? i + 1 : -1;
+    }
+    return -1;
+  }
+  return s.indexOf("=");
+}
+function parseKeyFromHeader(s) {
+  s = s.trim();
+  if (s.length >= 2 && s[0] === '"') return parseQuotedString(s);
+  return s;
+}
+function checkDup(obj, key) {
+  if (key in obj) throw new Error(`duplicate_key: ${key}`);
+}
+function parseArrayFromHeader(lines, headerLine, depth, bracketPart) {
+  const bp = bracketPart.trimStart();
+  if (!bp.startsWith("[")) throw new Error("invalid_count");
+  const closeIdx = bp.indexOf("]");
+  if (closeIdx < 0) throw new Error("invalid_count");
+  const countStr = bp.slice(1, closeIdx);
+  const afterBracket = bp.slice(closeIdx + 1);
+  let count = -1;
+  if (countStr !== "?") count = parseCount(countStr);
+  if (count === 0 && !afterBracket.startsWith("{") && !afterBracket.startsWith(":")) {
+    return [[], 1];
+  }
+  if (afterBracket.startsWith(": ") || afterBracket === ":") {
+    const valsStr = afterBracket.startsWith(": ") ? afterBracket.slice(2) : "";
+    if (!valsStr) {
+      if (count >= 0 && count !== 0) throw new Error(`count_mismatch: declared ${count}, got 0`);
+      return [[], 1];
+    }
+    const vals = splitRespectingQuotes(valsStr, ",");
+    if (count >= 0 && vals.length !== count) throw new Error(`count_mismatch: declared ${count}, got ${vals.length}`);
+    return [vals.map((v) => parseScalar(v.trim(), false)), 1];
+  }
+  if (afterBracket.startsWith("{")) {
+    const braceEnd = findClosingBrace2(afterBracket);
+    if (braceEnd < 0) throw new Error("invalid field declaration");
+    const fields = splitFieldDecl(afterBracket.slice(0, braceEnd + 1));
+    const [rows, consumed2] = parseTabularBody(lines, headerLine + 1, depth, fields, count);
+    if (count >= 0 && rows.length !== count) throw new Error(`count_mismatch: declared ${count}, got ${rows.length}`);
+    return [rows, consumed2 + 1];
+  }
+  const [items, consumed] = parseExpandedBody(lines, headerLine + 1, depth);
+  if (count >= 0 && items.length !== count) throw new Error(`count_mismatch: declared ${count}, got ${items.length}`);
+  return [items, consumed + 1];
+}
+function findClosingBrace2(s) {
+  let inQuote = false, escaped = false;
+  for (let i = 0; i < s.length; i++) {
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (s[i] === "\\" && inQuote) {
+      escaped = true;
+      continue;
+    }
+    if (s[i] === '"') {
+      inQuote = !inQuote;
+      continue;
+    }
+    if (s[i] === "}" && !inQuote) return i;
+  }
+  return -1;
+}
+function parseTabularBody(lines, start, depth, fields, expectedCount) {
+  const ind = "  ".repeat(depth);
+  const rows = [];
+  let i = start;
+  const inlineSchemas = /* @__PURE__ */ new Map();
+  const sharedArraySchemas = /* @__PURE__ */ new Map();
+  while (i < lines.length) {
+    const line = lines[i];
+    const content = depth > 0 ? line.startsWith(ind) ? line.slice(ind.length) : null : line;
+    if (content === null) break;
+    if (content.startsWith("## ") || content.startsWith("##!")) break;
+    if (content.length > 0 && content[0] === " ") {
+      const trimmed = content.trimStart();
+      if (trimmed.startsWith(".")) break;
+      break;
+    }
+    let rowData = content;
+    let rowHasID = false;
+    if (rowData.startsWith("@")) {
+      const sp = rowData.indexOf(" ");
+      if (sp > 0) {
+        const idStr = rowData.slice(1, sp);
+        if (/^\d+$/.test(idStr)) {
+          rowData = rowData.slice(sp + 1);
+          rowHasID = true;
+        }
+      }
+    }
+    const vals = splitRespectingQuotes(rowData, "|");
+    if (vals.length !== fields.length) throw new Error(`row_width_mismatch: expected ${fields.length}, got ${vals.length}`);
+    const cellValues = /* @__PURE__ */ new Map();
+    const traditionalAttFields = [];
+    const inlineAttFields = [];
+    const inlineAttOrder = [];
+    const missingFields = /* @__PURE__ */ new Set();
+    for (let j = 0; j < fields.length; j++) {
+      const cellVal = vals[j];
+      if (cellVal.startsWith("^{") && cellVal.endsWith("}")) {
+        const schemaStr = cellVal.slice(1);
+        const ifs = splitFieldDecl(schemaStr);
+        inlineSchemas.set(fields[j], ifs);
+        inlineAttFields.push(fields[j]);
+        inlineAttOrder.push(fields[j]);
+        continue;
+      }
+      const parsed = parseScalar(cellVal, true);
+      if (parsed === MISSING) {
+        missingFields.add(fields[j]);
+        continue;
+      }
+      if (parsed === ATTACHMENT) {
+        if (inlineSchemas.has(fields[j])) {
+          inlineAttFields.push(fields[j]);
+          inlineAttOrder.push(fields[j]);
+        } else {
+          traditionalAttFields.push(fields[j]);
+        }
+        continue;
+      }
+      if (parsed && typeof parsed === "object" && parsed.__inlineSchema) {
+        const ifs = splitFieldDecl(parsed.__inlineSchema);
+        inlineSchemas.set(fields[j], ifs);
+        inlineAttFields.push(fields[j]);
+        inlineAttOrder.push(fields[j]);
+        continue;
+      }
+      cellValues.set(fields[j], parsed);
+    }
+    i++;
+    const allAttFields = [...traditionalAttFields, ...inlineAttFields];
+    const attachmentValues = /* @__PURE__ */ new Map();
+    if (rowHasID && allAttFields.length > 0) {
+      let inlineIdx = 0;
+      while (i < lines.length && attachmentValues.size < allAttFields.length) {
+        const aLine = lines[i];
+        let aContent = null;
+        if (depth === 0 || aLine.startsWith(ind)) {
+          aContent = depth > 0 ? aLine.slice(ind.length) : aLine;
+        } else {
+          break;
+        }
+        if (aContent === null) break;
+        let attContent = aContent;
+        if (!attContent.startsWith(".") && attContent.startsWith("  .")) {
+          attContent = attContent.slice(2);
+        }
+        if (attContent.startsWith(".")) {
+          const rest = attContent.slice(1);
+          const [attName, afterName] = parseAttachmentName(rest);
+          const ifs2 = inlineSchemas.get(attName);
+          if (ifs2 && !afterName.trimStart().startsWith("{}") && !afterName.trimStart().startsWith("[")) {
+            const data = afterName.trimStart();
+            const inlineVals2 = splitRespectingQuotes(data, "|");
+            if (inlineVals2.length !== ifs2.length) throw new Error(`inline_width_mismatch: ${attName} expected ${ifs2.length}, got ${inlineVals2.length}`);
+            const obj2 = {};
+            for (let k = 0; k < ifs2.length; k++) {
+              const p = parseScalar(inlineVals2[k], true);
+              if (p !== MISSING) obj2[ifs2[k]] = p;
+            }
+            if (attachmentValues.has(attName)) throw new Error(`duplicate_attachment: ${attName}`);
+            attachmentValues.set(attName, obj2);
+            i++;
+            continue;
+          }
+          const [name, val, consumed, parsedFields] = parseAttachment(lines, i, rest, depth + 2, sharedArraySchemas);
+          if (attachmentValues.has(name)) throw new Error(`duplicate_attachment: ${name}`);
+          if (rows.length === 0 && parsedFields) {
+            sharedArraySchemas.set(name, parsedFields);
+          }
+          attachmentValues.set(name, val);
+          i += consumed;
+          continue;
+        }
+        let foundInline = false;
+        let nextInlineField = "";
+        while (inlineIdx < inlineAttOrder.length) {
+          const candidate = inlineAttOrder[inlineIdx];
+          if (!attachmentValues.has(candidate)) {
+            nextInlineField = candidate;
+            foundInline = true;
+            break;
+          }
+          inlineIdx++;
+        }
+        if (!foundInline) break;
+        const ifs = inlineSchemas.get(nextInlineField);
+        const inlineVals = splitRespectingQuotes(aContent, "|");
+        if (inlineVals.length !== ifs.length) throw new Error(`inline_width_mismatch: ${nextInlineField} expected ${ifs.length}, got ${inlineVals.length}`);
+        const obj = {};
+        for (let k = 0; k < ifs.length; k++) {
+          const p = parseScalar(inlineVals[k], true);
+          if (p !== MISSING) obj[ifs[k]] = p;
+        }
+        attachmentValues.set(nextInlineField, obj);
+        inlineIdx++;
+        i++;
+      }
+      for (const f of allAttFields) {
+        if (!attachmentValues.has(f)) throw new Error(`missing_attachment: ${f}`);
+      }
+      if (i < lines.length) {
+        let peekContent = null;
+        if (depth === 0 || lines[i].startsWith(ind)) {
+          peekContent = depth > 0 ? lines[i].slice(ind.length) : lines[i];
+        }
+        if (peekContent !== null) {
+          let peekAtt = peekContent;
+          if (!peekAtt.startsWith(".") && peekAtt.startsWith("  .")) {
+            peekAtt = peekAtt.slice(2);
+          }
+          if (peekAtt.startsWith(".")) {
+            const peekRest = peekAtt.slice(1);
+            const [peekName] = parseAttachmentName(peekRest);
+            if (attachmentValues.has(peekName)) {
+              throw new Error(`duplicate_attachment: ${peekName}`);
+            }
+          }
+        }
+      }
+    }
+    const row = {};
+    for (const f of fields) {
+      if (missingFields.has(f)) continue;
+      if (cellValues.has(f)) {
+        row[f] = cellValues.get(f);
+        continue;
+      }
+      if (attachmentValues.has(f)) {
+        row[f] = attachmentValues.get(f);
+        continue;
+      }
+    }
+    if (!rowHasID || allAttFields.length === 0) {
+      const attIndent = ind + "  ";
+      if (i < lines.length && lines[i].startsWith(attIndent)) {
+        const peek = lines[i].slice(attIndent.length);
+        if (peek.startsWith(".")) throw new Error(`orphan_attachment: ${peek}`);
+      }
+    }
+    rows.push(row);
+    if (expectedCount >= 0 && rows.length >= expectedCount) break;
+  }
+  return [rows, i - start];
+}
+function parseAttachmentName(rest) {
+  if (rest[0] === '"') {
+    for (let j = 1; j < rest.length; j++) {
+      if (rest[j] === "\\") {
+        j++;
+        continue;
+      }
+      if (rest[j] === '"') {
+        const name = parseQuotedString(rest.slice(0, j + 1));
+        return [name, rest.slice(j + 1)];
+      }
+    }
+    return ["", rest];
+  }
+  const sp = rest.indexOf(" ");
+  if (sp >= 0) return [rest.slice(0, sp), rest.slice(sp)];
+  return [rest, ""];
+}
+function parseAttachment(lines, lineIdx, rest, depth, sharedSchemas) {
+  const [name, afterNameRaw] = parseAttachmentName(rest);
+  const afterName = afterNameRaw.trimStart();
+  if (afterName.startsWith("{}")) {
+    const nested = {};
+    const consumed = parseObjectBody(lines, lineIdx + 1, depth, nested);
+    return [name, nested, consumed + 1, null];
+  }
+  if (afterName.startsWith("[")) {
+    const closeBracket = afterName.indexOf("]");
+    if (closeBracket < 0) throw new Error("invalid_count: missing ]");
+    const afterClose = afterName.slice(closeBracket + 1);
+    if (afterClose.startsWith("{")) {
+      const endBrace = findClosingBrace2(afterClose);
+      let parsedFields = null;
+      if (endBrace >= 0) {
+        try {
+          parsedFields = splitFieldDecl(afterClose.slice(0, endBrace + 1));
+        } catch {
+        }
+      }
+      const [arr2, consumed2] = parseArrayFromHeader(lines, lineIdx, depth, afterName);
+      return [name, arr2, consumed2, parsedFields];
+    }
+    const afterCloseForInline = afterName.slice(closeBracket + 1);
+    if (afterCloseForInline.startsWith(": ") || afterCloseForInline === ":") {
+      const [arr2, consumed2] = parseArrayFromHeader(lines, lineIdx, depth, afterName);
+      return [name, arr2, consumed2, null];
+    }
+    if (sharedSchemas.has(name)) {
+      const sf = sharedSchemas.get(name);
+      const countStr = afterName.slice(1, closeBracket);
+      let count = -1;
+      if (countStr !== "?") count = parseInt(countStr, 10);
+      if (count === 0) return [name, [], 1, null];
+      const nextIdx = lineIdx + 1;
+      const ind = "  ".repeat(depth);
+      let useShared = true;
+      if (nextIdx < lines.length) {
+        let nextContent = lines[nextIdx];
+        if (depth > 0 && nextContent.startsWith(ind)) nextContent = nextContent.slice(ind.length);
+        if (nextContent.trimStart().startsWith("@")) useShared = false;
+      }
+      if (useShared) {
+        const [rows, consumed2] = parseTabularBody(lines, lineIdx + 1, depth, sf, count);
+        if (count >= 0 && rows.length !== count) throw new Error(`count_mismatch: declared ${count}, got ${rows.length}`);
+        return [name, rows, consumed2 + 1, null];
+      }
+    }
+    const [arr, consumed] = parseArrayFromHeader(lines, lineIdx, depth, afterName);
+    return [name, arr, consumed, null];
+  }
+  throw new Error(`invalid attachment form: ${afterName}`);
+}
+function parseExpandedBody(lines, start, depth) {
+  const ind = "  ".repeat(depth);
+  const items = [];
+  let i = start;
+  while (i < lines.length) {
+    const line = lines[i];
+    const content = depth > 0 ? line.startsWith(ind) ? line.slice(ind.length) : null : line;
+    if (content === null) break;
+    if (content.startsWith("## ") || content.startsWith("##!")) break;
+    if (!content.startsWith("@")) break;
+    const sp = content.indexOf(" ");
+    if (sp < 0) break;
+    const idStr = content.slice(1, sp);
+    const id = parseInt(idStr, 10);
+    if (!isNaN(id) && id !== items.length) {
+      throw new Error(`invalid_item_id: expected @${items.length}, got @${idStr}`);
+    }
+    const marker = content.slice(sp + 1);
+    if (marker.startsWith("=")) {
+      items.push(parseScalar(marker.slice(1), false));
+      i++;
+      continue;
+    }
+    if (marker.startsWith("{}")) {
+      const nested = {};
+      i++;
+      const consumed = parseObjectBody(lines, i, depth + 1, nested);
+      items.push(nested);
+      i += consumed;
+      continue;
+    }
+    if (marker.startsWith("[")) {
+      const [arr, consumed] = parseArrayFromHeader(lines, i, depth + 1, marker);
+      items.push(arr);
+      i += consumed;
+      continue;
+    }
+    break;
+  }
+  return [items, i - start];
+}
+function parseCount(s) {
+  if (s === "0") return 0;
+  if (!s.length || s[0] === "0") throw new Error(`invalid_count: ${s}`);
+  const n = parseInt(s, 10);
+  if (isNaN(n) || String(n) !== s) throw new Error(`invalid_count: ${s}`);
+  return n;
+}
+function validateSummaryCounts(summaryLine, deferredCount, contentLines) {
+  const parts = summaryLine.split(/\s+/);
+  let countsStr = "";
+  for (const p of parts) {
+    if (p.startsWith("counts=")) {
+      countsStr = p.slice(7);
+      break;
+    }
+  }
+  if (!countsStr) return;
+  const countVals = countsStr.split(",");
+  if (countVals.length !== deferredCount) {
+    throw new Error(`count_mismatch: summary has ${countVals.length} count entries but ${deferredCount} deferred sections`);
+  }
+  const actualCounts = [];
+  let inDeferred = false;
+  let currentCount = 0;
+  for (const l of contentLines) {
+    const trimmed = l.trimStart();
+    if (trimmed.startsWith("## ") && trimmed.includes("[?]")) {
+      if (inDeferred) actualCounts.push(currentCount);
+      inDeferred = true;
+      currentCount = 0;
+      continue;
+    }
+    if (trimmed.startsWith("## ")) {
+      if (inDeferred) {
+        actualCounts.push(currentCount);
+        inDeferred = false;
+      }
+      continue;
+    }
+    if (inDeferred && !trimmed.startsWith(" ") && !trimmed.startsWith(".")) {
+      currentCount++;
+    }
+  }
+  if (inDeferred) actualCounts.push(currentCount);
+  for (let i = 0; i < countVals.length; i++) {
+    const declared = parseInt(countVals[i], 10);
+    if (isNaN(declared)) throw new Error(`count_mismatch: invalid count value "${countVals[i]}"`);
+    if (i < actualCounts.length && declared !== actualCounts[i]) {
+      throw new Error(`count_mismatch: section ${i} declared ${declared} in summary, actual ${actualCounts[i]}`);
+    }
+  }
+}
+
+// src/stream.ts
+var StreamEncoder = class {
+  w;
+  symIndex = /* @__PURE__ */ new Map();
+  nextID = 0;
+  currentGroup = "";
+  groupCounts = /* @__PURE__ */ new Map();
+  edgeCount = 0;
+  edgesStarted = false;
+  constructor(w, tool, opts = {}) {
+    this.w = w;
+    this.writeHeader(tool, opts);
+  }
+  writeHeader(tool, opts) {
+    const parts = [`GCF profile=graph tool=${tool}`];
+    if (opts.tokenBudget) parts.push(`budget=${opts.tokenBudget}`);
+    if (opts.tokensUsed) parts.push(`tokens=${opts.tokensUsed}`);
+    if (opts.packRoot) parts.push(`pack_root=${opts.packRoot}`);
+    if (opts.session) parts.push("session=true");
+    this.w.write(parts.join(" ") + "\n");
+  }
+  /**
+   * Emit a symbol line immediately. Group headers are emitted automatically
+   * when the distance changes.
+   */
+  writeSymbol(s) {
+    const groupNames = ["targets", "related", "extended"];
+    const groupName = s.distance < groupNames.length ? groupNames[s.distance] : `distance_${s.distance}`;
+    if (groupName !== this.currentGroup) {
+      this.w.write(`## ${groupName}
+`);
+      this.currentGroup = groupName;
+    }
+    const id = this.nextID++;
+    this.symIndex.set(s.qualifiedName, id);
+    const kind = KIND_ABBREV[s.kind] || s.kind;
+    this.w.write(`@${id} ${kind} ${s.qualifiedName} ${s.score.toFixed(2)} ${s.provenance}
+`);
+    this.groupCounts.set(groupName, (this.groupCounts.get(groupName) || 0) + 1);
+  }
+  /**
+   * Emit an edge line immediately. The edges section header is emitted
+   * automatically on the first edge (with [?] deferred count).
+   * Source and target must reference previously-written symbols.
+   */
+  writeEdge(e) {
+    const srcIdx = this.symIndex.get(e.source);
+    const tgtIdx = this.symIndex.get(e.target);
+    if (srcIdx === void 0 || tgtIdx === void 0) return;
+    if (!this.edgesStarted) {
+      this.w.write("## edges [?]\n");
+      this.edgesStarted = true;
+    }
+    let line = `@${tgtIdx}<@${srcIdx} ${e.edgeType}`;
+    if (e.status && e.status !== "unchanged") {
+      line += ` ${e.status}`;
+    }
+    this.w.write(line + "\n");
+    this.edgeCount++;
+  }
+  /**
+   * Emit a bare reference for a previously-transmitted symbol (session mode).
+   */
+  writeBareRef(qname, distance) {
+    const groupNames = ["targets", "related", "extended"];
+    const groupName = distance < groupNames.length ? groupNames[distance] : `distance_${distance}`;
+    if (groupName !== this.currentGroup) {
+      this.w.write(`## ${groupName}
+`);
+      this.currentGroup = groupName;
+    }
+    const id = this.nextID++;
+    this.symIndex.set(qname, id);
+    this.w.write(`@${id}  # previously transmitted
+`);
+    this.groupCounts.set(groupName, (this.groupCounts.get(groupName) || 0) + 1);
+  }
+  /**
+   * Emit the ##! summary trailer with final counts. Must be called after all
+   * symbols and edges have been written.
+   */
+  close() {
+    const deferredCounts = [];
+    const groupOrder = ["targets", "related", "extended"];
+    for (const g of groupOrder) {
+      const c = this.groupCounts.get(g);
+      if (c && c > 0) deferredCounts.push(c);
+    }
+    for (const [g, c] of this.groupCounts) {
+      if (!groupOrder.includes(g) && c > 0) deferredCounts.push(c);
+    }
+    if (this.edgeCount > 0) {
+      deferredCounts.push(this.edgeCount);
+    }
+    this.w.write(`##! summary symbols=${this.nextID} edges=${this.edgeCount} counts=${deferredCounts.join(",")}
+`);
+  }
+  /** Number of symbols written so far. */
+  get symbolCount() {
+    return this.nextID;
+  }
+  /** Number of edges written so far. */
+  get edgeCount_() {
+    return this.edgeCount;
+  }
+};
+
+// src/stream_generic.ts
+var GenericStreamEncoder = class {
+  writer;
+  sections = [];
+  current = null;
+  constructor(writer) {
+    this.writer = writer;
+  }
+  /** Start a tabular array section with deferred count [?]. */
+  beginArray(name, fields) {
+    if (this.current !== null) {
+      this.endArrayInternal();
+    }
+    this.writer.write(`## ${name} [?]{${fields.join(",")}}
+`);
+    this.current = { name, fields, count: 0 };
+  }
+  /** Emit a single pipe-separated row immediately. */
+  writeRow(values) {
+    if (this.current === null) {
+      return;
+    }
+    const parts = values.map(formatValue);
+    this.writer.write(`${parts.join("|")}
+`);
+    this.current.count++;
+  }
+  /** Close the current array section and record its count. */
+  endArray() {
+    this.endArrayInternal();
+  }
+  /** Emit a key=value line immediately. */
+  writeKV(key, value) {
+    this.writer.write(`${key}=${formatValue(value)}
+`);
+  }
+  /** Start a nested object section (## key). */
+  writeSection(name) {
+    if (this.current !== null) {
+      this.endArrayInternal();
+    }
+    this.writer.write(`## ${name}
+`);
+  }
+  /** Emit a primitive array inline: name[N]: val1,val2,val3 */
+  writeInlineArray(name, values) {
+    const parts = values.map(formatValue);
+    this.writer.write(`${name}[${values.length}]: ${parts.join(",")}
+`);
+  }
+  /** Emit the ##! summary trailer with final counts. Must be called after all data. */
+  close() {
+    if (this.current !== null) {
+      this.endArrayInternal();
+    }
+    if (this.sections.length === 0) {
+      return;
+    }
+    const counts = this.sections.map((s) => String(s.count));
+    this.writer.write(`##! summary counts=${counts.join(",")}
+`);
+  }
+  endArrayInternal() {
+    if (this.current === null) {
+      return;
+    }
+    this.sections.push({ name: this.current.name, count: this.current.count });
+    this.current = null;
+  }
+};
+function formatValue(v) {
+  return formatScalar(v, 124);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GenericStreamEncoder,
+  KIND_ABBREV,
+  KIND_EXPAND,
+  Session,
+  StreamEncoder,
+  decode,
+  decodeGeneric,
+  encode,
+  encodeDelta,
+  encodeGeneric,
+  encodeWithSession,
+  formatKey,
+  formatScalar,
+  needsQuote,
+  parseScalar,
+  quoteString,
+  verifyDelta
+});