@query-farm/vgi 0.15.0 → 0.18.0

package/dist/client-entry.js

@@ -1,3 +1,3864 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/arrow/predicates.ts
+var TypeId = {
+  Null: 1,
+  Int: 2,
+  Float: 3,
+  Binary: 4,
+  Utf8: 5,
+  Bool: 6,
+  Decimal: 7,
+  Date: 8,
+  Time: 9,
+  Timestamp: 10,
+  Interval: 11,
+  List: 12,
+  Struct: 13,
+  Union: 14,
+  FixedSizeBinary: 15,
+  FixedSizeList: 16,
+  Map: 17,
+  Duration: 18,
+  LargeBinary: 19,
+  LargeUtf8: 20,
+  Dictionary: -1
+};
+function isInt(t) {
+  return t.typeId === TypeId.Int;
+}
+function isBinary(t) {
+  return t.typeId === TypeId.Binary || t.typeId === TypeId.LargeBinary;
+}
+function isBool(t) {
+  return t.typeId === TypeId.Bool;
+}
+function isList(t) {
+  return t.typeId === TypeId.List;
+}
+function isStruct(t) {
+  return t.typeId === TypeId.Struct;
+}
+function isMap(t) {
+  return t.typeId === TypeId.Map;
+}
+function isDictionary(t) {
+  return t.typeId === TypeId.Dictionary;
+}
+// src/arrow/impl-arrowjs/index.ts
+var exports_impl_arrowjs = {};
+__export(exports_impl_arrowjs, {
+  utf8: () => utf8,
+  union: () => union,
+  uint8: () => uint8,
+  uint64: () => uint64,
+  uint32: () => uint32,
+  uint16: () => uint16,
+  timestamp: () => timestamp,
+  timeSecond: () => timeSecond,
+  timeNanosecond: () => timeNanosecond,
+  timeMillisecond: () => timeMillisecond,
+  timeMicrosecond: () => timeMicrosecond,
+  time: () => time,
+  struct: () => struct,
+  sparseUnion: () => sparseUnion,
+  serializeSchema: () => serializeSchema,
+  serializeBatch: () => serializeBatch,
+  schema: () => schema,
+  safeNumber: () => safeNumber,
+  readCanonicalValue: () => readCanonicalValue,
+  projectSchema: () => projectSchema,
+  projectBatch: () => projectBatch,
+  nullType: () => nullType,
+  map: () => map,
+  list: () => list,
+  iterRows: () => iterRows,
+  interval: () => interval,
+  int8: () => int8,
+  int64: () => int64,
+  int32: () => int32,
+  int16: () => int16,
+  int: () => int,
+  float64: () => float64,
+  float32: () => float32,
+  float16: () => float16,
+  fixedSizeList: () => fixedSizeList,
+  fixedSizeBinary: () => fixedSizeBinary,
+  filterBatch: () => filterBatch,
+  field: () => field,
+  emptyBatch: () => emptyBatch,
+  duration: () => duration,
+  dictionary: () => dictionary,
+  deserializeSchema: () => deserializeSchema,
+  deserializeBatch: () => deserializeBatch,
+  denseUnion: () => denseUnion,
+  decodeDictValue: () => decodeDictValue,
+  decimal256: () => decimal256,
+  decimal128: () => decimal128,
+  decimal: () => decimal,
+  dateMillisecond: () => dateMillisecond,
+  dateDay: () => dateDay,
+  date: () => date,
+  columnFromArray: () => columnFromArray,
+  buildStatisticsBatch: () => buildStatisticsBatch,
+  bool: () => bool,
+  binary: () => binary,
+  batchToSecretDict: () => batchToSecretDict,
+  batchToScalarDict: () => batchToScalarDict,
+  batchFromRows: () => batchFromRows,
+  batchFromColumns: () => batchFromColumns,
+  backend: () => backend,
+  UnionMode: () => UnionMode,
+  TimeUnit: () => TimeUnit,
+  IntervalUnit: () => IntervalUnit,
+  DateUnit: () => DateUnit
+});
+
+// src/arrow/impl-arrowjs/schema.ts
+import {
+  Schema as A_Schema,
+  Field as A_Field,
+  Null as A_Null,
+  Bool as A_Bool,
+  Int8 as A_Int8,
+  Int16 as A_Int16,
+  Int32 as A_Int32,
+  Int64 as A_Int64,
+  Uint8 as A_Uint8,
+  Uint16 as A_Uint16,
+  Uint32 as A_Uint32,
+  Uint64 as A_Uint64,
+  Float16 as A_Float16,
+  Float32 as A_Float32,
+  Float64 as A_Float64,
+  Utf8 as A_Utf8,
+  Binary as A_Binary,
+  Decimal as A_Decimal,
+  Date_ as A_Date,
+  Time as A_Time,
+  Timestamp as A_Timestamp,
+  Duration as A_Duration,
+  Interval as A_Interval,
+  List as A_List,
+  Struct as A_Struct,
+  Map_ as A_Map,
+  Dictionary as A_Dictionary,
+  SparseUnion as A_SparseUnion,
+  DenseUnion as A_DenseUnion,
+  FixedSizeBinary as A_FixedSizeBinary,
+  FixedSizeList as A_FixedSizeList,
+  DateUnit as A_DateUnit,
+  TimeUnit as A_TimeUnit,
+  IntervalUnit as A_IntervalUnit,
+  UnionMode as A_UnionMode
+} from "@query-farm/apache-arrow";
+var TimeUnit = {
+  SECOND: A_TimeUnit.SECOND,
+  MILLISECOND: A_TimeUnit.MILLISECOND,
+  MICROSECOND: A_TimeUnit.MICROSECOND,
+  NANOSECOND: A_TimeUnit.NANOSECOND
+};
+var DateUnit = {
+  DAY: A_DateUnit.DAY,
+  MILLISECOND: A_DateUnit.MILLISECOND
+};
+var IntervalUnit = {
+  YEAR_MONTH: A_IntervalUnit.YEAR_MONTH,
+  DAY_TIME: A_IntervalUnit.DAY_TIME,
+  MONTH_DAY_NANO: A_IntervalUnit.MONTH_DAY_NANO
+};
+var UnionMode = {
+  Sparse: A_UnionMode.Sparse,
+  Dense: A_UnionMode.Dense
+};
+function schema(fields, metadata) {
+  return new A_Schema(fields, metadata ?? new Map);
+}
+function field(name, type, nullable = true, metadata) {
+  return new A_Field(name, type, nullable, metadata ?? new Map);
+}
+var nullType = () => new A_Null;
+var bool = () => new A_Bool;
+var int8 = () => new A_Int8;
+var int16 = () => new A_Int16;
+var int32 = () => new A_Int32;
+var int64 = () => new A_Int64;
+var uint8 = () => new A_Uint8;
+var uint16 = () => new A_Uint16;
+var uint32 = () => new A_Uint32;
+var uint64 = () => new A_Uint64;
+function int(bitWidth = 32, signed = true) {
+  if (signed) {
+    switch (bitWidth) {
+      case 8:
+        return int8();
+      case 16:
+        return int16();
+      case 32:
+        return int32();
+      case 64:
+        return int64();
+    }
+  } else {
+    switch (bitWidth) {
+      case 8:
+        return uint8();
+      case 16:
+        return uint16();
+      case 32:
+        return uint32();
+      case 64:
+        return uint64();
+    }
+  }
+  throw new Error(`int: unsupported bitWidth ${bitWidth}`);
+}
+var float16 = () => new A_Float16;
+var float32 = () => new A_Float32;
+var float64 = () => new A_Float64;
+var utf8 = () => new A_Utf8;
+var binary = () => new A_Binary;
+var fixedSizeBinary = (byteWidth) => new A_FixedSizeBinary(byteWidth);
+function decimal(precision, scale, bitWidth = 128) {
+  return new A_Decimal(scale, precision, bitWidth);
+}
+var decimal128 = (precision, scale) => decimal(precision, scale, 128);
+var decimal256 = (precision, scale) => decimal(precision, scale, 256);
+var date = (unit = A_DateUnit.MILLISECOND) => new A_Date(unit);
+var dateDay = () => date(A_DateUnit.DAY);
+var dateMillisecond = () => date(A_DateUnit.MILLISECOND);
+function time(unit = A_TimeUnit.MILLISECOND, bitWidth) {
+  const bw = bitWidth ?? (unit <= A_TimeUnit.MILLISECOND ? 32 : 64);
+  return new A_Time(unit, bw);
+}
+var timeSecond = () => time(A_TimeUnit.SECOND, 32);
+var timeMillisecond = () => time(A_TimeUnit.MILLISECOND, 32);
+var timeMicrosecond = () => time(A_TimeUnit.MICROSECOND, 64);
+var timeNanosecond = () => time(A_TimeUnit.NANOSECOND, 64);
+var timestamp = (unit = A_TimeUnit.MILLISECOND, timezone = null) => new A_Timestamp(unit, timezone);
+var duration = (unit = A_TimeUnit.MILLISECOND) => new A_Duration(unit);
+var interval = (unit = A_IntervalUnit.MONTH_DAY_NANO) => new A_Interval(unit);
+function list(child) {
+  const childField = isField(child) ? child : field("item", child, true);
+  return new A_List(childField);
+}
+function fixedSizeList(child, listSize) {
+  const childField = isField(child) ? child : field("item", child, true);
+  return new A_FixedSizeList(listSize, childField);
+}
+function struct(children) {
+  return new A_Struct(children);
+}
+function map(keyField, valueField, keysSorted = false) {
+  const k = isField(keyField) ? keyField : field("key", keyField, false);
+  const v = isField(valueField) ? valueField : field("value", valueField, true);
+  const entries = field("entries", struct([k, v]), false);
+  return new A_Map(entries, keysSorted);
+}
+function dictionary(valueType, indexType = int16(), ordered = false, id) {
+  return new A_Dictionary(valueType, indexType, id, ordered);
+}
+function union(mode, children, typeIds) {
+  const childFields = children.map((c, i) => isField(c) ? c : field(String(i), c, true));
+  const ids = typeIds ?? childFields.map((_, i) => i);
+  const Ctor = mode === A_UnionMode.Dense ? A_DenseUnion : A_SparseUnion;
+  return new Ctor(ids, childFields);
+}
+var sparseUnion = (children, typeIds) => union(A_UnionMode.Sparse, children, typeIds);
+var denseUnion = (children, typeIds) => union(A_UnionMode.Dense, children, typeIds);
+function isField(x) {
+  return typeof x.name === "string" && x.type != null;
+}
+// src/arrow/impl-arrowjs/empty.ts
+import {
+  RecordBatch,
+  Struct,
+  DataType,
+  makeData
+} from "@query-farm/apache-arrow";
+function emptyData(field2) {
+  const type = field2.type;
+  if (DataType.isList(type)) {
+    const childField = type.children[0];
+    return makeData({
+      type,
+      length: 0,
+      nullCount: 0,
+      child: emptyData(childField),
+      valueOffsets: new Int32Array([0])
+    });
+  }
+  if (DataType.isMap(type)) {
+    const entriesField = type.children[0];
+    return makeData({
+      type,
+      length: 0,
+      nullCount: 0,
+      child: emptyData(entriesField),
+      valueOffsets: new Int32Array([0])
+    });
+  }
+  if (DataType.isStruct(type)) {
+    const children = type.children.map((child) => emptyData(child));
+    return makeData({ type, length: 0, nullCount: 0, children });
+  }
+  return makeData({ type, length: 0, nullCount: 0 });
+}
+function emptyBatch(schema2) {
+  const a = schema2;
+  const children = a.fields.map((f) => emptyData(f));
+  const structType = new Struct(a.fields);
+  const data = makeData({
+    type: structType,
+    length: 0,
+    children,
+    nullCount: 0
+  });
+  return new RecordBatch(a, data);
+}
+// src/arrow/impl-arrowjs/build.ts
+import {
+  RecordBatch as RecordBatch2,
+  Struct as Struct3,
+  makeData as makeData3,
+  vectorFromArray as vectorFromArray2
+} from "@query-farm/apache-arrow";
+
+// src/arrow/codec/registry.ts
+var MS_PER_DAY = 86400000;
+function isNullish(v) {
+  return v === null || v === undefined;
+}
+function err(label, msg, value) {
+  let shown;
+  try {
+    shown = typeof value === "bigint" ? `${value}n` : typeof value === "object" ? Object.prototype.toString.call(value) : String(value);
+  } catch {
+    shown = "<unprintable>";
+  }
+  throw new TypeError(`codec[${label}]: ${msg} (got ${typeof value}: ${shown})`);
+}
+function identity(label, check) {
+  const conv = (value) => {
+    if (isNullish(value))
+      return null;
+    check(value);
+    return value;
+  };
+  return {
+    label,
+    richToCanonical: conv,
+    canonicalToRich: conv,
+    rawToCanonical: conv,
+    canonicalToRaw: conv
+  };
+}
+function checkBoolean(label) {
+  return (v) => {
+    if (typeof v !== "boolean")
+      err(label, "expected boolean", v);
+  };
+}
+function checkIntNumber(label, min, max) {
+  return (v) => {
+    let n;
+    if (typeof v === "number")
+      n = v;
+    else if (typeof v === "bigint") {
+      if (v < BigInt(min) || v > BigInt(max))
+        err(label, `bigint out of ${label} range`, v);
+      return;
+    } else
+      return err(label, "expected number", v);
+    if (!Number.isInteger(n))
+      err(label, "expected an integer", v);
+    if (n < min || n > max)
+      err(label, `value out of ${label} range [${min}, ${max}]`, v);
+  };
+}
+function checkFloat(label) {
+  return (v) => {
+    if (typeof v === "number")
+      return;
+    if (typeof v === "bigint")
+      return;
+    err(label, "expected number", v);
+  };
+}
+function checkBigInt(label, bits, signed) {
+  const max = signed ? (1n << BigInt(bits - 1)) - 1n : (1n << BigInt(bits)) - 1n;
+  const min = signed ? -(1n << BigInt(bits - 1)) : 0n;
+  return (v) => {
+    let b;
+    if (typeof v === "bigint")
+      b = v;
+    else if (typeof v === "number") {
+      if (!Number.isInteger(v))
+        err(label, "expected an integer", v);
+      b = BigInt(v);
+    } else
+      return err(label, "expected bigint", v);
+    if (b < min || b > max)
+      err(label, `value out of ${label} range`, v);
+  };
+}
+function checkString(label) {
+  return (v) => {
+    if (typeof v !== "string")
+      err(label, "expected string", v);
+  };
+}
+function toBigIntStrict(label, v) {
+  if (typeof v === "bigint")
+    return v;
+  if (typeof v === "number") {
+    if (!Number.isInteger(v))
+      err(label, "expected an integer value", v);
+    return BigInt(v);
+  }
+  return err(label, "expected number or bigint", v);
+}
+function bigIntToSafeNumber(label, b) {
+  if (b < -9007199254740991n || b > 9007199254740991n) {
+    err(label, "bigint overflows the safe-integer range when narrowing to number", b);
+  }
+  return Number(b);
+}
+function dateDayCodec() {
+  const label = "date32";
+  return {
+    label,
+    richToCanonical(value) {
+      if (isNullish(value))
+        return null;
+      if (value instanceof Date) {
+        const ms = value.getTime();
+        if (Number.isNaN(ms))
+          err(label, "invalid Date", value);
+        if (ms % MS_PER_DAY !== 0) {
+          return Math.floor(ms / MS_PER_DAY);
+        }
+        return ms / MS_PER_DAY;
+      }
+      if (typeof value === "number") {
+        if (!Number.isInteger(value))
+          err(label, "day-number must be an integer", value);
+        return value;
+      }
+      if (typeof value === "bigint")
+        return bigIntToSafeNumber(label, value);
+      return err(label, "expected Date, number (days), or bigint", value);
+    },
+    canonicalToRich(value) {
+      if (isNullish(value))
+        return null;
+      let days;
+      if (typeof value === "number") {
+        if (!Number.isInteger(value))
+          err(label, "canonical day-number must be an integer", value);
+        days = value;
+      } else if (typeof value === "bigint") {
+        days = bigIntToSafeNumber(label, value);
+      } else if (value instanceof Date) {
+        return value;
+      } else
+        return err(label, "expected number (days) canonical", value);
+      const ms = days * MS_PER_DAY;
+      const d = new Date(ms);
+      if (Number.isNaN(d.getTime()))
+        err(label, "day-number produces an invalid Date", value);
+      return d;
+    },
+    rawToCanonical(value) {
+      if (isNullish(value))
+        return null;
+      if (typeof value === "number") {
+        if (!Number.isInteger(value))
+          err(label, "raw day-number must be an integer", value);
+        return value;
+      }
+      if (typeof value === "bigint")
+        return bigIntToSafeNumber(label, value);
+      return err(label, "expected branded Date32 (day-number)", value);
+    },
+    canonicalToRaw(value) {
+      if (isNullish(value))
+        return null;
+      if (typeof value === "number") {
+        if (!Number.isInteger(value))
+          err(label, "canonical day-number must be an integer", value);
+        return value;
+      }
+      if (typeof value === "bigint")
+        return bigIntToSafeNumber(label, value);
+      if (value instanceof Date) {
+        const ms = value.getTime();
+        if (Number.isNaN(ms))
+          err(label, "invalid Date", value);
+        return Math.floor(ms / MS_PER_DAY);
+      }
+      return err(label, "expected number (days) canonical", value);
+    }
+  };
+}
+function dateMillisCodec() {
+  const label = "date64";
+  return {
+    label,
+    richToCanonical(value) {
+      if (isNullish(value))
+        return null;
+      if (value instanceof Date) {
+        const ms = value.getTime();
+        if (Number.isNaN(ms))
+          err(label, "invalid Date", value);
+        return BigInt(ms);
+      }
+      if (typeof value === "bigint")
+        return value;
+      if (typeof value === "number") {
+        if (!Number.isInteger(value))
+          err(label, "ms value must be an integer", value);
+        return BigInt(value);
+      }
+      return err(label, "expected Date, bigint (ms), or number", value);
+    },
+    canonicalToRich(value) {
+      if (isNullish(value))
+        return null;
+      if (value instanceof Date)
+        return value;
+      const ms = toBigIntStrict(label, value);
+      const n = bigIntToSafeNumber(label, ms);
+      const d = new Date(n);
+      if (Number.isNaN(d.getTime()))
+        err(label, "ms value produces an invalid Date", value);
+      return d;
+    },
+    rawToCanonical(value) {
+      if (isNullish(value))
+        return null;
+      if (value instanceof Date)
+        return err(label, "raw Date64Ms must be a bigint (ms), not a Date", value);
+      return toBigIntStrict(label, value);
+    },
+    canonicalToRaw(value) {
+      if (isNullish(value))
+        return null;
+      if (value instanceof Date)
+        return BigInt(value.getTime());
+      return toBigIntStrict(label, value);
+    }
+  };
+}
+function time32Codec() {
+  const label = "time32";
+  const toCanon = (value) => {
+    if (isNullish(value))
+      return null;
+    if (typeof value === "number") {
+      if (!Number.isInteger(value))
+        err(label, "time32 value must be an integer", value);
+      return value;
+    }
+    if (typeof value === "bigint")
+      return bigIntToSafeNumber(label, value);
+    return err(label, "expected number (raw time unit)", value);
+  };
+  const fromCanon = (value) => {
+    if (isNullish(value))
+      return null;
+    if (typeof value === "number")
+      return value;
+    if (typeof value === "bigint")
+      return bigIntToSafeNumber(label, value);
+    return err(label, "expected number canonical", value);
+  };
+  return {
+    label,
+    richToCanonical: toCanon,
+    canonicalToRich: fromCanon,
+    rawToCanonical: toCanon,
+    canonicalToRaw: fromCanon
+  };
+}
+function bigIntUnitCodec(label) {
+  const conv = (value) => {
+    if (isNullish(value))
+      return null;
+    return toBigIntStrict(label, value);
+  };
+  return {
+    label,
+    richToCanonical: conv,
+    canonicalToRich: conv,
+    rawToCanonical: conv,
+    canonicalToRaw: conv
+  };
+}
+function decimalViewToBigInt(view) {
+  const u8 = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+  let bi = 0n;
+  for (let i = u8.length - 1;i >= 0; i--)
+    bi = bi << 8n | BigInt(u8[i]);
+  if (u8.length > 0 && u8[u8.length - 1] & 128)
+    bi -= 1n << BigInt(u8.length * 8);
+  return bi;
+}
+function decimalCodec() {
+  const label = "decimal";
+  const toCanon = (value) => {
+    if (isNullish(value))
+      return null;
+    if (typeof value === "bigint")
+      return value;
+    if (typeof value === "number")
+      return toBigIntStrict(label, value);
+    if (ArrayBuffer.isView(value))
+      return decimalViewToBigInt(value);
+    return err(label, "expected bigint, number, or decimal byte view", value);
+  };
+  const fromCanon = (value) => {
+    if (isNullish(value))
+      return null;
+    return toCanon(value);
+  };
+  return {
+    label,
+    richToCanonical: toCanon,
+    canonicalToRich: fromCanon,
+    rawToCanonical: toCanon,
+    canonicalToRaw: fromCanon
+  };
+}
+function structCodec(type) {
+  const children = type.children;
+  const childCodecs = children.map((c) => ({ name: c.name, codec: codecFor(c.type) }));
+  const label = "struct";
+  return {
+    label,
+    richToCanonical(value) {
+      if (isNullish(value))
+        return null;
+      if (typeof value !== "object")
+        err(label, "expected an object", value);
+      const obj = value;
+      const out = {};
+      for (const { name, codec } of childCodecs) {
+        out[name] = codec.richToCanonical(obj[name] ?? null);
+      }
+      return out;
+    },
+    canonicalToRich(value) {
+      if (isNullish(value))
+        return null;
+      if (typeof value !== "object")
+        err(label, "expected an object", value);
+      const obj = value;
+      const out = {};
+      for (const { name, codec } of childCodecs) {
+        out[name] = codec.canonicalToRich(obj[name] ?? null);
+      }
+      return out;
+    },
+    rawToCanonical(value) {
+      if (isNullish(value))
+        return null;
+      if (typeof value !== "object")
+        err(label, "expected an object", value);
+      const obj = value;
+      const out = {};
+      for (const { name, codec } of childCodecs) {
+        out[name] = codec.rawToCanonical(obj[name] ?? null);
+      }
+      return out;
+    },
+    canonicalToRaw(value) {
+      if (isNullish(value))
+        return null;
+      if (typeof value !== "object")
+        err(label, "expected an object", value);
+      const obj = value;
+      const out = {};
+      for (const { name, codec } of childCodecs) {
+        out[name] = codec.canonicalToRaw(obj[name] ?? null);
+      }
+      return out;
+    }
+  };
+}
+function listCodec(type) {
+  const childField = type.children?.[0];
+  if (!childField)
+    throw new Error("codec[list]: list type has no child field");
+  const child = codecFor(childField.type);
+  const label = "list";
+  const toArray = (value) => {
+    if (Array.isArray(value))
+      return value;
+    if (value != null && typeof value[Symbol.iterator] === "function") {
+      return Array.from(value);
+    }
+    return err(label, "expected an array or iterable", value);
+  };
+  return {
+    label,
+    richToCanonical(value) {
+      if (isNullish(value))
+        return null;
+      return toArray(value).map((v) => child.richToCanonical(v));
+    },
+    canonicalToRich(value) {
+      if (isNullish(value))
+        return null;
+      return toArray(value).map((v) => child.canonicalToRich(v));
+    },
+    rawToCanonical(value) {
+      if (isNullish(value))
+        return null;
+      return toArray(value).map((v) => child.rawToCanonical(v));
+    },
+    canonicalToRaw(value) {
+      if (isNullish(value))
+        return null;
+      return toArray(value).map((v) => child.canonicalToRaw(v));
+    }
+  };
+}
+function mapCodec(type) {
+  const entries = type.children?.[0];
+  const entryChildren = entries?.type?.children;
+  if (!entryChildren || entryChildren.length < 2) {
+    throw new Error("codec[map]: map type has no key/value entry fields");
+  }
+  const keyCodec = codecFor(entryChildren[0].type);
+  const valueCodec = codecFor(entryChildren[1].type);
+  const label = "map";
+  const toPairs = (value) => {
+    if (Array.isArray(value))
+      return value;
+    if (value instanceof Map)
+      return Array.from(value.entries());
+    if (value != null && typeof value[Symbol.iterator] === "function") {
+      return Array.from(value);
+    }
+    if (value != null && typeof value === "object") {
+      return Object.entries(value);
+    }
+    return err(label, "expected Map, array of pairs, or object", value);
+  };
+  return {
+    label,
+    richToCanonical(value) {
+      if (isNullish(value))
+        return null;
+      return toPairs(value).map(([k, v]) => [
+        keyCodec.richToCanonical(k),
+        valueCodec.richToCanonical(v)
+      ]);
+    },
+    canonicalToRich(value) {
+      if (isNullish(value))
+        return null;
+      return toPairs(value).map(([k, v]) => [
+        keyCodec.canonicalToRich(k),
+        valueCodec.canonicalToRich(v)
+      ]);
+    },
+    rawToCanonical(value) {
+      if (isNullish(value))
+        return null;
+      return toPairs(value).map(([k, v]) => [
+        keyCodec.rawToCanonical(k),
+        valueCodec.rawToCanonical(v)
+      ]);
+    },
+    canonicalToRaw(value) {
+      if (isNullish(value))
+        return null;
+      return toPairs(value).map(([k, v]) => [
+        keyCodec.canonicalToRaw(k),
+        valueCodec.canonicalToRaw(v)
+      ]);
+    }
+  };
+}
+function dictionaryCodec(type) {
+  const valueType = type.dictionary;
+  if (!valueType)
+    throw new Error("codec[dictionary]: missing dictionary value type");
+  const inner = codecFor(valueType);
+  return {
+    label: `dictionary<${inner.label}>`,
+    richToCanonical: (v) => inner.richToCanonical(v),
+    canonicalToRich: (v) => inner.canonicalToRich(v),
+    rawToCanonical: (v) => inner.rawToCanonical(v),
+    canonicalToRaw: (v) => inner.canonicalToRaw(v)
+  };
+}
+var INT8 = identity("int8", checkIntNumber("int8", -128, 127));
+var INT16 = identity("int16", checkIntNumber("int16", -32768, 32767));
+var INT32 = identity("int32", checkIntNumber("int32", -2147483648, 2147483647));
+var UINT8 = identity("uint8", checkIntNumber("uint8", 0, 255));
+var UINT16 = identity("uint16", checkIntNumber("uint16", 0, 65535));
+var UINT32 = identity("uint32", checkIntNumber("uint32", 0, 4294967295));
+var INT64 = identity("int64", checkBigInt("int64", 64, true));
+var UINT64 = identity("uint64", checkBigInt("uint64", 64, false));
+var FLOAT = identity("float", checkFloat("float"));
+var BOOL = identity("bool", checkBoolean("bool"));
+var UTF8 = {
+  label: "utf8",
+  richToCanonical(value) {
+    if (isNullish(value))
+      return null;
+    return typeof value === "string" ? value : String(value);
+  },
+  canonicalToRich(value) {
+    if (isNullish(value))
+      return null;
+    checkString("utf8")(value);
+    return value;
+  },
+  rawToCanonical(value) {
+    if (isNullish(value))
+      return null;
+    return typeof value === "string" ? value : String(value);
+  },
+  canonicalToRaw(value) {
+    if (isNullish(value))
+      return null;
+    checkString("utf8")(value);
+    return value;
+  }
+};
+function toCanonBytes(label, fixedWidth) {
+  return (value) => {
+    if (isNullish(value))
+      return null;
+    let u8;
+    if (value instanceof Uint8Array)
+      u8 = value;
+    else if (ArrayBuffer.isView(value)) {
+      const v = value;
+      u8 = new Uint8Array(v.buffer, v.byteOffset, v.byteLength);
+    } else
+      return err(label, "expected Uint8Array", value);
+    if (fixedWidth != null && u8.length !== fixedWidth) {
+      err(label, `expected exactly ${fixedWidth} bytes`, value);
+    }
+    return u8;
+  };
+}
+function bytesCodec(label, fixedWidth) {
+  const conv = toCanonBytes(label, fixedWidth);
+  return {
+    label,
+    richToCanonical: conv,
+    canonicalToRich: conv,
+    rawToCanonical: conv,
+    canonicalToRaw: conv
+  };
+}
+var BINARY = bytesCodec("binary");
+var NULL_CODEC = {
+  label: "null",
+  richToCanonical: () => null,
+  canonicalToRich: () => null,
+  rawToCanonical: () => null,
+  canonicalToRaw: () => null
+};
+function codecFor(type) {
+  switch (type.typeId) {
+    case TypeId.Null:
+      return NULL_CODEC;
+    case TypeId.Bool:
+      return BOOL;
+    case TypeId.Int: {
+      const bw = type.bitWidth ?? 32;
+      const signed = type.isSigned ?? type.signed ?? true;
+      if (bw === 64)
+        return signed ? INT64 : UINT64;
+      if (signed) {
+        if (bw === 8)
+          return INT8;
+        if (bw === 16)
+          return INT16;
+        return INT32;
+      }
+      if (bw === 8)
+        return UINT8;
+      if (bw === 16)
+        return UINT16;
+      return UINT32;
+    }
+    case TypeId.Float:
+      return FLOAT;
+    case TypeId.Utf8:
+    case TypeId.LargeUtf8:
+      return UTF8;
+    case TypeId.Binary:
+    case TypeId.LargeBinary:
+      return BINARY;
+    case TypeId.FixedSizeBinary:
+      return bytesCodec("fixedSizeBinary", type.byteWidth ?? type.stride);
+    case TypeId.Decimal:
+      return decimalCodec();
+    case TypeId.Date:
+      return type.unit === 0 ? dateDayCodec() : dateMillisCodec();
+    case TypeId.Time:
+      return (type.bitWidth ?? 32) === 64 ? bigIntUnitCodec("time64") : time32Codec();
+    case TypeId.Timestamp:
+      return bigIntUnitCodec("timestamp");
+    case TypeId.Duration:
+      return bigIntUnitCodec("duration");
+    case TypeId.Struct:
+      return structCodec(type);
+    case TypeId.Union:
+      return identity("union", () => {});
+    case TypeId.List:
+    case TypeId.FixedSizeList:
+      return listCodec(type);
+    case TypeId.Map:
+      return mapCodec(type);
+    case TypeId.Dictionary:
+      return dictionaryCodec(type);
+    case TypeId.Interval:
+      return identity("interval", () => {});
+    default:
+      return identity(`type#${type.typeId}`, () => {});
+  }
+}
+
+// src/arrow/impl-arrowjs/canonical.ts
+import {
+  DataType as DataType2,
+  DateUnit as DateUnit2,
+  makeData as makeData2,
+  vectorFromArray
+} from "@query-farm/apache-arrow";
+function writeCanonicalColumn(type, canonical) {
+  return buildColumnData(canonical, type);
+}
+function buildColumnData(values, type) {
+  if (DataType2.isList(type))
+    return buildListData(values, type);
+  if (DataType2.isMap(type))
+    return buildMapData(values, type);
+  if (DataType2.isStruct(type))
+    return buildStructData(values, type);
+  if (DataType2.isDecimal(type))
+    return buildDecimalData(values, type);
+  if (DataType2.isDate(type) || DataType2.isTime(type) || DataType2.isTimestamp(type) || DataType2.isDuration(type)) {
+    const bitWidth = dateTimeBitWidth(type);
+    if (bitWidth === 64)
+      return buildBigIntData(values, type);
+    return buildInt32Data(values, type);
+  }
+  if (DataType2.isInt(type) && type.bitWidth === 64) {
+    return buildBigIntData(values, type);
+  }
+  return vectorFromArray(values, type).data[0];
+}
+function dateTimeBitWidth(type) {
+  if (DataType2.isDate(type))
+    return type.unit === DateUnit2.DAY ? 32 : 64;
+  if (DataType2.isTime(type))
+    return type.bitWidth ?? 32;
+  return 64;
+}
+function buildInt32Data(values, type) {
+  const length = values.length;
+  const buf = new Int32Array(length);
+  const nullBitmap = new Uint8Array(Math.ceil(length / 8));
+  let nullCount = 0;
+  for (let i = 0;i < length; i++) {
+    const v = values[i];
+    if (v === null || v === undefined) {
+      nullCount++;
+      continue;
+    }
+    nullBitmap[i >> 3] |= 1 << (i & 7);
+    buf[i] = typeof v === "bigint" ? Number(v) : v;
+  }
+  return makeData2({
+    type,
+    length,
+    nullBitmap: nullCount > 0 ? nullBitmap : undefined,
+    data: buf,
+    nullCount
+  });
+}
+function buildBigIntData(values, type) {
+  const length = values.length;
+  const bigBuf = new BigInt64Array(length);
+  const nullBitmap = new Uint8Array(Math.ceil(length / 8));
+  let nullCount = 0;
+  for (let i = 0;i < length; i++) {
+    const v = values[i];
+    if (v === null || v === undefined) {
+      nullCount++;
+      continue;
+    }
+    nullBitmap[i >> 3] |= 1 << (i & 7);
+    bigBuf[i] = typeof v === "bigint" ? v : BigInt(v);
+  }
+  const data = new Int32Array(bigBuf.buffer);
+  return makeData2({
+    type,
+    length,
+    nullBitmap: nullCount > 0 ? nullBitmap : undefined,
+    data,
+    nullCount
+  });
+}
+function buildDecimalData(values, type) {
+  const byteWidth = type.byteWidth ?? (type.bitWidth ? type.bitWidth / 8 : 16);
+  const length = values.length;
+  const buf = new Uint8Array(length * byteWidth);
+  const nullBitmap = new Uint8Array(Math.ceil(length / 8));
+  let nullCount = 0;
+  for (let i = 0;i < length; i++) {
+    const val = values[i];
+    if (val === null || val === undefined) {
+      nullCount++;
+      continue;
+    }
+    nullBitmap[i >> 3] |= 1 << (i & 7);
+    let bytes;
+    if (val instanceof Uint8Array) {
+      bytes = val;
+    } else if (ArrayBuffer.isView(val)) {
+      const view = val;
+      bytes = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+    } else {
+      bytes = bigIntToDecimalBytes(toBig(val), byteWidth);
+    }
+    buf.set(bytes.subarray(0, byteWidth), i * byteWidth);
+  }
+  return makeData2({
+    type,
+    length,
+    nullBitmap: nullCount > 0 ? nullBitmap : undefined,
+    data: new Uint32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4),
+    nullCount
+  });
+}
+function toBig(v) {
+  return typeof v === "bigint" ? v : BigInt(Math.trunc(Number(v)));
+}
+function bigIntToDecimalBytes(value, byteWidth) {
+  const bytes = new Uint8Array(byteWidth);
+  let v = value;
+  if (v < 0n)
+    v = (1n << BigInt(byteWidth * 8)) + v;
+  for (let i = 0;i < byteWidth; i++) {
+    bytes[i] = Number(v & 0xffn);
+    v >>= 8n;
+  }
+  return bytes;
+}
+function buildListData(values, listType) {
+  const childField = listType.children[0];
+  const numRows = values.length;
+  const offsets = new Int32Array(numRows + 1);
+  const allItems = [];
+  const nullBitmap = new Uint8Array(Math.ceil(numRows / 8));
+  let nullCount = 0;
+  for (let i = 0;i < numRows; i++) {
+    offsets[i] = allItems.length;
+    const row = values[i];
+    if (row == null) {
+      nullCount++;
+    } else {
+      nullBitmap[i >> 3] |= 1 << (i & 7);
+      const items = Array.isArray(row) ? row : typeof row[Symbol.iterator] === "function" ? Array.from(row) : null;
+      if (items)
+        for (const item of items)
+          allItems.push(item);
+    }
+  }
+  offsets[numRows] = allItems.length;
+  const childData = allItems.length > 0 ? buildColumnData(allItems, childField.type) : emptyDataForType(childField.type);
+  return makeData2({
+    type: listType,
+    length: numRows,
+    nullCount,
+    nullBitmap: nullCount > 0 ? nullBitmap : undefined,
+    child: childData,
+    offset: 0,
+    valueOffsets: offsets
+  });
+}
+function buildMapData(values, mapType) {
+  const numRows = values.length;
+  const entriesField = mapType.children[0];
+  const keyField = entriesField.type.children[0];
+  const valueField = entriesField.type.children[1];
+  const offsets = new Int32Array(numRows + 1);
+  const allKeys = [];
+  const allValues = [];
+  const nullBitmap = new Uint8Array(Math.ceil(numRows / 8));
+  let nullCount = 0;
+  for (let i = 0;i < numRows; i++) {
+    offsets[i] = allKeys.length;
+    const row = values[i];
+    if (row == null) {
+      nullCount++;
+    } else {
+      nullBitmap[i >> 3] |= 1 << (i & 7);
+      const pairs = Array.isArray(row) ? row : row instanceof Map ? Array.from(row.entries()) : typeof row[Symbol.iterator] === "function" ? Array.from(row) : typeof row === "object" ? Object.entries(row) : [];
+      for (const [k, v] of pairs) {
+        allKeys.push(k);
+        allValues.push(v);
+      }
+    }
+  }
+  offsets[numRows] = allKeys.length;
+  const keyData = allKeys.length > 0 ? buildColumnData(allKeys, keyField.type) : emptyDataForType(keyField.type);
+  const valueData = allValues.length > 0 ? buildColumnData(allValues, valueField.type) : emptyDataForType(valueField.type);
+  const entriesData = makeData2({
+    type: entriesField.type,
+    length: allKeys.length,
+    children: [keyData, valueData],
+    nullCount: 0
+  });
+  return makeData2({
+    type: mapType,
+    length: numRows,
+    nullCount,
+    nullBitmap: nullCount > 0 ? nullBitmap : undefined,
+    child: entriesData,
+    offset: 0,
+    valueOffsets: offsets
+  });
+}
+function buildStructData(values, structType) {
+  const childFields = structType.children;
+  const numRows = values.length;
+  const nullBitmap = new Uint8Array(Math.ceil(numRows / 8));
+  let nullCount = 0;
+  const childArrays = childFields.map(() => []);
+  for (let i = 0;i < numRows; i++) {
+    const row = values[i];
+    if (row == null) {
+      nullCount++;
+      for (let c = 0;c < childFields.length; c++)
+        childArrays[c].push(null);
+    } else {
+      nullBitmap[i >> 3] |= 1 << (i & 7);
+      for (let c = 0;c < childFields.length; c++) {
+        const name = childFields[c].name;
+        childArrays[c].push(row[name] ?? row[c] ?? null);
+      }
+    }
+  }
+  const children = childFields.map((cf, idx) => buildColumnData(childArrays[idx], cf.type));
+  return makeData2({
+    type: structType,
+    length: numRows,
+    nullCount,
+    nullBitmap: nullCount > 0 ? nullBitmap : undefined,
+    children
+  });
+}
+function emptyDataForType(type) {
+  if (DataType2.isList(type)) {
+    return makeData2({
+      type,
+      length: 0,
+      nullCount: 0,
+      child: emptyDataForType(type.children[0].type),
+      valueOffsets: new Int32Array([0])
+    });
+  }
+  if (DataType2.isMap(type)) {
+    return makeData2({
+      type,
+      length: 0,
+      nullCount: 0,
+      child: emptyDataForType(type.children[0].type),
+      valueOffsets: new Int32Array([0])
+    });
+  }
+  if (DataType2.isStruct(type)) {
+    const children = type.children.map((cf) => emptyDataForType(cf.type));
+    return makeData2({ type, length: 0, nullCount: 0, children });
+  }
+  return makeData2({ type, length: 0, nullCount: 0 });
+}
+function readCanonicalValue(type, column, index) {
+  const col = column;
+  const data = col?.data?.[0];
+  return readFromData(type, col, data, index);
+}
+function isValid(col, data, index) {
+  if (typeof col?.isValid === "function")
+    return col.isValid(index);
+  const bitmap = data?.nullBitmap;
+  if (bitmap && bitmap.length > 0) {
+    return (bitmap[index >> 3] >> (index & 7) & 1) === 1;
+  }
+  return true;
+}
+function readFromData(type, col, data, index) {
+  if (!isValid(col, data, index))
+    return null;
+  const tid = type.typeId;
+  switch (tid) {
+    case 1:
+      return null;
+    case 6:
+      return col.get(index);
+    case 2: {
+      const bw = type.bitWidth ?? 32;
+      const v = data?.values?.[index];
+      if (bw === 64)
+        return typeof v === "bigint" ? v : BigInt(v);
+      return Number(v);
+    }
+    case 3:
+      return Number(data?.values?.[index]);
+    case 5:
+    case 20:
+      return String(col.get(index));
+    case 4:
+    case 19:
+    case 15:
+      return toUint8(col.get(index));
+    case 7:
+      return decimalToBigInt(type, data, index);
+    case 8: {
+      const v = data?.values?.[index];
+      if (type.unit === DateUnit2.DAY)
+        return Number(v);
+      return typeof v === "bigint" ? v : BigInt(v);
+    }
+    case 9: {
+      const v = data?.values?.[index];
+      const bw = type.bitWidth ?? 32;
+      if (bw === 64)
+        return typeof v === "bigint" ? v : BigInt(v);
+      return Number(v);
+    }
+    case 10:
+    case 18: {
+      const v = data?.values?.[index];
+      return typeof v === "bigint" ? v : BigInt(v);
+    }
+    case 13:
+      return readStruct(type, col, index);
+    case 14:
+      return readUnion(type, col, data, index);
+    case 12:
+    case 16:
+      return readList(type, col, data, index);
+    case 17:
+      return readMap(type, col, data, index);
+    case -1:
+      return readDictionary(type, col, data, index);
+    default:
+      return col.get(index);
+  }
+}
+function toUint8(v) {
+  if (v == null)
+    return null;
+  if (v instanceof Uint8Array)
+    return v;
+  if (ArrayBuffer.isView(v)) {
+    const view = v;
+    return new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+  }
+  return v;
+}
+function decimalToBigInt(type, data, index) {
+  const byteWidth = type.byteWidth ?? (type.bitWidth ? type.bitWidth / 8 : 16);
+  const u32 = data.values;
+  const wordsPerElem = byteWidth / 4;
+  const start = index * wordsPerElem;
+  const u8 = new Uint8Array(byteWidth);
+  for (let w = 0;w < wordsPerElem; w++) {
+    const word = u32[start + w] >>> 0;
+    u8[w * 4] = word & 255;
+    u8[w * 4 + 1] = word >>> 8 & 255;
+    u8[w * 4 + 2] = word >>> 16 & 255;
+    u8[w * 4 + 3] = word >>> 24 & 255;
+  }
+  return decimalBytesToBigInt(u8);
+}
+function decimalBytesToBigInt(u8) {
+  let bi = 0n;
+  for (let i = u8.length - 1;i >= 0; i--)
+    bi = bi << 8n | BigInt(u8[i]);
+  if (u8[u8.length - 1] & 128)
+    bi -= 1n << BigInt(u8.length * 8);
+  return bi;
+}
+function readStruct(type, col, index) {
+  const children = type.children;
+  const out = {};
+  for (let c = 0;c < children.length; c++) {
+    const cf = children[c];
+    const childVec = typeof col.getChildAt === "function" ? col.getChildAt(c) : col.children?.[c];
+    if (!childVec) {
+      out[cf.name] = null;
+      continue;
+    }
+    out[cf.name] = readCanonicalValue(cf.type, childVec, index);
+  }
+  return out;
+}
+function readUnion(type, col, data, index) {
+  const children = type.children;
+  const typeIds = data?.typeIds;
+  const tcode = typeIds ? typeIds[index] : children.length > 0 ? 0 : -1;
+  const map2 = type.typeIdToChildIndex;
+  const childIdx = map2 && map2[tcode] !== undefined ? map2[tcode] : tcode;
+  const childField = children[childIdx];
+  if (!childField)
+    return { tag: null, value: null };
+  const offsets = data?.valueOffsets;
+  const childRow = offsets ? offsets[index] : index;
+  const childVec = typeof col.getChildAt === "function" ? col.getChildAt(childIdx) : col.children?.[childIdx];
+  const value = childVec ? readCanonicalValue(childField.type, childVec, childRow) : null;
+  return { tag: childField.name, value };
+}
+function readList(type, col, data, index) {
+  const childField = type.children[0];
+  const childVec = typeof col.getChildAt === "function" ? col.getChildAt(0) : col.children?.[0];
+  const offsets = data?.valueOffsets;
+  let start, end;
+  if (offsets) {
+    start = offsets[index];
+    end = offsets[index + 1];
+  } else {
+    const listSize = type.listSize ?? 0;
+    start = index * listSize;
+    end = start + listSize;
+  }
+  const out = [];
+  for (let i = start;i < end; i++) {
+    out.push(readCanonicalValue(childField.type, childVec, i));
+  }
+  return out;
+}
+function readMap(type, col, data, index) {
+  const entriesField = type.children[0];
+  const keyField = entriesField.type.children[0];
+  const valueField = entriesField.type.children[1];
+  const offsets = data?.valueOffsets;
+  const entriesVec = typeof col.getChildAt === "function" ? col.getChildAt(0) : col.children?.[0];
+  const keyVec = entriesVec && (typeof entriesVec.getChildAt === "function" ? entriesVec.getChildAt(0) : entriesVec.children?.[0]);
+  const valueVec = entriesVec && (typeof entriesVec.getChildAt === "function" ? entriesVec.getChildAt(1) : entriesVec.children?.[1]);
+  const start = offsets ? offsets[index] : 0;
+  const end = offsets ? offsets[index + 1] : 0;
+  const out = [];
+  for (let i = start;i < end; i++) {
+    out.push([
+      readCanonicalValue(keyField.type, keyVec, i),
+      readCanonicalValue(valueField.type, valueVec, i)
+    ]);
+  }
+  return out;
+}
+function readDictionary(type, col, data, index) {
+  const valueType = type.dictionary;
+  if (data && data.dictionary && data.values) {
+    const idx = Number(data.values[index]);
+    const dictVec = data.dictionary;
+    return readCanonicalValue(valueType, dictVec, idx);
+  }
+  return col.get(index);
+}
+
+// src/arrow/impl-arrowjs/build.ts
+function columnFromArray(values, type) {
+  return vectorFromArray2(values, type).data[0];
+}
+function batchFromRows(rows, schema2) {
+  const a = schema2;
+  if (rows.length === 0) {
+    return emptyBatch(a);
+  }
+  const columns = {};
+  for (const field2 of a.fields) {
+    columns[field2.name] = rows.map((r) => r[field2.name] ?? null);
+  }
+  return batchFromColumns(columns, a);
+}
+function batchFromColumns(columns, schema2, repr = "rich") {
+  const a = schema2;
+  const numRows = a.fields.length > 0 ? columns[a.fields[0].name]?.length ?? 0 : 0;
+  const children = a.fields.map((f) => {
+    const values = columns[f.name];
+    if (!values) {
+      return makeData3({ type: f.type, length: numRows, nullCount: numRows });
+    }
+    const codec = codecFor(f.type);
+    const toCanon = repr === "raw" ? codec.rawToCanonical : codec.richToCanonical;
+    const canonical = values.map((v) => toCanon.call(codec, v));
+    return writeCanonicalColumn(f.type, canonical);
+  });
+  const structType = new Struct3(a.fields);
+  const data = makeData3({
+    type: structType,
+    length: numRows,
+    children,
+    nullCount: 0
+  });
+  return new RecordBatch2(a, data);
+}
+// src/arrow/impl-arrowjs/iterate.ts
+function* iterRows(batch, repr = "rich") {
+  const a = batch;
+  const codecs = a.schema.fields.map((f) => codecFor(f.type));
+  for (let i = 0;i < a.numRows; i++) {
+    const row = {};
+    for (let fi = 0;fi < a.schema.fields.length; fi++) {
+      const field2 = a.schema.fields[fi];
+      const col = a.getChild(field2.name);
+      if (!col) {
+        row[field2.name] = null;
+        continue;
+      }
+      const canonical = readCanonicalValue(field2.type, col, i);
+      const codec = codecs[fi];
+      row[field2.name] = repr === "raw" ? codec.canonicalToRaw(canonical) : codec.canonicalToRich(canonical);
+    }
+    yield row;
+  }
+}
+function batchToScalarDict(batch) {
+  if (!batch)
+    return {};
+  const a = batch;
+  if (a.numRows === 0)
+    return {};
+  const result = {};
+  for (const field2 of a.schema.fields) {
+    const col = a.getChild(field2.name);
+    if (col) {
+      const type = field2.type;
+      const canonical = readCanonicalValue(type, col, 0);
+      result[field2.name] = codecFor(type).canonicalToRich(canonical);
+    }
+  }
+  return result;
+}
+function decodeDictValue(value, index = 0) {
+  if (value && typeof value === "object" && "dictionary" in value && "values" in value && typeof value.dictionary?.get === "function") {
+    const data = value;
+    const nullBitmap = data.nullBitmap;
+    if (nullBitmap && nullBitmap.length > 0) {
+      const byte = nullBitmap[index >> 3];
+      if ((byte >> (index & 7) & 1) === 0)
+        return null;
+    }
+    const idx = Number(data.values[index]);
+    return value.dictionary.get(idx);
+  }
+  return value;
+}
+function batchToSecretDict(batch) {
+  if (!batch)
+    return {};
+  const a = batch;
+  if (a.numRows === 0)
+    return {};
+  const result = {};
+  for (const field2 of a.schema.fields) {
+    const col = a.getChild(field2.name);
+    if (col) {
+      const type = field2.type;
+      const val = codecFor(type).canonicalToRich(readCanonicalValue(type, col, 0));
+      let key = field2.name;
+      let scope;
+      if (field2.name.startsWith("secret_")) {
+        const secretType = field2.metadata?.get?.("secret_type");
+        if (secretType) {
+          key = secretType;
+          scope = field2.metadata?.get?.("scope") ?? undefined;
+        }
+      }
+      if (val && typeof val === "object" && !ArrayBuffer.isView(val)) {
+        const dict = { ...val };
+        if (key in result) {
+          throw new Error(`batchToSecretDict: duplicate secret_type '${key}' (scope=${scope ?? "none"}). ` + `Use scoped secrets with distinct scopes to avoid collisions.`);
+        }
+        result[key] = dict;
+        if (scope) {
+          result[`${key}:${scope}`] = dict;
+        }
+      } else if (val === null || val === undefined) {} else {
+        result[key] = {};
+      }
+    }
+  }
+  return result;
+}
+function safeNumber(value) {
+  if (typeof value === "bigint") {
+    return Number(value);
+  }
+  return value;
+}
+// src/arrow/impl-arrowjs/filter.ts
+function filterBatch(batch, mask) {
+  const a = batch;
+  const n = a.numRows;
+  let passCount = 0;
+  for (let i = 0;i < n; i++) {
+    if (mask[i])
+      passCount++;
+  }
+  if (passCount === n)
+    return a;
+  if (passCount === 0)
+    return emptyBatch(a.schema);
+  const indices = [];
+  for (let i = 0;i < n; i++) {
+    if (mask[i])
+      indices.push(i);
+  }
+  const columns = {};
+  for (const field2 of a.schema.fields) {
+    const col = a.getChild(field2.name);
+    const type = field2.type;
+    const codec = codecFor(type);
+    columns[field2.name] = indices.map((i) => codec.canonicalToRich(readCanonicalValue(type, col, i)));
+  }
+  return batchFromColumns(columns, a.schema);
+}
+// src/arrow/impl-arrowjs/project.ts
+import {
+  RecordBatch as RecordBatch3,
+  Schema as Schema3,
+  Struct as Struct4,
+  makeData as makeData4
+} from "@query-farm/apache-arrow";
+function validateProjectionIds(caller, projectionIds, fieldCount) {
+  for (const id of projectionIds) {
+    if (id < -1) {
+      throw new Error(`${caller}: unexpected negative projection ID ${id} (only -1 for row_id is allowed)`);
+    }
+    if (id >= fieldCount) {
+      console.warn(`${caller}: projection ID ${id} is out of bounds (schema has ${fieldCount} fields), ignoring`);
+    }
+  }
+  return projectionIds.filter((i) => i >= 0 && i < fieldCount);
+}
+function projectSchema(projectionIds, schema2) {
+  const a = schema2;
+  if (!projectionIds)
+    return a;
+  const validIds = validateProjectionIds("projectSchema", projectionIds, a.fields.length);
+  if (validIds.length === 0)
+    return a;
+  return new Schema3(validIds.map((i) => a.fields[i]));
+}
+function projectBatch(projectionIds, batch) {
+  const a = batch;
+  if (!projectionIds)
+    return a;
+  const validIds = validateProjectionIds("projectBatch", projectionIds, a.schema.fields.length);
+  if (validIds.length === 0)
+    return a;
+  const projectedSchema = projectSchema(projectionIds, a.schema);
+  const children = validIds.map((i) => {
+    const col = a.getChildAt(i);
+    return col.data[0];
+  });
+  const structType = new Struct4(projectedSchema.fields);
+  const data = makeData4({
+    type: structType,
+    length: a.numRows,
+    children,
+    nullCount: 0
+  });
+  return new RecordBatch3(projectedSchema, data);
+}
+// src/arrow/impl-arrowjs/ipc.ts
+import {
+  Schema as Schema4,
+  RecordBatchStreamWriter,
+  RecordBatchReader
+} from "@query-farm/apache-arrow";
+function serializeSchema(schema2) {
+  const writer = new RecordBatchStreamWriter;
+  writer.reset(undefined, schema2);
+  writer.close();
+  return writer.toUint8Array(true);
+}
+function deserializeSchema(bytes) {
+  const reader = RecordBatchReader.from(bytes);
+  const batches = [...reader];
+  if (batches.length > 0) {
+    return batches[0].schema;
+  }
+  if (reader.schema)
+    return reader.schema;
+  throw new Error("Cannot deserialize schema from empty IPC stream");
+}
+function serializeBatch(batch) {
+  const a = batch;
+  const writer = new RecordBatchStreamWriter;
+  writer.reset(undefined, a.schema);
+  writer._writeRecordBatch(a);
+  writer.close();
+  return writer.toUint8Array(true);
+}
+function deserializeBatch(bytes) {
+  const reader = RecordBatchReader.from(bytes);
+  const batches = [...reader];
+  if (batches.length === 0) {
+    const sch = reader.schema ?? new Schema4([]);
+    return emptyBatch(sch);
+  }
+  return batches[0];
+}
+// src/arrow/impl-arrowjs/statistics.ts
+import {
+  Field as Field3,
+  Null,
+  makeData as makeData5,
+  RecordBatch as RecordBatch5,
+  Struct as Struct5,
+  SparseUnion,
+  Schema as Schema5,
+  Utf8,
+  Bool,
+  Int64,
+  Uint64
+} from "@query-farm/apache-arrow";
+function typeKey(t) {
+  const a = t;
+  return [
+    t.typeId,
+    a.unit ?? "",
+    a.bitWidth ?? "",
+    a.precision ?? "",
+    a.scale ?? "",
+    a.byteWidth ?? ""
+  ].join(":");
+}
+function buildTypedColumnData(values, type) {
+  const a = type;
+  if (a.typeId === 1) {
+    return makeData5({ type: a, length: values.length, nullCount: values.length });
+  }
+  const codec = codecFor(type);
+  const canonical = values.map((v) => codec.richToCanonical(v));
+  return writeCanonicalColumn(type, canonical);
+}
+function buildStatisticsBatch(stats) {
+  if (stats.length === 0) {
+    const nullField = new Field3("0", new Null, true);
+    const unionType2 = new SparseUnion([0], [nullField]);
+    const minData2 = makeData5({
+      type: unionType2,
+      length: 0,
+      typeIds: new Int8Array(0),
+      children: [makeData5({ type: new Null, length: 0, nullCount: 0 })]
+    });
+    const maxData2 = makeData5({
+      type: unionType2,
+      length: 0,
+      typeIds: new Int8Array(0),
+      children: [makeData5({ type: new Null, length: 0, nullCount: 0 })]
+    });
+    return assemble([], minData2, maxData2, [], [], [], [], [], unionType2);
+  }
+  const typeOrder = [];
+  const typeIdMap = new Map;
+  const rowTypeCodes = [];
+  for (const s of stats) {
+    const key = typeKey(s.arrowType);
+    let code = typeIdMap.get(key);
+    if (code === undefined) {
+      code = typeOrder.length;
+      typeIdMap.set(key, code);
+      typeOrder.push(s.arrowType);
+    }
+    rowTypeCodes.push(code);
+  }
+  const unionFields = [];
+  const minChildren = [];
+  const maxChildren = [];
+  const typeIds = [];
+  for (const [code, arrowType] of typeOrder.entries()) {
+    unionFields.push(new Field3(String(code), arrowType, true));
+    typeIds.push(code);
+    const minVals = stats.map((s, i) => rowTypeCodes[i] === code ? s.min : null);
+    const maxVals = stats.map((s, i) => rowTypeCodes[i] === code ? s.max : null);
+    minChildren.push(buildTypedColumnData(minVals, arrowType));
+    maxChildren.push(buildTypedColumnData(maxVals, arrowType));
+  }
+  const unionType = new SparseUnion(typeIds, unionFields);
+  const typeIdsBuf = Int8Array.from(rowTypeCodes);
+  const minData = makeData5({
+    type: unionType,
+    length: stats.length,
+    typeIds: typeIdsBuf,
+    children: minChildren
+  });
+  const maxData = makeData5({
+    type: unionType,
+    length: stats.length,
+    typeIds: typeIdsBuf,
+    children: maxChildren
+  });
+  return assemble(stats.map((s) => s.columnName), minData, maxData, stats.map((s) => s.hasNull), stats.map((s) => s.hasNotNull), stats.map((s) => s.distinctCount == null ? null : BigInt(s.distinctCount)), stats.map((s) => s.containsUnicode), stats.map((s) => s.maxStringLength == null ? null : BigInt(s.maxStringLength)), unionType);
+}
+function assemble(columnNames, minData, maxData, hasNull, hasNotNull, distinctCount, containsUnicode, maxStringLength, unionType) {
+  const schema2 = new Schema5([
+    new Field3("column_name", new Utf8, false),
+    new Field3("min", unionType, true),
+    new Field3("max", unionType, true),
+    new Field3("has_null", new Bool, false),
+    new Field3("has_not_null", new Bool, false),
+    new Field3("distinct_count", new Int64, true),
+    new Field3("contains_unicode", new Bool, true),
+    new Field3("max_string_length", new Uint64, true)
+  ]);
+  const n = columnNames.length;
+  const children = [
+    buildTypedColumnData(columnNames, new Utf8),
+    minData,
+    maxData,
+    buildTypedColumnData(hasNull, new Bool),
+    buildTypedColumnData(hasNotNull, new Bool),
+    buildTypedColumnData(distinctCount, new Int64),
+    buildTypedColumnData(containsUnicode, new Bool),
+    buildTypedColumnData(maxStringLength, new Uint64)
+  ];
+  const structType = new Struct5(schema2.fields);
+  const data = makeData5({ type: structType, length: n, children, nullCount: 0 });
+  return new RecordBatch5(schema2, data);
+}
+
+// src/arrow/impl-arrowjs/index.ts
+var backend = { name: "arrow-js" };
+// src/arrow/schema-types.ts
+var { TimeUnit: TimeUnit2, DateUnit: DateUnit3, IntervalUnit: IntervalUnit2, UnionMode: UnionMode2, schema: schema2 } = exports_impl_arrowjs;
+function field2(name, type, nullable, metadata) {
+  return field(name, type, nullable, metadata);
+}
+var nullType2 = () => nullType();
+var bool2 = () => bool();
+var int162 = () => int16();
+var int322 = () => int32();
+var int642 = () => int64();
+var float642 = () => float64();
+var utf82 = () => utf8();
+var binary2 = () => binary();
+var UNIT_TO_TAG = {
+  [TimeUnit.SECOND]: "s",
+  [TimeUnit.MILLISECOND]: "ms",
+  [TimeUnit.MICROSECOND]: "us",
+  [TimeUnit.NANOSECOND]: "ns"
+};
+function timestamp2(unit, timezone) {
+  return timestamp(unit, timezone ?? null);
+}
+function list2(child) {
+  return list(child);
+}
+function struct2(children) {
+  return struct(children);
+}
+function map2(keyField, valueField, keysSorted) {
+  return map(keyField, valueField, keysSorted);
+}
+function dictionary2(valueType, indexType, ordered, id) {
+  return dictionary(valueType, indexType, ordered, id);
+}
+// src/arguments/arguments.ts
+class Arguments {
+  positional;
+  named;
+  argumentsSchema;
+  constructor(positional = [], named = new Map, argumentsSchema = null) {
+    this.positional = positional;
+    this.named = named;
+    this.argumentsSchema = argumentsSchema;
+  }
+  get(position, defaultValue) {
+    if (typeof position === "number") {
+      if (position < this.positional.length) {
+        const val = this.positional[position];
+        if (val === null || val === undefined) {
+          return defaultValue !== undefined ? defaultValue : null;
+        }
+        return unwrapScalar(val);
+      }
+      if (defaultValue !== undefined)
+        return defaultValue;
+      throw new Error(`Positional argument ${position} not found`);
+    }
+    if (this.named.has(position)) {
+      const val = this.named.get(position);
+      if (val === null || val === undefined) {
+        return defaultValue !== undefined ? defaultValue : null;
+      }
+      return unwrapScalar(val);
+    }
+    if (defaultValue !== undefined)
+      return defaultValue;
+    throw new Error(`Named argument '${position}' not found`);
+  }
+  get length() {
+    return this.positional.length;
+  }
+}
+function unwrapScalar(val) {
+  if (val === null || val === undefined)
+    return null;
+  if (typeof val !== "object")
+    return val;
+  if (typeof val.valueOf === "function") {
+    let v;
+    try {
+      v = val.valueOf();
+    } catch {
+      return val;
+    }
+    if (typeof v === "bigint") {
+      if (v >= Number.MIN_SAFE_INTEGER && v <= Number.MAX_SAFE_INTEGER) {
+        return Number(v);
+      }
+      return v;
+    }
+    return v;
+  }
+  return val;
+}
+
+// src/types.ts
+var FunctionType;
+((FunctionType2) => {
+  FunctionType2["SCALAR"] = "scalar";
+  FunctionType2["TABLE"] = "table";
+  FunctionType2["AGGREGATE"] = "aggregate";
+})(FunctionType ||= {});
+var FunctionStability;
+((FunctionStability2) => {
+  FunctionStability2["CONSISTENT"] = "CONSISTENT";
+  FunctionStability2["VOLATILE"] = "VOLATILE";
+  FunctionStability2["CONSISTENT_WITHIN_QUERY"] = "CONSISTENT_WITHIN_QUERY";
+})(FunctionStability ||= {});
+var NullHandling;
+((NullHandling2) => {
+  NullHandling2["DEFAULT"] = "DEFAULT";
+  NullHandling2["SPECIAL"] = "SPECIAL";
+})(NullHandling ||= {});
+var OrderPreservation;
+((OrderPreservation2) => {
+  OrderPreservation2["PRESERVES_ORDER"] = "PRESERVES_ORDER";
+  OrderPreservation2["NO_ORDER_GUARANTEE"] = "NO_ORDER_GUARANTEE";
+  OrderPreservation2["FIXED_ORDER"] = "FIXED_ORDER";
+})(OrderPreservation ||= {});
+var OrderDependence;
+((OrderDependence2) => {
+  OrderDependence2["ORDER_DEPENDENT"] = "ORDER_DEPENDENT";
+  OrderDependence2["NOT_ORDER_DEPENDENT"] = "NOT_ORDER_DEPENDENT";
+})(OrderDependence ||= {});
+var DistinctDependence;
+((DistinctDependence2) => {
+  DistinctDependence2["DISTINCT_DEPENDENT"] = "DISTINCT_DEPENDENT";
+  DistinctDependence2["NOT_DISTINCT_DEPENDENT"] = "NOT_DISTINCT_DEPENDENT";
+})(DistinctDependence ||= {});
+var TableInOutPhase;
+((TableInOutPhase2) => {
+  TableInOutPhase2["INPUT"] = "INPUT";
+  TableInOutPhase2["FINALIZE"] = "FINALIZE";
+  TableInOutPhase2["TABLE_BUFFERING"] = "TABLE_BUFFERING";
+  TableInOutPhase2["TABLE_BUFFERING_FINALIZE"] = "TABLE_BUFFERING_FINALIZE";
+})(TableInOutPhase ||= {});
+var VGI_ARG_KEY = "vgi_arg";
+var VGI_ARG_NAMED = "named";
+var VGI_TYPE_KEY = "vgi_type";
+var VGI_TYPE_TABLE = "table";
+var VGI_TYPE_ANY = "any";
+var VGI_VARARGS_KEY = "vgi_varargs";
+var VGI_VARARGS_TRUE = "true";
+var VGI_CONST_KEY = "vgi_const";
+var VGI_CONST_TRUE = "true";
+var VGI_DOC_KEY = "vgi_doc";
+var VGI_DEFAULT_KEY = "vgi_default";
+var VGI_CHOICES_KEY = "vgi_choices";
+var VGI_RANGE_KEY = "vgi_range";
+var VGI_PATTERN_KEY = "vgi_pattern";
+// src/util/bytes.ts
+function toUint8Array(val) {
+  if (val instanceof Uint8Array)
+    return val;
+  if (val instanceof ArrayBuffer)
+    return new Uint8Array(val);
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(val))
+    return new Uint8Array(val);
+  if (val && val.buffer instanceof ArrayBuffer) {
+    return new Uint8Array(val.buffer, val.byteOffset, val.byteLength);
+  }
+  return new Uint8Array(0);
+}
+
+// src/protocol/serializers/shared.ts
+function toUint8Array2(val) {
+  if (typeof val === "string")
+    return new TextEncoder().encode(val);
+  const result = toUint8Array(val);
+  if (result.length === 0 && val != null) {
+    throw new Error(`Cannot convert ${typeof val} to Uint8Array`);
+  }
+  return result;
+}
+function buildSingleRowBatch(schema3, values) {
+  const cols = {};
+  for (const f of schema3.fields) {
+    let val = values[f.name];
+    if (isInt(f.type) && f.type.bitWidth === 64 && typeof val === "number") {
+      val = BigInt(val);
+    }
+    cols[f.name] = [val];
+  }
+  return batchFromColumns(cols, schema3);
+}
+
+// src/protocol/serializers/arguments.ts
+function serializeArguments(args) {
+  const structFields = [];
+  const structValues = {};
+  for (let i = 0;i < args.positional.length; i++) {
+    const val = args.positional[i];
+    const fieldName = `positional_${i}`;
+    structFields.push(field2(fieldName, inferScalarType(val), true));
+    structValues[fieldName] = val;
+  }
+  for (const [name, val] of args.named) {
+    const fieldName = `named_${name}`;
+    structFields.push(field2(fieldName, inferScalarType(val), true));
+    structValues[fieldName] = val;
+  }
+  const structType = struct2(structFields);
+  const sch = schema2([field2("args", structType, true)]);
+  const structRow = {};
+  for (const f of structFields) {
+    let val = structValues[f.name];
+    if (isInt(f.type) && f.type.bitWidth === 64 && typeof val === "number") {
+      val = BigInt(val);
+    }
+    structRow[f.name] = val;
+  }
+  const batch = batchFromColumns({ args: [structRow] }, sch);
+  return serializeBatch(batch);
+}
+function inferScalarType(val) {
+  if (val === null || val === undefined)
+    return nullType2();
+  if (typeof val === "string")
+    return utf82();
+  if (typeof val === "boolean")
+    return bool2();
+  if (typeof val === "number")
+    return int642();
+  if (typeof val === "bigint")
+    return int642();
+  if (val instanceof Uint8Array || val instanceof ArrayBuffer)
+    return binary2();
+  return utf82();
+}
+
+// src/protocol/serializers/bind.ts
+var BIND_REQUEST_SCHEMA = schema2([
+  field2("function_name", utf82(), false),
+  field2("arguments", binary2(), false),
+  field2("function_type", utf82(), false),
+  field2("input_schema", binary2(), true),
+  field2("settings", binary2(), true),
+  field2("secrets", binary2(), true),
+  field2("attach_opaque_data", binary2(), true),
+  field2("transaction_opaque_data", binary2(), true),
+  field2("resolved_secrets_provided", bool2(), false),
+  field2("at_unit", utf82(), true),
+  field2("at_value", utf82(), true)
+]);
+var COPY_FROM_STRUCT_TYPE = struct2([
+  field2("format", utf82(), false),
+  field2("file_path", utf82(), false),
+  field2("expected_schema", binary2(), false)
+]);
+var COPY_FROM_FIELD = field2("copy_from", COPY_FROM_STRUCT_TYPE, true);
+var COPY_TO_STRUCT_TYPE = struct2([
+  field2("format", utf82(), false),
+  field2("file_path", utf82(), false)
+]);
+var COPY_TO_FIELD = field2("copy_to", COPY_TO_STRUCT_TYPE, true);
+var BIND_RESPONSE_SCHEMA = schema2([
+  field2("output_schema", binary2(), false),
+  field2("opaque_data", binary2(), true),
+  field2("lookup_secret_types", list2(field2("item", utf82(), true)), false),
+  field2("lookup_scopes", list2(field2("item", utf82(), true)), false),
+  field2("lookup_names", list2(field2("item", utf82(), true)), false)
+]);
+function serializeBindRequest(req) {
+  const row = {
+    function_name: req.function_name,
+    arguments: serializeArguments(req.arguments),
+    function_type: req.function_type,
+    input_schema: req.input_schema ? serializeSchema(req.input_schema) : null,
+    settings: req.settings ? serializeBatch(req.settings) : null,
+    secrets: req.secrets ? serializeBatch(req.secrets) : null,
+    attach_opaque_data: req.attach_opaque_data ?? null,
+    transaction_opaque_data: req.transaction_opaque_data ?? null,
+    resolved_secrets_provided: req.resolved_secrets_provided ?? false,
+    at_unit: req.at_unit ?? null,
+    at_value: req.at_value ?? null
+  };
+  const extraFields = [];
+  if (req.copy_from) {
+    extraFields.push(COPY_FROM_FIELD);
+    row.copy_from = {
+      format: req.copy_from.format,
+      file_path: req.copy_from.file_path,
+      expected_schema: serializeSchema(req.copy_from.expected_schema)
+    };
+  }
+  if (req.copy_to) {
+    extraFields.push(COPY_TO_FIELD);
+    row.copy_to = {
+      format: req.copy_to.format,
+      file_path: req.copy_to.file_path
+    };
+  }
+  if (extraFields.length > 0) {
+    const schemaWithCopy = schema2([...BIND_REQUEST_SCHEMA.fields, ...extraFields]);
+    return buildSingleRowBatch(schemaWithCopy, row);
+  }
+  return buildSingleRowBatch(BIND_REQUEST_SCHEMA, row);
+}
+function deserializeBindResponse(params) {
+  const toStrArray = (val) => {
+    if (!val)
+      return [];
+    const arr = Array.isArray(val) ? val : [...val];
+    return arr.filter((v) => v != null).map(String);
+  };
+  return {
+    output_schema: deserializeSchema(toUint8Array2(params.output_schema)),
+    opaque_data: params.opaque_data ? toUint8Array2(params.opaque_data) : null,
+    lookup_secret_types: toStrArray(params.lookup_secret_types),
+    lookup_scopes: toStrArray(params.lookup_scopes),
+    lookup_names: toStrArray(params.lookup_names)
+  };
+}
+// src/protocol/serializers/init.ts
+var INIT_REQUEST_SCHEMA = schema2([
+  field2("bind_call", binary2(), false),
+  field2("output_schema", binary2(), false),
+  field2("bind_opaque_data", binary2(), true),
+  field2("projection_ids", list2(field2("item", int642(), false)), true),
+  field2("pushdown_filters", binary2(), true),
+  field2("join_keys", list2(field2("item", binary2(), true)), false),
+  field2("phase", utf82(), true),
+  field2("execution_id", binary2(), true),
+  field2("init_opaque_data", binary2(), true),
+  field2("order_by_column_name", utf82(), true),
+  field2("order_by_direction", utf82(), true),
+  field2("order_by_null_order", utf82(), true),
+  field2("order_by_limit", int642(), true),
+  field2("tablesample_percentage", float642(), true),
+  field2("tablesample_seed", int642(), true),
+  field2("finalize_state_id", binary2(), true)
+]);
+var GLOBAL_INIT_RESPONSE_SCHEMA = schema2([
+  field2("execution_id", binary2(), false),
+  field2("opaque_data", binary2(), true),
+  field2("max_workers", int642(), false)
+]);
+function serializeInitRequest(req) {
+  const bindCallBatch = serializeBindRequest(req.bind_call);
+  const bindCallBytes = serializeBatch(bindCallBatch);
+  const row = {
+    bind_call: bindCallBytes,
+    output_schema: serializeSchema(req.output_schema),
+    bind_opaque_data: req.bind_opaque_data ?? null,
+    projection_ids: req.projection_ids?.map((n) => BigInt(n)) ?? null,
+    pushdown_filters: req.pushdown_filters ? serializeBatch(req.pushdown_filters) : null,
+    join_keys: (req.join_keys ?? []).map((b) => serializeBatch(b)),
+    phase: req.phase ?? null,
+    execution_id: req.execution_id ?? null,
+    init_opaque_data: req.init_opaque_data ?? null,
+    order_by_column_name: req.order_by_column_name ?? null,
+    order_by_direction: req.order_by_direction ?? null,
+    order_by_null_order: req.order_by_null_order ?? null,
+    order_by_limit: req.order_by_limit ?? null,
+    tablesample_percentage: req.tablesample_percentage ?? null,
+    tablesample_seed: req.tablesample_seed ?? null,
+    finalize_state_id: req.finalize_state_id ?? null
+  };
+  return buildSingleRowBatch(INIT_REQUEST_SCHEMA, row);
+}
+function deserializeGlobalInitResponse(params) {
+  return {
+    execution_id: toUint8Array2(params.execution_id),
+    opaque_data: params.opaque_data ? toUint8Array2(params.opaque_data) : null,
+    max_workers: Number(params.max_workers)
+  };
+}
+// src/errors.ts
+class VgiError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "VgiError";
+  }
+}
+
+class RowCountMismatchError extends VgiError {
+  constructor(expected, actual) {
+    super(`Scalar function output row count (${actual}) does not match ` + `input row count (${expected})`);
+    this.name = "RowCountMismatchError";
+  }
+}
+
+class FunctionNotFoundError extends VgiError {
+  constructor(name, available) {
+    super(`Unknown function '${name}'`);
+    this.name = "FunctionNotFoundError";
+  }
+}
+
+class CatalogReadOnlyError extends VgiError {
+  constructor(operation) {
+    super(`catalog is read-only: ${operation} is not supported`);
+    this.name = "CatalogReadOnlyError";
+  }
+}
+
+class CatalogNotFoundError extends VgiError {
+  constructor(entity, name) {
+    super(`${entity} '${name}' not found`);
+    this.name = "CatalogNotFoundError";
+  }
+}
+
+class CatalogAlreadyExistsError extends VgiError {
+  constructor(entity, name) {
+    super(`${entity} '${name}' already exists`);
+    this.name = "CatalogAlreadyExistsError";
+  }
+}
+
+class ArgumentValidationError extends VgiError {
+  constructor(message) {
+    super(message);
+    this.name = "ArgumentValidationError";
+  }
+}
+
+class NoCatalogError extends VgiError {
+  constructor() {
+    super("No catalog is configured for this worker");
+    this.name = "NoCatalogError";
+  }
+}
+
+// src/codec/asd.ts
+function encodeASD(schema3, obj) {
+  return serializeBatch(batchFromRows([obj], schema3));
+}
+function decodeASD(schema3, bytes) {
+  const batch = deserializeBatch(bytes);
+  if (batch.numRows === 0) {
+    const names = schema3.fields.map((f) => f.name).join(",");
+    throw new Error(`decodeASD: empty batch (expected 1 row for ${names})`);
+  }
+  const out = {};
+  for (const field3 of schema3.fields) {
+    const col = batch.getChild(field3.name);
+    const raw = col ? col.get(0) : null;
+    out[field3.name] = normalizeValue(raw, field3.type);
+  }
+  return out;
+}
+function normalizeValue(raw, type) {
+  if (raw == null)
+    return null;
+  if (isList(type)) {
+    const childType = type.children[0].type;
+    const out = [];
+    for (const item of raw)
+      out.push(normalizeValue(item, childType));
+    return out;
+  }
+  if (isMap(type)) {
+    const out = {};
+    if (raw[Symbol.iterator]) {
+      for (const entry of raw) {
+        if (Array.isArray(entry)) {
+          out[String(entry[0])] = String(entry[1] ?? "");
+        } else if (entry && typeof entry === "object") {
+          const k = entry.key ?? entry[0];
+          const v = entry.value ?? entry[1];
+          out[String(k)] = v == null ? "" : String(v);
+        }
+      }
+    } else if (typeof raw === "object") {
+      for (const [k, v] of Object.entries(raw)) {
+        out[String(k)] = v == null ? "" : String(v);
+      }
+    }
+    return out;
+  }
+  if (isStruct(type)) {
+    const childFields = type.children;
+    const out = {};
+    for (const cf of childFields) {
+      out[cf.name] = normalizeValue(raw[cf.name], cf.type);
+    }
+    return out;
+  }
+  if (isDictionary(type)) {
+    return raw == null ? null : String(raw);
+  }
+  if (isBinary(type)) {
+    return toUint8Array3(raw);
+  }
+  if (isInt(type) && type.bitWidth === 64) {
+    if (typeof raw === "bigint") {
+      if (raw >= BigInt(Number.MIN_SAFE_INTEGER) && raw <= BigInt(Number.MAX_SAFE_INTEGER)) {
+        return Number(raw);
+      }
+      return raw;
+    }
+    return raw;
+  }
+  if (isBool(type)) {
+    return Boolean(raw);
+  }
+  return raw;
+}
+function toUint8Array3(val) {
+  if (val instanceof Uint8Array)
+    return val;
+  if (val instanceof ArrayBuffer)
+    return new Uint8Array(val);
+  if (val && val.buffer instanceof ArrayBuffer) {
+    return new Uint8Array(val.buffer, val.byteOffset, val.byteLength);
+  }
+  return new Uint8Array(0);
+}
+
+// src/generated/vgi-protocol-schemas.ts
+var CatalogInfoSchema = schema2([
+  field2("name", utf82(), false),
+  field2("implementation_version", utf82(), true),
+  field2("data_version_spec", utf82(), true),
+  field2("attach_option_specs", list2(field2("item", binary2(), true)), false),
+  field2("releases", list2(field2("item", struct2([field2("version", utf82(), false), field2("released_at", timestamp2(TimeUnit2.MICROSECOND, "UTC"), false), field2("summary", utf82(), false), field2("notes_url", utf82(), true)]), true)), false),
+  field2("source_url", utf82(), true)
+]);
+var SchemaInfoSchema = schema2([
+  field2("comment", utf82(), true),
+  field2("tags", map2(field2("key", utf82(), false), field2("value", utf82(), true), false), false),
+  field2("attach_opaque_data", binary2(), false),
+  field2("name", utf82(), false),
+  field2("estimated_object_count", map2(field2("key", utf82(), false), field2("value", int642(), true), false), true)
+]);
+var TableInfoSchema = schema2([
+  field2("comment", utf82(), true),
+  field2("tags", map2(field2("key", utf82(), false), field2("value", utf82(), true), false), false),
+  field2("name", utf82(), false),
+  field2("schema_name", utf82(), false),
+  field2("columns", binary2(), false),
+  field2("not_null_constraints", list2(field2("item", int322(), true)), false),
+  field2("unique_constraints", list2(field2("item", list2(field2("item", int322(), true)), true)), false),
+  field2("check_constraints", list2(field2("item", utf82(), true)), false),
+  field2("primary_key_constraints", list2(field2("item", list2(field2("item", int322(), true)), true)), false),
+  field2("foreign_key_constraints", list2(field2("item", binary2(), true)), false),
+  field2("supports_insert", bool2(), false),
+  field2("supports_update", bool2(), false),
+  field2("supports_delete", bool2(), false),
+  field2("supports_returning", bool2(), false),
+  field2("supports_column_statistics", bool2(), false),
+  field2("scan_function", binary2(), false),
+  field2("insert_function", binary2(), false),
+  field2("update_function", binary2(), false),
+  field2("delete_function", binary2(), false),
+  field2("cardinality_estimate", int642(), false),
+  field2("cardinality_max", int642(), false),
+  field2("column_statistics", binary2(), false),
+  field2("bind_result", binary2(), false),
+  field2("required_filters", list2(field2("item", list2(field2("item", utf82(), true)), true)), false)
+]);
+var ViewInfoSchema = schema2([
+  field2("comment", utf82(), true),
+  field2("tags", map2(field2("key", utf82(), false), field2("value", utf82(), true), false), false),
+  field2("name", utf82(), false),
+  field2("schema_name", utf82(), false),
+  field2("definition", utf82(), false),
+  field2("column_comments", map2(field2("key", utf82(), false), field2("value", utf82(), true), false), false)
+]);
+var FunctionInfoSchema = schema2([
+  field2("comment", utf82(), true),
+  field2("tags", map2(field2("key", utf82(), false), field2("value", utf82(), true), false), false),
+  field2("name", utf82(), false),
+  field2("schema_name", utf82(), false),
+  field2("function_type", dictionary2(utf82(), int162()), false),
+  field2("arguments", binary2(), false),
+  field2("output_schema", binary2(), false),
+  field2("stability", dictionary2(utf82(), int162()), true),
+  field2("null_handling", dictionary2(utf82(), int162()), true),
+  field2("description", utf82(), false),
+  field2("examples", list2(field2("item", struct2([field2("sql", utf82(), false), field2("description", utf82(), false), field2("expected_output", utf82(), true)]), true)), false),
+  field2("categories", list2(field2("item", utf82(), true)), false),
+  field2("projection_pushdown", bool2(), true),
+  field2("filter_pushdown", bool2(), true),
+  field2("sampling_pushdown", bool2(), true),
+  field2("late_materialization", bool2(), true),
+  field2("supported_expression_filters", list2(field2("item", utf82(), true)), false),
+  field2("order_preservation", dictionary2(utf82(), int162()), true),
+  field2("max_workers", int322(), false),
+  field2("supports_batch_index", bool2(), false),
+  field2("partition_kind", dictionary2(utf82(), int162()), false),
+  field2("order_dependent", dictionary2(utf82(), int162()), false),
+  field2("distinct_dependent", dictionary2(utf82(), int162()), false),
+  field2("supports_window", bool2(), false),
+  field2("streaming_partitioned", bool2(), false),
+  field2("has_finalize", bool2(), false),
+  field2("source_order_dependent", bool2(), false),
+  field2("sink_order_dependent", bool2(), false),
+  field2("requires_input_batch_index", bool2(), false),
+  field2("required_settings", list2(field2("item", utf82(), true)), false),
+  field2("required_secrets", list2(field2("item", struct2([field2("secret_type", utf82(), false), field2("scope", utf82(), true), field2("secret_name", utf82(), true)]), true)), false)
+]);
+var MacroInfoSchema = schema2([
+  field2("comment", utf82(), true),
+  field2("tags", map2(field2("key", utf82(), false), field2("value", utf82(), true), false), false),
+  field2("name", utf82(), false),
+  field2("schema_name", utf82(), false),
+  field2("macro_type", dictionary2(utf82(), int162()), false),
+  field2("parameters", list2(field2("item", utf82(), true)), false),
+  field2("parameter_default_values", binary2(), false),
+  field2("definition", utf82(), false),
+  field2("arguments_schema", binary2(), false)
+]);
+var IndexInfoSchema = schema2([
+  field2("comment", utf82(), true),
+  field2("tags", map2(field2("key", utf82(), false), field2("value", utf82(), true), false), false),
+  field2("name", utf82(), false),
+  field2("schema_name", utf82(), false),
+  field2("table_name", utf82(), false),
+  field2("index_type", utf82(), false),
+  field2("constraint_type", dictionary2(utf82(), int162()), false),
+  field2("expressions", list2(field2("item", utf82(), true)), false),
+  field2("options", map2(field2("key", utf82(), false), field2("value", utf82(), true), false), false)
+]);
+var CopyFromFormatInfoSchema = schema2([
+  field2("comment", utf82(), true),
+  field2("tags", map2(field2("key", utf82(), false), field2("value", utf82(), true), false), false),
+  field2("format_name", utf82(), false),
+  field2("handler", utf82(), false),
+  field2("options", binary2(), false),
+  field2("direction", utf82(), false),
+  field2("description", utf82(), false),
+  field2("ordered", bool2(), false)
+]);
+var ScanFunctionResultSchema = schema2([
+  field2("function_name", utf82(), false),
+  field2("arguments", binary2(), false),
+  field2("required_extensions", list2(field2("item", utf82(), true)), false)
+]);
+var ScanBranchesResultSchema = schema2([
+  field2("branches", list2(field2("item", binary2(), true)), false),
+  field2("required_extensions", list2(field2("item", utf82(), true)), false)
+]);
+var ScanBranchSchema = schema2([
+  field2("function_name", utf82(), false),
+  field2("arguments", binary2(), false),
+  field2("branch_filter", utf82(), true),
+  field2("writable", bool2(), false),
+  field2("source_catalog", utf82(), true),
+  field2("source_schema", utf82(), true),
+  field2("source_table", utf82(), true)
+]);
+var AttachCatalogInfoSchema = schema2([
+  field2("alias", utf82(), false),
+  field2("target", utf82(), false),
+  field2("db_type", utf82(), false),
+  field2("options", map2(field2("key", utf82(), false), field2("value", utf82(), true), false), false),
+  field2("hidden", bool2(), false),
+  field2("required", bool2(), false),
+  field2("secret_ref", utf82(), false)
+]);
+var AggregateBindResultSchema = schema2([
+  field2("output_schema", binary2(), false),
+  field2("execution_id", binary2(), false)
+]);
+var AggregateCombineResultSchema = schema2([]);
+var AggregateDestructorResultSchema = schema2([]);
+var AggregateFinalizeResultSchema = schema2([
+  field2("result_batch", binary2(), false)
+]);
+var AggregateStreamingChunkResultSchema = schema2([
+  field2("result_batch", binary2(), false)
+]);
+var AggregateStreamingCloseResultSchema = schema2([]);
+var AggregateStreamingOpenResultSchema = schema2([
+  field2("execution_id", binary2(), false)
+]);
+var AggregateUpdateResultSchema = schema2([]);
+var AggregateWindowResultSchema = schema2([
+  field2("result_batch", binary2(), false)
+]);
+var AggregateWindowBatchResultSchema = schema2([
+  field2("result_batch", binary2(), false)
+]);
+var AggregateWindowDestructorResultSchema = schema2([]);
+var AggregateWindowInitResultSchema = schema2([]);
+var BindResultSchema = schema2([
+  field2("output_schema", binary2(), false),
+  field2("opaque_data", binary2(), false),
+  field2("lookup_secret_types", list2(field2("item", utf82(), true)), false),
+  field2("lookup_scopes", list2(field2("item", utf82(), true)), false),
+  field2("lookup_names", list2(field2("item", utf82(), true)), false)
+]);
+var CatalogAttachResultSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("supports_transactions", bool2(), false),
+  field2("supports_time_travel", bool2(), false),
+  field2("catalog_version_frozen", bool2(), false),
+  field2("catalog_version", int642(), false),
+  field2("attach_opaque_data_required", bool2(), false),
+  field2("default_schema", utf82(), false),
+  field2("settings", list2(field2("item", binary2(), true)), false),
+  field2("secret_types", list2(field2("item", binary2(), true)), false),
+  field2("attach_catalogs", list2(field2("item", binary2(), true)), false),
+  field2("comment", utf82(), true),
+  field2("tags", map2(field2("key", utf82(), false), field2("value", utf82(), true), false), false),
+  field2("supports_column_statistics", bool2(), false),
+  field2("resolved_data_version", utf82(), true),
+  field2("resolved_implementation_version", utf82(), true)
+]);
+var CatalogCatalogsResultSchema = schema2([
+  field2("items", list2(field2("item", binary2(), true)), false)
+]);
+var CatalogCopyFromFormatsResultSchema = schema2([
+  field2("items", list2(field2("item", binary2(), true)), false)
+]);
+var CatalogIndexGetResultSchema = schema2([
+  field2("items", list2(field2("item", binary2(), true)), false)
+]);
+var CatalogMacroGetResultSchema = schema2([
+  field2("items", list2(field2("item", binary2(), true)), false)
+]);
+var CatalogSchemaContentsFunctionsResultSchema = schema2([
+  field2("items", list2(field2("item", binary2(), true)), false)
+]);
+var CatalogSchemaContentsIndexesResultSchema = schema2([
+  field2("items", list2(field2("item", binary2(), true)), false)
+]);
+var CatalogSchemaContentsMacrosResultSchema = schema2([
+  field2("items", list2(field2("item", binary2(), true)), false)
+]);
+var CatalogSchemaContentsTablesResultSchema = schema2([
+  field2("items", list2(field2("item", binary2(), true)), false)
+]);
+var CatalogSchemaContentsViewsResultSchema = schema2([
+  field2("items", list2(field2("item", binary2(), true)), false)
+]);
+var CatalogSchemaGetResultSchema = schema2([
+  field2("items", list2(field2("item", binary2(), true)), false)
+]);
+var CatalogSchemasResultSchema = schema2([
+  field2("items", list2(field2("item", binary2(), true)), false)
+]);
+var CatalogTableGetResultSchema = schema2([
+  field2("items", list2(field2("item", binary2(), true)), false)
+]);
+var CatalogTransactionBeginResultSchema = schema2([
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogVersionResultSchema = schema2([
+  field2("version", int642(), false)
+]);
+var CatalogViewGetResultSchema = schema2([
+  field2("items", list2(field2("item", binary2(), true)), false)
+]);
+var TableBufferingCombineResultSchema = schema2([
+  field2("finalize_state_ids", list2(field2("item", binary2(), true)), false)
+]);
+var TableBufferingDestructorResultSchema = schema2([]);
+var TableBufferingProcessResultSchema = schema2([
+  field2("state_id", binary2(), false)
+]);
+var TableFunctionCardinalityResultSchema = schema2([
+  field2("estimate", int642(), true),
+  field2("max", int642(), true)
+]);
+var TableFunctionDynamicToStringResultSchema = schema2([
+  field2("keys", list2(field2("item", utf82(), true)), false),
+  field2("values", list2(field2("item", utf82(), true)), false)
+]);
+var AggregateBindParamsSchema = schema2([
+  field2("request", binary2(), false)
+]);
+var AggregateCombineParamsSchema = schema2([
+  field2("request", binary2(), false)
+]);
+var AggregateDestructorParamsSchema = schema2([
+  field2("request", binary2(), false)
+]);
+var AggregateFinalizeParamsSchema = schema2([
+  field2("request", binary2(), false)
+]);
+var AggregateStreamingChunkParamsSchema = schema2([
+  field2("request", binary2(), false)
+]);
+var AggregateStreamingCloseParamsSchema = schema2([
+  field2("request", binary2(), false)
+]);
+var AggregateStreamingOpenParamsSchema = schema2([
+  field2("request", binary2(), false)
+]);
+var AggregateUpdateParamsSchema = schema2([
+  field2("request", binary2(), false)
+]);
+var AggregateWindowParamsSchema = schema2([
+  field2("request", binary2(), false)
+]);
+var AggregateWindowBatchParamsSchema = schema2([
+  field2("request", binary2(), false)
+]);
+var AggregateWindowDestructorParamsSchema = schema2([
+  field2("request", binary2(), false)
+]);
+var AggregateWindowInitParamsSchema = schema2([
+  field2("request", binary2(), false)
+]);
+var BindParamsSchema = schema2([
+  field2("request", binary2(), false)
+]);
+var CatalogAttachParamsSchema = schema2([
+  field2("request", binary2(), false)
+]);
+var CatalogCatalogsParamsSchema = schema2([]);
+var CatalogCopyFromFormatsParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogCreateParamsSchema = schema2([
+  field2("request", binary2(), false)
+]);
+var CatalogDetachParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false)
+]);
+var CatalogDropParamsSchema = schema2([
+  field2("name", utf82(), false)
+]);
+var CatalogIndexCreateParamsSchema = schema2([
+  field2("request", binary2(), false)
+]);
+var CatalogIndexDropParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("schema_name", utf82(), false),
+  field2("name", utf82(), false),
+  field2("ignore_not_found", bool2(), false),
+  field2("cascade", bool2(), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogIndexGetParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("schema_name", utf82(), false),
+  field2("name", utf82(), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogMacroCreateParamsSchema = schema2([
+  field2("request", binary2(), false)
+]);
+var CatalogMacroDropParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("schema_name", utf82(), false),
+  field2("name", utf82(), false),
+  field2("ignore_not_found", bool2(), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogMacroGetParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("schema_name", utf82(), false),
+  field2("name", utf82(), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogSchemaContentsFunctionsParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("name", utf82(), false),
+  field2("type", dictionary2(utf82(), int162()), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogSchemaContentsIndexesParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("name", utf82(), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogSchemaContentsMacrosParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("name", utf82(), false),
+  field2("type", dictionary2(utf82(), int162()), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogSchemaContentsTablesParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("name", utf82(), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogSchemaContentsViewsParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("name", utf82(), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogSchemaCreateParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("name", utf82(), false),
+  field2("on_conflict", dictionary2(utf82(), int162()), false),
+  field2("comment", utf82(), true),
+  field2("tags", map2(field2("key", utf82(), false), field2("value", utf82(), true), false), true),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogSchemaDropParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("name", utf82(), false),
+  field2("ignore_not_found", bool2(), false),
+  field2("cascade", bool2(), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogSchemaGetParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("name", utf82(), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogSchemasParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogTableColumnAddParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("schema_name", utf82(), false),
+  field2("name", utf82(), false),
+  field2("column_definition", binary2(), false),
+  field2("ignore_not_found", bool2(), false),
+  field2("if_column_not_exists", bool2(), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogTableColumnCommentSetParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("schema_name", utf82(), false),
+  field2("name", utf82(), false),
+  field2("column_name", utf82(), false),
+  field2("comment", utf82(), true),
+  field2("ignore_not_found", bool2(), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogTableColumnDefaultDropParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("schema_name", utf82(), false),
+  field2("name", utf82(), false),
+  field2("column_name", utf82(), false),
+  field2("ignore_not_found", bool2(), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogTableColumnDefaultSetParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("schema_name", utf82(), false),
+  field2("name", utf82(), false),
+  field2("column_name", utf82(), false),
+  field2("expression", utf82(), false),
+  field2("ignore_not_found", bool2(), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogTableColumnDropParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("schema_name", utf82(), false),
+  field2("name", utf82(), false),
+  field2("column_name", utf82(), false),
+  field2("ignore_not_found", bool2(), false),
+  field2("if_column_exists", bool2(), false),
+  field2("cascade", bool2(), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogTableColumnRenameParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("schema_name", utf82(), false),
+  field2("name", utf82(), false),
+  field2("column_name", utf82(), false),
+  field2("new_column_name", utf82(), false),
+  field2("ignore_not_found", bool2(), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogTableColumnStatisticsGetParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("schema_name", utf82(), false),
+  field2("name", utf82(), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogTableColumnTypeChangeParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("schema_name", utf82(), false),
+  field2("name", utf82(), false),
+  field2("column_definition", binary2(), false),
+  field2("expression", utf82(), true),
+  field2("ignore_not_found", bool2(), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogTableCommentSetParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("schema_name", utf82(), false),
+  field2("name", utf82(), false),
+  field2("comment", utf82(), true),
+  field2("ignore_not_found", bool2(), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogTableCreateParamsSchema = schema2([
+  field2("request", binary2(), false)
+]);
+var CatalogTableDeleteFunctionGetParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("schema_name", utf82(), false),
+  field2("name", utf82(), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogTableDropParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("schema_name", utf82(), false),
+  field2("name", utf82(), false),
+  field2("ignore_not_found", bool2(), false),
+  field2("cascade", bool2(), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogTableGetParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("schema_name", utf82(), false),
+  field2("name", utf82(), false),
+  field2("at_unit", utf82(), true),
+  field2("at_value", utf82(), true),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogTableInsertFunctionGetParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("schema_name", utf82(), false),
+  field2("name", utf82(), false),
+  field2("transaction_opaque_data", binary2(), true),
+  field2("writable_branch_function_name", utf82(), true)
+]);
+var CatalogTableNotNullDropParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("schema_name", utf82(), false),
+  field2("name", utf82(), false),
+  field2("column_name", utf82(), false),
+  field2("ignore_not_found", bool2(), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogTableNotNullSetParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("schema_name", utf82(), false),
+  field2("name", utf82(), false),
+  field2("column_name", utf82(), false),
+  field2("ignore_not_found", bool2(), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogTableRenameParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("schema_name", utf82(), false),
+  field2("name", utf82(), false),
+  field2("new_name", utf82(), false),
+  field2("ignore_not_found", bool2(), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogTableScanBranchesGetParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("schema_name", utf82(), false),
+  field2("name", utf82(), false),
+  field2("at_unit", utf82(), true),
+  field2("at_value", utf82(), true),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogTableScanFunctionGetParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("schema_name", utf82(), false),
+  field2("name", utf82(), false),
+  field2("at_unit", utf82(), true),
+  field2("at_value", utf82(), true),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogTableUpdateFunctionGetParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("schema_name", utf82(), false),
+  field2("name", utf82(), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogTransactionBeginParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false)
+]);
+var CatalogTransactionCommitParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("transaction_opaque_data", binary2(), false)
+]);
+var CatalogTransactionRollbackParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("transaction_opaque_data", binary2(), false)
+]);
+var CatalogVersionParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogViewCommentSetParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("schema_name", utf82(), false),
+  field2("name", utf82(), false),
+  field2("comment", utf82(), true),
+  field2("ignore_not_found", bool2(), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogViewCreateParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("schema_name", utf82(), false),
+  field2("name", utf82(), false),
+  field2("definition", utf82(), false),
+  field2("on_conflict", dictionary2(utf82(), int162()), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogViewDropParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("schema_name", utf82(), false),
+  field2("name", utf82(), false),
+  field2("ignore_not_found", bool2(), false),
+  field2("cascade", bool2(), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogViewGetParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("schema_name", utf82(), false),
+  field2("name", utf82(), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var CatalogViewRenameParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("schema_name", utf82(), false),
+  field2("name", utf82(), false),
+  field2("new_name", utf82(), false),
+  field2("ignore_not_found", bool2(), false),
+  field2("transaction_opaque_data", binary2(), true)
+]);
+var InitParamsSchema = schema2([
+  field2("request", binary2(), false)
+]);
+var TableBufferingCombineParamsSchema = schema2([
+  field2("request", binary2(), false)
+]);
+var TableBufferingDestructorParamsSchema = schema2([
+  field2("request", binary2(), false)
+]);
+var TableBufferingProcessParamsSchema = schema2([
+  field2("request", binary2(), false)
+]);
+var TableFunctionCardinalityParamsSchema = schema2([
+  field2("request", binary2(), false)
+]);
+var TableFunctionDynamicToStringParamsSchema = schema2([
+  field2("request", binary2(), false)
+]);
+var TableFunctionStatisticsParamsSchema = schema2([
+  field2("request", binary2(), false)
+]);
+
+// src/generated/vgi-client.ts
+var decodeCatalogInfo = (b) => decodeASD(CatalogInfoSchema, b);
+var encodeFunctionInfo = (v) => encodeASD(FunctionInfoSchema, v);
+var decodeFunctionInfo = (b) => decodeASD(FunctionInfoSchema, b);
+var encodeMacroInfo = (v) => encodeASD(MacroInfoSchema, v);
+var decodeMacroInfo = (b) => decodeASD(MacroInfoSchema, b);
+var encodeSchemaInfo = (v) => encodeASD(SchemaInfoSchema, v);
+var decodeSchemaInfo = (b) => decodeASD(SchemaInfoSchema, b);
+var encodeTableInfo = (v) => encodeASD(TableInfoSchema, v);
+var decodeTableInfo = (b) => decodeASD(TableInfoSchema, b);
+var encodeViewInfo = (v) => encodeASD(ViewInfoSchema, v);
+var decodeViewInfo = (b) => decodeASD(ViewInfoSchema, b);
+// src/catalog/interface.ts
+function decodeScanFunctionResult(inner) {
+  const argsBytes = inner.arguments;
+  const positionalArguments = [];
+  const namedArguments = {};
+  if (argsBytes != null) {
+    const batch = deserializeBatch(toUint8Array(argsBytes));
+    for (const field3 of batch.schema.fields) {
+      const col = batch.getChild(field3.name);
+      const value = col ? col.get(0) : null;
+      if (field3.name.startsWith("arg_")) {
+        const idx = parseInt(field3.name.slice(4), 10);
+        while (positionalArguments.length <= idx)
+          positionalArguments.push(null);
+        positionalArguments[idx] = value;
+      } else {
+        namedArguments[field3.name] = value;
+      }
+    }
+  }
+  const exts = inner.required_extensions;
+  const requiredExtensions = exts == null ? [] : (Array.isArray(exts) ? exts : [...exts]).filter((v) => v != null).map(String);
+  return {
+    functionName: String(inner.function_name ?? ""),
+    positionalArguments,
+    namedArguments,
+    requiredExtensions
+  };
+}
+
+// src/client/protocol.ts
+function wrapRequest(batch) {
+  return { request: serializeBatch(batch) };
+}
+function unwrapResult(result) {
+  const resultBytes = toUint8Array(result.result);
+  const innerBatch = deserializeBatch(resultBytes);
+  return batchToScalarDict(innerBatch);
+}
+
+// src/catalog/attach-options.ts
+function inferAttachOptionArrowType(value) {
+  if (value === null)
+    return nullType2();
+  if (typeof value === "string")
+    return utf82();
+  if (typeof value === "bigint")
+    return int642();
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new TypeError(`Attach option number values must be finite (got ${value}). ` + `Use a bigint for integers or a finite number for floats.`);
+    }
+    return float642();
+  }
+  if (typeof value === "boolean")
+    return bool2();
+  if (value instanceof Uint8Array)
+    return binary2();
+  throw new TypeError(`Unsupported attach option value type: ${typeof value}. ` + `Supported: string, number, bigint, boolean, null, Uint8Array.`);
+}
+function serializeAttachOptions(options) {
+  if (!options)
+    return null;
+  const entries = Object.entries(options);
+  if (entries.length === 0)
+    return null;
+  const fields = [];
+  const columns = {};
+  for (const [key, value] of entries) {
+    const type = inferAttachOptionArrowType(value);
+    fields.push(field2(key, type, true));
+    columns[key] = [value];
+  }
+  const schema3 = schema2(fields);
+  const batch = batchFromColumns(columns, schema3);
+  return serializeBatch(batch);
+}
+
+// src/client/errors.ts
+import { RpcError } from "@query-farm/vgi-rpc";
+
+class VgiClientError extends Error {
+  remoteTraceback;
+  errorType;
+  constructor(message, options) {
+    super(message, options?.cause != null ? { cause: options.cause } : undefined);
+    this.name = "VgiClientError";
+    if (options?.remoteTraceback)
+      this.remoteTraceback = options.remoteTraceback;
+    if (options?.errorType)
+      this.errorType = options.errorType;
+  }
+  static fromRpcError(e) {
+    const head = `${e.errorType}: ${e.errorMessage}`;
+    const message = e.remoteTraceback ? `${head}
+
+Remote traceback:
+${e.remoteTraceback}` : head;
+    return new VgiClientError(message, {
+      remoteTraceback: e.remoteTraceback || undefined,
+      errorType: e.errorType,
+      cause: e
+    });
+  }
+}
+function wrapRpcWithErrorEnrichment(rpc) {
+  return {
+    async call(method, params) {
+      try {
+        return await rpc.call(method, params);
+      } catch (e) {
+        if (e instanceof RpcError)
+          throw VgiClientError.fromRpcError(e);
+        throw e;
+      }
+    },
+    async stream(method, params) {
+      try {
+        return await rpc.stream(method, params);
+      } catch (e) {
+        if (e instanceof RpcError)
+          throw VgiClientError.fromRpcError(e);
+        throw e;
+      }
+    },
+    describe: () => rpc.describe(),
+    close: () => rpc.close()
+  };
+}
+
+// src/client/helpers.ts
+function deserializeInfoList(items, deserializeFn) {
+  if (!items)
+    return [];
+  const arr = Array.isArray(items) ? items : [...items];
+  return arr.filter((b) => b != null).map((b) => deserializeFn(toUint8Array(b)));
+}
+function deserializeTags(mapVal) {
+  const tags = {};
+  if (!mapVal)
+    return tags;
+  const iterable = mapVal;
+  if (typeof iterable[Symbol.iterator] !== "function")
+    return tags;
+  for (const entry of iterable) {
+    if (Array.isArray(entry)) {
+      tags[String(entry[0])] = String(entry[1]);
+    } else if (entry && typeof entry === "object") {
+      const e = entry;
+      tags[String(e.key ?? e[0] ?? "")] = String(e.value ?? e[1] ?? "");
+    }
+  }
+  return tags;
+}
+function toAsyncIterator(input) {
+  if (Symbol.asyncIterator in input) {
+    return input[Symbol.asyncIterator]();
+  }
+  const syncIter = input[Symbol.iterator]();
+  return {
+    async next() {
+      return syncIter.next();
+    }
+  };
+}
+
+// src/client/client.ts
+class VgiClient {
+  rpc;
+  defaultAttachOpaqueData;
+  constructor(rpc, options) {
+    this.rpc = wrapRpcWithErrorEnrichment(rpc);
+    this.defaultAttachOpaqueData = options?.attachOpaqueData ?? null;
+  }
+  async _doBind(functionName, functionType, args, inputSchema, settings, secrets, transactionOpaqueData, attachOpaqueData = null, onBind) {
+    const request = {
+      function_name: functionName,
+      arguments: args,
+      function_type: functionType,
+      input_schema: inputSchema,
+      settings: settings ?? null,
+      secrets: secrets ?? null,
+      attach_opaque_data: attachOpaqueData ?? this.defaultAttachOpaqueData,
+      transaction_opaque_data: transactionOpaqueData ?? null,
+      resolved_secrets_provided: false
+    };
+    const requestBatch = serializeBindRequest(request);
+    const rpcResult = await this.rpc.call("bind", wrapRequest(requestBatch));
+    if (!rpcResult)
+      throw new VgiClientError("bind returned null");
+    const inner = unwrapResult(rpcResult);
+    const response = deserializeBindResponse(inner);
+    if (onBind)
+      onBind(response);
+    return { request, response };
+  }
+  async _doInit(bindRequest, bindResponse, opts) {
+    const ob = opts?.orderBy ?? null;
+    const ts = opts?.tablesample ?? null;
+    const initRequest = {
+      bind_call: bindRequest,
+      output_schema: bindResponse.output_schema,
+      bind_opaque_data: bindResponse.opaque_data,
+      projection_ids: opts?.projectionIds ?? null,
+      pushdown_filters: opts?.pushdownFilters ?? null,
+      join_keys: opts?.joinKeys ?? [],
+      phase: opts?.phase ?? null,
+      finalize_state_id: null,
+      order_by_column_name: ob?.columnName ?? null,
+      order_by_direction: ob?.direction ?? null,
+      order_by_null_order: ob?.nullOrder ?? null,
+      order_by_limit: ob?.limit == null ? null : BigInt(ob.limit),
+      tablesample_percentage: ts?.percentage ?? null,
+      tablesample_seed: ts?.seed == null ? null : BigInt(ts.seed),
+      execution_id: opts?.executionId ?? null,
+      init_opaque_data: null
+    };
+    const initBatch = serializeInitRequest(initRequest);
+    const session = await this.rpc.stream("init", wrapRequest(initBatch));
+    const headerDict = session.header;
+    if (!headerDict)
+      throw new VgiClientError("init did not return a header");
+    const initResponse = deserializeGlobalInitResponse(headerDict);
+    return { session, initResponse };
+  }
+  async* tableFunction(opts) {
+    const args = opts.arguments ?? new Arguments;
+    const { request: bindReq, response: bindResp } = await this._doBind(opts.functionName, "table" /* TABLE */, args, null, opts.settings ?? null, null, opts.transactionOpaqueData ?? null, opts.attachOpaqueData ?? null, opts.onBind ?? null);
+    const { session } = await this._doInit(bindReq, bindResp, {
+      projectionIds: opts.projectionIds,
+      pushdownFilters: opts.pushdownFilters,
+      orderBy: opts.orderBy,
+      tablesample: opts.tablesample,
+      joinKeys: opts.joinKeys
+    });
+    const outputSchema = bindResp.output_schema;
+    try {
+      for await (const rows of session) {
+        if (rows.length > 0) {
+          yield batchFromRows(rows, outputSchema);
+        }
+      }
+    } finally {
+      session.close();
+    }
+  }
+  async* scalarFunctionRows(opts) {
+    const inputIter = toAsyncIterator(opts.input);
+    const first = await inputIter.next();
+    if (first.done) {
+      throw new VgiClientError(`scalarFunction(${opts.functionName}): input iterator yielded no batches; ` + `at least one batch is required to determine the input schema`);
+    }
+    const firstBatch = first.value;
+    const inputSchema = firstBatch.schema;
+    const args = opts.arguments ?? new Arguments;
+    const { request: bindReq, response: bindResp } = await this._doBind(opts.functionName, "scalar" /* SCALAR */, args, inputSchema, opts.settings ?? null, opts.secrets ?? null, opts.transactionOpaqueData ?? null, opts.attachOpaqueData ?? null, opts.onBind ?? null);
+    const { session } = await this._doInit(bindReq, bindResp);
+    try {
+      const outRows = await session.exchange([...iterRows(firstBatch)]);
+      if (outRows.length > 0)
+        yield outRows;
+      for await (const batch of { [Symbol.asyncIterator]: () => inputIter }) {
+        const result = await session.exchange([...iterRows(batch)]);
+        if (result.length > 0)
+          yield result;
+      }
+    } finally {
+      session.close();
+    }
+  }
+  async* scalarFunction(opts) {
+    const inputIter = toAsyncIterator(opts.input);
+    const first = await inputIter.next();
+    if (first.done) {
+      throw new VgiClientError(`scalarFunction(${opts.functionName}): input iterator yielded no batches; ` + `at least one batch is required to determine the input schema`);
+    }
+    const firstBatch = first.value;
+    const inputSchema = firstBatch.schema;
+    const args = opts.arguments ?? new Arguments;
+    const { request: bindReq, response: bindResp } = await this._doBind(opts.functionName, "scalar" /* SCALAR */, args, inputSchema, opts.settings ?? null, opts.secrets ?? null, opts.transactionOpaqueData ?? null, opts.attachOpaqueData ?? null, opts.onBind ?? null);
+    const { session } = await this._doInit(bindReq, bindResp);
+    const outputSchema = bindResp.output_schema;
+    try {
+      const outRows = await session.exchange([...iterRows(firstBatch)]);
+      if (outRows.length > 0)
+        yield batchFromRows(outRows, outputSchema);
+      for await (const batch of { [Symbol.asyncIterator]: () => inputIter }) {
+        const result = await session.exchange([...iterRows(batch)]);
+        if (result.length > 0)
+          yield batchFromRows(result, outputSchema);
+      }
+    } finally {
+      session.close();
+    }
+  }
+  async* tableInOutFunctionRows(opts) {
+    const inputIter = toAsyncIterator(opts.input);
+    const first = await inputIter.next();
+    if (first.done) {
+      throw new VgiClientError(`tableInOutFunction(${opts.functionName}): input iterator yielded no batches; ` + `at least one batch is required to determine the input schema`);
+    }
+    const firstBatch = first.value;
+    const inputSchema = firstBatch.schema;
+    const args = opts.arguments ?? new Arguments;
+    const { request: bindReq, response: bindResp } = await this._doBind(opts.functionName, "table" /* TABLE */, args, inputSchema, opts.settings ?? null, null, opts.transactionOpaqueData ?? null, opts.attachOpaqueData ?? null, opts.onBind ?? null);
+    const { session: inputSession, initResponse } = await this._doInit(bindReq, bindResp, {
+      projectionIds: opts.projectionIds,
+      pushdownFilters: opts.pushdownFilters,
+      phase: "INPUT" /* INPUT */,
+      orderBy: opts.orderBy,
+      tablesample: opts.tablesample,
+      joinKeys: opts.joinKeys
+    });
+    try {
+      const outRows = await inputSession.exchange([...iterRows(firstBatch)]);
+      if (outRows.length > 0)
+        yield outRows;
+      for await (const batch of { [Symbol.asyncIterator]: () => inputIter }) {
+        const result = await inputSession.exchange([...iterRows(batch)]);
+        if (result.length > 0)
+          yield result;
+      }
+    } finally {
+      inputSession.close();
+    }
+    const { session: finalizeSession } = await this._doInit(bindReq, bindResp, {
+      projectionIds: opts.projectionIds,
+      pushdownFilters: opts.pushdownFilters,
+      phase: "FINALIZE" /* FINALIZE */,
+      executionId: initResponse.execution_id,
+      orderBy: opts.orderBy,
+      tablesample: opts.tablesample,
+      joinKeys: opts.joinKeys
+    });
+    try {
+      for await (const rows of finalizeSession) {
+        if (rows.length > 0)
+          yield rows;
+      }
+    } finally {
+      finalizeSession.close();
+    }
+  }
+  async* tableInOutFunction(opts) {
+    const inputIter = toAsyncIterator(opts.input);
+    const first = await inputIter.next();
+    if (first.done) {
+      throw new VgiClientError(`tableInOutFunction(${opts.functionName}): input iterator yielded no batches; ` + `at least one batch is required to determine the input schema`);
+    }
+    const firstBatch = first.value;
+    const inputSchema = firstBatch.schema;
+    const args = opts.arguments ?? new Arguments;
+    const { request: bindReq, response: bindResp } = await this._doBind(opts.functionName, "table" /* TABLE */, args, inputSchema, opts.settings ?? null, null, opts.transactionOpaqueData ?? null, opts.attachOpaqueData ?? null, opts.onBind ?? null);
+    const { session: inputSession, initResponse } = await this._doInit(bindReq, bindResp, {
+      projectionIds: opts.projectionIds,
+      pushdownFilters: opts.pushdownFilters,
+      phase: "INPUT" /* INPUT */,
+      orderBy: opts.orderBy,
+      tablesample: opts.tablesample,
+      joinKeys: opts.joinKeys
+    });
+    const outputSchema = bindResp.output_schema;
+    try {
+      const outRows = await inputSession.exchange([...iterRows(firstBatch)]);
+      if (outRows.length > 0)
+        yield batchFromRows(outRows, outputSchema);
+      for await (const batch of { [Symbol.asyncIterator]: () => inputIter }) {
+        const result = await inputSession.exchange([...iterRows(batch)]);
+        if (result.length > 0)
+          yield batchFromRows(result, outputSchema);
+      }
+    } finally {
+      inputSession.close();
+    }
+    const { session: finalizeSession } = await this._doInit(bindReq, bindResp, {
+      projectionIds: opts.projectionIds,
+      pushdownFilters: opts.pushdownFilters,
+      phase: "FINALIZE" /* FINALIZE */,
+      executionId: initResponse.execution_id,
+      orderBy: opts.orderBy,
+      tablesample: opts.tablesample,
+      joinKeys: opts.joinKeys
+    });
+    try {
+      for await (const rows of finalizeSession) {
+        if (rows.length > 0)
+          yield batchFromRows(rows, outputSchema);
+      }
+    } finally {
+      finalizeSession.close();
+    }
+  }
+  async* tableFunctionRows(opts) {
+    const args = opts.arguments ?? new Arguments;
+    const { request: bindReq, response: bindResp } = await this._doBind(opts.functionName, "table" /* TABLE */, args, null, opts.settings ?? null, null, opts.transactionOpaqueData ?? null, opts.attachOpaqueData ?? null, opts.onBind ?? null);
+    const { session } = await this._doInit(bindReq, bindResp, {
+      projectionIds: opts.projectionIds,
+      pushdownFilters: opts.pushdownFilters,
+      orderBy: opts.orderBy,
+      tablesample: opts.tablesample,
+      joinKeys: opts.joinKeys
+    });
+    try {
+      for await (const rows of session) {
+        if (rows.length > 0)
+          yield rows;
+      }
+    } finally {
+      session.close();
+    }
+  }
+  async catalogsInfo() {
+    const result = await this.rpc.call("catalog_catalogs", {});
+    if (!result)
+      return [];
+    const inner = unwrapResult(result);
+    return deserializeInfoList(inner.items, decodeCatalogInfo);
+  }
+  async catalogs() {
+    const infos = await this.catalogsInfo();
+    return infos.map((i) => i.name);
+  }
+  async catalogAttach(name, opts) {
+    if (opts?.options != null && opts?.optionsBytes != null) {
+      throw new VgiClientError("catalogAttach: cannot specify both `options` and `optionsBytes`");
+    }
+    let wireOptions;
+    if (opts?.optionsBytes != null) {
+      wireOptions = opts.optionsBytes.byteLength === 0 ? null : opts.optionsBytes;
+    } else {
+      wireOptions = serializeAttachOptions(opts?.options);
+    }
+    const schema3 = schema2([
+      field2("name", utf82(), false),
+      field2("options", binary2(), true),
+      field2("data_version_spec", utf82(), true),
+      field2("implementation_version", utf82(), true)
+    ]);
+    const innerBatch = batchFromColumns({
+      name: [name],
+      options: [wireOptions],
+      data_version_spec: [opts?.dataVersionSpec ?? null],
+      implementation_version: [opts?.implementationVersion ?? null]
+    }, schema3);
+    const result = await this.rpc.call("catalog_attach", wrapRequest(innerBatch));
+    if (!result)
+      throw new VgiClientError("catalog_attach returned null");
+    const inner = unwrapResult(result);
+    return {
+      attach_opaque_data: toUint8Array(inner.attach_opaque_data),
+      supports_transactions: inner.supports_transactions ?? false,
+      supports_time_travel: inner.supports_time_travel ?? false,
+      catalog_version_frozen: inner.catalog_version_frozen ?? false,
+      catalog_version: Number(inner.catalog_version ?? 0),
+      attach_opaque_data_required: inner.attach_opaque_data_required ?? true,
+      default_schema: inner.default_schema ?? "main",
+      settings: inner.settings ? (Array.isArray(inner.settings) ? inner.settings : [...inner.settings]).map(toUint8Array) : [],
+      secret_types: inner.secret_types ? (Array.isArray(inner.secret_types) ? inner.secret_types : [...inner.secret_types]).map(toUint8Array) : [],
+      attach_catalogs: inner.attach_catalogs ? (Array.isArray(inner.attach_catalogs) ? inner.attach_catalogs : [...inner.attach_catalogs]).map(toUint8Array) : [],
+      comment: inner.comment ?? null,
+      tags: deserializeTags(inner.tags),
+      supports_column_statistics: inner.supports_column_statistics ?? false,
+      resolved_data_version: inner.resolved_data_version ?? null,
+      resolved_implementation_version: inner.resolved_implementation_version ?? null
+    };
+  }
+  async catalogDetach(attachOpaqueData) {
+    await this.rpc.call("catalog_detach", { attach_opaque_data: attachOpaqueData });
+  }
+  async catalogCreate(name, onConflict, options) {
+    let wireOptions;
+    if (options == null) {
+      wireOptions = null;
+    } else if (options instanceof Uint8Array) {
+      wireOptions = options.byteLength === 0 ? null : options;
+    } else {
+      if (options.options != null && options.optionsBytes != null) {
+        throw new VgiClientError("catalogCreate: cannot specify both `options` and `optionsBytes`");
+      }
+      if (options.optionsBytes != null) {
+        wireOptions = options.optionsBytes.byteLength === 0 ? null : options.optionsBytes;
+      } else {
+        wireOptions = serializeAttachOptions(options.options);
+      }
+    }
+    await this.rpc.call("catalog_create", {
+      name,
+      on_conflict: onConflict,
+      options: wireOptions
+    });
+  }
+  async catalogDrop(name) {
+    await this.rpc.call("catalog_drop", { name });
+  }
+  async catalogVersion(attachOpaqueData, transactionOpaqueData) {
+    const result = await this.rpc.call("catalog_version", {
+      attach_opaque_data: attachOpaqueData,
+      transaction_opaque_data: transactionOpaqueData ?? null
+    });
+    if (!result)
+      throw new VgiClientError("catalog_version returned null");
+    const inner = unwrapResult(result);
+    return Number(inner.version ?? 0);
+  }
+  async transactionBegin(attachOpaqueData) {
+    const result = await this.rpc.call("catalog_transaction_begin", {
+      attach_opaque_data: attachOpaqueData
+    });
+    if (!result)
+      throw new VgiClientError("transaction_begin returned null");
+    const inner = unwrapResult(result);
+    if (!inner.transaction_opaque_data) {
+      throw new VgiClientError("transaction_begin returned no transaction_opaque_data");
+    }
+    return toUint8Array(inner.transaction_opaque_data);
+  }
+  async transactionCommit(attachOpaqueData, transactionOpaqueData) {
+    await this.rpc.call("catalog_transaction_commit", {
+      attach_opaque_data: attachOpaqueData,
+      transaction_opaque_data: transactionOpaqueData
+    });
+  }
+  async transactionRollback(attachOpaqueData, transactionOpaqueData) {
+    await this.rpc.call("catalog_transaction_rollback", {
+      attach_opaque_data: attachOpaqueData,
+      transaction_opaque_data: transactionOpaqueData
+    });
+  }
+  async schemas(attachOpaqueData, transactionOpaqueData) {
+    const result = await this.rpc.call("catalog_schemas", {
+      attach_opaque_data: attachOpaqueData,
+      transaction_opaque_data: transactionOpaqueData ?? null
+    });
+    if (!result)
+      return [];
+    const inner = unwrapResult(result);
+    return deserializeInfoList(inner.items, decodeSchemaInfo);
+  }
+  async schemaGet(attachOpaqueData, name, transactionOpaqueData) {
+    const result = await this.rpc.call("catalog_schema_get", {
+      attach_opaque_data: attachOpaqueData,
+      name,
+      transaction_opaque_data: transactionOpaqueData ?? null
+    });
+    if (!result)
+      return null;
+    const inner = unwrapResult(result);
+    const items = deserializeInfoList(inner.items, decodeSchemaInfo);
+    return items.length > 0 ? items[0] : null;
+  }
+  async schemaCreate(attachOpaqueData, name, opts) {
+    const tagsMap = opts?.tags ? new Map(Object.entries(opts.tags)) : null;
+    await this.rpc.call("catalog_schema_create", {
+      attach_opaque_data: attachOpaqueData,
+      name,
+      on_conflict: opts?.onConflict ?? "error",
+      comment: opts?.comment ?? null,
+      tags: tagsMap,
+      transaction_opaque_data: opts?.transactionOpaqueData ?? null
+    });
+  }
+  async schemaDrop(attachOpaqueData, name, ignoreNotFound, cascade, transactionOpaqueData) {
+    await this.rpc.call("catalog_schema_drop", {
+      attach_opaque_data: attachOpaqueData,
+      name,
+      ignore_not_found: ignoreNotFound ?? false,
+      cascade: cascade ?? false,
+      transaction_opaque_data: transactionOpaqueData ?? null
+    });
+  }
+  async schemaContentsTables(attachOpaqueData, name, transactionOpaqueData) {
+    const result = await this.rpc.call("catalog_schema_contents_tables", {
+      attach_opaque_data: attachOpaqueData,
+      name,
+      transaction_opaque_data: transactionOpaqueData ?? null
+    });
+    if (!result)
+      return [];
+    const inner = unwrapResult(result);
+    return deserializeInfoList(inner.items, decodeTableInfo);
+  }
+  async schemaContentsViews(attachOpaqueData, name, transactionOpaqueData) {
+    const result = await this.rpc.call("catalog_schema_contents_views", {
+      attach_opaque_data: attachOpaqueData,
+      name,
+      transaction_opaque_data: transactionOpaqueData ?? null
+    });
+    if (!result)
+      return [];
+    const inner = unwrapResult(result);
+    return deserializeInfoList(inner.items, decodeViewInfo);
+  }
+  async schemaContentsFunctions(attachOpaqueData, name, type, transactionOpaqueData) {
+    const result = await this.rpc.call("catalog_schema_contents_functions", {
+      attach_opaque_data: attachOpaqueData,
+      name,
+      type,
+      transaction_opaque_data: transactionOpaqueData ?? null
+    });
+    if (!result)
+      return [];
+    const inner = unwrapResult(result);
+    return deserializeInfoList(inner.items, decodeFunctionInfo);
+  }
+  async tableGet(attachOpaqueData, schemaName, name, transactionOpaqueData) {
+    const result = await this.rpc.call("catalog_table_get", {
+      attach_opaque_data: attachOpaqueData,
+      schema_name: schemaName,
+      name,
+      transaction_opaque_data: transactionOpaqueData ?? null
+    });
+    if (!result)
+      return null;
+    const inner = unwrapResult(result);
+    const items = deserializeInfoList(inner.items, decodeTableInfo);
+    return items.length > 0 ? items[0] : null;
+  }
+  async tableCreate(attachOpaqueData, schemaName, name, columns, onConflict, notNullConstraints, uniqueConstraints, checkConstraints, transactionOpaqueData) {
+    await this.rpc.call("catalog_table_create", {
+      attach_opaque_data: attachOpaqueData,
+      schema_name: schemaName,
+      name,
+      columns,
+      on_conflict: onConflict,
+      not_null_constraints: notNullConstraints ?? null,
+      unique_constraints: uniqueConstraints ?? null,
+      check_constraints: checkConstraints ?? null,
+      transaction_opaque_data: transactionOpaqueData ?? null
+    });
+  }
+  async tableDrop(attachOpaqueData, schemaName, name, ignoreNotFound, cascade, transactionOpaqueData) {
+    await this.rpc.call("catalog_table_drop", {
+      attach_opaque_data: attachOpaqueData,
+      schema_name: schemaName,
+      name,
+      ignore_not_found: ignoreNotFound ?? false,
+      cascade: cascade ?? false,
+      transaction_opaque_data: transactionOpaqueData ?? null
+    });
+  }
+  async tableScanFunctionGet(attachOpaqueData, schemaName, name, atUnit, atValue, transactionOpaqueData) {
+    const result = await this.rpc.call("catalog_table_scan_function_get", {
+      attach_opaque_data: attachOpaqueData,
+      schema_name: schemaName,
+      name,
+      at_unit: atUnit ?? null,
+      at_value: atValue ?? null,
+      transaction_opaque_data: transactionOpaqueData ?? null
+    });
+    if (!result)
+      throw new VgiClientError("table_scan_function_get returned null");
+    return decodeScanFunctionResult(unwrapResult(result));
+  }
+  async tableCommentSet(attachOpaqueData, schemaName, name, comment, ignoreNotFound, transactionOpaqueData) {
+    await this.rpc.call("catalog_table_comment_set", {
+      attach_opaque_data: attachOpaqueData,
+      schema_name: schemaName,
+      name,
+      comment: comment ?? null,
+      ignore_not_found: ignoreNotFound ?? null,
+      transaction_opaque_data: transactionOpaqueData ?? null
+    });
+  }
+  async tableRename(attachOpaqueData, schemaName, name, newName, ignoreNotFound, transactionOpaqueData) {
+    await this.rpc.call("catalog_table_rename", {
+      attach_opaque_data: attachOpaqueData,
+      schema_name: schemaName,
+      name,
+      new_name: newName,
+      ignore_not_found: ignoreNotFound ?? null,
+      transaction_opaque_data: transactionOpaqueData ?? null
+    });
+  }
+  async tableColumnAdd(attachOpaqueData, schemaName, name, columnName, columnType, defaultValue, ignoreNotFound, transactionOpaqueData) {
+    await this.rpc.call("catalog_table_column_add", {
+      attach_opaque_data: attachOpaqueData,
+      schema_name: schemaName,
+      name,
+      column_name: columnName,
+      column_type: columnType,
+      default_value: defaultValue ?? null,
+      ignore_not_found: ignoreNotFound ?? null,
+      transaction_opaque_data: transactionOpaqueData ?? null
+    });
+  }
+  async tableColumnDrop(attachOpaqueData, schemaName, name, columnName, ignoreNotFound, transactionOpaqueData) {
+    await this.rpc.call("catalog_table_column_drop", {
+      attach_opaque_data: attachOpaqueData,
+      schema_name: schemaName,
+      name,
+      column_name: columnName,
+      ignore_not_found: ignoreNotFound ?? null,
+      transaction_opaque_data: transactionOpaqueData ?? null
+    });
+  }
+  async tableColumnRename(attachOpaqueData, schemaName, name, columnName, newName, ignoreNotFound, transactionOpaqueData) {
+    await this.rpc.call("catalog_table_column_rename", {
+      attach_opaque_data: attachOpaqueData,
+      schema_name: schemaName,
+      name,
+      column_name: columnName,
+      new_name: newName,
+      ignore_not_found: ignoreNotFound ?? null,
+      transaction_opaque_data: transactionOpaqueData ?? null
+    });
+  }
+  async tableColumnDefaultSet(attachOpaqueData, schemaName, name, columnName, defaultValue, ignoreNotFound, transactionOpaqueData) {
+    await this.rpc.call("catalog_table_column_default_set", {
+      attach_opaque_data: attachOpaqueData,
+      schema_name: schemaName,
+      name,
+      column_name: columnName,
+      default_value: defaultValue,
+      ignore_not_found: ignoreNotFound ?? null,
+      transaction_opaque_data: transactionOpaqueData ?? null
+    });
+  }
+  async tableColumnDefaultDrop(attachOpaqueData, schemaName, name, columnName, ignoreNotFound, transactionOpaqueData) {
+    await this.rpc.call("catalog_table_column_default_drop", {
+      attach_opaque_data: attachOpaqueData,
+      schema_name: schemaName,
+      name,
+      column_name: columnName,
+      ignore_not_found: ignoreNotFound ?? null,
+      transaction_opaque_data: transactionOpaqueData ?? null
+    });
+  }
+  async tableColumnTypeChange(attachOpaqueData, schemaName, name, columnDefinition, expression, ignoreNotFound, transactionOpaqueData) {
+    await this.rpc.call("catalog_table_column_type_change", {
+      attach_opaque_data: attachOpaqueData,
+      schema_name: schemaName,
+      name,
+      column_definition: columnDefinition,
+      expression: expression ?? null,
+      ignore_not_found: ignoreNotFound ?? false,
+      transaction_opaque_data: transactionOpaqueData ?? null
+    });
+  }
+  async tableNotNullSet(attachOpaqueData, schemaName, name, columnName, ignoreNotFound, transactionOpaqueData) {
+    await this.rpc.call("catalog_table_not_null_set", {
+      attach_opaque_data: attachOpaqueData,
+      schema_name: schemaName,
+      name,
+      column_name: columnName,
+      ignore_not_found: ignoreNotFound ?? null,
+      transaction_opaque_data: transactionOpaqueData ?? null
+    });
+  }
+  async tableNotNullDrop(attachOpaqueData, schemaName, name, columnName, ignoreNotFound, transactionOpaqueData) {
+    await this.rpc.call("catalog_table_not_null_drop", {
+      attach_opaque_data: attachOpaqueData,
+      schema_name: schemaName,
+      name,
+      column_name: columnName,
+      ignore_not_found: ignoreNotFound ?? null,
+      transaction_opaque_data: transactionOpaqueData ?? null
+    });
+  }
+  async viewGet(attachOpaqueData, schemaName, name, transactionOpaqueData) {
+    const result = await this.rpc.call("catalog_view_get", {
+      attach_opaque_data: attachOpaqueData,
+      schema_name: schemaName,
+      name,
+      transaction_opaque_data: transactionOpaqueData ?? null
+    });
+    if (!result)
+      return null;
+    const inner = unwrapResult(result);
+    const items = deserializeInfoList(inner.items, decodeViewInfo);
+    return items.length > 0 ? items[0] : null;
+  }
+  async viewCreate(attachOpaqueData, schemaName, name, definition, onConflict, transactionOpaqueData) {
+    await this.rpc.call("catalog_view_create", {
+      attach_opaque_data: attachOpaqueData,
+      schema_name: schemaName,
+      name,
+      definition,
+      on_conflict: onConflict,
+      transaction_opaque_data: transactionOpaqueData ?? null
+    });
+  }
+  async viewDrop(attachOpaqueData, schemaName, name, ignoreNotFound, cascade, transactionOpaqueData) {
+    await this.rpc.call("catalog_view_drop", {
+      attach_opaque_data: attachOpaqueData,
+      schema_name: schemaName,
+      name,
+      ignore_not_found: ignoreNotFound ?? false,
+      cascade: cascade ?? false,
+      transaction_opaque_data: transactionOpaqueData ?? null
+    });
+  }
+  async viewRename(attachOpaqueData, schemaName, name, newName, ignoreNotFound, transactionOpaqueData) {
+    await this.rpc.call("catalog_view_rename", {
+      attach_opaque_data: attachOpaqueData,
+      schema_name: schemaName,
+      name,
+      new_name: newName,
+      ignore_not_found: ignoreNotFound ?? null,
+      transaction_opaque_data: transactionOpaqueData ?? null
+    });
+  }
+  async viewCommentSet(attachOpaqueData, schemaName, name, comment, ignoreNotFound, transactionOpaqueData) {
+    await this.rpc.call("catalog_view_comment_set", {
+      attach_opaque_data: attachOpaqueData,
+      schema_name: schemaName,
+      name,
+      comment: comment ?? null,
+      ignore_not_found: ignoreNotFound ?? null,
+      transaction_opaque_data: transactionOpaqueData ?? null
+    });
+  }
+  async macroGet(attachOpaqueData, schemaName, name, transactionOpaqueData) {
+    const result = await this.rpc.call("catalog_macro_get", {
+      attach_opaque_data: attachOpaqueData,
+      schema_name: schemaName,
+      name,
+      transaction_opaque_data: transactionOpaqueData ?? null
+    });
+    if (!result)
+      return null;
+    const inner = unwrapResult(result);
+    const items = deserializeInfoList(inner.items, decodeMacroInfo);
+    return items.length > 0 ? items[0] : null;
+  }
+  async schemaContentsMacros(attachOpaqueData, name, type, transactionOpaqueData) {
+    const result = await this.rpc.call("catalog_schema_contents_macros", {
+      attach_opaque_data: attachOpaqueData,
+      name,
+      type,
+      transaction_opaque_data: transactionOpaqueData ?? null
+    });
+    if (!result)
+      return [];
+    const inner = unwrapResult(result);
+    return deserializeInfoList(inner.items, decodeMacroInfo);
+  }
+  async macroCreate(attachOpaqueData, schemaName, name, macroType, parameters, definition, onConflict, parameterDefaultValues, argumentsSchema, transactionOpaqueData) {
+    const schema3 = schema2([
+      field2("attach_opaque_data", binary2(), true),
+      field2("schema_name", utf82(), false),
+      field2("name", utf82(), false),
+      field2("macro_type", utf82(), false),
+      field2("parameters", list2(field2("item", utf82(), false)), false),
+      field2("definition", utf82(), false),
+      field2("on_conflict", utf82(), false),
+      field2("parameter_default_values", binary2(), true),
+      field2("arguments_schema", binary2(), true),
+      field2("transaction_opaque_data", binary2(), true)
+    ]);
+    const innerBatch = batchFromColumns({
+      attach_opaque_data: [attachOpaqueData],
+      schema_name: [schemaName],
+      name: [name],
+      macro_type: [macroType],
+      parameters: [parameters],
+      definition: [definition],
+      on_conflict: [onConflict],
+      parameter_default_values: [parameterDefaultValues ?? null],
+      arguments_schema: [argumentsSchema ?? null],
+      transaction_opaque_data: [transactionOpaqueData ?? null]
+    }, schema3);
+    await this.rpc.call("catalog_macro_create", wrapRequest(innerBatch));
+  }
+  async macroDrop(attachOpaqueData, schemaName, name, ignoreNotFound, transactionOpaqueData) {
+    await this.rpc.call("catalog_macro_drop", {
+      attach_opaque_data: attachOpaqueData,
+      schema_name: schemaName,
+      name,
+      ignore_not_found: ignoreNotFound ?? false,
+      transaction_opaque_data: transactionOpaqueData ?? null
+    });
+  }
+  close() {
+    this.rpc.close();
+  }
+}
+// src/arguments/argument-spec.ts
+function argumentSpecSortKey(spec) {
+  if (typeof spec.position === "number") {
+    return [0, spec.position];
+  }
+  return [1, spec.position];
+}
+function argumentSpecsToSchema(specs) {
+  const sorted = [...specs].sort((a, b) => {
+    const ka = argumentSpecSortKey(a);
+    const kb = argumentSpecSortKey(b);
+    if (ka[0] !== kb[0])
+      return ka[0] - kb[0];
+    if (typeof ka[1] === "number" && typeof kb[1] === "number") {
+      return ka[1] - kb[1];
+    }
+    return String(ka[1]).localeCompare(String(kb[1]));
+  });
+  const fields = [];
+  for (const spec of sorted) {
+    const metadata = new Map;
+    if (typeof spec.position === "string") {
+      metadata.set(VGI_ARG_KEY, VGI_ARG_NAMED);
+    }
+    if (spec.isTableInput) {
+      metadata.set(VGI_TYPE_KEY, VGI_TYPE_TABLE);
+    } else if (spec.isAnyType) {
+      metadata.set(VGI_TYPE_KEY, VGI_TYPE_ANY);
+    }
+    if (spec.isVarargs) {
+      metadata.set(VGI_VARARGS_KEY, VGI_VARARGS_TRUE);
+    }
+    if (spec.isConst) {
+      metadata.set(VGI_CONST_KEY, VGI_CONST_TRUE);
+    }
+    if (spec.doc) {
+      metadata.set(VGI_DOC_KEY, spec.doc);
+    }
+    if (spec.defaultJson !== undefined) {
+      metadata.set(VGI_DEFAULT_KEY, spec.defaultJson);
+    }
+    if (spec.choicesJson !== undefined) {
+      metadata.set(VGI_CHOICES_KEY, spec.choicesJson);
+    }
+    if (spec.rangeNotation !== undefined) {
+      metadata.set(VGI_RANGE_KEY, spec.rangeNotation);
+    }
+    if (spec.pattern !== undefined) {
+      metadata.set(VGI_PATTERN_KEY, spec.pattern);
+    }
+    const field3 = field2(spec.name, spec.arrowType, true, metadata.size > 0 ? metadata : undefined);
+    fields.push(field3);
+  }
+  return schema2(fields);
+}
+function schemaToArgumentSpecs(schema3) {
+  const specs = [];
+  let positionIndex = 0;
+  for (const field3 of schema3.fields) {
+    const metadata = field3.metadata;
+    const isNamed = metadata.get(VGI_ARG_KEY) === VGI_ARG_NAMED;
+    const position = isNamed ? field3.name : positionIndex++;
+    const vgiType = metadata.get(VGI_TYPE_KEY);
+    const isTableInput = vgiType === VGI_TYPE_TABLE;
+    const isAnyType = vgiType === VGI_TYPE_ANY;
+    const isVarargs = metadata.get(VGI_VARARGS_KEY) === VGI_VARARGS_TRUE;
+    const isConst = metadata.get(VGI_CONST_KEY) === VGI_CONST_TRUE;
+    const doc = metadata.get(VGI_DOC_KEY) ?? "";
+    const defaultJson = metadata.get(VGI_DEFAULT_KEY);
+    const choicesJson = metadata.get(VGI_CHOICES_KEY);
+    const rangeNotation = metadata.get(VGI_RANGE_KEY);
+    const pattern = metadata.get(VGI_PATTERN_KEY);
+    specs.push({
+      name: field3.name,
+      position,
+      arrowType: field3.type,
+      isTableInput,
+      isAnyType,
+      isVarargs,
+      isConst,
+      doc,
+      defaultJson,
+      choicesJson,
+      rangeNotation,
+      pattern
+    });
+  }
+  return specs;
+}
 export {
   toUint8Array,
   serializeSchema,
@@ -45,4 +3906,4 @@ export {
   ArgumentValidationError
 };
 
-//# debugId=C4422E46DEACD50764756E2164756E21
+//# debugId=02E1D95AF7E1275C64756E2164756E21