@query-farm/vgi-rpc 0.3.1 → 0.3.2

package/dist/index.js

@@ -50,11 +50,122 @@ var init_zstd = __esm(() => {
   isBun = typeof globalThis.Bun !== "undefined";
 });
 
-// src/server.ts
-import { Schema as Schema4 } from "@query-farm/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/http/common.ts
+import {
+  makeData,
+  RecordBatch,
+  RecordBatchReader,
+  RecordBatchStreamWriter,
+  Struct
+} from "@query-farm/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 Struct(schema.fields);
+  const data = makeData({
+    type: structType,
+    length: batch.numRows,
+    children,
+    nullCount: batch.data.nullCount,
+    nullBitmap: batch.data.nullBitmap
+  });
+  return new RecordBatch(schema, data, batch.metadata);
+}
+function serializeIpcStream(schema, batches) {
+  const writer = new RecordBatchStreamWriter;
+  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 RecordBatchReader.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/client/introspect.ts
+import { Schema as ArrowSchema, RecordBatchReader as RecordBatchReader4 } from "@query-farm/apache-arrow";
+
+// src/client/ipc.ts
+import {
+  Binary,
+  Bool,
+  DataType,
+  Float64,
+  Int64,
+  makeData as makeData2,
+  RecordBatch as RecordBatch2,
+  RecordBatchReader as RecordBatchReader3,
+  Struct as Struct2,
+  Utf8,
+  vectorFromArray
+} from "@query-farm/apache-arrow";
+
+// 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/reader.ts
-import { RecordBatchReader } from "@query-farm/apache-arrow";
+import { RecordBatchReader as RecordBatchReader2 } from "@query-farm/apache-arrow";
 
 class IpcStreamReader {
   reader;
@@ -64,7 +175,7 @@ class IpcStreamReader {
     this.reader = reader;
   }
   static async create(input) {
-    const reader = await RecordBatchReader.from(input);
+    const reader = await RecordBatchReader2.from(input);
     await reader.open({ autoDestroy: false });
     if (reader.closed) {
       throw new Error("Input stream closed before first IPC message");
@@ -124,2386 +235,2265 @@ class IpcStreamReader {
   }
 }
 
-// src/wire/writer.ts
-import {
-  RecordBatchStreamWriter
-} from "@query-farm/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;
-    }
-  }
+// src/client/ipc.ts
+function inferArrowType(value) {
+  if (typeof value === "string")
+    return new Utf8;
+  if (typeof value === "boolean")
+    return new Bool;
+  if (typeof value === "bigint")
+    return new Int64;
+  if (typeof value === "number")
+    return new Float64;
+  if (value instanceof Uint8Array)
+    return new Binary;
+  return new Utf8;
 }
-
-class IpcStreamWriter {
-  fd;
-  constructor(fd = STDOUT_FD) {
-    this.fd = fd;
+function coerceForArrow(type, value) {
+  if (value == null)
+    return value;
+  if (DataType.isInt(type) && type.bitWidth === 64) {
+    if (typeof value === "number")
+      return BigInt(value);
+    return value;
   }
-  writeStream(schema, batches) {
-    const writer = new RecordBatchStreamWriter;
-    writer.reset(undefined, schema);
-    for (const batch of batches) {
-      writer._writeRecordBatch(batch);
+  if (DataType.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;
     }
-    writer.close();
-    const bytes = writer.toUint8Array(true);
-    writeAll(this.fd, bytes);
+    return value;
   }
-  openStream(schema) {
-    return new IncrementalStream(this.fd, schema);
+  if (DataType.isList(type)) {
+    if (Array.isArray(value)) {
+      const elemType = type.children[0].type;
+      return value.map((v) => coerceForArrow(elemType, v));
+    }
+    return value;
   }
+  return value;
 }
-
-class IncrementalStream {
-  writer;
-  fd;
-  closed = false;
-  constructor(fd, schema) {
-    this.fd = fd;
-    this.writer = new RecordBatchStreamWriter;
-    this.writer.reset(undefined, schema);
-    this.drain();
+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 Struct2(schema.fields);
+    const data2 = makeData2({
+      type: structType2,
+      length: 1,
+      children: [],
+      nullCount: 0
+    });
+    const batch2 = new RecordBatch2(schema, data2, metadata);
+    return serializeIpcStream(schema, [batch2]);
   }
-  write(batch) {
-    if (this.closed)
-      throw new Error("Stream already closed");
-    this.writer._writeRecordBatch(batch);
-    this.drain();
+  const children = schema.fields.map((f) => {
+    const val = coerceForArrow(f.type, params[f.name]);
+    return vectorFromArray([val], f.type).data[0];
+  });
+  const structType = new Struct2(schema.fields);
+  const data = makeData2({
+    type: structType,
+    length: 1,
+    children,
+    nullCount: 0
+  });
+  const batch = new RecordBatch2(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", "");
   }
-  close() {
-    if (this.closed)
-      return;
-    this.closed = true;
-    const eos = new Uint8Array(new Int32Array([-1, 0]).buffer);
-    writeAll(this.fd, eos);
+  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);
   }
-  drain() {
-    const values = this.writer._sink._values;
-    for (const chunk of values) {
-      writeAll(this.fd, chunk);
+  if (onLog) {
+    const extraStr = meta.get(LOG_EXTRA_KEY);
+    let extra;
+    if (extraStr) {
+      try {
+        extra = JSON.parse(extraStr);
+      } catch {}
     }
-    values.length = 0;
+    onLog({ level, message, extra });
   }
+  return true;
 }
-
-// src/wire/request.ts
-import { DataType } from "@query-farm/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";
+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;
 }
-
-class VersionError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "VersionError";
-  }
+async function readSequentialStreams(body) {
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(body);
+      controller.close();
+    }
+  });
+  return IpcStreamReader.create(stream);
 }
 
-// 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}'.`);
+// src/client/introspect.ts
+async function deserializeSchema(bytes) {
+  const reader = await RecordBatchReader4.from(bytes);
+  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;
   }
-  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.", "");
+  if (!dataBatch) {
+    throw new Error("Empty __describe__ response");
   }
-  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;
+  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 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);
-      }
+    let defaults;
+    if (paramDefaultsJson) {
+      try {
+        defaults = JSON.parse(paramDefaultsJson);
+      } catch {}
     }
