@query-farm/vgi 0.20.0 → 0.22.0

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

@@ -52,6 +52,7 @@ import {
 } from "@query-farm/flechette";
 
 import type { VgiField, VgiSchema, VgiDataType } from "../types.js";
+import { aliasIntSigned } from "./arrowjs-shape.js";
 
 // ----- Unit / mode constants -----------------------------------------------
 
@@ -91,16 +92,19 @@ export function field(
 export const nullType = (): VgiDataType => f_nullType() as unknown as VgiDataType;
 export const bool = (): VgiDataType => f_bool() as unknown as VgiDataType;
 
-export const int8 = (): VgiDataType => f_int8() as unknown as VgiDataType;
-export const int16 = (): VgiDataType => f_int16() as unknown as VgiDataType;
-export const int32 = (): VgiDataType => f_int32() as unknown as VgiDataType;
-export const int64 = (): VgiDataType => f_int64() as unknown as VgiDataType;
-export const uint8 = (): VgiDataType => f_uint8() as unknown as VgiDataType;
-export const uint16 = (): VgiDataType => f_uint16() as unknown as VgiDataType;
-export const uint32 = (): VgiDataType => f_uint32() as unknown as VgiDataType;
-export const uint64 = (): VgiDataType => f_uint64() as unknown as VgiDataType;
+// Int types carry the `isSigned` alias (arrow-js's spelling of flechette's
+// `signed`) so worker code that branches on signedness reads the same property
+// on both backends — see ./compat.ts.
+export const int8 = (): VgiDataType => aliasIntSigned(f_int8()) as unknown as VgiDataType;
+export const int16 = (): VgiDataType => aliasIntSigned(f_int16()) as unknown as VgiDataType;
+export const int32 = (): VgiDataType => aliasIntSigned(f_int32()) as unknown as VgiDataType;
+export const int64 = (): VgiDataType => aliasIntSigned(f_int64()) as unknown as VgiDataType;
+export const uint8 = (): VgiDataType => aliasIntSigned(f_uint8()) as unknown as VgiDataType;
+export const uint16 = (): VgiDataType => aliasIntSigned(f_uint16()) as unknown as VgiDataType;
+export const uint32 = (): VgiDataType => aliasIntSigned(f_uint32()) as unknown as VgiDataType;
+export const uint64 = (): VgiDataType => aliasIntSigned(f_uint64()) as unknown as VgiDataType;
 export const int = (bitWidth: 8 | 16 | 32 | 64 = 32, signed = true): VgiDataType =>
-  f_int(bitWidth, signed) as unknown as VgiDataType;
+  aliasIntSigned(f_int(bitWidth, signed)) as unknown as VgiDataType;
 
 export const float16 = (): VgiDataType => f_float16() as unknown as VgiDataType;
 export const float32 = (): VgiDataType => f_float32() as unknown as VgiDataType;

package/src/arrow/index.ts

@@ -44,6 +44,7 @@ export {
   isDuration,
   isDictionary,
   isBatch,
+  typeSignature,
 } from "./predicates.js";
 
 // Active backend's surface (IPC, build, iterate, utilities).
@@ -55,6 +56,8 @@ export {
   filterBatch, projectSchema, projectBatch,
   // per-record-batch metadata attachment
   withBatchMetadata,
+  // arrow-js method shape for batches decoded outside this module's backend copy
+  adoptArrowJsShape,
   // canonical single-value read (backend-agnostic, lossless)
   readCanonicalValue,
   // IPC

package/src/arrow/predicates.ts

@@ -53,6 +53,65 @@ export function isMap(t: VgiDataType): boolean { return t.typeId === TypeId.Map;
 export function isDuration(t: VgiDataType): boolean { return t.typeId === TypeId.Duration; }
 export function isDictionary(t: VgiDataType): boolean { return t.typeId === TypeId.Dictionary; }
 
+/**
+ * Stable structural identity for an Arrow type, usable for equality.
+ *
+ * `String(type)` is NOT usable for this: arrow-js DataTypes are class
+ * instances with a meaningful `toString()` ("Int64", "Utf8", …), while
+ * flechette types are plain object literals that stringify to
+ * "[object Object]". Comparing with `toString()` therefore reports *every*
+ * flechette type as equal to every other, and never equal to a declared
+ * arrow-js type — which collapsed overload resolution to a first-match tie
+ * (`type_info(42::BIGINT)` picked the INTEGER overload).
+ *
+ * Both libraries agree on `typeId` and on the parameter *values*; they differ
+ * only on a few property names, so those are read under both spellings. The
+ * output is an opaque key — compare it, don't display it.
+ */
+export function typeSignature(t: VgiDataType | null | undefined): string {
+  if (t == null) return "null";
+  const a = t as any;
+  const kids = (): string =>
+    Array.isArray(a.children)
+      ? a.children.map((c: any) => `${c?.name ?? ""}:${typeSignature(c?.type ?? c)}`).join(",")
+      : "";
+  switch (t.typeId) {
+    case TypeId.Int:
+      return `int${a.bitWidth}${(a.isSigned ?? a.signed ?? true) ? "" : "u"}`;
+    case TypeId.Float:
+      return `float${a.precision}`;
+    case TypeId.Decimal:
+      return `decimal${a.bitWidth ?? 128}(${a.precision},${a.scale})`;
+    case TypeId.Date:
+    case TypeId.Time:
+    case TypeId.Duration:
+      return `${t.typeId}[${a.unit}]`;
+    case TypeId.Timestamp:
+      return `ts[${a.unit},${a.timezone ?? ""}]`;
+    case TypeId.Interval:
+      return `iv[${a.unit}]`;
+    case TypeId.FixedSizeBinary:
+      return `fsb(${a.byteWidth ?? a.stride})`;
+    case TypeId.FixedSizeList:
+      return `fsl(${a.listSize ?? a.stride},${kids()})`;
+    case TypeId.List:
+    case TypeId.Struct:
+    case TypeId.Map:
+      return `${t.typeId}<${kids()}>`;
+    case TypeId.Union:
+      return `union(${a.mode},${kids()})`;
+    case TypeId.Dictionary:
+      return `dict(${typeSignature(a.dictionary)},${typeSignature(a.indices)},${
+        a.ordered ?? a.isOrdered ?? false
+      })`;
+    default:
+      // Covers the parameterless types (Null, Bool, Utf8, Binary and their
+      // Large variants) plus anything not enumerated above; children are
+      // folded in when present so a nested type still differentiates.
+      return Array.isArray(a.children) ? `${t.typeId}<${kids()}>` : String(t.typeId);
+  }
+}
+
 /** Runtime check: does `x` quack like a VgiBatch? Used at API boundaries
  *  where callers may pass either a batch or a plain column dict. Duck-typed
  *  because arrow-js and flechette use unrelated classes. */

package/src/cache-control.ts

@@ -41,6 +41,8 @@ export const CACHE_REVALIDATABLE_KEY = "vgi.cache.revalidatable";
 export const CACHE_STALE_WHILE_REVALIDATE_KEY = "vgi.cache.stale_while_revalidate";
 export const CACHE_STALE_IF_ERROR_KEY = "vgi.cache.stale_if_error";
 export const CACHE_NOT_MODIFIED_KEY = "vgi.cache.not_modified";
+export const CACHE_PARTITION_SCOPE_KEY = "vgi.cache.partition_scope";
+export const CACHE_PER_VALUE_KEY = "vgi.cache.per_value";
 
 // --- Request-side metadata keys (client -> worker) --------------------------
 // Ride on the first producer tick; surfaced as `TableProcessParams.ifNoneMatch`
@@ -91,6 +93,37 @@ export interface CacheControl {
    *  assert the client's stored payload is still fresh (the client reuses it
    *  instead of re-streaming). */
   notModified?: boolean;
+  /** Opt in to per-PARTITION caching: in addition to the whole-scan entry, the
+   *  client stores the result split by distinct partition tuple, so a later
+   *  `=`/`IN`-filtered scan on the partition column(s) can serve the requested
+   *  partitions without calling the worker. Only meaningful for a
+   *  `SINGLE_VALUE_PARTITIONS` table function; purely additive. */
+  partitionScope?: boolean;
+  /**
+   * Opt in to per-VALUE memoization: in addition to the whole-result entry, the
+   * client memoizes each distinct worker-input tuple's output keyed on that
+   * tuple, so the same value is served without calling the worker on a later
+   * chunk or a later query. Only meaningful for an exchange-mode MAP — a
+   * scalar, or a blended table-in-out invoked through a correlated `LATERAL`.
+   *
+   * **Default off, and it should stay off unless one call is genuinely
+   * expensive.** This is not a free win: serving a value from the memo costs a
+   * key probe, a decode and a per-value assembly step, and that only pays back
+   * when it is cheaper than asking you for the answer. For a cheap map —
+   * arithmetic, a string tweak, a lookup in a table the worker already has in
+   * memory — it is a large net loss (the engine measures a per-value serve at
+   * roughly 50x the cost of just calling the worker for a simple arithmetic
+   * map). Only the function author knows which side of that line a call falls
+   * on, which is why the engine will not guess: turn it on for model
+   * inference, geocoding, an external API call, or anything rate-limited or
+   * billed per request.
+   *
+   * Independent of freshness: `ttl`/`expires` make a result cacheable at all,
+   * while this decides whether the per-value tier is additionally populated.
+   * Requires a deterministic, side-effect-free function, exactly like the rest
+   * of the result cache.
+   */
+  perValue?: boolean;
 }
 
 const VALID_SCOPES: readonly string[] = [CACHE_SCOPE_CATALOG, CACHE_SCOPE_TRANSACTION];
@@ -129,5 +162,7 @@ export function cacheControlMetadata(cc: CacheControl, extra?: Map<string, strin
   if (cc.staleWhileRevalidate !== undefined) md.set(CACHE_STALE_WHILE_REVALIDATE_KEY, String(cc.staleWhileRevalidate));
   if (cc.staleIfError !== undefined) md.set(CACHE_STALE_IF_ERROR_KEY, String(cc.staleIfError));
   if (cc.notModified) md.set(CACHE_NOT_MODIFIED_KEY, "1");
+  if (cc.partitionScope) md.set(CACHE_PARTITION_SCOPE_KEY, "1");
+  if (cc.perValue) md.set(CACHE_PER_VALUE_KEY, "1");
   return md;
 }

package/src/catalog/composite.ts

@@ -56,6 +56,15 @@ export class CompositeCatalogInterface extends CatalogInterface {
     return route;
   }
 
+  /** Route to the owning backend and ask it, so the answer is per-attachment. */
+  override catalogNameForAttach(attachOpaqueData: Uint8Array): string | null {
+    try {
+      return this._route(attachOpaqueData).catalogNameForAttach(attachOpaqueData);
+    } catch {
+      return null; // Unroutable attach — fall back to unscoped resolution.
+    }
+  }
+
   catalogs(): string[] {
     const all: string[] = [];
     for (const b of this._backends) all.push(...b.catalogs());

package/src/catalog/interface.ts

@@ -365,6 +365,21 @@ function isPromise<T>(v: Awaitable<T>): v is Promise<T> {
 }
 
 export abstract class CatalogInterface {
+  /**
+   * Which catalog an `attach_opaque_data` belongs to, or null if unknown.
+   *
+   * Two catalogs served by one worker may declare the same schema *and*
+   * function name, in which case the attachment is the only thing that tells
+   * them apart — the bind path uses this to scope function resolution. The
+   * default answers from `catalogs()` when this interface owns exactly one,
+   * which is right for every single-catalog implementation; the composite
+   * overrides it to route by its backend index byte.
+   */
+  catalogNameForAttach(_attachOpaqueData: Uint8Array): string | null {
+    const names = this.catalogs();
+    return names.length === 1 ? names[0] : null;
+  }
+
   // Required overrides
   abstract catalogs(): string[];
   /**

package/src/catalog/read-only.ts

@@ -38,6 +38,19 @@ export class ReadOnlyCatalogInterface extends CatalogInterface {
     super();
     this._descriptor = descriptor;
     this._registry = registry;
+    // Index every function this catalog declares by its owning schema, so a
+    // schema-qualified bind resolves to the right implementation when one name
+    // is declared in more than one schema. Table-backing functions are indexed
+    // under their table's schema for the same reason.
+    for (const sch of descriptor.schemas ?? []) {
+      for (const fn of sch.functions ?? []) registry.registerInSchema(fn, sch.name, descriptor.name);
+      for (const tbl of sch.tables ?? []) {
+        for (const key of ["function", "insertFunction", "updateFunction", "deleteFunction"] as const) {
+          const fn = (tbl as any)[key];
+          if (fn) registry.registerInSchema(fn, sch.name, descriptor.name);
+        }
+      }
+    }
   }
 
   catalogs(): string[] {

package/src/functions/registry.ts

@@ -1,7 +1,11 @@
 // Copyright 2025, 2026 Query Farm LLC - https://query.farm
 // Function registry: name -> VgiFunction lookup with overload resolution.
 
-import { type VgiDataType, isBinary, isBool, isDecimal, isFloat, isInt, isNull, isUtf8 } from "../arrow/index.js";
+import {
+  type VgiDataType,
+  isBinary, isBool, isDecimal, isFloat, isInt, isNull, isUtf8,
+  typeSignature,
+} from "../arrow/index.js";
 import type { VgiSchema } from "../arrow/index.js";
 import type { VgiFunction } from "./types.js";
 import type { Arguments } from "../arguments/arguments.js";
@@ -12,13 +16,40 @@ export interface OverloadContext {
   arguments?: Arguments;
   inputSchema?: VgiSchema | null;
   isScalar?: boolean;
+  /**
+   * Catalog schema that declares the function, from `BindRequest.schema_name`.
+   * A worker may register the same name in more than one schema, so the bare
+   * name is not a unique key. When set, resolution is scoped to that schema and
+   * never falls back to another one; when absent, every schema is searched.
+   */
+  schemaName?: string | null;
+  /**
+   * Catalog that owns the function, resolved from the bind's
+   * `attach_opaque_data`. Two catalogs served by one worker may each declare
+   * the same schema *and* function name, in which case only the catalog tells
+   * them apart. Absent for calls with no attachment.
+   */
+  catalogName?: string | null;
 }
 
 const EXACT_MATCH_SCORE = 2;
 const FAMILY_MATCH_SCORE = 1;
 
+/**
+ * Exact structural type identity.
+ *
+ * `toString()` cannot be used: arrow-js DataTypes stringify to a meaningful
+ * name, flechette's plain-object types all stringify to "[object Object]".
+ * Under flechette that made every exact-match test fail, every overload score
+ * collapse to the family tie, and `type_info(42::BIGINT)` resolve to the
+ * INTEGER overload.
+ */
+function typesIdentical(a: VgiDataType, b: VgiDataType): boolean {
+  return typeSignature(a) === typeSignature(b);
+}
+
 function typesCompatible(actual: VgiDataType, declared: VgiDataType): boolean {
-  if (actual.toString() === declared.toString()) return true;
+  if (typesIdentical(actual, declared)) return true;
   // Integer family
   if (isInt(actual) && isInt(declared)) return true;
   // Float/decimal family
@@ -47,7 +78,7 @@ function scoreTypes(
     if (spec.isAnyType || isNull(spec.arrowType)) continue;
     const actual = actualTypes[i];
     if (actual === null) continue;
-    if (actual.toString() === spec.arrowType.toString()) {
+    if (typesIdentical(actual, spec.arrowType)) {
       score += EXACT_MATCH_SCORE;
     } else if (typesCompatible(actual, spec.arrowType)) {
       score += FAMILY_MATCH_SCORE;
@@ -61,7 +92,7 @@ function scoreTypes(
     for (let i = specs.length; i < actualTypes.length; i++) {
       const actual = actualTypes[i];
       if (actual === null) continue;
-      if (actual.toString() === varArgsSpec.arrowType.toString()) {
+      if (typesIdentical(actual, varArgsSpec.arrowType)) {
         score += EXACT_MATCH_SCORE;
       } else if (typesCompatible(actual, varArgsSpec.arrowType)) {
         score += FAMILY_MATCH_SCORE;
@@ -173,8 +204,26 @@ function filterByArgumentTypes(
   return scored.filter(s => s.score === maxScore).map(s => s.func);
 }
 
+/** Key for the schema-scoped index: lowercased schema, then function name. */
+function schemaKey(schemaName: string, functionName: string): string {
+  return `${schemaName.toLowerCase()}\u0000${functionName}`;
+}
+
+/** Key for the catalog-scoped index: lowercased catalog, then the schema key. */
+function catalogKey(catalogName: string, schemaName: string, functionName: string): string {
+  return `${catalogName.toLowerCase()}\u0000${schemaKey(schemaName, functionName)}`;
+}
+
 export class FunctionRegistry {
   private _functions: Map<string, VgiFunction[]> = new Map();
+  // (lowercased schema, function name) -> functions declared in that schema.
+  // Populated by registerInSchema(), which catalog construction calls for every
+  // function a SchemaDescriptor lists. Lets a schema-qualified bind pick the
+  // right implementation when one name is registered in several schemas.
+  private _bySchema: Map<string, VgiFunction[]> = new Map();
+  // (lowercased catalog, lowercased schema, function name) -> functions. Needed
+  // because two catalogs in one worker may declare the same schema AND name.
+  private _byCatalog: Map<string, VgiFunction[]> = new Map();
 
   register(func: VgiFunction): void {
     const name = func.meta.name;
@@ -184,12 +233,85 @@ export class FunctionRegistry {
     this._functions.get(name)!.push(func);
   }
 
+  /**
+   * Record that `func` is declared in `schemaName`, in addition to the flat
+   * by-name index. Idempotent, and independent of `register()` so a function
+   * reachable from several schemas (e.g. a scan function referenced by tables in
+   * more than one schema) resolves from any of them.
+   */
+  registerInSchema(func: VgiFunction, schemaName: string, catalogName?: string): void {
+    const add = (map: Map<string, VgiFunction[]>, key: string) => {
+      const bucket = map.get(key);
+      if (!bucket) {
+        map.set(key, [func]);
+        return;
+      }
+      if (!bucket.includes(func)) bucket.push(func);
+    };
+    add(this._bySchema, schemaKey(schemaName, func.meta.name));
+    if (catalogName) {
+      add(this._byCatalog, catalogKey(catalogName, schemaName, func.meta.name));
+    }
+  }
+
+  /** Schemas that declare `functionName`, sorted — for error messages. */
+  schemasFor(functionName: string): string[] {
+    const out: string[] = [];
+    for (const key of this._bySchema.keys()) {
+      const [schema, name] = key.split("\u0000");
+      if (name === functionName) out.push(schema);
+    }
+    return out.sort();
+  }
+
   get(name: string, context?: OverloadContext): VgiFunction {
-    const candidates = this._functions.get(name);
+    let candidates = this._functions.get(name);
+
+    // A schema-qualified lookup is exact: only functions declared in that schema
+    // are candidates, so a name registered in two schemas dispatches to the one
+    // the caller named rather than colliding as an overload.
+    // Catalog first: it is the only key that separates two catalogs declaring
+    // the same schema and name.
+    const catalogName = context?.catalogName;
+    const schemaName = context?.schemaName;
+    if (catalogName && schemaName) {
+      const scoped = this._byCatalog.get(catalogKey(catalogName, schemaName, name));
+      if (scoped && scoped.length > 0) {
+        return this._disambiguate(name, scoped, context);
+      }
+    }
+    if (schemaName) {
+      const scoped = this._bySchema.get(schemaKey(schemaName, name));
+      if (scoped && scoped.length > 0) {
+        candidates = scoped;
+      } else if (candidates && candidates.length > 0) {
+        const schemas = this.schemasFor(name);
+        if (schemas.length > 0) {
+          throw new Error(
+            `Function '${name}' is not registered in schema '${schemaName}'. ` +
+              `It is available in: [${schemas.join(", ")}]`,
+          );
+        }
+      }
+    }
+
     if (!candidates || candidates.length === 0) {
       throw new FunctionNotFoundError(name, this.names());
     }
 
+    return this._disambiguate(name, candidates, context);
+  }
+
+  /**
+   * Pick one function from an already-scoped candidate list, by argument shape
+   * and types. Scoping (catalog / schema) happens in `get()`; by the time this
+   * runs, every candidate is a legitimate overload of the same name.
+   */
+  private _disambiguate(
+    name: string,
+    candidates: VgiFunction[],
+    context?: OverloadContext,
+  ): VgiFunction {
     // Fast path: single candidate
     if (candidates.length === 1) {
       return candidates[0];

package/src/functions/scalar.ts

@@ -185,10 +185,14 @@ export interface ScalarFunctionConfig<
   /**
    * Result-cache opt-in: when set, this CacheControl's `vgi.cache.*` metadata
    * rides every output batch's custom metadata (per-batch — NOT the schema,
-   * which the IPC stream fixes at open), so the extension can memoize the
-   * scalar's output per distinct input value. A pure, deterministic scalar
-   * only — advertising this on a non-pure scalar serves stale rows. Mirrors
+   * which the IPC stream fixes at open). A pure, deterministic scalar only —
+   * advertising this on a non-pure scalar serves stale rows. Mirrors
    * vgi-python's `ScalarFunction.CACHE_CONTROL`.
+   *
+   * Per-VALUE memoization (the extension remembering one output per distinct
+   * input value) additionally requires `perValue: true`, which is off by
+   * default because a memo serve only beats a worker call when the call is
+   * expensive — see {@link CacheControl.perValue}.
    */
   cacheControl?: CacheControl;
 }
@@ -405,8 +409,9 @@ export function defineScalarFunction<
           }
 
           // Result-cache opt-in: a scalar declaring cacheControl rides its
-          // vgi.cache.* keys on the emit path's per-batch custom metadata so
-          // the extension can memoize the output per distinct input value.
+          // vgi.cache.* keys on the emit path's per-batch custom metadata. The
+          // per-value memo tier is only populated when that CacheControl also
+          // sets `perValue` (default off — it costs more than a cheap call).
           out.emit(
             outputBatch,
             config.cacheControl ? cacheControlMetadata(config.cacheControl) : undefined,

package/src/generated/vgi-client.ts

@@ -2,7 +2,7 @@
 // GENERATED by vgi.codegen.ts_client. DO NOT EDIT BY HAND.
 //
 // Generator: vgi-gen-ts-client v1
-// Content hash: 226553bd666c
+// Content hash: 80ec56060e88
 //
 // To regenerate:
 //   uv run --project ~/Development/vgi-python vgi-gen-ts-client \
@@ -174,6 +174,7 @@ export interface AggregateBindRequest {
   settings?: /** @record-batch */ Uint8Array | null;
   secrets?: /** @record-batch */ Uint8Array | null;
   attach_opaque_data?: Uint8Array | null;
+  schema_name?: string | null;
 }
 
 export interface AggregateBindResponse {
@@ -186,6 +187,7 @@ export interface AggregateCombineRequest {
   execution_id: Uint8Array;
   merge_batch: Uint8Array;
   attach_opaque_data?: Uint8Array | null;
+  schema_name?: string | null;
 }
 
 export interface AggregateCombineResponse {
@@ -196,6 +198,7 @@ export interface AggregateDestructorRequest {
   execution_id: Uint8Array;
   group_ids_batch: Uint8Array;
   attach_opaque_data?: Uint8Array | null;
+  schema_name?: string | null;
 }
 
 export interface AggregateDestructorResponse {
@@ -207,6 +210,7 @@ export interface AggregateFinalizeRequest {
   group_ids_batch: Uint8Array;
   output_schema: /** @arrow-schema */ Uint8Array;
   attach_opaque_data?: Uint8Array | null;
+  schema_name?: string | null;
 }
 
 export interface AggregateFinalizeResponse {
@@ -218,6 +222,7 @@ export interface AggregateStreamingChunkRequest {
   execution_id: Uint8Array;
   input_batch: Uint8Array;
   attach_opaque_data?: Uint8Array | null;
+  schema_name?: string | null;
 }
 
 export interface AggregateStreamingChunkResponse {
@@ -228,6 +233,7 @@ export interface AggregateStreamingCloseRequest {
   function_name: string;
   execution_id: Uint8Array;
   attach_opaque_data?: Uint8Array | null;
+  schema_name?: string | null;
 }
 
 export interface AggregateStreamingCloseResponse {
@@ -243,6 +249,7 @@ export interface AggregateStreamingOpenRequest {
   settings?: /** @record-batch */ Uint8Array | null;
   secrets?: /** @record-batch */ Uint8Array | null;
   attach_opaque_data?: Uint8Array | null;
+  schema_name?: string | null;
 }
 
 export interface AggregateStreamingOpenResponse {
@@ -254,6 +261,7 @@ export interface AggregateUpdateRequest {
   execution_id: Uint8Array;
   input_batch: Uint8Array;
   attach_opaque_data?: Uint8Array | null;
+  schema_name?: string | null;
 }
 
 export interface AggregateUpdateResponse {
@@ -267,6 +275,7 @@ export interface AggregateWindowRequest {
   frame_starts: number[];
   frame_ends: number[];
   attach_opaque_data?: Uint8Array | null;
+  schema_name?: string | null;
 }
 
 export interface AggregateWindowResponse {
@@ -283,6 +292,7 @@ export interface AggregateWindowBatchRequest {
   frame_starts: number[];
   frame_ends: number[];
   attach_opaque_data?: Uint8Array | null;
+  schema_name?: string | null;
 }
 
 export interface AggregateWindowBatchResponse {
@@ -294,6 +304,7 @@ export interface AggregateWindowDestructorRequest {
   execution_id: Uint8Array;
   partition_id: number;
   attach_opaque_data?: Uint8Array | null;
+  schema_name?: string | null;
 }
 
 export interface AggregateWindowDestructorResponse {
@@ -310,6 +321,7 @@ export interface AggregateWindowInitRequest {
   frame_stats: Uint8Array;
   all_valid: Uint8Array;
   attach_opaque_data?: Uint8Array | null;
+  schema_name?: string | null;
 }
 
 export interface AggregateWindowInitResponse {
@@ -340,6 +352,7 @@ export interface BindRequest {
   at_value?: string | null;
   copy_from?: CopyFromContext | null;
   copy_to?: CopyToContext | null;
+  schema_name?: string | null;
 }
 
 export interface BindResponse {
@@ -487,6 +500,7 @@ export interface TableBufferingCombineRequest {
   state_ids: Uint8Array[];
   attach_opaque_data?: Uint8Array | null;
   transaction_id?: Uint8Array | null;
+  schema_name?: string | null;
 }
 
 export interface TableBufferingCombineResponse {
@@ -498,6 +512,7 @@ export interface TableBufferingDestructorRequest {
   execution_id: Uint8Array;
   attach_opaque_data?: Uint8Array | null;
   transaction_id?: Uint8Array | null;
+  schema_name?: string | null;
 }
 
 export interface TableBufferingDestructorResponse {
@@ -510,6 +525,7 @@ export interface TableBufferingProcessRequest {
   attach_opaque_data?: Uint8Array | null;
   transaction_id?: Uint8Array | null;
   batch_index?: number | null;
+  schema_name?: string | null;
 }
 
 export interface TableBufferingProcessResponse {

package/src/index.core.ts

@@ -16,6 +16,8 @@ export {
   CACHE_LAST_MODIFIED_KEY,
   CACHE_NO_STORE_KEY,
   CACHE_NOT_MODIFIED_KEY,
+  CACHE_PARTITION_SCOPE_KEY,
+  CACHE_PER_VALUE_KEY,
   CACHE_REVALIDATABLE_KEY,
   CACHE_SCOPE_CATALOG,
   CACHE_SCOPE_KEY,
@@ -247,7 +249,9 @@ export {
   isNull, isInt, isFloat, isBinary, isUtf8, isBool, isDecimal, isDate,
   isTime, isTimestamp, isInterval, isList, isStruct, isUnion,
   isFixedSizeBinary, isFixedSizeList, isMap, isDuration, isDictionary, isBatch,
+  typeSignature,
   readCanonicalValue, columnFromArray, decodeDictValue, backend,
+  adoptArrowJsShape,
 } from "./arrow/index.js";
 
 export type {

package/src/protocol/dispatch.ts

@@ -43,6 +43,7 @@ export function buildVgiProtocol(config: ProtocolConfig): Protocol {
     registry: config.registry,
     recoverExchangeState: config.recoverExchangeState,
     signingKey: config.signingKey,
+    catalogInterface: config.catalogInterface,
   });
   registerAggregateMethods(protocol, config.registry);
   registerTableBufferingMethods(protocol, config.registry, config.signingKey);