@query-farm/vgi 0.6.0

package/src/arrow/impl-arrowjs/statistics.ts

@@ -0,0 +1,185 @@
+// Copyright 2025, 2026 Query Farm LLC - https://query.farm
+// arrow-js impl of column-statistics serialization. Builds a sparse-union
+// column manually with `makeData` + `typeIds` buffer + per-type children.
+// This is the only spot in vgi-typescript that touches makeData directly,
+// because flechette's union-column API takes a fundamentally different
+// shape (typeIdForValue closure).
+
+import {
+  Field,
+  Null,
+  makeData,
+  RecordBatch,
+  Struct,
+  SparseUnion,
+  Schema,
+  Utf8,
+  Bool,
+  Int64,
+  Uint64,
+  type DataType,
+} from "@query-farm/apache-arrow";
+import type {
+  VgiBatch,
+  VgiDataType,
+} from "../types.js";
+import { codecFor } from "../codec/registry.js";
+import { writeCanonicalColumn } from "./canonical.js";
+
+export interface ColumnStatistics {
+  columnName: string;
+  arrowType: VgiDataType;
+  min: any;
+  max: any;
+  hasNull: boolean;
+  hasNotNull: boolean;
+  distinctCount: bigint | number | null;
+  containsUnicode: boolean | null;
+  maxStringLength: bigint | number | null;
+}
+
+// Stable, backend-agnostic type key. Dispatch on the structural fields
+// (typeId + unit + bitWidth + precision/scale + byteWidth) rather than
+// `.toString()`, so the union-child grouping matches the flechette backend
+// exactly and never collapses distinct types into one child.
+function typeKey(t: VgiDataType): string {
+  const a = t as any;
+  return [
+    t.typeId,
+    a.unit ?? "",
+    a.bitWidth ?? "",
+    a.precision ?? "",
+    a.scale ?? "",
+    a.byteWidth ?? "",
+  ].join(":");
+}
+
+/**
+ * Build an arrow-js column `Data` node for `type` from RICH values, routed
+ * through the codec (rich -> canonical) and the canonical writer — the same
+ * path the public column-build uses. This guarantees a date/timestamp/decimal
+ * min/max is represented identically to ordinary column data and identically
+ * across both backends.
+ */
+function buildTypedColumnData(values: any[], type: VgiDataType): any {
+  const a = type as DataType;
+  if (a.typeId === 1 /* Null */) {
+    return makeData({ type: a, length: values.length, nullCount: values.length });
+  }
+  const codec = codecFor(type);
+  const canonical = values.map((v) => codec.richToCanonical(v));
+  return writeCanonicalColumn(type, canonical);
+}
+
+export function buildStatisticsBatch(stats: ColumnStatistics[]): VgiBatch {
+  if (stats.length === 0) {
+    // Minimal empty batch: sparse_union with a single null child. Matches
+    // Python's empty serialization — DuckDB tolerates this and reads zero
+    // rows of stats.
+    const nullField = new Field("0", new Null(), true);
+    const unionType = new SparseUnion([0], [nullField]);
+    const minData = makeData({
+      type: unionType,
+      length: 0,
+      typeIds: new Int8Array(0),
+      children: [makeData({ type: new Null(), length: 0, nullCount: 0 })],
+    } as any);
+    const maxData = makeData({
+      type: unionType,
+      length: 0,
+      typeIds: new Int8Array(0),
+      children: [makeData({ type: new Null(), length: 0, nullCount: 0 })],
+    } as any);
+    return assemble([], minData, maxData, [], [], [], [], [], unionType) as unknown as VgiBatch;
+  }
+
+  // Group distinct Arrow types in stable insertion order to assign type codes.
+  const typeOrder: VgiDataType[] = [];
+  const typeIdMap = new Map<string, number>();
+  const rowTypeCodes: number[] = [];
+  for (const s of stats) {
+    const key = typeKey(s.arrowType);
+    let code = typeIdMap.get(key);
+    if (code === undefined) {
+      code = typeOrder.length;
+      typeIdMap.set(key, code);
+      typeOrder.push(s.arrowType);
+    }
+    rowTypeCodes.push(code);
+  }
+
+  const unionFields: Field[] = [];
+  const minChildren: any[] = [];
+  const maxChildren: any[] = [];
+  const typeIds: number[] = [];
+
+  for (const [code, arrowType] of typeOrder.entries()) {
+    unionFields.push(new Field(String(code), arrowType as DataType, true));
+    typeIds.push(code);
+    const minVals = stats.map((s, i) => (rowTypeCodes[i] === code ? s.min : null));
+    const maxVals = stats.map((s, i) => (rowTypeCodes[i] === code ? s.max : null));
+    minChildren.push(buildTypedColumnData(minVals, arrowType));
+    maxChildren.push(buildTypedColumnData(maxVals, arrowType));
+  }
+
+  const unionType = new SparseUnion(typeIds, unionFields);
+  const typeIdsBuf = Int8Array.from(rowTypeCodes);
+
+  const minData = makeData({
+    type: unionType, length: stats.length, typeIds: typeIdsBuf, children: minChildren,
+  } as any);
+  const maxData = makeData({
+    type: unionType, length: stats.length, typeIds: typeIdsBuf, children: maxChildren,
+  } as any);
+
+  return assemble(
+    stats.map((s) => s.columnName),
+    minData,
+    maxData,
+    stats.map((s) => s.hasNull),
+    stats.map((s) => s.hasNotNull),
+    stats.map((s) => (s.distinctCount == null ? null : BigInt(s.distinctCount))),
+    stats.map((s) => s.containsUnicode),
+    stats.map((s) => (s.maxStringLength == null ? null : BigInt(s.maxStringLength))),
+    unionType,
+  ) as unknown as VgiBatch;
+}
+
+function assemble(
+  columnNames: string[],
+  minData: any,
+  maxData: any,
+  hasNull: boolean[],
+  hasNotNull: boolean[],
+  distinctCount: (bigint | null)[],
+  containsUnicode: (boolean | null)[],
+  maxStringLength: (bigint | null)[],
+  unionType: SparseUnion,
+): RecordBatch {
+  const schema = new Schema([
+    new Field("column_name", new Utf8(), false),
+    new Field("min", unionType, true),
+    new Field("max", unionType, true),
+    new Field("has_null", new Bool(), false),
+    new Field("has_not_null", new Bool(), false),
+    new Field("distinct_count", new Int64(), true),
+    new Field("contains_unicode", new Bool(), true),
+    new Field("max_string_length", new Uint64(), true),
+  ]);
+
+  const n = columnNames.length;
+  const children = [
+    buildTypedColumnData(columnNames, new Utf8() as unknown as VgiDataType),
+    minData,
+    maxData,
+    buildTypedColumnData(hasNull, new Bool() as unknown as VgiDataType),
+    buildTypedColumnData(hasNotNull, new Bool() as unknown as VgiDataType),
+    buildTypedColumnData(distinctCount, new Int64() as unknown as VgiDataType),
+    buildTypedColumnData(containsUnicode, new Bool() as unknown as VgiDataType),
+    buildTypedColumnData(maxStringLength, new Uint64() as unknown as VgiDataType),
+  ];
+
+  const structType = new Struct(schema.fields);
+  const data = makeData({ type: structType, length: n, children, nullCount: 0 });
+  return new RecordBatch(schema, data);
+}