-    params[field.name] = value;
+    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 {
-    methodName,
-    requestVersion: version,
-    requestId,
-    schema,
-    params,
-    rawMetadata: metadata
-  };
+  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/wire/response.ts
-import {
-  RecordBatch,
-  Data,
-  DataType as DataType2,
-  makeData,
-  Struct,
-  vectorFromArray
-} from "@query-farm/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);
-    }
+// src/client/stream.ts
+import { Field, makeData as makeData3, RecordBatch as RecordBatch3, Schema, Struct as Struct3, vectorFromArray as vectorFromArray2 } from "@query-farm/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;
   }
-  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);
+  get header() {
+    return this._header;
   }
-  if (schema.fields.length === 0) {
-    return buildEmptyBatch(schema, metadata);
+  _buildHeaders() {
+    const headers = {
+      "Content-Type": ARROW_CONTENT_TYPE
+    };
+    if (this._compressionLevel != null) {
+      headers["Content-Encoding"] = "zstd";
+      headers["Accept-Encoding"] = "zstd";
+    }
+    return headers;
   }
-  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(", ")}]`);
+  _prepareBody(content) {
+    if (this._compressionLevel != null && this._compressFn) {
+      return this._compressFn(content, this._compressionLevel);
     }
+    return content;
   }
-  const coerced = coerceInt64(schema, values);
-  const children = schema.fields.map((f) => {
-    let val = coerced[f.name];
-    if (val instanceof Data) {
-      return val;
+  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));
     }
-    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));
+    return body;
   }
-  if (serverId != null) {
-    metadata.set(SERVER_ID_KEY, serverId);
+  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 RecordBatch3(zeroSchema, emptyBatch.data, metadata2);
+      return this._doExchange(zeroSchema, [batchWithMeta]);
+    }
+    const keys = Object.keys(input[0]);
+    const fields = keys.map((key) => {
+      let sample;
+      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 Field(key, arrowType, nullable);
+    });
+    const inputSchema = new Schema(fields);
+    const children = inputSchema.fields.map((f) => {
+      const values = input.map((row) => row[f.name]);
+      return vectorFromArray2(values, f.type).data[0];
+    });
+    const structType = new Struct3(inputSchema.fields);
+    const data = makeData3({
+      type: structType,
+      length: input.length,
+      children,
+      nullCount: 0
+    });
+    const metadata = new Map;
+    metadata.set(STATE_KEY, this._stateToken);
+    const batch = new RecordBatch3(inputSchema, data, metadata);
+    return this._doExchange(inputSchema, [batch]);
   }
-  if (requestId != null) {
-    metadata.set(REQUEST_ID_KEY, requestId);
+  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;
   }
-  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,
+  _buildEmptyBatch(schema) {
+    const children = schema.fields.map((f) => {
+      return makeData3({ type: f.type, length: 0, nullCount: 0 });
+    });
+    const structType = new Struct3(schema.fields);
+    const data = makeData3({
+      type: structType,
       length: 0,
-      children: [],
+      children,
       nullCount: 0
     });
-    return new RecordBatch(schema, data2, metadata);
+    return new RecordBatch3(schema, data);
   }
-  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 "@query-farm/apache-arrow";
-
-// src/util/schema.ts
-import { RecordBatchStreamWriter as RecordBatchStreamWriter2 } from "@query-farm/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);
+  async* [Symbol.asyncIterator]() {
+    for (const batch of this._pendingBatches) {
+      if (batch.numRows === 0) {
+        dispatchLogOrError(batch, this._onLog);
+        continue;
+      }
+      yield extractBatchRows(batch);
     }
-    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;
+    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);
       }
-      paramDefaultsJsons.push(Object.keys(safe).length > 0 ? JSON.stringify(safe) : null);
-    } else {
-      paramDefaultsJsons.push(null);
+      if (!gotContinuation)
+        break;
     }
-    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 };
+  async _sendContinuation(token) {
+    const emptySchema = new Schema([]);
+    const metadata = new Map;
+    metadata.set(STATE_KEY, token);
+    const structType = new Struct3(emptySchema.fields);
+    const data = makeData3({
+      type: structType,
+      length: 1,
+      children: [],
+      nullCount: 0
+    });
+    const batch = new RecordBatch3(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/types.ts
-import { RecordBatch as RecordBatch3, recordBatchFromArrays } from "@query-farm/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);
+// 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 {}
   }
-  finish() {
-    if (!this._producerMode) {
-      throw new Error("finish() is not allowed on exchange streams; " + "exchange streams must emit exactly one data batch per call");
+  function buildHeaders() {
+    const headers = {
+      "Content-Type": ARROW_CONTENT_TYPE
+    };
+    if (compressionLevel != null) {
+      headers["Content-Encoding"] = "zstd";
+      headers["Accept-Encoding"] = "zstd";
     }
-    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]);
+    return headers;
   }
-}
-
-// src/dispatch/stream.ts
-import { Schema as Schema3 } from "@query-farm/apache-arrow";
-var EMPTY_SCHEMA = new Schema3([]);
-async function dispatchStream(method, params, writer, reader, serverId, requestId) {
-  const isProducer = !!method.producerFn;
-  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) {}
+  function prepareBody(content) {
+    if (compressionLevel != null && compressFn) {
+      return compressFn(content, compressionLevel);
     }
-    return;
+    return content;
   }
-  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;
+  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;
   }
-  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;
+  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;
   }
-  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;
+  return {
+    async call(method, params) {
+      await ensureCompression();
+      const methods = await ensureMethodCache();
+      const info = methods.get(method);
+      if (!info) {
+        throw new Error(`Unknown method: '${method}'`);
       }
-    }
-  } 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);
+      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;
       }
-    } 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;
+      if (!resultBatch) {
+        return null;
       }
-      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;
+      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}'`);
       }
