@query-farm/vgi-rpc 0.2.4 → 0.3.2

package/src/http/handler.ts

@@ -1,26 +1,21 @@
 // © Copyright 2025-2026, Query.Farm LLC - https://query.farm
 // SPDX-License-Identifier: Apache-2.0
 
-import { Schema } from "apache-arrow";
 import { randomBytes } from "node:crypto";
+import { Schema } from "@query-farm/apache-arrow";
+import { DESCRIBE_METHOD_NAME } from "../constants.js";
 import type { Protocol } from "../protocol.js";
 import { MethodType } from "../types.js";
-import { DESCRIBE_METHOD_NAME } from "../constants.js";
+import { zstdCompress, zstdDecompress } from "../util/zstd.js";
 import { buildErrorBatch } from "../wire/response.js";
-import { jsonStateSerializer, type HttpHandlerOptions } from "./types.js";
-import {
-  ARROW_CONTENT_TYPE,
-  HttpRpcError,
-  serializeIpcStream,
-  arrowResponse,
-} from "./common.js";
+import { ARROW_CONTENT_TYPE, arrowResponse, HttpRpcError, serializeIpcStream } from "./common.js";
 import {
   httpDispatchDescribe,
-  httpDispatchUnary,
-  httpDispatchStreamInit,
   httpDispatchStreamExchange,
+  httpDispatchStreamInit,
+  httpDispatchUnary,
 } from "./dispatch.js";
-import { zstdCompress, zstdDecompress } from "../util/zstd.js";
+import { type HttpHandlerOptions, jsonStateSerializer } from "./types.js";
 
 const EMPTY_SCHEMA = new Schema([]);
 
@@ -46,8 +41,7 @@ export function createHttpHandler(
   const corsOrigins = options?.corsOrigins;
   const maxRequestBytes = options?.maxRequestBytes;
   const maxStreamResponseBytes = options?.maxStreamResponseBytes;
-  const serverId =
-    options?.serverId ?? crypto.randomUUID().replace(/-/g, "").slice(0, 12);
+  const serverId = options?.serverId ?? crypto.randomUUID().replace(/-/g, "").slice(0, 12);
 
   const methods = protocol.getMethods();
 
@@ -70,10 +64,7 @@ export function createHttpHandler(
     }
   }
 
-  async function compressIfAccepted(
-    response: Response,
-    clientAcceptsZstd: boolean,
-  ): Promise<Response> {
+  async function compressIfAccepted(response: Response, clientAcceptsZstd: boolean): Promise<Response> {
     if (compressionLevel == null || !clientAcceptsZstd) return response;
     const responseBody = new Uint8Array(await response.arrayBuffer());
     const compressed = zstdCompress(responseBody, compressionLevel);
@@ -85,11 +76,7 @@ export function createHttpHandler(
     });
   }
 
-  function makeErrorResponse(
-    error: Error,
-    statusCode: number,
-    schema: Schema = EMPTY_SCHEMA,
-  ): Response {
+  function makeErrorResponse(error: Error, statusCode: number, schema: Schema = EMPTY_SCHEMA): Response {
     const errBatch = buildErrorBatch(schema, error, serverId, null);
     const body = serializeIpcStream(schema, [errBatch]);
     const resp = arrowResponse(body, statusCode);
@@ -128,23 +115,18 @@ export function createHttpHandler(
     // Validate Content-Type
     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 },
-      );
+      return new Response(`Unsupported Media Type: expected ${ARROW_CONTENT_TYPE}`, { status: 415 });
     }
 
     // Check request body size
     if (maxRequestBytes != null) {
       const contentLength = request.headers.get("Content-Length");
-      if (contentLength && parseInt(contentLength) > maxRequestBytes) {
+      if (contentLength && parseInt(contentLength, 10) > maxRequestBytes) {
         return new Response("Request body too large", { status: 413 });
       }
     }
 
-    const clientAcceptsZstd = (
-      request.headers.get("Accept-Encoding") ?? ""
-    ).includes("zstd");
+    const clientAcceptsZstd = (request.headers.get("Accept-Encoding") ?? "").includes("zstd");
 
     // Read body, decompressing if needed
     let body = new Uint8Array(await request.arrayBuffer());
@@ -160,15 +142,12 @@ export function createHttpHandler(
         addCorsHeaders(response.headers);
         return compressIfAccepted(response, clientAcceptsZstd);
       } catch (error: any) {
-        return compressIfAccepted(
-          makeErrorResponse(error, 500),
-          clientAcceptsZstd,
-        );
+        return compressIfAccepted(makeErrorResponse(error, 500), clientAcceptsZstd);
       }
     }
 
     // Parse method name and sub-path from URL
