@query-farm/vgi-rpc 0.1.0

package/dist/index.js

@@ -0,0 +1,2493 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/util/zstd.ts
+var exports_zstd = {};
+__export(exports_zstd, {
+  zstdDecompress: () => zstdDecompress,
+  zstdCompress: () => zstdCompress
+});
+import * as zlib from "node:zlib";
+function zstdCompress(data, level) {
+  if (isBun) {
+    return new Uint8Array(Bun.zstdCompressSync(data, { level }));
+  }
+  const fn = zlib.zstdCompressSync;
+  if (typeof fn !== "function") {
+    throw new Error("zstd is not available in this runtime. " + "Requires Bun, Node.js >= 22.15, or Deno >= 2.6.9.");
+  }
+  return new Uint8Array(fn(data, {
+    params: {
+      [zlib.constants.ZSTD_c_compressionLevel]: level
+    }
+  }));
+}
+function zstdDecompress(data) {
+  if (isBun) {
+    return new Uint8Array(Bun.zstdDecompressSync(data));
+  }
+  const fn = zlib.zstdDecompressSync;
+  if (typeof fn !== "function") {
+    throw new Error("zstd is not available in this runtime. " + "Requires Bun, Node.js >= 22.15, or Deno >= 2.6.9.");
+  }
+  return new Uint8Array(fn(data));
+}
+var isBun;
+var init_zstd = __esm(() => {
+  isBun = typeof globalThis.Bun !== "undefined";
+});
+
+// src/server.ts
+import { Schema as Schema4 } from "apache-arrow";
+
+// src/wire/reader.ts
+import { RecordBatchReader } from "apache-arrow";
+
+class IpcStreamReader {
+  reader;
+  initialized = false;
+  streamEnded = false;
+  constructor(reader) {
+    this.reader = reader;
+  }
+  static async create(input) {
+    const reader = await RecordBatchReader.from(input);
+    await reader.open({ autoDestroy: false });
+    if (reader.closed) {
+      throw new Error("Input stream closed before first IPC message");
+    }
+    return new IpcStreamReader(reader);
+  }
+  async readStream() {
+    if (this.initialized) {
+      await this.reader.reset().open();
+      if (this.reader.closed) {
+        return null;
+      }
+    }
+    this.initialized = true;
+    const schema = this.reader.schema;
+    if (!schema) {
+      return null;
+    }
+    const batches = [];
+    while (true) {
+      const result = await this.reader.next();
+      if (result.done)
+        break;
+      if (result.value.constructor.name === "_InternalEmptyPlaceholderRecordBatch")
+        break;
+      batches.push(result.value);
+    }
+    return { schema, batches };
+  }
+  async openNextStream() {
+    if (this.initialized) {
+      await this.reader.reset().open();
+      if (this.reader.closed) {
+        return null;
+      }
+    }
+    this.initialized = true;
+    this.streamEnded = false;
+    return this.reader.schema ?? null;
+  }
+  async readNextBatch() {
+    if (this.streamEnded)
+      return null;
+    const result = await this.reader.next();
+    if (result.done) {
+      this.streamEnded = true;
+      return null;
+    }
+    if (result.value.constructor.name === "_InternalEmptyPlaceholderRecordBatch") {
+      this.streamEnded = true;
+      return null;
+    }
+    return result.value;
+  }
+  async cancel() {
+    await this.reader.cancel();
+  }
+}
+
+// src/wire/writer.ts
+import {
+  RecordBatchStreamWriter
+} from "apache-arrow";
+import { writeSync } from "node:fs";
+var STDOUT_FD = 1;
+function writeAll(fd, data) {
+  let offset = 0;
+  while (offset < data.length) {
+    try {
+      const written = writeSync(fd, data, offset, data.length - offset);
+      if (written <= 0)
+        throw new Error(`writeSync returned ${written}`);
+      offset += written;
+    } catch (e) {
+      if (e.code === "EAGAIN") {
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 1);
+        continue;
+      }
+      throw e;
+    }
+  }
+}
+
+class IpcStreamWriter {
+  fd;
+  constructor(fd = STDOUT_FD) {
+    this.fd = fd;
+  }
+  writeStream(schema, batches) {
+    const writer = new RecordBatchStreamWriter;
+    writer.reset(undefined, schema);
+    for (const batch of batches) {
+      writer._writeRecordBatch(batch);
+    }
+    writer.close();
+    const bytes = writer.toUint8Array(true);
+    writeAll(this.fd, bytes);
+  }
+  openStream(schema) {
+    return new IncrementalStream(this.fd, schema);
+  }
+}
+
+class IncrementalStream {
+  writer;
+  fd;
+  closed = false;
+  constructor(fd, schema) {
+    this.fd = fd;
+    this.writer = new RecordBatchStreamWriter;
+    this.writer.reset(undefined, schema);
+    this.drain();
+  }
+  write(batch) {
+    if (this.closed)
+      throw new Error("Stream already closed");
+    this.writer._writeRecordBatch(batch);
+    this.drain();
+  }
+  close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    const eos = new Uint8Array(new Int32Array([-1, 0]).buffer);
+    writeAll(this.fd, eos);
+  }
+  drain() {
+    const values = this.writer._sink._values;
+    for (const chunk of values) {
+      writeAll(this.fd, chunk);
+    }
+    values.length = 0;
+  }
+}
+
+// src/wire/request.ts
+import { DataType } from "apache-arrow";
+
+// src/constants.ts
+var RPC_METHOD_KEY = "vgi_rpc.method";
+var LOG_LEVEL_KEY = "vgi_rpc.log_level";
+var LOG_MESSAGE_KEY = "vgi_rpc.log_message";
+var LOG_EXTRA_KEY = "vgi_rpc.log_extra";
+var REQUEST_VERSION_KEY = "vgi_rpc.request_version";
+var REQUEST_VERSION = "1";
+var SERVER_ID_KEY = "vgi_rpc.server_id";
+var REQUEST_ID_KEY = "vgi_rpc.request_id";
+var PROTOCOL_NAME_KEY = "vgi_rpc.protocol_name";
+var DESCRIBE_VERSION_KEY = "vgi_rpc.describe_version";
+var DESCRIBE_VERSION = "2";
+var DESCRIBE_METHOD_NAME = "__describe__";
+var STATE_KEY = "vgi_rpc.stream_state#b64";
+
+// src/errors.ts
+class RpcError extends Error {
+  errorType;
+  errorMessage;
+  remoteTraceback;
+  constructor(errorType, errorMessage, remoteTraceback) {
+    super(`${errorType}: ${errorMessage}`);
+    this.errorType = errorType;
+    this.errorMessage = errorMessage;
+    this.remoteTraceback = remoteTraceback;
+    this.name = "RpcError";
+  }
+}
+
+class VersionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "VersionError";
+  }
+}
+
+// src/wire/request.ts
+function parseRequest(schema, batch) {
+  const metadata = batch.metadata ?? new Map;
+  const methodName = metadata.get(RPC_METHOD_KEY);
+  if (methodName === undefined) {
+    throw new RpcError("ProtocolError", "Missing 'vgi_rpc.method' in request batch custom_metadata. " + "Each request batch must carry a 'vgi_rpc.method' key in its Arrow IPC custom_metadata " + "with the method name as a UTF-8 string.", "");
+  }
+  const version = metadata.get(REQUEST_VERSION_KEY);
+  if (version === undefined) {
+    throw new VersionError("Missing 'vgi_rpc.request_version' in request batch custom_metadata. " + `Set the 'vgi_rpc.request_version' custom_metadata value to '${REQUEST_VERSION}'.`);
+  }
+  if (version !== REQUEST_VERSION) {
+    throw new VersionError(`Unsupported request version '${version}', expected '${REQUEST_VERSION}'. ` + `Set the 'vgi_rpc.request_version' custom_metadata value to '${REQUEST_VERSION}'.`);
+  }
+  const requestId = metadata.get(REQUEST_ID_KEY) ?? null;
+  const params = {};
+  if (schema.fields.length > 0 && batch.numRows !== 1) {
+    throw new RpcError("ProtocolError", `Expected 1 row in request batch, got ${batch.numRows}. ` + "Each parameter is a column (not a row). The batch should have exactly 1 row.", "");
+  }
+  for (let i = 0;i < schema.fields.length; i++) {
+    const field = schema.fields[i];
+    if (DataType.isMap(field.type)) {
+      params[field.name] = batch.getChildAt(i).data[0];
+      continue;
+    }
+    let value = batch.getChildAt(i)?.get(0);
+    if (typeof value === "bigint") {
+      if (value >= BigInt(Number.MIN_SAFE_INTEGER) && value <= BigInt(Number.MAX_SAFE_INTEGER)) {
+        value = Number(value);
+      }
+    }
+    params[field.name] = value;
+  }
+  return {
+    methodName,
+    requestVersion: version,
+    requestId,
+    schema,
+    params,
+    rawMetadata: metadata
+  };
+}
+
+// src/wire/response.ts
+import {
+  RecordBatch,
+  Data,
+  DataType as DataType2,
+  makeData,
+  Struct,
+  vectorFromArray
+} from "apache-arrow";
+function coerceInt64(schema, values) {
+  const result = { ...values };
+  for (const field of schema.fields) {
+    const val = result[field.name];
+    if (val === undefined)
+      continue;
+    if (!DataType2.isInt(field.type) || field.type.bitWidth !== 64)
+      continue;
+    if (Array.isArray(val)) {
+      result[field.name] = val.map((v) => typeof v === "number" ? BigInt(v) : v);
+    } else if (typeof val === "number") {
+      result[field.name] = BigInt(val);
+    }
+  }
+  return result;
+}
+function buildResultBatch(schema, values, serverId, requestId) {
+  const metadata = new Map;
+  metadata.set(SERVER_ID_KEY, serverId);
+  if (requestId !== null) {
+    metadata.set(REQUEST_ID_KEY, requestId);
+  }
+  if (schema.fields.length === 0) {
+    return buildEmptyBatch(schema, metadata);
+  }
+  for (const field of schema.fields) {
+    if (values[field.name] === undefined && !field.nullable) {
+      const got = Object.keys(values);
+      throw new TypeError(`Handler result missing required field '${field.name}'. Got keys: [${got.join(", ")}]`);
+    }
+  }
+  const coerced = coerceInt64(schema, values);
+  const children = schema.fields.map((f) => {
+    let val = coerced[f.name];
+    if (val instanceof Data) {
+      return val;
+    }
+    const arr = vectorFromArray([val], f.type);
+    return arr.data[0];
+  });
+  const structType = new Struct(schema.fields);
+  const data = makeData({
+    type: structType,
+    length: 1,
+    children,
+    nullCount: 0
+  });
+  return new RecordBatch(schema, data, metadata);
+}
+function buildErrorBatch(schema, error, serverId, requestId) {
+  const metadata = new Map;
+  metadata.set(LOG_LEVEL_KEY, "EXCEPTION");
+  metadata.set(LOG_MESSAGE_KEY, `${error.constructor.name}: ${error.message}`);
+  const extra = {
+    exception_type: error.constructor.name,
+    exception_message: error.message,
+    traceback: error.stack ?? ""
+  };
+  metadata.set(LOG_EXTRA_KEY, JSON.stringify(extra));
+  metadata.set(SERVER_ID_KEY, serverId);
+  if (requestId !== null) {
+    metadata.set(REQUEST_ID_KEY, requestId);
+  }
+  return buildEmptyBatch(schema, metadata);
+}
+function buildLogBatch(schema, level, message, extra, serverId, requestId) {
+  const metadata = new Map;
+  metadata.set(LOG_LEVEL_KEY, level);
+  metadata.set(LOG_MESSAGE_KEY, message);
+  if (extra) {
+    metadata.set(LOG_EXTRA_KEY, JSON.stringify(extra));
+  }
+  if (serverId != null) {
+    metadata.set(SERVER_ID_KEY, serverId);
+  }
+  if (requestId != null) {
+    metadata.set(REQUEST_ID_KEY, requestId);
+  }
+  return buildEmptyBatch(schema, metadata);
+}
+function buildEmptyBatch(schema, metadata) {
+  const children = schema.fields.map((f) => {
+    return makeData({ type: f.type, length: 0, nullCount: 0 });
+  });
+  if (schema.fields.length === 0) {
+    const structType2 = new Struct(schema.fields);
+    const data2 = makeData({
+      type: structType2,
+      length: 0,
+      children: [],
+      nullCount: 0
+    });
+    return new RecordBatch(schema, data2, metadata);
+  }
+  const structType = new Struct(schema.fields);
+  const data = makeData({
+    type: structType,
+    length: 0,
+    children,
+    nullCount: 0
+  });
+  return new RecordBatch(schema, data, metadata);
+}
+
+// src/dispatch/describe.ts
+import {
+  Schema as Schema2,
+  Field as Field2,
+  RecordBatch as RecordBatch2,
+  Utf8,
+  Bool,
+  Binary,
+  vectorFromArray as vectorFromArray2,
+  makeData as makeData2,
+  Struct as Struct2
+} from "apache-arrow";
+
+// src/util/schema.ts
+import { RecordBatchStreamWriter as RecordBatchStreamWriter2 } from "apache-arrow";
+function serializeSchema(schema) {
+  const writer = new RecordBatchStreamWriter2;
+  writer.reset(undefined, schema);
+  writer.close();
+  return writer.toUint8Array(true);
+}
+
+// src/dispatch/describe.ts
+var DESCRIBE_SCHEMA = new Schema2([
+  new Field2("name", new Utf8, false),
+  new Field2("method_type", new Utf8, false),
+  new Field2("doc", new Utf8, true),
+  new Field2("has_return", new Bool, false),
+  new Field2("params_schema_ipc", new Binary, false),
+  new Field2("result_schema_ipc", new Binary, false),
+  new Field2("param_types_json", new Utf8, true),
+  new Field2("param_defaults_json", new Utf8, true),
+  new Field2("has_header", new Bool, false),
+  new Field2("header_schema_ipc", new Binary, true)
+]);
+function buildDescribeBatch(protocolName, methods, serverId) {
+  const sortedEntries = [...methods.entries()].sort(([a], [b]) => a.localeCompare(b));
+  const names = [];
+  const methodTypes = [];
+  const docs = [];
+  const hasReturns = [];
+  const paramsSchemas = [];
+  const resultSchemas = [];
+  const paramTypesJsons = [];
+  const paramDefaultsJsons = [];
+  const hasHeaders = [];
+  const headerSchemas = [];
+  for (const [name, method] of sortedEntries) {
+    names.push(name);
+    methodTypes.push(method.type);
+    docs.push(method.doc ?? null);
+    const hasReturn = method.type === "unary" && method.resultSchema.fields.length > 0;
+    hasReturns.push(hasReturn);
+    paramsSchemas.push(serializeSchema(method.paramsSchema));
+    resultSchemas.push(serializeSchema(method.resultSchema));
+    if (method.paramTypes && Object.keys(method.paramTypes).length > 0) {
+      paramTypesJsons.push(JSON.stringify(method.paramTypes));
+    } else {
+      paramTypesJsons.push(null);
+    }
+    if (method.defaults && Object.keys(method.defaults).length > 0) {
+      const safe = {};
+      for (const [k, v] of Object.entries(method.defaults)) {
+        if (v === null || typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+          safe[k] = v;
+        }
+      }
+      paramDefaultsJsons.push(Object.keys(safe).length > 0 ? JSON.stringify(safe) : null);
+    } else {
+      paramDefaultsJsons.push(null);
+    }
+    hasHeaders.push(!!method.headerSchema);
+    headerSchemas.push(method.headerSchema ? serializeSchema(method.headerSchema) : null);
+  }
+  const nameArr = vectorFromArray2(names, new Utf8);
+  const methodTypeArr = vectorFromArray2(methodTypes, new Utf8);
+  const docArr = vectorFromArray2(docs, new Utf8);
+  const hasReturnArr = vectorFromArray2(hasReturns, new Bool);
+  const paramsSchemaArr = vectorFromArray2(paramsSchemas, new Binary);
+  const resultSchemaArr = vectorFromArray2(resultSchemas, new Binary);
+  const paramTypesArr = vectorFromArray2(paramTypesJsons, new Utf8);
+  const paramDefaultsArr = vectorFromArray2(paramDefaultsJsons, new Utf8);
+  const hasHeaderArr = vectorFromArray2(hasHeaders, new Bool);
+  const headerSchemaArr = vectorFromArray2(headerSchemas, new Binary);
+  const children = [
+    nameArr.data[0],
+    methodTypeArr.data[0],
+    docArr.data[0],
+    hasReturnArr.data[0],
+    paramsSchemaArr.data[0],
+    resultSchemaArr.data[0],
+    paramTypesArr.data[0],
+    paramDefaultsArr.data[0],
+    hasHeaderArr.data[0],
+    headerSchemaArr.data[0]
+  ];
+  const structType = new Struct2(DESCRIBE_SCHEMA.fields);
+  const data = makeData2({
+    type: structType,
+    length: sortedEntries.length,
+    children,
+    nullCount: 0
+  });
+  const metadata = new Map;
+  metadata.set(PROTOCOL_NAME_KEY, protocolName);
+  metadata.set(REQUEST_VERSION_KEY, REQUEST_VERSION);
+  metadata.set(DESCRIBE_VERSION_KEY, DESCRIBE_VERSION);
+  metadata.set(SERVER_ID_KEY, serverId);
+  const batch = new RecordBatch2(DESCRIBE_SCHEMA, data, metadata);
+  return { batch, metadata };
+}
+
+// src/types.ts
+import { RecordBatch as RecordBatch3, recordBatchFromArrays } from "apache-arrow";
+var MethodType;
+((MethodType2) => {
+  MethodType2["UNARY"] = "unary";
+  MethodType2["STREAM"] = "stream";
+})(MethodType ||= {});
+
+class OutputCollector {
+  _batches = [];
+  _dataBatchIdx = null;
+  _finished = false;
+  _producerMode;
+  _outputSchema;
+  _serverId;
+  _requestId;
+  constructor(outputSchema, producerMode = true, serverId = "", requestId = null) {
+    this._outputSchema = outputSchema;
+    this._producerMode = producerMode;
+    this._serverId = serverId;
+    this._requestId = requestId;
+  }
+  get outputSchema() {
+    return this._outputSchema;
+  }
+  get finished() {
+    return this._finished;
+  }
+  get batches() {
+    return this._batches;
+  }
+  emit(batchOrColumns, metadata) {
+    let batch;
+    if (batchOrColumns instanceof RecordBatch3) {
+      batch = batchOrColumns;
+    } else {
+      const coerced = coerceInt64(this._outputSchema, batchOrColumns);
+      batch = recordBatchFromArrays(coerced, this._outputSchema);
+    }
+    if (this._dataBatchIdx !== null) {
+      throw new Error("Only one data batch may be emitted per call");
+    }
+    this._dataBatchIdx = this._batches.length;
+    this._batches.push({ batch, metadata });
+  }
+  emitRow(values) {
+    const columns = {};
+    for (const [key, value] of Object.entries(values)) {
+      columns[key] = [value];
+    }
+    this.emit(columns);
+  }
+  finish() {
+    if (!this._producerMode) {
+      throw new Error("finish() is not allowed on exchange streams; " + "exchange streams must emit exactly one data batch per call");
+    }
+    this._finished = true;
+  }
+  clientLog(level, message, extra) {
+    const batch = buildLogBatch(this._outputSchema, level, message, extra, this._serverId, this._requestId);
+    this._batches.push({ batch });
+  }
+}
+
+// src/dispatch/unary.ts
+async function dispatchUnary(method, params, writer, serverId, requestId) {
+  const schema = method.resultSchema;
+  const out = new OutputCollector(schema, true, serverId, requestId);
+  try {
+    const result = await method.handler(params, out);
+    const resultBatch = buildResultBatch(schema, result, serverId, requestId);
+    const batches = [...out.batches.map((b) => b.batch), resultBatch];
+    writer.writeStream(schema, batches);
+  } catch (error) {
+    const batch = buildErrorBatch(schema, error, serverId, requestId);
+    writer.writeStream(schema, [batch]);
+  }
+}
+
+// src/dispatch/stream.ts
+import { Schema as Schema3 } from "apache-arrow";
+var EMPTY_SCHEMA = new Schema3([]);
+async function dispatchStream(method, params, writer, reader, serverId, requestId) {
+  const isProducer = !method.inputSchema || method.inputSchema.fields.length === 0;
+  let state;
+  try {
+    if (isProducer) {
+      state = await method.producerInit(params);
+    } else {
+      state = await method.exchangeInit(params);
+    }
+  } catch (error) {
+    const errSchema = method.headerSchema ?? EMPTY_SCHEMA;
+    const errBatch = buildErrorBatch(errSchema, error, serverId, requestId);
+    writer.writeStream(errSchema, [errBatch]);
+    const inputSchema2 = await reader.openNextStream();
+    if (inputSchema2) {
+      while (await reader.readNextBatch() !== null) {}
+    }
+    return;
+  }
+  const outputSchema = state?.__outputSchema ?? method.outputSchema;
+  const effectiveProducer = state?.__isProducer ?? isProducer;
+  if (method.headerSchema && method.headerInit) {
+    try {
+      const headerOut = new OutputCollector(method.headerSchema, true, serverId, requestId);
+      const headerValues = method.headerInit(params, state, headerOut);
+      const headerBatch = buildResultBatch(method.headerSchema, headerValues, serverId, requestId);
+      const headerBatches = [
+        ...headerOut.batches.map((b) => b.batch),
+        headerBatch
+      ];
+      writer.writeStream(method.headerSchema, headerBatches);
+    } catch (error) {
+      const errBatch = buildErrorBatch(method.headerSchema, error, serverId, requestId);
+      writer.writeStream(method.headerSchema, [errBatch]);
+      const inputSchema2 = await reader.openNextStream();
+      if (inputSchema2) {
+        while (await reader.readNextBatch() !== null) {}
+      }
+      return;
+    }
+  }
+  const inputSchema = await reader.openNextStream();
+  if (!inputSchema) {
+    const errBatch = buildErrorBatch(outputSchema, new Error("Expected input stream but got EOF"), serverId, requestId);
+    writer.writeStream(outputSchema, [errBatch]);
+    return;
+  }
+  const stream = writer.openStream(outputSchema);
+  try {
+    while (true) {
+      const inputBatch = await reader.readNextBatch();
+      if (!inputBatch)
+        break;
+      const out = new OutputCollector(outputSchema, effectiveProducer, serverId, requestId);
+      if (isProducer) {
+        await method.producerFn(state, out);
+      } else {
+        await method.exchangeFn(state, inputBatch, out);
+      }
+      for (const emitted of out.batches) {
+        stream.write(emitted.batch);
+      }
+      if (out.finished) {
+        break;
+      }
+    }
+  } catch (error) {
+    stream.write(buildErrorBatch(outputSchema, error, serverId, requestId));
+  }
+  stream.close();
+  try {
+    while (await reader.readNextBatch() !== null) {}
+  } catch {}
+}
+
+// src/server.ts
+var EMPTY_SCHEMA2 = new Schema4([]);
+
+class VgiRpcServer {
+  protocol;
+  enableDescribe;
+  serverId;
+  describeBatch = null;
+  constructor(protocol, options) {
+    this.protocol = protocol;
+    this.enableDescribe = options?.enableDescribe ?? true;
+    this.serverId = options?.serverId ?? crypto.randomUUID().replace(/-/g, "").slice(0, 12);
+    if (this.enableDescribe) {
+      const { batch } = buildDescribeBatch(protocol.name, protocol.getMethods(), this.serverId);
+      this.describeBatch = batch;
+    }
+  }
+  async run() {
+    const stdin = process.stdin;
+    if (process.stdin.isTTY || process.stdout.isTTY) {
+      process.stderr.write("WARNING: This process communicates via Arrow IPC on stdin/stdout " + `and is not intended to be run interactively.
+` + "It should be launched as a subprocess by an RPC client " + `(e.g. vgi_rpc.connect()).
+`);
+    }
+    const reader = await IpcStreamReader.create(stdin);
+    const writer = new IpcStreamWriter;
+    try {
+      while (true) {
+        await this.serveOne(reader, writer);
+      }
+    } catch (e) {
+      if (e.message?.includes("closed") || e.message?.includes("Expected Schema Message") || e.message?.includes("null or length 0") || e.code === "EPIPE" || e.code === "ERR_STREAM_PREMATURE_CLOSE" || e.code === "ERR_STREAM_DESTROYED" || e instanceof Error && e.message.includes("EOF")) {
+        return;
+      }
+      throw e;
+    } finally {
+      await reader.cancel();
+    }
+  }
+  async serveOne(reader, writer) {
+    const stream = await reader.readStream();
+    if (!stream) {
+      throw new Error("EOF");
+    }
+    const { schema, batches } = stream;
+    if (batches.length === 0) {
+      const err = new RpcError("ProtocolError", "Request stream contains no batches", "");
+      const errBatch = buildErrorBatch(EMPTY_SCHEMA2, err, this.serverId, null);
+      writer.writeStream(EMPTY_SCHEMA2, [errBatch]);
+      return;
+    }
+    const batch = batches[0];
+    let methodName;
+    let params;
+    let requestId;
+    try {
+      const parsed = parseRequest(schema, batch);
+      methodName = parsed.methodName;
+      params = parsed.params;
+      requestId = parsed.requestId;
+    } catch (e) {
+      const errBatch = buildErrorBatch(EMPTY_SCHEMA2, e, this.serverId, null);
+      writer.writeStream(EMPTY_SCHEMA2, [errBatch]);
+      if (e instanceof VersionError || e instanceof RpcError) {
+        return;
+      }
+      throw e;
+    }
+    if (methodName === DESCRIBE_METHOD_NAME && this.describeBatch) {
+      writer.writeStream(this.describeBatch.schema, [this.describeBatch]);
+      return;
+    }
+    const methods = this.protocol.getMethods();
+    const method = methods.get(methodName);
+    if (!method) {
+      const available = [...methods.keys()].sort();
+      const err = new Error(`Unknown method: '${methodName}'. Available methods: [${available.join(", ")}]`);
+      const errBatch = buildErrorBatch(EMPTY_SCHEMA2, err, this.serverId, requestId);
+      writer.writeStream(EMPTY_SCHEMA2, [errBatch]);
+      return;
+    }
+    if (method.type === "unary" /* UNARY */) {
+      await dispatchUnary(method, params, writer, this.serverId, requestId);
+    } else {
+      await dispatchStream(method, params, writer, reader, this.serverId, requestId);
+    }
+  }
+}
+// src/protocol.ts
+import { Schema as Schema6 } from "apache-arrow";
+
+// src/schema.ts
+import {
+  Schema as Schema5,
+  Field as Field3,
+  DataType as DataType3,
+  Utf8 as Utf82,
+  Binary as Binary2,
+  Int64,
+  Int32,
+  Int16,
+  Float64,
+  Float32,
+  Bool as Bool2
+} from "apache-arrow";
+var str = new Utf82;
+var bytes = new Binary2;
+var int = new Int64;
+var int32 = new Int32;
+var float = new Float64;
+var float32 = new Float32;
+var bool = new Bool2;
+function toSchema(spec) {
+  if (spec instanceof Schema5)
+    return spec;
+  const fields = [];
+  for (const [name, value] of Object.entries(spec)) {
+    if (value instanceof Field3) {
+      fields.push(value);
+    } else if (value instanceof DataType3) {
+      fields.push(new Field3(name, value, false));
+    } else {
+      throw new TypeError(`Invalid schema value for "${name}": expected DataType or Field, got ${typeof value}`);
+    }
+  }
+  return new Schema5(fields);
+}
+var TYPE_MAP = [
+  [Utf82, "str"],
+  [Binary2, "bytes"],
+  [Bool2, "bool"],
+  [Float64, "float"],
+  [Float32, "float"],
+  [Int64, "int"],
+  [Int32, "int"],
+  [Int16, "int"]
+];
+function inferParamTypes(spec) {
+  const schema = toSchema(spec);
+  if (schema.fields.length === 0)
+    return;
+  const result = {};
+  for (const field of schema.fields) {
+    let mapped;
+    for (const [ctor, name] of TYPE_MAP) {
+      if (field.type instanceof ctor) {
+        mapped = name;
+        break;
+      }
+    }
+    if (!mapped)
+      return;
+    result[field.name] = mapped;
+  }
+  return result;
+}
+
+// src/protocol.ts
+var EMPTY_SCHEMA3 = new Schema6([]);
+
+class Protocol {
+  name;
+  _methods = new Map;
+  constructor(name) {
+    this.name = name;
+  }
+  unary(name, config) {
+    const params = toSchema(config.params);
+    this._methods.set(name, {
+      name,
+      type: "unary" /* UNARY */,
+      paramsSchema: params,
+      resultSchema: toSchema(config.result),
+      handler: config.handler,
+      doc: config.doc,
+      defaults: config.defaults,
+      paramTypes: config.paramTypes ?? inferParamTypes(params)
+    });
+    return this;
+  }
+  producer(name, config) {
+    const params = toSchema(config.params);
+    this._methods.set(name, {
+      name,
+      type: "stream" /* STREAM */,
+      paramsSchema: params,
+      resultSchema: EMPTY_SCHEMA3,
+      outputSchema: toSchema(config.outputSchema),
+      inputSchema: EMPTY_SCHEMA3,
+      producerInit: config.init,
+      producerFn: config.produce,
+      headerSchema: config.headerSchema ? toSchema(config.headerSchema) : undefined,
+      headerInit: config.headerInit,
+      doc: config.doc,
+      defaults: config.defaults,
+      paramTypes: config.paramTypes ?? inferParamTypes(params)
+    });
+    return this;
+  }
+  exchange(name, config) {
+    const params = toSchema(config.params);
+    this._methods.set(name, {
+      name,
+      type: "stream" /* STREAM */,
+      paramsSchema: params,
+      resultSchema: EMPTY_SCHEMA3,
+      inputSchema: toSchema(config.inputSchema),
+      outputSchema: toSchema(config.outputSchema),
+      exchangeInit: config.init,
+      exchangeFn: config.exchange,
+      headerSchema: config.headerSchema ? toSchema(config.headerSchema) : undefined,
+      headerInit: config.headerInit,
+      doc: config.doc,
+      defaults: config.defaults,
+      paramTypes: config.paramTypes ?? inferParamTypes(params)
+    });
+    return this;
+  }
+  getMethods() {
+    return new Map(this._methods);
+  }
+}
+// src/http/handler.ts
+import { Schema as Schema9 } from "apache-arrow";
+import { randomBytes } from "node:crypto";
+
+// src/http/types.ts
+var jsonStateSerializer = {
+  serialize(state) {
+    return new TextEncoder().encode(JSON.stringify(state, (_key, value) => typeof value === "bigint" ? `__bigint__:${value}` : value));
+  },
+  deserialize(bytes2) {
+    return JSON.parse(new TextDecoder().decode(bytes2), (_key, value) => typeof value === "string" && value.startsWith("__bigint__:") ? BigInt(value.slice(11)) : value);
+  }
+};
+
+// src/http/common.ts
+import {
+  RecordBatchStreamWriter as RecordBatchStreamWriter3,
+  RecordBatchReader as RecordBatchReader2,
+  RecordBatch as RecordBatch4,
+  Struct as Struct3,
+  makeData as makeData3
+} from "apache-arrow";
+var ARROW_CONTENT_TYPE = "application/vnd.apache.arrow.stream";
+
+class HttpRpcError extends Error {
+  statusCode;
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "HttpRpcError";
+  }
+}
+function conformBatchToSchema(batch, schema) {
+  if (batch.numRows === 0)
+    return batch;
+  const children = schema.fields.map((f, i) => batch.data.children[i].clone(f.type));
+  const structType = new Struct3(schema.fields);
+  const data = makeData3({
+    type: structType,
+    length: batch.numRows,
+    children,
+    nullCount: batch.data.nullCount,
+    nullBitmap: batch.data.nullBitmap
+  });
+  return new RecordBatch4(schema, data, batch.metadata);
+}
+function serializeIpcStream(schema, batches) {
+  const writer = new RecordBatchStreamWriter3;
+  writer.reset(undefined, schema);
+  for (const batch of batches) {
+    writer.write(conformBatchToSchema(batch, schema));
+  }
+  writer.close();
+  return writer.toUint8Array(true);
+}
+function arrowResponse(body, status = 200, extraHeaders) {
+  const headers = extraHeaders ?? new Headers;
+  headers.set("Content-Type", ARROW_CONTENT_TYPE);
+  return new Response(body, { status, headers });
+}
+async function readRequestFromBody(body) {
+  const reader = await RecordBatchReader2.from(body);
+  await reader.open();
+  const schema = reader.schema;
+  if (!schema) {
+    throw new HttpRpcError("Empty IPC stream: no schema", 400);
+  }
+  const batches = reader.readAll();
+  if (batches.length === 0) {
+    throw new HttpRpcError("IPC stream contains no batches", 400);
+  }
+  return { schema, batch: batches[0] };
+}
+
+// src/http/dispatch.ts
+import { Schema as Schema8, RecordBatch as RecordBatch5 } from "apache-arrow";
+
+// src/http/token.ts
+import { createHmac, timingSafeEqual } from "node:crypto";
+var TOKEN_VERSION = 2;
+var HMAC_LEN = 32;
+var MIN_TOKEN_LEN = 1 + 8 + 12 + HMAC_LEN;
+function packStateToken(stateBytes, schemaBytes, inputSchemaBytes, signingKey, createdAt) {
+  const now = createdAt ?? Math.floor(Date.now() / 1000);
+  const payloadLen = 1 + 8 + 4 + stateBytes.length + 4 + schemaBytes.length + 4 + inputSchemaBytes.length;
+  const buf = Buffer.alloc(payloadLen);
+  let offset = 0;
+  buf.writeUInt8(TOKEN_VERSION, offset);
+  offset += 1;
+  buf.writeBigUInt64LE(BigInt(now), offset);
+  offset += 8;
+  buf.writeUInt32LE(stateBytes.length, offset);
+  offset += 4;
+  buf.set(stateBytes, offset);
+  offset += stateBytes.length;
+  buf.writeUInt32LE(schemaBytes.length, offset);
+  offset += 4;
+  buf.set(schemaBytes, offset);
+  offset += schemaBytes.length;
+  buf.writeUInt32LE(inputSchemaBytes.length, offset);
+  offset += 4;
+  buf.set(inputSchemaBytes, offset);
+  offset += inputSchemaBytes.length;
+  const mac = createHmac("sha256", signingKey).update(buf).digest();
+  const token = Buffer.concat([buf, mac]);
+  return token.toString("base64");
+}
+function unpackStateToken(tokenBase64, signingKey, tokenTtl) {
+  const token = Buffer.from(tokenBase64, "base64");
+  if (token.length < MIN_TOKEN_LEN) {
+    throw new Error("State token too short");
+  }
+  const payload = token.subarray(0, token.length - HMAC_LEN);
+  const receivedMac = token.subarray(token.length - HMAC_LEN);
+  const expectedMac = createHmac("sha256", signingKey).update(payload).digest();
+  if (!timingSafeEqual(receivedMac, expectedMac)) {
+    throw new Error("State token HMAC verification failed");
+  }
+  let offset = 0;
+  const version = payload.readUInt8(offset);
+  offset += 1;
+  if (version !== TOKEN_VERSION) {
+    throw new Error(`Unsupported state token version: ${version}`);
+  }
+  const createdAt = Number(payload.readBigUInt64LE(offset));
+  offset += 8;
+  if (tokenTtl > 0) {
+    const now = Math.floor(Date.now() / 1000);
+    if (now - createdAt > tokenTtl) {
+      throw new Error("State token expired");
+    }
+  }
+  const stateLen = payload.readUInt32LE(offset);
+  offset += 4;
+  if (offset + stateLen > payload.length) {
+    throw new Error("State token truncated (state)");
+  }
+  const stateBytes = payload.slice(offset, offset + stateLen);
+  offset += stateLen;
+  const schemaLen = payload.readUInt32LE(offset);
+  offset += 4;
+  if (offset + schemaLen > payload.length) {
+    throw new Error("State token truncated (schema)");
+  }
+  const schemaBytes = payload.slice(offset, offset + schemaLen);
+  offset += schemaLen;
+  const inputSchemaLen = payload.readUInt32LE(offset);
+  offset += 4;
+  if (offset + inputSchemaLen > payload.length) {
+    throw new Error("State token truncated (input schema)");
+  }
+  const inputSchemaBytes = payload.slice(offset, offset + inputSchemaLen);
+  return { stateBytes, schemaBytes, inputSchemaBytes, createdAt };
+}
+
+// src/http/dispatch.ts
+var EMPTY_SCHEMA4 = new Schema8([]);
+function httpDispatchDescribe(protocolName, methods, serverId) {
+  const { batch } = buildDescribeBatch(protocolName, methods, serverId);
+  const body = serializeIpcStream(DESCRIBE_SCHEMA, [batch]);
+  return arrowResponse(body);
+}
+async function httpDispatchUnary(method, body, ctx) {
+  const schema = method.resultSchema;
+  const { schema: reqSchema, batch: reqBatch } = await readRequestFromBody(body);
+  const parsed = parseRequest(reqSchema, reqBatch);
+  if (parsed.methodName !== method.name) {
+    throw new HttpRpcError(`Method name in request '${parsed.methodName}' does not match URL '${method.name}'`, 400);
+  }
+  const out = new OutputCollector(schema, true, ctx.serverId, parsed.requestId);
+  try {
+    const result = await method.handler(parsed.params, out);
+    const resultBatch = buildResultBatch(schema, result, ctx.serverId, parsed.requestId);
+    const batches = [...out.batches.map((b) => b.batch), resultBatch];
+    return arrowResponse(serializeIpcStream(schema, batches));
+  } catch (error) {
+    const errBatch = buildErrorBatch(schema, error, ctx.serverId, parsed.requestId);
+    return arrowResponse(serializeIpcStream(schema, [errBatch]), 500);
+  }
+}
+async function httpDispatchStreamInit(method, body, ctx) {
+  const isProducer = !method.inputSchema || method.inputSchema.fields.length === 0;
+  const outputSchema = method.outputSchema;
+  const inputSchema = method.inputSchema ?? EMPTY_SCHEMA4;
+  const { schema: reqSchema, batch: reqBatch } = await readRequestFromBody(body);
+  const parsed = parseRequest(reqSchema, reqBatch);
+  if (parsed.methodName !== method.name) {
+    throw new HttpRpcError(`Method name in request '${parsed.methodName}' does not match URL '${method.name}'`, 400);
+  }
+  let state;
+  try {
+    if (isProducer) {
+      state = await method.producerInit(parsed.params);
+    } else {
+      state = await method.exchangeInit(parsed.params);
+    }
+  } catch (error) {
+    const errSchema = method.headerSchema ?? EMPTY_SCHEMA4;
+    const errBatch = buildErrorBatch(errSchema, error, ctx.serverId, parsed.requestId);
+    return arrowResponse(serializeIpcStream(errSchema, [errBatch]), 500);
+  }
+  const resolvedOutputSchema = state?.__outputSchema ?? outputSchema;
+  const effectiveProducer = state?.__isProducer ?? isProducer;
+  let headerBytes = null;
+  if (method.headerSchema && method.headerInit) {
+    try {
+      const headerOut = new OutputCollector(method.headerSchema, true, ctx.serverId, parsed.requestId);
+      const headerValues = method.headerInit(parsed.params, state, headerOut);
+      const headerBatch = buildResultBatch(method.headerSchema, headerValues, ctx.serverId, parsed.requestId);
+      const headerBatches = [
+        ...headerOut.batches.map((b) => b.batch),
+        headerBatch
+      ];
+      headerBytes = serializeIpcStream(method.headerSchema, headerBatches);
+    } catch (error) {
+      const errBatch = buildErrorBatch(method.headerSchema, error, ctx.serverId, parsed.requestId);
+      return arrowResponse(serializeIpcStream(method.headerSchema, [errBatch]), 500);
+    }
+  }
+  if (effectiveProducer) {
+    return produceStreamResponse(method, state, resolvedOutputSchema, inputSchema, ctx, parsed.requestId, headerBytes);
+  } else {
+    const stateBytes = ctx.stateSerializer.serialize(state);
+    const schemaBytes = serializeSchema(resolvedOutputSchema);
+    const inputSchemaBytes = serializeSchema(inputSchema);
+    const token = packStateToken(stateBytes, schemaBytes, inputSchemaBytes, ctx.signingKey);
+    const tokenMeta = new Map;
+    tokenMeta.set(STATE_KEY, token);
+    const tokenBatch = buildEmptyBatch(resolvedOutputSchema, tokenMeta);
+    const tokenStreamBytes = serializeIpcStream(resolvedOutputSchema, [tokenBatch]);
+    let responseBody;
+    if (headerBytes) {
+      responseBody = concatBytes(headerBytes, tokenStreamBytes);
+    } else {
+      responseBody = tokenStreamBytes;
+    }
+    return arrowResponse(responseBody);
+  }
+}
+async function httpDispatchStreamExchange(method, body, ctx) {
+  const isProducer = !method.inputSchema || method.inputSchema.fields.length === 0;
+  const { batch: reqBatch } = await readRequestFromBody(body);
+  const tokenBase64 = reqBatch.metadata?.get(STATE_KEY);
+  if (!tokenBase64) {
+    throw new HttpRpcError("Missing state token in exchange request", 400);
+  }
+  let unpacked;
+  try {
+    unpacked = unpackStateToken(tokenBase64, ctx.signingKey, ctx.tokenTtl);
+  } catch (error) {
+    throw new HttpRpcError(`Invalid state token: ${error.message}`, 400);
+  }
+  const state = ctx.stateSerializer.deserialize(unpacked.stateBytes);
+  const outputSchema = state?.__outputSchema ?? method.outputSchema;
+  const inputSchema = method.inputSchema ?? EMPTY_SCHEMA4;
+  const effectiveProducer = state?.__isProducer ?? isProducer;
+  if (effectiveProducer) {
+    return produceStreamResponse(method, state, outputSchema, inputSchema, ctx, null, null);
+  } else {
+    const out = new OutputCollector(outputSchema, false, ctx.serverId, null);
+    try {
+      await method.exchangeFn(state, reqBatch, out);
+    } catch (error) {
+      const errBatch = buildErrorBatch(outputSchema, error, ctx.serverId, null);
+      return arrowResponse(serializeIpcStream(outputSchema, [errBatch]), 500);
+    }
+    const stateBytes = ctx.stateSerializer.serialize(state);
+    const schemaBytes = serializeSchema(outputSchema);
+    const inputSchemaBytes = serializeSchema(inputSchema);
+    const token = packStateToken(stateBytes, schemaBytes, inputSchemaBytes, ctx.signingKey);
+    const batches = [];
+    for (const emitted of out.batches) {
+      const batch = emitted.batch;
+      if (batch.numRows > 0) {
+        const mergedMeta = new Map(batch.metadata ?? []);
+        mergedMeta.set(STATE_KEY, token);
+        batches.push(new RecordBatch5(batch.schema, batch.data, mergedMeta));
+      } else {
+        batches.push(batch);
+      }
+    }
+    return arrowResponse(serializeIpcStream(outputSchema, batches));
+  }
+}
+async function produceStreamResponse(method, state, outputSchema, inputSchema, ctx, requestId, headerBytes) {
+  const allBatches = [];
+  const maxBytes = ctx.maxStreamResponseBytes;
+  let estimatedBytes = 0;
+  while (true) {
+    const out = new OutputCollector(outputSchema, true, ctx.serverId, requestId);
+    try {
+      await method.producerFn(state, out);
+    } catch (error) {
+      allBatches.push(buildErrorBatch(outputSchema, error, ctx.serverId, requestId));
+      break;
+    }
+    for (const emitted of out.batches) {
+      allBatches.push(emitted.batch);
+      if (maxBytes != null) {
+        estimatedBytes += emitted.batch.data.byteLength;
+      }
+    }
+    if (out.finished) {
+      break;
+    }
+    if (maxBytes != null && estimatedBytes >= maxBytes) {
+      const stateBytes = ctx.stateSerializer.serialize(state);
+      const schemaBytes = serializeSchema(outputSchema);
+      const inputSchemaBytes = serializeSchema(inputSchema);
+      const token = packStateToken(stateBytes, schemaBytes, inputSchemaBytes, ctx.signingKey);
+      const tokenMeta = new Map;
+      tokenMeta.set(STATE_KEY, token);
+      allBatches.push(buildEmptyBatch(outputSchema, tokenMeta));
+      break;
+    }
+  }
+  const dataBytes = serializeIpcStream(outputSchema, allBatches);
+  let responseBody;
+  if (headerBytes) {
+    responseBody = concatBytes(headerBytes, dataBytes);
+  } else {
+    responseBody = dataBytes;
+  }
+  return arrowResponse(responseBody);
+}
+function concatBytes(...arrays) {
+  const totalLen = arrays.reduce((sum, a) => sum + a.length, 0);
+  const result = new Uint8Array(totalLen);
+  let offset = 0;
+  for (const arr of arrays) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+}
+
+// src/http/handler.ts
+init_zstd();
+var EMPTY_SCHEMA5 = new Schema9([]);
+function createHttpHandler(protocol, options) {
+  const prefix = (options?.prefix ?? "/vgi").replace(/\/+$/, "");
+  const signingKey = options?.signingKey ?? randomBytes(32);
+  const tokenTtl = options?.tokenTtl ?? 3600;
+  const corsOrigins = options?.corsOrigins;
+  const maxRequestBytes = options?.maxRequestBytes;
+  const maxStreamResponseBytes = options?.maxStreamResponseBytes;
+  const serverId = options?.serverId ?? crypto.randomUUID().replace(/-/g, "").slice(0, 12);
+  const methods = protocol.getMethods();
+  const compressionLevel = options?.compressionLevel;
+  const stateSerializer = options?.stateSerializer ?? jsonStateSerializer;
+  const ctx = {
+    signingKey,
+    tokenTtl,
+    serverId,
+    maxStreamResponseBytes,
+    stateSerializer
+  };
+  function addCorsHeaders(headers) {
+    if (corsOrigins) {
+      headers.set("Access-Control-Allow-Origin", corsOrigins);
+      headers.set("Access-Control-Allow-Methods", "POST, OPTIONS");
+      headers.set("Access-Control-Allow-Headers", "Content-Type");
+    }
+  }
+  async function compressIfAccepted(response, clientAcceptsZstd) {
+    if (compressionLevel == null || !clientAcceptsZstd)
+      return response;
+    const responseBody = new Uint8Array(await response.arrayBuffer());
+    const compressed = zstdCompress(responseBody, compressionLevel);
+    const headers = new Headers(response.headers);
+    headers.set("Content-Encoding", "zstd");
+    return new Response(compressed, {
+      status: response.status,
+      headers
+    });
+  }
+  function makeErrorResponse(error, statusCode, schema = EMPTY_SCHEMA5) {
+    const errBatch = buildErrorBatch(schema, error, serverId, null);
+    const body = serializeIpcStream(schema, [errBatch]);
+    const resp = arrowResponse(body, statusCode);
+    addCorsHeaders(resp.headers);
+    return resp;
+  }
+  return async function handler(request) {
+    const url = new URL(request.url);
+    const path = url.pathname;
+    if (request.method === "OPTIONS") {
+      if (path === `${prefix}/__capabilities__`) {
+        const headers = new Headers;
+        addCorsHeaders(headers);
+        if (maxRequestBytes != null) {
+          headers.set("VGI-Max-Request-Bytes", String(maxRequestBytes));
+        }
+        return new Response(null, { status: 204, headers });
+      }
+      if (corsOrigins) {
+        const headers = new Headers;
+        addCorsHeaders(headers);
+        return new Response(null, { status: 204, headers });
+      }
+      return new Response(null, { status: 405 });
+    }
+    if (request.method !== "POST") {
+      return new Response("Method Not Allowed", { status: 405 });
+    }
+    const contentType = request.headers.get("Content-Type");
+    if (!contentType || !contentType.includes(ARROW_CONTENT_TYPE)) {
+      return new Response(`Unsupported Media Type: expected ${ARROW_CONTENT_TYPE}`, { status: 415 });
+    }
+    if (maxRequestBytes != null) {
+      const contentLength = request.headers.get("Content-Length");
+      if (contentLength && parseInt(contentLength) > maxRequestBytes) {
+        return new Response("Request body too large", { status: 413 });
+      }
+    }
+    const clientAcceptsZstd = (request.headers.get("Accept-Encoding") ?? "").includes("zstd");
+    let body = new Uint8Array(await request.arrayBuffer());
+    const contentEncoding = request.headers.get("Content-Encoding");
+    if (contentEncoding === "zstd") {
+      body = zstdDecompress(body);
+    }
+    if (path === `${prefix}/${DESCRIBE_METHOD_NAME}`) {
+      try {
+        const response = httpDispatchDescribe(protocol.name, methods, serverId);
+        addCorsHeaders(response.headers);
+        return compressIfAccepted(response, clientAcceptsZstd);
+      } catch (error) {
+        return compressIfAccepted(makeErrorResponse(error, 500), clientAcceptsZstd);
+      }
+    }
+    if (!path.startsWith(prefix + "/")) {
+      return new Response("Not Found", { status: 404 });
+    }
+    const subPath = path.slice(prefix.length + 1);
+    let methodName;
+    let action;
+    if (subPath.endsWith("/init")) {
+      methodName = subPath.slice(0, -5);
+      action = "init";
+    } else if (subPath.endsWith("/exchange")) {
+      methodName = subPath.slice(0, -9);
+      action = "exchange";
+    } else {
+      methodName = subPath;
+      action = "call";
+    }
+    const method = methods.get(methodName);
+    if (!method) {
+      const available = [...methods.keys()].sort();
+      const err = new Error(`Unknown method: '${methodName}'. Available methods: [${available.join(", ")}]`);
+      return compressIfAccepted(makeErrorResponse(err, 404), clientAcceptsZstd);
+    }
+    try {
+      let response;
+      if (action === "call") {
+        if (method.type !== "unary" /* UNARY */) {
+          throw new HttpRpcError(`Method '${methodName}' is a stream method. Use /init and /exchange endpoints.`, 400);
+        }
+        response = await httpDispatchUnary(method, body, ctx);
+      } else if (action === "init") {
+        if (method.type !== "stream" /* STREAM */) {
+          throw new HttpRpcError(`Method '${methodName}' is a unary method. Use POST ${prefix}/${methodName} instead.`, 400);
+        }
+        response = await httpDispatchStreamInit(method, body, ctx);
+      } else {
+        if (method.type !== "stream" /* STREAM */) {
+          throw new HttpRpcError(`Method '${methodName}' is a unary method. Use POST ${prefix}/${methodName} instead.`, 400);
+        }
+        response = await httpDispatchStreamExchange(method, body, ctx);
+      }
+      addCorsHeaders(response.headers);
+      return compressIfAccepted(response, clientAcceptsZstd);
+    } catch (error) {
+      if (error instanceof HttpRpcError) {
+        return compressIfAccepted(makeErrorResponse(error, error.statusCode), clientAcceptsZstd);
+      }
+      return compressIfAccepted(makeErrorResponse(error, 500), clientAcceptsZstd);
+    }
+  };
+}
+// src/client/ipc.ts
+import {
+  RecordBatch as RecordBatch6,
+  RecordBatchReader as RecordBatchReader3,
+  DataType as DataType4,
+  Float64 as Float642,
+  Int64 as Int642,
+  Utf8 as Utf83,
+  Bool as Bool3,
+  Binary as Binary3,
+  vectorFromArray as vectorFromArray3,
+  makeData as makeData4,
+  Struct as Struct4
+} from "apache-arrow";
+function inferArrowType(value) {
+  if (typeof value === "string")
+    return new Utf83;
+  if (typeof value === "boolean")
+    return new Bool3;
+  if (typeof value === "bigint")
+    return new Int642;
+  if (typeof value === "number")
+    return new Float642;
+  if (value instanceof Uint8Array)
+    return new Binary3;
+  return new Utf83;
+}
+function coerceForArrow(type, value) {
+  if (value == null)
+    return value;
+  if (DataType4.isInt(type) && type.bitWidth === 64) {
+    if (typeof value === "number")
+      return BigInt(value);
+    return value;
+  }
+  if (DataType4.isMap(type)) {
+    if (value instanceof Map) {
+      const entriesField = type.children[0];
+      const valueType = entriesField.type.children[1].type;
+      const coerced = new Map;
+      for (const [k, v] of value) {
+        coerced.set(k, coerceForArrow(valueType, v));
+      }
+      return coerced;
+    }
+    return value;
+  }
+  if (DataType4.isList(type)) {
+    if (Array.isArray(value)) {
+      const elemType = type.children[0].type;
+      return value.map((v) => coerceForArrow(elemType, v));
+    }
+    return value;
+  }
+  return value;
+}
+function buildRequestIpc(schema, params, method) {
+  const metadata = new Map;
+  metadata.set(RPC_METHOD_KEY, method);
+  metadata.set(REQUEST_VERSION_KEY, REQUEST_VERSION);
+  if (schema.fields.length === 0) {
+    const structType2 = new Struct4(schema.fields);
+    const data2 = makeData4({
+      type: structType2,
+      length: 1,
+      children: [],
+      nullCount: 0
+    });
+    const batch2 = new RecordBatch6(schema, data2, metadata);
+    return serializeIpcStream(schema, [batch2]);
+  }
+  const children = schema.fields.map((f) => {
+    const val = coerceForArrow(f.type, params[f.name]);
+    return vectorFromArray3([val], f.type).data[0];
+  });
+  const structType = new Struct4(schema.fields);
+  const data = makeData4({
+    type: structType,
+    length: 1,
+    children,
+    nullCount: 0
+  });
+  const batch = new RecordBatch6(schema, data, metadata);
+  return serializeIpcStream(schema, [batch]);
+}
+async function readResponseBatches(body) {
+  const reader = await RecordBatchReader3.from(body);
+  await reader.open();
+  const schema = reader.schema;
+  if (!schema) {
+    throw new RpcError("ProtocolError", "Empty IPC stream: no schema", "");
+  }
+  const batches = reader.readAll();
+  return { schema, batches };
+}
+function dispatchLogOrError(batch, onLog) {
+  const meta = batch.metadata;
+  if (!meta)
+    return false;
+  const level = meta.get(LOG_LEVEL_KEY);
+  if (!level)
+    return false;
+  const message = meta.get(LOG_MESSAGE_KEY) ?? "";
+  if (level === "EXCEPTION") {
+    const extraStr = meta.get(LOG_EXTRA_KEY);
+    let errorType = "RpcError";
+    let errorMessage = message;
+    let traceback = "";
+    if (extraStr) {
+      try {
+        const extra = JSON.parse(extraStr);
+        errorType = extra.exception_type ?? "RpcError";
+        errorMessage = extra.exception_message ?? message;
+        traceback = extra.traceback ?? "";
+      } catch {}
+    }
+    throw new RpcError(errorType, errorMessage, traceback);
+  }
+  if (onLog) {
+    const extraStr = meta.get(LOG_EXTRA_KEY);
+    let extra;
+    if (extraStr) {
+      try {
+        extra = JSON.parse(extraStr);
+      } catch {}
+    }
+    onLog({ level, message, extra });
+  }
+  return true;
+}
+function extractBatchRows(batch) {
+  const rows = [];
+  for (let r = 0;r < batch.numRows; r++) {
+    const row = {};
+    for (let i = 0;i < batch.schema.fields.length; i++) {
+      const field = batch.schema.fields[i];
+      let value = batch.getChildAt(i)?.get(r);
+      if (typeof value === "bigint") {
+        if (value >= BigInt(Number.MIN_SAFE_INTEGER) && value <= BigInt(Number.MAX_SAFE_INTEGER)) {
+          value = Number(value);
+        }
+      }
+      row[field.name] = value;
+    }
+    rows.push(row);
+  }
+  return rows;
+}
+async function readSequentialStreams(body) {
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(body);
+      controller.close();
+    }
+  });
+  return IpcStreamReader.create(stream);
+}
+
+// src/client/introspect.ts
+import { RecordBatchReader as RecordBatchReader4 } from "apache-arrow";
+import { Schema as ArrowSchema } from "apache-arrow";
+async function deserializeSchema(bytes2) {
+  const reader = await RecordBatchReader4.from(bytes2);
+  await reader.open();
+  return reader.schema;
+}
+async function parseDescribeResponse(batches, onLog) {
+  let dataBatch = null;
+  for (const batch of batches) {
+    if (batch.numRows === 0) {
+      dispatchLogOrError(batch, onLog);
+      continue;
+    }
+    dataBatch = batch;
+  }
+  if (!dataBatch) {
+    throw new Error("Empty __describe__ response");
+  }
+  const meta = dataBatch.metadata;
+  const protocolName = meta?.get(PROTOCOL_NAME_KEY) ?? "";
+  const methods = [];
+  for (let i = 0;i < dataBatch.numRows; i++) {
+    const name = dataBatch.getChildAt(0).get(i);
+    const methodType = dataBatch.getChildAt(1).get(i);
+    const doc = dataBatch.getChildAt(2)?.get(i);
+    const hasReturn = dataBatch.getChildAt(3).get(i);
+    const paramsIpc = dataBatch.getChildAt(4).get(i);
+    const resultIpc = dataBatch.getChildAt(5).get(i);
+    const paramTypesJson = dataBatch.getChildAt(6)?.get(i);
+    const paramDefaultsJson = dataBatch.getChildAt(7)?.get(i);
+    const hasHeader = dataBatch.getChildAt(8).get(i);
+    const headerIpc = dataBatch.getChildAt(9)?.get(i);
+    const paramsSchema = await deserializeSchema(paramsIpc);
+    const resultSchema = await deserializeSchema(resultIpc);
+    let paramTypes;
+    if (paramTypesJson) {
+      try {
+        paramTypes = JSON.parse(paramTypesJson);
+      } catch {}
+    }
+    let defaults;
+    if (paramDefaultsJson) {
+      try {
+        defaults = JSON.parse(paramDefaultsJson);
+      } catch {}
+    }
+    const info = {
+      name,
+      type: methodType,
+      paramsSchema,
+      resultSchema,
+      doc: doc ?? undefined,
+      paramTypes,
+      defaults
+    };
+    if (methodType === "stream") {
+      info.outputSchema = resultSchema;
+    }
+    if (hasHeader && headerIpc) {
+      info.headerSchema = await deserializeSchema(headerIpc);
+    }
+    methods.push(info);
+  }
+  return { protocolName, methods };
+}
+async function httpIntrospect(baseUrl, options) {
+  const prefix = options?.prefix ?? "/vgi";
+  const emptySchema = new ArrowSchema([]);
+  const body = buildRequestIpc(emptySchema, {}, DESCRIBE_METHOD_NAME);
+  const response = await fetch(`${baseUrl}${prefix}/${DESCRIBE_METHOD_NAME}`, {
+    method: "POST",
+    headers: { "Content-Type": ARROW_CONTENT_TYPE },
+    body
+  });
+  const responseBody = new Uint8Array(await response.arrayBuffer());
+  const { batches } = await readResponseBatches(responseBody);
+  return parseDescribeResponse(batches);
+}
+
+// src/client/stream.ts
+import {
+  RecordBatch as RecordBatch8,
+  Schema as Schema11,
+  Field as Field4,
+  makeData as makeData5,
+  Struct as Struct5,
+  vectorFromArray as vectorFromArray4
+} from "apache-arrow";
+class HttpStreamSession {
+  _baseUrl;
+  _prefix;
+  _method;
+  _stateToken;
+  _outputSchema;
+  _inputSchema;
+  _onLog;
+  _pendingBatches;
+  _finished;
+  _header;
+  _compressionLevel;
+  _compressFn;
+  _decompressFn;
+  constructor(opts) {
+    this._baseUrl = opts.baseUrl;
+    this._prefix = opts.prefix;
+    this._method = opts.method;
+    this._stateToken = opts.stateToken;
+    this._outputSchema = opts.outputSchema;
+    this._inputSchema = opts.inputSchema;
+    this._onLog = opts.onLog;
+    this._pendingBatches = opts.pendingBatches;
+    this._finished = opts.finished;
+    this._header = opts.header;
+    this._compressionLevel = opts.compressionLevel;
+    this._compressFn = opts.compressFn;
+    this._decompressFn = opts.decompressFn;
+  }
+  get header() {
+    return this._header;
+  }
+  _buildHeaders() {
+    const headers = {
+      "Content-Type": ARROW_CONTENT_TYPE
+    };
+    if (this._compressionLevel != null) {
+      headers["Content-Encoding"] = "zstd";
+      headers["Accept-Encoding"] = "zstd";
+    }
+    return headers;
+  }
+  _prepareBody(content) {
+    if (this._compressionLevel != null && this._compressFn) {
+      return this._compressFn(content, this._compressionLevel);
+    }
+    return content;
+  }
+  async _readResponse(resp) {
+    let body = new Uint8Array(await resp.arrayBuffer());
+    if (resp.headers.get("Content-Encoding") === "zstd" && this._decompressFn) {
+      body = new Uint8Array(this._decompressFn(body));
+    }
+    return body;
+  }
+  async exchange(input) {
+    if (this._stateToken === null) {
+      throw new RpcError("ProtocolError", "Stream has finished — no state token available", "");
+    }
+    if (input.length === 0) {
+      const zeroSchema = this._inputSchema ?? this._outputSchema;
+      const emptyBatch = this._buildEmptyBatch(zeroSchema);
+      const metadata2 = new Map;
+      metadata2.set(STATE_KEY, this._stateToken);
+      const batchWithMeta = new RecordBatch8(zeroSchema, emptyBatch.data, metadata2);
+      return this._doExchange(zeroSchema, [batchWithMeta]);
+    }
+    const keys = Object.keys(input[0]);
+    const fields = keys.map((key) => {
+      let sample = undefined;
+      for (const row of input) {
+        if (row[key] != null) {
+          sample = row[key];
+          break;
+        }
+      }
+      const arrowType = inferArrowType(sample);
+      const nullable = input.some((row) => row[key] == null);
+      return new Field4(key, arrowType, nullable);
+    });
+    const inputSchema = new Schema11(fields);
+    const children = inputSchema.fields.map((f) => {
+      const values = input.map((row) => row[f.name]);
+      return vectorFromArray4(values, f.type).data[0];
+    });
+    const structType = new Struct5(inputSchema.fields);
+    const data = makeData5({
+      type: structType,
+      length: input.length,
+      children,
+      nullCount: 0
+    });
+    const metadata = new Map;
+    metadata.set(STATE_KEY, this._stateToken);
+    const batch = new RecordBatch8(inputSchema, data, metadata);
+    return this._doExchange(inputSchema, [batch]);
+  }
+  async _doExchange(schema, batches) {
+    const body = serializeIpcStream(schema, batches);
+    const resp = await fetch(`${this._baseUrl}${this._prefix}/${this._method}/exchange`, {
+      method: "POST",
+      headers: this._buildHeaders(),
+      body: this._prepareBody(body)
+    });
+    const responseBody = await this._readResponse(resp);
+    const { batches: responseBatches } = await readResponseBatches(responseBody);
+    let resultRows = [];
+    for (const batch of responseBatches) {
+      if (batch.numRows === 0) {
+        dispatchLogOrError(batch, this._onLog);
+        const token2 = batch.metadata?.get(STATE_KEY);
+        if (token2) {
+          this._stateToken = token2;
+        }
+        continue;
+      }
+      const token = batch.metadata?.get(STATE_KEY);
+      if (token) {
+        this._stateToken = token;
+      }
+      resultRows = extractBatchRows(batch);
+    }
+    return resultRows;
+  }
+  _buildEmptyBatch(schema) {
+    const children = schema.fields.map((f) => {
+      return makeData5({ type: f.type, length: 0, nullCount: 0 });
+    });
+    const structType = new Struct5(schema.fields);
+    const data = makeData5({
+      type: structType,
+      length: 0,
+      children,
+      nullCount: 0
+    });
+    return new RecordBatch8(schema, data);
+  }
+  async* [Symbol.asyncIterator]() {
+    for (const batch of this._pendingBatches) {
+      if (batch.numRows === 0) {
+        dispatchLogOrError(batch, this._onLog);
+        continue;
+      }
+      yield extractBatchRows(batch);
+    }
+    this._pendingBatches = [];
+    if (this._finished)
+      return;
+    if (this._stateToken === null)
+      return;
+    while (true) {
+      const responseBody = await this._sendContinuation(this._stateToken);
+      const { batches } = await readResponseBatches(responseBody);
+      let gotContinuation = false;
+      for (const batch of batches) {
+        if (batch.numRows === 0) {
+          const token = batch.metadata?.get(STATE_KEY);
+          if (token) {
+            this._stateToken = token;
+            gotContinuation = true;
+            continue;
+          }
+          dispatchLogOrError(batch, this._onLog);
+          continue;
+        }
+        yield extractBatchRows(batch);
+      }
+      if (!gotContinuation)
+        break;
+    }
+  }
+  async _sendContinuation(token) {
+    const emptySchema = new Schema11([]);
+    const metadata = new Map;
+    metadata.set(STATE_KEY, token);
+    const structType = new Struct5(emptySchema.fields);
+    const data = makeData5({
+      type: structType,
+      length: 1,
+      children: [],
+      nullCount: 0
+    });
+    const batch = new RecordBatch8(emptySchema, data, metadata);
+    const body = serializeIpcStream(emptySchema, [batch]);
+    const resp = await fetch(`${this._baseUrl}${this._prefix}/${this._method}/exchange`, {
+      method: "POST",
+      headers: this._buildHeaders(),
+      body: this._prepareBody(body)
+    });
+    return this._readResponse(resp);
+  }
+  close() {}
+}
+
+// src/client/connect.ts
+function httpConnect(baseUrl, options) {
+  const prefix = (options?.prefix ?? "/vgi").replace(/\/+$/, "");
+  const onLog = options?.onLog;
+  const compressionLevel = options?.compressionLevel;
+  let methodCache = null;
+  let compressFn;
+  let decompressFn;
+  let compressionLoaded = false;
+  async function ensureCompression() {
+    if (compressionLoaded || compressionLevel == null)
+      return;
+    compressionLoaded = true;
+    try {
+      const mod = await Promise.resolve().then(() => (init_zstd(), exports_zstd));
+      compressFn = mod.zstdCompress;
+      decompressFn = mod.zstdDecompress;
+    } catch {}
+  }
+  function buildHeaders() {
+    const headers = {
+      "Content-Type": ARROW_CONTENT_TYPE
+    };
+    if (compressionLevel != null) {
+      headers["Content-Encoding"] = "zstd";
+      headers["Accept-Encoding"] = "zstd";
+    }
+    return headers;
+  }
+  function prepareBody(content) {
+    if (compressionLevel != null && compressFn) {
+      return compressFn(content, compressionLevel);
+    }
+    return content;
+  }
+  async function readResponse(resp) {
+    let body = new Uint8Array(await resp.arrayBuffer());
+    if (resp.headers.get("Content-Encoding") === "zstd" && decompressFn) {
+      body = new Uint8Array(decompressFn(body));
+    }
+    return body;
+  }
+  async function ensureMethodCache() {
+    if (methodCache)
+      return methodCache;
+    const desc = await httpIntrospect(baseUrl, { prefix });
+    methodCache = new Map(desc.methods.map((m) => [m.name, m]));
+    return methodCache;
+  }
+  return {
+    async call(method, params) {
+      await ensureCompression();
+      const methods = await ensureMethodCache();
+      const info = methods.get(method);
+      if (!info) {
+        throw new Error(`Unknown method: '${method}'`);
+      }
+      const fullParams = { ...info.defaults ?? {}, ...params ?? {} };
+      const body = buildRequestIpc(info.paramsSchema, fullParams, method);
+      const resp = await fetch(`${baseUrl}${prefix}/${method}`, {
+        method: "POST",
+        headers: buildHeaders(),
+        body: prepareBody(body)
+      });
+      const responseBody = await readResponse(resp);
+      const { batches } = await readResponseBatches(responseBody);
+      let resultBatch = null;
+      for (const batch of batches) {
+        if (batch.numRows === 0) {
+          dispatchLogOrError(batch, onLog);
+          continue;
+        }
+        resultBatch = batch;
+      }
+      if (!resultBatch) {
+        return null;
+      }
+      const rows = extractBatchRows(resultBatch);
+      if (rows.length === 0)
+        return null;
+      const result = rows[0];
+      if (info.resultSchema.fields.length === 0)
+        return null;
+      return result;
+    },
+    async stream(method, params) {
+      await ensureCompression();
+      const methods = await ensureMethodCache();
+      const info = methods.get(method);
+      if (!info) {
+        throw new Error(`Unknown method: '${method}'`);
+      }
+      const fullParams = { ...info.defaults ?? {}, ...params ?? {} };
+      const body = buildRequestIpc(info.paramsSchema, fullParams, method);
+      const resp = await fetch(`${baseUrl}${prefix}/${method}/init`, {
+        method: "POST",
+        headers: buildHeaders(),
+        body: prepareBody(body)
+      });
+      const responseBody = await readResponse(resp);
+      let header = null;
+      let stateToken = null;
+      const pendingBatches = [];
+      let finished = false;
+      let streamSchema = null;
+      if (info.headerSchema) {
+        const reader = await readSequentialStreams(responseBody);
+        const headerStream = await reader.readStream();
+        if (headerStream) {
+          for (const batch of headerStream.batches) {
+            if (batch.numRows === 0) {
+              dispatchLogOrError(batch, onLog);
+              continue;
+            }
+            const rows = extractBatchRows(batch);
+            if (rows.length > 0) {
+              header = rows[0];
+            }
+          }
+        }
+        const dataStream = await reader.readStream();
+        if (dataStream) {
+          streamSchema = dataStream.schema;
+        }
+        const headerErrorBatches = [];
+        if (dataStream) {
+          for (const batch of dataStream.batches) {
+            if (batch.numRows === 0) {
+              const token = batch.metadata?.get(STATE_KEY);
+              if (token) {
+                stateToken = token;
+                continue;
+              }
+              const level = batch.metadata?.get(LOG_LEVEL_KEY);
+              if (level === "EXCEPTION") {
+                headerErrorBatches.push(batch);
+                continue;
+              }
+              dispatchLogOrError(batch, onLog);
+              continue;
+            }
+            pendingBatches.push(batch);
+          }
+        }
+        if (headerErrorBatches.length > 0) {
+          if (pendingBatches.length > 0 || stateToken !== null) {
+            pendingBatches.push(...headerErrorBatches);
+          } else {
+            for (const batch of headerErrorBatches) {
+              dispatchLogOrError(batch, onLog);
+            }
+          }
+        }
+        if (!dataStream && !stateToken) {
+          finished = true;
+        }
+      } else {
+        const { schema: responseSchema, batches } = await readResponseBatches(responseBody);
+        streamSchema = responseSchema;
+        const errorBatches = [];
+        for (const batch of batches) {
+          if (batch.numRows === 0) {
+            const token = batch.metadata?.get(STATE_KEY);
+            if (token) {
+              stateToken = token;
+              continue;
+            }
+            const level = batch.metadata?.get(LOG_LEVEL_KEY);
+            if (level === "EXCEPTION") {
+              errorBatches.push(batch);
+              continue;
+            }
+            dispatchLogOrError(batch, onLog);
+            continue;
+          }
+          pendingBatches.push(batch);
+        }
+        if (errorBatches.length > 0) {
+          if (pendingBatches.length > 0 || stateToken !== null) {
+            pendingBatches.push(...errorBatches);
+          } else {
+            for (const batch of errorBatches) {
+              dispatchLogOrError(batch, onLog);
+            }
+          }
+        }
+      }
+      if (pendingBatches.length === 0 && stateToken === null) {
+        finished = true;
+      }
+      const outputSchema = (streamSchema && streamSchema.fields.length > 0 ? streamSchema : null) ?? (pendingBatches.length > 0 ? pendingBatches[0].schema : null) ?? info.outputSchema ?? info.resultSchema;
+      return new HttpStreamSession({
+        baseUrl,
+        prefix,
+        method,
+        stateToken,
+        outputSchema,
+        inputSchema: info.inputSchema,
+        onLog,
+        pendingBatches,
+        finished,
+        header,
+        compressionLevel,
+        compressFn,
+        decompressFn
+      });
+    },
+    async describe() {
+      return httpIntrospect(baseUrl, { prefix });
+    },
+    close() {}
+  };
+}
+// src/client/pipe.ts
+import {
+  RecordBatch as RecordBatch9,
+  RecordBatchStreamWriter as RecordBatchStreamWriter4,
+  Schema as Schema12,
+  Field as Field5,
+  Struct as Struct6,
+  makeData as makeData6,
+  vectorFromArray as vectorFromArray5
+} from "apache-arrow";
+class PipeIncrementalWriter {
+  writer;
+  writeFn;
+  closed = false;
+  constructor(writeFn, schema) {
+    this.writeFn = writeFn;
+    this.writer = new RecordBatchStreamWriter4;
+    this.writer.reset(undefined, schema);
+    this.drain();
+  }
+  write(batch) {
+    if (this.closed)
+      throw new Error("PipeIncrementalWriter already closed");
+    this.writer._writeRecordBatch(batch);
+    this.drain();
+  }
+  close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    const eos = new Uint8Array(new Int32Array([-1, 0]).buffer);
+    this.writeFn(eos);
+  }
+  drain() {
+    const values = this.writer._sink._values;
+    for (const chunk of values) {
+      this.writeFn(chunk);
+    }
+    values.length = 0;
+  }
+}
+
+class PipeStreamSession {
+  _reader;
+  _writeFn;
+  _onLog;
+  _header;
+  _inputWriter = null;
+  _inputSchema = null;
+  _outputStreamOpened = false;
+  _closed = false;
+  _outputSchema;
+  _releaseBusy;
+  _setDrainPromise;
+  constructor(opts) {
+    this._reader = opts.reader;
+    this._writeFn = opts.writeFn;
+    this._onLog = opts.onLog;
+    this._header = opts.header;
+    this._outputSchema = opts.outputSchema;
+    this._releaseBusy = opts.releaseBusy;
+    this._setDrainPromise = opts.setDrainPromise;
+  }
+  get header() {
+    return this._header;
+  }
+  async _readOutputBatch() {
+    while (true) {
+      const batch = await this._reader.readNextBatch();
+      if (batch === null)
+        return null;
+      if (batch.numRows === 0) {
+        if (dispatchLogOrError(batch, this._onLog)) {
+          continue;
+        }
+      }
+      return batch;
+    }
+  }
+  async _ensureOutputStream() {
+    if (this._outputStreamOpened)
+      return;
+    this._outputStreamOpened = true;
+    const schema = await this._reader.openNextStream();
+    if (!schema) {
+      throw new RpcError("ProtocolError", "Expected output stream but got EOF", "");
+    }
+  }
+  async exchange(input) {
+    if (this._closed) {
+      throw new RpcError("ProtocolError", "Stream session is closed", "");
+    }
+    let inputSchema;
+    let batch;
+    if (input.length === 0) {
+      inputSchema = this._inputSchema ?? this._outputSchema;
+      const children = inputSchema.fields.map((f) => {
+        return makeData6({ type: f.type, length: 0, nullCount: 0 });
+      });
+      const structType = new Struct6(inputSchema.fields);
+      const data = makeData6({
+        type: structType,
+        length: 0,
+        children,
+        nullCount: 0
+      });
+      batch = new RecordBatch9(inputSchema, data);
+    } else {
+      const keys = Object.keys(input[0]);
+      const fields = keys.map((key) => {
+        let sample = undefined;
+        for (const row of input) {
+          if (row[key] != null) {
+            sample = row[key];
+            break;
+          }
+        }
+        const arrowType = inferArrowType(sample);
+        return new Field5(key, arrowType, true);
+      });
+      inputSchema = new Schema12(fields);
+      if (this._inputSchema) {
+        const cached = this._inputSchema;
+        if (cached.fields.length !== inputSchema.fields.length || cached.fields.some((f, i) => f.name !== inputSchema.fields[i].name)) {
+          throw new RpcError("ProtocolError", `Exchange input schema changed: expected [${cached.fields.map((f) => f.name).join(", ")}] ` + `but got [${inputSchema.fields.map((f) => f.name).join(", ")}]`, "");
+        }
+      } else {
+        this._inputSchema = inputSchema;
+      }
+      const children = inputSchema.fields.map((f) => {
+        const values = input.map((row) => row[f.name]);
+        return vectorFromArray5(values, f.type).data[0];
+      });
+      const structType = new Struct6(inputSchema.fields);
+      const data = makeData6({
+        type: structType,
+        length: input.length,
+        children,
+        nullCount: 0
+      });
+      batch = new RecordBatch9(inputSchema, data);
+    }
+    if (!this._inputWriter) {
+      this._inputWriter = new PipeIncrementalWriter(this._writeFn, inputSchema);
+    }
+    this._inputWriter.write(batch);
+    await this._ensureOutputStream();
+    try {
+      const outputBatch = await this._readOutputBatch();
+      if (outputBatch === null) {
+        return [];
+      }
+      return extractBatchRows(outputBatch);
+    } catch (e) {
+      await this._cleanup();
+      throw e;
+    }
+  }
+  async _cleanup() {
+    if (this._closed)
+      return;
+    this._closed = true;
+    if (this._inputWriter) {
+      this._inputWriter.close();
+      this._inputWriter = null;
+    }
+    try {
+      if (this._outputStreamOpened) {
+        while (await this._reader.readNextBatch() !== null) {}
+      }
+    } catch {}
+    this._releaseBusy();
+  }
+  async* [Symbol.asyncIterator]() {
+    if (this._closed)
+      return;
+    try {
+      const tickSchema = new Schema12([]);
+      this._inputWriter = new PipeIncrementalWriter(this._writeFn, tickSchema);
+      const structType = new Struct6(tickSchema.fields);
+      const tickData = makeData6({
+        type: structType,
+        length: 0,
+        children: [],
+        nullCount: 0
+      });
+      const tickBatch = new RecordBatch9(tickSchema, tickData);
+      while (true) {
+        this._inputWriter.write(tickBatch);
+        await this._ensureOutputStream();
+        const outputBatch = await this._readOutputBatch();
+        if (outputBatch === null) {
+          break;
+        }
+        yield extractBatchRows(outputBatch);
+      }
+    } finally {
+      if (this._inputWriter) {
+        this._inputWriter.close();
+        this._inputWriter = null;
+      }
+      try {
+        if (this._outputStreamOpened) {
+          while (await this._reader.readNextBatch() !== null) {}
+        }
+      } catch {}
+      this._closed = true;
+      this._releaseBusy();
+    }
+  }
+  close() {
+    if (this._closed)
+      return;
+    this._closed = true;
+    if (this._inputWriter) {
+      this._inputWriter.close();
+      this._inputWriter = null;
+    } else {
+      const emptySchema = new Schema12([]);
+      const ipc = serializeIpcStream(emptySchema, []);
+      this._writeFn(ipc);
+    }
+    const drainPromise = (async () => {
+      try {
+        if (!this._outputStreamOpened) {
+          const schema = await this._reader.openNextStream();
+          if (schema) {
+            while (await this._reader.readNextBatch() !== null) {}
+          }
+        } else {
+          while (await this._reader.readNextBatch() !== null) {}
+        }
+      } catch {} finally {
+        this._releaseBusy();
+      }
+    })();
+    this._setDrainPromise(drainPromise);
+  }
+}
+function pipeConnect(readable, writable, options) {
+  const onLog = options?.onLog;
+  let reader = null;
+  let readerPromise = null;
+  let methodCache = null;
+  let protocolName = "";
+  let _busy = false;
+  let _drainPromise = null;
+  let closed = false;
+  const writeFn = (bytes2) => {
+    writable.write(bytes2);
+    writable.flush?.();
+  };
+  async function ensureReader() {
+    if (reader)
+      return reader;
+    if (!readerPromise) {
+      readerPromise = IpcStreamReader.create(readable);
+    }
+    reader = await readerPromise;
+    return reader;
+  }
+  async function acquireBusy() {
+    if (_drainPromise) {
+      await _drainPromise;
+      _drainPromise = null;
+    }
+    if (_busy) {
+      throw new Error("Pipe transport is busy — another call or stream is in progress. " + "Pipe connections are single-threaded; wait for the current operation to complete.");
+    }
+    _busy = true;
+  }
+  function releaseBusy() {
+    _busy = false;
+  }
+  function setDrainPromise(p) {
+    _drainPromise = p;
+  }
+  async function ensureMethodCache() {
+    if (methodCache)
+      return methodCache;
+    await acquireBusy();
+    try {
+      const emptySchema = new Schema12([]);
+      const body = buildRequestIpc(emptySchema, {}, DESCRIBE_METHOD_NAME);
+      writeFn(body);
+      const r = await ensureReader();
+      const response = await r.readStream();
+      if (!response) {
+        throw new Error("EOF reading __describe__ response");
+      }
+      const desc = await parseDescribeResponse(response.batches, onLog);
+      protocolName = desc.protocolName;
+      methodCache = new Map(desc.methods.map((m) => [m.name, m]));
+      return methodCache;
+    } finally {
+      releaseBusy();
+    }
+  }
+  return {
+    async call(method, params) {
+      const methods = await ensureMethodCache();
+      await acquireBusy();
+      try {
+        const info = methods.get(method);
+        if (!info) {
+          throw new Error(`Unknown method: '${method}'`);
+        }
+        const r = await ensureReader();
+        const fullParams = { ...info.defaults ?? {}, ...params ?? {} };
+        const body = buildRequestIpc(info.paramsSchema, fullParams, method);
+        writeFn(body);
+        const response = await r.readStream();
+        if (!response) {
+          throw new Error("EOF reading response");
+        }
+        let resultBatch = null;
+        for (const batch of response.batches) {
+          if (batch.numRows === 0) {
+            dispatchLogOrError(batch, onLog);
+            continue;
+          }
+          resultBatch = batch;
+        }
+        if (!resultBatch) {
+          return null;
+        }
+        const rows = extractBatchRows(resultBatch);
+        if (rows.length === 0)
+          return null;
+        if (info.resultSchema.fields.length === 0)
+          return null;
+        return rows[0];
+      } finally {
+        releaseBusy();
+      }
+    },
+    async stream(method, params) {
+      const methods = await ensureMethodCache();
+      await acquireBusy();
+      try {
+        const info = methods.get(method);
+        if (!info) {
+          throw new Error(`Unknown method: '${method}'`);
+        }
+        const r = await ensureReader();
+        const fullParams = { ...info.defaults ?? {}, ...params ?? {} };
+        const body = buildRequestIpc(info.paramsSchema, fullParams, method);
+        writeFn(body);
+        let header = null;
+        if (info.headerSchema) {
+          const headerStream = await r.readStream();
+          if (headerStream) {
+            for (const batch of headerStream.batches) {
+              if (batch.numRows === 0) {
+                dispatchLogOrError(batch, onLog);
+                continue;
+              }
+              const rows = extractBatchRows(batch);
+              if (rows.length > 0) {
+                header = rows[0];
+              }
+            }
+          }
+        }
+        const outputSchema = info.outputSchema ?? info.resultSchema;
+        return new PipeStreamSession({
+          reader: r,
+          writeFn,
+          onLog,
+          header,
+          outputSchema,
+          releaseBusy,
+          setDrainPromise
+        });
+      } catch (e) {
+        try {
+          const r = await ensureReader();
+          const emptySchema = new Schema12([]);
+          const ipc = serializeIpcStream(emptySchema, []);
+          writeFn(ipc);
+          const outStream = await r.readStream();
+        } catch {}
+        releaseBusy();
+        throw e;
+      }
+    },
+    async describe() {
+      const methods = await ensureMethodCache();
+      return {
+        protocolName,
+        methods: [...methods.values()]
+      };
+    },
+    close() {
+      if (closed)
+        return;
+      closed = true;
+      writable.end();
+    }
+  };
+}
+function subprocessConnect(cmd, options) {
+  const proc = Bun.spawn(cmd, {
+    stdin: "pipe",
+    stdout: "pipe",
+    stderr: options?.stderr ?? "ignore",
+    cwd: options?.cwd,
+    env: options?.env ? { ...process.env, ...options.env } : undefined
+  });
+  const stdout = proc.stdout;
+  const writable = {
+    write(data) {
+      proc.stdin.write(data);
+    },
+    flush() {
+      proc.stdin.flush();
+    },
+    end() {
+      proc.stdin.end();
+    }
+  };
+  const client = pipeConnect(stdout, writable, {
+    onLog: options?.onLog
+  });
+  const originalClose = client.close;
+  client.close = () => {
+    originalClose.call(client);
+    try {
+      proc.kill();
+    } catch {}
+  };
+  return client;
+}
+export {
+  toSchema,
+  subprocessConnect,
+  str,
+  pipeConnect,
+  parseDescribeResponse,
+  int32,
+  int,
+  inferParamTypes,
+  httpIntrospect,
+  httpConnect,
+  float32,
+  float,
+  createHttpHandler,
+  bytes,
+  bool,
+  VgiRpcServer,
+  VersionError,
+  STATE_KEY,
+  SERVER_ID_KEY,
+  RpcError,
+  RPC_METHOD_KEY,
+  REQUEST_VERSION_KEY,
+  REQUEST_VERSION,
+  REQUEST_ID_KEY,
+  Protocol,
+  PipeStreamSession,
+  PROTOCOL_NAME_KEY,
+  OutputCollector,
+  MethodType,
+  LOG_MESSAGE_KEY,
+  LOG_LEVEL_KEY,
+  LOG_EXTRA_KEY,
+  HttpStreamSession,
+  DESCRIBE_VERSION_KEY,
+  DESCRIBE_VERSION,
+  DESCRIBE_METHOD_NAME,
+  ARROW_CONTENT_TYPE
+};
+
+//# debugId=8512C0DD5A9E2A4F64756E2164756E21