package/src/arrow/impl-flechette/build.ts

@@ -0,0 +1,65 @@
+// Copyright 2025, 2026 Query Farm LLC - https://query.farm
+// Build batches from row objects or column arrays for the flechette backend.
+//
+// The public build path routes RICH author values through the codec registry
+// (rich -> canonical) and then through the per-backend canonical writer
+// (canonical -> flechette Column). All flechette-specific assembly now lives in
+// ./canonical.ts; this file is just the public shape.
+
+import {
+  columnFromArray as f_columnFromArray,
+} from "@query-farm/flechette";
+import type { VgiSchema, VgiBatch, VgiDataType, VgiColumnData } from "../types.js";
+import { emptyBatch } from "./empty.js";
+import { codecFor } from "../codec/registry.js";
+import { writeCanonicalBatch } from "./canonical.js";
+
+/**
+ * Build an opaque column-data handle from a JS array. Low-level pass-through
+ * for callers that already hold backend-native values; does NOT run the codec.
+ */
+export function columnFromArray(values: any[], type: VgiDataType): VgiColumnData {
+  return f_columnFromArray(values, type as any, {
+    useBigInt: true,
+    useBigIntTimestamp: true,
+    useDecimalInt: true,
+  }) as VgiColumnData;
+}
+
+/** Build a batch from row objects (values are RICH). */
+export function batchFromRows(
+  rows: Record<string, any>[],
+  schema: VgiSchema,
+): VgiBatch {
+  if (rows.length === 0) return emptyBatch(schema);
+  const columns: Record<string, any[]> = {};
+  for (const f of schema.fields) {
+    columns[f.name] = rows.map((r) => r[f.name] ?? null);
+  }
+  return batchFromColumns(columns, schema);
+}
+
+/**
+ * Build a batch from column arrays (values are RICH). Each column is converted
+ * rich -> canonical via the codec, then the canonical batch writer assembles
+ * the flechette Table (preserving per-field nullable + metadata).
+ */
+export function batchFromColumns(
+  columns: Record<string, any[]>,
+  schema: VgiSchema,
+  repr: "rich" | "raw" = "rich",
+): VgiBatch {
+  let numRows = 0;
+  for (const f of schema.fields) {
+    if (columns[f.name]) { numRows = columns[f.name].length; break; }
+  }
+  const canonicalColumns: Record<string, unknown[]> = {};
+  for (const f of schema.fields) {
+    const values = columns[f.name];
+    if (!values) continue;
+    const codec = codecFor(f.type as VgiDataType);
+    const toCanon = repr === "raw" ? codec.rawToCanonical : codec.richToCanonical;
+    canonicalColumns[f.name] = values.map((v) => toCanon.call(codec, v));
+  }
+  return writeCanonicalBatch(canonicalColumns, schema, numRows);
+}