-      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 "@query-farm/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 "@query-farm/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;
+      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 (!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);
-  }
+      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/http/handler.ts
-import { Schema as Schema9 } from "@query-farm/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
+// src/client/pipe.ts
 import {
-  RecordBatchStreamWriter as RecordBatchStreamWriter3,
-  RecordBatchReader as RecordBatchReader2,
+  Field as Field2,
+  makeData as makeData4,
   RecordBatch as RecordBatch4,
-  Struct as Struct3,
-  makeData as makeData3
+  RecordBatchStreamWriter as RecordBatchStreamWriter2,
+  Schema as Schema2,
+  Struct as Struct4,
+  vectorFromArray as vectorFromArray3
 } from "@query-farm/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, RecordBatchReader as RecordBatchReader3 } from "@query-farm/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");
-    }
+class PipeIncrementalWriter {
+  writer;
+  writeFn;
+  closed = false;
+  constructor(writeFn, schema) {
+    this.writeFn = writeFn;
+    this.writer = new RecordBatchStreamWriter2;
+    this.writer.reset(undefined, schema);
+    this.drain();
   }
-  const stateLen = payload.readUInt32LE(offset);
-  offset += 4;
-  if (offset + stateLen > payload.length) {
-    throw new Error("State token truncated (state)");
+  write(batch) {
+    if (this.closed)
+      throw new Error("PipeIncrementalWriter already closed");
+    this.writer._writeRecordBatch(batch);
+    this.drain();
   }
-  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)");
+  close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    const eos = new Uint8Array(new Int32Array([-1, 0]).buffer);
+    this.writeFn(eos);
   }
-  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)");
+  drain() {
+    const values = this.writer._sink._values;
+    for (const chunk of values) {
+      this.writeFn(chunk);
+    }
+    values.length = 0;
   }
-  const inputSchemaBytes = payload.slice(offset, offset + inputSchemaLen);
-  return { stateBytes, schemaBytes, inputSchemaBytes, createdAt };
 }
 
-// src/http/dispatch.ts
-async function deserializeSchema(bytes2) {
-  const reader = await RecordBatchReader3.from(bytes2);
-  await reader.open();
-  return reader.schema;
-}
-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);
+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;
   }
-  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);
+  get header() {
+    return this._header;
   }
-}
-async function httpDispatchStreamInit(method, body, ctx) {
-  const isProducer = !!method.producerFn;
-  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);
+  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;
+    }
   }
-  let state;
-  try {
-    if (isProducer) {
-      state = await method.producerInit(parsed.params);
+  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 makeData4({ type: f.type, length: 0, nullCount: 0 });
+      });
+      const structType = new Struct4(inputSchema.fields);
+      const data = makeData4({
+        type: structType,
+        length: 0,
+        children,
+        nullCount: 0
+      });
+      batch = new RecordBatch4(inputSchema, data);
     } else {
-      state = await method.exchangeInit(parsed.params);
+      const keys = Object.keys(input[0]);
+      const fields = keys.map((key) => {
+        let sample;
+        for (const row of input) {
+          if (row[key] != null) {
+            sample = row[key];
+            break;
+          }
+        }
+        const arrowType = inferArrowType(sample);
+        return new Field2(key, arrowType, true);
+      });
+      inputSchema = new Schema2(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 vectorFromArray3(values, f.type).data[0];
+      });
+      const structType = new Struct4(inputSchema.fields);
+      const data = makeData4({
+        type: structType,
+        length: input.length,
+        children,
+        nullCount: 0
+      });
+      batch = new RecordBatch4(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;
     }
-  } 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) {
+  async _cleanup() {
+    if (this._closed)
+      return;
+    this._closed = true;
+    if (this._inputWriter) {
+      this._inputWriter.close();
+      this._inputWriter = null;
+    }
     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 (this._outputStreamOpened) {
+        while (await this._reader.readNextBatch() !== null) {}
+      }
+    } catch {}
+    this._releaseBusy();
+  }
+  async* [Symbol.asyncIterator]() {
+    if (this._closed)
+      return;
+    try {
+      const tickSchema = new Schema2([]);
+      this._inputWriter = new PipeIncrementalWriter(this._writeFn, tickSchema);
+      const structType = new Struct4(tickSchema.fields);
+      const tickData = makeData4({
+        type: structType,
+        length: 0,
+        children: [],
+        nullCount: 0
+      });
+      const tickBatch = new RecordBatch4(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();
     }
   }
-  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);
+  close() {
+    if (this._closed)
+      return;
+    this._closed = true;
+    if (this._inputWriter) {
+      this._inputWriter.close();
+      this._inputWriter = null;
     } else {
-      responseBody = tokenStreamBytes;
+      const emptySchema = new Schema2([]);
+      const ipc = serializeIpcStream(emptySchema, []);
+      this._writeFn(ipc);
     }
-    return arrowResponse(responseBody);
+    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);
   }
 }
-async function httpDispatchStreamExchange(method, body, ctx) {
-  const isProducer = !!method.producerFn;
-  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);
+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 = (bytes) => {
+    writable.write(bytes);
+    writable.flush?.();
+  };
+  async function ensureReader() {
+    if (reader)
+      return reader;
+    if (!readerPromise) {
+      readerPromise = IpcStreamReader.create(readable);
+    }
+    reader = await readerPromise;
+    return reader;
   }
-  let state;
-  try {
-    state = ctx.stateSerializer.deserialize(unpacked.stateBytes);
-  } catch (error) {
-    console.error(`[httpDispatchStreamExchange] state deserialize error:`, error.message);
-    throw new HttpRpcError(`State deserialization failed: ${error.message}`, 500);
+  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;
   }
