@query-farm/vgi 0.31.0 → 0.32.0

package/dist/serve-entry.js

@@ -55,8 +55,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());
@@ -201,11 +201,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;
@@ -278,11 +273,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;
@@ -383,8 +381,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));
@@ -421,12 +419,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);
@@ -523,8 +523,7 @@ import {
 // src/http/fetch.ts
 import {
   AuthContext,
-  createHttpHandler,
-  unpackStateToken
+  createHttpHandler
 } from "@query-farm/vgi-rpc";
 
 // src/arrow/predicates.ts
@@ -2354,159 +2353,109 @@ 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)`);
-    }
-  }
-  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)
+// src/filter-pushdown/history.ts
+var MAX_ENCODED_DELTA_BYTES = 24 << 20;
+var MAX_DELTA_IPC_BYTES = 17 << 20;
+var EMPTY_FILTER_HISTORY = Object.freeze({
+  deltas: Object.freeze([]),
+  order: Object.freeze([])
+});
+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 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));
+  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 extractTypedValue(col, index, type) {
-  return codecFor(type).canonicalToRich(readCanonicalValue(type, col, index));
+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 deserializeUserState(bytes) {
-  if (bytes == null)
-    return null;
-  const batch = deserializeBatch(bytes);
-  if (batch.numRows === 0 && batch.schema.fields.length === 0) {
-    return {};
+
+// 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))
+    };
   }
-  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);
+  let zlib = null;
+  try {
+    zlib = globalThis.process?.getBuiltinModule?.("node:zlib") ?? null;
+  } catch {
+    zlib = null;
   }
-  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");
+  if (typeof zlib?.zstdCompressSync === "function" && typeof zlib?.zstdDecompressSync === "function") {
+    const params = { [zlib.constants.ZSTD_c_compressionLevel]: LEVEL };
     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)
+      compress: (data) => new Uint8Array(zlib.zstdCompressSync(data, { params })),
+      decompress: (data) => new Uint8Array(zlib.zstdDecompressSync(data))
     };
   }
-};
-
-// src/protocol/dispatch.ts
-import { Protocol } from "@query-farm/vgi-rpc";
+  return null;
+}
+var resolved;
+function zstdSync() {
+  if (resolved === undefined)
+    resolved = resolveZstdSync();
+  return resolved;
+}
 
 // src/arguments/arguments.ts
 class Arguments {
@@ -2910,6 +2859,269 @@ function serializeTableCardinality(card) {
     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]}`);
+  }
+}
+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)`);
+    }
+  }
+  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/protocol/dispatch.ts
+import { Protocol } from "@query-farm/vgi-rpc";
+
 // src/util/statistics.ts
 function serializeColumnStatistics(stats, _cacheMaxAgeSeconds) {
   return serializeBatch(buildStatisticsBatch(stats));
@@ -3912,17 +4124,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/errors.ts
 class VgiError extends Error {
@@ -5086,8 +5287,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();
@@ -5121,10 +5321,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,
@@ -5138,8 +5337,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) {
@@ -5163,6 +5361,7 @@ function registerFunctionMethods(protocol, config) {
       if (handlerState?.state !== undefined) {
         state.userState = handlerState.state;
       }
+      state.filterHistory = handlerState?.filterHistory ?? null;
     },
     headerSchema: initHeaderSchema,
     headerInit: (params, state, ctx) => {
@@ -5846,6 +6045,19 @@ var encodeSchemaInfo = (v) => encodeASD(SchemaInfoSchema, v);
 var encodeTableInfo = (v) => encodeASD(TableInfoSchema, v);
 var encodeViewInfo = (v) => encodeASD(ViewInfoSchema, v);
 
+// src/catalog/item-encoding.ts
+var ENCODED = new WeakMap;
+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/interface.ts
 var encodeCopyFromFormatInfo = (v) => encodeASD(CopyFromFormatInfoSchema, {
   comment: v.comment ?? null,
@@ -6053,7 +6265,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);
     }
   });
@@ -6347,7 +6559,6 @@ function buildVgiProtocol(config) {
   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
   });
@@ -6496,15 +6707,7 @@ function createVgiFetch(opts) {
   const serverId = opts.serverId ?? "vgi-cf";
   const protocol = buildVgiProtocol({
     signingKey: opts.signingKey,
-    ...opts.protocol,
-    recoverExchangeState: async (opaqueData) => {
-      const tokenString = new TextDecoder().decode(opaqueData);
-      const unpacked = await unpackStateToken(tokenString, opts.signingKey, tokenTtl, {
-        protocol: VGI_PROTOCOL_NAME,
-        principal: undefined
-      });
-      return arrowStateSerializer.deserialize(unpacked.stateBytes);
-    }
+    ...opts.protocol
   });
   const handler = createHttpHandler(protocol, {
     prefix,
@@ -6656,4 +6859,4 @@ export {
   serveVgiWorker
 };
 
-//# debugId=D209EDA2709578AC64756E2164756E21
+//# debugId=CEC41B08D9AF368564756E2164756E21