package/src/arrow/impl-flechette/canonical.ts

@@ -0,0 +1,289 @@
+// Copyright 2025, 2026 Query Farm LLC - https://query.farm
+//
+// Canonical Arrow I/O for the flechette backend.
+//
+// The ONLY place in the flechette backend that knows flechette-specific
+// build/read details. Produces and consumes the SAME canonical representation
+// as impl-arrowjs/canonical.ts (see ../codec/registry.ts), so both backends
+// agree byte-for-byte.
+//
+// flechette's `columnFromArray` already handles the complex cases (List, Map,
+// Struct, Decimal, Timestamp[ns]) when given the right options, so the WRITE
+// side is mostly delegation. The one wrinkle is Date: flechette stores a Date
+// column correctly only when fed JS `Date` objects, but our canonical date32 is
+// a day-number and date64 is ms-bigint — so we convert canonical -> Date here.
+//
+// On the READ side, flechette's Column/Data `.at()` already decodes every
+// scalar to its canonical JS value LOSSLESSLY (timestamp/duration/time64 ->
+// bigint, decimal -> unscaled bigint with useDecimalInt) — UNLIKE arrow-js,
+// whose Vector.get() is lossy for timestamp. The only mismatch is Date, which
+// `.at()` returns as epoch-ms; we convert that to days (date32) / ms-bigint
+// (date64). Composites recurse so nested Date children are converted too.
+
+import {
+  columnFromArray as f_columnFromArray,
+  field as f_field,
+  Table,
+  type Column,
+} from "@query-farm/flechette";
+import type { VgiSchema, VgiBatch, VgiDataType, VgiColumnData, TaggedUnion } from "../types.js";
+import { toFlechetteType } from "./normalize-type.js";
+
+const MS_PER_DAY = 86_400_000;
+
+const COLUMN_OPTS = {
+  useBigInt: true,
+  useBigIntTimestamp: true,
+  useDecimalInt: true,
+} as const;
+
+// ===========================================================================
+// WRITE: canonical[] -> flechette Column
+// ===========================================================================
+
+/** Build a flechette `Column` from an array of CANONICAL values for `type`. */
+export function writeCanonicalColumn(
+  type: VgiDataType,
+  canonical: unknown[],
+): VgiColumnData {
+  const ftype = toFlechetteType(type);
+  return f_columnFromArray(prepareForFlechette(type, canonical), ftype, COLUMN_OPTS) as VgiColumnData;
+}
+
+/**
+ * Build a whole batch (Table) from canonical column arrays. Kept here so the
+ * per-field `nullable` flag and metadata are preserved on the output schema
+ * (tableFromColumns would drop them, which the C++ extension rejects).
+ */
+export function writeCanonicalBatch(
+  columns: Record<string, unknown[]>,
+  schema: VgiSchema,
+  numRows: number,
+): VgiBatch {
+  const childCols: Column<any>[] = [];
+  const fields: any[] = [];
+  for (const f of schema.fields) {
+    const ftype = toFlechetteType(f.type);
+    const values = columns[f.name];
+    const col: Column<any> = values
+      ? f_columnFromArray(prepareForFlechette(f.type, values), ftype, COLUMN_OPTS)
+      : f_columnFromArray(new Array(numRows).fill(null), ftype, COLUMN_OPTS);
+    childCols.push(col);
+    const nullable = (f as any).nullable ?? true;
+    const metadata = (f as any).metadata ?? null;
+    fields.push(f_field(f.name, col.type as any, nullable, metadata));
+  }
+  const flechSchema = {
+    version: 5,
+    endianness: 0,
+    fields,
+    metadata: (schema as any).metadata ?? null,
+  };
+  return new Table(flechSchema as any, childCols) as unknown as VgiBatch;
+}
+
+/**
+ * Convert canonical values into the shape flechette's columnFromArray needs.
+ * Date columns: canonical day-number / ms-bigint -> JS Date. Map columns:
+ * canonical Array<[k,v]> -> Map. Struct/List recurse. Everything else passes
+ * through.
+ */
+export function prepareForFlechette(type: VgiDataType, values: unknown[]): unknown[] {
+  const tid = type.typeId;
+  if (tid === 8) {
+    const isDay = (type as any).unit === 0;
+    return values.map((v) => {
+      if (v == null) return null;
+      if (v instanceof Date) return v;
+      const n = typeof v === "bigint" ? Number(v) : (v as number);
+      return new Date(isDay ? n * MS_PER_DAY : n);
+    });
+  }
+  if (tid === 17) {
+    return values.map((v) => {
+      if (v == null) return null;
+      if (v instanceof Map) return v;
+      if (Array.isArray(v)) return new Map(v as Array<[unknown, unknown]>);
+      if (typeof v === "object") return new Map(Object.entries(v as any));
+      return v;
+    });
+  }
+  if (tid === 13) {
+    const children = (type as any).children as Array<{ name: string; type: VgiDataType }>;
+    if (children.some((c) => needsPrepare(c.type))) {
+      return values.map((row) => {
+        if (row == null) return null;
+        const out: Record<string, unknown> = {};
+        for (const c of children) {
+          out[c.name] = prepareForFlechette(c.type, [(row as any)[c.name] ?? null])[0];
+        }
+        return out;
+      });
+    }
+    return values;
+  }
+  if (tid === 12 || tid === 16) {
+    const childType = (type as any).children?.[0]?.type as VgiDataType;
+    if (childType && needsPrepare(childType)) {
+      return values.map((row) => {
+        if (row == null) return null;
+        const items = Array.isArray(row) ? row : Array.from(row as Iterable<unknown>);
+        return prepareForFlechette(childType, items);
+      });
+    }
+    return values;
+  }
+  return values;
+}
+
+function needsPrepare(type: VgiDataType): boolean {
+  const tid = type.typeId;
+  if (tid === 8 || tid === 17) return true;
+  if (tid === 13) return ((type as any).children ?? []).some((c: any) => needsPrepare(c.type));
+  if (tid === 12 || tid === 16) {
+    const ct = (type as any).children?.[0]?.type;
+    return ct ? needsPrepare(ct) : false;
+  }
+  return false;
+}
+
+// ===========================================================================
+// READ: flechette column + index -> canonical value
+// ===========================================================================
+
+/** Read a single CANONICAL value at `index` from a flechette Column. */
+export function readCanonicalValue(
+  type: VgiDataType,
+  column: unknown,
+  index: number,
+): unknown {
+  const tid = type.typeId;
+  // Struct and Union must be read column-based: flechette's `.at()` collapses a
+  // union to only its member value (dropping the discriminator), and a struct
+  // wrapping a union would inherit that loss. Reading the child Data nodes
+  // directly preserves the union tag for any nesting depth.
+  if (tid === 13) return readStructColumn(type, column, index);
+  if (tid === 14) return readUnionColumn(type, column, index);
+  const at = (column as any)?.at?.(index);
+  return canonicalize(type, at);
+}
+
+/** Child Data nodes for a flechette Column/Data. A top-level Column exposes
+ *  `.data[0]`; a nested child is already a Data node carrying `.children`. */
+function childData(column: any): any {
+  return column?.children ? column : column?.data?.[0];
+}
+
+/** True when row `index` is null per the Data node's validity bitmap. */
+function isNullAt(data: any, index: number): boolean {
+  if ((data?.nullCount ?? 0) === 0) return false;
+  const validity: Uint8Array | undefined = data?.validity;
+  if (!validity || validity.length === 0) return false;
+  return ((validity[index >> 3] >> (index & 7)) & 1) === 0;
+}
+
+/** Read a struct column-based so nested union children keep their tags. */
+function readStructColumn(
+  type: VgiDataType,
+  column: unknown,
+  index: number,
+): Record<string, unknown> | null {
+  const col: any = column;
+  const data = childData(col);
+  if (!data?.children) {
+    // No structural access: fall back to value-based canonicalization.
+    return canonicalize(type, col?.at?.(index)) as Record<string, unknown> | null;
+  }
+  // A null struct row has no member values to read.
+  if (isNullAt(data, index)) return null;
+  const children = (type as any).children as Array<{ name: string; type: VgiDataType }>;
+  const out: Record<string, unknown> = {};
+  for (let c = 0; c < children.length; c++) {
+    out[children[c].name] = readCanonicalValue(children[c].type, data.children[c], index);
+  }
+  return out;
+}
+
+/** Read a union column-based into a TaggedUnion, recovering the active tag. */
+function readUnionColumn(
+  type: VgiDataType,
+  column: unknown,
+  index: number,
+): TaggedUnion {
+  const children = (type as any).children as Array<{ name: string; type: VgiDataType }>;
+  const data = childData(column);
+  if (data && isNullAt(data, index)) return { tag: null, value: null };
+  // Per-row type code -> child index. DuckDB emits SPARSE unions: each child is
+  // full-length and aligned with the parent row.
+  const typeIds: ArrayLike<number> | undefined = data?.typeIds;
+  const tcode = typeIds ? typeIds[index] : children.length > 0 ? 0 : -1;
+  const map = (type as any).typeMap as Record<number, number> | undefined;
+  const childIdx = map && map[tcode] !== undefined ? map[tcode] : tcode;
+  const childField = children[childIdx];
+  if (!childField || !data?.children) return { tag: null, value: null };
+  // Dense unions remap the row via offsets; sparse unions share the row index.
+  const offsets: ArrayLike<number> | undefined = data?.offsets;
+  const isDense = (type as any).mode === 1;
+  const childRow = isDense && offsets ? offsets[index] : index;
+  const value = readCanonicalValue(childField.type, data.children[childIdx], childRow);
+  return { tag: childField.name, value };
+}
+
+/**
+ * Normalize a flechette-decoded value (from Column/Data `.at()`) into the
+ * canonical representation. `.at()` already produces canonical for every
+ * scalar except Date; composites recurse so nested Dates are handled.
+ */
+function canonicalize(type: VgiDataType, value: unknown): unknown {
+  if (value === null || value === undefined) return null;
+  const tid = type.typeId;
+  switch (tid) {
+    case 8: { // Date: .at() returns epoch-ms number
+      const ms = value instanceof Date ? value.getTime()
+        : typeof value === "bigint" ? Number(value) : (value as number);
+      if ((type as any).unit === 0) return Math.round(ms / MS_PER_DAY); // date32 -> days
+      return BigInt(ms);                                                // date64 -> ms bigint
+    }
+    case 4: // Binary
+    case 19: // LargeBinary
+    case 15: // FixedSizeBinary
+      return toUint8(value);
+    case 13: { // Struct -> { field: canonical }
+      const children = (type as any).children as Array<{ name: string; type: VgiDataType }>;
+      const obj = value as any;
+      const out: Record<string, unknown> = {};
+      for (const c of children) out[c.name] = canonicalize(c.type, obj[c.name] ?? null);
+      return out;
+    }
+    case 12: // List
+    case 16: { // FixedSizeList -> canonical[]
+      const childType = (type as any).children[0].type as VgiDataType;
+      const arr = Array.isArray(value) ? value : Array.from(value as Iterable<unknown>);
+      return arr.map((v) => canonicalize(childType, v));
+    }
+    case 17: { // Map -> Array<[k,v]>
+      const entries = (type as any).children[0].type.children;
+      const keyType = entries[0].type as VgiDataType;
+      const valueType = entries[1].type as VgiDataType;
+      const pairs: Array<[unknown, unknown]> = value instanceof Map ? Array.from(value.entries())
+        : Array.isArray(value) ? (value as Array<[unknown, unknown]>)
+        : Object.entries(value as Record<string, unknown>);
+      return pairs.map(([k, v]) => [canonicalize(keyType, k), canonicalize(valueType, v)]);
+    }
+    case -1: // Dictionary -> decoded value's canonical
+      return canonicalize((type as any).dictionary as VgiDataType, value);
+    default:
+      // bool/int/float/utf8/decimal/time/timestamp/duration: already canonical.
+      return value;
+  }
+}
+
+function toUint8(v: any): Uint8Array | null {
+  if (v == null) return null;
+  if (v instanceof Uint8Array) return v;
+  if (ArrayBuffer.isView(v)) {
+    const view = v as ArrayBufferView;
+    return new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+  }
+  return v;
+}

