@query-farm/vgi 0.30.0 → 0.32.0

package/dist/index.js

@@ -2008,8 +2008,8 @@ class FunctionStorageCfDo {
       fetch: this._fetch
     });
   }
-  async workerPut(executionId, workerId, state) {
-    await this._statePutMany(executionId, NS_WORKER, [[int64Key(workerId), state]]);
+  async workerPut(executionId, worker, state) {
+    await this._statePutMany(executionId, NS_WORKER, [[workerStateKey(worker), state]]);
   }
   async workerCollect(executionId) {
     const rows = await this._statePaged("state_drain", executionId, NS_WORKER, newAttemptId());
@@ -2154,11 +2154,6 @@ function newAttemptId() {
     s += b[i].toString(16).padStart(2, "0");
   return s;
 }
-function int64Key(v) {
-  const b = new Uint8Array(8);
-  new DataView(b.buffer).setBigInt64(0, BigInt(v), false);
-  return b;
-}
 function int64FromKey(b) {
   if (b.length !== 8)
     return 0;
@@ -2231,11 +2226,14 @@ function getDefaultDbPath() {
   mkdirSync(stateDir, { recursive: true });
   return join(stateDir, "vgi_storage.db");
 }
-function int64Key2(v) {
+function int64Key(v) {
   const b = new Uint8Array(8);
   new DataView(b.buffer).setBigInt64(0, BigInt(v), false);
   return b;
 }
+function workerStateKey(worker) {
+  return typeof worker === "number" ? int64Key(worker) : worker;
+}
 function int64FromKey2(b) {
   if (b.length !== 8)
     return 0;
@@ -2336,8 +2334,8 @@ class FunctionStorageSqlite {
     total += this._db.prepare("DELETE FROM function_state_log WHERE scope_id = ?").run(eid).changes;
     return total;
   }
-  async workerPut(executionId, workerId, state) {
-    this._db.prepare("INSERT OR REPLACE INTO function_state (scope_id, ns, key, value) VALUES (?, ?, ?, ?)").run(bufferArg(executionId), bufferArg(NS_WORKER2), bufferArg(int64Key2(workerId)), bufferArg(state));
+  async workerPut(executionId, worker, state) {
+    this._db.prepare("INSERT OR REPLACE INTO function_state (scope_id, ns, key, value) VALUES (?, ?, ?, ?)").run(bufferArg(executionId), bufferArg(NS_WORKER2), bufferArg(workerStateKey(worker)), bufferArg(state));
   }
   async workerCollect(executionId) {
     const rows = this._db.prepare("DELETE FROM function_state WHERE scope_id = ? AND ns = ? RETURNING value").all(bufferArg(executionId), bufferArg(NS_WORKER2));
@@ -2374,12 +2372,14 @@ class FunctionStorageSqlite {
 class BoundStorage {
   _base;
   _executionId;
-  constructor(storage, executionId) {
+  _substreamId;
+  constructor(storage, executionId, substreamId = null) {
     this._base = storage;
     this._executionId = executionId;
+    this._substreamId = substreamId;
   }
   put(state) {
-    return this._base.workerPut(this._executionId, process.pid, state);
+    return this._base.workerPut(this._executionId, this._substreamId ?? process.pid, state);
   }
   collect() {
     return this._base.workerCollect(this._executionId);
@@ -3808,9 +3808,24 @@ function buildJoinKeysLookup(joinKeyBatches) {
 }
 
 // src/filter-pushdown/evaluate.ts
-function readCell(batch, index, row) {
-  const column = batch.getChildAt(index);
-  return column ? readCanonicalValue(batch.schema.fields[index].type, column, row) : null;
+var RESOLVED_COLUMNS = new WeakMap;
+function resolveColumn(batch, columnName) {
+  let byName = RESOLVED_COLUMNS.get(batch);
+  if (!byName) {
+    byName = new Map;
+    RESOLVED_COLUMNS.set(batch, byName);
+  }
+  let resolved = byName.get(columnName);
+  if (resolved === undefined) {
+    const index = batch.schema.fields.findIndex((field) => field.name === columnName);
+    if (index < 0) {
+      throw new FilterV2Error(`filter column ${columnName} is unavailable in emitted batch`);
+    }
+    const column = batch.getChildAt(index);
+    resolved = column ? { type: batch.schema.fields[index].type, column } : null;
+    byName.set(columnName, resolved);
+  }
+  return resolved;
 }
 function deepEqual(left, right) {
   if (typeof left === "number" && typeof right === "number") {
@@ -4104,11 +4119,8 @@ function evaluateCall(expression, args) {
 function evaluateExpression(expression, batch, row, context) {
   switch (expression.node) {
     case "column_ref": {
-      const projectedIndex = batch.schema.fields.findIndex((field) => field.name === expression.columnName);
-      if (projectedIndex < 0) {
-        throw new FilterV2Error(`filter column ${expression.columnName} is unavailable in emitted batch`);
-      }
-      return readCell(batch, projectedIndex, row);
+      const resolved = resolveColumn(batch, expression.columnName);
+      return resolved ? readCanonicalValue(resolved.type, resolved.column, row) : null;
     }
     case "field_ref": {
       const parent = evaluateExpression(expression.expression, batch, row, context);
@@ -4242,6 +4254,17 @@ class PushdownFilters {
   applyDelta(batch) {
     return applyFilterDelta(this, batch);
   }
+  withPredicateOrder(order) {
+    const predicates = this.predicates;
+    if (predicates.length === order.length && predicates.every((predicate, i) => predicate.id === order[i])) {
+      return this;
+    }
+    const byId = new Map(predicates.map((predicate) => [predicate.id, predicate]));
+    if (order.length !== byId.size || new Set(order).size !== order.length || !order.every((id) => byId.has(id))) {
+      throw new FilterV2Error("recorded predicate order does not match the replayed filter state");
+    }
+    return new PushdownFilters(order.map((id) => byId.get(id)), this.evaluationContext, this.options, new Map(this.revisions), new Set(this.requiredIds));
+  }
   evaluate(batch) {
     const mask = new Uint8Array(batch.numRows);
     mask.fill(1);
@@ -4346,6 +4369,148 @@ function expressionToSql(expression) {
       return `${filterFunctionIdentityKey(expression.algorithm)}(${expressionToSql(expression.input)})`;
   }
 }
+// src/filter-pushdown/history.ts
+init_arrow();
+var MAX_ENCODED_DELTA_BYTES = 24 << 20;
+var MAX_DELTA_IPC_BYTES = 17 << 20;
+var BASE64 = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+var EMPTY_FILTER_HISTORY = Object.freeze({
+  deltas: Object.freeze([]),
+  order: Object.freeze([])
+});
+function decodeDynamicFilterMetadata(encoded) {
+  if (new TextEncoder().encode(encoded).byteLength > MAX_ENCODED_DELTA_BYTES) {
+    throw new Error("base64 dynamic filter metadata exceeds the encoded-size limit");
+  }
+  if (encoded.length % 4 !== 0 || !BASE64.test(encoded)) {
+    throw new Error("dynamic filter metadata is not valid base64");
+  }
+  const binary = globalThis.atob ? globalThis.atob(encoded) : Buffer.from(encoded, "base64").toString("binary");
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0;i < binary.length; i++)
+    bytes[i] = binary.charCodeAt(i);
+  if (bytes.byteLength > MAX_DELTA_IPC_BYTES) {
+    throw new Error("dynamic filter IPC payload exceeds the encoded-size limit");
+  }
+  return bytes;
+}
+function decodeFilterDelta(bytes) {
+  if (bytes.byteLength > MAX_DELTA_IPC_BYTES) {
+    throw new Error("dynamic filter IPC payload exceeds the encoded-size limit");
+  }
+  const batch = bytes.byteLength > 0 ? deserializeBatch(bytes) : null;
+  if (!batch || batch.numRows === 0 && batch.schema.fields.length === 0) {
+    throw new Error("dynamic filter metadata must contain one RecordBatch");
+  }
+  return batch;
+}
+function deltaRevisionKeys(batch) {
+  const column = batch.getChildAt(0);
+  if (!column)
+    throw new FilterV2Error("delta document has no filter_spec column");
+  const raw = readCanonicalValue(batch.schema.fields[0].type, column, 0);
+  const document = JSON.parse(String(raw));
+  return (document.updates ?? []).map((update) => revisionKey(update.id, update.revision));
+}
+function revisionKey(id, revision) {
+  return `${id}\x00${revision}`;
+}
+function recordFilterDelta(current, history, deltaBytes) {
+  const incoming = decodeFilterDelta(deltaBytes);
+  const filters = current.applyDelta(incoming);
+  const wanted = new Set;
+  for (const [id, revision] of filters.revisions)
+    wanted.add(revisionKey(id, revision));
+  const deltas = [];
+  const consider = (bytes, batch) => {
+    let carries = false;
+    for (const key of deltaRevisionKeys(batch)) {
+      if (wanted.delete(key))
+        carries = true;
+    }
+    if (carries)
+      deltas.push(bytes);
+  };
+  for (const bytes of history.deltas)
+    consider(bytes, decodeFilterDelta(bytes));
+  consider(deltaBytes, incoming);
+  return { filters, history: { deltas, order: filters.predicates.map((predicate) => predicate.id) } };
+}
+var HISTORY_FORMAT_VERSION = 1;
+var UTF8_ENCODER = new TextEncoder;
+var UTF8_DECODER = new TextDecoder("utf-8", { fatal: true });
+function encodeFilterHistory(history) {
+  if (!history || history.deltas.length === 0)
+    return null;
+  const ids = history.order.map((id) => UTF8_ENCODER.encode(id));
+  let size = 1 + 4 + 4;
+  for (const delta of history.deltas)
+    size += 4 + delta.byteLength;
+  for (const id of ids)
+    size += 4 + id.byteLength;
+  const out = new Uint8Array(size);
+  const view = new DataView(out.buffer);
+  let offset = 0;
+  out[offset++] = HISTORY_FORMAT_VERSION;
+  const put = (chunks) => {
+    view.setUint32(offset, chunks.length, true);
+    offset += 4;
+    for (const chunk of chunks) {
+      view.setUint32(offset, chunk.byteLength, true);
+      offset += 4;
+      out.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+  };
+  put(history.deltas);
+  put(ids);
+  return out;
+}
+function decodeFilterHistory(bytes) {
+  if (!bytes || bytes.byteLength === 0)
+    return EMPTY_FILTER_HISTORY;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let offset = 0;
+  const need = (n) => {
+    if (offset + n > bytes.byteLength)
+      throw new Error("dynamic filter history in the state token is truncated");
+  };
+  need(1);
+  if (bytes[offset++] !== HISTORY_FORMAT_VERSION) {
+    throw new Error("dynamic filter history in the state token has an unknown format");
+  }
+  const take = () => {
+    need(4);
+    const count = view.getUint32(offset, true);
+    offset += 4;
+    const chunks = [];
+    for (let i = 0;i < count; i++) {
+      need(4);
+      const length = view.getUint32(offset, true);
+      offset += 4;
+      need(length);
+      chunks.push(bytes.slice(offset, offset + length));
+      offset += length;
+    }
+    return chunks;
+  };
+  const deltas = take();
+  const order = take().map((id) => UTF8_DECODER.decode(id));
+  if (offset !== bytes.byteLength)
+    throw new Error("dynamic filter history in the state token has trailing bytes");
+  return { deltas, order };
+}
+function replayFilterHistory(filters, history) {
+  if (!history || history.deltas.length === 0)
+    return filters;
+  if (!filters)
+    throw new Error("dynamic filter history carried without an initial snapshot");
+  let replayed = filters;
+  for (const bytes of history.deltas)
+    replayed = replayed.applyDelta(decodeFilterDelta(bytes));
+  return replayed.withPredicateOrder(history.order);
+}
+
 // src/filter-pushdown/collector.ts
 init_arrow();
 function formatPushedFilters(filters) {
@@ -4453,27 +4618,6 @@ class FilteringOutputCollector {
 }
 // src/functions/table.ts
 init_storage();
-function base64Decode(s) {
-  if (new TextEncoder().encode(s).byteLength > 24 << 20) {
-    throw new Error("base64 dynamic filter metadata exceeds the encoded-size limit");
-  }
-  if (s.length % 4 !== 0 || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(s)) {
-    throw new Error("dynamic filter metadata is not valid base64");
-  }
-  const bin = globalThis.atob ? globalThis.atob(s) : Buffer.from(s, "base64").toString("binary");
-  const out = new Uint8Array(bin.length);
-  for (let i = 0;i < bin.length; i++)
-    out[i] = bin.charCodeAt(i);
-  if (out.byteLength > 17 << 20)
-    throw new Error("dynamic filter IPC payload exceeds the encoded-size limit");
-  return out;
-}
-function deserializeFilterBatch(bytes) {
-  if (!bytes || bytes.length === 0)
-    return null;
-  const batch = deserializeBatch(bytes);
-  return batch.numRows === 0 && batch.schema.fields.length === 0 ? null : batch;
-}
 function makeProjectingCollector(inner, targetSchema) {
   function alreadyMatches(batch) {
     if (batch.schema.fields.length !== targetSchema.fields.length)
@@ -4654,7 +4798,7 @@ function defineTableFunction(config) {
         opaque_data: null
       };
     },
-    createStreamHandlers(request, response) {
+    createStreamHandlers(request, response, filterHistory) {
       const args = extractArgs(request.bind_call);
       const settings = batchToScalarDict(request.bind_call.settings);
       const secrets = batchToSecretDict(request.bind_call.secrets);
@@ -4667,7 +4811,8 @@ function defineTableFunction(config) {
         runtimeAlgorithms: meta.runtimeFilterAlgorithms,
         evaluationContexts: meta.filterEvaluationContexts
       };
-      const pushdownFilters = request.pushdown_filters ? deserializeFilters(request.pushdown_filters, filterOptions) : undefined;
+      const carriedFilterHistory = filterHistory ?? EMPTY_FILTER_HISTORY;
+      const pushdownFilters = replayFilterHistory(request.pushdown_filters ? deserializeFilters(request.pushdown_filters, filterOptions) : undefined, carriedFilterHistory);
       const boundStorage = new BoundStorage(storage, response.execution_id);
       const processParams = {
         args,
@@ -4688,7 +4833,11 @@ function defineTableFunction(config) {
       const state = config.initialState ? config.initialState(processParams) : null;
       return {
         outputSchema,
-        producerInit: () => ({ state, processParams }),
+        producerInit: () => ({
+          state,
+          processParams,
+          filterHistory: carriedFilterHistory
+        }),
         onTick: (pState, tickMetadata) => {
           if (!tickMetadata)
             return;
@@ -4704,11 +4853,9 @@ function defineTableFunction(config) {
           const current = pState.processParams.pushdownFilters;
           if (!current)
             throw new Error("dynamic filter delta received without an initial snapshot");
-          const bytes = base64Decode(encoded);
-          const filterBatch = deserializeFilterBatch(bytes);
-          if (!filterBatch)
-            throw new Error("dynamic filter metadata must contain one RecordBatch");
-          pState.processParams.pushdownFilters = current.applyDelta(filterBatch);
+          const recorded = recordFilterDelta(current, pState.filterHistory, decodeDynamicFilterMetadata(encoded));
+          pState.processParams.pushdownFilters = recorded.filters;
+          pState.filterHistory = recorded.history;
         },
         producerFn: async (pState, out) => {
           const current = pState.processParams.pushdownFilters;
@@ -4960,725 +5107,133 @@ function toUint8Array(val) {
   return new Uint8Array(0);
 }
 
-// src/protocol/state-serializer.ts
-var EXCHANGE_STATE_SCHEMA = schema2([
-  field2("function_name", binary2(), false),
-  field2("init_request", binary2(), false),
-  field2("execution_id", binary2(), false),
-  field2("max_workers", int642(), false),
-  field2("opaque_data", binary2(), true),
-  field2("is_producer", bool2(), false),
-  field2("user_state", binary2(), true)
-]);
-var TEXT_ENCODER = new TextEncoder;
-var TEXT_DECODER = new TextDecoder;
-var LIST_CHILD_NAME = "item";
-var emptyListElementType = () => utf82();
-function inferElementType(values) {
-  let elementType = null;
-  let elementSig = "";
-  for (const v of values) {
-    if (v === null || v === undefined)
-      continue;
-    const t = inferFieldType(v);
-    const sig = typeSignature(t);
-    if (elementType === null) {
-      elementType = t;
-      elementSig = sig;
-      continue;
-    }
-    if (sig !== elementSig) {
-      throw new Error(`inferFieldType: arrays in userState must be homogeneous; ` + `found both '${elementSig}' and '${sig}' in the same array ` + `(split the values into separate fields, or normalize them to one type)`);
-    }
+// src/protocol/carried-init-request.ts
+init_arrow();
+
+// src/util/zstd-sync.ts
+var LEVEL = 3;
+function resolveZstdSync() {
+  const bun = globalThis.Bun;
+  if (typeof bun?.zstdCompressSync === "function" && typeof bun?.zstdDecompressSync === "function") {
+    return {
+      compress: (data) => new Uint8Array(bun.zstdCompressSync(data, { level: LEVEL })),
+      decompress: (data) => new Uint8Array(bun.zstdDecompressSync(data))
+    };
   }
-  return elementType ?? emptyListElementType();
+  let zlib = null;
+  try {
+    zlib = globalThis.process?.getBuiltinModule?.("node:zlib") ?? null;
+  } catch {
+    zlib = null;
+  }
+  if (typeof zlib?.zstdCompressSync === "function" && typeof zlib?.zstdDecompressSync === "function") {
+    const params = { [zlib.constants.ZSTD_c_compressionLevel]: LEVEL };
+    return {
+      compress: (data) => new Uint8Array(zlib.zstdCompressSync(data, { params })),
+      decompress: (data) => new Uint8Array(zlib.zstdDecompressSync(data))
+    };
+  }
+  return null;
 }
-function inferFieldType(value) {
-  if (value === null || value === undefined)
-    return nullType2();
-  switch (typeof value) {
-    case "number":
-      return float642();
-    case "bigint":
-      return int642();
-    case "string":
-      return utf82();
-    case "boolean":
-      return bool2();
-    case "object":
-      if (value instanceof Uint8Array || value instanceof ArrayBuffer)
-        return binary2();
-      if (ArrayBuffer.isView(value))
-        return binary2();
-      if (Array.isArray(value)) {
-        return list2(field2(LIST_CHILD_NAME, inferElementType(value), true));
-      }
-      if (value instanceof Map) {
-        throw new Error(`inferFieldType: Map is not supported in userState (use a plain object instead)`);
-      }
-      if (value instanceof Set) {
-        throw new Error(`inferFieldType: Set is not supported in userState (use an array or plain object instead)`);
-      }
-      if (value instanceof Date) {
-        throw new Error(`inferFieldType: Date is not supported in userState (use a number (epoch ms) or ISO string instead)`);
+var resolved;
+function zstdSync() {
+  if (resolved === undefined)
+    resolved = resolveZstdSync();
+  return resolved;
+}
+
+// src/protocol/serializers/arguments.ts
+init_arrow();
+init_registry();
+
+// 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 (value instanceof RegExp) {
-        throw new Error(`inferFieldType: RegExp is not supported in userState (use a string pattern instead)`);
+      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;
       }
-      const fields = Object.entries(value).map(([k, v]) => field2(k, inferFieldType(v), true));
-      return struct2(fields);
-    default:
-      throw new Error(`inferFieldType: unsupported type '${typeof value}'`);
+      return unwrapScalar(val);
+    }
+    if (defaultValue !== undefined)
+      return defaultValue;
+    throw new Error(`Named argument '${position}' not found`);
+  }
+  get length() {
+    return this.positional.length;
   }
 }
-function serializeUserState(userState) {
-  if (userState == null)
+function unwrapScalar(val) {
+  if (val === null || val === undefined)
     return null;
-  const entries = Object.entries(userState);
-  if (entries.length === 0) {
-    return serializeBatch(batchFromColumns({}, schema2([])));
-  }
-  const fields = entries.map(([k, v]) => field2(k, inferFieldType(v), true));
-  const sch = schema2(fields);
-  const columns = {};
-  for (const [key, val] of entries) {
-    columns[key] = [val];
+  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 serializeBatch(batchFromColumns(columns, sch));
-}
-function extractTypedValue(col, index, type) {
-  return codecFor(type).canonicalToRich(readCanonicalValue(type, col, index));
+  return val;
 }
-function deserializeUserState(bytes) {
-  if (bytes == null)
-    return null;
-  const batch = deserializeBatch(bytes);
-  if (batch.numRows === 0 && batch.schema.fields.length === 0) {
-    return {};
+
+// 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;
   }
-  if (batch.numRows === 0)
-    return null;
-  const result = {};
-  for (const f of batch.schema.fields) {
-    const col = batch.getChild(f.name);
-    if (!col) {
-      result[f.name] = null;
-      continue;
+  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);
     }
-    result[f.name] = extractTypedValue(col, 0, f.type);
+    structRow[f.name] = val;
   }
-  return result;
-}
-var arrowStateSerializer = {
-  serialize(state) {
-    const columns = {
-      function_name: [TEXT_ENCODER.encode(state.functionName)],
-      init_request: [state.initRequestIpc],
-      execution_id: [state.executionId],
-      max_workers: [state.maxWorkers],
-      opaque_data: [state.opaqueData ?? null],
-      is_producer: [state.isProducer],
-      user_state: [serializeUserState(state.userState)]
-    };
-    const batch = batchFromColumns(columns, EXCHANGE_STATE_SCHEMA);
-    return serializeBatch(batch);
-  },
-  deserialize(bytes) {
-    const batch = deserializeBatch(bytes);
-    const fieldByName = new Map(batch.schema.fields.map((f) => [f.name, f]));
-    const get = (name) => {
-      const col = batch.getChild(name);
-      const f = fieldByName.get(name);
-      if (!col || !f)
-        return null;
-      const type = f.type;
-      return codecFor(type).canonicalToRich(readCanonicalValue(type, col, 0));
-    };
-    const isProducer = get("is_producer");
-    const opaqueDataRaw = get("opaque_data");
-    const fnNameRaw = get("function_name");
-    return {
-      functionName: fnNameRaw != null ? TEXT_DECODER.decode(toUint8Array(fnNameRaw)) : "",
-      initRequestIpc: toUint8Array(get("init_request")),
-      executionId: toUint8Array(get("execution_id")),
-      maxWorkers: Number(get("max_workers")),
-      opaqueData: opaqueDataRaw != null ? toUint8Array(opaqueDataRaw) : null,
-      isProducer,
-      __isProducer: isProducer,
-      userState: deserializeUserState(get("user_state") != null ? toUint8Array(get("user_state")) : null)
-    };
-  }
-};
-
-// src/functions/table-in-out.ts
-var STREAMING_FINALIZE_KEY = new Uint8Array(0);
-function defineTableInOutFunction(config) {
-  assertArrowTypes(config.args, `defineTableInOutFunction("${config.name}"): args`);
-  const specs = [];
-  let posIdx = 0;
-  if (config.args) {
-    for (const [name, type] of Object.entries(config.args)) {
-      specs.push({
-        name,
-        position: posIdx++,
-        arrowType: type,
-        doc: config.argDocs?.[name],
-        ...constraintSpecFields(config.argConstraints?.[name], config.argDefaults?.[name])
-      });
-    }
-  }
-  specs.push({
-    name: "data",
-    position: posIdx++,
-    arrowType: nullType2(),
-    isTableInput: true
-  });
-  if (config.namedArgs) {
-    for (const [name, type] of Object.entries(config.namedArgs)) {
-      specs.push({
-        name,
-        position: name,
-        arrowType: type,
-        doc: config.argDocs?.[name],
-        ...constraintSpecFields(config.argConstraints?.[name], config.argDefaults?.[name])
-      });
-    }
-  }
-  const meta = {
-    name: config.name,
-    description: config.description,
-    stability: config.stability,
-    projectionPushdown: config.projectionPushdown,
-    filterPushdown: config.filterPushdown,
-    autoApplyFilters: config.autoApplyFilters,
-    examples: config.examples,
-    categories: config.categories,
-    tags: config.tags,
-    parameterDefaultValues: config.parameterDefaultValues,
-    maxWorkers: config.maxWorkers,
-    requiredSettings: config.requiredSettings,
-    requiredSecrets: config.requiredSecrets,
-    hasFinalize: !!config.finalize
-  };
-  function extractArgs(request) {
-    const args = {};
-    for (const spec of specs) {
-      if (spec.isTableInput)
-        continue;
-      const defaultVal = config.argDefaults?.[spec.name] !== undefined ? config.argDefaults[spec.name] : undefined;
-      let val = request.arguments.get(spec.position, defaultVal);
-      val = narrowArgValue(val);
-      const constraints = config.argConstraints?.[spec.name];
-      if (constraints)
-        validateConstConstraints(spec.name, constraints, val);
-      args[spec.name] = val;
-    }
-    return args;
-  }
-  return {
-    kind: "table_in_out",
-    meta,
-    argumentSpecs: specs,
-    async bind(request) {
-      if (config.onBind) {
-        const args = extractArgs(request);
-        const settings = batchToScalarDict(request.settings);
-        const secrets = batchToSecretDict(request.secrets);
-        const result = await config.onBind({
-          args,
-          bindCall: request,
-          settings,
-          secrets,
-          argumentNames: request.argument_names ?? null
-        });
-        return {
-          output_schema: result.outputSchema,
-          opaque_data: result.opaqueData ?? null
-        };
-      }
-      return {
-        output_schema: request.input_schema ?? schema2([]),
-        opaque_data: null
-      };
-    },
-    async globalInit(request) {
-      const executionId = new Uint8Array(16);
-      crypto.getRandomValues(executionId);
-      if (request.execution_id) {
-        return {
-          max_workers: DEFAULT_MAX_WORKERS,
-          execution_id: request.execution_id,
-          opaque_data: null
-        };
-      }
-      if (config.onInit) {
-        const args = extractArgs(request.bind_call);
-        return await config.onInit({
-          args,
-          initCall: request,
-          outputSchema: request.output_schema,
-          executionId
-        });
-      }
-      return {
-        max_workers: config.maxWorkers ?? 1,
-        execution_id: executionId,
-        opaque_data: null
-      };
-    },
-    createStreamHandlers(request, response, accumulatedState) {
-      const args = extractArgs(request.bind_call);
-      const settings = batchToScalarDict(request.bind_call.settings);
-      const secrets = batchToSecretDict(request.bind_call.secrets);
-      const projIds = request.projection_ids && meta.projectionPushdown ? request.projection_ids : null;
-      const outputSchema = projIds ? projectSchema(projIds, request.output_schema) : request.output_schema;
-      const pushdownFilters = request.pushdown_filters ? deserializeFilters(request.pushdown_filters, {
-        outputSchema: request.output_schema,
-        joinKeyBatches: request.join_keys,
-        extensionFunctions: meta.additionalFilterFunctions,
-        runtimeAlgorithms: meta.runtimeFilterAlgorithms,
-        evaluationContexts: meta.filterEvaluationContexts
-      }) : undefined;
-      const boundStorage = new BoundStorage(storage, response.execution_id ?? new Uint8Array(16));
-      const processParams = {
-        args,
-        initCall: request,
-        initResponse: response,
-        outputSchema,
-        settings,
-        secrets,
-        pushdownFilters,
-        storage: boundStorage,
-        substreamId: request.substream_id ?? null
-      };
-      const phase = request.phase;
-      if (phase === "FINALIZE" /* FINALIZE */) {
-        const finalizeLogKey = STREAMING_FINALIZE_KEY;
-        return {
-          outputSchema,
-          producerInit: () => ({ state: { cursor: -1, materialized: false } }),
-          producerFn: async (pState, out) => {
-            if (!pState.state.materialized) {
-              const finalizeStates = [];
-              if (accumulatedState != null) {
-                finalizeStates.push(accumulatedState);
-              }
-              const stored = await boundStorage.collect();
-              for (const bytes of stored) {
-                finalizeStates.push(deserializeUserState(bytes));
-              }
-              if (finalizeStates.length === 0) {
-                finalizeStates.push(config.initialState ? config.initialState(processParams) : null);
-              }
-              const batches = config.finalize ? await config.finalize(processParams, finalizeStates) : [];
-              for (const batch of batches) {
-                await boundStorage.stateAppend(FrameworkNS.STREAMING_FINALIZE, finalizeLogKey, serializeBatch(batch));
-              }
-              pState.state.materialized = true;
-            }
-            const rows = await boundStorage.stateLogScan(FrameworkNS.STREAMING_FINALIZE, finalizeLogKey, pState.state.cursor, 1);
-            if (rows.length === 0) {
-              out.finish();
-              return;
-            }
-            const [logId, bytes] = rows[0];
-            out.emit(deserializeBatch(bytes));
-            pState.state.cursor = logId;
-          }
-        };
-      }
-      if (request.bind_call.input_schema == null) {
-        throw new Error(`${config.name}: is a table-in-out function (it requires an input row ` + `stream) but no input schema was supplied -- call it via ` + `table_in_out_function(input=...), not table_function().`);
-      }
-      const state = config.initialState ? config.initialState(processParams) : null;
-      const processFn = config.process ?? ((_params, _state, batch, out) => {
-        out.emit(projIds ? projectBatch(projIds, batch) : batch);
-      });
-      return {
-        outputSchema,
-        inputSchema: request.bind_call.input_schema,
-        exchangeInit: () => ({ state, processParams }),
-        exchangeFn: async (eState, input, out) => {
-          applyRevalidationValidators(eState.processParams, input);
-          applyDynamicFilterUpdate(eState.processParams, input);
-          let wrappedOut = makeMetadataBakingCollector(out);
-          if (projIds) {
-            wrappedOut = makeSchemaReconcilingCollector(wrappedOut, outputSchema);
-          }
-          const currentFilters = eState.processParams.pushdownFilters;
-          if (config.autoApplyFilters && currentFilters) {
-            wrappedOut = new FilteringOutputCollector(wrappedOut, currentFilters);
-          }
-          await processFn(eState.processParams, eState.state, input, wrappedOut);
-          if (eState.state != null) {
-            const serialized = serializeUserState(eState.state);
-            if (serialized != null) {
-              await boundStorage.put(serialized);
-            }
-          }
-        }
-      };
-    }
-  };
-}
-function applyRevalidationValidators(params, input) {
-  const md = input?.metadata;
-  params.ifNoneMatch = md?.get(CACHE_IF_NONE_MATCH_KEY);
-  params.ifModifiedSince = md?.get(CACHE_IF_MODIFIED_SINCE_KEY);
-}
-function applyDynamicFilterUpdate(params, input) {
-  const encoded = input?.metadata?.get("vgi_pushdown_filters");
-  if (!encoded)
-    return;
-  if (!params.pushdownFilters)
-    throw new Error("dynamic filter delta received without an initial snapshot");
-  if (new TextEncoder().encode(encoded).byteLength > 24 << 20) {
-    throw new Error("base64 dynamic filter metadata exceeds the encoded-size limit");
-  }
-  if (encoded.length % 4 !== 0 || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(encoded)) {
-    throw new Error("dynamic filter metadata is not valid base64");
-  }
-  const binary = globalThis.atob ? globalThis.atob(encoded) : Buffer.from(encoded, "base64").toString("binary");
-  const bytes = Uint8Array.from(binary, (character) => character.charCodeAt(0));
-  if (bytes.byteLength > 17 << 20)
-    throw new Error("dynamic filter IPC payload exceeds the encoded-size limit");
-  const current = params.pushdownFilters;
-  params.pushdownFilters = current.applyDelta(deserializeBatch(bytes));
-}
-function makeMetadataBakingCollector(inner) {
-  return new Proxy(inner, {
-    get(target, prop, receiver) {
-      if (prop === "emit") {
-        return function(batchOrColumns, metadata) {
-          if (batchOrColumns && typeof batchOrColumns.getChild === "function" && metadata && metadata.size > 0) {
-            const batch = batchOrColumns;
-            const merged = new Map(batch.metadata ?? []);
-            for (const [k, v] of metadata)
-              merged.set(k, v);
-            return target.emit(withBatchMetadata(batch, merged), merged);
-          }
-          return target.emit(batchOrColumns, metadata);
-        };
-      }
-      const v = Reflect.get(target, prop, receiver);
-      return typeof v === "function" ? v.bind(target) : v;
-    }
-  });
-}
-function makeSchemaReconcilingCollector(inner, targetSchema) {
-  function reconcile(batch) {
-    const batchFields = batch.schema.fields;
-    if (batchFields.length === targetSchema.fields.length && targetSchema.fields.every((f, i) => batchFields[i].name === f.name)) {
-      return batch;
-    }
-    const ids = [];
-    for (const f of targetSchema.fields) {
-      const idx = batchFields.findIndex((bf) => bf.name === f.name);
-      if (idx < 0) {
-        throw new Error(`emitted batch is missing projected output column '${f.name}' ` + `(emitted: [${batchFields.map((bf) => bf.name).join(", ")}])`);
-      }
-      ids.push(idx);
-    }
-    return projectBatch(ids, batch);
-  }
-  return new Proxy(inner, {
-    get(target, prop, receiver) {
-      if (prop === "emit") {
-        return function(batchOrColumns, metadata) {
-          if (batchOrColumns && typeof batchOrColumns.getChild === "function") {
-            return target.emit(reconcile(batchOrColumns), metadata);
-          }
-          return target.emit(batchOrColumns, metadata);
-        };
-      }
-      const v = Reflect.get(target, prop, receiver);
-      return typeof v === "function" ? v.bind(target) : v;
-    }
-  });
-}
-var PARENT_ROW_METADATA_KEY = "vgi_rpc.parent_row#b64";
-function parentRowsMetadata(parentRows, outputRows, extra) {
-  if (parentRows.length !== outputRows) {
-    throw new Error(`parentRowsMetadata: length ${parentRows.length} != output rows ${outputRows}; ` + `parentRows must carry exactly one input-row index per emitted output row`);
-  }
-  const md = new Map(extra ?? []);
-  if (outputRows === 0) {
-    return md;
-  }
-  const raw = new Uint8Array(parentRows.length * 4);
-  const dv = new DataView(raw.buffer);
-  for (let i = 0;i < parentRows.length; i++) {
-    dv.setInt32(i * 4, parentRows[i], true);
-  }
-  md.set(PARENT_ROW_METADATA_KEY, base64Encode(raw));
-  return md;
-}
-function base64Encode(bytes) {
-  if (typeof globalThis.Buffer !== "undefined") {
-    return globalThis.Buffer.from(bytes).toString("base64");
-  }
-  let bin = "";
-  for (let i = 0;i < bytes.length; i++)
-    bin += String.fromCharCode(bytes[i]);
-  return globalThis.btoa(bin);
-}
-function defineRowTransformFunction(config) {
-  const numPositional = Object.keys(config.args ?? {}).length + (config.varargs ? 1 : 0);
-  if (numPositional === 0) {
-    throw new Error(`${config.name}: a blended row-transform function needs at least one ` + `positional arg (its per-row input column); found none.`);
-  }
-  const specs = [];
-  let posIdx = 0;
-  if (config.args) {
-    for (const [name, type] of Object.entries(config.args)) {
-      specs.push({
-        name,
-        position: posIdx++,
-        arrowType: type,
-        doc: config.argDocs?.[name],
-        ...constraintSpecFields(config.argConstraints?.[name])
-      });
-    }
-  }
-  if (config.varargs) {
-    specs.push({
-      name: config.varargs.name,
-      position: posIdx++,
-      arrowType: config.varargs.type,
-      isVarargs: true,
-      doc: config.varargs.doc ?? config.argDocs?.[config.varargs.name],
-      ...constraintSpecFields(config.argConstraints?.[config.varargs.name])
-    });
-  }
-  if (config.namedArgs) {
-    for (const [name, type] of Object.entries(config.namedArgs)) {
-      specs.push({
-        name,
-        position: name,
-        arrowType: type,
-        doc: config.argDocs?.[name],
-        ...constraintSpecFields(config.argConstraints?.[name], config.argDefaults?.[name])
-      });
-    }
-  }
-  const meta = {
-    name: config.name,
-    description: config.description,
-    stability: config.stability,
-    projectionPushdown: config.projectionPushdown,
-    filterPushdown: config.filterPushdown,
-    autoApplyFilters: config.autoApplyFilters,
-    examples: config.examples,
-    categories: config.categories,
-    tags: config.tags,
-    parameterDefaultValues: config.parameterDefaultValues,
-    maxWorkers: config.maxWorkers,
-    requiredSettings: config.requiredSettings,
-    requiredSecrets: config.requiredSecrets,
-    hasFinalize: false,
-    inputFromArgs: true
-  };
-  function extractArgs(request) {
-    const args = {};
-    for (const spec of specs) {
-      if (typeof spec.position !== "string")
-        continue;
-      const defaultVal = config.argDefaults?.[spec.name] !== undefined ? config.argDefaults[spec.name] : undefined;
-      let val = request.arguments.get(spec.position, defaultVal ?? null);
-      val = narrowArgValue(val);
-      const constraints = config.argConstraints?.[spec.name];
-      if (constraints)
-        validateConstConstraints(spec.name, constraints, val);
-      args[spec.name] = val;
-    }
-    return args;
-  }
-  return {
-    kind: "table_in_out",
-    meta,
-    argumentSpecs: specs,
-    async bind(request) {
-      const args = extractArgs(request);
-      const settings = batchToScalarDict(request.settings);
-      const secrets = batchToSecretDict(request.secrets);
-      const result = await config.onBind({
-        args,
-        bindCall: request,
-        settings,
-        secrets,
-        argumentNames: request.argument_names ?? null
-      });
-      return {
-        output_schema: result.outputSchema,
-        opaque_data: result.opaqueData ?? null
-      };
-    },
-    async globalInit(request) {
-      if (request.execution_id) {
-        return {
-          max_workers: DEFAULT_MAX_WORKERS,
-          execution_id: request.execution_id,
-          opaque_data: null
-        };
-      }
-      const executionId = new Uint8Array(16);
-      crypto.getRandomValues(executionId);
-      return {
-        max_workers: config.maxWorkers ?? 1,
-        execution_id: executionId,
-        opaque_data: null
-      };
-    },
-    createStreamHandlers(request, response, _accumulatedState) {
-      const args = extractArgs(request.bind_call);
-      const settings = batchToScalarDict(request.bind_call.settings);
-      const secrets = batchToSecretDict(request.bind_call.secrets);
-      const projIds = request.projection_ids && meta.projectionPushdown ? request.projection_ids : null;
-      const outputSchema = projIds ? projectSchema(projIds, request.output_schema) : request.output_schema;
-      const pushdownFilters = request.pushdown_filters ? deserializeFilters(request.pushdown_filters, {
-        outputSchema: request.output_schema,
-        joinKeyBatches: request.join_keys,
-        extensionFunctions: meta.additionalFilterFunctions,
-        runtimeAlgorithms: meta.runtimeFilterAlgorithms,
-        evaluationContexts: meta.filterEvaluationContexts
-      }) : undefined;
-      const boundStorage = new BoundStorage(storage, response.execution_id ?? new Uint8Array(16));
-      const processParams = {
-        args,
-        initCall: request,
-        initResponse: response,
-        outputSchema,
-        settings,
-        secrets,
-        pushdownFilters,
-        storage: boundStorage,
-        substreamId: request.substream_id ?? null
-      };
-      if (request.phase === "FINALIZE" /* FINALIZE */) {
-        throw new Error(`${config.name}: a blended row-transform function has no FINALIZE ` + `phase (it is a per-row map; has_finalize is advertised false).`);
-      }
-      if (request.bind_call.input_schema == null) {
-        throw new Error(`${config.name}: is a table-in-out function (its positional args are ` + `per-row input columns) but no input schema was supplied -- call it ` + `via table_in_out_function(input=...), not table_function().`);
-      }
-      return {
-        outputSchema,
-        inputSchema: request.bind_call.input_schema,
-        exchangeInit: () => ({ state: null, processParams }),
-        exchangeFn: async (eState, input, out) => {
-          applyRevalidationValidators(eState.processParams, input);
-          applyDynamicFilterUpdate(eState.processParams, input);
-          let wrappedOut = makeMetadataBakingCollector(out);
-          if (projIds) {
-            wrappedOut = makeSchemaReconcilingCollector(wrappedOut, outputSchema);
-          }
-          const currentFilters = eState.processParams.pushdownFilters;
-          if (config.autoApplyFilters && currentFilters) {
-            wrappedOut = new FilteringOutputCollector(wrappedOut, currentFilters);
-          }
-          await config.process(eState.processParams, input, wrappedOut);
-        }
-      };
-    }
-  };
-}
-// src/functions/table-buffering.ts
-init_arrow();
-init_arrow();
-init_registry();
-init_storage();
-
-// src/protocol/serializers/arguments.ts
-init_arrow();
-init_registry();
-
-// 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/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);
+  const batch = batchFromColumns({ args: [structRow] }, sch);
+  return serializeBatch(batch);
 }
 function inferScalarType(val) {
   if (val === null || val === undefined)
@@ -5968,162 +5523,892 @@ function serializeInitRequest(req) {
     tablesample_percentage: req.tablesample_percentage ?? null,
     tablesample_seed: req.tablesample_seed ?? null
   };
-  return buildSingleRowBatch(INIT_REQUEST_SCHEMA, row);
+  return buildSingleRowBatch(INIT_REQUEST_SCHEMA, row);
+}
+function deserializeInitRequest(params) {
+  const bindCallBytes = toUint8Array2(params.bind_call);
+  const bindCallBatch = deserializeBatch(bindCallBytes);
+  const bindParams = batchToScalarDict(bindCallBatch);
+  const bindCall = deserializeBindRequest(bindParams);
+  let projectionIds = null;
+  if (params.projection_ids != null) {
+    const raw = params.projection_ids;
+    if (Array.isArray(raw)) {
+      projectionIds = raw.map(Number);
+    } else if (raw && typeof raw[Symbol.iterator] === "function") {
+      projectionIds = [...raw].map(Number);
+    }
+  }
+  let phase = null;
+  const phaseRaw = decodeDictValue(params.phase);
+  if (phaseRaw != null) {
+    const phaseStr = String(phaseRaw);
+    if (phaseStr === "INPUT") {
+      phase = "INPUT" /* INPUT */;
+    } else if (phaseStr === "FINALIZE") {
+      phase = "FINALIZE" /* FINALIZE */;
+    } else if (phaseStr === "TABLE_BUFFERING") {
+      phase = "TABLE_BUFFERING" /* TABLE_BUFFERING */;
+    } else if (phaseStr === "TABLE_BUFFERING_FINALIZE") {
+      phase = "TABLE_BUFFERING_FINALIZE" /* TABLE_BUFFERING_FINALIZE */;
+    }
+  }
+  const joinKeys = [];
+  if (params.join_keys != null) {
+    const raw = params.join_keys;
+    const iter = Array.isArray(raw) ? raw : typeof raw[Symbol.iterator] === "function" ? raw : [];
+    for (const entry of iter) {
+      if (entry == null)
+        continue;
+      try {
+        joinKeys.push(deserializeBatch(toUint8Array2(entry)));
+      } catch {}
+    }
+  }
+  return {
+    bind_call: bindCall,
+    output_schema: deserializeSchema(toUint8Array2(params.output_schema)),
+    bind_opaque_data: params.bind_opaque_data ? toUint8Array2(params.bind_opaque_data) : null,
+    projection_ids: projectionIds,
+    row_limit: params.row_limit == null ? null : Number(params.row_limit),
+    pushdown_filters: params.pushdown_filters ? deserializeBatch(toUint8Array2(params.pushdown_filters)) : null,
+    join_keys: joinKeys,
+    phase,
+    finalize_state_id: params.finalize_state_id ? toUint8Array2(params.finalize_state_id) : null,
+    split_tokens: (() => {
+      const raw = params.split_tokens;
+      if (raw == null)
+        return null;
+      const iter = Array.isArray(raw) ? raw : typeof raw[Symbol.iterator] === "function" ? raw : [];
+      const tokens = [...iter].filter((e) => e != null).map((e) => toUint8Array2(e));
+      return tokens.length > 0 ? tokens : null;
+    })(),
+    execution_id: params.execution_id ? toUint8Array2(params.execution_id) : null,
+    init_opaque_data: params.init_opaque_data ? toUint8Array2(params.init_opaque_data) : null,
+    substream_id: params.substream_id ? toUint8Array2(params.substream_id) : null,
+    order_by_column_name: parseEnum(decodeDictValue(params.order_by_column_name)) ?? null,
+    order_by_direction: parseDirection(decodeDictValue(params.order_by_direction)),
+    order_by_null_order: parseNullOrder(decodeDictValue(params.order_by_null_order)),
+    order_by_limit: parseBigInt(params.order_by_limit),
+    tablesample_percentage: parseNumber(params.tablesample_percentage),
+    tablesample_seed: parseBigInt(params.tablesample_seed)
+  };
+}
+function parseEnum(v) {
+  if (v === null || v === undefined)
+    return null;
+  return String(v);
+}
+function parseDirection(v) {
+  if (v === null || v === undefined)
+    return null;
+  const s = String(v);
+  if (s === "ASC")
+    return "ASC" /* ASC */;
+  if (s === "DESC")
+    return "DESC" /* DESC */;
+  return null;
+}
+function parseNullOrder(v) {
+  if (v === null || v === undefined)
+    return null;
+  const s = String(v);
+  if (s === "NULLS_FIRST")
+    return "NULLS_FIRST" /* NULLS_FIRST */;
+  if (s === "NULLS_LAST")
+    return "NULLS_LAST" /* NULLS_LAST */;
+  return null;
+}
+function parseBigInt(v) {
+  if (v === null || v === undefined)
+    return null;
+  if (typeof v === "bigint")
+    return v;
+  if (typeof v === "number")
+    return BigInt(v);
+  try {
+    return BigInt(String(v));
+  } catch {
+    return null;
+  }
+}
+function parseNumber(v) {
+  if (v === null || v === undefined)
+    return null;
+  if (typeof v === "number")
+    return v;
+  if (typeof v === "bigint")
+    return Number(v);
+  const n = Number(v);
+  return Number.isNaN(n) ? null : n;
+}
+function serializeGlobalInitResponse(resp) {
+  return {
+    execution_id: resp.execution_id,
+    opaque_data: resp.opaque_data ?? null,
+    max_workers: resp.max_workers
+  };
 }
-function deserializeInitRequest(params) {
+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/protocol/serializers/cardinality.ts
+init_arrow();
+var TABLE_FUNCTION_CARDINALITY_REQUEST_SCHEMA = schema2([
+  field2("bind_call", binary2(), false),
+  field2("bind_opaque_data", binary2(), true)
+]);
+function deserializeCardinalityRequest(params) {
   const bindCallBytes = toUint8Array2(params.bind_call);
   const bindCallBatch = deserializeBatch(bindCallBytes);
   const bindParams = batchToScalarDict(bindCallBatch);
   const bindCall = deserializeBindRequest(bindParams);
-  let projectionIds = null;
-  if (params.projection_ids != null) {
-    const raw = params.projection_ids;
-    if (Array.isArray(raw)) {
-      projectionIds = raw.map(Number);
-    } else if (raw && typeof raw[Symbol.iterator] === "function") {
-      projectionIds = [...raw].map(Number);
+  return {
+    bind_call: bindCall,
+    bind_opaque_data: params.bind_opaque_data ? toUint8Array2(params.bind_opaque_data) : null
+  };
+}
+function serializeTableCardinality(card) {
+  return {
+    estimate: card.estimate,
+    max: card.max
+  };
+}
+// src/protocol/carried-init-request.ts
+var RAW = 0;
+var ZSTD = 1;
+function packInitRequest(ipc) {
+  const codec = zstdSync();
+  const compressed = codec ? codec.compress(ipc) : null;
+  const useZstd = compressed !== null && compressed.byteLength < ipc.byteLength;
+  const payload = useZstd ? compressed : ipc;
+  const packed = new Uint8Array(payload.byteLength + 1);
+  packed[0] = useZstd ? ZSTD : RAW;
+  packed.set(payload, 1);
+  return packed;
+}
+function unpackInitRequest(packed) {
+  if (packed.byteLength === 0)
+    throw new Error("state token carries no init request");
+  switch (packed[0]) {
+    case RAW:
+      return packed.slice(1);
+    case ZSTD: {
+      const codec = zstdSync();
+      if (!codec) {
+        throw new Error("state token carries a zstd-compressed init request, and this runtime has no synchronous zstd " + "(it was minted by a worker running under Bun or Node >= 22.15 with the same signing key)");
+      }
+      return codec.decompress(packed.subarray(1));
     }
+    default:
+      throw new Error(`state token carries an init request with unknown codec ${packed[0]}`);
   }
-  let phase = null;
-  const phaseRaw = decodeDictValue(params.phase);
-  if (phaseRaw != null) {
-    const phaseStr = String(phaseRaw);
-    if (phaseStr === "INPUT") {
-      phase = "INPUT" /* INPUT */;
-    } else if (phaseStr === "FINALIZE") {
-      phase = "FINALIZE" /* FINALIZE */;
-    } else if (phaseStr === "TABLE_BUFFERING") {
-      phase = "TABLE_BUFFERING" /* TABLE_BUFFERING */;
-    } else if (phaseStr === "TABLE_BUFFERING_FINALIZE") {
-      phase = "TABLE_BUFFERING_FINALIZE" /* TABLE_BUFFERING_FINALIZE */;
+}
+var MAX_ENTRIES = 128;
+var parsed = new Map;
+var stats = { parses: 0, hits: 0 };
+function hashBytes(bytes) {
+  let h = 2166136261 ^ bytes.byteLength;
+  for (let i = 0;i < bytes.byteLength; i++) {
+    h ^= bytes[i];
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+function sameBytes(a, b) {
+  if (a.byteLength !== b.byteLength)
+    return false;
+  for (let i = 0;i < a.byteLength; i++)
+    if (a[i] !== b[i])
+      return false;
+  return true;
+}
+function parseCarriedInitRequest(packed) {
+  const key = hashBytes(packed);
+  let entry = parsed.get(key);
+  if (entry && sameBytes(entry.packed, packed)) {
+    parsed.delete(key);
+    parsed.set(key, entry);
+    stats.hits++;
+  } else {
+    const dict = batchToScalarDict(deserializeBatch(unpackInitRequest(packed)));
+    stats.parses++;
+    entry = { packed: packed.slice(), request: deserializeInitRequest(dict), bindCallIpc: dict.bind_call };
+    parsed.delete(key);
+    if (parsed.size >= MAX_ENTRIES)
+      parsed.delete(parsed.keys().next().value);
+    parsed.set(key, entry);
+  }
+  return {
+    request: { ...entry.request, bind_call: { ...entry.request.bind_call } },
+    bindCallIpc: entry.bindCallIpc
+  };
+}
+
+// src/protocol/state-serializer.ts
+var EXCHANGE_STATE_SCHEMA = schema2([
+  field2("function_name", binary2(), false),
+  field2("init_request", binary2(), false),
+  field2("execution_id", binary2(), false),
+  field2("max_workers", int642(), false),
+  field2("opaque_data", binary2(), true),
+  field2("is_producer", bool2(), false),
+  field2("user_state", binary2(), true),
+  field2("filter_history", binary2(), true)
+]);
+var TEXT_ENCODER = new TextEncoder;
+var TEXT_DECODER = new TextDecoder;
+var STATE_FORMAT_VERSION = 1;
+var FLAG_PRODUCER = 1;
+var FLAG_OPAQUE_DATA = 2;
+var FLAG_USER_STATE = 4;
+var FLAG_FILTER_HISTORY = 8;
+var LIST_CHILD_NAME = "item";
+var emptyListElementType = () => utf82();
+function inferElementType(values) {
+  let elementType = null;
+  let elementSig = "";
+  for (const v of values) {
+    if (v === null || v === undefined)
+      continue;
+    const t = inferFieldType(v);
+    const sig = typeSignature(t);
+    if (elementType === null) {
+      elementType = t;
+      elementSig = sig;
+      continue;
+    }
+    if (sig !== elementSig) {
+      throw new Error(`inferFieldType: arrays in userState must be homogeneous; ` + `found both '${elementSig}' and '${sig}' in the same array ` + `(split the values into separate fields, or normalize them to one type)`);
     }
   }
-  const joinKeys = [];
-  if (params.join_keys != null) {
-    const raw = params.join_keys;
-    const iter = Array.isArray(raw) ? raw : typeof raw[Symbol.iterator] === "function" ? raw : [];
-    for (const entry of iter) {
-      if (entry == null)
+  return elementType ?? emptyListElementType();
+}
+function inferFieldType(value) {
+  if (value === null || value === undefined)
+    return nullType2();
+  switch (typeof value) {
+    case "number":
+      return float642();
+    case "bigint":
+      return int642();
+    case "string":
+      return utf82();
+    case "boolean":
+      return bool2();
+    case "object":
+      if (value instanceof Uint8Array || value instanceof ArrayBuffer)
+        return binary2();
+      if (ArrayBuffer.isView(value))
+        return binary2();
+      if (Array.isArray(value)) {
+        return list2(field2(LIST_CHILD_NAME, inferElementType(value), true));
+      }
+      if (value instanceof Map) {
+        throw new Error(`inferFieldType: Map is not supported in userState (use a plain object instead)`);
+      }
+      if (value instanceof Set) {
+        throw new Error(`inferFieldType: Set is not supported in userState (use an array or plain object instead)`);
+      }
+      if (value instanceof Date) {
+        throw new Error(`inferFieldType: Date is not supported in userState (use a number (epoch ms) or ISO string instead)`);
+      }
+      if (value instanceof RegExp) {
+        throw new Error(`inferFieldType: RegExp is not supported in userState (use a string pattern instead)`);
+      }
+      const fields = Object.entries(value).map(([k, v]) => field2(k, inferFieldType(v), true));
+      return struct2(fields);
+    default:
+      throw new Error(`inferFieldType: unsupported type '${typeof value}'`);
+  }
+}
+function serializeUserState(userState) {
+  if (userState == null)
+    return null;
+  const entries = Object.entries(userState);
+  if (entries.length === 0) {
+    return serializeBatch(batchFromColumns({}, schema2([])));
+  }
+  const fields = entries.map(([k, v]) => field2(k, inferFieldType(v), true));
+  const sch = schema2(fields);
+  const columns = {};
+  for (const [key, val] of entries) {
+    columns[key] = [val];
+  }
+  return serializeBatch(batchFromColumns(columns, sch));
+}
+function extractTypedValue(col, index, type) {
+  return codecFor(type).canonicalToRich(readCanonicalValue(type, col, index));
+}
+function deserializeUserState(bytes) {
+  if (bytes == null)
+    return null;
+  const batch = deserializeBatch(bytes);
+  if (batch.numRows === 0 && batch.schema.fields.length === 0) {
+    return {};
+  }
+  if (batch.numRows === 0)
+    return null;
+  const result = {};
+  for (const f of batch.schema.fields) {
+    const col = batch.getChild(f.name);
+    if (!col) {
+      result[f.name] = null;
+      continue;
+    }
+    result[f.name] = extractTypedValue(col, 0, f.type);
+  }
+  return result;
+}
+var arrowStateSerializer = {
+  serialize(state) {
+    const functionName = TEXT_ENCODER.encode(state.functionName ?? "");
+    const initRequest = state.initRequestPacked ?? packInitRequest(state.initRequestIpc);
+    const executionId = toUint8Array(state.executionId);
+    const opaqueData = state.opaqueData != null ? toUint8Array(state.opaqueData) : null;
+    const userState = serializeUserState(state.userState);
+    const filterHistory = encodeFilterHistory(state.filterHistory);
+    const flags = (state.isProducer ? FLAG_PRODUCER : 0) | (opaqueData ? FLAG_OPAQUE_DATA : 0) | (userState ? FLAG_USER_STATE : 0) | (filterHistory ? FLAG_FILTER_HISTORY : 0);
+    const chunks = [functionName, initRequest, executionId];
+    if (opaqueData)
+      chunks.push(opaqueData);
+    if (userState)
+      chunks.push(userState);
+    if (filterHistory)
+      chunks.push(filterHistory);
+    let size = 2 + 8;
+    for (const chunk of chunks)
+      size += 4 + chunk.byteLength;
+    const out = new Uint8Array(size);
+    const view = new DataView(out.buffer);
+    out[0] = STATE_FORMAT_VERSION;
+    out[1] = flags;
+    view.setFloat64(2, Number(state.maxWorkers ?? 1), true);
+    let offset = 10;
+    for (const chunk of chunks) {
+      view.setUint32(offset, chunk.byteLength, true);
+      out.set(chunk, offset + 4);
+      offset += 4 + chunk.byteLength;
+    }
+    return out;
+  },
+  deserialize(bytes) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    if (bytes.byteLength < 10 || bytes[0] !== STATE_FORMAT_VERSION) {
+      throw new Error("exchange state has an unknown format (minted by another build of this worker?)");
+    }
+    const flags = bytes[1];
+    const maxWorkers = view.getFloat64(2, true);
+    let offset = 10;
+    const take = () => {
+      if (offset + 4 > bytes.byteLength)
+        throw new Error("exchange state is truncated");
+      const length = view.getUint32(offset, true);
+      offset += 4;
+      if (offset + length > bytes.byteLength)
+        throw new Error("exchange state is truncated");
+      const chunk = bytes.slice(offset, offset + length);
+      offset += length;
+      return chunk;
+    };
+    const functionName = TEXT_DECODER.decode(take());
+    const initRequestPacked = take();
+    const executionId = take();
+    const opaqueData = flags & FLAG_OPAQUE_DATA ? take() : null;
+    const userStateBytes = flags & FLAG_USER_STATE ? take() : null;
+    const filterHistoryBytes = flags & FLAG_FILTER_HISTORY ? take() : null;
+    if (offset !== bytes.byteLength)
+      throw new Error("exchange state has trailing bytes");
+    const isProducer = (flags & FLAG_PRODUCER) !== 0;
+    return {
+      functionName,
+      initRequestPacked,
+      executionId,
+      maxWorkers,
+      opaqueData,
+      isProducer,
+      __isProducer: isProducer,
+      userState: deserializeUserState(userStateBytes),
+      filterHistory: decodeFilterHistory(filterHistoryBytes)
+    };
+  }
+};
+
+// src/functions/table-in-out.ts
+var STREAMING_FINALIZE_KEY = new Uint8Array(0);
+function defineTableInOutFunction(config) {
+  assertArrowTypes(config.args, `defineTableInOutFunction("${config.name}"): args`);
+  const specs = [];
+  let posIdx = 0;
+  if (config.args) {
+    for (const [name, type] of Object.entries(config.args)) {
+      specs.push({
+        name,
+        position: posIdx++,
+        arrowType: type,
+        doc: config.argDocs?.[name],
+        ...constraintSpecFields(config.argConstraints?.[name], config.argDefaults?.[name])
+      });
+    }
+  }
+  specs.push({
+    name: "data",
+    position: posIdx++,
+    arrowType: nullType2(),
+    isTableInput: true
+  });
+  if (config.namedArgs) {
+    for (const [name, type] of Object.entries(config.namedArgs)) {
+      specs.push({
+        name,
+        position: name,
+        arrowType: type,
+        doc: config.argDocs?.[name],
+        ...constraintSpecFields(config.argConstraints?.[name], config.argDefaults?.[name])
+      });
+    }
+  }
+  const meta = {
+    name: config.name,
+    description: config.description,
+    stability: config.stability,
+    projectionPushdown: config.projectionPushdown,
+    filterPushdown: config.filterPushdown,
+    autoApplyFilters: config.autoApplyFilters,
+    examples: config.examples,
+    categories: config.categories,
+    tags: config.tags,
+    parameterDefaultValues: config.parameterDefaultValues,
+    maxWorkers: config.maxWorkers,
+    requiredSettings: config.requiredSettings,
+    requiredSecrets: config.requiredSecrets,
+    hasFinalize: !!config.finalize
+  };
+  function extractArgs(request) {
+    const args = {};
+    for (const spec of specs) {
+      if (spec.isTableInput)
         continue;
-      try {
-        joinKeys.push(deserializeBatch(toUint8Array2(entry)));
-      } catch {}
+      const defaultVal = config.argDefaults?.[spec.name] !== undefined ? config.argDefaults[spec.name] : undefined;
+      let val = request.arguments.get(spec.position, defaultVal);
+      val = narrowArgValue(val);
+      const constraints = config.argConstraints?.[spec.name];
+      if (constraints)
+        validateConstConstraints(spec.name, constraints, val);
+      args[spec.name] = val;
     }
+    return args;
   }
   return {
-    bind_call: bindCall,
-    output_schema: deserializeSchema(toUint8Array2(params.output_schema)),
-    bind_opaque_data: params.bind_opaque_data ? toUint8Array2(params.bind_opaque_data) : null,
-    projection_ids: projectionIds,
-    row_limit: params.row_limit == null ? null : Number(params.row_limit),
-    pushdown_filters: params.pushdown_filters ? deserializeBatch(toUint8Array2(params.pushdown_filters)) : null,
-    join_keys: joinKeys,
-    phase,
-    finalize_state_id: params.finalize_state_id ? toUint8Array2(params.finalize_state_id) : null,
-    split_tokens: (() => {
-      const raw = params.split_tokens;
-      if (raw == null)
-        return null;
-      const iter = Array.isArray(raw) ? raw : typeof raw[Symbol.iterator] === "function" ? raw : [];
-      const tokens = [...iter].filter((e) => e != null).map((e) => toUint8Array2(e));
-      return tokens.length > 0 ? tokens : null;
-    })(),
-    execution_id: params.execution_id ? toUint8Array2(params.execution_id) : null,
-    init_opaque_data: params.init_opaque_data ? toUint8Array2(params.init_opaque_data) : null,
-    substream_id: params.substream_id ? toUint8Array2(params.substream_id) : null,
-    order_by_column_name: parseEnum(decodeDictValue(params.order_by_column_name)) ?? null,
-    order_by_direction: parseDirection(decodeDictValue(params.order_by_direction)),
-    order_by_null_order: parseNullOrder(decodeDictValue(params.order_by_null_order)),
-    order_by_limit: parseBigInt(params.order_by_limit),
-    tablesample_percentage: parseNumber(params.tablesample_percentage),
-    tablesample_seed: parseBigInt(params.tablesample_seed)
+    kind: "table_in_out",
+    meta,
+    argumentSpecs: specs,
+    async bind(request) {
+      if (config.onBind) {
+        const args = extractArgs(request);
+        const settings = batchToScalarDict(request.settings);
+        const secrets = batchToSecretDict(request.secrets);
+        const result = await config.onBind({
+          args,
+          bindCall: request,
+          settings,
+          secrets,
+          argumentNames: request.argument_names ?? null
+        });
+        return {
+          output_schema: result.outputSchema,
+          opaque_data: result.opaqueData ?? null
+        };
+      }
+      return {
+        output_schema: request.input_schema ?? schema2([]),
+        opaque_data: null
+      };
+    },
+    async globalInit(request) {
+      const executionId = new Uint8Array(16);
+      crypto.getRandomValues(executionId);
+      if (request.execution_id) {
+        return {
+          max_workers: DEFAULT_MAX_WORKERS,
+          execution_id: request.execution_id,
+          opaque_data: null
+        };
+      }
+      if (config.onInit) {
+        const args = extractArgs(request.bind_call);
+        return await config.onInit({
+          args,
+          initCall: request,
+          outputSchema: request.output_schema,
+          executionId
+        });
+      }
+      return {
+        max_workers: config.maxWorkers ?? 1,
+        execution_id: executionId,
+        opaque_data: null
+      };
+    },
+    createStreamHandlers(request, response, filterHistory) {
+      const args = extractArgs(request.bind_call);
+      const settings = batchToScalarDict(request.bind_call.settings);
+      const secrets = batchToSecretDict(request.bind_call.secrets);
+      const projIds = request.projection_ids && meta.projectionPushdown ? request.projection_ids : null;
+      const outputSchema = projIds ? projectSchema(projIds, request.output_schema) : request.output_schema;
+      const carriedFilterHistory = filterHistory ?? EMPTY_FILTER_HISTORY;
+      const pushdownFilters = replayFilterHistory(request.pushdown_filters ? deserializeFilters(request.pushdown_filters, {
+        outputSchema: request.output_schema,
+        joinKeyBatches: request.join_keys,
+        extensionFunctions: meta.additionalFilterFunctions,
+        runtimeAlgorithms: meta.runtimeFilterAlgorithms,
+        evaluationContexts: meta.filterEvaluationContexts
+      }) : undefined, carriedFilterHistory);
+      const boundStorage = new BoundStorage(storage, response.execution_id ?? new Uint8Array(16), request.substream_id ?? null);
+      const processParams = {
+        args,
+        initCall: request,
+        initResponse: response,
+        outputSchema,
+        settings,
+        secrets,
+        pushdownFilters,
+        storage: boundStorage,
+        substreamId: request.substream_id ?? null
+      };
+      const phase = request.phase;
+      if (phase === "FINALIZE" /* FINALIZE */) {
+        const finalizeLogKey = STREAMING_FINALIZE_KEY;
+        return {
+          outputSchema,
+          producerInit: () => ({ state: { cursor: -1, materialized: false } }),
+          producerFn: async (pState, out) => {
+            if (!pState.state.materialized) {
+              const finalizeStates = [];
+              const stored = await boundStorage.collect();
+              for (const bytes of stored) {
+                finalizeStates.push(deserializeUserState(bytes));
+              }
+              if (finalizeStates.length === 0) {
+                finalizeStates.push(config.initialState ? config.initialState(processParams) : null);
+              }
+              const batches = config.finalize ? await config.finalize(processParams, finalizeStates) : [];
+              for (const batch of batches) {
+                await boundStorage.stateAppend(FrameworkNS.STREAMING_FINALIZE, finalizeLogKey, serializeBatch(batch));
+              }
+              pState.state.materialized = true;
+            }
+            const rows = await boundStorage.stateLogScan(FrameworkNS.STREAMING_FINALIZE, finalizeLogKey, pState.state.cursor, 1);
+            if (rows.length === 0) {
+              out.finish();
+              return;
+            }
+            const [logId, bytes] = rows[0];
+            out.emit(deserializeBatch(bytes));
+            pState.state.cursor = logId;
+          }
+        };
+      }
+      if (request.bind_call.input_schema == null) {
+        throw new Error(`${config.name}: is a table-in-out function (it requires an input row ` + `stream) but no input schema was supplied -- call it via ` + `table_in_out_function(input=...), not table_function().`);
+      }
+      const state = config.initialState ? config.initialState(processParams) : null;
+      const processFn = config.process ?? ((_params, _state, batch, out) => {
+        out.emit(projIds ? projectBatch(projIds, batch) : batch);
+      });
+      return {
+        outputSchema,
+        inputSchema: request.bind_call.input_schema,
+        exchangeInit: () => ({ state, processParams, filterHistory: carriedFilterHistory }),
+        exchangeFn: async (eState, input, out) => {
+          applyRevalidationValidators(eState.processParams, input);
+          applyDynamicFilterUpdate(eState, input);
+          let wrappedOut = makeMetadataBakingCollector(out);
+          if (projIds) {
+            wrappedOut = makeSchemaReconcilingCollector(wrappedOut, outputSchema);
+          }
+          const currentFilters = eState.processParams.pushdownFilters;
+          if (config.autoApplyFilters && currentFilters) {
+            wrappedOut = new FilteringOutputCollector(wrappedOut, currentFilters);
+          }
+          await processFn(eState.processParams, eState.state, input, wrappedOut);
+          if (eState.state != null) {
+            const serialized = serializeUserState(eState.state);
+            if (serialized != null) {
+              await boundStorage.put(serialized);
+            }
+          }
+        }
+      };
+    }
   };
 }
-function parseEnum(v) {
-  if (v === null || v === undefined)
-    return null;
-  return String(v);
+function applyRevalidationValidators(params, input) {
+  const md = input?.metadata;
+  params.ifNoneMatch = md?.get(CACHE_IF_NONE_MATCH_KEY);
+  params.ifModifiedSince = md?.get(CACHE_IF_MODIFIED_SINCE_KEY);
 }
-function parseDirection(v) {
-  if (v === null || v === undefined)
-    return null;
-  const s = String(v);
-  if (s === "ASC")
-    return "ASC" /* ASC */;
-  if (s === "DESC")
-    return "DESC" /* DESC */;
-  return null;
+function applyDynamicFilterUpdate(eState, input) {
+  const encoded = input?.metadata?.get("vgi_pushdown_filters");
+  if (!encoded)
+    return;
+  const current = eState.processParams.pushdownFilters;
+  if (!current)
+    throw new Error("dynamic filter delta received without an initial snapshot");
+  const recorded = recordFilterDelta(current, eState.filterHistory, decodeDynamicFilterMetadata(encoded));
+  eState.processParams.pushdownFilters = recorded.filters;
+  eState.filterHistory = recorded.history;
 }
-function parseNullOrder(v) {
-  if (v === null || v === undefined)
-    return null;
-  const s = String(v);
-  if (s === "NULLS_FIRST")
-    return "NULLS_FIRST" /* NULLS_FIRST */;
-  if (s === "NULLS_LAST")
-    return "NULLS_LAST" /* NULLS_LAST */;
-  return null;
+function makeMetadataBakingCollector(inner) {
+  return new Proxy(inner, {
+    get(target, prop, receiver) {
+      if (prop === "emit") {
+        return function(batchOrColumns, metadata) {
+          if (batchOrColumns && typeof batchOrColumns.getChild === "function" && metadata && metadata.size > 0) {
+            const batch = batchOrColumns;
+            const merged = new Map(batch.metadata ?? []);
+            for (const [k, v] of metadata)
+              merged.set(k, v);
+            return target.emit(withBatchMetadata(batch, merged), merged);
+          }
+          return target.emit(batchOrColumns, metadata);
+        };
+      }
+      const v = Reflect.get(target, prop, receiver);
+      return typeof v === "function" ? v.bind(target) : v;
+    }
+  });
 }
-function parseBigInt(v) {
-  if (v === null || v === undefined)
-    return null;
-  if (typeof v === "bigint")
-    return v;
-  if (typeof v === "number")
-    return BigInt(v);
-  try {
-    return BigInt(String(v));
-  } catch {
-    return null;
+function makeSchemaReconcilingCollector(inner, targetSchema) {
+  function reconcile(batch) {
+    const batchFields = batch.schema.fields;
+    if (batchFields.length === targetSchema.fields.length && targetSchema.fields.every((f, i) => batchFields[i].name === f.name)) {
+      return batch;
+    }
+    const ids = [];
+    for (const f of targetSchema.fields) {
+      const idx = batchFields.findIndex((bf) => bf.name === f.name);
+      if (idx < 0) {
+        throw new Error(`emitted batch is missing projected output column '${f.name}' ` + `(emitted: [${batchFields.map((bf) => bf.name).join(", ")}])`);
+      }
+      ids.push(idx);
+    }
+    return projectBatch(ids, batch);
   }
+  return new Proxy(inner, {
+    get(target, prop, receiver) {
+      if (prop === "emit") {
+        return function(batchOrColumns, metadata) {
+          if (batchOrColumns && typeof batchOrColumns.getChild === "function") {
+            return target.emit(reconcile(batchOrColumns), metadata);
+          }
+          return target.emit(batchOrColumns, metadata);
+        };
+      }
+      const v = Reflect.get(target, prop, receiver);
+      return typeof v === "function" ? v.bind(target) : v;
+    }
+  });
 }
-function parseNumber(v) {
-  if (v === null || v === undefined)
-    return null;
-  if (typeof v === "number")
-    return v;
-  if (typeof v === "bigint")
-    return Number(v);
-  const n = Number(v);
-  return Number.isNaN(n) ? null : n;
-}
-function serializeGlobalInitResponse(resp) {
-  return {
-    execution_id: resp.execution_id,
-    opaque_data: resp.opaque_data ?? null,
-    max_workers: resp.max_workers
-  };
+var PARENT_ROW_METADATA_KEY = "vgi_rpc.parent_row#b64";
+function parentRowsMetadata(parentRows, outputRows, extra) {
+  if (parentRows.length !== outputRows) {
+    throw new Error(`parentRowsMetadata: length ${parentRows.length} != output rows ${outputRows}; ` + `parentRows must carry exactly one input-row index per emitted output row`);
+  }
+  const md = new Map(extra ?? []);
+  if (outputRows === 0) {
+    return md;
+  }
+  const raw = new Uint8Array(parentRows.length * 4);
+  const dv = new DataView(raw.buffer);
+  for (let i = 0;i < parentRows.length; i++) {
+    dv.setInt32(i * 4, parentRows[i], true);
+  }
+  md.set(PARENT_ROW_METADATA_KEY, base64Encode(raw));
+  return md;
 }
-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)
-  };
+function base64Encode(bytes) {
+  if (typeof globalThis.Buffer !== "undefined") {
+    return globalThis.Buffer.from(bytes).toString("base64");
+  }
+  let bin = "";
+  for (let i = 0;i < bytes.length; i++)
+    bin += String.fromCharCode(bytes[i]);
+  return globalThis.btoa(bin);
 }
-// src/protocol/serializers/cardinality.ts
-init_arrow();
-var TABLE_FUNCTION_CARDINALITY_REQUEST_SCHEMA = schema2([
-  field2("bind_call", binary2(), false),
-  field2("bind_opaque_data", binary2(), true)
-]);
-function deserializeCardinalityRequest(params) {
-  const bindCallBytes = toUint8Array2(params.bind_call);
-  const bindCallBatch = deserializeBatch(bindCallBytes);
-  const bindParams = batchToScalarDict(bindCallBatch);
-  const bindCall = deserializeBindRequest(bindParams);
-  return {
-    bind_call: bindCall,
-    bind_opaque_data: params.bind_opaque_data ? toUint8Array2(params.bind_opaque_data) : null
+function defineRowTransformFunction(config) {
+  const numPositional = Object.keys(config.args ?? {}).length + (config.varargs ? 1 : 0);
+  if (numPositional === 0) {
+    throw new Error(`${config.name}: a blended row-transform function needs at least one ` + `positional arg (its per-row input column); found none.`);
+  }
+  const specs = [];
+  let posIdx = 0;
+  if (config.args) {
+    for (const [name, type] of Object.entries(config.args)) {
+      const isAny = isNull(type);
+      specs.push({
+        name,
+        position: posIdx++,
+        arrowType: isAny ? nullType2() : type,
+        isAnyType: isAny,
+        doc: config.argDocs?.[name],
+        ...constraintSpecFields(config.argConstraints?.[name])
+      });
+    }
+  }
+  if (config.varargs) {
+    const isAny = isNull(config.varargs.type);
+    specs.push({
+      name: config.varargs.name,
+      position: posIdx++,
+      arrowType: isAny ? nullType2() : config.varargs.type,
+      isAnyType: isAny,
+      isVarargs: true,
+      doc: config.varargs.doc ?? config.argDocs?.[config.varargs.name],
+      ...constraintSpecFields(config.argConstraints?.[config.varargs.name])
+    });
+  }
+  if (config.namedArgs) {
+    for (const [name, type] of Object.entries(config.namedArgs)) {
+      specs.push({
+        name,
+        position: name,
+        arrowType: type,
+        doc: config.argDocs?.[name],
+        ...constraintSpecFields(config.argConstraints?.[name], config.argDefaults?.[name])
+      });
+    }
+  }
+  const meta = {
+    name: config.name,
+    description: config.description,
+    stability: config.stability,
+    projectionPushdown: config.projectionPushdown,
+    filterPushdown: config.filterPushdown,
+    autoApplyFilters: config.autoApplyFilters,
+    examples: config.examples,
+    categories: config.categories,
+    tags: config.tags,
+    parameterDefaultValues: config.parameterDefaultValues,
+    maxWorkers: config.maxWorkers,
+    requiredSettings: config.requiredSettings,
+    requiredSecrets: config.requiredSecrets,
+    hasFinalize: false,
+    inputFromArgs: true
   };
-}
-function serializeTableCardinality(card) {
+  function extractArgs(request) {
+    const args = {};
+    for (const spec of specs) {
+      if (typeof spec.position !== "string")
+        continue;
+      const defaultVal = config.argDefaults?.[spec.name] !== undefined ? config.argDefaults[spec.name] : undefined;
+      let val = request.arguments.get(spec.position, defaultVal ?? null);
+      val = narrowArgValue(val);
+      const constraints = config.argConstraints?.[spec.name];
+      if (constraints)
+        validateConstConstraints(spec.name, constraints, val);
+      args[spec.name] = val;
+    }
+    return args;
+  }
   return {
-    estimate: card.estimate,
-    max: card.max
+    kind: "table_in_out",
+    meta,
+    argumentSpecs: specs,
+    async bind(request) {
+      const args = extractArgs(request);
+      const settings = batchToScalarDict(request.settings);
+      const secrets = batchToSecretDict(request.secrets);
+      const result = await config.onBind({
+        args,
+        bindCall: request,
+        settings,
+        secrets,
+        argumentNames: request.argument_names ?? null
+      });
+      return {
+        output_schema: result.outputSchema,
+        opaque_data: result.opaqueData ?? null
+      };
+    },
+    async globalInit(request) {
+      if (request.execution_id) {
+        return {
+          max_workers: DEFAULT_MAX_WORKERS,
+          execution_id: request.execution_id,
+          opaque_data: null
+        };
+      }
+      const executionId = new Uint8Array(16);
+      crypto.getRandomValues(executionId);
+      return {
+        max_workers: config.maxWorkers ?? 1,
+        execution_id: executionId,
+        opaque_data: null
+      };
+    },
+    createStreamHandlers(request, response, filterHistory) {
+      const args = extractArgs(request.bind_call);
+      const settings = batchToScalarDict(request.bind_call.settings);
+      const secrets = batchToSecretDict(request.bind_call.secrets);
+      const projIds = request.projection_ids && meta.projectionPushdown ? request.projection_ids : null;
+      const outputSchema = projIds ? projectSchema(projIds, request.output_schema) : request.output_schema;
+      const carriedFilterHistory = filterHistory ?? EMPTY_FILTER_HISTORY;
+      const pushdownFilters = replayFilterHistory(request.pushdown_filters ? deserializeFilters(request.pushdown_filters, {
+        outputSchema: request.output_schema,
+        joinKeyBatches: request.join_keys,
+        extensionFunctions: meta.additionalFilterFunctions,
+        runtimeAlgorithms: meta.runtimeFilterAlgorithms,
+        evaluationContexts: meta.filterEvaluationContexts
+      }) : undefined, carriedFilterHistory);
+      const boundStorage = new BoundStorage(storage, response.execution_id ?? new Uint8Array(16), request.substream_id ?? null);
+      const processParams = {
+        args,
+        initCall: request,
+        initResponse: response,
+        outputSchema,
+        settings,
+        secrets,
+        pushdownFilters,
+        storage: boundStorage,
+        substreamId: request.substream_id ?? null
+      };
+      if (request.phase === "FINALIZE" /* FINALIZE */) {
+        throw new Error(`${config.name}: a blended row-transform function has no FINALIZE ` + `phase (it is a per-row map; has_finalize is advertised false).`);
+      }
+      if (request.bind_call.input_schema == null) {
+        throw new Error(`${config.name}: is a table-in-out function (its positional args are ` + `per-row input columns) but no input schema was supplied -- call it ` + `via table_in_out_function(input=...), not table_function().`);
+      }
+      return {
+        outputSchema,
+        inputSchema: request.bind_call.input_schema,
+        exchangeInit: () => ({ state: null, processParams, filterHistory: carriedFilterHistory }),
+        exchangeFn: async (eState, input, out) => {
+          applyRevalidationValidators(eState.processParams, input);
+          applyDynamicFilterUpdate(eState, input);
+          let wrappedOut = makeMetadataBakingCollector(out);
+          if (projIds) {
+            wrappedOut = makeSchemaReconcilingCollector(wrappedOut, outputSchema);
+          }
+          const currentFilters = eState.processParams.pushdownFilters;
+          if (config.autoApplyFilters && currentFilters) {
+            wrappedOut = new FilteringOutputCollector(wrappedOut, currentFilters);
+          }
+          await config.process(eState.processParams, input, wrappedOut);
+        }
+      };
+    }
   };
 }
 // src/functions/table-buffering.ts
+init_arrow();
+init_arrow();
+init_registry();
+init_storage();
 function defineTableBufferingFunction(config) {
   assertArrowTypes(config.args, `defineTableBufferingFunction("${config.name}"): args`);
   if (config.sinkOrderDependent && config.requiresInputBatchIndex) {
@@ -6245,7 +6530,7 @@ function defineTableBufferingFunction(config) {
       }
       return response;
     },
-    createStreamHandlers(request, response, _accumulatedState) {
+    createStreamHandlers(request, response) {
       const args = extractArgs(request.bind_call);
       const settings = batchToScalarDict(request.bind_call.settings);
       const secrets = batchToSecretDict(request.bind_call.secrets);
@@ -8217,12 +8502,41 @@ function validateRequiredAttachOptions(catalogName, specs, options) {
   }
 }
 
+// src/catalog/item-encoding.ts
+var ENCODED = new WeakMap;
+function freezeCatalogItem(item) {
+  deepFreeze(item);
+  return item;
+}
+function deepFreeze(value) {
+  if (value === null || typeof value !== "object" || Object.isFrozen(value) || ArrayBuffer.isView(value))
+    return;
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== Object.prototype && proto !== Array.prototype && proto !== null)
+    return;
+  for (const child of Object.values(value))
+    deepFreeze(child);
+  Object.freeze(value);
+}
+function encodeFunctionInfoOnce(info) {
+  if (!Object.isFrozen(info))
+    return encodeFunctionInfo(info);
+  let encoded = ENCODED.get(info);
+  if (encoded === undefined) {
+    encoded = encodeFunctionInfo(info);
+    ENCODED.set(info, encoded);
+  }
+  return encoded;
+}
+
 // src/catalog/read-only.ts
 class ReadOnlyCatalogInterface extends CatalogInterface {
   _descriptor;
   _registry;
   _attachments = new Map;
   _version = 1;
+  _functionListings = new Map;
+  _functionInfos = new Map;
   constructor(descriptor, registry) {
     super();
     this._descriptor = descriptor;
@@ -8288,7 +8602,7 @@ class ReadOnlyCatalogInterface extends CatalogInterface {
       comment: this._descriptor.comment ?? null,
       tags: this._descriptor.tags ?? {},
       supports_column_statistics: true,
-      global_functions: this._globalFunctionInfos().map(encodeFunctionInfo),
+      global_functions: this._globalFunctionInfos().map(encodeFunctionInfoOnce),
       global_function_prefix: this._descriptor.globalFunctionPrefix ?? "",
       resolved_data_version: null,
       resolved_implementation_version: null
@@ -8464,16 +8778,35 @@ class ReadOnlyCatalogInterface extends CatalogInterface {
     const schema = this._descriptor.schemas.find((s) => schemaPathsEqual(schemaDescriptorPath(s), path));
     if (!schema || !schema.functions)
       return [];
-    return schema.functions.filter((f) => {
-      const t = String(type ?? "").toUpperCase();
-      if (t === "SCALAR_FUNCTION")
-        return f.kind === "scalar";
-      if (t === "TABLE_FUNCTION")
-        return f.kind === "table" || f.kind === "table_in_out" || f.kind === "table_buffering";
-      if (t === "AGGREGATE_FUNCTION")
-        return f.kind === "aggregate";
-      return true;
-    }).map((f) => this._functionToInfo(f, path));
+    const kind = functionListingKind(type);
+    const canonicalPath = schemaDescriptorPath(schema);
+    if (!sameSpelling(path, canonicalPath)) {
+      return schema.functions.filter((f) => inListing(f, kind)).map((f) => this._functionToInfo(f, path));
+    }
+    let listings = this._functionListings.get(schema);
+    if (!listings) {
+      listings = new Map;
+      this._functionListings.set(schema, listings);
+    }
+    let listing = listings.get(kind);
+    if (!listing) {
+      listing = Object.freeze(schema.functions.filter((f) => inListing(f, kind)).map((f) => this._sharedFunctionInfo(schema, f)));
+      listings.set(kind, listing);
+    }
+    return listing.slice();
+  }
+  _sharedFunctionInfo(schema, f) {
+    let infos = this._functionInfos.get(schema);
+    if (!infos) {
+      infos = new Map;
+      this._functionInfos.set(schema, infos);
+    }
+    let info = infos.get(f);
+    if (!info) {
+      info = freezeCatalogItem(structuredClone(this._functionToInfo(f, schemaDescriptorPath(schema))));
+      infos.set(f, info);
+    }
+    return info;
   }
   _functionToInfo(f, path) {
     const meta = resolveMetadata(f);
@@ -8574,15 +8907,15 @@ class ReadOnlyCatalogInterface extends CatalogInterface {
     for (const sch of this._descriptor.schemas) {
       for (const fn of sch.functions ?? []) {
         if (!schemaOf.has(fn))
-          schemaOf.set(fn, schemaDescriptorPath(sch));
+          schemaOf.set(fn, sch);
       }
     }
     return globals.map((fn) => {
-      const schemaPath = schemaOf.get(fn);
-      if (schemaPath === undefined) {
+      const schema = schemaOf.get(fn);
+      if (schema === undefined) {
         throw new Error(`Catalog '${this._descriptor.name}': '${fn.meta.name}' is listed in ` + `globalFunctions but is not declared in any schema.`);
       }
-      return this._functionToInfo(fn, schemaPath);
+      return this._sharedFunctionInfo(schema, fn);
     });
   }
   schemaContentsMacros(attachOpaqueData, path, type, transactionOpaqueData) {
@@ -8895,6 +9228,24 @@ function inlineScanFunction(func, args, schemaPath) {
   const argBytes = serializeArgsBatch(args ?? new Arguments, argSchema);
   return encodeScanFunctionResult(func.meta.name, argBytes, [], schemaPath);
 }
+function functionListingKind(type) {
+  const t = String(type ?? "").toUpperCase();
+  return t === "SCALAR_FUNCTION" || t === "TABLE_FUNCTION" || t === "AGGREGATE_FUNCTION" ? t : "ALL";
+}
+function inListing(f, kind) {
+  if (kind === "SCALAR_FUNCTION")
+    return f.kind === "scalar";
+  if (kind === "TABLE_FUNCTION")
+    return f.kind === "table" || f.kind === "table_in_out" || f.kind === "table_buffering";
+  if (kind === "AGGREGATE_FUNCTION")
+    return f.kind === "aggregate";
+  return true;
+}
+function sameSpelling(left, right) {
+  const a = normalizeSchemaPath(left);
+  const b = normalizeSchemaPath(right);
+  return a.length === b.length && a.every((part, i) => part === b[i]);
+}
 // src/catalog/composite.ts
 var ROUTE_BYTE = 0;
 
@@ -9569,17 +9920,6 @@ function overloadContext(req, catalogInterface) {
     catalogName
   };
 }
-function recoverFinalizeState(request, recoverExchangeState) {
-  if (request.phase === "FINALIZE" /* FINALIZE */ && request.init_opaque_data && recoverExchangeState) {
-    try {
-      const recovered = recoverExchangeState(request.init_opaque_data);
-      return recovered?.userState;
-    } catch (e) {
-      throw new Error(`Failed to recover FINALIZE state from init_opaque_data: ${e.message}`);
-    }
-  }
-  return;
-}
 
 // src/protocol/handlers/catalog/shared.ts
 init_arrow();
@@ -10722,8 +11062,7 @@ function registerFunctionMethods(protocol, config) {
       });
       const func = registry.get(request.bind_call.function_name, overloadContext(request.bind_call, catalogInterface));
       const initResponse = await func.globalInit(request);
-      const accumulatedState = recoverFinalizeState(request, config.recoverExchangeState);
-      const handlers = func.createStreamHandlers(request, initResponse, accumulatedState);
+      const handlers = func.createStreamHandlers(request, initResponse);
       let handlerState;
       if (handlers.producerInit) {
         handlerState = handlers.producerInit();
@@ -10757,10 +11096,9 @@ function registerFunctionMethods(protocol, config) {
         handlers = state._handlers;
         handlerState = state._handlerState;
       } else {
-        const initRequestBatch = deserializeBatch(state.initRequestIpc);
-        const initRequestDict = batchToScalarDict(initRequestBatch);
-        const request = deserializeInitRequest(initRequestDict);
-        await resolveSplitPayloads(request, { bind_call: initRequestDict.bind_call }, {
+        const carried = parseCarriedInitRequest(state.initRequestPacked);
+        const request = carried.request;
+        await resolveSplitPayloads(request, { bind_call: carried.bindCallIpc }, {
           auth: currentRequestAuth(),
           signingKey,
           catalogInterface,
@@ -10774,8 +11112,7 @@ function registerFunctionMethods(protocol, config) {
           max_workers: Number(state.maxWorkers ?? 1),
           opaque_data: opaqueData
         };
-        const recoveredState = recoverFinalizeState(request, config.recoverExchangeState);
-        handlers = func.createStreamHandlers(request, initResponse, recoveredState);
+        handlers = func.createStreamHandlers(request, initResponse, state.filterHistory ?? null);
         if (handlers.producerInit) {
           handlerState = handlers.producerInit();
         } else if (handlers.exchangeInit) {
@@ -10799,6 +11136,7 @@ function registerFunctionMethods(protocol, config) {
       if (handlerState?.state !== undefined) {
         state.userState = handlerState.state;
       }
+      state.filterHistory = handlerState?.filterHistory ?? null;
     },
     headerSchema: initHeaderSchema,
     headerInit: (params, state, ctx) => {
@@ -11465,7 +11803,7 @@ function registerCatalogAdminMethods(protocol, getCatalog, signingKey) {
       const cat = getCatalog();
       const funcs = await cat.schemaContentsFunctions(toUint8Array(params.attach_opaque_data), params.path, decodeDictValue(params.type), params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined);
       return wrapResult({
-        items: funcs.map((f) => encodeFunctionInfo(f))
+        items: funcs.map((f) => encodeFunctionInfoOnce(f))
       }, CatalogSchemaContentsFunctionsResultSchema);
     }
   });
@@ -11754,11 +12092,11 @@ function registerCatalogMethods(protocol, catalog, _catalogName, signingKey) {
 }
 
 // src/protocol/dispatch.ts
+var VGI_PROTOCOL_NAME = "vgi.v2";
 function buildVgiProtocol(config) {
-  const protocol = new Protocol("vgi", { protocolVersion: "2.0.0" });
+  const protocol = new Protocol(VGI_PROTOCOL_NAME, { protocolVersion: "2.0.0" });
   registerFunctionMethods(protocol, {
     registry: config.registry,
-    recoverExchangeState: config.recoverExchangeState,
     signingKey: config.signingKey,
     catalogInterface: config.catalogInterface
   });
@@ -12016,6 +12354,24 @@ function wrapRpcWithErrorEnrichment(rpc) {
         throw e;
       }
     },
+    async callRaw(method, input) {
+      try {
+        return await rpc.callRaw(method, input);
+      } catch (e) {
+        if (e instanceof RpcError)
+          throw VgiClientError.fromRpcError(e);
+        throw e;
+      }
+    },
+    async streamRaw(method, input, options) {
+      try {
+        return await rpc.streamRaw(method, input, options);
+      } catch (e) {
+        if (e instanceof RpcError)
+          throw VgiClientError.fromRpcError(e);
+        throw e;
+      }
+    },
     describe: () => rpc.describe(),
     close: () => rpc.close()
   };
@@ -13197,4 +13553,4 @@ export {
   utf82 as utf8
 };
 
-//# debugId=5739BCB2FB0272A864756E2164756E21
+//# debugId=D343450F0C99C4DF64756E2164756E21