-  let outputSchema;
-  if (unpacked.schemaBytes.length > 0) {
-    outputSchema = await deserializeSchema(unpacked.schemaBytes);
-  } else {
-    outputSchema = state?.__outputSchema ?? method.outputSchema;
+  function releaseBusy() {
+    _busy = false;
   }
-  let inputSchema;
-  if (unpacked.inputSchemaBytes.length > 0) {
-    inputSchema = await deserializeSchema(unpacked.inputSchemaBytes);
-  } else {
-    inputSchema = method.inputSchema ?? EMPTY_SCHEMA4;
+  function setDrainPromise(p) {
+    _drainPromise = p;
   }
-  const effectiveProducer = state?.__isProducer ?? isProducer;
-  if (process.env.VGI_DISPATCH_DEBUG)
-    console.error(`[httpDispatchStreamExchange] method=${method.name} effectiveProducer=${effectiveProducer} stateKeys=${Object.keys(state || {})}`);
-  if (effectiveProducer) {
-    return produceStreamResponse(method, state, outputSchema, inputSchema, ctx, null, null);
-  } else {
-    const out = new OutputCollector(outputSchema, effectiveProducer, ctx.serverId, null);
+  async function ensureMethodCache() {
+    if (methodCache)
+      return methodCache;
+    await acquireBusy();
     try {
-      if (method.exchangeFn) {
-        await method.exchangeFn(state, reqBatch, out);
-      } else {
-        await method.producerFn(state, out);
+      const emptySchema = new Schema2([]);
+      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");
       }
-    } catch (error) {
-      if (process.env.VGI_DISPATCH_DEBUG)
-        console.error(`[httpDispatchStreamExchange] exchange handler error:`, error.message, error.stack?.split(`
-`).slice(0, 5).join(`
-`));
-      const errBatch = buildErrorBatch(outputSchema, error, ctx.serverId, null);
-      return arrowResponse(serializeIpcStream(outputSchema, [errBatch]), 500);
+      const desc = await parseDescribeResponse(response.batches, onLog);
+      protocolName = desc.protocolName;
+      methodCache = new Map(desc.methods.map((m) => [m.name, m]));
+      return methodCache;
+    } finally {
+      releaseBusy();
     }
-    const batches = [];
-    if (out.finished) {
-      for (const emitted of out.batches) {
-        batches.push(emitted.batch);
-      }
-    } else {
-      const stateBytes = ctx.stateSerializer.serialize(state);
-      const schemaBytes = serializeSchema(outputSchema);
-      const inputSchemaBytes = serializeSchema(inputSchema);
-      const token = packStateToken(stateBytes, schemaBytes, inputSchemaBytes, ctx.signingKey);
-      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 {
+    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();
       }
-      if (!batches.some((b) => b.metadata?.get(STATE_KEY))) {
-        const tokenMeta = new Map;
-        tokenMeta.set(STATE_KEY, token);
-        batches.push(buildEmptyBatch(outputSchema, tokenMeta));
+    },
+    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 Schema2([]);
+          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();
     }
-    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 {
-      if (method.producerFn) {
-        await method.producerFn(state, out);
-      } else {
-        const tickBatch = buildEmptyBatch(inputSchema);
-        await method.exchangeFn(state, tickBatch, out);
-      }
-    } catch (error) {
-      if (process.env.VGI_DISPATCH_DEBUG)
-        console.error(`[produceStreamResponse] error:`, error.message, error.stack?.split(`
-`).slice(0, 3).join(`
-`));
-      allBatches.push(buildErrorBatch(outputSchema, error, ctx.serverId, requestId));
-      break;
+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();
     }
-    for (const emitted of out.batches) {
-      allBatches.push(emitted.batch);
-      if (maxBytes != null) {
-        estimatedBytes += emitted.batch.data.byteLength;
-      }
+  };
+  const client = pipeConnect(stdout, writable, {
+    onLog: options?.onLog
+  });
+  const originalClose = client.close;
+  client.close = () => {
+    originalClose.call(client);
+    try {
+      proc.kill();
+    } catch {}
+  };
+  return client;
+}
+// src/http/handler.ts
+import { randomBytes } from "node:crypto";
+import { Schema as Schema5 } from "@query-farm/apache-arrow";
+
+// src/types.ts
+import { RecordBatch as RecordBatch6, recordBatchFromArrays } from "@query-farm/apache-arrow";
+
+// src/wire/response.ts
+import {
+  Data,
+  DataType as DataType2,
+  makeData as makeData5,
+  RecordBatch as RecordBatch5,
+  Struct as Struct5,
+  vectorFromArray as vectorFromArray4
+} from "@query-farm/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);
     }
-    if (out.finished) {
-      break;
+  }
+  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(", ")}]`);
     }
-    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 coerced = coerceInt64(schema, values);
+  const children = schema.fields.map((f) => {
+    const val = coerced[f.name];
+    if (val instanceof Data) {
+      return val;
     }
+    const arr = vectorFromArray4([val], f.type);
+    return arr.data[0];
+  });
+  const structType = new Struct5(schema.fields);
+  const data = makeData5({
+    type: structType,
+    length: 1,
+    children,
+    nullCount: 0
+  });
+  return new RecordBatch5(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);
   }
-  const dataBytes = serializeIpcStream(outputSchema, allBatches);
-  let responseBody;
-  if (headerBytes) {
-    responseBody = concatBytes(headerBytes, dataBytes);
-  } else {
-    responseBody = dataBytes;
+  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));
   }
-  return arrowResponse(responseBody);
+  if (serverId != null) {
+    metadata.set(SERVER_ID_KEY, serverId);
+  }
+  if (requestId != null) {
+    metadata.set(REQUEST_ID_KEY, requestId);
+  }
+  return buildEmptyBatch(schema, metadata);
 }
-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;
+function buildEmptyBatch(schema, metadata) {
+  const children = schema.fields.map((f) => {
+    return makeData5({ type: f.type, length: 0, nullCount: 0 });
+  });
+  if (schema.fields.length === 0) {
+    const structType2 = new Struct5(schema.fields);
+    const data2 = makeData5({
+      type: structType2,
+      length: 0,
+      children: [],
+      nullCount: 0
+    });
+    return new RecordBatch5(schema, data2, metadata);
   }
-  return result;
+  const structType = new Struct5(schema.fields);
+  const data = makeData5({
+    type: structType,
+    length: 0,
+    children,
+    nullCount: 0
+  });
+  return new RecordBatch5(schema, data, metadata);
 }
 
-// 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");
-    }
+// src/types.ts
+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;
   }
-  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
-    });
+  get outputSchema() {
+    return this._outputSchema;
   }
-  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;
+  get finished() {
+    return this._finished;
   }
-  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";
+  get batches() {
+    return this._batches;
+  }
+  emit(batchOrColumns, metadata) {
+    let batch;
+    if (batchOrColumns instanceof RecordBatch6) {
+      batch = batchOrColumns;
     } else {
-      methodName = subPath;
-      action = "call";
+      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");
     }
-    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);
+    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];
     }
-    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);
+    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/client/ipc.ts
+
+// src/http/handler.ts
+init_zstd();
+
+// src/http/dispatch.ts
+import { RecordBatch as RecordBatch8, RecordBatchReader as RecordBatchReader5, Schema as Schema4 } from "@query-farm/apache-arrow";
+
+// src/dispatch/describe.ts
 import {
-  RecordBatch as RecordBatch6,
-  RecordBatchReader as RecordBatchReader4,
-  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
+  Binary as Binary2,
+  Bool as Bool2,
+  Field as Field3,
+  makeData as makeData6,
+  RecordBatch as RecordBatch7,
+  Schema as Schema3,
+  Struct as Struct6,
+  Utf8 as Utf82,
+  vectorFromArray as vectorFromArray5
 } from "@query-farm/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;
+
+// src/util/schema.ts
+import { RecordBatchStreamWriter as RecordBatchStreamWriter3 } from "@query-farm/apache-arrow";
+function serializeSchema(schema) {
+  const writer = new RecordBatchStreamWriter3;
+  writer.reset(undefined, schema);
+  writer.close();
+  return writer.toUint8Array(true);
 }
-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));
+
+// src/dispatch/describe.ts
+var DESCRIBE_SCHEMA = new Schema3([
+  new Field3("name", new Utf82, false),
+  new Field3("method_type", new Utf82, false),
+  new Field3("doc", new Utf82, true),
+  new Field3("has_return", new Bool2, false),
+  new Field3("params_schema_ipc", new Binary2, false),
+  new Field3("result_schema_ipc", new Binary2, false),
+  new Field3("param_types_json", new Utf82, true),
+  new Field3("param_defaults_json", new Utf82, true),
+  new Field3("has_header", new Bool2, false),
+  new Field3("header_schema_ipc", new Binary2, 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;
+        }
       }
-      return coerced;
+      paramDefaultsJsons.push(Object.keys(safe).length > 0 ? JSON.stringify(safe) : null);
+    } else {
+      paramDefaultsJsons.push(null);
     }
-    return value;
+    hasHeaders.push(!!method.headerSchema);
+    headerSchemas.push(method.headerSchema ? serializeSchema(method.headerSchema) : null);
   }
-  if (DataType4.isList(type)) {
-    if (Array.isArray(value)) {
-      const elemType = type.children[0].type;
-      return value.map((v) => coerceForArrow(elemType, v));
+  const nameArr = vectorFromArray5(names, new Utf82);
+  const methodTypeArr = vectorFromArray5(methodTypes, new Utf82);
+  const docArr = vectorFromArray5(docs, new Utf82);
+  const hasReturnArr = vectorFromArray5(hasReturns, new Bool2);
+  const paramsSchemaArr = vectorFromArray5(paramsSchemas, new Binary2);
+  const resultSchemaArr = vectorFromArray5(resultSchemas, new Binary2);
+  const paramTypesArr = vectorFromArray5(paramTypesJsons, new Utf82);
+  const paramDefaultsArr = vectorFromArray5(paramDefaultsJsons, new Utf82);
+  const hasHeaderArr = vectorFromArray5(hasHeaders, new Bool2);
+  const headerSchemaArr = vectorFromArray5(headerSchemas, new Binary2);
+  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 Struct6(DESCRIBE_SCHEMA.fields);
+  const data = makeData6({
+    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 RecordBatch7(DESCRIBE_SCHEMA, data, metadata);
+  return { batch, metadata };
+}
+
+// src/wire/request.ts
+import { DataType as DataType3 } from "@query-farm/apache-arrow";
+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 (DataType3.isMap(field.type)) {
+      params[field.name] = batch.getChildAt(i).data[0];
+      continue;
     }
-    return value;
+    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 value;
+  return {
+    methodName,
+    requestVersion: version,
+    requestId,
+    schema,
+    params,
+    rawMetadata: metadata
+  };
 }
-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]);
+
+// 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");
   }
-  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 RecordBatchReader4.from(body);
-  await reader.open();
-  const schema = reader.schema;
-  if (!schema) {
-    throw new RpcError("ProtocolError", "Empty IPC stream: no schema", "");
+  let offset = 0;
+  const version = payload.readUInt8(offset);
+  offset += 1;
+  if (version !== TOKEN_VERSION) {
+    throw new Error(`Unsupported state token version: ${version}`);
   }
-  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 {}
+  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");
     }
-    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 });
+  const stateLen = payload.readUInt32LE(offset);
+  offset += 4;
+  if (offset + stateLen > payload.length) {
+    throw new Error("State token truncated (state)");
   }
-  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);
+  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)");
   }
-  return rows;
-}
-async function readSequentialStreams(body) {
-  const stream = new ReadableStream({
-    start(controller) {
-      controller.enqueue(body);
-      controller.close();
-    }
-  });
-  return IpcStreamReader.create(stream);
+  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/client/introspect.ts
-import { RecordBatchReader as RecordBatchReader5 } from "@query-farm/apache-arrow";
-import { Schema as ArrowSchema } from "@query-farm/apache-arrow";
-async function deserializeSchema2(bytes2) {
-  const reader = await RecordBatchReader5.from(bytes2);
+// src/http/dispatch.ts
+async function deserializeSchema2(bytes) {
+  const reader = await RecordBatchReader5.from(bytes);
   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");
+var EMPTY_SCHEMA = new Schema4([]);
+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 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 deserializeSchema2(paramsIpc);
-    const resultSchema = await deserializeSchema2(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 deserializeSchema2(headerIpc);
-    }
-    methods.push(info);
+  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);
   }
-  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 "@query-farm/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;
+async function httpDispatchStreamInit(method, body, ctx) {
+  const isProducer = !!method.producerFn;
+  const outputSchema = method.outputSchema;
+  const inputSchema = method.inputSchema ?? EMPTY_SCHEMA;
+  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);
   }
-  _buildHeaders() {
-    const headers = {
-      "Content-Type": ARROW_CONTENT_TYPE
-    };
-    if (this._compressionLevel != null) {
-      headers["Content-Encoding"] = "zstd";
-      headers["Accept-Encoding"] = "zstd";
+  let state;
+  try {
+    if (isProducer) {
+      state = await method.producerInit(parsed.params);
+    } else {
+      state = await method.exchangeInit(parsed.params);
     }
-    return headers;
+  } catch (error) {
+    const errSchema = method.headerSchema ?? EMPTY_SCHEMA;
+    const errBatch = buildErrorBatch(errSchema, error, ctx.serverId, parsed.requestId);
+    return arrowResponse(serializeIpcStream(errSchema, [errBatch]), 500);
   }
-  _prepareBody(content) {
-    if (this._compressionLevel != null && this._compressFn) {
-      return this._compressFn(content, this._compressionLevel);
+  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);
     }
-    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));
+  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 body;
+    return arrowResponse(responseBody);
   }
-  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]);
+}
+async function httpDispatchStreamExchange(method, body, ctx) {
+  const isProducer = !!method.producerFn;
+  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);
+  }
+  let state;
+  try {
+    state = ctx.stateSerializer.deserialize(unpacked.stateBytes);
+  } catch (error) {
+    console.error(`[httpDispatchStreamExchange] state deserialize error:`, error.message);
+    throw new HttpRpcError(`State deserialization failed: ${error.message}`, 500);
+  }
+  let outputSchema;
+  if (unpacked.schemaBytes.length > 0) {
+    outputSchema = await deserializeSchema2(unpacked.schemaBytes);
+  } else {
+    outputSchema = state?.__outputSchema ?? method.outputSchema;
+  }
+  let inputSchema;
+  if (unpacked.inputSchemaBytes.length > 0) {
+    inputSchema = await deserializeSchema2(unpacked.inputSchemaBytes);
+  } else {
+    inputSchema = method.inputSchema ?? EMPTY_SCHEMA;
+  }
+  const effectiveProducer = state?.__isProducer ?? isProducer;
+  if (process.env.VGI_DISPATCH_DEBUG)
+    console.error(`[httpDispatchStreamExchange] method=${method.name} effectiveProducer=${effectiveProducer} stateKeys=${Object.keys(state || {})}`);
+  if (effectiveProducer) {
+    return produceStreamResponse(method, state, outputSchema, inputSchema, ctx, null, null);
+  } else {
+    const out = new OutputCollector(outputSchema, effectiveProducer, ctx.serverId, null);
+    try {
+      if (method.exchangeFn) {
+        await method.exchangeFn(state, reqBatch, out);
+      } else {
+        await method.producerFn(state, out);
+      }
+    } catch (error) {
+      if (process.env.VGI_DISPATCH_DEBUG)
+        console.error(`[httpDispatchStreamExchange] exchange handler error:`, error.message, error.stack?.split(`
+`).slice(0, 5).join(`
+`));
+      const errBatch = buildErrorBatch(outputSchema, error, ctx.serverId, null);
+      return arrowResponse(serializeIpcStream(outputSchema, [errBatch]), 500);
     }
-    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 batches = [];
+    if (out.finished) {
+      for (const emitted of out.batches) {
+        batches.push(emitted.batch);
       }
-      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;
+    } else {
+      const stateBytes = ctx.stateSerializer.serialize(state);
+      const schemaBytes = serializeSchema(outputSchema);
+      const inputSchemaBytes = serializeSchema(inputSchema);
+      const token = packStateToken(stateBytes, schemaBytes, inputSchemaBytes, ctx.signingKey);
+      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 RecordBatch8(batch.schema, batch.data, mergedMeta));
+        } else {
+          batches.push(batch);
         }
-        continue;
       }
-      const token = batch.metadata?.get(STATE_KEY);
-      if (token) {
-        this._stateToken = token;
+      if (!batches.some((b) => b.metadata?.get(STATE_KEY))) {
+        const tokenMeta = new Map;
+        tokenMeta.set(STATE_KEY, token);
+        batches.push(buildEmptyBatch(outputSchema, tokenMeta));
       }
-      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);
+    return arrowResponse(serializeIpcStream(outputSchema, batches));
   }
-  async* [Symbol.asyncIterator]() {
-    for (const batch of this._pendingBatches) {
-      if (batch.numRows === 0) {
-        dispatchLogOrError(batch, this._onLog);
-        continue;
+}
+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 {
+      if (method.producerFn) {
+        await method.producerFn(state, out);
+      } else {
+        const tickBatch = buildEmptyBatch(inputSchema);
+        await method.exchangeFn(state, tickBatch, out);
       }
-      yield extractBatchRows(batch);
+    } catch (error) {
+      if (process.env.VGI_DISPATCH_DEBUG)
+        console.error(`[produceStreamResponse] error:`, error.message, error.stack?.split(`
+`).slice(0, 3).join(`
+`));
+      allBatches.push(buildErrorBatch(outputSchema, error, ctx.serverId, requestId));
+      break;
     }
-    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);
+    for (const emitted of out.batches) {
+      allBatches.push(emitted.batch);
+      if (maxBytes != null) {
+        estimatedBytes += emitted.batch.data.byteLength;
       }
-      if (!gotContinuation)
-        break;
+    }
+    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;
     }
   }
-  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);
+  const dataBytes = serializeIpcStream(outputSchema, allBatches);
+  let responseBody;
+  if (headerBytes) {
+    responseBody = concatBytes(headerBytes, dataBytes);
+  } else {
+    responseBody = dataBytes;
   }
-  close() {}
+  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/client/connect.ts
-function httpConnect(baseUrl, options) {
+// src/http/types.ts
+var jsonStateSerializer = {
+  serialize(state) {
+    return new TextEncoder().encode(JSON.stringify(state, (_key, value) => typeof value === "bigint" ? `__bigint__:${value}` : value));
+  },
+  deserialize(bytes) {
+    return JSON.parse(new TextDecoder().decode(bytes), (_key, value) => typeof value === "string" && value.startsWith("__bigint__:") ? BigInt(value.slice(11)) : value);
+  }
+};
+
+// src/http/handler.ts
+var EMPTY_SCHEMA2 = new Schema5([]);
+function createHttpHandler(protocol, options) {
   const prefix = (options?.prefix ?? "/vgi").replace(/\/+$/, "");
-  const onLog = options?.onLog;
+  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;
-  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);
+  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");
     }
-    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 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
+    });
   }
-  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;
+  function makeErrorResponse(error, statusCode, schema = EMPTY_SCHEMA2) {
+    const errBatch = buildErrorBatch(schema, error, serverId, null);
+    const body = serializeIpcStream(schema, [errBatch]);
+    const resp = arrowResponse(body, statusCode);
+    addCorsHeaders(resp.headers);
+    return resp;
   }
-  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;
+  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));
         }
-        resultBatch = batch;
+        return new Response(null, { status: 204, headers });
       }
-      if (!resultBatch) {
-        return null;
+      if (corsOrigins) {
+        const headers = new Headers;
+        addCorsHeaders(headers);
+        return new Response(null, { status: 204, headers });
       }
-      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}'`);
+      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, 10) > maxRequestBytes) {
+        return new Response("Request body too large", { status: 413 });
       }