package/src/arrow/impl-flechette/empty.ts

@@ -0,0 +1,20 @@
+// Copyright 2025, 2026 Query Farm LLC - https://query.farm
+// Empty (0-row) batch construction for the flechette backend.
+
+import { columnFromArray, tableFromColumns } from "@query-farm/flechette";
+import type { VgiSchema, VgiBatch } from "../types.js";
+
+/**
+ * Create an empty (0-row) batch with the given schema.
+ *
+ * For each field we build a 0-length column of the matching type. flechette
+ * handles complex types (List, Map, Struct, Decimal) without the manual
+ * makeData scaffolding the arrow-js backend needs.
+ */
+export function emptyBatch(schema: VgiSchema): VgiBatch {
+  const cols: Record<string, ReturnType<typeof columnFromArray>> = {};
+  for (const f of schema.fields) {
+    cols[f.name] = columnFromArray([], f.type as any);
+  }
+  return tableFromColumns(cols) as unknown as VgiBatch;
+}

package/src/arrow/impl-flechette/filter.ts

@@ -0,0 +1,42 @@
+// Copyright 2025, 2026 Query Farm LLC - https://query.farm
+// Mask-based row filtering for flechette tables.
+
+import type { VgiBatch, VgiDataType } from "../types.js";
+import { emptyBatch } from "./empty.js";
+import { batchFromColumns } from "./build.js";
+import { codecFor } from "../codec/registry.js";
+import { readCanonicalValue } from "./canonical.js";
+
+/**
+ * Filter a batch using a Uint8Array mask (0=exclude, nonzero=include).
+ *
+ * Rows are read in canonical form then mapped back to RICH so the rebuild goes
+ * through the same codec/canonical path as every other column build — lossless,
+ * Date-correct (flechette `.at()` returns epoch-ms for dates), and identical to
+ * the arrow-js backend.
+ */
+export function filterBatch(batch: VgiBatch, mask: Uint8Array): VgiBatch {
+  const t = batch as any;
+  const n = t.numRows;
+
+  let passCount = 0;
+  for (let i = 0; i < n; i++) if (mask[i]) passCount++;
+
+  if (passCount === n) return batch;
+  if (passCount === 0) return emptyBatch(t.schema);
+
+  const indices: number[] = [];
+  for (let i = 0; i < n; i++) if (mask[i]) indices.push(i);
+
+  const columns: Record<string, any[]> = {};
+  for (const f of t.schema.fields) {
+    const col = t.getChild(f.name);
+    if (!col) continue;
+    const type = f.type as VgiDataType;
+    const codec = codecFor(type);
+    columns[f.name] = indices.map((i) =>
+      codec.canonicalToRich(readCanonicalValue(type, col, i)),
+    );
+  }
+  return batchFromColumns(columns, t.schema);
+}

