@query-farm/vgi-rpc 0.3.1 → 0.3.2

package/src/dispatch/describe.ts

@@ -2,25 +2,25 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import {
-  Schema,
+  Binary,
+  Bool,
   Field,
+  makeData,
   RecordBatch,
+  Schema,
+  Struct,
   Utf8,
-  Bool,
-  Binary,
   vectorFromArray,
-  makeData,
-  Struct,
 } from "@query-farm/apache-arrow";
-import type { MethodDefinition } from "../types.js";
 import {
+  DESCRIBE_VERSION,
+  DESCRIBE_VERSION_KEY,
   PROTOCOL_NAME_KEY,
-  REQUEST_VERSION_KEY,
   REQUEST_VERSION,
-  DESCRIBE_VERSION_KEY,
-  DESCRIBE_VERSION,
+  REQUEST_VERSION_KEY,
   SERVER_ID_KEY,
 } from "../constants.js";
+import type { MethodDefinition } from "../types.js";
 import { serializeSchema } from "../util/schema.js";
 
 /**
@@ -48,9 +48,7 @@ export function buildDescribeBatch(
   serverId: string,
 ): { batch: RecordBatch; metadata: Map<string, string> } {
   // Sort methods by name for consistent ordering
-  const sortedEntries = [...methods.entries()].sort(([a], [b]) =>
-    a.localeCompare(b),
-  );
+  const sortedEntries = [...methods.entries()].sort(([a], [b]) => a.localeCompare(b));
 
   const names: (string | null)[] = [];
   const methodTypes: (string | null)[] = [];
@@ -69,8 +67,7 @@ export function buildDescribeBatch(
     docs.push(method.doc ?? null);
 
     // Unary methods with non-empty result schema have a return value
-    const hasReturn =
-      method.type === "unary" && method.resultSchema.fields.length > 0;
+    const hasReturn = method.type === "unary" && method.resultSchema.fields.length > 0;
     hasReturns.push(hasReturn);
 
     paramsSchemas.push(serializeSchema(method.paramsSchema));
@@ -87,26 +84,17 @@ export function buildDescribeBatch(
     if (method.defaults && Object.keys(method.defaults).length > 0) {
       const safe: Record<string, any> = {};
       for (const [k, v] of Object.entries(method.defaults)) {
-        if (
-          v === null ||
-          typeof v === "string" ||
-          typeof v === "number" ||
-          typeof v === "boolean"
-        ) {
+        if (v === null || typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
           safe[k] = v;
         }
       }
-      paramDefaultsJsons.push(
-        Object.keys(safe).length > 0 ? JSON.stringify(safe) : null,
-      );
+      paramDefaultsJsons.push(Object.keys(safe).length > 0 ? JSON.stringify(safe) : null);
     } else {
       paramDefaultsJsons.push(null);
     }
 
     hasHeaders.push(!!method.headerSchema);
-    headerSchemas.push(
-      method.headerSchema ? serializeSchema(method.headerSchema) : null,
-    );
+    headerSchemas.push(method.headerSchema ? serializeSchema(method.headerSchema) : null);
   }
 
   // Build the batch using vectorFromArray for each column

package/src/dispatch/stream.ts

@@ -4,9 +4,9 @@
 import { Schema } from "@query-farm/apache-arrow";
 import type { MethodDefinition } from "../types.js";
 import { OutputCollector } from "../types.js";
-import type { IpcStreamWriter } from "../wire/writer.js";
 import type { IpcStreamReader } from "../wire/reader.js";
-import { buildResultBatch, buildErrorBatch } from "../wire/response.js";
+import { buildErrorBatch, buildResultBatch } from "../wire/response.js";
+import type { IpcStreamWriter } from "../wire/writer.js";
 
 const EMPTY_SCHEMA = new Schema([]);
 
@@ -70,16 +70,8 @@ export async function dispatchStream(
     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,
-      ];
+      const headerBatch = buildResultBatch(method.headerSchema, headerValues, serverId, requestId);
+      const headerBatches = [...headerOut.batches.map((b) => b.batch), headerBatch];
       writer.writeStream(method.headerSchema, headerBatches);
     } catch (error: any) {
       const errBatch = buildErrorBatch(method.headerSchema, error, serverId, requestId);
@@ -96,12 +88,7 @@ export async function dispatchStream(
   // Open the input IPC stream (ticks or data from client)
   const inputSchema = await reader.openNextStream();
   if (!inputSchema) {
-    const errBatch = buildErrorBatch(
-      outputSchema,
-      new Error("Expected input stream but got EOF"),
-      serverId,
-      requestId,
-    );
+    const errBatch = buildErrorBatch(outputSchema, new Error("Expected input stream but got EOF"), serverId, requestId);
     writer.writeStream(outputSchema, [errBatch]);
     return;
   }

package/src/dispatch/unary.ts

@@ -1,11 +1,10 @@
 // © Copyright 2025-2026, Query.Farm LLC - https://query.farm
 // SPDX-License-Identifier: Apache-2.0
 
-import { Schema } from "@query-farm/apache-arrow";
 import type { MethodDefinition } from "../types.js";
 import { OutputCollector } from "../types.js";
+import { buildErrorBatch, buildResultBatch } from "../wire/response.js";
 import type { IpcStreamWriter } from "../wire/writer.js";
-import { buildResultBatch, buildErrorBatch } from "../wire/response.js";
 
 /**
  * Dispatch a unary RPC call.

package/src/http/common.ts

@@ -2,12 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import {
-  RecordBatchStreamWriter,
-  RecordBatchReader,
+  makeData,
   RecordBatch,
-  Schema,
+  RecordBatchReader,
+  RecordBatchStreamWriter,
+  type Schema,
   Struct,
-  makeData,
 } from "@query-farm/apache-arrow";
 
 export const ARROW_CONTENT_TYPE = "application/vnd.apache.arrow.stream";
@@ -31,14 +31,9 @@ export class HttpRpcError extends Error {
  * match the writer's schema.  Cloning each child Data with the schema's field
  * type fixes the type metadata while preserving the underlying buffers.
  */
