@felixdrp/gcf-wasm 0.0.0-stage → 0.1.0

package/dist/cli.js

@@ -0,0 +1,712 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { readFileSync } from "node:fs";
+
+// 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 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 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);
+  }
+}
+var I64_MIN = -9223372036854775808n;
+
+// src/cli.ts
+var USAGE = `usage:
+  gcf encode [file] [--graph] [--no-flatten]   JSON -> GCF (stdin if no file)
+  gcf decode [file] [--large-int=error|string|bigint|number]
+  gcf stats  [file] [--graph]                  JSON vs GCF size and estimated tokens`;
+function main(argv, gcf) {
+  const [command, ...rest] = argv;
+  if (command === "--help" || command === "-h") {
+    console.log(USAGE);
+    return 0;
+  }
+  if (command !== "encode" && command !== "decode" && command !== "stats") {
+    console.error(USAGE);
+    return command ? 1 : 0;
+  }
+  const flags = new Set(rest.filter((a) => a.startsWith("--")));
+  const file = rest.find((a) => !a.startsWith("--"));
+  const input = readFileSync(file && file !== "-" ? file : 0, "utf8");
+  const isGraphPayload = (json) => {
+    if (flags.has("--graph"))
+      return true;
+    try {
+      const v = JSON.parse(json);
+      return v !== null && typeof v === "object" && Array.isArray(v.symbols) && Array.isArray(v.edges ?? []);
+    } catch {
+      return false;
+    }
+  };
+  const encode = (json) => isGraphPayload(json) ? gcf.encodeGraph(JSON.parse(json)) : gcf.encodeJson(json, { noFlatten: flags.has("--no-flatten") });
+  try {
+    if (command === "encode") {
+      process.stdout.write(encode(input));
+    } else if (command === "decode") {
+      const mode = [...flags].find((f) => f.startsWith("--large-int="))?.split("=")[1];
+      const value = gcf.decode(input, { largeInt: mode ?? "string" });
+      console.log(JSON.stringify(value, (_k, v) => typeof v === "bigint" ? v.toString() : v, 2));
+    } else {
+      const out = encode(input);
+      const jsonTokens = Math.round(input.trim().length / 4);
+      const gcfTokens = Math.round(out.trim().length / 4);
+      const bar = (n) => "█".repeat(Math.max(1, Math.round(30 * n / Math.max(jsonTokens, 1)))).padEnd(30, "░");
+      console.log(`JSON  ${bar(jsonTokens)}  ${input.length} chars  ~${jsonTokens} tokens`);
+      console.log(`GCF   ${bar(gcfTokens)}  ${out.length} chars  ~${gcfTokens} tokens`);
+      console.log(`
+~${Math.round(100 * (1 - gcfTokens / Math.max(jsonTokens, 1)))}% fewer tokens (estimate: 4 chars/token)`);
+    }
+    return 0;
+  } catch (e) {
+    if (e instanceof GcfError) {
+      console.error(`gcf: ${e.message}`);
+      return 2;
+    }
+    throw e;
+  }
+}
+// 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));
+}
+
+// src/cli-npm.ts
+process.exitCode = main(process.argv.slice(2), await init());