package/src/arrow/impl-flechette/index.ts

@@ -0,0 +1,54 @@
+// Copyright 2025, 2026 Query Farm LLC - https://query.farm
+// flechette backend for the vgi-typescript Arrow facade.
+// Selected via `#arrow-impl` resolution under the workerd / worker / browser
+// conditions. The Bun worker keeps using the arrow-js backend (default).
+
+import type { VgiBackendInfo } from "../types.js";
+
+export const backend: VgiBackendInfo = { name: "flechette" };
+
+// Schema / Field / DataType factories
+export {
+  schema,
+  field,
+  nullType,
+  bool,
+  int,
+  int8, int16, int32, int64,
+  uint8, uint16, uint32, uint64,
+  float16, float32, float64,
+  utf8, binary, fixedSizeBinary,
+  decimal, decimal128, decimal256,
+  date, dateDay, dateMillisecond,
+  time, timeSecond, timeMillisecond, timeMicrosecond, timeNanosecond,
+  timestamp, duration, interval,
+  list, fixedSizeList, struct, map,
+  dictionary,
+  union, sparseUnion, denseUnion,
+  TimeUnit, DateUnit, IntervalUnit, UnionMode,
+} from "./schema.js";
+
+// Batch construction / iteration / utilities
+export { emptyBatch } from "./empty.js";
+export { batchFromRows, batchFromColumns, columnFromArray } from "./build.js";
+export {
+  iterRows,
+  batchToScalarDict,
+  batchToSecretDict,
+  safeNumber,
+  decodeDictValue,
+} from "./iterate.js";
+export { filterBatch } from "./filter.js";
+export { projectSchema, projectBatch } from "./project.js";
+export { readCanonicalValue } from "./canonical.js";
+
+// IPC
+export {
+  serializeSchema,
+  deserializeSchema,
+  serializeBatch,
+  deserializeBatch,
+} from "./ipc.js";
+
+// Column statistics — sparse-union min/max via the codec/canonical path.
+export { buildStatisticsBatch, type ColumnStatistics } from "./statistics.js";