@query-farm/vgi 0.7.0 → 0.9.0

package/dist/arguments/argument-spec.d.ts

@@ -8,7 +8,56 @@ export interface ArgumentSpec {
     isVarargs?: boolean;
     isConst?: boolean;
     doc?: string;
+    /**
+     * Discovery-facing constraint metadata, pre-encoded to their surfaced UTF-8
+     * forms (presence-only — `undefined` means the constraint is absent and the
+     * corresponding field-metadata key is omitted entirely). Mirrors Python's
+     * `ArgumentSpec.default_json` / `choices_json` / `range_notation` / `pattern`
+     * so `argumentSpecsToSchema`/`schemaToArgumentSpecs` round-trip symmetrically.
+     */
+    defaultJson?: string;
+    choicesJson?: string;
+    rangeNotation?: string;
+    pattern?: string;
 }
+/**
+ * Raw per-argument constraint declarations, as authored on a function's
+ * argument descriptor. Encoded into the pre-computed {@link ArgumentSpec}
+ * constraint fields via {@link constraintSpecFields}.
+ */
+export interface ArgumentConstraints {
+    /** Closed set of allowed values (JSON-encoded into `vgi_choices`). */
+    choices?: readonly unknown[];
+    /** Inclusive lower bound (`>=`). */
+    ge?: number;
+    /** Inclusive upper bound (`<=`). */
+    le?: number;
+    /** Exclusive lower bound (`>`). */
+    gt?: number;
+    /** Exclusive upper bound (`<`). */
+    lt?: number;
+    /** Regex the value must match (surfaced as `vgi_pattern`, as-is). */
+    pattern?: string;
+    /** Default value (JSON-encoded into `vgi_default`); optional args only. */
+    default?: unknown;
+}
+/**
+ * Build interval notation from an argument's numeric bounds.
+ *
+ * Inclusive bounds (`ge`/`le`) render as square brackets, exclusive bounds
+ * (`gt`/`lt`) as parentheses, and an open side as `-inf`/`+inf`. Returns
+ * `undefined` when the argument has no numeric bound at all.
+ *
+ * Examples: `ge=0,le=10` -> `"[0, 10]"`; `gt=0` -> `"(0, +inf)"`;
+ * `ge=1,lt=10` -> `"[1, 10)"`.
+ */
+export declare function formatRange(ge?: number, le?: number, gt?: number, lt?: number): string | undefined;
+/**
+ * Encode raw {@link ArgumentConstraints} into the pre-computed constraint
+ * fields of an {@link ArgumentSpec} (presence-only — absent constraints yield
+ * no field). Mirrors Python's `_constraint_kwargs`.
+ */
+export declare function constraintSpecFields(constraints: ArgumentConstraints | undefined): Pick<ArgumentSpec, "defaultJson" | "choicesJson" | "rangeNotation" | "pattern">;
 /**
  * Convert ArgumentSpecs to an Arrow Schema with VGI metadata keys.
  * Positional arguments come first (in order), named arguments follow.

package/dist/catalog/descriptors.d.ts

@@ -1,4 +1,5 @@
 import type { VgiSchema, VgiDataType } from "../arrow/index.js";
+import type { AttachCatalogInfo } from "./interface.js";
 import type { VgiFunction } from "../functions/types.js";
 import type { Arguments } from "../arguments/arguments.js";
 import type { ColumnStatistics } from "../util/statistics.js";
@@ -142,6 +143,11 @@ export interface CatalogDescriptor {
     schemas: SchemaDescriptor[];
     settings?: SettingDescriptor[];
     secretTypes?: SecretTypeDescriptor[];
+    /**
+     * Companion catalogs (lakehouse federation) the client should ATTACH when this
+     * VGI catalog attaches. Surfaced via `catalog_attach.attach_catalogs`.
+     */
+    attachCatalogs?: AttachCatalogInfo[];
     comment?: string;
     tags?: Record<string, string>;
     /**

package/dist/catalog/interface.d.ts

@@ -56,6 +56,31 @@ export interface CopyFromFormatInfo {
 }
 /** Encode a CopyFromFormatInfo to Arrow IPC bytes (single-row batch). */
 export declare const encodeCopyFromFormatInfo: (v: CopyFromFormatInfo) => Uint8Array;
