Bump version to 0.3.4 and add cast-compatible exchange conformance tests

Add exchange_cast_compatible method (48th) to the conformance suite.
Enhance conformBatchToSchema to perform actual numeric value conversion
(int32/int64/float32 → float64) instead of only cloning type metadata,
and validate field names match before casting.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: rustyconover

.github/workflows/ci.yml

@@ -120,7 +120,7 @@ jobs:
         run: bun install && bun run postinstall
 
       - name: Install Python dependencies
-        run: pip install "vgi-rpc[http,cli]>=0.1.13" pytest
+        run: pip install "vgi-rpc[http,cli]>=0.1.15" pytest
 
       - name: Run conformance tests
         run: timeout 120 python -m pytest test_ts_conformance.py -x -v

examples/conformance-protocol.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 /**
- * Conformance protocol — 47-method reference RPC service exercising all framework
+ * Conformance protocol — 48-method reference RPC service exercising all framework
  * capabilities. Used by the Python CLI to verify wire-protocol compatibility.
  *
  * This module exports the Protocol instance so it can be reused by both the
@@ -745,6 +745,19 @@ protocol.exchange<{ callCount: number }>("exchange_zero_columns", {
   },
 });
 
+protocol.exchange<{ factor: number }>("exchange_cast_compatible", {
+  params: {},
+  inputSchema: SCALE_INPUT,
+  outputSchema: SCALE_OUTPUT,
+  init: () => ({ factor: 1.0 }),
+  exchange: (state, input: RecordBatch, out) => {
+    const col = input.getChildAt(0)!;
+    const values: number[] = [];
+    for (let i = 0; i < input.numRows; i++) values.push(col.get(i) * state.factor);
+    out.emit({ value: values });
+  },
+});
+
 protocol.exchange<never>("exchange_error_on_init", {
   params: {},
   inputSchema: SCALE_INPUT,

examples/conformance.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 /**
- * Conformance worker — 43-method reference RPC service exercising all framework
+ * Conformance worker — 48-method reference RPC service exercising all framework
  * capabilities. Used by the Python CLI to verify wire-protocol compatibility.
  *
  * Run: bun run examples/conformance.ts

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@query-farm/vgi-rpc",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "license": "Apache-2.0",
   "homepage": "https://vgi-rpc-typescript.query.farm",
   "repository": {

src/util/conform.ts

@@ -1,7 +1,31 @@
 // © Copyright 2025-2026, Query.Farm LLC - https://query.farm
 // SPDX-License-Identifier: Apache-2.0
 
-import { RecordBatch, Struct, makeData, type Schema } from "@query-farm/apache-arrow";
+import {
+  type DataType,
+  RecordBatch,
+  Struct,
+  Type,
+  makeData,
+  type Schema,
+  vectorFromArray,
+} from "@query-farm/apache-arrow";
+
+/** Return true when the source type's values can be losslessly read and
+ *  re-encoded into the target type (e.g., int32 → float64). */
+function needsValueCast(src: DataType, dst: DataType): boolean {
+  if (src.typeId === dst.typeId) return false;
+  // Same broad family (e.g. Float → Float64) — clone is sufficient.
+  if (src.constructor === dst.constructor) return false;
+  return true;
+}
+
+/** Check if a type is a numeric type we can cast between.
+ *  Uses typeId instead of instanceof because IPC-deserialized types
+ *  may be generic (e.g., Int_ instead of Int64). */
+function isNumeric(t: DataType): boolean {
+  return t.typeId === Type.Int || t.typeId === Type.Float;
+}
 
 /**
  * Rebuild a batch's data to match the given schema's field types.
@@ -12,13 +36,54 @@ import { RecordBatch, Struct, makeData, type Schema } from "@query-farm/apache-a
  * match the writer's schema.  Cloning each child Data with the schema's field
  * type fixes the type metadata while preserving the underlying buffers.
  *
- * This is also used to cast compatible input types (e.g., decimal→double,
- * int32→int64) when the input batch schema doesn't exactly match the method's
- * declared input schema.
+ * This is also used to cast compatible input types (e.g., int32→float64,
+ * float32→float64) when the input batch schema doesn't exactly match the
+ * method's declared input schema.  When the underlying buffer layout differs
+ * (e.g., 4-byte int32 vs 8-byte float64), we read the values and build a
+ * new vector with the target type.
  */
 export 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));
+
+  // Validate field count and names match before attempting any cast.
+  if (batch.schema.fields.length !== schema.fields.length) {
+    throw new TypeError(
+      `Field count mismatch: expected ${schema.fields.length}, got ${batch.schema.fields.length}`,
+    );
+  }
+  for (let i = 0; i < schema.fields.length; i++) {
+    if (batch.schema.fields[i].name !== schema.fields[i].name) {
+      throw new TypeError(
+        `Field name mismatch at index ${i}: expected '${schema.fields[i].name}', got '${batch.schema.fields[i].name}'`,
+      );
+    }
+  }
+
+  const children = schema.fields.map((f, i) => {
+    const srcChild = batch.data.children[i];
+    const srcType = srcChild.type;
+    const dstType = f.type;
+
+    if (!needsValueCast(srcType, dstType)) {
+      return srcChild.clone(dstType);
+    }
+
+    // Numeric → numeric: read values and rebuild with target type.
+    if (isNumeric(srcType) && isNumeric(dstType)) {
+      // Read source values via the batch's column vector.
+      const col = batch.getChildAt(i)!;
+      const values: number[] = [];
+      for (let r = 0; r < batch.numRows; r++) {
+        const v = col.get(r);
+        values.push(typeof v === "bigint" ? Number(v) : (v as number));
+      }
+      return vectorFromArray(values, dstType).data[0];
+    }
+
+    // Fallback: clone type metadata (works for same-layout types).
+    return srcChild.clone(dstType);
+  });
+
   const structType = new Struct(schema.fields);
   const data = makeData({
     type: structType,

test/client.test.ts

@@ -1099,9 +1099,9 @@ function defineConformanceTests<TCtx>(
     // -----------------------------------------------------------------
 
     describe("TestDescribeConformance", () => {
-      it("verify 47 methods", async () => {
+      it("verify 48 methods", async () => {
         const desc = await describeFactory(ctx);
-        expect(desc.methods.length).toBe(47);
+        expect(desc.methods.length).toBe(48);
         expect(["Conformance", "ConformanceService"]).toContain(desc.protocolName);
       });
 

test/http/conformance.test.ts

@@ -156,12 +156,12 @@ async function writeExchangeInput(values: number[]): Promise<string> {
 // ==========================================================================
 
 describe("HTTP conformance: describe", () => {
-  it("lists all 47 methods via HTTP", async () => {
+  it("lists all 48 methods via HTTP", async () => {
     const { stdout, exitCode, stderr } = await run(cliHttp("describe"));
     if (exitCode !== 0) throw new Error(`exit ${exitCode}: ${stdout}\n${stderr}`);
     const data = JSON.parse(stdout);
     expect(data.protocol_name).toBe("Conformance");
-    expect(Object.keys(data.methods).length).toBe(47);
+    expect(Object.keys(data.methods).length).toBe(48);
   });
 });