-    if (!path.startsWith(prefix + "/")) {
+    if (!path.startsWith(`${prefix}/`)) {
       return new Response("Not Found", { status: 404 });
     }
 
@@ -191,13 +170,8 @@ export function createHttpHandler(
     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,
-      );
+      const err = new Error(`Unknown method: '${methodName}'. Available methods: [${available.join(", ")}]`);
+      return compressIfAccepted(makeErrorResponse(err, 404), clientAcceptsZstd);
     }
 
     try {
@@ -205,10 +179,7 @@ export function createHttpHandler(
 
       if (action === "call") {
         if (method.type !== MethodType.UNARY) {
-          throw new HttpRpcError(
-            `Method '${methodName}' is a stream method. Use /init and /exchange endpoints.`,
-            400,
-          );
+          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") {
@@ -233,15 +204,9 @@ export function createHttpHandler(
       return compressIfAccepted(response, clientAcceptsZstd);
     } catch (error: any) {
       if (error instanceof HttpRpcError) {
-        return compressIfAccepted(
-          makeErrorResponse(error, error.statusCode),
-          clientAcceptsZstd,
-        );
+        return compressIfAccepted(makeErrorResponse(error, error.statusCode), clientAcceptsZstd);
       }
-      return compressIfAccepted(
-        makeErrorResponse(error, 500),
-        clientAcceptsZstd,
-      );
+      return compressIfAccepted(makeErrorResponse(error, 500), clientAcceptsZstd);
     }
   };
 }

package/src/http/index.ts

@@ -1,6 +1,8 @@
 // © Copyright 2025-2026, Query.Farm LLC - https://query.farm
 // SPDX-License-Identifier: Apache-2.0
 
+export { ARROW_CONTENT_TYPE } from "./common.js";
 export { createHttpHandler } from "./handler.js";
+export { type UnpackedToken, unpackStateToken } from "./token.js";
 export type { HttpHandlerOptions, StateSerializer } from "./types.js";
-export { ARROW_CONTENT_TYPE } from "./common.js";
+export { jsonStateSerializer } from "./types.js";

package/src/http/token.ts

@@ -28,8 +28,7 @@ export function packStateToken(
 ): string {
   const now = createdAt ?? Math.floor(Date.now() / 1000);
 
-  const payloadLen =
-    1 + 8 + 4 + stateBytes.length + 4 + schemaBytes.length + 4 + inputSchemaBytes.length;
+  const payloadLen = 1 + 8 + 4 + stateBytes.length + 4 + schemaBytes.length + 4 + inputSchemaBytes.length;
   const buf = Buffer.alloc(payloadLen);
   let offset = 0;
 
@@ -77,11 +76,7 @@ export interface UnpackedToken {
  * Unpack and verify a state token.
  * Throws on tampered, expired, or malformed tokens.
  */
-export function unpackStateToken(
-  tokenBase64: string,
-  signingKey: Uint8Array,
-  tokenTtl: number,
-): UnpackedToken {
+export function unpackStateToken(tokenBase64: string, signingKey: Uint8Array, tokenTtl: number): UnpackedToken {
   const token = Buffer.from(tokenBase64, "base64");
 
   if (token.length < MIN_TOKEN_LEN) {

package/src/http/types.ts

@@ -34,16 +34,12 @@ export interface StateSerializer {
 export const jsonStateSerializer: StateSerializer = {
   serialize(state: any): Uint8Array {
     return new TextEncoder().encode(
-      JSON.stringify(state, (_key, value) =>
-        typeof value === "bigint" ? `__bigint__:${value}` : value,
-      ),
+      JSON.stringify(state, (_key, value) => (typeof value === "bigint" ? `__bigint__:${value}` : value)),
     );
   },
   deserialize(bytes: Uint8Array): any {
     return JSON.parse(new TextDecoder().decode(bytes), (_key, value) =>
-      typeof value === "string" && value.startsWith("__bigint__:")
-        ? BigInt(value.slice(11))
-        : value,
+      typeof value === "string" && value.startsWith("__bigint__:") ? BigInt(value.slice(11)) : value,
     );
   },
 };

package/src/index.ts

@@ -1,52 +1,55 @@
 // © Copyright 2025-2026, Query.Farm LLC - https://query.farm
 // SPDX-License-Identifier: Apache-2.0
 
-export { VgiRpcServer } from "./server.js";
-export { Protocol } from "./protocol.js";
-export {
-  MethodType,
-  OutputCollector,
-  type LogContext,
-  type MethodDefinition,
-  type UnaryHandler,
-  type HeaderInit,
-  type ProducerInit,
-  type ProducerFn,
-  type ExchangeInit,
-  type ExchangeFn,
-} from "./types.js";
+export * from "./client/index.js";
 export {
-  type SchemaLike,
-  toSchema,
-  inferParamTypes,
-  str,
-  bytes,
-  int,
-  int32,
-  float,
-  float32,
-  bool,
-} from "./schema.js";
+  DESCRIBE_METHOD_NAME,
+  DESCRIBE_VERSION,
+  DESCRIBE_VERSION_KEY,
+  LOG_EXTRA_KEY,
+  LOG_LEVEL_KEY,
+  LOG_MESSAGE_KEY,
+  PROTOCOL_NAME_KEY,
+  REQUEST_ID_KEY,
+  REQUEST_VERSION,
+  REQUEST_VERSION_KEY,
+  RPC_METHOD_KEY,
+  SERVER_ID_KEY,
+  STATE_KEY,
+} from "./constants.js";
 export { RpcError, VersionError } from "./errors.js";
 export {
-  createHttpHandler,
   ARROW_CONTENT_TYPE,
+  createHttpHandler,
   type HttpHandlerOptions,
+  jsonStateSerializer,
   type StateSerializer,
+  type UnpackedToken,
+  unpackStateToken,
 } from "./http/index.js";
+export { Protocol } from "./protocol.js";
 export {
-  RPC_METHOD_KEY,
-  REQUEST_VERSION_KEY,
-  REQUEST_VERSION,
-  LOG_LEVEL_KEY,
-  LOG_MESSAGE_KEY,
-  LOG_EXTRA_KEY,
-  SERVER_ID_KEY,
-  REQUEST_ID_KEY,
-  PROTOCOL_NAME_KEY,
-  DESCRIBE_VERSION_KEY,
-  DESCRIBE_VERSION,
-  DESCRIBE_METHOD_NAME,
-  STATE_KEY,
-} from "./constants.js";
-export * from "./client/index.js";
+  bool,
+  bytes,
+  float,
+  float32,
+  inferParamTypes,
+  int,
+  int32,
+  type SchemaLike,
+  str,
+  toSchema,
+} from "./schema.js";
+export { VgiRpcServer } from "./server.js";
+export {
+  type ExchangeFn,
+  type ExchangeInit,
+  type HeaderInit,
+  type LogContext,
+  type MethodDefinition,
+  MethodType,
+  OutputCollector,
+  type ProducerFn,
+  type ProducerInit,
+  type UnaryHandler,
+} from "./types.js";

package/src/protocol.ts

@@ -1,17 +1,17 @@
 // © Copyright 2025-2026, Query.Farm LLC - https://query.farm
 // SPDX-License-Identifier: Apache-2.0
 
-import { Schema } from "apache-arrow";
-import { type SchemaLike, toSchema, inferParamTypes } from "./schema.js";
+import { Schema } from "@query-farm/apache-arrow";
+import { inferParamTypes, type SchemaLike, toSchema } from "./schema.js";
 import {
-  MethodType,
-  type MethodDefinition,
-  type UnaryHandler,
+  type ExchangeFn,
+  type ExchangeInit,
   type HeaderInit,
-  type ProducerInit,
+  type MethodDefinition,
+  MethodType,
   type ProducerFn,
-  type ExchangeInit,
-  type ExchangeFn,
+  type ProducerInit,
+  type UnaryHandler,
 } from "./types.js";
 
 const EMPTY_SCHEMA = new Schema([]);

package/src/schema.ts

@@ -2,18 +2,18 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import {
-  Schema,
-  Field,
-  DataType,
-  Utf8,
   Binary,
-  Int64,
-  Int32,
-  Int16,
-  Float64,
-  Float32,
   Bool,
-} from "apache-arrow";
+  DataType,
+  Field,
+  Float32,
+  Float64,
+  Int16,
+  Int32,
+  Int64,
+  Schema,
+  Utf8,
+} from "@query-farm/apache-arrow";
 
 // ---------------------------------------------------------------------------
 // Convenient DataType singletons — re-export so users avoid arrow imports
@@ -64,9 +64,7 @@ export function toSchema(spec: SchemaLike): Schema {
     } else if (value instanceof DataType) {
       fields.push(new Field(name, value, false));
     } else {
-      throw new TypeError(
-        `Invalid schema value for "${name}": expected DataType or Field, got ${typeof value}`,
-      );
+      throw new TypeError(`Invalid schema value for "${name}": expected DataType or Field, got ${typeof value}`);
     }
   }
   return new Schema(fields);
@@ -92,9 +90,7 @@ const TYPE_MAP: [new (...args: any[]) => DataType, string][] = [
  * Maps common Arrow scalar types to Python-style type strings.
  * Returns `undefined` if any field has a complex type (List, Map_, Dictionary, etc.).
  */
-export function inferParamTypes(
-  spec: SchemaLike,
-): Record<string, string> | undefined {
+export function inferParamTypes(spec: SchemaLike): Record<string, string> | undefined {
   const schema = toSchema(spec);
   if (schema.fields.length === 0) return undefined;
 

package/src/server.ts

@@ -1,18 +1,18 @@
 // © Copyright 2025-2026, Query.Farm LLC - https://query.farm
 // SPDX-License-Identifier: Apache-2.0
 
-import { Schema } from "apache-arrow";
-import { Protocol } from "./protocol.js";
-import { IpcStreamReader } from "./wire/reader.js";
-import { IpcStreamWriter } from "./wire/writer.js";
-import { parseRequest } from "./wire/request.js";
-import { buildErrorBatch } from "./wire/response.js";
+import { Schema } from "@query-farm/apache-arrow";
+import { DESCRIBE_METHOD_NAME } from "./constants.js";
 import { buildDescribeBatch } from "./dispatch/describe.js";
-import { dispatchUnary } from "./dispatch/unary.js";
 import { dispatchStream } from "./dispatch/stream.js";
-import { DESCRIBE_METHOD_NAME } from "./constants.js";
-import { MethodType } from "./types.js";
+import { dispatchUnary } from "./dispatch/unary.js";
 import { RpcError, VersionError } from "./errors.js";
+import type { Protocol } from "./protocol.js";
+import { MethodType } from "./types.js";
+import { IpcStreamReader } from "./wire/reader.js";
+import { parseRequest } from "./wire/request.js";
+import { buildErrorBatch } from "./wire/response.js";
+import { IpcStreamWriter } from "./wire/writer.js";
 
 const EMPTY_SCHEMA = new Schema([]);
 
@@ -24,23 +24,15 @@ export class VgiRpcServer {
   private protocol: Protocol;
   private enableDescribe: boolean;
   private serverId: string;
-  private describeBatch: import("apache-arrow").RecordBatch | null = null;
+  private describeBatch: import("@query-farm/apache-arrow").RecordBatch | null = null;
 
-  constructor(
-    protocol: Protocol,
-    options?: { enableDescribe?: boolean; serverId?: string },
-  ) {
+  constructor(protocol: Protocol, options?: { enableDescribe?: boolean; serverId?: string }) {
     this.protocol = protocol;
     this.enableDescribe = options?.enableDescribe ?? true;
-    this.serverId =
-      options?.serverId ?? crypto.randomUUID().replace(/-/g, "").slice(0, 12);
+    this.serverId = options?.serverId ?? crypto.randomUUID().replace(/-/g, "").slice(0, 12);
 
     if (this.enableDescribe) {
-      const { batch } = buildDescribeBatch(
-        protocol.name,
-        protocol.getMethods(),
-        this.serverId,
-      );
+      const { batch } = buildDescribeBatch(protocol.name, protocol.getMethods(), this.serverId);
       this.describeBatch = batch;
     }
   }
@@ -86,10 +78,7 @@ export class VgiRpcServer {
     }
   }
 
-  private async serveOne(
-    reader: IpcStreamReader,
-    writer: IpcStreamWriter,
-  ): Promise<void> {
+  private async serveOne(reader: IpcStreamReader, writer: IpcStreamWriter): Promise<void> {
     const stream = await reader.readStream();
     if (!stream) {
       throw new Error("EOF");
@@ -134,9 +123,7 @@ export class VgiRpcServer {
     const method = methods.get(methodName);
     if (!method) {
       const available = [...methods.keys()].sort();
-      const err = new Error(
-        `Unknown method: '${methodName}'. Available methods: [${available.join(", ")}]`,
-      );
+      const err = new Error(`Unknown method: '${methodName}'. Available methods: [${available.join(", ")}]`);
       const errBatch = buildErrorBatch(EMPTY_SCHEMA, err, this.serverId, requestId);
       writer.writeStream(EMPTY_SCHEMA, [errBatch]);
       return;
@@ -146,14 +133,7 @@ export class VgiRpcServer {
     if (method.type === MethodType.UNARY) {
       await dispatchUnary(method, params, writer, this.serverId, requestId);
     } else {
-      await dispatchStream(
-        method,
-        params,
-        writer,
-        reader,
-        this.serverId,
-        requestId,
-      );
+      await dispatchStream(method, params, writer, reader, this.serverId, requestId);
     }
   }
 }

package/src/types.ts

@@ -1,7 +1,7 @@
 // © Copyright 2025-2026, Query.Farm LLC - https://query.farm
 // SPDX-License-Identifier: Apache-2.0
 
-import { type Schema, RecordBatch, recordBatchFromArrays } from "apache-arrow";
+import { RecordBatch, recordBatchFromArrays, type Schema } from "@query-farm/apache-arrow";
 import { buildLogBatch, coerceInt64 } from "./wire/response.js";
 
 export enum MethodType {
@@ -21,32 +21,17 @@ export type UnaryHandler = (
 ) => Promise<Record<string, any>> | Record<string, any>;
 
 /** Initialization function for producer streams. Returns the initial state object. */
-export type ProducerInit<S = any> = (
-  params: Record<string, any>,
-) => Promise<S> | S;
+export type ProducerInit<S = any> = (params: Record<string, any>) => Promise<S> | S;
 /** Called repeatedly to produce output batches. Call `out.finish()` to end the stream. */
-export type ProducerFn<S = any> = (
-  state: S,
-  out: OutputCollector,
-) => Promise<void> | void;
+export type ProducerFn<S = any> = (state: S, out: OutputCollector) => Promise<void> | void;
 
 /** Initialization function for exchange streams. Returns the initial state object. */
-export type ExchangeInit<S = any> = (
-  params: Record<string, any>,
-) => Promise<S> | S;
+export type ExchangeInit<S = any> = (params: Record<string, any>) => Promise<S> | S;
 /** Called once per input batch. Must emit exactly one output batch per call. */
-export type ExchangeFn<S = any> = (
-  state: S,
-  input: RecordBatch,
-  out: OutputCollector,
-) => Promise<void> | void;
+export type ExchangeFn<S = any> = (state: S, input: RecordBatch, out: OutputCollector) => Promise<void> | void;
 
 /** Produces a header batch sent before the first output batch in a stream. */
-export type HeaderInit = (
-  params: Record<string, any>,
-  state: any,
-  ctx: LogContext,
-) => Record<string, any>;
+export type HeaderInit = (params: Record<string, any>, state: any, ctx: LogContext) => Record<string, any>;
 
 export interface MethodDefinition {
   name: string;
@@ -108,10 +93,7 @@ export class OutputCollector implements LogContext {
   emit(batch: RecordBatch, metadata?: Map<string, string>): void;
   /** Emit a data batch from column arrays keyed by field name. Int64 Number values are coerced to BigInt. */
   emit(columns: Record<string, any[]>): void;
-  emit(
-    batchOrColumns: RecordBatch | Record<string, any[]>,
-    metadata?: Map<string, string>,
-  ): void {
+  emit(batchOrColumns: RecordBatch | Record<string, any[]>, metadata?: Map<string, string>): void {
     let batch: RecordBatch;
     if (batchOrColumns instanceof RecordBatch) {
       batch = batchOrColumns;
@@ -139,8 +121,7 @@ export class OutputCollector implements LogContext {
   finish(): void {
     if (!this._producerMode) {
       throw new Error(
-        "finish() is not allowed on exchange streams; " +
-          "exchange streams must emit exactly one data batch per call",
+        "finish() is not allowed on exchange streams; " + "exchange streams must emit exactly one data batch per call",
       );
     }
     this._finished = true;
@@ -148,15 +129,7 @@ export class OutputCollector implements LogContext {
 
   /** Emit a zero-row client-directed log batch. */
   clientLog(level: string, message: string, extra?: Record<string, string>): void {
-    const batch = buildLogBatch(
-      this._outputSchema,
-      level,
-      message,
-      extra,
-      this._serverId,
-      this._requestId,
-    );
+    const batch = buildLogBatch(this._outputSchema, level, message, extra, this._serverId, this._requestId);
     this._batches.push({ batch });
   }
-
 }

package/src/util/schema.ts

@@ -1,7 +1,7 @@
 // © Copyright 2025-2026, Query.Farm LLC - https://query.farm
 // SPDX-License-Identifier: Apache-2.0
 
-import { RecordBatchStreamWriter, type Schema } from "apache-arrow";
+import { RecordBatchStreamWriter, type Schema } from "@query-farm/apache-arrow";
 
 /**
  * Serialize a Schema to the Arrow IPC Schema message format.

package/src/util/zstd.ts

@@ -19,10 +19,7 @@ export function zstdCompress(data: Uint8Array, level: number): Uint8Array<ArrayB
   }
   const fn = (zlib as any).zstdCompressSync;
   if (typeof fn !== "function") {
-    throw new Error(
-      "zstd is not available in this runtime. " +
-        "Requires Bun, Node.js >= 22.15, or Deno >= 2.6.9.",
-    );
+    throw new Error("zstd is not available in this runtime. " + "Requires Bun, Node.js >= 22.15, or Deno >= 2.6.9.");
   }
   return new Uint8Array(
     fn(data, {
@@ -40,10 +37,7 @@ export function zstdDecompress(data: Uint8Array): Uint8Array<ArrayBuffer> {
   }
   const fn = (zlib as any).zstdDecompressSync;
   if (typeof fn !== "function") {
-    throw new Error(
-      "zstd is not available in this runtime. " +
-        "Requires Bun, Node.js >= 22.15, or Deno >= 2.6.9.",
-    );
+    throw new Error("zstd is not available in this runtime. " + "Requires Bun, Node.js >= 22.15, or Deno >= 2.6.9.");
   }
   return new Uint8Array(fn(data));
 }

package/src/wire/reader.ts

@@ -1,7 +1,7 @@
 // © Copyright 2025-2026, Query.Farm LLC - https://query.farm
 // SPDX-License-Identifier: Apache-2.0
 
-import { RecordBatchReader, type RecordBatch, type Schema } from "apache-arrow";
+import { type RecordBatch, RecordBatchReader, type Schema } from "@query-farm/apache-arrow";
 
 export interface StreamMessage {
   schema: Schema;
@@ -23,9 +23,7 @@ export class IpcStreamReader {
     this.reader = reader;
   }
 
-  static async create(
-    input: ReadableStream<Uint8Array> | NodeJS.ReadableStream,
-  ): Promise<IpcStreamReader> {
+  static async create(input: ReadableStream<Uint8Array> | NodeJS.ReadableStream): Promise<IpcStreamReader> {
     const reader = await RecordBatchReader.from(input as any);
     await reader.open({ autoDestroy: false });
     if (reader.closed) {

package/src/wire/request.ts

@@ -1,13 +1,8 @@
 // © Copyright 2025-2026, Query.Farm LLC - https://query.farm
 // SPDX-License-Identifier: Apache-2.0
 
-import { DataType, type Schema, type RecordBatch } from "apache-arrow";
-import {
-  RPC_METHOD_KEY,
-  REQUEST_VERSION_KEY,
-  REQUEST_VERSION,
-  REQUEST_ID_KEY,
-} from "../constants.js";
+import { DataType, type RecordBatch, type Schema } from "@query-farm/apache-arrow";
+import { REQUEST_ID_KEY, REQUEST_VERSION, REQUEST_VERSION_KEY, RPC_METHOD_KEY } from "../constants.js";
 import { RpcError, VersionError } from "../errors.js";
 
 export interface ParsedRequest {
@@ -23,10 +18,7 @@ export interface ParsedRequest {
  * Parse a request from a RecordBatch with metadata.
  * Extracts method name, version, and params from the batch.
  */
-export function parseRequest(
-  schema: Schema,
-  batch: RecordBatch,
-): ParsedRequest {
+export function parseRequest(schema: Schema, batch: RecordBatch): ParsedRequest {
   const metadata: Map<string, string> = batch.metadata ?? new Map();
 
   const methodName = metadata.get(RPC_METHOD_KEY);
@@ -77,10 +69,7 @@ export function parseRequest(
     let value = batch.getChildAt(i)?.get(0);
     // Convert BigInt to Number when safe
     if (typeof value === "bigint") {
-      if (
-        value >= BigInt(Number.MIN_SAFE_INTEGER) &&
-        value <= BigInt(Number.MAX_SAFE_INTEGER)
-      ) {
+      if (value >= BigInt(Number.MIN_SAFE_INTEGER) && value <= BigInt(Number.MAX_SAFE_INTEGER)) {
         value = Number(value);
       }
     }