-      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);
-            }
-          }
+    }
+    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);
         }
-        if (!dataStream && !stateToken) {
-          finished = true;
+        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 {
-        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 (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);
       }
-      if (pendingBatches.length === 0 && stateToken === null) {
-        finished = true;
+      addCorsHeaders(response.headers);
+      return compressIfAccepted(response, clientAcceptsZstd);
+    } catch (error) {
+      if (error instanceof HttpRpcError) {
+        return compressIfAccepted(makeErrorResponse(error, error.statusCode), clientAcceptsZstd);
       }
-      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() {}
+      return compressIfAccepted(makeErrorResponse(error, 500), clientAcceptsZstd);
+    }
   };
 }
-// src/client/pipe.ts
+// src/protocol.ts
+import { Schema as Schema7 } from "@query-farm/apache-arrow";
+
+// src/schema.ts
 import {
-  RecordBatch as RecordBatch9,
-  RecordBatchStreamWriter as RecordBatchStreamWriter4,
-  Schema as Schema12,
-  Field as Field5,
-  Struct as Struct6,
-  makeData as makeData6,
-  vectorFromArray as vectorFromArray5
+  Binary as Binary3,
+  Bool as Bool3,
+  DataType as DataType4,
+  Field as Field4,
+  Float32,
+  Float64 as Float642,
+  Int16,
+  Int32,
+  Int64 as Int642,
+  Schema as Schema6,
+  Utf8 as Utf83
 } from "@query-farm/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);