+/**
+ * A companion catalog the client should ATTACH when this VGI catalog attaches
+ * (lakehouse federation). Serialized into `CatalogAttachResult.attach_catalogs`;
+ * the C++ VGI extension attaches each at VGI-attach time so multi-branch
+ * catalog-table branches can resolve tables in a companion DuckLake / Iceberg /
+ * Postgres / DuckDB.
+ */
+export interface AttachCatalogInfo {
+    /** ATTACH alias; also a catalog-table ScanBranch's `sourceCatalog`. */
+    alias: string;
+    /** ATTACH target — a path or DSN (e.g. `ducklake:sqlite:/data/meta.sqlite`). */
+    target: string;
+    /** DuckDB db type; empty => inferred from the target scheme prefix. */
+    db_type?: string;
+    /** Extra ATTACH options forwarded verbatim (e.g. DuckLake DATA_PATH). */
+    options?: Record<string, string>;
+    /** Attach hidden (excluded from duckdb_databases()); still resolvable. */
+    hidden?: boolean;
+    /** When true, attach failure fails the whole VGI ATTACH. */
+    required?: boolean;
+    /** Optional named secret to inject into the companion's ATTACH options. */
+    secret_ref?: string;
+}
+/** Encode an AttachCatalogInfo to Arrow IPC bytes (single-row batch). */
+export declare const encodeAttachCatalogInfo: (v: AttachCatalogInfo) => Uint8Array;
 import { type VgiDataType } from "../arrow/index.js";
 /**
  * Result from `tableScanFunctionGet` — tells the VGI DuckDB extension which
@@ -124,6 +149,15 @@ export interface ScanBranchInput {
     branchFilter?: string | null;
     /** Declares this branch as the INSERT target (at most one per table). */
     writable?: boolean;
+    /**
+     * Catalog-table branch (lakehouse federation): leave `functionName` empty and
+     * set these to scan the base table
+     * `sourceCatalog.sourceSchema.sourceTable` in a companion catalog instead of
+     * calling a table function.
+     */
+    sourceCatalog?: string | null;
+    sourceSchema?: string | null;
+    sourceTable?: string | null;
 }
 /**
  * Build a multi-branch `ScanBranchesResult` wire dict from explicit branch

package/dist/functions/scalar.d.ts

@@ -25,6 +25,20 @@ export interface ScalarParameterDef {
     varargs?: boolean;
     /** Human-readable per-argument description (surfaced as `vgi_doc`). */
     doc?: string;
