@query-farm/vgi 0.40.0 → 0.41.0

package/dist/index.js

@@ -8676,6 +8676,14 @@ function resolveMetadata(func) {
 
 // src/catalog/attach-option.ts
 init_arrow();
+var RESERVED_ATTACH_OPTION = "vgi_attach_ticket";
+function assertNoReservedAttachOption(specs) {
+  for (const spec of specs) {
+    if (spec.name.toLowerCase() === RESERVED_ATTACH_OPTION) {
+      throw new Error(`Attach option '${spec.name}' uses the reserved name '${RESERVED_ATTACH_OPTION}': the framework ` + "reads it as an attach ticket before any catalog code runs. Rename the option.");
+    }
+  }
+}
 var SPEC_SCHEMA = schema2([
   field2("name", utf82(), false),
   field2("description", utf82(), false),
@@ -8685,6 +8693,7 @@ var SPEC_SCHEMA = schema2([
   field2("secret", bool2(), true)
 ]);
 function serializeAttachOptionSpec(spec) {
+  assertNoReservedAttachOption([spec]);
   if (spec.required && spec.default !== undefined && spec.default !== null) {
     throw new Error(`Attach option '${spec.name}' is required but also declares a default ` + `(${JSON.stringify(spec.default)}); an option with a default is always ` + "satisfiable without the caller. Drop one.");
   }
@@ -8747,6 +8756,8 @@ class MissingAttachOptionsError extends Error {
   }
 }
 function validateRequiredAttachOptions(catalogName, specs, options) {
+  specs = Array.from(specs);
+  assertNoReservedAttachOption(specs);
   const supplied = new Set(Object.keys(options).map((key) => key.toLowerCase()));
   const missing = Array.from(specs).filter((spec) => spec.required && !supplied.has(spec.name.toLowerCase())).map((spec) => spec.name);
   if (missing.length > 0) {
@@ -8754,6 +8765,41 @@ function validateRequiredAttachOptions(catalogName, specs, options) {
   }
 }
 
+class ReservedAttachOptionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ReservedAttachOptionError";
+  }
+}
+async function checkReservedAttachOptions(catalog) {
+  if (!catalog?.catalogsInfo)
+    return;
+  let infos;
+  try {
+    infos = await catalog.catalogsInfo();
+  } catch (e) {
+    if (e instanceof Error && e.message.includes(`reserved name '${RESERVED_ATTACH_OPTION}'`)) {
+      throw new ReservedAttachOptionError(e.message);
+    }
+    return;
+  }
+  for (const info of infos ?? []) {
+    for (const raw of info.attach_option_specs ?? []) {
+      let name;
+      try {
+        name = deserializeAttachOptionSpec(toUint8Array(raw)).name;
+      } catch {
+        continue;
+      }
+      try {
+        assertNoReservedAttachOption([{ name }]);
+      } catch (e) {
+        throw new ReservedAttachOptionError(e.message);
+      }
+    }
+  }
+}
+
 // src/catalog/item-encoding.ts
 var ENCODED = new WeakMap;
 function freezeCatalogItem(item) {
@@ -9513,1533 +9559,1536 @@ function sameSpelling(left, right) {
   const b = normalizeSchemaPath(right);
   return a.length === b.length && a.every((part, i) => part === b[i]);
 }
-// src/catalog/composite.ts
-var ROUTE_BYTE = 0;
-
-class CompositeCatalogInterface extends CatalogInterface {
-  _backends;
-  constructor(_backends) {
-    super();
-    this._backends = _backends;
-    if (_backends.length > 256) {
-      throw new Error("CompositeCatalog: at most 256 backends supported");
-    }
+// node_modules/@noble/ciphers/utils.js
+/*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) */
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
+}
+var atitle = (title) => title ? `"${title}" ` : "";
+function abool(value, title = "") {
+  if (typeof value !== "boolean")
+    throw new TypeError(atitle(title) + "expected boolean, got type=" + typeof value);
+  return value;
+}
+function anumber(n, title = "") {
+  if (typeof n !== "number")
+    throw new TypeError(atitle(title) + "expected number, got " + typeof n);
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new RangeError(atitle(title) + "expected integer >= 0, got " + n);
+  return n;
+}
+function abytes(value, length, title = "") {
+  if (isBytes(value) && (length === undefined || value.length === length))
+    return value;
+  if (length !== undefined)
+    anumber(length, "length");
+  const bytes = isBytes(value);
+  const ofLen = length !== undefined ? ` of length ${length}` : "";
+  const got = bytes ? `length=${value.length}` : `type=${typeof value}`;
+  const message = atitle(title) + "expected Uint8Array" + ofLen + ", got " + got;
+  if (!bytes)
+    throw new TypeError(message);
+  throw new RangeError(message);
+}
+var aobject = (value, label) => {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    throw new TypeError(label === "object" ? "expected valid options object" : `"${label}" expected object, got type=${typeof value}`);
+};
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("hash was destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("digest() was already called");
+}
+function aoutput(out, instance) {
+  abytes(out, undefined, "output");
+  const min = instance.outputLen;
+  if (!(out.length >= min)) {
+    throw new RangeError('"output" expected length >= ' + min);
   }
-  _route(attachOpaqueData) {
-    const idx = attachOpaqueData[ROUTE_BYTE];
-    const route = this._backends[idx];
-    if (!route) {
-      throw new Error(`CompositeCatalog: no backend at route-byte index ${idx} (have ${this._backends.length})`);
-    }
-    return route;
+}
+function u32(arr) {
+  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+function clean(...arrays) {
+  for (let i = 0;i < arrays.length; i++) {
+    arrays[i].fill(0);
   }
-  catalogNameForAttach(attachOpaqueData) {
-    try {
-      return this._route(attachOpaqueData).catalogNameForAttach(attachOpaqueData);
-    } catch {
-      return null;
-    }
+}
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+var isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+function byteSwap(word) {
+  return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+}
+function byteSwap32(arr) {
+  for (let i = 0;i < arr.length; i++) {
+    arr[i] = byteSwap(arr[i]);
   }
-  catalogs() {
-    const all = [];
-    for (const b of this._backends)
-      all.push(...b.catalogs());
-    return all;
+  return arr;
+}
+var swap32IfBE = isLE ? (u) => u : byteSwap32;
+function checkOpts(defaults, opts) {
+  aobject(defaults, "defaults");
+  aobject(opts, "opts");
+  const merged = Object.assign(defaults, opts);
+  return merged;
+}
+function equalBytes(a, b) {
+  a = abytes(a);
+  b = abytes(b);
+  if (a.length !== b.length)
+    return false;
+  let diff = 0;
+  for (let i = 0;i < a.length; i++)
+    diff |= a[i] ^ b[i];
+  return diff === 0;
+}
+function wrapMacConstructor(keyLen, macCons, fromMsg) {
+  const mac = macCons;
+  const getArgs = fromMsg || (() => []);
+  const macC = (msg, key) => mac(key, ...getArgs(msg)).update(msg).digest();
+  const tmp = mac(new Uint8Array(keyLen), ...getArgs(new Uint8Array(0)));
+  macC.outputLen = tmp.outputLen;
+  macC.blockLen = tmp.blockLen;
+  macC.create = (key, ...args) => mac(key, ...args);
+  return macC;
+}
+var wrapCipher = (params, constructor) => {
+  function wrappedCipher(key, ...args) {
+    abytes(key, undefined, "key");
+    if (params.nonceLength !== undefined) {
+      const nonce = args[0];
+      abytes(nonce, params.varSizeNonce ? undefined : params.nonceLength, "nonce");
+    }
+    const tagl = params.tagLength;
+    const aadStart = params.nonceLength !== undefined ? 1 : 0;
+    if (!params.withAAD) {
+      for (let i = aadStart;i < args.length; i++)
+        if (isBytes(args[i]))
+          throw new Error("AAD not supported");
+    }
+    if (params.withAAD && args[aadStart] !== undefined)
+      abytes(args[aadStart], undefined, "AAD");
+    const cipher = constructor(key, ...args);
+    const checkOutput = (fnLength, output) => {
+      if (output !== undefined) {
+        if (fnLength !== 2)
+          throw new Error("cipher output not supported");
+        abytes(output, undefined, "output");
+      }
+    };
+    let called = false;
+    const wrCipher = {
+      encrypt(data, output) {
+        if (called)
+          throw new Error("cannot encrypt() twice with same key + nonce");
+        called = true;
+        abytes(data, undefined, "data");
+        checkOutput(cipher.encrypt.length, output);
+        return cipher.encrypt(data, output);
+      },
+      decrypt(data, output) {
+        abytes(data, undefined, "data");
+        if (tagl && data.length < tagl)
+          throw new Error('"ciphertext" expected length >= tagLength=' + tagl);
+        checkOutput(cipher.decrypt.length, output);
+        return cipher.decrypt(data, output);
+      }
+    };
+    return wrCipher;
   }
-  async catalogsInfo() {
-    const all = [];
-    for (const b of this._backends) {
-      if (b.catalogsInfo) {
-        all.push(...await b.catalogsInfo());
-      } else {
-        for (const name of b.catalogs()) {
-          all.push({ name, implementation_version: null, data_version_spec: null, attach_option_specs: [], releases: [] });
-        }
+  Object.assign(wrappedCipher, params);
+  return wrappedCipher;
+};
+function getOutput(expectedLength, out, onlyAligned = true) {
+  if (out === undefined)
+    return new Uint8Array(expectedLength);
+  abytes(out, expectedLength, "output");
+  if (onlyAligned && !isAligned32(out))
+    throw new Error("invalid output, must be aligned");
+  return out;
+}
+function u64Lengths(dataLength, aadLength, isLE) {
+  anumber(dataLength);
+  anumber(aadLength);
+  abool(isLE);
+  const num = new Uint8Array(16);
+  const view = createView(num);
+  view.setBigUint64(0, BigInt(aadLength), isLE);
+  view.setBigUint64(8, BigInt(dataLength), isLE);
+  return num;
+}
+function isAligned32(bytes) {
+  return bytes.byteOffset % 4 === 0;
+}
+function copyBytes(bytes) {
+  return Uint8Array.from(abytes(bytes));
+}
+
+// node_modules/@noble/ciphers/_arx.js
+var encodeStr = (str) => Uint8Array.from(str.split(""), (c) => c.charCodeAt(0));
+var sigma16_32 = /* @__PURE__ */ (() => swap32IfBE(u32(encodeStr("expand 16-byte k"))))();
+var sigma32_32 = /* @__PURE__ */ (() => swap32IfBE(u32(encodeStr("expand 32-byte k"))))();
+function rotl(a, b) {
+  return a << b | a >>> 32 - b;
+}
+var BLOCK_LEN = 64;
+var BLOCK_LEN32 = 16;
+var MAX_COUNTER = /* @__PURE__ */ (() => 2 ** 32 - 1)();
+var U32_EMPTY = /* @__PURE__ */ Uint32Array.of();
+function runCipher(core, sigma, key, nonce, data, output, counter, rounds) {
+  const len = data.length;
+  const block = new Uint8Array(BLOCK_LEN);
+  const b32 = u32(block);
+  const isAligned = isLE && isAligned32(data) && isAligned32(output);
+  const d32 = isAligned ? u32(data) : U32_EMPTY;
+  const o32 = isAligned ? u32(output) : U32_EMPTY;
+  if (!isLE) {
+    for (let pos = 0;pos < len; counter++) {
+      core(sigma, key, nonce, b32, counter, rounds);
+      swap32IfBE(b32);
+      if (counter >= MAX_COUNTER)
+        throw new Error("arx: counter overflow");
+      const take = Math.min(BLOCK_LEN, len - pos);
+      for (let j = 0, posj;j < take; j++) {
+        posj = pos + j;
+        output[posj] = data[posj] ^ block[j];
       }
+      pos += take;
     }
-    return all;
+    return;
   }
-  async attach(name, options, dataVersionSpec, implementationVersion) {
-    for (let i = 0;i < this._backends.length; i++) {
-      const b = this._backends[i];
-      if (b.catalogs().includes(name)) {
-        const result = await b.attach(name, options, dataVersionSpec, implementationVersion);
-        const stamped = new Uint8Array(result.attach_opaque_data);
-        stamped[ROUTE_BYTE] = i;
-        result.attach_opaque_data = stamped;
-        return result;
+  for (let pos = 0;pos < len; counter++) {
+    core(sigma, key, nonce, b32, counter, rounds);
+    if (counter >= MAX_COUNTER)
+      throw new Error("arx: counter overflow");
+    const take = Math.min(BLOCK_LEN, len - pos);
+    if (isAligned && take === BLOCK_LEN) {
+      const pos32 = pos / 4;
+      if (pos % 4 !== 0)
+        throw new Error("arx: invalid block position");
+      for (let j = 0, posj;j < BLOCK_LEN32; j++) {
+        posj = pos32 + j;
+        o32[posj] = d32[posj] ^ b32[j];
       }
+      pos += BLOCK_LEN;
+      continue;
     }
-    throw new Error(`No worker handles catalog '${name}'`);
-  }
-  async detach(attachOpaqueData) {
-    await this._route(attachOpaqueData).detach(attachOpaqueData);
-  }
-  async version(attachOpaqueData, transactionOpaqueData) {
-    return await this._route(attachOpaqueData).version(attachOpaqueData, transactionOpaqueData);
-  }
-  async schemas(attachOpaqueData, transactionOpaqueData) {
-    return await this._route(attachOpaqueData).schemas(attachOpaqueData, transactionOpaqueData);
-  }
-  async schemaGet(attachOpaqueData, path, transactionOpaqueData) {
-    return await this._route(attachOpaqueData).schemaGet(attachOpaqueData, path, transactionOpaqueData);
-  }
-  async schemaContentsTables(attachOpaqueData, path, transactionOpaqueData) {
-    return await this._route(attachOpaqueData).schemaContentsTables(attachOpaqueData, path, transactionOpaqueData);
-  }
-  async schemaContentsViews(attachOpaqueData, path, transactionOpaqueData) {
-    return await this._route(attachOpaqueData).schemaContentsViews(attachOpaqueData, path, transactionOpaqueData);
-  }
-  async schemaContentsFunctions(attachOpaqueData, path, type, transactionOpaqueData) {
-    return await this._route(attachOpaqueData).schemaContentsFunctions(attachOpaqueData, path, type, transactionOpaqueData);
-  }
-  async schemaContentsMacros(attachOpaqueData, path, type, transactionOpaqueData) {
-    return await this._route(attachOpaqueData).schemaContentsMacros(attachOpaqueData, path, type, transactionOpaqueData);
-  }
-  async schemaContentsIndexes(attachOpaqueData, path, transactionOpaqueData) {
-    return await this._route(attachOpaqueData).schemaContentsIndexes(attachOpaqueData, path, transactionOpaqueData);
-  }
-  async indexGet(attachOpaqueData, schemaPath, name, transactionOpaqueData) {
-    return await this._route(attachOpaqueData).indexGet(attachOpaqueData, schemaPath, name, transactionOpaqueData);
-  }
-  async tableGet(attachOpaqueData, schemaPath, name, atUnit, atValue, transactionOpaqueData) {
-    return await this._route(attachOpaqueData).tableGet(attachOpaqueData, schemaPath, name, atUnit, atValue, transactionOpaqueData);
-  }
-  async tableScanFunctionGet(attachOpaqueData, schemaPath, name, atUnit, atValue, transactionOpaqueData) {
-    return await this._route(attachOpaqueData).tableScanFunctionGet(attachOpaqueData, schemaPath, name, atUnit, atValue, transactionOpaqueData);
-  }
-  async tableScanBranchesGet(attachOpaqueData, schemaPath, name, atUnit, atValue, transactionOpaqueData) {
-    return await this._route(attachOpaqueData).tableScanBranchesGet(attachOpaqueData, schemaPath, name, atUnit, atValue, transactionOpaqueData);
-  }
-  async tableColumnStatisticsGet(attachOpaqueData, schemaPath, name, transactionOpaqueData) {
-    return await this._route(attachOpaqueData).tableColumnStatisticsGet(attachOpaqueData, schemaPath, name, transactionOpaqueData);
-  }
-  async viewGet(attachOpaqueData, schemaPath, name, transactionOpaqueData) {
-    return await this._route(attachOpaqueData).viewGet(attachOpaqueData, schemaPath, name, transactionOpaqueData);
-  }
-  async macroGet(attachOpaqueData, schemaPath, name, transactionOpaqueData) {
-    return await this._route(attachOpaqueData).macroGet(attachOpaqueData, schemaPath, name, transactionOpaqueData);
-  }
-  async schemaCreate(...args) {
-    await this._route(args[0]).schemaCreate(...args);
-  }
-  async schemaDrop(...args) {
-    await this._route(args[0]).schemaDrop(...args);
-  }
-  async tableCreate(...args) {
-    await this._route(args[0]).tableCreate(...args);
-  }
-  async tableDrop(...args) {
-    await this._route(args[0]).tableDrop(...args);
-  }
-  async tableCommentSet(...args) {
-    await this._route(args[0]).tableCommentSet(...args);
-  }
-  async tableRename(...args) {
-    await this._route(args[0]).tableRename(...args);
-  }
-  async tableColumnAdd(...args) {
-    await this._route(args[0]).tableColumnAdd(...args);
-  }
-  async tableColumnDrop(...args) {
-    await this._route(args[0]).tableColumnDrop(...args);
-  }
-  async tableColumnRename(...args) {
-    await this._route(args[0]).tableColumnRename(...args);
-  }
-  async tableColumnDefaultSet(...args) {
-    await this._route(args[0]).tableColumnDefaultSet(...args);
-  }
-  async tableColumnDefaultDrop(...args) {
-    await this._route(args[0]).tableColumnDefaultDrop(...args);
-  }
-  async tableColumnTypeChange(...args) {
-    await this._route(args[0]).tableColumnTypeChange(...args);
-  }
-  async tableNotNullSet(...args) {
-    await this._route(args[0]).tableNotNullSet(...args);
-  }
-  async tableNotNullDrop(...args) {
-    await this._route(args[0]).tableNotNullDrop(...args);
-  }
-  async viewCreate(...args) {
-    await this._route(args[0]).viewCreate(...args);
-  }
-  async viewDrop(...args) {
-    await this._route(args[0]).viewDrop(...args);
-  }
-  async viewRename(...args) {
-    await this._route(args[0]).viewRename(...args);
-  }
-  async viewCommentSet(...args) {
-    await this._route(args[0]).viewCommentSet(...args);
-  }
-  async macroCreate(...args) {
-    await this._route(args[0]).macroCreate(...args);
-  }
-  async macroDrop(...args) {
-    await this._route(args[0]).macroDrop(...args);
-  }
-  async catalogContents(attachOpaqueData, ifNoneMatch) {
-    return await this._route(attachOpaqueData).catalogContents(attachOpaqueData, ifNoneMatch);
-  }
-  catalogContentsOwner(attachOpaqueData) {
-    return this._route(attachOpaqueData).catalogContentsOwner(attachOpaqueData);
-  }
-  async copyFromFormats(attachOpaqueData, transactionOpaqueData) {
-    return await this._route(attachOpaqueData).copyFromFormats(attachOpaqueData, transactionOpaqueData);
-  }
-  async transactionBegin(attachOpaqueData) {
-    return await this._route(attachOpaqueData).transactionBegin(attachOpaqueData);
-  }
-  async transactionCommit(attachOpaqueData, transactionOpaqueData) {
-    await this._route(attachOpaqueData).transactionCommit(attachOpaqueData, transactionOpaqueData);
-  }
-  async transactionRollback(attachOpaqueData, transactionOpaqueData) {
-    await this._route(attachOpaqueData).transactionRollback(attachOpaqueData, transactionOpaqueData);
+    for (let j = 0, posj;j < take; j++) {
+      posj = pos + j;
+      output[posj] = data[posj] ^ block[j];
+    }
+    pos += take;
   }
 }
-// src/functions/registry.ts
-init_arrow();
-var EXACT_MATCH_SCORE = 2;
-var FAMILY_MATCH_SCORE = 1;
-function typesIdentical(a, b) {
-  return typeSignature(a) === typeSignature(b);
-}
-function typesCompatible(actual, declared) {
-  if (typesIdentical(actual, declared))
-    return true;
-  if (isInt(actual) && isInt(declared))
-    return true;
-  if ((isFloat(actual) || isDecimal(actual)) && (isFloat(declared) || isDecimal(declared)))
-    return true;
-  if (isUtf8(actual) && isUtf8(declared))
-    return true;
-  if (isBinary(actual) && isBinary(declared))
-    return true;
-  if (isBool(actual) && isBool(declared))
-    return true;
-  return false;
-}
-function scoreTypes(specs, actualTypes) {
-  let score = 0;
-  let varArgsSpec = null;
-  for (let i = 0;i < specs.length; i++) {
-    const spec = specs[i];
-    if (spec.isVarargs)
-      varArgsSpec = spec;
-    if (i >= actualTypes.length)
-      break;
-    if (spec.isAnyType || isNull(spec.arrowType))
-      continue;
-    const actual = actualTypes[i];
-    if (actual === null)
-      continue;
-    if (typesIdentical(actual, spec.arrowType)) {
-      score += EXACT_MATCH_SCORE;
-    } else if (typesCompatible(actual, spec.arrowType)) {
-      score += FAMILY_MATCH_SCORE;
+function createCipher(core, opts) {
+  const { allowShortKeys, extendNonceFn, counterLength, counterRight, rounds } = checkOpts({ allowShortKeys: false, counterLength: 8, counterRight: false, rounds: 20 }, opts);
+  if (typeof core !== "function")
+    throw new Error("core must be a function");
+  anumber(counterLength);
+  anumber(rounds);
+  abool(counterRight);
+  abool(allowShortKeys);
+  return (key, nonce, data, output, counter = 0) => {
+    abytes(key, undefined, "key");
+    abytes(nonce, undefined, "nonce");
+    abytes(data, undefined, "data");
+    const len = data.length;
+    output = getOutput(len, output, false);
+    anumber(counter);
+    if (counter < 0 || counter >= MAX_COUNTER)
+      throw new Error("arx: counter overflow");
+    const toClean = [];
+    let l = key.length;
+    let k;
+    let sigma;
+    if (l === 32) {
+      toClean.push(k = copyBytes(key));
+      sigma = sigma32_32;
+    } else if (l === 16 && allowShortKeys) {
+      k = new Uint8Array(32);
+      k.set(key);
+      k.set(key, 16);
+      sigma = sigma16_32;
+      toClean.push(k);
     } else {
-      return { score, matched: false };
+      abytes(key, 32, "arx key");
+      throw new Error("invalid key size");
     }
-  }
-  if (varArgsSpec && !varArgsSpec.isAnyType && !isNull(varArgsSpec.arrowType)) {
-    for (let i = specs.length;i < actualTypes.length; i++) {
-      const actual = actualTypes[i];
-      if (actual === null)
-        continue;
-      if (typesIdentical(actual, varArgsSpec.arrowType)) {
-        score += EXACT_MATCH_SCORE;
-      } else if (typesCompatible(actual, varArgsSpec.arrowType)) {
-        score += FAMILY_MATCH_SCORE;
-      } else {
-        return { score, matched: false };
+    if (!isLE || !isAligned32(nonce))
+      toClean.push(nonce = copyBytes(nonce));
+    let k32 = u32(k);
+    if (extendNonceFn) {
+      if (nonce.length !== 24)
+        throw new Error("arx: extended nonce must be 24 bytes");
+      const n16 = nonce.subarray(0, 16);
+      if (isLE)
+        extendNonceFn(sigma, k32, u32(n16), k32);
+      else {
+        const sigmaRaw = swap32IfBE(Uint32Array.from(sigma));
+        extendNonceFn(sigmaRaw, k32, u32(n16), k32);
+        clean(sigmaRaw);
+        swap32IfBE(k32);
       }
+      nonce = nonce.subarray(16);
+    } else if (!isLE)
+      swap32IfBE(k32);
+    const nonceNcLen = 16 - counterLength;
+    if (nonceNcLen !== nonce.length)
+      throw new Error(`arx: nonce must be ${nonceNcLen} or 16 bytes`);
+    if (nonceNcLen !== 12) {
+      const nc = new Uint8Array(12);
+      nc.set(nonce, counterRight ? 0 : 12 - nonce.length);
+      nonce = nc;
+      toClean.push(nonce);
     }
-  }
-  return { score, matched: true };
-}
-function filterByArgumentTypes(candidates, args, inputSchema, isScalar) {
-  const scored = [];
-  for (const func of candidates) {
-    const specs = func.argumentSpecs;
-    let score = 0;
-    let matched = true;
-    if (isScalar) {
-      const constSpecs = specs.filter((s) => s.isConst);
-      const colSpecs = specs.filter((s) => !s.isConst && typeof s.position === "number");
-      const constTypes = [];
-      const argsSchema = args.argumentsSchema;
-      for (let i = 0;i < args.positional.length; i++) {
-        const field = argsSchema?.fields.find((f) => f.name === `positional_${i}`);
-        constTypes.push(field ? field.type : null);
-      }
-      const r1 = scoreTypes(constSpecs, constTypes);
-      score += r1.score;
-      matched = r1.matched;
-      if (matched && inputSchema) {
-        const colTypes = [];
-        let varArgsColSpec = null;
-        for (const spec of colSpecs) {
-          if (spec.isVarargs)
-            varArgsColSpec = spec;
-          const pos = spec.position;
-          colTypes.push(pos < inputSchema.fields.length ? inputSchema.fields[pos].type : null);
-        }
-        if (varArgsColSpec) {
-          const start = varArgsColSpec.position + 1;
-          for (let i = start;i < inputSchema.fields.length; i++) {
-            colTypes.push(inputSchema.fields[i].type);
-          }
-        }
-        const r2 = scoreTypes(colSpecs, colTypes);
-        score += r2.score;
-        matched = r2.matched;
-      }
-    } else {
-      const posSpecs = specs.filter((s) => typeof s.position === "number" && !s.isTableInput).sort((a, b) => a.position - b.position);
-      const posTypes = [];
-      if (func.meta.inputFromArgs) {
-        if (inputSchema) {
-          let varArgsSpec = null;
-          for (const spec of posSpecs) {
-            if (spec.isVarargs)
-              varArgsSpec = spec;
-            const pos = spec.position;
-            posTypes.push(pos < inputSchema.fields.length ? inputSchema.fields[pos].type : null);
-          }
-          if (varArgsSpec) {
-            for (let i = varArgsSpec.position + 1;i < inputSchema.fields.length; i++) {
-              posTypes.push(inputSchema.fields[i].type);
-            }
-          }
-        }
-      } else {
-        const argsSchema = args.argumentsSchema;
-        for (let i = 0;i < args.positional.length; i++) {
-          const field = argsSchema?.fields.find((f) => f.name === `positional_${i}`);
-          posTypes.push(field ? field.type : null);
-        }
-      }
-      const r = scoreTypes(posSpecs, posTypes);
-      score += r.score;
-      matched = r.matched;
-    }
-    if (matched) {
-      scored.push({ score, func });
+    const n32 = swap32IfBE(u32(nonce));
+    try {
+      runCipher(core, sigma, k32, n32, data, output, counter, rounds);
+      return output;
+    } finally {
+      clean(...toClean);
     }
-  }
-  if (scored.length === 0)
-    return [];
-  const maxScore = Math.max(...scored.map((s) => s.score));
-  return scored.filter((s) => s.score === maxScore).map((s) => s.func);
-}
-function schemaKey(schemaPath, functionName) {
-  return `${schemaPathKey(schemaPath)}\x01${functionName}`;
+  };
 }
-function catalogKey(catalogName, schemaPath, functionName) {
-  return `${catalogName.toLowerCase()}\x00${schemaKey(schemaPath, functionName)}`;
+
+// node_modules/@noble/ciphers/_poly1305.js
+function u8to16(a, i) {
+  return a[i++] & 255 | (a[i++] & 255) << 8;
 }
 
-class FunctionRegistry {
-  _functions = new Map;
-  _bySchema = new Map;
-  _byCatalog = new Map;
-  register(func) {
-    const name = func.meta.name;
-    if (!this._functions.has(name)) {
-      this._functions.set(name, []);
-    }
-    this._functions.get(name).push(func);
-  }
-  registerInSchema(func, schemaPath, catalogName) {
-    const add = (map, key) => {
-      const bucket = map.get(key);
-      if (!bucket) {
-        map.set(key, [func]);
-        return;
-      }
-      if (!bucket.includes(func))
-        bucket.push(func);
-    };
-    add(this._bySchema, schemaKey(schemaPath, func.meta.name));
-    if (catalogName) {
-      add(this._byCatalog, catalogKey(catalogName, schemaPath, func.meta.name));
-    }
-  }
-  schemasFor(functionName) {
-    const out = [];
-    for (const key of this._bySchema.keys()) {
-      const separator = key.lastIndexOf("\x01");
-      const name = key.slice(separator + 1);
-      if (name === functionName)
-        out.push(key.slice(0, separator).split("\x00"));
-    }
-    return out.sort((left, right) => schemaPathKey(left).localeCompare(schemaPathKey(right)));
-  }
-  get(name, context) {
-    let candidates = this._functions.get(name);
-    const catalogName = context?.catalogName;
-    const schemaPath = context?.schemaPath;
-    if (catalogName && schemaPath) {
-      const scoped = this._byCatalog.get(catalogKey(catalogName, schemaPath, name));
-      if (scoped && scoped.length > 0) {
-        return this._disambiguate(name, scoped, context);
-      }
-    }
-    if (schemaPath) {
-      const scoped = this._bySchema.get(schemaKey(schemaPath, 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 ${schemaPathDisplay(schemaPath)}. ` + `It is available in: [${schemas.map(schemaPathDisplay).join(", ")}]`);
-        }
-      }
-    }
-    if (!candidates || candidates.length === 0) {
-      throw new FunctionNotFoundError(name, this.names());
-    }
-    return this._disambiguate(name, candidates, context);
+class Poly1305 {
+  blockLen = 16;
+  outputLen = 16;
+  buffer = new Uint8Array(16);
+  r = new Uint16Array(10);
+  h = new Uint16Array(10);
+  pad = new Uint16Array(8);
+  pos = 0;
+  finished = false;
+  destroyed = false;
+  constructor(key) {
+    key = copyBytes(abytes(key, 32, "key"));
+    const t0 = u8to16(key, 0);
+    const t1 = u8to16(key, 2);
+    const t2 = u8to16(key, 4);
+    const t3 = u8to16(key, 6);
+    const t4 = u8to16(key, 8);
+    const t5 = u8to16(key, 10);
+    const t6 = u8to16(key, 12);
+    const t7 = u8to16(key, 14);
+    this.r[0] = t0 & 8191;
+    this.r[1] = (t0 >>> 13 | t1 << 3) & 8191;
+    this.r[2] = (t1 >>> 10 | t2 << 6) & 7939;
+    this.r[3] = (t2 >>> 7 | t3 << 9) & 8191;
+    this.r[4] = (t3 >>> 4 | t4 << 12) & 255;
+    this.r[5] = t4 >>> 1 & 8190;
+    this.r[6] = (t4 >>> 14 | t5 << 2) & 8191;
+    this.r[7] = (t5 >>> 11 | t6 << 5) & 8065;
+    this.r[8] = (t6 >>> 8 | t7 << 8) & 8191;
+    this.r[9] = t7 >>> 5 & 127;
+    for (let i = 0;i < 8; i++)
+      this.pad[i] = u8to16(key, 16 + 2 * i);
   }
-  _disambiguate(name, candidates, context) {
-    if (candidates.length === 1) {
-      return candidates[0];
-    }
-    if (!context?.arguments) {
-      return candidates[0];
-    }
-    const args = context.arguments;
-    const isScalar = context.isScalar ?? candidates[0].kind === "scalar";
-    let matches;
-    if (isScalar) {
-      const numConstArgs = args.positional.length;
-      matches = candidates.filter((func) => {
-        const constSpecs = func.argumentSpecs.filter((s) => s.isConst);
-        const hasVarargs = constSpecs.some((s) => s.isVarargs);
-        const nonVarargConst = constSpecs.filter((s) => !s.isVarargs).length;
-        if (hasVarargs) {
-          return numConstArgs >= nonVarargConst;
-        }
-        return constSpecs.length === numConstArgs;
-      });
-      if (matches.length === 0 || matches.length === candidates.length) {
-        matches = candidates;
-      }
-    } else {
-      const numArgs = args.positional.length;
-      matches = candidates.filter((func) => {
-        const posSpecs = func.argumentSpecs.filter((s) => typeof s.position === "number" && !s.isTableInput);
-        const hasVarargs = posSpecs.some((s) => s.isVarargs);
-        const nonVarargs = posSpecs.filter((s) => !s.isVarargs).length;
-        if (func.meta.inputFromArgs) {
-          const numInputCols = context.inputSchema?.fields.length ?? 0;
-          if (hasVarargs) {
-            if (numInputCols < nonVarargs)
-              return false;
-          } else if (numInputCols !== posSpecs.length) {
-            return false;
-          }
-          const validNamed = new Set(func.argumentSpecs.filter((s) => typeof s.position === "string").map((s) => s.position));
-          for (const key of args.named.keys()) {
-            if (!validNamed.has(key))
-              return false;
-          }
-          return true;
-        }
-        if (hasVarargs) {
-          return numArgs >= nonVarargs;
-        }
-        return posSpecs.length === numArgs;
-      });
-      if (matches.length === 0) {
-        matches = candidates;
-      }
-    }
-    if (matches.length === 1) {
-      return matches[0];
-    }
-    const typeFiltered = filterByArgumentTypes(matches, args, context.inputSchema, isScalar);
-    if (typeFiltered.length === 1) {
-      return typeFiltered[0];
-    }
-    if (typeFiltered.length > 1) {
-      return typeFiltered[0];
+  process(data, offset, isLast = false) {
+    const hibit = isLast ? 0 : 1 << 11;
+    const { h, r } = this;
+    const r0 = r[0];
+    const r1 = r[1];
+    const r2 = r[2];
+    const r3 = r[3];
+    const r4 = r[4];
+    const r5 = r[5];
+    const r6 = r[6];
+    const r7 = r[7];
+    const r8 = r[8];
+    const r9 = r[9];
+    const t0 = u8to16(data, offset + 0);
+    const t1 = u8to16(data, offset + 2);
+    const t2 = u8to16(data, offset + 4);
+    const t3 = u8to16(data, offset + 6);
+    const t4 = u8to16(data, offset + 8);
+    const t5 = u8to16(data, offset + 10);
+    const t6 = u8to16(data, offset + 12);
+    const t7 = u8to16(data, offset + 14);
+    let h0 = h[0] + (t0 & 8191);
+    let h1 = h[1] + ((t0 >>> 13 | t1 << 3) & 8191);
+    let h2 = h[2] + ((t1 >>> 10 | t2 << 6) & 8191);
+    let h3 = h[3] + ((t2 >>> 7 | t3 << 9) & 8191);
+    let h4 = h[4] + ((t3 >>> 4 | t4 << 12) & 8191);
+    let h5 = h[5] + (t4 >>> 1 & 8191);
+    let h6 = h[6] + ((t4 >>> 14 | t5 << 2) & 8191);
+    let h7 = h[7] + ((t5 >>> 11 | t6 << 5) & 8191);
+    let h8 = h[8] + ((t6 >>> 8 | t7 << 8) & 8191);
+    let h9 = h[9] + (t7 >>> 5 | hibit);
+    let c = 0;
+    let d0 = c + h0 * r0 + h1 * (5 * r9) + h2 * (5 * r8) + h3 * (5 * r7) + h4 * (5 * r6);
+    c = d0 >>> 13;
+    d0 &= 8191;
+    d0 += h5 * (5 * r5) + h6 * (5 * r4) + h7 * (5 * r3) + h8 * (5 * r2) + h9 * (5 * r1);
+    c += d0 >>> 13;
+    d0 &= 8191;
+    let d1 = c + h0 * r1 + h1 * r0 + h2 * (5 * r9) + h3 * (5 * r8) + h4 * (5 * r7);
+    c = d1 >>> 13;
+    d1 &= 8191;
+    d1 += h5 * (5 * r6) + h6 * (5 * r5) + h7 * (5 * r4) + h8 * (5 * r3) + h9 * (5 * r2);
+    c += d1 >>> 13;
+    d1 &= 8191;
+    let d2 = c + h0 * r2 + h1 * r1 + h2 * r0 + h3 * (5 * r9) + h4 * (5 * r8);
+    c = d2 >>> 13;
+    d2 &= 8191;
+    d2 += h5 * (5 * r7) + h6 * (5 * r6) + h7 * (5 * r5) + h8 * (5 * r4) + h9 * (5 * r3);
+    c += d2 >>> 13;
+    d2 &= 8191;
+    let d3 = c + h0 * r3 + h1 * r2 + h2 * r1 + h3 * r0 + h4 * (5 * r9);
+    c = d3 >>> 13;
+    d3 &= 8191;
+    d3 += h5 * (5 * r8) + h6 * (5 * r7) + h7 * (5 * r6) + h8 * (5 * r5) + h9 * (5 * r4);
+    c += d3 >>> 13;
+    d3 &= 8191;
+    let d4 = c + h0 * r4 + h1 * r3 + h2 * r2 + h3 * r1 + h4 * r0;
+    c = d4 >>> 13;
+    d4 &= 8191;
+    d4 += h5 * (5 * r9) + h6 * (5 * r8) + h7 * (5 * r7) + h8 * (5 * r6) + h9 * (5 * r5);
+    c += d4 >>> 13;
+    d4 &= 8191;
+    let d5 = c + h0 * r5 + h1 * r4 + h2 * r3 + h3 * r2 + h4 * r1;
+    c = d5 >>> 13;
+    d5 &= 8191;
+    d5 += h5 * r0 + h6 * (5 * r9) + h7 * (5 * r8) + h8 * (5 * r7) + h9 * (5 * r6);
+    c += d5 >>> 13;
+    d5 &= 8191;
+    let d6 = c + h0 * r6 + h1 * r5 + h2 * r4 + h3 * r3 + h4 * r2;
+    c = d6 >>> 13;
+    d6 &= 8191;
+    d6 += h5 * r1 + h6 * r0 + h7 * (5 * r9) + h8 * (5 * r8) + h9 * (5 * r7);
+    c += d6 >>> 13;
+    d6 &= 8191;
+    let d7 = c + h0 * r7 + h1 * r6 + h2 * r5 + h3 * r4 + h4 * r3;
+    c = d7 >>> 13;
+    d7 &= 8191;
+    d7 += h5 * r2 + h6 * r1 + h7 * r0 + h8 * (5 * r9) + h9 * (5 * r8);
+    c += d7 >>> 13;
+    d7 &= 8191;
+    let d8 = c + h0 * r8 + h1 * r7 + h2 * r6 + h3 * r5 + h4 * r4;
+    c = d8 >>> 13;
+    d8 &= 8191;
+    d8 += h5 * r3 + h6 * r2 + h7 * r1 + h8 * r0 + h9 * (5 * r9);
+    c += d8 >>> 13;
+    d8 &= 8191;
+    let d9 = c + h0 * r9 + h1 * r8 + h2 * r7 + h3 * r6 + h4 * r5;
+    c = d9 >>> 13;
+    d9 &= 8191;
+    d9 += h5 * r4 + h6 * r3 + h7 * r2 + h8 * r1 + h9 * r0;
+    c += d9 >>> 13;
+    d9 &= 8191;
+    c = (c << 2) + c | 0;
+    c = c + d0 | 0;
+    d0 = c & 8191;
+    c = c >>> 13;
+    d1 += c;
+    h[0] = d0;
+    h[1] = d1;
+    h[2] = d2;
+    h[3] = d3;
+    h[4] = d4;
+    h[5] = d5;
+    h[6] = d6;
+    h[7] = d7;
+    h[8] = d8;
+    h[9] = d9;
+  }
+  finalize() {
+    const { h, pad } = this;
+    const g = new Uint16Array(10);
+    let c = h[1] >>> 13;
+    h[1] &= 8191;
+    for (let i = 2;i < 10; i++) {
+      h[i] += c;
+      c = h[i] >>> 13;
+      h[i] &= 8191;
     }
-    return candidates[0];
+    h[0] += c * 5;
+    c = h[0] >>> 13;
+    h[0] &= 8191;
+    h[1] += c;
+    c = h[1] >>> 13;
+    h[1] &= 8191;
+    h[2] += c;
+    g[0] = h[0] + 5;
+    c = g[0] >>> 13;
+    g[0] &= 8191;
+    for (let i = 1;i < 10; i++) {
+      g[i] = h[i] + c;
+      c = g[i] >>> 13;
+      g[i] &= 8191;
+    }
+    g[9] -= 1 << 13;
+    let mask = (c ^ 1) - 1;
+    for (let i = 0;i < 10; i++)
+      g[i] &= mask;
+    mask = ~mask;
+    for (let i = 0;i < 10; i++)
+      h[i] = h[i] & mask | g[i];
+    h[0] = (h[0] | h[1] << 13) & 65535;
+    h[1] = (h[1] >>> 3 | h[2] << 10) & 65535;
+    h[2] = (h[2] >>> 6 | h[3] << 7) & 65535;
+    h[3] = (h[3] >>> 9 | h[4] << 4) & 65535;
+    h[4] = (h[4] >>> 12 | h[5] << 1 | h[6] << 14) & 65535;
+    h[5] = (h[6] >>> 2 | h[7] << 11) & 65535;
+    h[6] = (h[7] >>> 5 | h[8] << 8) & 65535;
+    h[7] = (h[8] >>> 8 | h[9] << 5) & 65535;
+    let f = h[0] + pad[0];
+    h[0] = f & 65535;
+    for (let i = 1;i < 8; i++) {
+      f = (h[i] + pad[i] | 0) + (f >>> 16) | 0;
+      h[i] = f & 65535;
+    }
+    clean(g);
   }
-  has(name) {
-    return this._functions.has(name) && this._functions.get(name).length > 0;
+  update(data) {
+    aexists(this);
+    abytes(data);
+    data = copyBytes(data);
+    const { buffer, blockLen } = this;
+    const len = data.length;
+    for (let pos = 0;pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      if (take === blockLen) {
+        for (;blockLen <= len - pos; pos += blockLen)
+          this.process(data, pos);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(buffer, 0, false);
+        this.pos = 0;
+      }
+    }
+    return this;
   }
-  names() {
-    return [...this._functions.keys()].sort();
+  destroy() {
+    this.destroyed = true;
+    clean(this.h, this.r, this.buffer, this.pad);
   }
-  all() {
-    const result = [];
-    for (const candidates of this._functions.values()) {
-      result.push(...candidates);
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { buffer, h } = this;
+    let { pos } = this;
+    if (pos) {
+      buffer[pos++] = 1;
+      for (;pos < 16; pos++)
+        buffer[pos] = 0;
+      this.process(buffer, 0, true);
     }
-    return result;
+    this.finalize();
+    let opos = 0;
+    for (let i = 0;i < 8; i++) {
+      out[opos++] = h[i] >>> 0;
+      out[opos++] = h[i] >>> 8;
+    }
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
   }
 }
-// src/metadata/serialize.ts
-init_arrow();
-var EXAMPLE_STRUCT = struct2([
-  field2("sql", utf82(), false),
-  field2("description", utf82(), false),
-  field2("expected_output", utf82(), true)
-]);
-var PARAMETER_STRUCT = struct2([
-  field2("name", utf82(), false),
-  field2("position", int322(), true),
-  field2("position_name", utf82(), true),
-  field2("type_name", utf82(), true),
-  field2("description", utf82(), false),
-  field2("required", bool2(), false),
-  field2("default", utf82(), true),
-  field2("constraints", utf82(), true),
-  field2("is_table_input", bool2(), false),
-  field2("is_varargs", bool2(), false),
-  field2("is_const", bool2(), false)
-]);
-var FILTER_IDENTITY_STRUCT = struct2([
-  field2("namespace", utf82(), false),
-  field2("name", utf82(), false),
-  field2("version", uint642(), false)
-]);
-var FILTER_CONTEXT_STRUCT = struct2([
-  field2("profile", utf82(), false),
-  field2("provider_fingerprint", utf82(), true)
-]);
-var METADATA_SCHEMA = schema2([
-  field2("name", utf82(), false),
-  field2("class_name", utf82(), false),
-  field2("function_type", utf82(), false),
-  field2("description", utf82(), false),
-  field2("examples", list2(field2("item", EXAMPLE_STRUCT, true)), false),
-  field2("categories", list2(field2("item", utf82(), true)), false),
-  field2("tags", map2(field2("key", utf82(), false), field2("value", utf82(), true), false), false),
-  field2("parameters", list2(field2("item", PARAMETER_STRUCT, true)), false),
-  field2("stability", utf82(), false),
-  field2("null_handling", utf82(), false),
-  field2("argument_monotonicity", list2(field2("item", utf82(), true)), true),
-  field2("required_settings", list2(field2("item", utf82(), true)), false),
-  field2("required_secrets", list2(field2("item", utf82(), true)), false),
-  field2("projection_pushdown", bool2(), false),
-  field2("filter_pushdown", bool2(), false),
-  field2("filter_semantic_profiles", list2(field2("item", utf82(), true)), false),
-  field2("additional_filter_functions", list2(field2("item", FILTER_IDENTITY_STRUCT, true)), false),
-  field2("runtime_filter_algorithms", list2(field2("item", FILTER_IDENTITY_STRUCT, true)), false),
-  field2("filter_evaluation_contexts", list2(field2("item", FILTER_CONTEXT_STRUCT, true)), false),
-  field2("preserves_order", utf82(), false),
-  field2("max_workers", int322(), true),
-  field2("order_dependent", utf82(), false),
-  field2("distinct_dependent", utf82(), false)
-]);
-function metadataToRow(m) {
-  return {
-    name: m.name,
-    class_name: m.className,
-    function_type: m.functionType,
-    description: m.description,
-    examples: m.examples.map((e) => ({
-      sql: e.sql,
-      description: e.description,
-      expected_output: e.expectedOutput
-    })),
-    categories: m.categories,
-    tags: Object.entries(m.tags).map(([k, v]) => [k, v]),
-    parameters: m.parameters.map((p) => ({
-      name: p.name,
-      position: p.position,
-      position_name: p.positionName,
-      type_name: p.typeName,
-      description: p.description,
-      required: p.required,
-      default: p.default,
-      constraints: p.constraints,
-      is_table_input: p.isTableInput,
-      is_varargs: p.isVarargs,
-      is_const: p.isConst
-    })),
-    stability: m.stability,
-    null_handling: m.nullHandling,
-    argument_monotonicity: m.argumentMonotonicity,
-    required_settings: m.requiredSettings,
-    required_secrets: m.requiredSecrets,
-    projection_pushdown: m.projectionPushdown,
-    filter_pushdown: m.filterPushdown,
-    sampling_pushdown: m.samplingPushdown,
-    filter_semantic_profiles: m.filterSemanticProfiles,
-    additional_filter_functions: m.additionalFilterFunctions.map((value) => ({
-      ...value,
-      version: BigInt(value.version)
-    })),
-    runtime_filter_algorithms: m.runtimeFilterAlgorithms.map((value) => ({
-      ...value,
-      version: BigInt(value.version)
-    })),
-    filter_evaluation_contexts: m.filterEvaluationContexts.map((value) => ({
-      profile: value.profile,
-      provider_fingerprint: value.providerFingerprint
-    })),
-    preserves_order: m.preservesOrder,
-    max_workers: m.maxWorkers,
-    order_dependent: m.orderDependent,
-    distinct_dependent: m.distinctDependent
-  };
-}
-function metadatasToArrow(metadatas) {
-  if (metadatas.length === 0) {
-    return emptyBatch(METADATA_SCHEMA);
-  }
-  const rows = metadatas.map(metadataToRow);
-  const columns = {};
-  for (const f of METADATA_SCHEMA.fields) {
-    columns[f.name] = rows.map((r) => r[f.name]);
-  }
-  return batchFromColumns(columns, METADATA_SCHEMA);
-}
-function arrowToMetadatas(batch) {
-  const results = [];
-  for (let i = 0;i < batch.numRows; i++) {
-    const get = (name) => {
-      const col = batch.getChild(name);
-      return col ? col.get(i) : null;
-    };
-    const rawExamples = get("examples") ?? [];
-    const examples = [];
-    if (rawExamples && typeof rawExamples[Symbol.iterator] === "function") {
-      for (const e of rawExamples) {
-        if (e) {
-          examples.push({
-            sql: e.sql ?? "",
-            description: e.description ?? "",
-            expectedOutput: e.expected_output ?? null
-          });
-        }
-      }
-    }
-    const rawParams = get("parameters") ?? [];
-    const parameters = [];
-    if (rawParams && typeof rawParams[Symbol.iterator] === "function") {
-      for (const p of rawParams) {
-        if (p) {
-          parameters.push({
-            name: p.name ?? "",
-            position: p.position ?? null,
-            positionName: p.position_name ?? null,
-            typeName: p.type_name ?? null,
-            description: p.description ?? "",
-            required: p.required ?? true,
-            default: p.default ?? null,
-            constraints: p.constraints ?? null,
-            isTableInput: p.is_table_input ?? false,
-            isVarargs: p.is_varargs ?? false,
-            isConst: p.is_const ?? false
-          });
-        }
-      }
-    }
-    const rawCategories = get("categories") ?? [];
-    const categories = rawCategories ? [...rawCategories].filter((c) => c != null) : [];
-    const rawTags = get("tags");
-    const tags = {};
-    if (rawTags) {
-      if (typeof rawTags[Symbol.iterator] === "function") {
-        for (const entry of rawTags) {
-          if (Array.isArray(entry)) {
-            tags[String(entry[0])] = String(entry[1] ?? "");
-          } else if (entry && entry.key != null) {
-            tags[String(entry.key)] = String(entry.value ?? "");
-          }
-        }
-      }
-    }
-    const rawRequiredSettings = get("required_settings") ?? [];
-    const requiredSettings = rawRequiredSettings ? [...rawRequiredSettings].filter((s) => s != null) : [];
-    const rawRequiredSecrets = get("required_secrets") ?? [];
-    const requiredSecrets = rawRequiredSecrets ? [...rawRequiredSecrets].filter((s) => s != null) : [];
-    results.push({
-      name: get("name") ?? "",
-      className: get("class_name") ?? "",
-      functionType: get("function_type") ?? "TABLE",
-      description: get("description") ?? "",
-      examples,
-      categories,
-      tags,
-      parameters,
-      stability: get("stability") ?? "CONSISTENT",
-      nullHandling: get("null_handling") ?? "DEFAULT",
-      argumentMonotonicity: get("argument_monotonicity") == null ? null : [...get("argument_monotonicity")].map(String),
-      requiredSettings,
-      requiredSecrets,
-      projectionPushdown: get("projection_pushdown") ?? false,
-      filterPushdown: get("filter_pushdown") ?? false,
-      samplingPushdown: get("sampling_pushdown") ?? false,
-      filterSemanticProfiles: [...get("filter_semantic_profiles") ?? []].filter((s) => s != null).map(String),
-      additionalFilterFunctions: [...get("additional_filter_functions") ?? []].filter((v) => v != null).map((v) => ({
-        namespace: String(v.namespace),
-        name: String(v.name),
-        version: Number(v.version)
-      })),
-      runtimeFilterAlgorithms: [...get("runtime_filter_algorithms") ?? []].filter((v) => v != null).map((v) => ({
-        namespace: String(v.namespace),
-        name: String(v.name),
-        version: Number(v.version)
-      })),
-      filterEvaluationContexts: [...get("filter_evaluation_contexts") ?? []].filter((v) => v != null).map((v) => ({
-        profile: String(v.profile),
-        providerFingerprint: v.provider_fingerprint == null ? null : String(v.provider_fingerprint)
-      })),
-      preservesOrder: get("preserves_order") ?? "NO_ORDER_GUARANTEE",
-      maxWorkers: get("max_workers") ?? null,
-      orderDependent: get("order_dependent") ?? "NOT_ORDER_DEPENDENT",
-      distinctDependent: get("distinct_dependent") ?? "NOT_DISTINCT_DEPENDENT"
-    });
-  }
-  return results;
-}
-// src/protocol/dispatch.ts
-import { Protocol } from "@query-farm/vgi-rpc";
-
-// src/protocol/handlers/function.ts
-init_arrow();
+var poly1305 = /* @__PURE__ */ wrapMacConstructor(32, (key) => new Poly1305(key));
 
-// src/protocol/handlers/shared.ts
-init_arrow();
-var RESULT_BINARY_SCHEMA = schema2([
-  field2("result", binary2(), false)
-]);
-var REQUEST_PARAMS_SCHEMA = schema2([
-  field2("request", binary2(), false)
-]);
-var RESULT_BINARY_NULLABLE_SCHEMA = schema2([
-  field2("result", binary2(), true)
-]);
-function unwrapRequest(requestBytes) {
-  const bytes = toUint8Array(requestBytes);
-  const innerBatch = deserializeBatch(bytes);
-  const params = batchToScalarDict(innerBatch);
-  normalizeRequestSchemaPaths(params);
-  return params;
+// node_modules/@noble/ciphers/chacha.js
+function chachaCore(s, k, n, out, cnt, rounds = 20) {
+  let y00 = s[0], y01 = s[1], y02 = s[2], y03 = s[3], y04 = k[0], y05 = k[1], y06 = k[2], y07 = k[3], y08 = k[4], y09 = k[5], y10 = k[6], y11 = k[7], y12 = cnt, y13 = n[0], y14 = n[1], y15 = n[2];
+  let x00 = y00, x01 = y01, x02 = y02, x03 = y03, x04 = y04, x05 = y05, x06 = y06, x07 = y07, x08 = y08, x09 = y09, x10 = y10, x11 = y11, x12 = y12, x13 = y13, x14 = y14, x15 = y15;
+  for (let r = 0;r < rounds; r += 2) {
+    x00 = x00 + x04 | 0;
+    x12 = rotl(x12 ^ x00, 16);
+    x08 = x08 + x12 | 0;
+    x04 = rotl(x04 ^ x08, 12);
+    x00 = x00 + x04 | 0;
+    x12 = rotl(x12 ^ x00, 8);
+    x08 = x08 + x12 | 0;
+    x04 = rotl(x04 ^ x08, 7);
+    x01 = x01 + x05 | 0;
+    x13 = rotl(x13 ^ x01, 16);
+    x09 = x09 + x13 | 0;
+    x05 = rotl(x05 ^ x09, 12);
+    x01 = x01 + x05 | 0;
+    x13 = rotl(x13 ^ x01, 8);
+    x09 = x09 + x13 | 0;
+    x05 = rotl(x05 ^ x09, 7);
+    x02 = x02 + x06 | 0;
+    x14 = rotl(x14 ^ x02, 16);
+    x10 = x10 + x14 | 0;
+    x06 = rotl(x06 ^ x10, 12);
+    x02 = x02 + x06 | 0;
+    x14 = rotl(x14 ^ x02, 8);
+    x10 = x10 + x14 | 0;
+    x06 = rotl(x06 ^ x10, 7);
+    x03 = x03 + x07 | 0;
+    x15 = rotl(x15 ^ x03, 16);
+    x11 = x11 + x15 | 0;
+    x07 = rotl(x07 ^ x11, 12);
+    x03 = x03 + x07 | 0;
+    x15 = rotl(x15 ^ x03, 8);
+    x11 = x11 + x15 | 0;
+    x07 = rotl(x07 ^ x11, 7);
+    x00 = x00 + x05 | 0;
+    x15 = rotl(x15 ^ x00, 16);
+    x10 = x10 + x15 | 0;
+    x05 = rotl(x05 ^ x10, 12);
+    x00 = x00 + x05 | 0;
+    x15 = rotl(x15 ^ x00, 8);
+    x10 = x10 + x15 | 0;
+    x05 = rotl(x05 ^ x10, 7);
+    x01 = x01 + x06 | 0;
+    x12 = rotl(x12 ^ x01, 16);
+    x11 = x11 + x12 | 0;
+    x06 = rotl(x06 ^ x11, 12);
+    x01 = x01 + x06 | 0;
+    x12 = rotl(x12 ^ x01, 8);
+    x11 = x11 + x12 | 0;
+    x06 = rotl(x06 ^ x11, 7);
+    x02 = x02 + x07 | 0;
+    x13 = rotl(x13 ^ x02, 16);
+    x08 = x08 + x13 | 0;
+    x07 = rotl(x07 ^ x08, 12);
+    x02 = x02 + x07 | 0;
+    x13 = rotl(x13 ^ x02, 8);
+    x08 = x08 + x13 | 0;
+    x07 = rotl(x07 ^ x08, 7);
+    x03 = x03 + x04 | 0;
+    x14 = rotl(x14 ^ x03, 16);
+    x09 = x09 + x14 | 0;
+    x04 = rotl(x04 ^ x09, 12);
+    x03 = x03 + x04 | 0;
+    x14 = rotl(x14 ^ x03, 8);
+    x09 = x09 + x14 | 0;
+    x04 = rotl(x04 ^ x09, 7);
+  }
+  let oi = 0;
+  out[oi++] = y00 + x00 | 0;
+  out[oi++] = y01 + x01 | 0;
+  out[oi++] = y02 + x02 | 0;
+  out[oi++] = y03 + x03 | 0;
+  out[oi++] = y04 + x04 | 0;
+  out[oi++] = y05 + x05 | 0;
+  out[oi++] = y06 + x06 | 0;
+  out[oi++] = y07 + x07 | 0;
+  out[oi++] = y08 + x08 | 0;
+  out[oi++] = y09 + x09 | 0;
+  out[oi++] = y10 + x10 | 0;
+  out[oi++] = y11 + x11 | 0;
+  out[oi++] = y12 + x12 | 0;
+  out[oi++] = y13 + x13 | 0;
+  out[oi++] = y14 + x14 | 0;
+  out[oi++] = y15 + x15 | 0;
 }
-function normalizeRequestSchemaPaths(params) {
-  if (params.path != null)
-    params.path = normalizeSchemaPath(params.path);
-  if (params.schema_path != null)
-    params.schema_path = normalizeSchemaPath(params.schema_path);
+function hchacha(s, k, i, out) {
+  const s2 = isLE ? s : swap32IfBE(s.slice(0, 4));
+  const k2 = isLE ? k : swap32IfBE(k.slice(0, 8));
+  const i2 = isLE ? i : swap32IfBE(i.slice(0, 4));
+  const t = new Uint32Array(16);
+  chachaCore(s2, k2, i2.subarray(1), t, i2[0]);
+  let oi = 0;
+  out[oi++] = t[0] - s2[0] | 0;
+  out[oi++] = t[1] - s2[1] | 0;
+  out[oi++] = t[2] - s2[2] | 0;
+  out[oi++] = t[3] - s2[3] | 0;
+  out[oi++] = t[12] - i2[0] | 0;
+  out[oi++] = t[13] - i2[1] | 0;
+  out[oi++] = t[14] - i2[2] | 0;
+  out[oi++] = t[15] - i2[3] | 0;
+  swap32IfBE(out);
+  if (!isLE)
+    clean(s2, k2, i2);
+  clean(t);
 }
-function wrapResult(values, innerSchema) {
-  const a = innerSchema;
-  const batch = batchFromColumns(Object.fromEntries(a.fields.map((f) => [f.name, [values[f.name] ?? null]])), a);
-  return { result: serializeBatch(batch) };
+var xchacha20 = /* @__PURE__ */ createCipher(chachaCore, {
+  counterRight: false,
+  counterLength: 8,
+  extendNonceFn: hchacha,
+  allowShortKeys: false
+});
+var ZEROS16 = /* @__PURE__ */ new Uint8Array(16);
+var updatePadded = (h, msg) => {
+  h.update(msg);
+  const leftover = msg.length % 16;
+  if (leftover)
+    h.update(ZEROS16.subarray(leftover));
+};
+var ZEROS32 = /* @__PURE__ */ new Uint8Array(32);
+function computeTag(fn, key, nonce, ciphertext, AAD) {
+  if (AAD !== undefined)
+    abytes(AAD, undefined, "AAD");
+  const authKey = fn(key, nonce, ZEROS32);
+  const lengths = u64Lengths(ciphertext.length, AAD ? AAD.length : 0, true);
+  const h = poly1305.create(authKey);
+  if (AAD)
+    updatePadded(h, AAD);
+  updatePadded(h, ciphertext);
+  h.update(lengths);
+  const res = h.digest();
+  clean(authKey, lengths);
+  return res;
 }
-function overloadContext(req, catalogInterface) {
-  let catalogName = null;
-  if (catalogInterface && req.attach_opaque_data) {
-    try {
-      catalogName = catalogInterface.catalogNameForAttach(req.attach_opaque_data);
-    } catch {
-      catalogName = null;
-    }
-  }
+var _poly1305_aead = (xorStream) => (key, nonce, AAD) => {
+  const tagLength = 16;
   return {
-    arguments: req.arguments,
-    inputSchema: req.input_schema,
-    isScalar: String(req.function_type).toLowerCase() === "scalar",
-    schemaPath: req.schema_path ?? null,
-    catalogName
+    encrypt(plaintext, output) {
+      const plength = plaintext.length;
+      output = getOutput(plength + tagLength, output, false);
+      output.set(plaintext);
+      const oPlain = output.subarray(0, -tagLength);
+      xorStream(key, nonce, oPlain, oPlain, 1);
+      const tag = computeTag(xorStream, key, nonce, oPlain, AAD);
+      output.set(tag, plength);
+      clean(tag);
+      return output;
+    },
+    decrypt(ciphertext, output) {
+      output = getOutput(ciphertext.length - tagLength, output, false);
+      const data = ciphertext.subarray(0, -tagLength);
+      const passedTag = ciphertext.subarray(-tagLength);
+      const tag = computeTag(xorStream, key, nonce, data, AAD);
+      if (!equalBytes(passedTag, tag)) {
+        clean(tag);
+        throw new Error("invalid tag");
+      }
+      output.set(ciphertext.subarray(0, -tagLength));
+      xorStream(key, nonce, output, output, 1);
+      clean(tag);
+      return output;
+    }
   };
-}
+};
+var xchacha20poly1305 = /* @__PURE__ */ wrapCipher({ blockSize: 64, nonceLength: 24, tagLength: 16, withAAD: true }, /* @__PURE__ */ _poly1305_aead(xchacha20));
 
-// src/protocol/handlers/catalog/shared.ts
-init_arrow();
+// src/crypto.ts
+var _UTF8 = new TextEncoder;
+var ATTACH_ENVELOPE_VERSION = 2;
+var TRANSACTION_ENVELOPE_VERSION = 2;
+var ATTACH_UUID_LEN = 16;
+var NONCE_LEN = 24;
+var TAG_LEN = 16;
+var MIN_ENVELOPE_LEN = 1 + NONCE_LEN + TAG_LEN;
+var ATTACH_AAD_PREFIX = _UTF8.encode("vgi.attach_opaque_data.v1\x00");
+var TRANSACTION_AAD_PREFIX = _UTF8.encode("vgi.transaction_opaque_data.v1\x00");
 
-// node_modules/@noble/ciphers/utils.js
-/*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) */
-function isBytes(a) {
-  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
-}
-var atitle = (title) => title ? `"${title}" ` : "";
-function abool(value, title = "") {
-  if (typeof value !== "boolean")
-    throw new TypeError(atitle(title) + "expected boolean, got type=" + typeof value);
-  return value;
-}
-function anumber(n, title = "") {
-  if (typeof n !== "number")
-    throw new TypeError(atitle(title) + "expected number, got " + typeof n);
-  if (!Number.isSafeInteger(n) || n < 0)
-    throw new RangeError(atitle(title) + "expected integer >= 0, got " + n);
-  return n;
-}
-function abytes(value, length, title = "") {
-  if (isBytes(value) && (length === undefined || value.length === length))
-    return value;
-  if (length !== undefined)
-    anumber(length, "length");
-  const bytes = isBytes(value);
-  const ofLen = length !== undefined ? ` of length ${length}` : "";
-  const got = bytes ? `length=${value.length}` : `type=${typeof value}`;
-  const message = atitle(title) + "expected Uint8Array" + ofLen + ", got " + got;
-  if (!bytes)
-    throw new TypeError(message);
-  throw new RangeError(message);
-}
-var aobject = (value, label) => {
-  if (value === null || typeof value !== "object" || Array.isArray(value))
-    throw new TypeError(label === "object" ? "expected valid options object" : `"${label}" expected object, got type=${typeof value}`);
-};
-function aexists(instance, checkFinished = true) {
-  if (instance.destroyed)
-    throw new Error("hash was destroyed");
-  if (checkFinished && instance.finished)
-    throw new Error("digest() was already called");
-}
-function aoutput(out, instance) {
-  abytes(out, undefined, "output");
-  const min = instance.outputLen;
-  if (!(out.length >= min)) {
-    throw new RangeError('"output" expected length >= ' + min);
+class OpaqueDataRejectedError extends Error {
+  errorCode = "INVALID_ARGUMENT";
+  errorKind = "opaque_data_not_recognized";
+  constructor(field = "opaque data") {
+    super(`${field} not recognized`);
+    this.name = "OpaqueDataRejectedError";
   }
 }
-function u32(arr) {
-  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
-}
-function clean(...arrays) {
-  for (let i = 0;i < arrays.length; i++) {
-    arrays[i].fill(0);
+function concat(...parts) {
+  let total = 0;
+  for (const p of parts)
+    total += p.length;
+  const out = new Uint8Array(total);
+  let off = 0;
+  for (const p of parts) {
+    out.set(p, off);
+    off += p.length;
   }
+  return out;
 }
-function createView(arr) {
-  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+async function normalizeKey(key) {
+  if (key.length === 32)
+    return key;
+  return new Uint8Array(await crypto.subtle.digest("SHA-256", key));
 }
-var isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
-function byteSwap(word) {
-  return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+function identityTail(auth) {
+  if (!auth || !auth.authenticated)
+    return _UTF8.encode("\x00anonymous");
+  const domain = _UTF8.encode(auth.domain ?? "");
+  const principal = _UTF8.encode(auth.principal ?? "");
+  return concat(Uint8Array.of(1), domain, Uint8Array.of(0), principal);
 }
-function byteSwap32(arr) {
-  for (let i = 0;i < arr.length; i++) {
-    arr[i] = byteSwap(arr[i]);
-  }
-  return arr;
+function attachAad(auth) {
+  return concat(ATTACH_AAD_PREFIX, identityTail(auth));
 }
-var swap32IfBE = isLE ? (u) => u : byteSwap32;
-function checkOpts(defaults, opts) {
-  aobject(defaults, "defaults");
-  aobject(opts, "opts");
-  const merged = Object.assign(defaults, opts);
-  return merged;
+function transactionAad(auth, attachEnvelope) {
+  return concat(TRANSACTION_AAD_PREFIX, identityTail(auth), Uint8Array.of(0), attachEnvelope);
 }
-function equalBytes(a, b) {
-  a = abytes(a);
-  b = abytes(b);
-  if (a.length !== b.length)
-    return false;
-  let diff = 0;
-  for (let i = 0;i < a.length; i++)
-    diff |= a[i] ^ b[i];
-  return diff === 0;
+async function sealBytes(payload, key, aad, version, fixedNonce) {
+  if (fixedNonce !== undefined && fixedNonce.length !== NONCE_LEN) {
+    throw new Error(`nonce must be ${NONCE_LEN} bytes`);
+  }
+  const nonce = fixedNonce ?? crypto.getRandomValues(new Uint8Array(NONCE_LEN));
+  const ciphertext = xchacha20poly1305(await normalizeKey(key), nonce, aad).encrypt(payload);
+  const out = new Uint8Array(1 + NONCE_LEN + ciphertext.length);
+  out[0] = version & 255;
+  out.set(nonce, 1);
+  out.set(ciphertext, 1 + NONCE_LEN);
+  return out;
 }
-function wrapMacConstructor(keyLen, macCons, fromMsg) {
-  const mac = macCons;
-  const getArgs = fromMsg || (() => []);
-  const macC = (msg, key) => mac(key, ...getArgs(msg)).update(msg).digest();
-  const tmp = mac(new Uint8Array(keyLen), ...getArgs(new Uint8Array(0)));
-  macC.outputLen = tmp.outputLen;
-  macC.blockLen = tmp.blockLen;
-  macC.create = (key, ...args) => mac(key, ...args);
-  return macC;
+async function openBytes(token, key, aad, version, field = "opaque data") {
+  if (token.length < MIN_ENVELOPE_LEN || token[0] !== (version & 255)) {
+    throw new OpaqueDataRejectedError(field);
+  }
+  const nonce = token.subarray(1, 1 + NONCE_LEN);
+  const ciphertext = token.subarray(1 + NONCE_LEN);
+  try {
+    return xchacha20poly1305(await normalizeKey(key), nonce, aad).decrypt(ciphertext);
+  } catch {
+    throw new OpaqueDataRejectedError(field);
+  }
 }
-var wrapCipher = (params, constructor) => {
-  function wrappedCipher(key, ...args) {
-    abytes(key, undefined, "key");
-    if (params.nonceLength !== undefined) {
-      const nonce = args[0];
-      abytes(nonce, params.varSizeNonce ? undefined : params.nonceLength, "nonce");
+
+// src/catalog/composite.ts
+var ROUTE_BYTE = 0;
+
+class CompositeCatalogInterface extends CatalogInterface {
+  _backends;
+  constructor(_backends) {
+    super();
+    this._backends = _backends;
+    if (_backends.length > 256) {
+      throw new Error("CompositeCatalog: at most 256 backends supported");
     }
-    const tagl = params.tagLength;
-    const aadStart = params.nonceLength !== undefined ? 1 : 0;
-    if (!params.withAAD) {
-      for (let i = aadStart;i < args.length; i++)
-        if (isBytes(args[i]))
-          throw new Error("AAD not supported");
+  }
+  _route(attachOpaqueData) {
+    const idx = attachOpaqueData[ROUTE_BYTE];
+    const route = this._backends[idx];
+    if (!route) {
+      throw new OpaqueDataRejectedError("attach_opaque_data");
     }
-    if (params.withAAD && args[aadStart] !== undefined)
-      abytes(args[aadStart], undefined, "AAD");
-    const cipher = constructor(key, ...args);
-    const checkOutput = (fnLength, output) => {
-      if (output !== undefined) {
-        if (fnLength !== 2)
-          throw new Error("cipher output not supported");
-        abytes(output, undefined, "output");
+    return route;
+  }
+  catalogNameForAttach(attachOpaqueData) {
+    try {
+      return this._route(attachOpaqueData).catalogNameForAttach(attachOpaqueData);
+    } catch {
+      return null;
+    }
+  }
+  catalogs() {
+    const all = [];
+    for (const b of this._backends)
+      all.push(...b.catalogs());
+    return all;
+  }
+  async catalogsInfo() {
+    const all = [];
+    for (const b of this._backends) {
+      if (b.catalogsInfo) {
+        all.push(...await b.catalogsInfo());
+      } else {
+        for (const name of b.catalogs()) {
+          all.push({ name, implementation_version: null, data_version_spec: null, attach_option_specs: [], releases: [] });
+        }
       }
-    };
-    let called = false;
-    const wrCipher = {
-      encrypt(data, output) {
-        if (called)
-          throw new Error("cannot encrypt() twice with same key + nonce");
-        called = true;
-        abytes(data, undefined, "data");
-        checkOutput(cipher.encrypt.length, output);
-        return cipher.encrypt(data, output);
-      },
-      decrypt(data, output) {
-        abytes(data, undefined, "data");
-        if (tagl && data.length < tagl)
-          throw new Error('"ciphertext" expected length >= tagLength=' + tagl);
-        checkOutput(cipher.decrypt.length, output);
-        return cipher.decrypt(data, output);
+    }
+    return all;
+  }
+  async attach(name, options, dataVersionSpec, implementationVersion) {
+    for (let i = 0;i < this._backends.length; i++) {
+      const b = this._backends[i];
+      if (b.catalogs().includes(name)) {
+        const result = await b.attach(name, options, dataVersionSpec, implementationVersion);
+        const stamped = new Uint8Array(result.attach_opaque_data);
+        stamped[ROUTE_BYTE] = i;
+        result.attach_opaque_data = stamped;
+        return result;
       }
-    };
-    return wrCipher;
+    }
+    throw new Error(`No worker handles catalog '${name}'`);
+  }
+  async detach(attachOpaqueData) {
+    await this._route(attachOpaqueData).detach(attachOpaqueData);
+  }
+  async version(attachOpaqueData, transactionOpaqueData) {
+    return await this._route(attachOpaqueData).version(attachOpaqueData, transactionOpaqueData);
+  }
+  async schemas(attachOpaqueData, transactionOpaqueData) {
+    return await this._route(attachOpaqueData).schemas(attachOpaqueData, transactionOpaqueData);
+  }
+  async schemaGet(attachOpaqueData, path, transactionOpaqueData) {
+    return await this._route(attachOpaqueData).schemaGet(attachOpaqueData, path, transactionOpaqueData);
+  }
+  async schemaContentsTables(attachOpaqueData, path, transactionOpaqueData) {
+    return await this._route(attachOpaqueData).schemaContentsTables(attachOpaqueData, path, transactionOpaqueData);
+  }
+  async schemaContentsViews(attachOpaqueData, path, transactionOpaqueData) {
+    return await this._route(attachOpaqueData).schemaContentsViews(attachOpaqueData, path, transactionOpaqueData);
+  }
+  async schemaContentsFunctions(attachOpaqueData, path, type, transactionOpaqueData) {
+    return await this._route(attachOpaqueData).schemaContentsFunctions(attachOpaqueData, path, type, transactionOpaqueData);
+  }
+  async schemaContentsMacros(attachOpaqueData, path, type, transactionOpaqueData) {
+    return await this._route(attachOpaqueData).schemaContentsMacros(attachOpaqueData, path, type, transactionOpaqueData);
+  }
+  async schemaContentsIndexes(attachOpaqueData, path, transactionOpaqueData) {
+    return await this._route(attachOpaqueData).schemaContentsIndexes(attachOpaqueData, path, transactionOpaqueData);
+  }
+  async indexGet(attachOpaqueData, schemaPath, name, transactionOpaqueData) {
+    return await this._route(attachOpaqueData).indexGet(attachOpaqueData, schemaPath, name, transactionOpaqueData);
+  }
+  async tableGet(attachOpaqueData, schemaPath, name, atUnit, atValue, transactionOpaqueData) {
+    return await this._route(attachOpaqueData).tableGet(attachOpaqueData, schemaPath, name, atUnit, atValue, transactionOpaqueData);
+  }
+  async tableScanFunctionGet(attachOpaqueData, schemaPath, name, atUnit, atValue, transactionOpaqueData) {
+    return await this._route(attachOpaqueData).tableScanFunctionGet(attachOpaqueData, schemaPath, name, atUnit, atValue, transactionOpaqueData);
+  }
+  async tableScanBranchesGet(attachOpaqueData, schemaPath, name, atUnit, atValue, transactionOpaqueData) {
+    return await this._route(attachOpaqueData).tableScanBranchesGet(attachOpaqueData, schemaPath, name, atUnit, atValue, transactionOpaqueData);
+  }
+  async tableColumnStatisticsGet(attachOpaqueData, schemaPath, name, transactionOpaqueData) {
+    return await this._route(attachOpaqueData).tableColumnStatisticsGet(attachOpaqueData, schemaPath, name, transactionOpaqueData);
+  }
+  async viewGet(attachOpaqueData, schemaPath, name, transactionOpaqueData) {
+    return await this._route(attachOpaqueData).viewGet(attachOpaqueData, schemaPath, name, transactionOpaqueData);
+  }
+  async macroGet(attachOpaqueData, schemaPath, name, transactionOpaqueData) {
+    return await this._route(attachOpaqueData).macroGet(attachOpaqueData, schemaPath, name, transactionOpaqueData);
+  }
+  async schemaCreate(...args) {
+    await this._route(args[0]).schemaCreate(...args);
+  }
+  async schemaDrop(...args) {
+    await this._route(args[0]).schemaDrop(...args);
+  }
+  async tableCreate(...args) {
+    await this._route(args[0]).tableCreate(...args);
+  }
+  async tableDrop(...args) {
+    await this._route(args[0]).tableDrop(...args);
+  }
+  async tableCommentSet(...args) {
+    await this._route(args[0]).tableCommentSet(...args);
+  }
+  async tableRename(...args) {
+    await this._route(args[0]).tableRename(...args);
+  }
+  async tableColumnAdd(...args) {
+    await this._route(args[0]).tableColumnAdd(...args);
+  }
+  async tableColumnDrop(...args) {
+    await this._route(args[0]).tableColumnDrop(...args);
+  }
+  async tableColumnRename(...args) {
+    await this._route(args[0]).tableColumnRename(...args);
+  }
+  async tableColumnDefaultSet(...args) {
+    await this._route(args[0]).tableColumnDefaultSet(...args);
+  }
+  async tableColumnDefaultDrop(...args) {
+    await this._route(args[0]).tableColumnDefaultDrop(...args);
+  }
+  async tableColumnTypeChange(...args) {
+    await this._route(args[0]).tableColumnTypeChange(...args);
+  }
+  async tableNotNullSet(...args) {
+    await this._route(args[0]).tableNotNullSet(...args);
+  }
+  async tableNotNullDrop(...args) {
+    await this._route(args[0]).tableNotNullDrop(...args);
+  }
+  async viewCreate(...args) {
+    await this._route(args[0]).viewCreate(...args);
+  }
+  async viewDrop(...args) {
+    await this._route(args[0]).viewDrop(...args);
+  }
+  async viewRename(...args) {
+    await this._route(args[0]).viewRename(...args);
+  }
+  async viewCommentSet(...args) {
+    await this._route(args[0]).viewCommentSet(...args);
+  }
+  async macroCreate(...args) {
+    await this._route(args[0]).macroCreate(...args);
+  }
+  async macroDrop(...args) {
+    await this._route(args[0]).macroDrop(...args);
+  }
+  async catalogContents(attachOpaqueData, ifNoneMatch) {
+    return await this._route(attachOpaqueData).catalogContents(attachOpaqueData, ifNoneMatch);
+  }
+  catalogContentsOwner(attachOpaqueData) {
+    return this._route(attachOpaqueData).catalogContentsOwner(attachOpaqueData);
+  }
+  async copyFromFormats(attachOpaqueData, transactionOpaqueData) {
+    return await this._route(attachOpaqueData).copyFromFormats(attachOpaqueData, transactionOpaqueData);
+  }
+  async transactionBegin(attachOpaqueData) {
+    return await this._route(attachOpaqueData).transactionBegin(attachOpaqueData);
+  }
+  async transactionCommit(attachOpaqueData, transactionOpaqueData) {
+    await this._route(attachOpaqueData).transactionCommit(attachOpaqueData, transactionOpaqueData);
+  }
+  async transactionRollback(attachOpaqueData, transactionOpaqueData) {
+    await this._route(attachOpaqueData).transactionRollback(attachOpaqueData, transactionOpaqueData);
   }
-  Object.assign(wrappedCipher, params);
-  return wrappedCipher;
-};
-function getOutput(expectedLength, out, onlyAligned = true) {
-  if (out === undefined)
-    return new Uint8Array(expectedLength);
-  abytes(out, expectedLength, "output");
-  if (onlyAligned && !isAligned32(out))
-    throw new Error("invalid output, must be aligned");
-  return out;
-}
-function u64Lengths(dataLength, aadLength, isLE) {
-  anumber(dataLength);
-  anumber(aadLength);
-  abool(isLE);
-  const num = new Uint8Array(16);
-  const view = createView(num);
-  view.setBigUint64(0, BigInt(aadLength), isLE);
-  view.setBigUint64(8, BigInt(dataLength), isLE);
-  return num;
-}
-function isAligned32(bytes) {
-  return bytes.byteOffset % 4 === 0;
 }
-function copyBytes(bytes) {
-  return Uint8Array.from(abytes(bytes));
+// src/functions/registry.ts
+init_arrow();
+var EXACT_MATCH_SCORE = 2;
+var FAMILY_MATCH_SCORE = 1;
+function typesIdentical(a, b) {
+  return typeSignature(a) === typeSignature(b);
 }
-
-// node_modules/@noble/ciphers/_arx.js
-var encodeStr = (str) => Uint8Array.from(str.split(""), (c) => c.charCodeAt(0));
-var sigma16_32 = /* @__PURE__ */ (() => swap32IfBE(u32(encodeStr("expand 16-byte k"))))();
-var sigma32_32 = /* @__PURE__ */ (() => swap32IfBE(u32(encodeStr("expand 32-byte k"))))();
-function rotl(a, b) {
-  return a << b | a >>> 32 - b;
+function typesCompatible(actual, declared) {
+  if (typesIdentical(actual, declared))
+    return true;
+  if (isInt(actual) && isInt(declared))
+    return true;
+  if ((isFloat(actual) || isDecimal(actual)) && (isFloat(declared) || isDecimal(declared)))
+    return true;
+  if (isUtf8(actual) && isUtf8(declared))
+    return true;
+  if (isBinary(actual) && isBinary(declared))
+    return true;
+  if (isBool(actual) && isBool(declared))
+    return true;
+  return false;
 }
-var BLOCK_LEN = 64;
-var BLOCK_LEN32 = 16;
-var MAX_COUNTER = /* @__PURE__ */ (() => 2 ** 32 - 1)();
-var U32_EMPTY = /* @__PURE__ */ Uint32Array.of();
-function runCipher(core, sigma, key, nonce, data, output, counter, rounds) {
-  const len = data.length;
-  const block = new Uint8Array(BLOCK_LEN);
-  const b32 = u32(block);
-  const isAligned = isLE && isAligned32(data) && isAligned32(output);
-  const d32 = isAligned ? u32(data) : U32_EMPTY;
-  const o32 = isAligned ? u32(output) : U32_EMPTY;
-  if (!isLE) {
-    for (let pos = 0;pos < len; counter++) {
-      core(sigma, key, nonce, b32, counter, rounds);
-      swap32IfBE(b32);
-      if (counter >= MAX_COUNTER)
-        throw new Error("arx: counter overflow");
-      const take = Math.min(BLOCK_LEN, len - pos);
-      for (let j = 0, posj;j < take; j++) {
-        posj = pos + j;
-        output[posj] = data[posj] ^ block[j];
-      }
-      pos += take;
+function scoreTypes(specs, actualTypes) {
+  let score = 0;
+  let varArgsSpec = null;
+  for (let i = 0;i < specs.length; i++) {
+    const spec = specs[i];
+    if (spec.isVarargs)
+      varArgsSpec = spec;
+    if (i >= actualTypes.length)
+      break;
+    if (spec.isAnyType || isNull(spec.arrowType))
+      continue;
+    const actual = actualTypes[i];
+    if (actual === null)
+      continue;
+    if (typesIdentical(actual, spec.arrowType)) {
+      score += EXACT_MATCH_SCORE;
+    } else if (typesCompatible(actual, spec.arrowType)) {
+      score += FAMILY_MATCH_SCORE;
+    } else {
+      return { score, matched: false };
     }
-    return;
   }
-  for (let pos = 0;pos < len; counter++) {
-    core(sigma, key, nonce, b32, counter, rounds);
-    if (counter >= MAX_COUNTER)
-      throw new Error("arx: counter overflow");
-    const take = Math.min(BLOCK_LEN, len - pos);
-    if (isAligned && take === BLOCK_LEN) {
-      const pos32 = pos / 4;
-      if (pos % 4 !== 0)
-        throw new Error("arx: invalid block position");
-      for (let j = 0, posj;j < BLOCK_LEN32; j++) {
-        posj = pos32 + j;
-        o32[posj] = d32[posj] ^ b32[j];
+  if (varArgsSpec && !varArgsSpec.isAnyType && !isNull(varArgsSpec.arrowType)) {
+    for (let i = specs.length;i < actualTypes.length; i++) {
+      const actual = actualTypes[i];
+      if (actual === null)
+        continue;
+      if (typesIdentical(actual, varArgsSpec.arrowType)) {
+        score += EXACT_MATCH_SCORE;
+      } else if (typesCompatible(actual, varArgsSpec.arrowType)) {
+        score += FAMILY_MATCH_SCORE;
+      } else {
+        return { score, matched: false };
       }
-      pos += BLOCK_LEN;
-      continue;
-    }
-    for (let j = 0, posj;j < take; j++) {
-      posj = pos + j;
-      output[posj] = data[posj] ^ block[j];
     }
-    pos += take;
   }
+  return { score, matched: true };
 }
-function createCipher(core, opts) {
-  const { allowShortKeys, extendNonceFn, counterLength, counterRight, rounds } = checkOpts({ allowShortKeys: false, counterLength: 8, counterRight: false, rounds: 20 }, opts);
-  if (typeof core !== "function")
-    throw new Error("core must be a function");
-  anumber(counterLength);
-  anumber(rounds);
-  abool(counterRight);
-  abool(allowShortKeys);
-  return (key, nonce, data, output, counter = 0) => {
-    abytes(key, undefined, "key");
-    abytes(nonce, undefined, "nonce");
-    abytes(data, undefined, "data");
-    const len = data.length;
-    output = getOutput(len, output, false);
-    anumber(counter);
-    if (counter < 0 || counter >= MAX_COUNTER)
-      throw new Error("arx: counter overflow");
-    const toClean = [];
-    let l = key.length;
-    let k;
-    let sigma;
-    if (l === 32) {
-      toClean.push(k = copyBytes(key));
-      sigma = sigma32_32;
-    } else if (l === 16 && allowShortKeys) {
-      k = new Uint8Array(32);
-      k.set(key);
-      k.set(key, 16);
-      sigma = sigma16_32;
-      toClean.push(k);
+function filterByArgumentTypes(candidates, args, inputSchema, isScalar) {
+  const scored = [];
+  for (const func of candidates) {
+    const specs = func.argumentSpecs;
+    let score = 0;
+    let matched = true;
+    if (isScalar) {
+      const constSpecs = specs.filter((s) => s.isConst);
+      const colSpecs = specs.filter((s) => !s.isConst && typeof s.position === "number");
+      const constTypes = [];
+      const argsSchema = args.argumentsSchema;
+      for (let i = 0;i < args.positional.length; i++) {
+        const field = argsSchema?.fields.find((f) => f.name === `positional_${i}`);
+        constTypes.push(field ? field.type : null);
+      }
+      const r1 = scoreTypes(constSpecs, constTypes);
+      score += r1.score;
+      matched = r1.matched;
+      if (matched && inputSchema) {
+        const colTypes = [];
+        let varArgsColSpec = null;
+        for (const spec of colSpecs) {
+          if (spec.isVarargs)
+            varArgsColSpec = spec;
+          const pos = spec.position;
+          colTypes.push(pos < inputSchema.fields.length ? inputSchema.fields[pos].type : null);
+        }
+        if (varArgsColSpec) {
+          const start = varArgsColSpec.position + 1;
+          for (let i = start;i < inputSchema.fields.length; i++) {
+            colTypes.push(inputSchema.fields[i].type);
+          }
+        }
+        const r2 = scoreTypes(colSpecs, colTypes);
+        score += r2.score;
+        matched = r2.matched;
+      }
     } else {
-      abytes(key, 32, "arx key");
-      throw new Error("invalid key size");
-    }
-    if (!isLE || !isAligned32(nonce))
-      toClean.push(nonce = copyBytes(nonce));
-    let k32 = u32(k);
-    if (extendNonceFn) {
-      if (nonce.length !== 24)
-        throw new Error("arx: extended nonce must be 24 bytes");
-      const n16 = nonce.subarray(0, 16);
-      if (isLE)
-        extendNonceFn(sigma, k32, u32(n16), k32);
-      else {
-        const sigmaRaw = swap32IfBE(Uint32Array.from(sigma));
-        extendNonceFn(sigmaRaw, k32, u32(n16), k32);
-        clean(sigmaRaw);
-        swap32IfBE(k32);
+      const posSpecs = specs.filter((s) => typeof s.position === "number" && !s.isTableInput).sort((a, b) => a.position - b.position);
+      const posTypes = [];
+      if (func.meta.inputFromArgs) {
+        if (inputSchema) {
+          let varArgsSpec = null;
+          for (const spec of posSpecs) {
+            if (spec.isVarargs)
+              varArgsSpec = spec;
+            const pos = spec.position;
+            posTypes.push(pos < inputSchema.fields.length ? inputSchema.fields[pos].type : null);
+          }
+          if (varArgsSpec) {
+            for (let i = varArgsSpec.position + 1;i < inputSchema.fields.length; i++) {
+              posTypes.push(inputSchema.fields[i].type);
+            }
+          }
+        }
+      } else {
+        const argsSchema = args.argumentsSchema;
+        for (let i = 0;i < args.positional.length; i++) {
+          const field = argsSchema?.fields.find((f) => f.name === `positional_${i}`);
+          posTypes.push(field ? field.type : null);
+        }
       }
-      nonce = nonce.subarray(16);
-    } else if (!isLE)
-      swap32IfBE(k32);
-    const nonceNcLen = 16 - counterLength;
-    if (nonceNcLen !== nonce.length)
-      throw new Error(`arx: nonce must be ${nonceNcLen} or 16 bytes`);
-    if (nonceNcLen !== 12) {
-      const nc = new Uint8Array(12);
-      nc.set(nonce, counterRight ? 0 : 12 - nonce.length);
-      nonce = nc;
-      toClean.push(nonce);
+      const r = scoreTypes(posSpecs, posTypes);
+      score += r.score;
+      matched = r.matched;
     }
-    const n32 = swap32IfBE(u32(nonce));
-    try {
-      runCipher(core, sigma, k32, n32, data, output, counter, rounds);
-      return output;
-    } finally {
-      clean(...toClean);
+    if (matched) {
+      scored.push({ score, func });
     }
-  };
+  }
+  if (scored.length === 0)
+    return [];
+  const maxScore = Math.max(...scored.map((s) => s.score));
+  return scored.filter((s) => s.score === maxScore).map((s) => s.func);
 }
-
-// node_modules/@noble/ciphers/_poly1305.js
-function u8to16(a, i) {
-  return a[i++] & 255 | (a[i++] & 255) << 8;
+function schemaKey(schemaPath, functionName) {
+  return `${schemaPathKey(schemaPath)}\x01${functionName}`;
+}
+function catalogKey(catalogName, schemaPath, functionName) {
+  return `${catalogName.toLowerCase()}\x00${schemaKey(schemaPath, functionName)}`;
 }
 
-class Poly1305 {
-  blockLen = 16;
-  outputLen = 16;
-  buffer = new Uint8Array(16);
-  r = new Uint16Array(10);
-  h = new Uint16Array(10);
-  pad = new Uint16Array(8);
-  pos = 0;
-  finished = false;
-  destroyed = false;
-  constructor(key) {
-    key = copyBytes(abytes(key, 32, "key"));
-    const t0 = u8to16(key, 0);
-    const t1 = u8to16(key, 2);
-    const t2 = u8to16(key, 4);
-    const t3 = u8to16(key, 6);
-    const t4 = u8to16(key, 8);
-    const t5 = u8to16(key, 10);
-    const t6 = u8to16(key, 12);
-    const t7 = u8to16(key, 14);
-    this.r[0] = t0 & 8191;
-    this.r[1] = (t0 >>> 13 | t1 << 3) & 8191;
-    this.r[2] = (t1 >>> 10 | t2 << 6) & 7939;
-    this.r[3] = (t2 >>> 7 | t3 << 9) & 8191;
-    this.r[4] = (t3 >>> 4 | t4 << 12) & 255;
-    this.r[5] = t4 >>> 1 & 8190;
-    this.r[6] = (t4 >>> 14 | t5 << 2) & 8191;
-    this.r[7] = (t5 >>> 11 | t6 << 5) & 8065;
-    this.r[8] = (t6 >>> 8 | t7 << 8) & 8191;
-    this.r[9] = t7 >>> 5 & 127;
-    for (let i = 0;i < 8; i++)
-      this.pad[i] = u8to16(key, 16 + 2 * i);
+class FunctionRegistry {
+  _functions = new Map;
+  _bySchema = new Map;
+  _byCatalog = new Map;
+  register(func) {
+    const name = func.meta.name;
+    if (!this._functions.has(name)) {
+      this._functions.set(name, []);
+    }
+    this._functions.get(name).push(func);
   }
-  process(data, offset, isLast = false) {
-    const hibit = isLast ? 0 : 1 << 11;
-    const { h, r } = this;
-    const r0 = r[0];
-    const r1 = r[1];
-    const r2 = r[2];
-    const r3 = r[3];
-    const r4 = r[4];
-    const r5 = r[5];
-    const r6 = r[6];
-    const r7 = r[7];
-    const r8 = r[8];
-    const r9 = r[9];
-    const t0 = u8to16(data, offset + 0);
-    const t1 = u8to16(data, offset + 2);
-    const t2 = u8to16(data, offset + 4);
-    const t3 = u8to16(data, offset + 6);
-    const t4 = u8to16(data, offset + 8);
-    const t5 = u8to16(data, offset + 10);
-    const t6 = u8to16(data, offset + 12);
-    const t7 = u8to16(data, offset + 14);
-    let h0 = h[0] + (t0 & 8191);
-    let h1 = h[1] + ((t0 >>> 13 | t1 << 3) & 8191);
-    let h2 = h[2] + ((t1 >>> 10 | t2 << 6) & 8191);
-    let h3 = h[3] + ((t2 >>> 7 | t3 << 9) & 8191);
-    let h4 = h[4] + ((t3 >>> 4 | t4 << 12) & 8191);
-    let h5 = h[5] + (t4 >>> 1 & 8191);
-    let h6 = h[6] + ((t4 >>> 14 | t5 << 2) & 8191);
-    let h7 = h[7] + ((t5 >>> 11 | t6 << 5) & 8191);
-    let h8 = h[8] + ((t6 >>> 8 | t7 << 8) & 8191);
-    let h9 = h[9] + (t7 >>> 5 | hibit);
-    let c = 0;
-    let d0 = c + h0 * r0 + h1 * (5 * r9) + h2 * (5 * r8) + h3 * (5 * r7) + h4 * (5 * r6);
-    c = d0 >>> 13;
-    d0 &= 8191;
-    d0 += h5 * (5 * r5) + h6 * (5 * r4) + h7 * (5 * r3) + h8 * (5 * r2) + h9 * (5 * r1);
-    c += d0 >>> 13;
-    d0 &= 8191;
-    let d1 = c + h0 * r1 + h1 * r0 + h2 * (5 * r9) + h3 * (5 * r8) + h4 * (5 * r7);
-    c = d1 >>> 13;
-    d1 &= 8191;
-    d1 += h5 * (5 * r6) + h6 * (5 * r5) + h7 * (5 * r4) + h8 * (5 * r3) + h9 * (5 * r2);
-    c += d1 >>> 13;
-    d1 &= 8191;
-    let d2 = c + h0 * r2 + h1 * r1 + h2 * r0 + h3 * (5 * r9) + h4 * (5 * r8);
-    c = d2 >>> 13;
-    d2 &= 8191;
-    d2 += h5 * (5 * r7) + h6 * (5 * r6) + h7 * (5 * r5) + h8 * (5 * r4) + h9 * (5 * r3);
-    c += d2 >>> 13;
-    d2 &= 8191;
-    let d3 = c + h0 * r3 + h1 * r2 + h2 * r1 + h3 * r0 + h4 * (5 * r9);
-    c = d3 >>> 13;
-    d3 &= 8191;
-    d3 += h5 * (5 * r8) + h6 * (5 * r7) + h7 * (5 * r6) + h8 * (5 * r5) + h9 * (5 * r4);
-    c += d3 >>> 13;
-    d3 &= 8191;
-    let d4 = c + h0 * r4 + h1 * r3 + h2 * r2 + h3 * r1 + h4 * r0;
-    c = d4 >>> 13;
-    d4 &= 8191;
-    d4 += h5 * (5 * r9) + h6 * (5 * r8) + h7 * (5 * r7) + h8 * (5 * r6) + h9 * (5 * r5);
-    c += d4 >>> 13;
-    d4 &= 8191;
-    let d5 = c + h0 * r5 + h1 * r4 + h2 * r3 + h3 * r2 + h4 * r1;
-    c = d5 >>> 13;
-    d5 &= 8191;
-    d5 += h5 * r0 + h6 * (5 * r9) + h7 * (5 * r8) + h8 * (5 * r7) + h9 * (5 * r6);
-    c += d5 >>> 13;
-    d5 &= 8191;
-    let d6 = c + h0 * r6 + h1 * r5 + h2 * r4 + h3 * r3 + h4 * r2;
-    c = d6 >>> 13;
-    d6 &= 8191;
-    d6 += h5 * r1 + h6 * r0 + h7 * (5 * r9) + h8 * (5 * r8) + h9 * (5 * r7);
-    c += d6 >>> 13;
-    d6 &= 8191;
-    let d7 = c + h0 * r7 + h1 * r6 + h2 * r5 + h3 * r4 + h4 * r3;
-    c = d7 >>> 13;
-    d7 &= 8191;
-    d7 += h5 * r2 + h6 * r1 + h7 * r0 + h8 * (5 * r9) + h9 * (5 * r8);
-    c += d7 >>> 13;
-    d7 &= 8191;
-    let d8 = c + h0 * r8 + h1 * r7 + h2 * r6 + h3 * r5 + h4 * r4;
-    c = d8 >>> 13;
-    d8 &= 8191;
-    d8 += h5 * r3 + h6 * r2 + h7 * r1 + h8 * r0 + h9 * (5 * r9);
-    c += d8 >>> 13;
-    d8 &= 8191;
-    let d9 = c + h0 * r9 + h1 * r8 + h2 * r7 + h3 * r6 + h4 * r5;
-    c = d9 >>> 13;
-    d9 &= 8191;
-    d9 += h5 * r4 + h6 * r3 + h7 * r2 + h8 * r1 + h9 * r0;
-    c += d9 >>> 13;
-    d9 &= 8191;
-    c = (c << 2) + c | 0;
-    c = c + d0 | 0;
-    d0 = c & 8191;
-    c = c >>> 13;
-    d1 += c;
-    h[0] = d0;
-    h[1] = d1;
-    h[2] = d2;
-    h[3] = d3;
-    h[4] = d4;
-    h[5] = d5;
-    h[6] = d6;
-    h[7] = d7;
-    h[8] = d8;
-    h[9] = d9;
+  registerInSchema(func, schemaPath, catalogName) {
+    const add = (map, key) => {
+      const bucket = map.get(key);
+      if (!bucket) {
+        map.set(key, [func]);
+        return;
+      }
+      if (!bucket.includes(func))
+        bucket.push(func);
+    };
+    add(this._bySchema, schemaKey(schemaPath, func.meta.name));
+    if (catalogName) {
+      add(this._byCatalog, catalogKey(catalogName, schemaPath, func.meta.name));
+    }
+  }
+  schemasFor(functionName) {
+    const out = [];
+    for (const key of this._bySchema.keys()) {
+      const separator = key.lastIndexOf("\x01");
+      const name = key.slice(separator + 1);
+      if (name === functionName)
+        out.push(key.slice(0, separator).split("\x00"));
+    }
+    return out.sort((left, right) => schemaPathKey(left).localeCompare(schemaPathKey(right)));
+  }
+  get(name, context) {
+    let candidates = this._functions.get(name);
+    const catalogName = context?.catalogName;
+    const schemaPath = context?.schemaPath;
+    if (catalogName && schemaPath) {
+      const scoped = this._byCatalog.get(catalogKey(catalogName, schemaPath, name));
+      if (scoped && scoped.length > 0) {
+        return this._disambiguate(name, scoped, context);
+      }
+    }
+    if (schemaPath) {
+      const scoped = this._bySchema.get(schemaKey(schemaPath, 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 ${schemaPathDisplay(schemaPath)}. ` + `It is available in: [${schemas.map(schemaPathDisplay).join(", ")}]`);
+        }
+      }
+    }
+    if (!candidates || candidates.length === 0) {
+      throw new FunctionNotFoundError(name, this.names());
+    }
+    return this._disambiguate(name, candidates, context);
   }
-  finalize() {
-    const { h, pad } = this;
-    const g = new Uint16Array(10);
-    let c = h[1] >>> 13;
-    h[1] &= 8191;
-    for (let i = 2;i < 10; i++) {
-      h[i] += c;
-      c = h[i] >>> 13;
-      h[i] &= 8191;
+  _disambiguate(name, candidates, context) {
+    if (candidates.length === 1) {
+      return candidates[0];
     }
-    h[0] += c * 5;
-    c = h[0] >>> 13;
-    h[0] &= 8191;
-    h[1] += c;
-    c = h[1] >>> 13;
-    h[1] &= 8191;
-    h[2] += c;
-    g[0] = h[0] + 5;
-    c = g[0] >>> 13;
-    g[0] &= 8191;
-    for (let i = 1;i < 10; i++) {
-      g[i] = h[i] + c;
-      c = g[i] >>> 13;
-      g[i] &= 8191;
+    if (!context?.arguments) {
+      return candidates[0];
     }
-    g[9] -= 1 << 13;
-    let mask = (c ^ 1) - 1;
-    for (let i = 0;i < 10; i++)
-      g[i] &= mask;
-    mask = ~mask;
-    for (let i = 0;i < 10; i++)
-      h[i] = h[i] & mask | g[i];
-    h[0] = (h[0] | h[1] << 13) & 65535;
-    h[1] = (h[1] >>> 3 | h[2] << 10) & 65535;
-    h[2] = (h[2] >>> 6 | h[3] << 7) & 65535;
-    h[3] = (h[3] >>> 9 | h[4] << 4) & 65535;
-    h[4] = (h[4] >>> 12 | h[5] << 1 | h[6] << 14) & 65535;
-    h[5] = (h[6] >>> 2 | h[7] << 11) & 65535;
-    h[6] = (h[7] >>> 5 | h[8] << 8) & 65535;
-    h[7] = (h[8] >>> 8 | h[9] << 5) & 65535;
-    let f = h[0] + pad[0];
-    h[0] = f & 65535;
-    for (let i = 1;i < 8; i++) {
-      f = (h[i] + pad[i] | 0) + (f >>> 16) | 0;
-      h[i] = f & 65535;
+    const args = context.arguments;
+    const isScalar = context.isScalar ?? candidates[0].kind === "scalar";
+    let matches;
+    if (isScalar) {
+      const numConstArgs = args.positional.length;
+      matches = candidates.filter((func) => {
+        const constSpecs = func.argumentSpecs.filter((s) => s.isConst);
+        const hasVarargs = constSpecs.some((s) => s.isVarargs);
+        const nonVarargConst = constSpecs.filter((s) => !s.isVarargs).length;
+        if (hasVarargs) {
+          return numConstArgs >= nonVarargConst;
+        }
+        return constSpecs.length === numConstArgs;
+      });
+      if (matches.length === 0 || matches.length === candidates.length) {
+        matches = candidates;
+      }
+    } else {
+      const numArgs = args.positional.length;
+      matches = candidates.filter((func) => {
+        const posSpecs = func.argumentSpecs.filter((s) => typeof s.position === "number" && !s.isTableInput);
+        const hasVarargs = posSpecs.some((s) => s.isVarargs);
+        const nonVarargs = posSpecs.filter((s) => !s.isVarargs).length;
+        if (func.meta.inputFromArgs) {
+          const numInputCols = context.inputSchema?.fields.length ?? 0;
+          if (hasVarargs) {
+            if (numInputCols < nonVarargs)
+              return false;
+          } else if (numInputCols !== posSpecs.length) {
+            return false;
+          }
+          const validNamed = new Set(func.argumentSpecs.filter((s) => typeof s.position === "string").map((s) => s.position));
+          for (const key of args.named.keys()) {
+            if (!validNamed.has(key))
+              return false;
+          }
+          return true;
+        }
+        if (hasVarargs) {
+          return numArgs >= nonVarargs;
+        }
+        return posSpecs.length === numArgs;
+      });
+      if (matches.length === 0) {
+        matches = candidates;
+      }
     }
-    clean(g);
+    if (matches.length === 1) {
+      return matches[0];
+    }
+    const typeFiltered = filterByArgumentTypes(matches, args, context.inputSchema, isScalar);
+    if (typeFiltered.length === 1) {
+      return typeFiltered[0];
+    }
+    if (typeFiltered.length > 1) {
+      return typeFiltered[0];
+    }
+    return candidates[0];
   }
-  update(data) {
-    aexists(this);
-    abytes(data);
-    data = copyBytes(data);
-    const { buffer, blockLen } = this;
-    const len = data.length;
-    for (let pos = 0;pos < len; ) {
-      const take = Math.min(blockLen - this.pos, len - pos);
-      if (take === blockLen) {
-        for (;blockLen <= len - pos; pos += blockLen)
-          this.process(data, pos);
-        continue;
-      }
-      buffer.set(data.subarray(pos, pos + take), this.pos);
-      this.pos += take;
-      pos += take;
-      if (this.pos === blockLen) {
-        this.process(buffer, 0, false);
-        this.pos = 0;
+  has(name) {
+    return this._functions.has(name) && this._functions.get(name).length > 0;
+  }
+  names() {
+    return [...this._functions.keys()].sort();
+  }
+  all() {
+    const result = [];
+    for (const candidates of this._functions.values()) {
+      result.push(...candidates);
+    }
+    return result;
+  }
+}
+// src/metadata/serialize.ts
+init_arrow();
+var EXAMPLE_STRUCT = struct2([
+  field2("sql", utf82(), false),
+  field2("description", utf82(), false),
+  field2("expected_output", utf82(), true)
+]);
+var PARAMETER_STRUCT = struct2([
+  field2("name", utf82(), false),
+  field2("position", int322(), true),
+  field2("position_name", utf82(), true),
+  field2("type_name", utf82(), true),
+  field2("description", utf82(), false),
+  field2("required", bool2(), false),
+  field2("default", utf82(), true),
+  field2("constraints", utf82(), true),
+  field2("is_table_input", bool2(), false),
+  field2("is_varargs", bool2(), false),
+  field2("is_const", bool2(), false)
+]);
+var FILTER_IDENTITY_STRUCT = struct2([
+  field2("namespace", utf82(), false),
+  field2("name", utf82(), false),
+  field2("version", uint642(), false)
+]);
+var FILTER_CONTEXT_STRUCT = struct2([
+  field2("profile", utf82(), false),
+  field2("provider_fingerprint", utf82(), true)
+]);
+var METADATA_SCHEMA = schema2([
+  field2("name", utf82(), false),
+  field2("class_name", utf82(), false),
+  field2("function_type", utf82(), false),
+  field2("description", utf82(), false),
+  field2("examples", list2(field2("item", EXAMPLE_STRUCT, true)), false),
+  field2("categories", list2(field2("item", utf82(), true)), false),
+  field2("tags", map2(field2("key", utf82(), false), field2("value", utf82(), true), false), false),
+  field2("parameters", list2(field2("item", PARAMETER_STRUCT, true)), false),
+  field2("stability", utf82(), false),
+  field2("null_handling", utf82(), false),
+  field2("argument_monotonicity", list2(field2("item", utf82(), true)), true),
+  field2("required_settings", list2(field2("item", utf82(), true)), false),
+  field2("required_secrets", list2(field2("item", utf82(), true)), false),
+  field2("projection_pushdown", bool2(), false),
+  field2("filter_pushdown", bool2(), false),
+  field2("filter_semantic_profiles", list2(field2("item", utf82(), true)), false),
+  field2("additional_filter_functions", list2(field2("item", FILTER_IDENTITY_STRUCT, true)), false),
+  field2("runtime_filter_algorithms", list2(field2("item", FILTER_IDENTITY_STRUCT, true)), false),
+  field2("filter_evaluation_contexts", list2(field2("item", FILTER_CONTEXT_STRUCT, true)), false),
+  field2("preserves_order", utf82(), false),
+  field2("max_workers", int322(), true),
+  field2("order_dependent", utf82(), false),
+  field2("distinct_dependent", utf82(), false)
+]);
+function metadataToRow(m) {
+  return {
+    name: m.name,
+    class_name: m.className,
+    function_type: m.functionType,
+    description: m.description,
+    examples: m.examples.map((e) => ({
+      sql: e.sql,
+      description: e.description,
+      expected_output: e.expectedOutput
+    })),
+    categories: m.categories,
+    tags: Object.entries(m.tags).map(([k, v]) => [k, v]),
+    parameters: m.parameters.map((p) => ({
+      name: p.name,
+      position: p.position,
+      position_name: p.positionName,
+      type_name: p.typeName,
+      description: p.description,
+      required: p.required,
+      default: p.default,
+      constraints: p.constraints,
+      is_table_input: p.isTableInput,
+      is_varargs: p.isVarargs,
+      is_const: p.isConst
+    })),
+    stability: m.stability,
+    null_handling: m.nullHandling,
+    argument_monotonicity: m.argumentMonotonicity,
+    required_settings: m.requiredSettings,
+    required_secrets: m.requiredSecrets,
+    projection_pushdown: m.projectionPushdown,
+    filter_pushdown: m.filterPushdown,
+    sampling_pushdown: m.samplingPushdown,
+    filter_semantic_profiles: m.filterSemanticProfiles,
+    additional_filter_functions: m.additionalFilterFunctions.map((value) => ({
+      ...value,
+      version: BigInt(value.version)
+    })),
+    runtime_filter_algorithms: m.runtimeFilterAlgorithms.map((value) => ({
+      ...value,
+      version: BigInt(value.version)
+    })),
+    filter_evaluation_contexts: m.filterEvaluationContexts.map((value) => ({
+      profile: value.profile,
+      provider_fingerprint: value.providerFingerprint
+    })),
+    preserves_order: m.preservesOrder,
+    max_workers: m.maxWorkers,
+    order_dependent: m.orderDependent,
+    distinct_dependent: m.distinctDependent
+  };
+}
+function metadatasToArrow(metadatas) {
+  if (metadatas.length === 0) {
+    return emptyBatch(METADATA_SCHEMA);
+  }
+  const rows = metadatas.map(metadataToRow);
+  const columns = {};
+  for (const f of METADATA_SCHEMA.fields) {
+    columns[f.name] = rows.map((r) => r[f.name]);
+  }
+  return batchFromColumns(columns, METADATA_SCHEMA);
+}
+function arrowToMetadatas(batch) {
+  const results = [];
+  for (let i = 0;i < batch.numRows; i++) {
+    const get = (name) => {
+      const col = batch.getChild(name);
+      return col ? col.get(i) : null;
+    };
+    const rawExamples = get("examples") ?? [];
+    const examples = [];
+    if (rawExamples && typeof rawExamples[Symbol.iterator] === "function") {
+      for (const e of rawExamples) {
+        if (e) {
+          examples.push({
+            sql: e.sql ?? "",
+            description: e.description ?? "",
+            expectedOutput: e.expected_output ?? null
+          });
+        }
       }
     }
-    return this;
-  }
-  destroy() {
-    this.destroyed = true;
-    clean(this.h, this.r, this.buffer, this.pad);
-  }
-  digestInto(out) {
-    aexists(this);
-    aoutput(out, this);
-    this.finished = true;
-    const { buffer, h } = this;
-    let { pos } = this;
-    if (pos) {
-      buffer[pos++] = 1;
-      for (;pos < 16; pos++)
-        buffer[pos] = 0;
-      this.process(buffer, 0, true);
+    const rawParams = get("parameters") ?? [];
+    const parameters = [];
+    if (rawParams && typeof rawParams[Symbol.iterator] === "function") {
+      for (const p of rawParams) {
+        if (p) {
+          parameters.push({
+            name: p.name ?? "",
+            position: p.position ?? null,
+            positionName: p.position_name ?? null,
+            typeName: p.type_name ?? null,
+            description: p.description ?? "",
+            required: p.required ?? true,
+            default: p.default ?? null,
+            constraints: p.constraints ?? null,
+            isTableInput: p.is_table_input ?? false,
+            isVarargs: p.is_varargs ?? false,
+            isConst: p.is_const ?? false
+          });
+        }
+      }
     }
-    this.finalize();
-    let opos = 0;
-    for (let i = 0;i < 8; i++) {
-      out[opos++] = h[i] >>> 0;
-      out[opos++] = h[i] >>> 8;
+    const rawCategories = get("categories") ?? [];
+    const categories = rawCategories ? [...rawCategories].filter((c) => c != null) : [];
+    const rawTags = get("tags");
+    const tags = {};
+    if (rawTags) {
+      if (typeof rawTags[Symbol.iterator] === "function") {
+        for (const entry of rawTags) {
+          if (Array.isArray(entry)) {
+            tags[String(entry[0])] = String(entry[1] ?? "");
+          } else if (entry && entry.key != null) {
+            tags[String(entry.key)] = String(entry.value ?? "");
+          }
+        }
+      }
     }
-  }
-  digest() {
-    const { buffer, outputLen } = this;
-    this.digestInto(buffer);
-    const res = buffer.slice(0, outputLen);
-    this.destroy();
-    return res;
-  }
-}
-var poly1305 = /* @__PURE__ */ wrapMacConstructor(32, (key) => new Poly1305(key));
-
-// node_modules/@noble/ciphers/chacha.js
-function chachaCore(s, k, n, out, cnt, rounds = 20) {
-  let y00 = s[0], y01 = s[1], y02 = s[2], y03 = s[3], y04 = k[0], y05 = k[1], y06 = k[2], y07 = k[3], y08 = k[4], y09 = k[5], y10 = k[6], y11 = k[7], y12 = cnt, y13 = n[0], y14 = n[1], y15 = n[2];
-  let x00 = y00, x01 = y01, x02 = y02, x03 = y03, x04 = y04, x05 = y05, x06 = y06, x07 = y07, x08 = y08, x09 = y09, x10 = y10, x11 = y11, x12 = y12, x13 = y13, x14 = y14, x15 = y15;
-  for (let r = 0;r < rounds; r += 2) {
-    x00 = x00 + x04 | 0;
-    x12 = rotl(x12 ^ x00, 16);
-    x08 = x08 + x12 | 0;
-    x04 = rotl(x04 ^ x08, 12);
-    x00 = x00 + x04 | 0;
-    x12 = rotl(x12 ^ x00, 8);
-    x08 = x08 + x12 | 0;
-    x04 = rotl(x04 ^ x08, 7);
-    x01 = x01 + x05 | 0;
-    x13 = rotl(x13 ^ x01, 16);
-    x09 = x09 + x13 | 0;
-    x05 = rotl(x05 ^ x09, 12);
-    x01 = x01 + x05 | 0;
-    x13 = rotl(x13 ^ x01, 8);
-    x09 = x09 + x13 | 0;
-    x05 = rotl(x05 ^ x09, 7);
-    x02 = x02 + x06 | 0;
-    x14 = rotl(x14 ^ x02, 16);
-    x10 = x10 + x14 | 0;
-    x06 = rotl(x06 ^ x10, 12);
-    x02 = x02 + x06 | 0;
-    x14 = rotl(x14 ^ x02, 8);
-    x10 = x10 + x14 | 0;
-    x06 = rotl(x06 ^ x10, 7);
-    x03 = x03 + x07 | 0;
-    x15 = rotl(x15 ^ x03, 16);
-    x11 = x11 + x15 | 0;
-    x07 = rotl(x07 ^ x11, 12);
-    x03 = x03 + x07 | 0;
-    x15 = rotl(x15 ^ x03, 8);
-    x11 = x11 + x15 | 0;
-    x07 = rotl(x07 ^ x11, 7);
-    x00 = x00 + x05 | 0;
-    x15 = rotl(x15 ^ x00, 16);
-    x10 = x10 + x15 | 0;
-    x05 = rotl(x05 ^ x10, 12);
-    x00 = x00 + x05 | 0;
-    x15 = rotl(x15 ^ x00, 8);
-    x10 = x10 + x15 | 0;
-    x05 = rotl(x05 ^ x10, 7);
-    x01 = x01 + x06 | 0;
-    x12 = rotl(x12 ^ x01, 16);
-    x11 = x11 + x12 | 0;
-    x06 = rotl(x06 ^ x11, 12);
-    x01 = x01 + x06 | 0;
-    x12 = rotl(x12 ^ x01, 8);
-    x11 = x11 + x12 | 0;
-    x06 = rotl(x06 ^ x11, 7);
-    x02 = x02 + x07 | 0;
-    x13 = rotl(x13 ^ x02, 16);
-    x08 = x08 + x13 | 0;
-    x07 = rotl(x07 ^ x08, 12);
-    x02 = x02 + x07 | 0;
-    x13 = rotl(x13 ^ x02, 8);
-    x08 = x08 + x13 | 0;
-    x07 = rotl(x07 ^ x08, 7);
-    x03 = x03 + x04 | 0;
-    x14 = rotl(x14 ^ x03, 16);
-    x09 = x09 + x14 | 0;
-    x04 = rotl(x04 ^ x09, 12);
-    x03 = x03 + x04 | 0;
-    x14 = rotl(x14 ^ x03, 8);
-    x09 = x09 + x14 | 0;
-    x04 = rotl(x04 ^ x09, 7);
-  }
-  let oi = 0;
-  out[oi++] = y00 + x00 | 0;
-  out[oi++] = y01 + x01 | 0;
-  out[oi++] = y02 + x02 | 0;
-  out[oi++] = y03 + x03 | 0;
-  out[oi++] = y04 + x04 | 0;
-  out[oi++] = y05 + x05 | 0;
-  out[oi++] = y06 + x06 | 0;
-  out[oi++] = y07 + x07 | 0;
-  out[oi++] = y08 + x08 | 0;
-  out[oi++] = y09 + x09 | 0;
-  out[oi++] = y10 + x10 | 0;
-  out[oi++] = y11 + x11 | 0;
-  out[oi++] = y12 + x12 | 0;
-  out[oi++] = y13 + x13 | 0;
-  out[oi++] = y14 + x14 | 0;
-  out[oi++] = y15 + x15 | 0;
-}
-function hchacha(s, k, i, out) {
-  const s2 = isLE ? s : swap32IfBE(s.slice(0, 4));
-  const k2 = isLE ? k : swap32IfBE(k.slice(0, 8));
-  const i2 = isLE ? i : swap32IfBE(i.slice(0, 4));
-  const t = new Uint32Array(16);
-  chachaCore(s2, k2, i2.subarray(1), t, i2[0]);
-  let oi = 0;
-  out[oi++] = t[0] - s2[0] | 0;
-  out[oi++] = t[1] - s2[1] | 0;
-  out[oi++] = t[2] - s2[2] | 0;
-  out[oi++] = t[3] - s2[3] | 0;
-  out[oi++] = t[12] - i2[0] | 0;
-  out[oi++] = t[13] - i2[1] | 0;
-  out[oi++] = t[14] - i2[2] | 0;
-  out[oi++] = t[15] - i2[3] | 0;
-  swap32IfBE(out);
-  if (!isLE)
-    clean(s2, k2, i2);
-  clean(t);
-}
-var xchacha20 = /* @__PURE__ */ createCipher(chachaCore, {
-  counterRight: false,
-  counterLength: 8,
-  extendNonceFn: hchacha,
-  allowShortKeys: false
-});
-var ZEROS16 = /* @__PURE__ */ new Uint8Array(16);
-var updatePadded = (h, msg) => {
-  h.update(msg);
-  const leftover = msg.length % 16;
-  if (leftover)
-    h.update(ZEROS16.subarray(leftover));
-};
-var ZEROS32 = /* @__PURE__ */ new Uint8Array(32);
-function computeTag(fn, key, nonce, ciphertext, AAD) {
-  if (AAD !== undefined)
-    abytes(AAD, undefined, "AAD");
-  const authKey = fn(key, nonce, ZEROS32);
-  const lengths = u64Lengths(ciphertext.length, AAD ? AAD.length : 0, true);
-  const h = poly1305.create(authKey);
-  if (AAD)
-    updatePadded(h, AAD);
-  updatePadded(h, ciphertext);
-  h.update(lengths);
-  const res = h.digest();
-  clean(authKey, lengths);
-  return res;
+    const rawRequiredSettings = get("required_settings") ?? [];
+    const requiredSettings = rawRequiredSettings ? [...rawRequiredSettings].filter((s) => s != null) : [];
+    const rawRequiredSecrets = get("required_secrets") ?? [];
+    const requiredSecrets = rawRequiredSecrets ? [...rawRequiredSecrets].filter((s) => s != null) : [];
+    results.push({
+      name: get("name") ?? "",
+      className: get("class_name") ?? "",
+      functionType: get("function_type") ?? "TABLE",
+      description: get("description") ?? "",
+      examples,
+      categories,
+      tags,
+      parameters,
+      stability: get("stability") ?? "CONSISTENT",
+      nullHandling: get("null_handling") ?? "DEFAULT",
+      argumentMonotonicity: get("argument_monotonicity") == null ? null : [...get("argument_monotonicity")].map(String),
+      requiredSettings,
+      requiredSecrets,
+      projectionPushdown: get("projection_pushdown") ?? false,
+      filterPushdown: get("filter_pushdown") ?? false,
+      samplingPushdown: get("sampling_pushdown") ?? false,
+      filterSemanticProfiles: [...get("filter_semantic_profiles") ?? []].filter((s) => s != null).map(String),
+      additionalFilterFunctions: [...get("additional_filter_functions") ?? []].filter((v) => v != null).map((v) => ({
+        namespace: String(v.namespace),
+        name: String(v.name),
+        version: Number(v.version)
+      })),
+      runtimeFilterAlgorithms: [...get("runtime_filter_algorithms") ?? []].filter((v) => v != null).map((v) => ({
+        namespace: String(v.namespace),
+        name: String(v.name),
+        version: Number(v.version)
+      })),
+      filterEvaluationContexts: [...get("filter_evaluation_contexts") ?? []].filter((v) => v != null).map((v) => ({
+        profile: String(v.profile),
+        providerFingerprint: v.provider_fingerprint == null ? null : String(v.provider_fingerprint)
+      })),
+      preservesOrder: get("preserves_order") ?? "NO_ORDER_GUARANTEE",
+      maxWorkers: get("max_workers") ?? null,
+      orderDependent: get("order_dependent") ?? "NOT_ORDER_DEPENDENT",
+      distinctDependent: get("distinct_dependent") ?? "NOT_DISTINCT_DEPENDENT"
+    });
+  }
+  return results;
 }
-var _poly1305_aead = (xorStream) => (key, nonce, AAD) => {
-  const tagLength = 16;
-  return {
-    encrypt(plaintext, output) {
-      const plength = plaintext.length;
-      output = getOutput(plength + tagLength, output, false);
-      output.set(plaintext);
-      const oPlain = output.subarray(0, -tagLength);
-      xorStream(key, nonce, oPlain, oPlain, 1);
-      const tag = computeTag(xorStream, key, nonce, oPlain, AAD);
-      output.set(tag, plength);
-      clean(tag);
-      return output;
-    },
-    decrypt(ciphertext, output) {
-      output = getOutput(ciphertext.length - tagLength, output, false);
-      const data = ciphertext.subarray(0, -tagLength);
-      const passedTag = ciphertext.subarray(-tagLength);
-      const tag = computeTag(xorStream, key, nonce, data, AAD);
-      if (!equalBytes(passedTag, tag)) {
-        clean(tag);
-        throw new Error("invalid tag");
-      }
-      output.set(ciphertext.subarray(0, -tagLength));
-      xorStream(key, nonce, output, output, 1);
-      clean(tag);
-      return output;
-    }
-  };
-};
-var xchacha20poly1305 = /* @__PURE__ */ wrapCipher({ blockSize: 64, nonceLength: 24, tagLength: 16, withAAD: true }, /* @__PURE__ */ _poly1305_aead(xchacha20));
+// src/protocol/dispatch.ts
+import { Protocol as Protocol2 } from "@query-farm/vgi-rpc";
 
-// src/crypto.ts
-var _UTF8 = new TextEncoder;
-var ATTACH_ENVELOPE_VERSION = 2;
-var TRANSACTION_ENVELOPE_VERSION = 2;
-var ATTACH_UUID_LEN = 16;
-var NONCE_LEN = 24;
-var TAG_LEN = 16;
-var MIN_ENVELOPE_LEN = 1 + NONCE_LEN + TAG_LEN;
-var ATTACH_AAD_PREFIX = _UTF8.encode("vgi.attach_opaque_data.v1\x00");
-var TRANSACTION_AAD_PREFIX = _UTF8.encode("vgi.transaction_opaque_data.v1\x00");
+// src/protocol/handlers/function.ts
+init_arrow();
 
-class OpaqueDataRejectedError extends Error {
-  constructor(field = "opaque data") {
-    super(`${field} not recognized`);
-    this.name = "OpaqueDataRejectedError";
-  }
-}
-function concat(...parts) {
-  let total = 0;
-  for (const p of parts)
-    total += p.length;
-  const out = new Uint8Array(total);
-  let off = 0;
-  for (const p of parts) {
-    out.set(p, off);
-    off += p.length;
-  }
-  return out;
-}
-async function normalizeKey(key) {
-  if (key.length === 32)
-    return key;
-  return new Uint8Array(await crypto.subtle.digest("SHA-256", key));
-}
-function identityTail(auth) {
-  if (!auth || !auth.authenticated)
-    return _UTF8.encode("\x00anonymous");
-  const domain = _UTF8.encode(auth.domain ?? "");
-  const principal = _UTF8.encode(auth.principal ?? "");
-  return concat(Uint8Array.of(1), domain, Uint8Array.of(0), principal);
-}
-function attachAad(auth) {
-  return concat(ATTACH_AAD_PREFIX, identityTail(auth));
+// src/protocol/handlers/shared.ts
+init_arrow();
+var RESULT_BINARY_SCHEMA = schema2([
+  field2("result", binary2(), false)
+]);
+var REQUEST_PARAMS_SCHEMA = schema2([
+  field2("request", binary2(), false)
+]);
+var RESULT_BINARY_NULLABLE_SCHEMA = schema2([
+  field2("result", binary2(), true)
+]);
+function unwrapRequest(requestBytes) {
+  const bytes = toUint8Array(requestBytes);
+  const innerBatch = deserializeBatch(bytes);
+  const params = batchToScalarDict(innerBatch);
+  normalizeRequestSchemaPaths(params);
+  return params;
 }
-function transactionAad(auth, attachEnvelope) {
-  return concat(TRANSACTION_AAD_PREFIX, identityTail(auth), Uint8Array.of(0), attachEnvelope);
+function normalizeRequestSchemaPaths(params) {
+  if (params.path != null)
+    params.path = normalizeSchemaPath(params.path);
+  if (params.schema_path != null)
+    params.schema_path = normalizeSchemaPath(params.schema_path);
 }
-async function sealBytes(payload, key, aad, version) {
-  const nonce = crypto.getRandomValues(new Uint8Array(NONCE_LEN));
-  const ciphertext = xchacha20poly1305(await normalizeKey(key), nonce, aad).encrypt(payload);
-  const out = new Uint8Array(1 + NONCE_LEN + ciphertext.length);
-  out[0] = version & 255;
-  out.set(nonce, 1);
-  out.set(ciphertext, 1 + NONCE_LEN);
-  return out;
+function wrapResult(values, innerSchema) {
+  const a = innerSchema;
+  const batch = batchFromColumns(Object.fromEntries(a.fields.map((f) => [f.name, [values[f.name] ?? null]])), a);
+  return { result: serializeBatch(batch) };
 }
-async function openBytes(token, key, aad, version, field = "opaque data") {
-  if (token.length < MIN_ENVELOPE_LEN || token[0] !== (version & 255)) {
-    throw new OpaqueDataRejectedError(field);
-  }
-  const nonce = token.subarray(1, 1 + NONCE_LEN);
-  const ciphertext = token.subarray(1 + NONCE_LEN);
-  try {
-    return xchacha20poly1305(await normalizeKey(key), nonce, aad).decrypt(ciphertext);
-  } catch {
-    throw new OpaqueDataRejectedError(field);
+function overloadContext(req, catalogInterface) {
+  let catalogName = null;
+  if (catalogInterface && req.attach_opaque_data) {
+    try {
+      catalogName = catalogInterface.catalogNameForAttach(req.attach_opaque_data);
+    } catch {
+      catalogName = null;
+    }
   }
+  return {
+    arguments: req.arguments,
+    inputSchema: req.input_schema,
+    isScalar: String(req.function_type).toLowerCase() === "scalar",
+    schemaPath: req.schema_path ?? null,
+    catalogName
+  };
 }
 
 // src/protocol/handlers/catalog/shared.ts
+init_arrow();
 async function sealAttach(plaintext, auth, signingKey) {
   const uuid = new Uint8Array(ATTACH_UUID_LEN);
   crypto.getRandomValues(uuid);
@@ -12072,6 +12121,398 @@ async function serveCatalogContents(cat, attach, ifNoneMatch) {
   return wrapResult(await buildCatalogContents(cat, owner, attach, version, ifNoneMatch), CatalogContentsResultSchema);
 }
 
+// src/attach-ticket.ts
+init_arrow();
+import {
+  Protocol,
+  badRequest,
+  errorInfo,
+  preconditionFailure
+} from "@query-farm/vgi-rpc";
+var ATTACH_TICKET_PREFIX = "vgia1.";
+var ATTACH_TICKET_OPTION = RESERVED_ATTACH_OPTION;
+var ATTACH_TICKETS_PROTOCOL_NAME = "vgi.attach_tickets.v1";
+var ATTACH_TICKETS_PROTOCOL_VERSION = "1.0.0";
+var TICKET_ENVELOPE_VERSION = 1;
+var MAX_OPTIONS_BYTES = 16 * 1024;
+var MAX_TICKET_CHARS = 32 * 1024;
+var CLOCK_SKEW_SECONDS = 60;
+var UTF82 = new TextEncoder;
+var STRICT_UTF8 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+var TICKET_AAD_DOMAIN = UTF82.encode("vgi.attach_ticket.v1\x00");
+var TICKET_ID = /^[0-9a-f]{32}$/;
+var B64URL = /^[A-Za-z0-9_-]+$/;
+var MAX_TEXT = 65535;
+
+class AttachTicketInvalidError extends Error {
+  static errorKind = "attach_ticket_invalid";
+  errorKind = "attach_ticket_invalid";
+  errorCode = "INVALID_ARGUMENT";
+  errorDetails;
+  constructor(detail = "attach ticket not accepted") {
+    super(detail);
+    this.name = "AttachTicketInvalidError";
+    this.errorDetails = [badRequest([{ field: ATTACH_TICKET_OPTION, description: detail }])];
+  }
+}
+
+class AttachTicketExpiredError extends Error {
+  static errorKind = "attach_ticket_expired";
+  errorKind = "attach_ticket_expired";
+  errorCode = "FAILED_PRECONDITION";
+  errorDetails;
+  constructor(detail = "attach ticket has expired") {
+    super(detail);
+    this.name = "AttachTicketExpiredError";
+    this.errorDetails = [
+      preconditionFailure([{ type: "ATTACH_TICKET", subject: ATTACH_TICKET_OPTION, description: detail }])
+    ];
+  }
+}
+
+class AttachTicketRequestError extends Error {
+  errorKind = "invalid_request";
+  errorCode = "INVALID_ARGUMENT";
+  errorDetails;
+  constructor(message, violations) {
+    super(message);
+    this.name = "AttachTicketRequestError";
+    this.errorDetails = [
+      badRequest(violations.map(([f, description]) => ({ field: f, description })))
+    ];
+  }
+}
+
+class SealAttachDeniedError extends Error {
+  errorKind = "action_denied";
+  errorCode = "PERMISSION_DENIED";
+  errorDetails = [errorInfo({ action: "seal_attach" })];
+  constructor(message) {
+    super(message);
+    this.name = "SealAttachDeniedError";
+  }
+}
+function attachTicketAad(principal) {
+  const p = UTF82.encode(principal);
+  const out = new Uint8Array(TICKET_AAD_DOMAIN.length + p.length);
+  out.set(TICKET_AAD_DOMAIN, 0);
+  out.set(p, TICKET_AAD_DOMAIN.length);
+  return out;
+}
+function packText(value, name) {
+  const raw = UTF82.encode(value);
+  if (raw.length > MAX_TEXT)
+    throw new Error(`${name} is longer than 65535 bytes`);
+  const out = new Uint8Array(2 + raw.length);
+  new DataView(out.buffer).setUint16(0, raw.length, true);
+  out.set(raw, 2);
+  return out;
+}
+function encodePayload(c) {
+  if (c.optionsIpc.length > MAX_OPTIONS_BYTES) {
+    throw new Error(`options are ${c.optionsIpc.length} bytes; a ticket carries at most ${MAX_OPTIONS_BYTES}`);
+  }
+  const head = new Uint8Array(16);
+  const hv = new DataView(head.buffer);
+  hv.setBigInt64(0, BigInt(c.issuedAt), true);
+  hv.setBigInt64(8, BigInt(c.expiresAt), true);
+  const optLen = new Uint8Array(4);
+  new DataView(optLen.buffer).setUint32(0, c.optionsIpc.length, true);
+  const parts = [
+    head,
+    packText(c.ticketId, "ticket_id"),
+    packText(c.catalogName, "catalog_name"),
+    packText(c.dataVersionSpec, "data_version_spec"),
+    packText(c.implementationVersion, "implementation_version"),
+    optLen,
+    c.optionsIpc
+  ];
+  let total = 0;
+  for (const p of parts)
+    total += p.length;
+  const out = new Uint8Array(total);
+  let off = 0;
+  for (const p of parts) {
+    out.set(p, off);
+    off += p.length;
+  }
+  return out;
+}
+function decodePayload(payload) {
+  const view = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+  let pos = 0;
+  const need = (n) => {
+    if (pos + n > payload.length)
+      throw new AttachTicketInvalidError("attach ticket payload is truncated");
+  };
+  const text = () => {
+    need(2);
+    const len = view.getUint16(pos, true);
+    pos += 2;
+    need(len);
+    const raw = payload.subarray(pos, pos + len);
+    pos += len;
+    try {
+      return STRICT_UTF8.decode(raw);
+    } catch {
+      throw new AttachTicketInvalidError("attach ticket payload is not UTF-8");
+    }
+  };
+  need(16);
+  const issuedAt = Number(view.getBigInt64(0, true));
+  const expiresAt = Number(view.getBigInt64(8, true));
+  pos = 16;
+  const ticketId = text();
+  const catalogName = text();
+  const dataVersionSpec = text();
+  const implementationVersion = text();
+  need(4);
+  const optionsLen = view.getUint32(pos, true);
+  pos += 4;
+  if (optionsLen > MAX_OPTIONS_BYTES)
+    throw new AttachTicketInvalidError("attach ticket options exceed 16 KiB");
+  need(optionsLen);
+  const optionsIpc = payload.slice(pos, pos + optionsLen);
+  pos += optionsLen;
+  if (pos !== payload.length)
+    throw new AttachTicketInvalidError("attach ticket payload has trailing bytes");
+  if (!TICKET_ID.test(ticketId))
+    throw new AttachTicketInvalidError("attach ticket id is not 32 lowercase hex");
+  if (!catalogName)
+    throw new AttachTicketInvalidError("attach ticket names no catalog");
+  if (expiresAt !== 0 && expiresAt <= issuedAt)
+    throw new AttachTicketInvalidError("attach ticket lifetime is empty");
+  return { issuedAt, expiresAt, ticketId, catalogName, dataVersionSpec, implementationVersion, optionsIpc };
+}
+function b64url(data) {
+  let bin = "";
+  for (let i = 0;i < data.length; i++)
+    bin += String.fromCharCode(data[i]);
+  return btoa(bin).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function b64urlStrict(text) {
+  if (!B64URL.test(text) || text.length % 4 === 1) {
+    throw new AttachTicketInvalidError("attach ticket is not unpadded base64url");
+  }
+  const padded = text.replace(/-/g, "+").replace(/_/g, "/") + "=".repeat((4 - text.length % 4) % 4);
+  const bin = atob(padded);
+  const raw = new Uint8Array(bin.length);
+  for (let i = 0;i < bin.length; i++)
+    raw[i] = bin.charCodeAt(i);
+  if (b64url(raw) !== text)
+    throw new AttachTicketInvalidError("attach ticket is not canonical base64url");
+  return raw;
+}
+function randomHex(bytes) {
+  const b = crypto.getRandomValues(new Uint8Array(bytes));
+  let s = "";
+  for (const x of b)
+    s += x.toString(16).padStart(2, "0");
+  return s;
+}
+async function mintAttachTicket(signingKey, opts) {
+  if (!opts.principal)
+    throw new Error("a ticket needs a principal");
+  if (!opts.catalogName)
+    throw new Error("a ticket needs a catalog name");
+  const claims = {
+    issuedAt: Math.trunc(opts.issuedAt),
+    expiresAt: Math.trunc(opts.expiresAt),
+    ticketId: opts.ticketId ?? randomHex(16),
+    catalogName: opts.catalogName,
+    dataVersionSpec: opts.dataVersionSpec ?? "",
+    implementationVersion: opts.implementationVersion ?? "",
+    optionsIpc: opts.optionsIpc
+  };
+  if (!TICKET_ID.test(claims.ticketId))
+    throw new Error("ticket_id must be 32 lowercase hex");
+  if (claims.expiresAt !== 0 && claims.expiresAt <= claims.issuedAt) {
+    throw new Error("expires_at must be 0 or after issued_at");
+  }
+  const envelope = await sealBytes(encodePayload(claims), signingKey, attachTicketAad(opts.principal), TICKET_ENVELOPE_VERSION, opts.nonce);
+  const token = ATTACH_TICKET_PREFIX + b64url(envelope);
+  if (token.length > MAX_TICKET_CHARS) {
+    throw new Error(`the ticket would be ${token.length} characters; at most ${MAX_TICKET_CHARS} are accepted`);
+  }
+  return { token, claims };
+}
+async function openAttachTicket(signingKey, token, principal, now) {
+  if (!token.startsWith(ATTACH_TICKET_PREFIX))
+    throw new AttachTicketInvalidError("not an attach ticket");
+  if (token.length > MAX_TICKET_CHARS)
+    throw new AttachTicketInvalidError("attach ticket is too long");
+  const envelope = b64urlStrict(token.slice(ATTACH_TICKET_PREFIX.length));
+  if (!principal)
+    throw new AttachTicketInvalidError("an anonymous caller cannot redeem an attach ticket");
+  let payload;
+  try {
+    payload = await openBytes(envelope, signingKey, attachTicketAad(principal), TICKET_ENVELOPE_VERSION);
+  } catch (e) {
+    if (e instanceof OpaqueDataRejectedError) {
+      throw new AttachTicketInvalidError("attach ticket failed verification");
+    }
+    throw e;
+  }
+  const claims = decodePayload(payload);
+  const current = now ?? Date.now() / 1000;
+  if (claims.issuedAt > current + CLOCK_SKEW_SECONDS)
+    throw new AttachTicketExpiredError("attach ticket is not yet valid");
+  if (claims.expiresAt !== 0 && current >= claims.expiresAt + CLOCK_SKEW_SECONDS) {
+    throw new AttachTicketExpiredError("attach ticket has expired");
+  }
+  return claims;
+}
+function callerPrincipal(auth) {
+  if (!auth || !auth.authenticated)
+    return null;
+  return auth.principal || null;
+}
+async function redeemAttachTicket(options, signingKey, auth, now) {
+  const keys = Object.keys(options);
+  const ticketKeys = keys.filter((k) => k.toLowerCase() === ATTACH_TICKET_OPTION);
+  if (ticketKeys.length === 0)
+    return null;
+  const others = keys.filter((k) => k !== ticketKeys[0]);
+  if (others.length > 0) {
+    throw new AttachTicketRequestError(`${ATTACH_TICKET_OPTION} must be the only attach option`, others.map((k) => [`options.${k}`, `not allowed alongside ${ATTACH_TICKET_OPTION}`]));
+  }
+  const token = options[ticketKeys[0]];
+  if (typeof token !== "string")
+    throw new AttachTicketInvalidError(`${ATTACH_TICKET_OPTION} must be a string`);
+  if (!signingKey)
+    throw new AttachTicketInvalidError("this worker does not redeem attach tickets");
+  const claims = await openAttachTicket(signingKey, token, callerPrincipal(auth), now);
+  let restored = {};
+  if (claims.optionsIpc.length > 0) {
+    try {
+      restored = decodeOptionsBatch(claims.optionsIpc);
+    } catch {
+      throw new AttachTicketInvalidError("attach ticket options are not an Arrow IPC record");
+    }
+  }
+  return {
+    name: claims.catalogName,
+    optionsIpc: claims.optionsIpc.length > 0 ? claims.optionsIpc : null,
+    options: restored,
+    dataVersionSpec: claims.dataVersionSpec || null,
+    implementationVersion: claims.implementationVersion || null
+  };
+}
+var SEAL_ATTACH_REQUEST_SCHEMA = schema2([
+  field2("catalog_name", utf82(), false),
+  field2("options", binary2(), true),
+  field2("data_version_spec", utf82(), false),
+  field2("implementation_version", utf82(), false),
+  field2("ttl_seconds", int642(), false)
+]);
+var ATTACH_TICKET_SCHEMA = schema2([
+  field2("ticket", utf82(), false),
+  field2("expires_at", float642(), false)
+]);
+function resolveTicketMaxTtl(grantKeys, env) {
+  if (grantKeys)
+    return Math.trunc(grantKeys.maxTtlSeconds);
+  const raw = (env?.VGI_RPC_GRANT_MAX_TTL_SECONDS ?? "").trim();
+  if (!raw)
+    return null;
+  const value = /^\d+$/.test(raw) ? Number(raw) : 0;
+  if (!(value > 0))
+    throw new Error(`VGI_RPC_GRANT_MAX_TTL_SECONDS=${JSON.stringify(raw)} must be a positive integer`);
+  return value;
+}
+async function declaredSpecs(catalog, catalogName) {
+  if (!catalog)
+    return null;
+  const infos = catalog.catalogsInfo ? await catalog.catalogsInfo() : catalog.catalogs().map((name) => ({ name, attach_option_specs: [] }));
+  for (const info of infos) {
+    if (info.name === catalogName) {
+      return deserializeAttachOptionSpecs((info.attach_option_specs ?? []).map((b) => toUint8Array(b)));
+    }
+  }
+  return null;
+}
+async function sealAttach2(config, request, auth) {
+  const principal = callerPrincipal(auth);
+  if (principal === null)
+    throw new SealAttachDeniedError("an anonymous caller cannot seal an attach ticket");
+  const violations = [];
+  const ttl = Number(request.ttl_seconds ?? 0);
+  if (!Number.isFinite(ttl) || ttl < 0)
+    violations.push(["ttl_seconds", "must be 0 (as long as allowed) or positive"]);
+  const catalogName = String(request.catalog_name ?? "");
+  let optionsIpc = new Uint8Array(0);
+  let options = {};
+  if (request.options != null) {
+    const raw = toUint8Array(request.options);
+    if (raw.length > 0) {
+      const batch = deserializeBatch(raw);
+      if (batch.numRows > 1) {
+        violations.push(["options", "must be a one-row record"]);
+      } else if (batch.numRows === 1) {
+        options = decodeOptionsBatch(raw);
+        optionsIpc = raw;
+      }
+    }
+  }
+  const specs = await declaredSpecs(config.catalogInterface, catalogName);
+  if (specs === null) {
+    violations.push(["catalog_name", `no catalog named ${JSON.stringify(catalogName)}`]);
+  } else {
+    const declared = new Set(specs.map((s) => s.name.toLowerCase()));
+    for (const name of Object.keys(options)) {
+      if (name.toLowerCase() === ATTACH_TICKET_OPTION) {
+        violations.push([`options.${name}`, "a ticket cannot seal another ticket"]);
+      } else if (!declared.has(name.toLowerCase())) {
+        violations.push([`options.${name}`, "not an attach option this catalog declares"]);
+      }
+    }
+    const supplied = new Set(Object.keys(options).map((n) => n.toLowerCase()));
+    for (const spec of specs) {
+      if (spec.required && !supplied.has(spec.name.toLowerCase()))
+        violations.push([`options.${spec.name}`, "required"]);
+    }
+  }
+  if (optionsIpc.length > MAX_OPTIONS_BYTES) {
+    violations.push(["options", `${optionsIpc.length} bytes; a ticket carries at most ${MAX_OPTIONS_BYTES}`]);
+  }
+  if (violations.length > 0)
+    throw new AttachTicketRequestError("seal_attach request is invalid", violations);
+  const issuedAt = Math.trunc(config.now ? config.now() : Date.now() / 1000);
+  const ceiling = config.maxTtlSeconds;
+  const lifetime = ttl === 0 ? ceiling : ceiling === null ? Math.trunc(ttl) : Math.min(Math.trunc(ttl), ceiling);
+  const expiresAt = lifetime === null ? 0 : issuedAt + lifetime;
+  let token;
+  try {
+    ({ token } = await mintAttachTicket(config.signingKey, {
+      principal,
+      catalogName,
+      optionsIpc,
+      dataVersionSpec: String(request.data_version_spec ?? ""),
+      implementationVersion: String(request.implementation_version ?? ""),
+      issuedAt,
+      expiresAt
+    }));
+  } catch (e) {
+    throw new AttachTicketRequestError("seal_attach request is invalid", [["request", e.message]]);
+  }
+  return { ticket: token, expires_at: expiresAt === 0 ? Number.POSITIVE_INFINITY : expiresAt };
+}
+function buildAttachTicketsProtocol(config) {
+  const p = new Protocol(ATTACH_TICKETS_PROTOCOL_NAME, { protocolVersion: ATTACH_TICKETS_PROTOCOL_VERSION });
+  p.unary("seal_attach", {
+    params: REQUEST_PARAMS_SCHEMA,
+    result: RESULT_BINARY_SCHEMA,
+    doc: "Seal the caller's attach of request.catalog_name into a ticket.",
+    handler: async (params, ctx) => {
+      const request = unwrapRequest(params.request);
+      const sealed = await sealAttach2(config, request, ctx?.auth);
+      const batch = batchFromColumns({ ticket: [sealed.ticket], expires_at: [sealed.expires_at] }, ATTACH_TICKET_SCHEMA);
+      return { result: serializeBatch(batch) };
+    }
+  });
+  return p;
+}
+
 // src/protocol/handlers/catalog/admin.ts
 function registerCatalogAdminMethods(protocol, getCatalog, signingKey) {
   catalogUnary(protocol, signingKey, "catalog_catalogs", {
@@ -12096,7 +12537,15 @@ function registerCatalogAdminMethods(protocol, getCatalog, signingKey) {
     handler: async (params, ctx) => {
       const innerParams = unwrapRequest(params.request);
       const cat = getCatalog();
-      const optionsDict = decodeOptionsBatch(innerParams.options);
+      let optionsDict = decodeOptionsBatch(innerParams.options);
+      const restored = await redeemAttachTicket(optionsDict, signingKey, ctx?.auth ?? currentRequestAuth());
+      if (restored !== null) {
+        innerParams.name = restored.name;
+        innerParams.options = restored.optionsIpc;
+        innerParams.data_version_spec = restored.dataVersionSpec;
+        innerParams.implementation_version = restored.implementationVersion;
+        optionsDict = restored.options;
+      }
       const result = await cat.attach(innerParams.name, optionsDict, innerParams.data_version_spec ?? null, innerParams.implementation_version ?? null);
       const sealedAttach = await sealAttach(toUint8Array(result.attach_opaque_data), ctx?.auth, signingKey);
       return wrapResult(buildCatalogAttachResult({
@@ -12552,7 +13001,7 @@ function registerCatalogMethods(protocol, catalog, _catalogName, signingKey) {
 // src/protocol/dispatch.ts
 var VGI_PROTOCOL_NAME = "vgi.v2";
 function buildVgiProtocol(config) {
-  const protocol = new Protocol(VGI_PROTOCOL_NAME, { protocolVersion: "2.1.0" });
+  const protocol = new Protocol2(VGI_PROTOCOL_NAME, { protocolVersion: "2.1.0" });
   registerFunctionMethods(protocol, {
     registry: config.registry,
     signingKey: config.signingKey,
@@ -13735,7 +14184,15 @@ function buildRpcServer(primary, hosting, options) {
     throw new Error(`Unknown transport ${JSON.stringify(options.transport)}; expected one of ${[...TRANSPORTS].join(", ")}.`);
   }
   const protocols = validatedHostedProtocols(hosting, primary);
-  const identity = IDENTITY_TRANSPORTS.has(options.transport) ? buildIdentity(hosting, options.env) : undefined;
+  let identity;
+  if (IDENTITY_TRANSPORTS.has(options.transport)) {
+    const env = options.env ?? processEnv();
+    const grantKeys = hosting.grantKeys === undefined ? GrantKeys.fromEnv(env) : hosting.grantKeys;
+    identity = buildIdentity(hosting, grantKeys, options.env);
+    const tickets = buildAttachTickets(hosting, grantKeys, options.attachTickets, env);
+    if (tickets)
+      protocols.push(tickets);
+  }
   return new VgiRpcServer(primary, {
     serverId: options.serverId,
     protocols,
@@ -13781,9 +14238,8 @@ function validatedHostedProtocols(hosting, primary) {
   }
   return out;
 }
-function buildIdentity(hosting, env) {
+function buildIdentity(hosting, grantKeys, env) {
   const { resolveToken, mintGrant } = hosting;
-  const grantKeys = hosting.grantKeys === undefined ? GrantKeys.fromEnv(env ?? processEnv()) : hosting.grantKeys;
   if (!resolveToken && !mintGrant && !grantKeys)
     return;
   return new IdentityImpl({
@@ -13794,6 +14250,17 @@ function buildIdentity(hosting, env) {
     maxAuthAge: hosting.maxAuthAge
   });
 }
+function buildAttachTickets(hosting, grantKeys, config, env) {
+  if (!config || !config.signingKeyConfigured || !config.signingKey)
+    return;
+  if (!grantKeys && !hosting.mintGrant)
+    return;
+  return buildAttachTicketsProtocol({
+    signingKey: config.signingKey,
+    catalogInterface: config.catalogInterface,
+    maxTtlSeconds: resolveTicketMaxTtl(grantKeys, env)
+  });
+}
 function resolveIntrospectPrincipals(explicit, env) {
   let principals;
   if (explicit !== undefined) {
@@ -13941,6 +14408,13 @@ class Worker {
   }
   run(argv = process.argv.slice(2)) {
     debug(() => `[worker] starting, pid=${process.pid}`);
+    checkReservedAttachOptions(this._catalogInterface).then(() => this._serve(argv), (err) => {
+      process.stderr.write(`Worker init error: ${err.message}
+`);
+      process.exit(1);
+    });
+  }
+  _serve(argv) {
     try {
       const protocol = this.buildProtocol();
       debug(() => `[worker] protocol built`);
@@ -14025,9 +14499,17 @@ ${err.stack}
   }
 }
 export {
+  ATTACH_TICKETS_PROTOCOL_NAME,
+  ATTACH_TICKETS_PROTOCOL_VERSION,
+  ATTACH_TICKET_OPTION,
+  ATTACH_TICKET_PREFIX,
+  ATTACH_TICKET_SCHEMA,
   ArgumentMonotonicity,
   ArgumentValidationError,
   Arguments,
+  AttachTicketExpiredError,
+  AttachTicketInvalidError,
+  AttachTicketRequestError,
   AuthContext,
   AuthUnavailableError,
   BindResultSchema,
@@ -14080,9 +14562,13 @@ export {
   PARENT_ROW_METADATA_KEY,
   PushdownFilters,
   READ_ONLY_ITEM_ATTACH_ID,
+  RESERVED_ATTACH_OPTION,
   ReadOnlyCatalogInterface,
+  ReservedAttachOptionError,
   RowCountMismatchError,
+  SEAL_ATTACH_REQUEST_SCHEMA,
   ScanFunctionResultSchema,
+  SealAttachDeniedError,
   StatusError,
   TableInOutPhase,
   TimeUnit2 as TimeUnit,
@@ -14114,6 +14600,7 @@ export {
   asTimestampSeconds,
   asUint64,
   asUnscaledDecimal,
+  attachTicketAad,
   backend,
   batchFromColumns,
   batchFromRows,
@@ -14225,12 +14712,15 @@ export {
   macroParameterDocsFromSchema,
   map2 as map,
   metadatasToArrow,
+  mintAttachTicket,
   normalizeSchemaPath,
   nullType2 as nullType,
+  openAttachTicket,
   parentRowsMetadata,
   projectBatch,
   projectSchema,
   readCanonicalValue,
+  redeemAttachTicket,
   reprPushedFilters,
   resolveMetadata,
   resolveStorageFromEnv,
@@ -14277,4 +14767,4 @@ export {
   utf82 as utf8
 };
 
-//# debugId=E43EFCB3DEBB959264756E2164756E21
+//# debugId=121A6A9C9B24594A64756E2164756E21