@query-farm/vgi 0.21.0 → 0.23.0

package/dist/cache-control.d.ts

@@ -36,6 +36,7 @@ export declare const CACHE_STALE_WHILE_REVALIDATE_KEY = "vgi.cache.stale_while_r
 export declare const CACHE_STALE_IF_ERROR_KEY = "vgi.cache.stale_if_error";
 export declare const CACHE_NOT_MODIFIED_KEY = "vgi.cache.not_modified";
 export declare const CACHE_PARTITION_SCOPE_KEY = "vgi.cache.partition_scope";
+export declare const CACHE_PER_VALUE_KEY = "vgi.cache.per_value";
 export declare const CACHE_IF_NONE_MATCH_KEY = "vgi.cache.if_none_match";
 export declare const CACHE_IF_MODIFIED_SINCE_KEY = "vgi.cache.if_modified_since";
 export declare const CACHE_SCOPE_CATALOG = "catalog";
@@ -82,6 +83,31 @@ export interface CacheControl {
      *  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;
 }
 /**
  * Render a {@link CacheControl} to the `vgi.cache.*` batch-metadata map.

package/dist/catalog/composite.d.ts

@@ -4,6 +4,8 @@ export declare class CompositeCatalogInterface extends CatalogInterface {
     private readonly _backends;
     constructor(_backends: CatalogInterface[]);
     private _route;
+    /** Route to the owning backend and ask it, so the answer is per-attachment. */
+    catalogNameForAttach(attachOpaqueData: Uint8Array): string | null;
     catalogs(): string[];
     catalogsInfo(): Promise<CatalogInfo[]>;
     attach(name: string, options?: Record<string, unknown>, dataVersionSpec?: string | null, implementationVersion?: string | null): Promise<CatalogAttachResult>;

package/dist/catalog/interface.d.ts

@@ -180,6 +180,17 @@ export declare function buildScanBranchesResult(branches: ScanBranchInput[], req
  */
 type Awaitable<T> = T | Promise<T>;
 export declare 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;
     abstract catalogs(): string[];
     /**
      * Attach this catalog. The framework already validates ATTACH options

package/dist/client-entry.js

@@ -2004,7 +2004,8 @@ var BIND_REQUEST_SCHEMA = schema2([
   field2("transaction_opaque_data", binary2(), true),
   field2("resolved_secrets_provided", bool2(), false),
   field2("at_unit", utf82(), true),
-  field2("at_value", utf82(), true)
+  field2("at_value", utf82(), true),
+  field2("schema_name", utf82(), true)
 ]);
 var COPY_FROM_STRUCT_TYPE = struct2([
   field2("format", utf82(), false),
@@ -2036,7 +2037,8 @@ function serializeBindRequest(req) {
     transaction_opaque_data: req.transaction_opaque_data ?? null,
     resolved_secrets_provided: req.resolved_secrets_provided ?? false,
     at_unit: req.at_unit ?? null,
-    at_value: req.at_value ?? null
+    at_value: req.at_value ?? null,
+    schema_name: req.schema_name ?? null
   };
   const extraFields = [];
   if (req.copy_from) {
@@ -3921,4 +3923,4 @@ export {
   ArgumentValidationError
 };
 
-//# debugId=D04A9CC224B063B264756E2164756E21
+//# debugId=FCC2DEE998E0D9AC64756E2164756E21