+var str = new Utf83;
+var bytes = new Binary3;
+var int = new Int642;
+var int32 = new Int32;
+var float = new Float642;
+var float32 = new Float32;
+var bool = new Bool3;
+function toSchema(spec) {
+  if (spec instanceof Schema6)
+    return spec;
+  const fields = [];
+  for (const [name, value] of Object.entries(spec)) {
+    if (value instanceof Field4) {
+      fields.push(value);
+    } else if (value instanceof DataType4) {
+      fields.push(new Field4(name, value, false));
+    } else {
+      throw new TypeError(`Invalid schema value for "${name}": expected DataType or Field, got ${typeof value}`);
+    }
   }
-  drain() {
-    const values = this.writer._sink._values;
-    for (const chunk of values) {
-      this.writeFn(chunk);
+  return new Schema6(fields);
+}
+var TYPE_MAP = [
+  [Utf83, "str"],
+  [Binary3, "bytes"],
+  [Bool3, "bool"],
+  [Float642, "float"],
+  [Float32, "float"],
+  [Int642, "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;
+      }
     }
-    values.length = 0;
+    if (!mapped)
+      return;
+    result[field.name] = mapped;
   }
+  return result;
 }
 
-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;
+// src/protocol.ts
+var EMPTY_SCHEMA3 = new Schema7([]);
+
+class Protocol {
+  name;
+  _methods = new Map;
+  constructor(name) {
+    this.name = name;
   }
-  get header() {
-    return this._header;
+  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;
   }
-  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;
+  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/server.ts
+import { Schema as Schema9 } from "@query-farm/apache-arrow";
+
+// src/dispatch/stream.ts
+import { Schema as Schema8 } from "@query-farm/apache-arrow";
+var EMPTY_SCHEMA4 = new Schema8([]);
+async function dispatchStream(method, params, writer, reader, serverId, requestId) {
+  const isProducer = !!method.producerFn;
+  let state;
+  try {
+    if (isProducer) {
+      state = await method.producerInit(params);
+    } else {
+      state = await method.exchangeInit(params);
+    }
+  } catch (error) {
+    const errSchema = method.headerSchema ?? EMPTY_SCHEMA4;
+    const errBatch = buildErrorBatch(errSchema, error, serverId, requestId);
+    writer.writeStream(errSchema, [errBatch]);
+    const inputSchema2 = await reader.openNextStream();
+    if (inputSchema2) {
+      while (await reader.readNextBatch() !== null) {}
     }
+    return;
   }
-  async _ensureOutputStream() {
-    if (this._outputStreamOpened)
+  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;
-    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(", ")}]`, "");
-        }
+  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 {
-        this._inputSchema = inputSchema;
+        await method.exchangeFn(state, inputBatch, out);
+      }
+      for (const emitted of out.batches) {
+        stream.write(emitted.batch);
+      }
+      if (out.finished) {
+        break;
       }
-      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();
+  } catch (error) {
+    stream.write(buildErrorBatch(outputSchema, error, serverId, requestId));
+  }
+  stream.close();
+  try {
+    while (await reader.readNextBatch() !== null) {}
+  } catch {}
+}
+
+// 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/wire/writer.ts
+import { writeSync } from "node:fs";
+import { RecordBatchStreamWriter as RecordBatchStreamWriter4 } from "@query-farm/apache-arrow";
+var STDOUT_FD = 1;
+function writeAll(fd, data) {
+  let offset = 0;
+  while (offset < data.length) {
     try {
-      const outputBatch = await this._readOutputBatch();
-      if (outputBatch === null) {
-        return [];
-      }
-      return extractBatchRows(outputBatch);
+      const written = writeSync(fd, data, offset, data.length - offset);
+      if (written <= 0)
+        throw new Error(`writeSync returned ${written}`);
+      offset += written;
     } catch (e) {
-      await this._cleanup();
+      if (e.code === "EAGAIN") {
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 1);
+        continue;
+      }
       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();
+}
+
+class IpcStreamWriter {
+  fd;
+  constructor(fd = STDOUT_FD) {
+    this.fd = fd;
   }
-  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();
+  writeStream(schema, batches) {
+    const writer = new RecordBatchStreamWriter4;
+    writer.reset(undefined, schema);
+    for (const batch of batches) {
+      writer._writeRecordBatch(batch);
     }
+    writer.close();
+    const bytes2 = writer.toUint8Array(true);
+    writeAll(this.fd, bytes2);
+  }
+  openStream(schema) {
+    return new IncrementalStream(this.fd, schema);
+  }
+}
+
+class IncrementalStream {
+  writer;
+  fd;
+  closed = false;
+  constructor(fd, schema) {
+    this.fd = fd;
+    this.writer = new RecordBatchStreamWriter4;
+    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)
+    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);
+    this.closed = true;
+    const eos = new Uint8Array(new Int32Array([-1, 0]).buffer);
+    writeAll(this.fd, eos);
   }
-}
-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);
+  drain() {
+    const values = this.writer._sink._values;
+    for (const chunk of values) {
+      writeAll(this.fd, chunk);
     }
-    reader = await readerPromise;
-    return reader;
+    values.length = 0;
   }
-  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.");
+}
+
+// src/server.ts
+var EMPTY_SCHEMA5 = new Schema9([]);
+
+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;
     }
-    _busy = true;
-  }
-  function releaseBusy() {
-    _busy = false;
   }
-  function setDrainPromise(p) {
-    _drainPromise = p;
-  }
-  async function ensureMethodCache() {
-    if (methodCache)
-      return methodCache;
-    await acquireBusy();
+  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 {
-      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");
+      while (true) {
+        await this.serveOne(reader, writer);
       }
-      const desc = await parseDescribeResponse(response.batches, onLog);
-      protocolName = desc.protocolName;
-      methodCache = new Map(desc.methods.map((m) => [m.name, m]));
-      return methodCache;
+    } 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 {
-      releaseBusy();
+      await reader.cancel();
     }
   }
-  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();
+  async serveOne(reader, writer) {
+    const stream = await reader.readStream();
+    if (!stream) {
+      throw new Error("EOF");
     }
-  };
-}
-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 { schema, batches } = stream;
+    if (batches.length === 0) {
+      const err = new RpcError("ProtocolError", "Request stream contains no batches", "");
+      const errBatch = buildErrorBatch(EMPTY_SCHEMA5, err, this.serverId, null);
+      writer.writeStream(EMPTY_SCHEMA5, [errBatch]);
+      return;
     }
-  };
-  const client = pipeConnect(stdout, writable, {
-    onLog: options?.onLog
-  });
-  const originalClose = client.close;
-  client.close = () => {
-    originalClose.call(client);
+    const batch = batches[0];
+    let methodName;
+    let params;
+    let requestId;
     try {
-      proc.kill();
-    } catch {}
-  };
-  return client;
+      const parsed = parseRequest(schema, batch);
+      methodName = parsed.methodName;
+      params = parsed.params;
+      requestId = parsed.requestId;
+    } catch (e) {
+      const errBatch = buildErrorBatch(EMPTY_SCHEMA5, e, this.serverId, null);
+      writer.writeStream(EMPTY_SCHEMA5, [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_SCHEMA5, err, this.serverId, requestId);
+      writer.writeStream(EMPTY_SCHEMA5, [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);
+    }
+  }
 }
 export {
   unpackStateToken,
@@ -2547,4 +2537,4 @@ export {
   ARROW_CONTENT_TYPE
 };
 
-//# debugId=90D671AA0075054164756E2164756E21
+//# debugId=E5E571F45BA75F8D64756E2164756E21