@felixdrp/gcf-wasm 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,1006 @@
+// src/host.ts
+class GcfError extends Error {
+  code;
+  detail;
+  line;
+  constructor(code, detail, line) {
+    super(line > 0 ? `${code} (line ${line}): ${detail}` : `${code}: ${detail}`);
+    this.name = "GcfError";
+    this.code = code;
+    this.detail = detail;
+    this.line = line;
+  }
+}
+var GcfDecodeError = GcfError;
+var utf8 = new TextEncoder;
+var fromUtf8 = new TextDecoder;
+function isPlainGraph(text) {
+  if (!text.startsWith("GCF profile=graph"))
+    return false;
+  const nl = text.indexOf(`
+`);
+  const header = nl < 0 ? text : text.slice(0, nl);
+  return !/ delta=true(\s|$)/.test(header);
+}
+function toJsonText(value) {
+  try {
+    const s = JSON.stringify(value);
+    if (s !== undefined && !/(?<![\d.eE+-])-?\d{16,}(?![\d.eE])/.test(s))
+      return s;
+  } catch {}
+  const skip = (v) => v === undefined || typeof v === "function" || typeof v === "symbol";
+  const walk = (v0, key) => {
+    const v = v0 !== null && typeof v0 === "object" && typeof v0.toJSON === "function" ? v0.toJSON(key) : v0;
+    if (typeof v === "bigint")
+      return v.toString();
+    if (typeof v === "number" && Number.isInteger(v) && Math.abs(v) >= 9007199254740992)
+      return v.toExponential();
+    if (v === null || skip(v) || typeof v === "number" || typeof v === "boolean" || typeof v === "string")
+      return skip(v) ? "null" : JSON.stringify(v);
+    if (Array.isArray(v)) {
+      const items = [];
+      for (let i = 0;i < v.length; i++)
+        items.push(skip(v[i]) ? "null" : walk(v[i], String(i)));
+      return `[${items.join(",")}]`;
+    }
+    const entries = v instanceof Map ? [...v.entries()] : Object.entries(v);
+    return `{${entries.filter(([, x]) => !skip(x)).map(([k, x]) => `${JSON.stringify(String(k))}:${walk(x, String(k))}`).join(",")}}`;
+  };
+  return walk(value, "");
+}
+function isPlainRecord(v) {
+  if (v === null || typeof v !== "object" || Array.isArray(v))
+    return false;
+  const proto = Object.getPrototypeOf(v);
+  return (proto === Object.prototype || proto === null) && v.toJSON === undefined;
+}
+function utf8LengthStrict(s) {
+  let n = 0;
+  for (let i = 0;i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c < 128)
+      n += 1;
+    else if (c < 2048)
+      n += 2;
+    else if (c >= 55296 && c <= 56319) {
+      const d = i + 1 < s.length ? s.charCodeAt(i + 1) : 0;
+      if (d < 56320 || d > 57343)
+        return -1;
+      n += 4;
+      i++;
+    } else if (c >= 56320 && c <= 57343)
+      return -1;
+    else
+      n += 3;
+  }
+  return n;
+}
+function parseLargeInts(text, mode) {
+  let i = 0;
+  const ws = () => {
+    while (i < text.length && (text[i] === " " || text[i] === `
+` || text[i] === "\r" || text[i] === "\t"))
+      i++;
+  };
+  const value = () => {
+    ws();
+    const c = text[i];
+    if (c === "{") {
+      i++;
+      const o = {};
+      ws();
+      if (text[i] === "}") {
+        i++;
+        return o;
+      }
+      for (;; ) {
+        ws();
+        const k = value();
+        ws();
+        i++;
+        o[k] = value();
+        ws();
+        if (text[i++] === "}")
+          return o;
+      }
+    }
+    if (c === "[") {
+      i++;
+      const a = [];
+      ws();
+      if (text[i] === "]") {
+        i++;
+        return a;
+      }
+      for (;; ) {
+        a.push(value());
+        ws();
+        if (text[i++] === "]")
+          return a;
+      }
+    }
+    if (c === '"') {
+      const start = i++;
+      while (text[i] !== '"')
+        i += text[i] === "\\" ? 2 : 1;
+      i++;
+      return JSON.parse(text.slice(start, i));
+    }
+    const start = i;
+    while (i < text.length && !`,}] 
+\r	`.includes(text[i]))
+      i++;
+    const lex = text.slice(start, i);
+    if (lex === "true")
+      return true;
+    if (lex === "false")
+      return false;
+    if (lex === "null")
+      return null;
+    if (/^-?\d+$/.test(lex)) {
+      const n = Number(lex);
+      if (!Number.isSafeInteger(n))
+        return mode === "bigint" ? BigInt(lex) : lex;
+      return n;
+    }
+    return Number(lex);
+  };
+  return value();
+}
+
+class GcfCodec {
+  exports;
+  constructor(exports) {
+    this.exports = exports;
+  }
+  static async instantiate(wasm) {
+    const instance = wasm instanceof WebAssembly.Module ? await WebAssembly.instantiate(wasm, {}) : (await WebAssembly.instantiate(wasm, {})).instance;
+    return new GcfCodec(instance.exports);
+  }
+  load(input) {
+    const x = this.exports;
+    if (typeof input !== "string") {
+      const ptr = x.gcf_input_alloc(input.length);
+      new Uint8Array(x.memory.buffer, ptr, input.length).set(input);
+      return input.length;
+    }
+    const cap = input.length * 3;
+    const ptr = x.gcf_input_alloc(cap);
+    return utf8.encodeInto(input, new Uint8Array(x.memory.buffer, ptr, cap)).written;
+  }
+  output(status) {
+    const x = this.exports;
+    const text = (p, n) => fromUtf8.decode(new Uint8Array(x.memory.buffer, p, n));
+    if (status !== 0) {
+      throw new GcfError(text(x.gcf_error_name_ptr(), x.gcf_error_name_len()), text(x.gcf_error_message_ptr(), x.gcf_error_message_len()), x.gcf_error_line());
+    }
+    return text(x.gcf_output_ptr(), x.gcf_output_len());
+  }
+  outputBytes(status, view) {
+    if (status !== 0)
+      this.output(status);
+    const x = this.exports;
+    const bytes = new Uint8Array(x.memory.buffer, x.gcf_output_ptr(), x.gcf_output_len());
+    return view ? bytes : bytes.slice();
+  }
+  run(fn, input) {
+    return this.output(fn.call(this.exports, this.load(input)));
+  }
+  parse(json, mode) {
+    if (!this.exports.gcf_output_unsafe_ints() || mode === "number")
+      return JSON.parse(json);
+    if (mode === "error") {
+      const m = /-?\d{16,}/.exec(json);
+      throw new GcfError("unsafe_integer", `integer ${m ? m[0] : ""} exceeds the safe-integer range (2^53-1) of a JavaScript number; decode with largeInt 'string' | 'bigint' | 'number', or model the value as a string`, 0);
+    }
+    return parseLargeInts(json, mode);
+  }
+  decodeToJson(input) {
+    return this.output(this.exports.gcf_decode(this.load(input)));
+  }
+  decode(input, opts = {}) {
+    const mode = opts.largeInt ?? "error";
+    if (typeof input === "string" && isPlainGraph(input)) {
+      const cols = this.parse(this.output(this.exports.gcf_decode_graph_columns(this.load(input))), mode);
+      return GcfCodec.graphFromColumns(cols);
+    }
+    return this.parse(this.decodeToJson(input), mode);
+  }
+  decodeLazy(input, opts = {}) {
+    const tape = this.outputBytes(this.exports.gcf_decode_tape(this.load(input)), false);
+    return new LazyTape(tape.buffer, opts.largeInt ?? "error").root();
+  }
+  static graphFromColumns(c) {
+    const { names, kinds, provs, types, statuses, k, p, s, d, es, et, ty, st } = c;
+    const n = k.length;
+    const symbols = new Array(n);
+    for (let i = 0;i < n; i++) {
+      symbols[i] = { qualifiedName: names[i], kind: kinds[k[i]], score: s[i], provenance: provs[p[i]], distance: d[i] };
+    }
+    const m = es.length;
+    const edges = new Array(m);
+    for (let j = 0;j < m; j++) {
+      edges[j] = { source: names[es[j]], target: names[et[j]], edgeType: types[ty[j]], status: statuses[st[j]] };
+    }
+    const out = { tool: c.tool, tokenBudget: c.tokenBudget, tokensUsed: c.tokensUsed, packRoot: c.packRoot };
+    if (c.unchanged)
+      out.unchanged = true;
+    if (c.session)
+      out.session = true;
+    out.symbols = symbols;
+    out.edges = edges;
+    if (c.references)
+      out.references = c.references;
+    return out;
+  }
+  encodeJsonBytes(json, opts = {}) {
+    const len = this.load(json);
+    const status = opts.profile === "graph" ? this.exports.gcf_encode_graph(len) : this.exports.gcf_encode(len, opts.noFlatten ? 1 : 0);
+    return this.outputBytes(status, opts.view ?? false);
+  }
+  decodeToJsonBytes(gcf, opts = {}) {
+    return this.outputBytes(this.exports.gcf_decode(this.load(gcf)), opts.view ?? false);
+  }
+  encode(value, opts = {}) {
+    const x = this.exports;
+    if (x.gcf_features && (x.gcf_features() & 2) !== 0) {
+      let text;
+      try {
+        text = JSON.stringify(value);
+      } catch {
+        text = undefined;
+      }
+      if (text !== undefined)
+        return this.output(x.gcf_encode(this.load(text), (opts.noFlatten ? 1 : 0) | 2));
+    }
+    return this.encodeJson(toJsonText(value), opts);
+  }
+  encodeJson(json, opts = {}) {
+    return this.output(this.exports.gcf_encode(this.load(json), opts.noFlatten ? 1 : 0));
+  }
+  encodeGraph(payload) {
+    if (this.exports.gcf_encode_graph_cols) {
+      const out = this.encodeGraphColumns(payload);
+      if (out !== null)
+        return out;
+    }
+    return this.run(this.exports.gcf_encode_graph, toJsonText(payload));
+  }
+  encodeGraphColumns(p) {
+    if (!isPlainRecord(p))
+      return null;
+    const syms = Array.isArray(p.symbols) && p.symbols.toJSON === undefined ? p.symbols : [];
+    const edges = Array.isArray(p.edges) && p.edges.toJSON === undefined ? p.edges : [];
+    const ns = syms.length;
+    const ne = edges.length;
+    const parts = new Array(2 + 3 * ns + 4 * ne);
+    const nums = new Float64Array(2 + 2 * ns);
+    let k = 0;
+    let bail = false;
+    const str = (v) => {
+      if (typeof v === "string")
+        return v;
+      if (v !== null && typeof v === "object")
+        bail = true;
+      return "";
+    };
+    const num = (v) => {
+      if (typeof v === "number")
+        return Number.isFinite(v) && v !== 0 ? v : 0;
+      if (typeof v === "bigint" || v !== null && typeof v === "object" || typeof v === "string" && utf8LengthStrict(v) < 0)
+        bail = true;
+      return 0;
+    };
+    parts[k++] = str(p.tool);
+    parts[k++] = str(p.packRoot);
+    nums[0] = num(p.tokenBudget);
+    nums[1] = num(p.tokensUsed);
+    for (let i = 0;i < ns; i++) {
+      const s = syms[i];
+      if (s !== null && typeof s === "object" && !Array.isArray(s)) {
+        if (!isPlainRecord(s))
+          return null;
+        parts[k++] = str(s.qualifiedName);
+        parts[k++] = str(s.kind);
+        parts[k++] = str(s.provenance);
+        nums[2 + 2 * i] = num(s.score);
+        nums[3 + 2 * i] = num(s.distance);
+      } else {
+        parts[k++] = "";
+        parts[k++] = "";
+        parts[k++] = "";
+      }
+    }
+    for (let i = 0;i < ne; i++) {
+      const e = edges[i];
+      if (e !== null && typeof e === "object" && !Array.isArray(e)) {
+        if (!isPlainRecord(e))
+          return null;
+        parts[k++] = str(e.source);
+        parts[k++] = str(e.target);
+        parts[k++] = str(e.edgeType);
+        parts[k++] = str(e.status);
+      } else {
+        parts[k++] = "";
+        parts[k++] = "";
+        parts[k++] = "";
+        parts[k++] = "";
+      }
+    }
+    if (bail)
+      return null;
+    const joined = parts.join("");
+    const head = 48 + 40 * ns + 32 * ne;
+    const cap = head + 3 * joined.length;
+    const x = this.exports;
+    const ptr = x.gcf_input_alloc(cap);
+    const buf = x.memory.buffer;
+    const written = utf8.encodeInto(joined, new Uint8Array(buf, ptr + head, cap - head)).written;
+    const lens = new Uint32Array(parts.length);
+    if (written === joined.length) {
+      for (let i = 0;i < parts.length; i++)
+        lens[i] = parts[i].length;
+    } else {
+      for (let i = 0;i < parts.length; i++) {
+        const n = utf8LengthStrict(parts[i]);
+        if (n < 0)
+          return null;
+        lens[i] = n;
+      }
+    }
+    const u32 = new Uint32Array(buf, ptr, head >>> 2);
+    const f64 = new Float64Array(buf, ptr, head >>> 3);
+    u32[0] = 1195787079;
+    u32[1] = ns;
+    u32[2] = ne;
+    u32[3] = head;
+    let off = 0;
+    let j = 0;
+    const put = (at) => {
+      u32[at] = off;
+      u32[at + 1] = lens[j];
+      off += lens[j++];
+    };
+    put(4);
+    put(6);
+    f64[4] = nums[0];
+    f64[5] = nums[1];
+    for (let i = 0;i < ns; i++) {
+      f64[6 + 5 * i] = nums[2 + 2 * i];
+      f64[7 + 5 * i] = nums[3 + 2 * i];
+      const w = 16 + 10 * i;
+      put(w);
+      put(w + 2);
+      put(w + 4);
+    }
+    const e0 = 12 + 10 * ns;
+    for (let i = 0;i < ne; i++) {
+      const w = e0 + 8 * i;
+      put(w);
+      put(w + 2);
+      put(w + 4);
+      put(w + 6);
+    }
+    return this.output(x.gcf_encode_graph_cols(head + written));
+  }
+  encodeGraphDelta(delta) {
+    return this.run(this.exports.gcf_encode_graph_delta, toJsonText(delta));
+  }
+  encodeGrouped(data, keyField, groupField) {
+    return this.run(this.exports.gcf_encode_grouped, toJsonText({ data, keyField, groupField }));
+  }
+  encodeGenericFull(set, tool = "") {
+    return this.run(this.exports.gcf_encode_generic_full, toJsonText({ set, tool }));
+  }
+  encodeGenericDelta(delta) {
+    return this.run(this.exports.gcf_encode_generic_delta, toJsonText(delta));
+  }
+  encodeGenericDiff(base, next, opts = {}) {
+    return this.run(this.exports.gcf_generic_diff, toJsonText({ base, next, ...opts }));
+  }
+  packRoot(input) {
+    return this.run(this.exports.gcf_pack_root, toJsonText(input));
+  }
+  applyGenericDelta(wire, base, expectedNewRoot) {
+    return this.run(this.exports.gcf_delta_decode_apply, toJsonText({ wire, base, expectedNewRoot }));
+  }
+  applyGraphDelta(wire, base) {
+    return JSON.parse(this.run(this.exports.gcf_graph_delta_apply, toJsonText({ wire, base })));
+  }
+  encodeGraphSessionRaw(payload, known, next) {
+    return this.run(this.exports.gcf_encode_graph_session, toJsonText({ payload, known, next }));
+  }
+}
+var GcfDecoder = GcfCodec;
+
+class GraphSession {
+  ids = new Map;
+  nextId = 0;
+  codec;
+  constructor(codec) {
+    this.codec = codec;
+  }
+  encode(payload) {
+    const known = {};
+    for (const s of payload.symbols) {
+      const id = this.ids.get(s.qualifiedName);
+      if (id !== undefined)
+        known[s.qualifiedName] = id;
+    }
+    const wire = this.codec.encodeGraphSessionRaw(payload, known, this.nextId);
+    for (const s of payload.symbols) {
+      if (!this.ids.has(s.qualifiedName))
+        this.ids.set(s.qualifiedName, this.nextId++);
+    }
+    return wire;
+  }
+  get size() {
+    return this.ids.size;
+  }
+  reset() {
+    this.ids.clear();
+    this.nextId = 0;
+  }
+}
+var DEFAULT_REANCHOR_N = 15;
+function utf8Length(s) {
+  let n = 0;
+  for (let i = 0;i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c < 128)
+      n += 1;
+    else if (c < 2048)
+      n += 2;
+    else if (c >= 55296 && c <= 56319) {
+      n += 4;
+      i++;
+    } else
+      n += 3;
+  }
+  return n;
+}
+
+class GenericDeltaSession {
+  turnCount = 0;
+  cum = 0;
+  policy;
+  codec;
+  base;
+  tool;
+  constructor(codec, base, tool = "", policy = { mode: "fixedN", n: DEFAULT_REANCHOR_N }) {
+    this.codec = codec;
+    this.base = base;
+    this.tool = tool;
+    this.policy = policy.mode === "fixedN" && policy.n <= 0 ? { mode: "fixedN", n: DEFAULT_REANCHOR_N } : policy;
+  }
+  currentFull() {
+    return this.codec.encodeGenericFull(this.base, this.tool);
+  }
+  turn() {
+    return this.turnCount;
+  }
+  next(nextSet) {
+    this.turnCount++;
+    const sameSchema = nextSet.key === this.base.key && nextSet.fields.length === this.base.fields.length && nextSet.fields.every((f, i) => f === this.base.fields[i]);
+    if (!sameSchema)
+      return { wire: this.reanchor(nextSet), isFull: true };
+    const deltaWire = this.codec.encodeGenericDiff(this.base, nextSet);
+    const reanchor = this.policy.mode === "sizeGuard" ? this.cum + utf8Length(deltaWire) >= utf8Length(this.codec.encodeGenericFull(nextSet, this.tool)) : this.turnCount % this.policy.n === 0;
+    if (reanchor)
+      return { wire: this.reanchor(nextSet), isFull: true };
+    this.base = nextSet;
+    this.cum += utf8Length(deltaWire);
+    return { wire: deltaWire, isFull: false };
+  }
+  reanchor(nextSet) {
+    this.base = nextSet;
+    this.cum = 0;
+    return this.codec.encodeGenericFull(nextSet, this.tool);
+  }
+}
+var TAPE_HEADER = 20;
+var textDecoder = new TextDecoder;
+var lazyNodes = new WeakMap;
+
+class LazyTape {
+  w;
+  pool;
+  dv;
+  rootIndex;
+  keyText = new Map;
+  keyOffset = new Map;
+  proxies = new Map;
+  largeInt;
+  constructor(buf, largeInt) {
+    this.largeInt = largeInt;
+    const h = new Uint32Array(buf, 0, 5);
+    if (h[0] !== 1413890887 || h[1] !== 1)
+      throw new GcfError("invalid_input", "not a GCF tape", 0);
+    this.rootIndex = h[2];
+    this.w = new Uint32Array(buf, TAPE_HEADER, h[3]);
+    this.pool = new Uint8Array(buf, TAPE_HEADER + h[3] * 4, h[4]);
+    this.dv = new DataView(buf);
+  }
+  root() {
+    return this.value(this.rootIndex);
+  }
+  text(off, len) {
+    const p = this.pool;
+    if (len <= 24) {
+      let s = "";
+      for (let i = off, end = off + len;i < end; i++) {
+        const b = p[i];
+        if (b >= 128)
+          return textDecoder.decode(p.subarray(off, off + len));
+        s += String.fromCharCode(b);
+      }
+      return s;
+    }
+    return textDecoder.decode(p.subarray(off, off + len));
+  }
+  key(off, len) {
+    let k = this.keyText.get(off);
+    if (k === undefined) {
+      k = this.text(off, len);
+      this.keyText.set(off, k);
+      this.keyOffset.set(k, off);
+    }
+    return k;
+  }
+  int64(i) {
+    const lo = this.w[i + 1];
+    const hi = this.w[i + 2] | 0;
+    const n = hi * 4294967296 + lo;
+    if (Number.isSafeInteger(n))
+      return n;
+    const big = BigInt(hi) << 32n | BigInt(lo);
+    switch (this.largeInt) {
+      case "bigint":
+        return big;
+      case "string":
+        return big.toString();
+      case "number":
+        return Number(big);
+      default:
+        throw new GcfError("unsafe_integer", `integer ${big} exceeds the safe-integer range (2^53-1) of a JavaScript number; decode with largeInt 'string' | 'bigint' | 'number'`, 0);
+    }
+  }
+  value(i) {
+    const h = this.w[i];
+    switch (h & 15) {
+      case 0:
+        return null;
+      case 1:
+        return false;
+      case 2:
+        return true;
+      case 3:
+        return (h | 0) >> 4;
+      case 4:
+        return this.int64(i);
+      case 5:
+        return this.dv.getFloat64(TAPE_HEADER + (i + 1) * 4, true);
+      case 6:
+        return this.text(this.w[i + 1], h >>> 4);
+      default: {
+        let p = this.proxies.get(i);
+        if (p === undefined) {
+          p = (h & 15) === 7 ? this.arrayProxy(i) : this.objectProxy(i);
+          this.proxies.set(i, p);
+          lazyNodes.set(p, [this, i]);
+        }
+        return p;
+      }
+    }
+  }
+  find(i, name) {
+    const n = this.w[i] >>> 4;
+    const base = i + 1;
+    const w = this.w;
+    const off = this.keyOffset.get(name);
+    if (off !== undefined) {
+      for (let k = 0, j = base;k < n; k++, j += 3)
+        if (w[j] === off)
+          return w[j + 2];
+      return -1;
+    }
+    for (let k = 0, j = base;k < n; k++, j += 3) {
+      if (this.key(w[j], w[j + 1]) === name)
+        return w[j + 2];
+    }
+    return -1;
+  }
+  keys(i) {
+    const n = this.w[i] >>> 4;
+    const out = new Array(n);
+    for (let k = 0, j = i + 1;k < n; k++, j += 3)
+      out[k] = this.key(this.w[j], this.w[j + 1]);
+    return out;
+  }
+  objectProxy(i) {
+    const tape = this;
+    const readOnly = () => false;
+    return new Proxy({}, {
+      get(t, prop, receiver) {
+        if (typeof prop === "string") {
+          const c = tape.find(i, prop);
+          if (c >= 0)
+            return tape.value(c);
+        }
+        return Reflect.get(t, prop, receiver);
+      },
+      has(t, prop) {
+        return typeof prop === "string" && tape.find(i, prop) >= 0 || Reflect.has(t, prop);
+      },
+      ownKeys() {
+        return tape.keys(i);
+      },
+      getOwnPropertyDescriptor(_t, prop) {
+        if (typeof prop !== "string")
+          return;
+        const c = tape.find(i, prop);
+        return c < 0 ? undefined : { value: tape.value(c), writable: false, enumerable: true, configurable: true };
+      },
+      set: readOnly,
+      defineProperty: readOnly,
+      deleteProperty: readOnly
+    });
+  }
+  arrayProxy(i) {
+    const tape = this;
+    const n = this.w[i] >>> 4;
+    const index = (prop) => {
+      if (typeof prop !== "string" || prop.length === 0)
+        return -1;
+      const c = prop.charCodeAt(0);
+      if (c < 48 || c > 57)
+        return -1;
+      const k = Number(prop);
+      return Number.isInteger(k) && k < n && String(k) === prop ? k : -1;
+    };
+    const readOnly = () => false;
+    return new Proxy(new Array(n), {
+      get(t, prop, receiver) {
+        const k = index(prop);
+        if (k >= 0)
+          return tape.value(tape.w[i + 1 + k]);
+        return Reflect.get(t, prop, receiver);
+      },
+      has(t, prop) {
+        return index(prop) >= 0 || Reflect.has(t, prop);
+      },
+      ownKeys() {
+        const keys = new Array(n + 1);
+        for (let k = 0;k < n; k++)
+          keys[k] = String(k);
+        keys[n] = "length";
+        return keys;
+      },
+      getOwnPropertyDescriptor(t, prop) {
+        const k = index(prop);
+        if (k >= 0)
+          return { value: tape.value(tape.w[i + 1 + k]), writable: false, enumerable: true, configurable: true };
+        return Reflect.getOwnPropertyDescriptor(t, prop);
+      },
+      set: readOnly,
+      defineProperty: readOnly,
+      deleteProperty: readOnly
+    });
+  }
+  plain(i) {
+    const h = this.w[i];
+    const tag = h & 15;
+    if (tag === 7) {
+      const n = h >>> 4;
+      const out = new Array(n);
+      for (let k = 0;k < n; k++)
+        out[k] = this.plain(this.w[i + 1 + k]);
+      return out;
+    }
+    if (tag === 8) {
+      const n = h >>> 4;
+      const out = {};
+      for (let k = 0, j = i + 1;k < n; k++, j += 3)
+        out[this.key(this.w[j], this.w[j + 1])] = this.plain(this.w[j + 2]);
+      return out;
+    }
+    return this.value(i);
+  }
+}
+function toPlain(value) {
+  if (value === null || typeof value !== "object")
+    return value;
+  const node = lazyNodes.get(value);
+  return node ? node[0].plain(node[1]) : value;
+}
+var JSON_NUMBER_RE = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+var NUMERIC_LIKE_RE = /^[+-]\.?\d|^\.\d|^0\d/;
+var INLINE_ARRAY_RE = /\[[^\]]*\][ \t\n\v\f\r]*:/;
+var BARE_KEY_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+function needsQuote(s) {
+  if (s === "" || s === "-" || s === "~" || s === "^" || s === "true" || s === "false")
+    return true;
+  if (s.length >= 3 && s[0] === "^" && s[1] === "{" && s[s.length - 1] === "}")
+    return true;
+  if (JSON_NUMBER_RE.test(s) || NUMERIC_LIKE_RE.test(s))
+    return true;
+  if (s[0] === " " || s[s.length - 1] === " " || s[0] === "#" || s[0] === "@" || s[0] === ".")
+    return true;
+  if (INLINE_ARRAY_RE.test(s))
+    return true;
+  for (let i = 0;i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c === 34 || c === 92 || c < 32 || c === 124 || c === 44)
+      return true;
+    if (c >= 128 && (c <= 160 || c === 5760 || c >= 8192 && c <= 8202 || c === 8232 || c === 8233 || c === 8239 || c === 8287 || c === 12288 || c === 65279))
+      return true;
+  }
+  return false;
+}
+function quoteString(s) {
+  let out = '"';
+  for (let i = 0;i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c === 34)
+      out += "\\\"";
+    else if (c === 92)
+      out += "\\\\";
+    else if (c === 8)
+      out += "\\b";
+    else if (c === 12)
+      out += "\\f";
+    else if (c === 10)
+      out += "\\n";
+    else if (c === 13)
+      out += "\\r";
+    else if (c === 9)
+      out += "\\t";
+    else if (c < 32)
+      out += "\\u" + c.toString(16).padStart(4, "0");
+    else
+      out += s[i];
+  }
+  return out + '"';
+}
+function formatKey(k) {
+  return BARE_KEY_RE.test(k) ? k : quoteString(k);
+}
+var I64_MIN = -9223372036854775808n;
+var I64_MAX = 9223372036854775807n;
+function formatNumber(f) {
+  if (!Number.isFinite(f))
+    throw new GcfError("invalid_input", `non-finite number ${f} is outside the JSON data model`, 0);
+  if (f === 0)
+    return "0";
+  const a = Math.abs(f);
+  if (a >= 0.000001 && a < 9007199254740992)
+    return String(f);
+  return f.toExponential().replace(/e\+?0*(\d)/, "e+$1").replace(/e-0*(\d)/, "e-$1");
+}
+function formatScalar(v) {
+  if (v === null || v === undefined)
+    return "-";
+  if (typeof v === "boolean")
+    return v ? "true" : "false";
+  if (typeof v === "number")
+    return formatNumber(v);
+  if (typeof v === "bigint") {
+    if (v < I64_MIN || v > I64_MAX)
+      throw new GcfError("out_of_range", `integer ${v} is outside int64; model it as a string`, 0);
+    return v.toString();
+  }
+  const s = String(v);
+  return needsQuote(s) ? quoteString(s) : s;
+}
+function formatScore(x) {
+  if (!Number.isFinite(x))
+    return "0.00";
+  const neg = x < 0;
+  const exact = Math.abs(x).toFixed(20);
+  const dot = exact.indexOf(".");
+  const keep = exact.slice(dot + 1, dot + 3);
+  const rest = exact.slice(dot + 3);
+  const first = rest.charCodeAt(0) - 48;
+  const up = first > 5 || first === 5 && (/[1-9]/.test(rest.slice(1)) || (keep.charCodeAt(1) - 48) % 2 === 1);
+  let cents = parseInt(exact.slice(0, dot), 10) * 100 + parseInt(keep, 10) + (up ? 1 : 0);
+  const whole = Math.floor(cents / 100);
+  cents %= 100;
+  return `${neg ? "-" : ""}${whole}.${String(cents).padStart(2, "0")}`;
+}
+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 groupName = (d) => d === 0 ? "targets" : d === 1 ? "related" : d === 2 ? "extended" : `distance_${d}`;
+
+class GraphStreamEncoder {
+  ids = new Map;
+  nextId = 0;
+  group = "";
+  groupCounts = new Map;
+  edges = 0;
+  edgesStarted = false;
+  w;
+  opts;
+  constructor(w, tool, opts = {}) {
+    this.w = w;
+    this.opts = opts;
+    let h = "GCF profile=graph";
+    if (tool)
+      h += ` tool=${tool}`;
+    if (opts.tokenBudget)
+      h += ` budget=${opts.tokenBudget}`;
+    if (opts.tokensUsed)
+      h += ` tokens=${opts.tokensUsed}`;
+    if (opts.packRoot)
+      h += ` pack_root=${opts.packRoot}`;
+    if (opts.session)
+      h += " session=true";
+    w.write(h + `
+`);
+  }
+  enterGroup(distance) {
+    const g = groupName(distance);
+    if (g !== this.group) {
+      this.w.write(`## ${g}
+`);
+      this.group = g;
+    }
+    this.groupCounts.set(g, (this.groupCounts.get(g) ?? 0) + 1);
+    return g;
+  }
+  writeSymbol(s) {
+    this.enterGroup(s.distance ?? 0);
+    const id = this.nextId++;
+    this.ids.set(s.qualifiedName, id);
+    this.w.write(`@${id} ${KIND_ABBREV[s.kind] ?? s.kind} ${s.qualifiedName} ${formatScore(s.score)} ${s.provenance}
+`);
+  }
+  writeBareRef(qualifiedName, distance) {
+    this.enterGroup(distance);
+    const id = this.nextId++;
+    this.ids.set(qualifiedName, id);
+    this.w.write(`@${id}  # previously transmitted
+`);
+  }
+  writeEdge(e) {
+    const src = this.ids.get(e.source);
+    const tgt = this.ids.get(e.target);
+    if (src === undefined || tgt === undefined)
+      return;
+    if (!this.edgesStarted) {
+      this.w.write(`## edges [?]
+`);
+      this.edgesStarted = true;
+    }
+    const status = e.status && e.status !== "unchanged" ? ` ${e.status}` : "";
+    this.w.write(`@${tgt}<@${src} ${e.edgeType}${status}
+`);
+    this.edges++;
+  }
+  close() {
+    const parts = [...this.groupCounts].filter(([, c]) => c > 0).map(([g, c]) => `${g}:${c}`);
+    parts.push(`edges:${this.edges}`);
+    const counts = this.opts.labeledTrailerCounts ? parts.join(",") : parts.map((p) => p.split(":")[1]).join(",");
+    this.w.write(`##! summary symbols=${this.nextId} edges=${this.edges} counts=${counts}
+`);
+  }
+}
+
+class GenericStreamEncoder {
+  sections = [];
+  current = null;
+  w;
+  constructor(w) {
+    this.w = w;
+    w.write(`GCF profile=generic
+`);
+  }
+  checkFields(fields) {
+    for (const f of fields) {
+      if (f.includes(">"))
+        throw new GcfError("invalid_input", `streaming field name ${JSON.stringify(f)} contains '>' (a flattened path is not representable in a streaming row)`, 0);
+    }
+  }
+  beginArray(name, fields) {
+    this.checkFields(fields);
+    this.endArray();
+    this.w.write(`## ${formatKey(name)} [?]{${fields.map(formatKey).join(",")}}
+`);
+    this.current = { count: 0 };
+  }
+  beginKeyedMap(name, keyLabel, valueFields) {
+    this.checkFields(valueFields);
+    this.endArray();
+    this.w.write(`## ${formatKey(name)} [?:]{${[keyLabel, ...valueFields].map(formatKey).join(",")}}
+`);
+    this.current = { count: 0 };
+  }
+  writeRow(values) {
+    if (!this.current)
+      throw new GcfError("invalid_input", "writeRow outside beginArray/beginKeyedMap", 0);
+    this.w.write(values.map(formatScalar).join("|") + `
+`);
+    this.current.count++;
+  }
+  endArray() {
+    if (this.current)
+      this.sections.push(this.current.count);
+    this.current = null;
+  }
+  writeKV(key, value) {
+    this.endArray();
+    this.w.write(`${formatKey(key)}=${formatScalar(value)}
+`);
+  }
+  writeInlineArray(name, values) {
+    this.endArray();
+    this.w.write(`${formatKey(name)}[${values.length}]: ${values.map(formatScalar).join(",")}
+`);
+  }
+  close() {
+    this.endArray();
+    if (this.sections.length > 0)
+      this.w.write(`##! summary counts=${this.sections.join(",")}
+`);
+  }
+}
+// src/index.ts
+var shared;
+async function wasmBytes(source) {
+  if (source instanceof URL || typeof source === "string") {
+    const url = source instanceof URL ? source : new URL(source, import.meta.url);
+    if (url.protocol === "file:") {
+      const { readFile } = await import("node:fs/promises");
+      return readFile(url);
+    }
+    source = fetch(url);
+  }
+  const res = await source;
+  if (!res.ok)
+    throw new Error(`failed to load gcf.wasm: HTTP ${res.status}`);
+  return res.arrayBuffer();
+}
+function init(source) {
+  if (source === undefined) {
+    shared ??= wasmBytes(new URL("./gcf.wasm", import.meta.url)).then((b) => GcfCodec.instantiate(b));
+    return shared;
+  }
+  if (source instanceof WebAssembly.Module || source instanceof ArrayBuffer || ArrayBuffer.isView(source)) {
+    return GcfCodec.instantiate(source);
+  }
+  return wasmBytes(source).then((b) => GcfCodec.instantiate(b));
+}
+export {
+  DEFAULT_REANCHOR_N,
+  GcfCodec,
+  GcfDecodeError,
+  GcfDecoder,
+  GcfError,
+  GenericDeltaSession,
+  GenericStreamEncoder,
+  GraphSession,
+  GraphStreamEncoder,
+  formatKey,
+  formatNumber,
+  formatScalar,
+  formatScore,
+  init,
+  needsQuote,
+  quoteString,
+  toPlain
+};