-function conformBatchToSchema(
-  batch: RecordBatch,
-  schema: Schema,
-): RecordBatch {
+function conformBatchToSchema(batch: RecordBatch, schema: Schema): RecordBatch {
   if (batch.numRows === 0) return batch;
-  const children = schema.fields.map((f, i) =>
-    batch.data.children[i].clone(f.type),
-  );
+  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,
@@ -51,10 +46,7 @@ function conformBatchToSchema(
 }
 
 /** Serialize a schema + batches into a complete IPC stream as Uint8Array. */
-export function serializeIpcStream(
-  schema: Schema,
-  batches: RecordBatch[],
-): Uint8Array {
+export function serializeIpcStream(schema: Schema, batches: RecordBatch[]): Uint8Array {
   const writer = new RecordBatchStreamWriter();
   writer.reset(undefined, schema);
   for (const batch of batches) {
@@ -72,9 +64,7 @@ export function arrowResponse(body: Uint8Array, status = 200, extraHeaders?: Hea
 }
 
 /** Read schema + first batch from an IPC stream body. */
-export async function readRequestFromBody(
-  body: Uint8Array,
-): Promise<{ schema: Schema; batch: RecordBatch }> {
+export async function readRequestFromBody(body: Uint8Array): Promise<{ schema: Schema; batch: RecordBatch }> {
   const reader = await RecordBatchReader.from(body);
   await reader.open();
   const schema = reader.schema;

package/src/http/dispatch.ts

@@ -1,24 +1,15 @@
 // © Copyright 2025-2026, Query.Farm LLC - https://query.farm
 // SPDX-License-Identifier: Apache-2.0
 
-import { Schema, RecordBatch, RecordBatchReader } from "@query-farm/apache-arrow";
+import { RecordBatch, RecordBatchReader, Schema } from "@query-farm/apache-arrow";
+import { STATE_KEY } from "../constants.js";
+import { buildDescribeBatch, DESCRIBE_SCHEMA } from "../dispatch/describe.js";
 import type { MethodDefinition } from "../types.js";
 import { OutputCollector } from "../types.js";
-import { parseRequest } from "../wire/request.js";
-import {
-  buildResultBatch,
-  buildErrorBatch,
-  buildEmptyBatch,
-} from "../wire/response.js";
-import { buildDescribeBatch, DESCRIBE_SCHEMA } from "../dispatch/describe.js";
-import { STATE_KEY } from "../constants.js";
 import { serializeSchema } from "../util/schema.js";
-import {
-  HttpRpcError,
-  serializeIpcStream,
-  readRequestFromBody,
-  arrowResponse,
-} from "./common.js";
+import { parseRequest } from "../wire/request.js";
+import { buildEmptyBatch, buildErrorBatch, buildResultBatch } from "../wire/response.js";
+import { arrowResponse, HttpRpcError, readRequestFromBody, serializeIpcStream } from "./common.js";
 import { packStateToken, unpackStateToken } from "./token.js";
 import type { StateSerializer } from "./types.js";
 
@@ -60,10 +51,7 @@ export async function httpDispatchUnary(
   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,
-    );
+    throw new HttpRpcError(`Method name in request '${parsed.methodName}' does not match URL '${method.name}'`, 400);
   }
 
   const out = new OutputCollector(schema, true, ctx.serverId, parsed.requestId);
@@ -93,10 +81,7 @@ export async function httpDispatchStreamInit(
   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,
-    );
+    throw new HttpRpcError(`Method name in request '${parsed.methodName}' does not match URL '${method.name}'`, 400);
   }
 
   // Init state
@@ -121,31 +106,13 @@ export async function httpDispatchStreamInit(
   let headerBytes: Uint8Array | null = null;
   if (method.headerSchema && method.headerInit) {
     try {
-      const headerOut = new OutputCollector(
-        method.headerSchema,
-        true,
-        ctx.serverId,
-        parsed.requestId,
-      );
+      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,
-      ];
+      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: any) {
-      const errBatch = buildErrorBatch(
-        method.headerSchema,
-        error,
-        ctx.serverId,
-        parsed.requestId,
-      );
+      const errBatch = buildErrorBatch(method.headerSchema, error, ctx.serverId, parsed.requestId);
       return arrowResponse(serializeIpcStream(method.headerSchema, [errBatch]), 500);
     }
   }
@@ -154,26 +121,13 @@ export async function httpDispatchStreamInit(
     // Producer method — produce data inline in the init response.
     // For exchange-registered methods acting as producers (__isProducer),
     // produceStreamResponse falls back to exchangeFn with tick batches.
-    return produceStreamResponse(
-      method,
-      state,
-      resolvedOutputSchema,
-      inputSchema,
-      ctx,
-      parsed.requestId,
-      headerBytes,
-    );
+    return produceStreamResponse(method, state, resolvedOutputSchema, inputSchema, ctx, parsed.requestId, headerBytes);
   } else {
     // Exchange: serialize state into signed token, return zero-row batch with token
     const stateBytes = ctx.stateSerializer.serialize(state);
     const schemaBytes = serializeSchema(resolvedOutputSchema);
     const inputSchemaBytes = serializeSchema(inputSchema);
-    const token = packStateToken(
-      stateBytes,
-      schemaBytes,
-      inputSchemaBytes,
-      ctx.signingKey,
-    );
+    const token = packStateToken(stateBytes, schemaBytes, inputSchemaBytes, ctx.signingKey);
 
     const tokenMeta = new Map<string, string>();
     tokenMeta.set(STATE_KEY, token);
@@ -207,7 +161,7 @@ export async function httpDispatchStreamExchange(
     throw new HttpRpcError("Missing state token in exchange request", 400);
   }
 
-  let unpacked;
+  let unpacked: import("./token.js").UnpackedToken;
   try {
     unpacked = unpackStateToken(tokenBase64, ctx.signingKey, ctx.tokenTtl);
   } catch (error: any) {
@@ -237,20 +191,15 @@ export async function httpDispatchStreamExchange(
     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 (process.env.VGI_DISPATCH_DEBUG)
+    console.error(
+      `[httpDispatchStreamExchange] method=${method.name} effectiveProducer=${effectiveProducer} stateKeys=${Object.keys(state || {})}`,
+    );
 
   if (effectiveProducer) {
     // Producer continuation — produce more data inline.
     // For exchange-registered methods, falls back to exchangeFn with tick batches.
-    return produceStreamResponse(
-      method,
-      state,
-      outputSchema,
-      inputSchema,
-      ctx,
-      null,
-      null,
-    );
+    return produceStreamResponse(method, state, outputSchema, inputSchema, ctx, null, null);
   } else {
     // Exchange path — also handles exchange-registered methods acting as
     // producers (__isProducer=true). Use producer mode on the OutputCollector
@@ -264,7 +213,12 @@ export async function httpDispatchStreamExchange(
         await method.producerFn!(state, out);
       }
     } catch (error: any) {
-      if (process.env.VGI_DISPATCH_DEBUG) console.error(`[httpDispatchStreamExchange] exchange handler error:`, error.message, error.stack?.split('\n').slice(0,5).join('\n'));
+      if (process.env.VGI_DISPATCH_DEBUG)
+        console.error(
+          `[httpDispatchStreamExchange] exchange handler error:`,
+          error.message,
+          error.stack?.split("\n").slice(0, 5).join("\n"),
+        );
       const errBatch = buildErrorBatch(outputSchema, error, ctx.serverId, null);
       return arrowResponse(serializeIpcStream(outputSchema, [errBatch]), 500);
     }
@@ -283,12 +237,7 @@ export async function httpDispatchStreamExchange(
       const stateBytes = ctx.stateSerializer.serialize(state);
       const schemaBytes = serializeSchema(outputSchema);
       const inputSchemaBytes = serializeSchema(inputSchema);
-      const token = packStateToken(
-        stateBytes,
-        schemaBytes,
-        inputSchemaBytes,
-        ctx.signingKey,
-      );
+      const token = packStateToken(stateBytes, schemaBytes, inputSchemaBytes, ctx.signingKey);
 
       for (const emitted of out.batches) {
         const batch = emitted.batch;
@@ -304,7 +253,7 @@ export async function httpDispatchStreamExchange(
       // Safety net: if no batch carries a state token (e.g. all rows were
       // filtered out by pushdown filters), emit an empty batch with the
       // token so the client knows to continue exchanging.
-      if (!batches.some(b => b.metadata?.get(STATE_KEY))) {
+      if (!batches.some((b) => b.metadata?.get(STATE_KEY))) {
         const tokenMeta = new Map<string, string>();
         tokenMeta.set(STATE_KEY, token);
         batches.push(buildEmptyBatch(outputSchema, tokenMeta));
@@ -344,7 +293,8 @@ async function produceStreamResponse(
         await method.exchangeFn!(state, tickBatch, out);
       }
     } catch (error: any) {
-      if (process.env.VGI_DISPATCH_DEBUG) console.error(`[produceStreamResponse] error:`, error.message, error.stack?.split('\n').slice(0,3).join('\n'));
+      if (process.env.VGI_DISPATCH_DEBUG)
+        console.error(`[produceStreamResponse] error:`, error.message, error.stack?.split("\n").slice(0, 3).join("\n"));
       allBatches.push(buildErrorBatch(outputSchema, error, ctx.serverId, requestId));
       break;
     }
@@ -365,12 +315,7 @@ async function produceStreamResponse(
       const stateBytes = ctx.stateSerializer.serialize(state);
       const schemaBytes = serializeSchema(outputSchema);
       const inputSchemaBytes = serializeSchema(inputSchema);
-      const token = packStateToken(
-        stateBytes,
-        schemaBytes,
-        inputSchemaBytes,
-        ctx.signingKey,
-      );
+      const token = packStateToken(stateBytes, schemaBytes, inputSchemaBytes, ctx.signingKey);
       const tokenMeta = new Map<string, string>();
       tokenMeta.set(STATE_KEY, token);
       allBatches.push(buildEmptyBatch(outputSchema, tokenMeta));

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 "@query-farm/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,8 +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 { jsonStateSerializer } from "./types.js";
-export { ARROW_CONTENT_TYPE } from "./common.js";
-export { unpackStateToken, type UnpackedToken } from "./token.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,
     );
   },
 };