+    /** Closed set of allowed values (surfaced as `vgi_choices`). */
+    choices?: readonly unknown[];
+    /** Inclusive lower bound, `>=` (folded into `vgi_range`). */
+    ge?: number;
+    /** Inclusive upper bound, `<=` (folded into `vgi_range`). */
+    le?: number;
+    /** Exclusive lower bound, `>` (folded into `vgi_range`). */
+    gt?: number;
+    /** Exclusive upper bound, `<` (folded into `vgi_range`). */
+    lt?: number;
+    /** Regex the value must match (surfaced as `vgi_pattern`). */
+    pattern?: string;
+    /** Default value (surfaced as `vgi_default`, JSON-encoded). */
+    default?: unknown;
 }
 /**
  * The typed compute row for a scalar function: one property per declared

package/dist/generated/vgi-client.d.ts

@@ -304,6 +304,7 @@ export interface CatalogAttachResult {
     default_schema: string;
     settings: Uint8Array[];
     secret_types: Uint8Array[];
+    attach_catalogs: Uint8Array[];
     comment?: string | null;
     tags: Record<string, string>;
     supports_column_statistics: boolean;

package/dist/generated/vgi-protocol-schemas.d.ts

@@ -9,6 +9,7 @@ export declare const CopyFromFormatInfoSchema: import("../index.core.js").VgiSch
 export declare const ScanFunctionResultSchema: import("../index.core.js").VgiSchema;
 export declare const ScanBranchesResultSchema: import("../index.core.js").VgiSchema;
 export declare const ScanBranchSchema: import("../index.core.js").VgiSchema;
+export declare const AttachCatalogInfoSchema: import("../index.core.js").VgiSchema;
 export declare const AggregateBindResultSchema: import("../index.core.js").VgiSchema;
 export declare const AggregateCombineResultSchema: import("../index.core.js").VgiSchema;
 export declare const AggregateDestructorResultSchema: import("../index.core.js").VgiSchema;

package/dist/index.core.d.ts

@@ -14,7 +14,7 @@ export { FunctionRegistry } from "./functions/registry.js";
 export { FunctionType, FunctionStability, NullHandling, OrderPreservation, OrderDependence, DistinctDependence, TableInOutPhase, DEFAULT_MAX_WORKERS, } from "./types.js";
 export type { BindRequest, BindResponse, CopyFromContext, CopyToContext, InitRequest, GlobalInitResponse, TableCardinality, } from "./protocol/types.js";
 export { Arguments } from "./arguments/arguments.js";
-export { type ArgumentSpec, argumentSpecsToSchema, schemaToArgumentSpecs, macroArgumentsSchema, macroParameterDocsFromSchema } from "./arguments/argument-spec.js";
+export { type ArgumentSpec, type ArgumentConstraints, argumentSpecsToSchema, schemaToArgumentSpecs, macroArgumentsSchema, macroParameterDocsFromSchema, formatRange, constraintSpecFields } from "./arguments/argument-spec.js";
 export { VgiError, RowCountMismatchError, FunctionNotFoundError, CatalogReadOnlyError, CatalogNotFoundError, CatalogAlreadyExistsError, ArgumentValidationError, NoCatalogError, } from "./errors.js";
 export type { ResolvedMetadata, ParameterInfo } from "./metadata/types.js";
 export { CatalogFunctionType } from "./metadata/types.js";

package/dist/index.js

@@ -2600,6 +2600,10 @@ var VGI_VARARGS_TRUE = "true";
 var VGI_CONST_KEY = "vgi_const";
 var VGI_CONST_TRUE = "true";
 var VGI_DOC_KEY = "vgi_doc";
+var VGI_DEFAULT_KEY = "vgi_default";
+var VGI_CHOICES_KEY = "vgi_choices";
+var VGI_RANGE_KEY = "vgi_range";
+var VGI_PATTERN_KEY = "vgi_pattern";
 var DEFAULT_MAX_WORKERS = 99999;
 
 // src/errors.ts
@@ -2659,6 +2663,180 @@ class NoCatalogError extends VgiError {
   }
 }
 
+// src/arguments/argument-spec.ts
+init_arrow();
+function safeJson(value) {
+  try {
+    const encoded = JSON.stringify(value);
+    if (encoded === undefined) {
+      return JSON.stringify(String(value));
+    }
+    return encoded;
+  } catch {
+    return JSON.stringify(String(value));
+  }
+}
+function formatRange(ge, le, gt, lt) {
+  if (ge === undefined && le === undefined && gt === undefined && lt === undefined) {
+    return;
+  }
+  let low;
+  if (gt !== undefined) {
+    low = `(${gt}`;
+  } else if (ge !== undefined) {
+    low = `[${ge}`;
+  } else {
+    low = "(-inf";
+  }
+  let high;
+  if (lt !== undefined) {
+    high = `${lt})`;
+  } else if (le !== undefined) {
+    high = `${le}]`;
+  } else {
+    high = "+inf)";
+  }
+  return `${low}, ${high}`;
+}
+function constraintSpecFields(constraints) {
+  const fields = {};
+  if (constraints === undefined)
+    return fields;
+  if ("default" in constraints && constraints.default !== undefined) {
+    fields.defaultJson = safeJson(constraints.default);
+  }
+  if (constraints.choices !== undefined) {
+    fields.choicesJson = safeJson([...constraints.choices]);
+  }
+  const range = formatRange(constraints.ge, constraints.le, constraints.gt, constraints.lt);
+  if (range !== undefined) {
+    fields.rangeNotation = range;
+  }
+  if (constraints.pattern !== undefined) {
+    fields.pattern = constraints.pattern;
+  }
+  return fields;
+}
+function argumentSpecSortKey(spec) {
+  if (typeof spec.position === "number") {
+    return [0, spec.position];
+  }
+  return [1, spec.position];
+}
+function argumentSpecsToSchema(specs) {
+  const sorted = [...specs].sort((a, b) => {
+    const ka = argumentSpecSortKey(a);
+    const kb = argumentSpecSortKey(b);
+    if (ka[0] !== kb[0])
+      return ka[0] - kb[0];
+    if (typeof ka[1] === "number" && typeof kb[1] === "number") {
+      return ka[1] - kb[1];
+    }
+    return String(ka[1]).localeCompare(String(kb[1]));
+  });
+  const fields = [];
+  for (const spec of sorted) {
+    const metadata = new Map;
+    if (typeof spec.position === "string") {
+      metadata.set(VGI_ARG_KEY, VGI_ARG_NAMED);
+    }
+    if (spec.isTableInput) {
+      metadata.set(VGI_TYPE_KEY, VGI_TYPE_TABLE);
+    } else if (spec.isAnyType) {
+      metadata.set(VGI_TYPE_KEY, VGI_TYPE_ANY);
+    }
+    if (spec.isVarargs) {
+      metadata.set(VGI_VARARGS_KEY, VGI_VARARGS_TRUE);
+    }
+    if (spec.isConst) {
+      metadata.set(VGI_CONST_KEY, VGI_CONST_TRUE);
+    }
+    if (spec.doc) {
+      metadata.set(VGI_DOC_KEY, spec.doc);
+    }
+    if (spec.defaultJson !== undefined) {
+      metadata.set(VGI_DEFAULT_KEY, spec.defaultJson);
+    }
+    if (spec.choicesJson !== undefined) {
+      metadata.set(VGI_CHOICES_KEY, spec.choicesJson);
+    }
+    if (spec.rangeNotation !== undefined) {
+      metadata.set(VGI_RANGE_KEY, spec.rangeNotation);
+    }
+    if (spec.pattern !== undefined) {
+      metadata.set(VGI_PATTERN_KEY, spec.pattern);
+    }
+    const field3 = field2(spec.name, spec.arrowType, true, metadata.size > 0 ? metadata : undefined);
+    fields.push(field3);
+  }
+  return schema2(fields);
+}
+function macroArgumentsSchema(parameters, parameterDefaultValues, parameterDocs) {
+  const docs = parameterDocs ?? {};
+  const defaultTypes = new Map;
+  if (parameterDefaultValues && parameterDefaultValues.length > 0) {
+    const batch = deserializeBatch(parameterDefaultValues);
+    for (const f of batch.schema.fields) {
+      defaultTypes.set(f.name, f.type);
+    }
+  }
+  const fields = [];
+  for (const name of parameters) {
+    const metadata = new Map;
+    const doc = docs[name];
+    if (doc) {
+      metadata.set(VGI_DOC_KEY, doc);
+    }
+    const fieldType = defaultTypes.get(name) ?? nullType2();
+    fields.push(field2(name, fieldType, true, metadata.size > 0 ? metadata : undefined));
+  }
+  return schema2(fields);
+}
+function macroParameterDocsFromSchema(schema3) {
+  const docs = {};
+  for (const field3 of schema3.fields) {
+    const doc = field3.metadata.get(VGI_DOC_KEY);
+    if (doc) {
+      docs[field3.name] = doc;
+    }
+  }
+  return docs;
+}
+function schemaToArgumentSpecs(schema3) {
+  const specs = [];
+  let positionIndex = 0;
+  for (const field3 of schema3.fields) {
+    const metadata = field3.metadata;
+    const isNamed = metadata.get(VGI_ARG_KEY) === VGI_ARG_NAMED;
+    const position = isNamed ? field3.name : positionIndex++;
+    const vgiType = metadata.get(VGI_TYPE_KEY);
+    const isTableInput = vgiType === VGI_TYPE_TABLE;
+    const isAnyType = vgiType === VGI_TYPE_ANY;
+    const isVarargs = metadata.get(VGI_VARARGS_KEY) === VGI_VARARGS_TRUE;
+    const isConst = metadata.get(VGI_CONST_KEY) === VGI_CONST_TRUE;
+    const doc = metadata.get(VGI_DOC_KEY) ?? "";
+    const defaultJson = metadata.get(VGI_DEFAULT_KEY);
+    const choicesJson = metadata.get(VGI_CHOICES_KEY);
+    const rangeNotation = metadata.get(VGI_RANGE_KEY);
+    const pattern = metadata.get(VGI_PATTERN_KEY);
+    specs.push({
+      name: field3.name,
+      position,
+      arrowType: field3.type,
+      isTableInput,
+      isAnyType,
+      isVarargs,
+      isConst,
+      doc,
+      defaultJson,
+      choicesJson,
+      rangeNotation,
+      pattern
+    });
+  }
+  return specs;
+}
+
 // src/util/arrow/index.ts
 init_arrow();
 
@@ -2676,7 +2854,8 @@ function defineScalarFunction(config) {
         isAnyType: isAny,
         isConst: p.const,
         isVarargs: p.varargs,
-        doc: p.doc
+        doc: p.doc,
+        ...constraintSpecFields(p)
       });
     }
   } else {
@@ -5584,7 +5763,19 @@ var ScanBranchSchema = schema2([
   field2("function_name", utf82(), false),
   field2("arguments", binary2(), false),
   field2("branch_filter", utf82(), true),
-  field2("writable", bool2(), false)
+  field2("writable", bool2(), false),
+  field2("source_catalog", utf82(), true),
+  field2("source_schema", utf82(), true),
+  field2("source_table", utf82(), true)
+]);
+var AttachCatalogInfoSchema = schema2([
+  field2("alias", utf82(), false),
+  field2("target", utf82(), false),
+  field2("db_type", utf82(), false),
+  field2("options", map2(field2("key", utf82(), false), field2("value", utf82(), true), false), false),
+  field2("hidden", bool2(), false),
+  field2("required", bool2(), false),
+  field2("secret_ref", utf82(), false)
 ]);
 var AggregateBindResultSchema = schema2([
   field2("output_schema", binary2(), false),
@@ -5628,6 +5819,7 @@ var CatalogAttachResultSchema = schema2([
   field2("default_schema", utf82(), false),
   field2("settings", list2(field2("item", binary2(), true)), false),
   field2("secret_types", list2(field2("item", binary2(), true)), false),
+  field2("attach_catalogs", list2(field2("item", binary2(), true)), false),
   field2("comment", utf82(), true),
   field2("tags", map2(field2("key", utf82(), false), field2("value", utf82(), true), false), false),
   field2("supports_column_statistics", bool2(), false),
@@ -6090,6 +6282,15 @@ var encodeCopyFromFormatInfo = (v) => encodeASD(CopyFromFormatInfoSchema, {
   description: v.description ?? "",
   ordered: v.ordered ?? false
 });
+var encodeAttachCatalogInfo = (v) => encodeASD(AttachCatalogInfoSchema, {
+  alias: v.alias,
+  target: v.target,
+  db_type: v.db_type ?? "",
+  options: v.options ?? {},
+  hidden: v.hidden ?? false,
+  required: v.required ?? false,
+  secret_ref: v.secret_ref ?? ""
+});
 function decodeScanFunctionResult(inner) {
   const argsBytes = inner.arguments;
   const positionalArguments = [];
@@ -6123,7 +6324,10 @@ function singleBranchResult(legacy) {
     function_name: [legacy.function_name],
     arguments: [toUint8Array(legacy.arguments)],
     branch_filter: [null],
-    writable: [false]
+    writable: [false],
+    source_catalog: [null],
+    source_schema: [null],
+    source_table: [null]
   }, ScanBranchSchema);
   return {
     branches: [serializeBatch(branchBatch)],
@@ -6152,7 +6356,10 @@ function buildScanBranchesResult(branches, requiredExtensions = []) {
       function_name: [branch.functionName],
       arguments: [serializeBranchArguments(branch)],
       branch_filter: [branch.branchFilter ?? null],
-      writable: [branch.writable ?? false]
+      writable: [branch.writable ?? false],
+      source_catalog: [branch.sourceCatalog ?? null],
+      source_schema: [branch.sourceSchema ?? null],
+      source_table: [branch.sourceTable ?? null]
     }, ScanBranchSchema);
     return serializeBatch(branchBatch);
   });
@@ -6294,108 +6501,6 @@ function serializeColumnStatistics(stats, _cacheMaxAgeSeconds) {
   return serializeBatch(buildStatisticsBatch(stats));
 }
 
-// src/arguments/argument-spec.ts
-init_arrow();
-function argumentSpecSortKey(spec) {
-  if (typeof spec.position === "number") {
-    return [0, spec.position];
-  }
-  return [1, spec.position];
-}
-function argumentSpecsToSchema(specs) {
-  const sorted = [...specs].sort((a, b) => {
-    const ka = argumentSpecSortKey(a);
-    const kb = argumentSpecSortKey(b);
-    if (ka[0] !== kb[0])
-      return ka[0] - kb[0];
-    if (typeof ka[1] === "number" && typeof kb[1] === "number") {
-      return ka[1] - kb[1];
-    }
-    return String(ka[1]).localeCompare(String(kb[1]));
-  });
-  const fields = [];
-  for (const spec of sorted) {
-    const metadata = new Map;
-    if (typeof spec.position === "string") {
-      metadata.set(VGI_ARG_KEY, VGI_ARG_NAMED);
-    }
-    if (spec.isTableInput) {
-      metadata.set(VGI_TYPE_KEY, VGI_TYPE_TABLE);
-    } else if (spec.isAnyType) {
-      metadata.set(VGI_TYPE_KEY, VGI_TYPE_ANY);
-    }
-    if (spec.isVarargs) {
-      metadata.set(VGI_VARARGS_KEY, VGI_VARARGS_TRUE);
-    }
-    if (spec.isConst) {
-      metadata.set(VGI_CONST_KEY, VGI_CONST_TRUE);
-    }
-    if (spec.doc) {
-      metadata.set(VGI_DOC_KEY, spec.doc);
-    }
-    const field3 = field2(spec.name, spec.arrowType, true, metadata.size > 0 ? metadata : undefined);
-    fields.push(field3);
-  }
-  return schema2(fields);
-}
-function macroArgumentsSchema(parameters, parameterDefaultValues, parameterDocs) {
-  const docs = parameterDocs ?? {};
-  const defaultTypes = new Map;
-  if (parameterDefaultValues && parameterDefaultValues.length > 0) {
-    const batch = deserializeBatch(parameterDefaultValues);
-    for (const f of batch.schema.fields) {
-      defaultTypes.set(f.name, f.type);
-    }
-  }
-  const fields = [];
-  for (const name of parameters) {
-    const metadata = new Map;
-    const doc = docs[name];
-    if (doc) {
-      metadata.set(VGI_DOC_KEY, doc);
-    }
-    const fieldType = defaultTypes.get(name) ?? nullType2();
-    fields.push(field2(name, fieldType, true, metadata.size > 0 ? metadata : undefined));
-  }
-  return schema2(fields);
-}
-function macroParameterDocsFromSchema(schema3) {
-  const docs = {};
-  for (const field3 of schema3.fields) {
-    const doc = field3.metadata.get(VGI_DOC_KEY);
-    if (doc) {
-      docs[field3.name] = doc;
-    }
-  }
-  return docs;
-}
-function schemaToArgumentSpecs(schema3) {
-  const specs = [];
-  let positionIndex = 0;
-  for (const field3 of schema3.fields) {
-    const metadata = field3.metadata;
-    const isNamed = metadata.get(VGI_ARG_KEY) === VGI_ARG_NAMED;
-    const position = isNamed ? field3.name : positionIndex++;
-    const vgiType = metadata.get(VGI_TYPE_KEY);
-    const isTableInput = vgiType === VGI_TYPE_TABLE;
-    const isAnyType = vgiType === VGI_TYPE_ANY;
-    const isVarargs = metadata.get(VGI_VARARGS_KEY) === VGI_VARARGS_TRUE;
-    const isConst = metadata.get(VGI_CONST_KEY) === VGI_CONST_TRUE;
-    const doc = metadata.get(VGI_DOC_KEY) ?? "";
-    specs.push({
-      name: field3.name,
-      position,
-      arrowType: field3.type,
-      isTableInput,
-      isAnyType,
-      isVarargs,
-      isConst,
-      doc
-    });
-  }
-  return specs;
-}
-
 // src/metadata/types.ts
 var CatalogFunctionType;
 ((CatalogFunctionType2) => {
@@ -6525,6 +6630,7 @@ class ReadOnlyCatalogInterface extends CatalogInterface {
     this._attachments.set(name, attachOpaqueData);
     const settings = (this._descriptor.settings ?? []).map((s) => serializeSetting(s));
     const secretTypes = (this._descriptor.secretTypes ?? []).map((s) => serializeSecretType(s));
+    const attachCatalogs = (this._descriptor.attachCatalogs ?? []).map((c) => encodeAttachCatalogInfo(c));
     const hasTimeTravel = this._descriptor.schemas.some((s) => s.tables?.some((t) => t.supportsTimeTravel) ?? false);
     return {
       attach_opaque_data: attachOpaqueData,
@@ -6536,6 +6642,7 @@ class ReadOnlyCatalogInterface extends CatalogInterface {
       default_schema: this._descriptor.defaultSchema ?? "main",
       settings,
       secret_types: secretTypes,
+      attach_catalogs: attachCatalogs,
       comment: this._descriptor.comment ?? null,
       tags: this._descriptor.tags ?? {},
       supports_column_statistics: true,
@@ -9166,6 +9273,7 @@ function registerCatalogAdminMethods(protocol, getCatalog, signingKey) {
         default_schema: result.default_schema ?? "main",
         settings: result.settings ?? [],
         secret_types: result.secret_types ?? [],
+        attach_catalogs: result.attach_catalogs ?? [],
         comment: result.comment ?? null,
         tags: result.tags ?? {},
         supports_column_statistics: result.supports_column_statistics ?? true,
@@ -10256,6 +10364,7 @@ class VgiClient {
       default_schema: inner.default_schema ?? "main",
       settings: inner.settings ? (Array.isArray(inner.settings) ? inner.settings : [...inner.settings]).map(toUint8Array) : [],
       secret_types: inner.secret_types ? (Array.isArray(inner.secret_types) ? inner.secret_types : [...inner.secret_types]).map(toUint8Array) : [],
+      attach_catalogs: inner.attach_catalogs ? (Array.isArray(inner.attach_catalogs) ? inner.attach_catalogs : [...inner.attach_catalogs]).map(toUint8Array) : [],
       comment: inner.comment ?? null,
       tags: deserializeTags(inner.tags),
       supports_column_statistics: inner.supports_column_statistics ?? false,
@@ -10759,6 +10868,7 @@ export {
   fromBrandedNumber,
   fromBrandedBigInt,
   fromBranded,
+  formatRange,
   formatPushedFilters,
   float642 as float64,
   float323 as float32,
@@ -10807,6 +10917,7 @@ export {
   dateMillisecond2 as dateMillisecond,
   dateDay2 as dateDay,
   date2 as date,
+  constraintSpecFields,
   columnFromArray,
   codecFor,
   bytes,
@@ -10885,4 +10996,4 @@ export {
   ArgumentValidationError
 };
 
-//# debugId=19A9033B1335C3EC64756E2164756E21
+//# debugId=B8E8A46EBC37A19064756E2164756E21