@uwdata/mosaic-core 0.8.0 → 0.10.0

package/dist/mosaic-core.js

@@ -123,7 +123,6 @@ var MosaicClient = class {
    * @returns {this}
    */
   queryError(error) {
-    console.error(error);
     return this;
   }
   /**
@@ -147,7 +146,7 @@ var MosaicClient = class {
   /**
    * Requests a client update.
    * For example to (re-)render an interface component.
-   * 
+   *
    * @returns {this | Promise<any>}
    */
   update() {
@@ -211,16 +210,24 @@ function __await(v2) {
 function __asyncGenerator(thisArg, _arguments, generator) {
   if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
   var g2 = generator.apply(thisArg, _arguments || []), i, q2 = [];
-  return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+  return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
     return this;
   }, i;
-  function verb(n) {
-    if (g2[n]) i[n] = function(v2) {
-      return new Promise(function(a2, b2) {
-        q2.push([n, v2, a2, b2]) > 1 || resume(n, v2);
-      });
+  function awaitReturn(f2) {
+    return function(v2) {
+      return Promise.resolve(v2).then(f2, reject);
     };
   }
+  function verb(n, f2) {
+    if (g2[n]) {
+      i[n] = function(v2) {
+        return new Promise(function(a2, b2) {
+          q2.push([n, v2, a2, b2]) > 1 || resume(n, v2);
+        });
+      };
+      if (f2) i[n] = f2(i[n]);
+    }
+  }
   function resume(n, v2) {
     try {
       step(g2[n](v2));
@@ -840,26 +847,26 @@ var IntervalUnit;
   IntervalUnit4[IntervalUnit4["MONTH_DAY_NANO"] = 2] = "MONTH_DAY_NANO";
 })(IntervalUnit || (IntervalUnit = {}));
 
-// ../../node_modules/flatbuffers/mjs/constants.js
+// ../../node_modules/apache-arrow/node_modules/flatbuffers/mjs/constants.js
 var SIZEOF_SHORT = 2;
 var SIZEOF_INT = 4;
 var FILE_IDENTIFIER_LENGTH = 4;
 var SIZE_PREFIX_LENGTH = 4;
 
-// ../../node_modules/flatbuffers/mjs/utils.js
+// ../../node_modules/apache-arrow/node_modules/flatbuffers/mjs/utils.js
 var int32 = new Int32Array(2);
 var float32 = new Float32Array(int32.buffer);
 var float64 = new Float64Array(int32.buffer);
 var isLittleEndian = new Uint16Array(new Uint8Array([1, 0]).buffer)[0] === 1;
 
-// ../../node_modules/flatbuffers/mjs/encoding.js
+// ../../node_modules/apache-arrow/node_modules/flatbuffers/mjs/encoding.js
 var Encoding;
-(function(Encoding2) {
-  Encoding2[Encoding2["UTF8_BYTES"] = 1] = "UTF8_BYTES";
-  Encoding2[Encoding2["UTF16_STRING"] = 2] = "UTF16_STRING";
+(function(Encoding3) {
+  Encoding3[Encoding3["UTF8_BYTES"] = 1] = "UTF8_BYTES";
+  Encoding3[Encoding3["UTF16_STRING"] = 2] = "UTF16_STRING";
 })(Encoding || (Encoding = {}));
 
-// ../../node_modules/flatbuffers/mjs/byte-buffer.js
+// ../../node_modules/apache-arrow/node_modules/flatbuffers/mjs/byte-buffer.js
 var ByteBuffer = class _ByteBuffer {
   /**
    * Create a new ByteBuffer with a given array of bytes (`Uint8Array`)
@@ -1103,7 +1110,7 @@ var ByteBuffer = class _ByteBuffer {
   }
 };
 
-// ../../node_modules/flatbuffers/mjs/builder.js
+// ../../node_modules/apache-arrow/node_modules/flatbuffers/mjs/builder.js
 var Builder = class _Builder {
   /**
    * Create a FlatBufferBuilder.
@@ -1543,9 +1550,22 @@ var Builder = class _Builder {
     this.addInt8(0);
     this.startVector(1, utf8.length, 1);
     this.bb.setPosition(this.space -= utf8.length);
-    for (let i = 0, offset = this.space, bytes = this.bb.bytes(); i < utf8.length; i++) {
-      bytes[offset++] = utf8[i];
+    this.bb.bytes().set(utf8, this.space);
+    return this.endVector();
+  }
+  /**
+   * Create a byte vector.
+   *
+   * @param v The bytes to add
+   * @returns The offset in the buffer where the byte vector starts
+   */
+  createByteVector(v2) {
+    if (v2 === null || v2 === void 0) {
+      return 0;
     }
+    this.startVector(1, v2.length, 1);
+    this.bb.setPosition(this.space -= v2.length);
+    this.bb.bytes().set(v2, this.space);
     return this.endVector();
   }
   /**
@@ -3148,9 +3168,9 @@ var BufferType;
 // ../../node_modules/apache-arrow/util/vector.mjs
 var vector_exports = {};
 __export(vector_exports, {
-  clampIndex: () => clampIndex,
   clampRange: () => clampRange,
-  createElementComparator: () => createElementComparator
+  createElementComparator: () => createElementComparator,
+  wrapIndex: () => wrapIndex
 });
 
 // ../../node_modules/apache-arrow/util/pretty.mjs
@@ -3191,9 +3211,23 @@ var bn_exports = {};
 __export(bn_exports, {
   BN: () => BN,
   bigNumToBigInt: () => bigNumToBigInt,
+  bigNumToNumber: () => bigNumToNumber,
   bigNumToString: () => bigNumToString,
   isArrowBigNumSymbol: () => isArrowBigNumSymbol
 });
+
+// ../../node_modules/apache-arrow/util/bigint.mjs
+function bigIntToNumber(number) {
+  if (typeof number === "bigint" && (number < Number.MIN_SAFE_INTEGER || number > Number.MAX_SAFE_INTEGER)) {
+    throw new TypeError(`${number} is not safe to convert to a number.`);
+  }
+  return Number(number);
+}
+function divideBigInts(number, divisor) {
+  return bigIntToNumber(number / divisor) + bigIntToNumber(number % divisor) / bigIntToNumber(divisor);
+}
+
+// ../../node_modules/apache-arrow/util/bn.mjs
 var isArrowBigNumSymbol = Symbol.for("isArrowBigNum");
 function BigNum(x3, ...xs) {
   if (xs.length === 0) {
@@ -3205,8 +3239,8 @@ BigNum.prototype[isArrowBigNumSymbol] = true;
 BigNum.prototype.toJSON = function() {
   return `"${bigNumToString(this)}"`;
 };
-BigNum.prototype.valueOf = function() {
-  return bigNumToNumber(this);
+BigNum.prototype.valueOf = function(scale) {
+  return bigNumToNumber(this, scale);
 };
 BigNum.prototype.toString = function() {
   return bigNumToString(this);
@@ -3237,25 +3271,34 @@ Object.setPrototypeOf(DecimalBigNum.prototype, Object.create(Uint32Array.prototy
 Object.assign(SignedBigNum.prototype, BigNum.prototype, { "constructor": SignedBigNum, "signed": true, "TypedArray": Int32Array, "BigIntArray": BigInt64Array });
 Object.assign(UnsignedBigNum.prototype, BigNum.prototype, { "constructor": UnsignedBigNum, "signed": false, "TypedArray": Uint32Array, "BigIntArray": BigUint64Array });
 Object.assign(DecimalBigNum.prototype, BigNum.prototype, { "constructor": DecimalBigNum, "signed": true, "TypedArray": Uint32Array, "BigIntArray": BigUint64Array });
-function bigNumToNumber(bn) {
-  const { buffer, byteOffset, length: length2, "signed": signed } = bn;
-  const words = new BigUint64Array(buffer, byteOffset, length2);
+var TWO_TO_THE_64 = BigInt(4294967296) * BigInt(4294967296);
+var TWO_TO_THE_64_MINUS_1 = TWO_TO_THE_64 - BigInt(1);
+function bigNumToNumber(bn, scale) {
+  const { buffer, byteOffset, byteLength, "signed": signed } = bn;
+  const words = new BigUint64Array(buffer, byteOffset, byteLength / 8);
   const negative = signed && words.at(-1) & BigInt(1) << BigInt(63);
-  let number = negative ? BigInt(1) : BigInt(0);
-  let i = BigInt(0);
-  if (!negative) {
+  let number = BigInt(0);
+  let i = 0;
+  if (negative) {
     for (const word of words) {
-      number += word * (BigInt(1) << BigInt(32) * i++);
+      number |= (word ^ TWO_TO_THE_64_MINUS_1) * (BigInt(1) << BigInt(64 * i++));
     }
+    number *= BigInt(-1);
+    number -= BigInt(1);
   } else {
     for (const word of words) {
-      number += ~word * (BigInt(1) << BigInt(32) * i++);
+      number |= word * (BigInt(1) << BigInt(64 * i++));
     }
-    number *= BigInt(-1);
   }
-  return number;
+  if (typeof scale === "number") {
+    const denominator = BigInt(Math.pow(10, scale));
+    const quotient = number / denominator;
+    const remainder = number % denominator;
+    return bigIntToNumber(quotient) + bigIntToNumber(remainder) / bigIntToNumber(denominator);
+  }
+  return bigIntToNumber(number);
 }
-var bigNumToString = (a2) => {
+function bigNumToString(a2) {
   if (a2.byteLength === 8) {
     const bigIntArray = new a2["BigIntArray"](a2.buffer, a2.byteOffset, 1);
     return `${bigIntArray[0]}`;
@@ -3278,15 +3321,15 @@ var bigNumToString = (a2) => {
   }
   const negated = unsignedBigNumToString(array);
   return `-${negated}`;
-};
-var bigNumToBigInt = (a2) => {
+}
+function bigNumToBigInt(a2) {
   if (a2.byteLength === 8) {
     const bigIntArray = new a2["BigIntArray"](a2.buffer, a2.byteOffset, 1);
     return bigIntArray[0];
   } else {
     return bigNumToString(a2);
   }
-};
+}
 function unsignedBigNumToString(a2) {
   let digits = "";
   const base64 = new Uint32Array(2);
@@ -3343,14 +3386,6 @@ var BN = class _BN {
   }
 };
 
-// ../../node_modules/apache-arrow/util/bigint.mjs
-function bigIntToNumber(number) {
-  if (typeof number === "bigint" && (number < Number.MIN_SAFE_INTEGER || number > Number.MAX_SAFE_INTEGER)) {
-    throw new TypeError(`${number} is not safe to convert to a number.`);
-  }
-  return Number(number);
-}
-
 // ../../node_modules/apache-arrow/type.mjs
 var _a;
 var _b;
@@ -3725,11 +3760,13 @@ var Date_ = class extends DataType {
   toString() {
     return `Date${(this.unit + 1) * 32}<${DateUnit[this.unit]}>`;
   }
+  get ArrayType() {
+    return this.unit === DateUnit.DAY ? Int32Array : BigInt64Array;
+  }
 };
 _l = Symbol.toStringTag;
 Date_[_l] = ((proto) => {
   proto.unit = null;
-  proto.ArrayType = Int32Array;
   return proto[Symbol.toStringTag] = "Date";
 })(Date_.prototype);
 var Time_ = class extends DataType {
@@ -3771,7 +3808,7 @@ _o = Symbol.toStringTag;
 Timestamp_[_o] = ((proto) => {
   proto.unit = null;
   proto.timezone = null;
-  proto.ArrayType = Int32Array;
+  proto.ArrayType = BigInt64Array;
   return proto[Symbol.toStringTag] = "Timestamp";
 })(Timestamp_.prototype);
 var Interval_ = class extends DataType {
@@ -3976,10 +4013,6 @@ function strideForType(type) {
   switch (type.typeId) {
     case Type2.Decimal:
       return type.bitWidth / 32;
-    case Type2.Timestamp:
-      return 2;
-    case Type2.Date:
-      return 1 + t.unit;
     case Type2.Interval:
       return 1 + t.unit;
     case Type2.FixedSizeList:
@@ -4446,19 +4479,7 @@ function wrapSet(fn) {
   };
 }
 var setEpochMsToDays = (data, index, epochMs) => {
-  data[index] = Math.trunc(epochMs / 864e5);
-};
-var setEpochMsToMillisecondsLong = (data, index, epochMs) => {
-  data[index] = Math.trunc(epochMs % 4294967296);
-  data[index + 1] = Math.trunc(epochMs / 4294967296);
-};
-var setEpochMsToMicrosecondsLong = (data, index, epochMs) => {
-  data[index] = Math.trunc(epochMs * 1e3 % 4294967296);
-  data[index + 1] = Math.trunc(epochMs * 1e3 / 4294967296);
-};
-var setEpochMsToNanosecondsLong = (data, index, epochMs) => {
-  data[index] = Math.trunc(epochMs * 1e6 % 4294967296);
-  data[index + 1] = Math.trunc(epochMs * 1e6 / 4294967296);
+  data[index] = Math.floor(epochMs / 864e5);
 };
 var setVariableWidthBytes = (values, valueOffsets, index, value) => {
   if (index + 1 < valueOffsets.length) {
@@ -4493,7 +4514,7 @@ var setDateDay = ({ values }, index, value) => {
   setEpochMsToDays(values, index, value.valueOf());
 };
 var setDateMillisecond = ({ values }, index, value) => {
-  setEpochMsToMillisecondsLong(values, index * 2, value.valueOf());
+  values[index] = BigInt(value);
 };
 var setFixedSizeBinary = ({ stride, values }, index, value) => {
   values.set(value.subarray(0, stride), stride * index);
@@ -4503,10 +4524,18 @@ var setUtf8 = ({ values, valueOffsets }, index, value) => setVariableWidthBytes(
 var setDate = (data, index, value) => {
   data.type.unit === DateUnit.DAY ? setDateDay(data, index, value) : setDateMillisecond(data, index, value);
 };
-var setTimestampSecond = ({ values }, index, value) => setEpochMsToMillisecondsLong(values, index * 2, value / 1e3);
-var setTimestampMillisecond = ({ values }, index, value) => setEpochMsToMillisecondsLong(values, index * 2, value);
-var setTimestampMicrosecond = ({ values }, index, value) => setEpochMsToMicrosecondsLong(values, index * 2, value);
-var setTimestampNanosecond = ({ values }, index, value) => setEpochMsToNanosecondsLong(values, index * 2, value);
+var setTimestampSecond = ({ values }, index, value) => {
+  values[index] = BigInt(value / 1e3);
+};
+var setTimestampMillisecond = ({ values }, index, value) => {
+  values[index] = BigInt(value);
+};
+var setTimestampMicrosecond = ({ values }, index, value) => {
+  values[index] = BigInt(value * 1e3);
+};
+var setTimestampNanosecond = ({ values }, index, value) => {
+  values[index] = BigInt(value * 1e6);
+};
 var setTimestamp = (data, index, value) => {
   switch (data.type.unit) {
     case TimeUnit.SECOND:
@@ -4811,12 +4840,6 @@ function wrapGet(fn) {
   return (data, _1) => data.getValid(_1) ? fn(data, _1) : null;
 }
 var epochDaysToMs = (data, index) => 864e5 * data[index];
-var epochMillisecondsLongToMs = (data, index) => 4294967296 * data[index + 1] + (data[index] >>> 0);
-var epochMicrosecondsLongToMs = (data, index) => 4294967296 * (data[index + 1] / 1e3) + (data[index] >>> 0) / 1e3;
-var epochNanosecondsLongToMs = (data, index) => 4294967296 * (data[index + 1] / 1e6) + (data[index] >>> 0) / 1e6;
-var epochMillisecondsToDate = (epochMs) => new Date(epochMs);
-var epochDaysToDate = (data, index) => epochMillisecondsToDate(epochDaysToMs(data, index));
-var epochMillisecondsLongToDate = (data, index) => epochMillisecondsToDate(epochMillisecondsLongToMs(data, index));
 var getNull = (_data, _index) => null;
 var getVariableWidthBytes = (values, valueOffsets, index) => {
   if (index + 1 >= valueOffsets.length) {
@@ -4831,8 +4854,8 @@ var getBool = ({ offset, values }, index) => {
   const byte = values[idx >> 3];
   return (byte & 1 << idx % 8) !== 0;
 };
-var getDateDay = ({ values }, index) => epochDaysToDate(values, index);
-var getDateMillisecond = ({ values }, index) => epochMillisecondsLongToDate(values, index * 2);
+var getDateDay = ({ values }, index) => epochDaysToMs(values, index);
+var getDateMillisecond = ({ values }, index) => bigIntToNumber(values[index]);
 var getNumeric = ({ stride, values }, index) => values[stride * index];
 var getFloat16 = ({ stride, values }, index) => uint16ToFloat64(values[stride * index]);
 var getBigInts = ({ values }, index) => values[index];
@@ -4845,10 +4868,10 @@ var getUtf8 = ({ values, valueOffsets }, index) => {
 var getInt = ({ values }, index) => values[index];
 var getFloat = ({ type, values }, index) => type.precision !== Precision.HALF ? values[index] : uint16ToFloat64(values[index]);
 var getDate = (data, index) => data.type.unit === DateUnit.DAY ? getDateDay(data, index) : getDateMillisecond(data, index);
-var getTimestampSecond = ({ values }, index) => 1e3 * epochMillisecondsLongToMs(values, index * 2);
-var getTimestampMillisecond = ({ values }, index) => epochMillisecondsLongToMs(values, index * 2);
-var getTimestampMicrosecond = ({ values }, index) => epochMicrosecondsLongToMs(values, index * 2);
-var getTimestampNanosecond = ({ values }, index) => epochNanosecondsLongToMs(values, index * 2);
+var getTimestampSecond = ({ values }, index) => 1e3 * bigIntToNumber(values[index]);
+var getTimestampMillisecond = ({ values }, index) => bigIntToNumber(values[index]);
+var getTimestampMicrosecond = ({ values }, index) => divideBigInts(values[index], BigInt(1e3));
+var getTimestampNanosecond = ({ values }, index) => divideBigInts(values[index], BigInt(1e6));
 var getTimestamp = (data, index) => {
   switch (data.type.unit) {
     case TimeUnit.SECOND:
@@ -4997,12 +5020,18 @@ var instance2 = new GetVisitor();
 // ../../node_modules/apache-arrow/row/map.mjs
 var kKeys = Symbol.for("keys");
 var kVals = Symbol.for("vals");
+var kKeysAsStrings = Symbol.for("kKeysAsStrings");
+var _kKeysAsStrings = Symbol.for("_kKeysAsStrings");
 var MapRow = class {
   constructor(slice) {
     this[kKeys] = new Vector([slice.children[0]]).memoize();
     this[kVals] = slice.children[1];
     return new Proxy(this, new MapRowProxyHandler());
   }
+  /** @ignore */
+  get [kKeysAsStrings]() {
+    return this[_kKeysAsStrings] || (this[_kKeysAsStrings] = Array.from(this[kKeys].toArray(), String));
+  }
   [Symbol.iterator]() {
     return new MapRowIterator(this[kKeys], this[kVals]);
   }
@@ -5064,13 +5093,13 @@ var MapRowProxyHandler = class {
     return true;
   }
   ownKeys(row) {
-    return row[kKeys].toArray().map(String);
+    return row[kKeysAsStrings];
   }
   has(row, key) {
-    return row[kKeys].includes(key);
+    return row[kKeysAsStrings].includes(key);
   }
   getOwnPropertyDescriptor(row, key) {
-    const idx = row[kKeys].indexOf(key);
+    const idx = row[kKeysAsStrings].indexOf(key);
     if (idx !== -1) {
       return { writable: true, enumerable: true, configurable: true };
     }
@@ -5080,7 +5109,7 @@ var MapRowProxyHandler = class {
     if (Reflect.has(row, key)) {
       return row[key];
     }
-    const idx = row[kKeys].indexOf(key);
+    const idx = row[kKeysAsStrings].indexOf(key);
     if (idx !== -1) {
       const val = instance2.visit(Reflect.get(row, kVals), idx);
       Reflect.set(row, key, val);
@@ -5088,7 +5117,7 @@ var MapRowProxyHandler = class {
     }
   }
   set(row, key, val) {
-    const idx = row[kKeys].indexOf(key);
+    const idx = row[kKeysAsStrings].indexOf(key);
     if (idx !== -1) {
       instance.visit(Reflect.get(row, kVals), idx, val);
       return Reflect.set(row, key, val);
@@ -5101,15 +5130,11 @@ var MapRowProxyHandler = class {
 Object.defineProperties(MapRow.prototype, {
   [Symbol.toStringTag]: { enumerable: false, configurable: false, value: "Row" },
   [kKeys]: { writable: true, enumerable: false, configurable: false, value: null },
-  [kVals]: { writable: true, enumerable: false, configurable: false, value: null }
+  [kVals]: { writable: true, enumerable: false, configurable: false, value: null },
+  [_kKeysAsStrings]: { writable: true, enumerable: false, configurable: false, value: null }
 });
 
 // ../../node_modules/apache-arrow/util/vector.mjs
-function clampIndex(source, index, then) {
-  const length2 = source.length;
-  const adjust = index > -1 ? index : length2 + index % length2;
-  return then ? then(source, adjust) : adjust;
-}
 var tmp;
 function clampRange(source, begin, end, then) {
   const { length: len = 0 } = source;
@@ -5121,6 +5146,7 @@ function clampRange(source, begin, end, then) {
   rhs > len && (rhs = len);
   return then ? then(source, lhs, rhs) : [lhs, rhs];
 }
+var wrapIndex = (index, len) => index < 0 ? len + index : index;
 var isNaNFast = (value) => value !== value;
 function createElementComparator(search) {
   const typeofSearch = typeof search;
@@ -5409,7 +5435,10 @@ var Data = class _Data {
     let nullCount = this._nullCount;
     let nullBitmap;
     if (nullCount <= kUnknownNullCount && (nullBitmap = this.nullBitmap)) {
-      this._nullCount = nullCount = this.length - popcnt_bit_range(nullBitmap, this.offset, this.offset + this.length);
+      this._nullCount = nullCount = nullBitmap.length === 0 ? (
+        // no null bitmap, so all values are valid
+        0
+      ) : this.length - popcnt_bit_range(nullBitmap, this.offset, this.offset + this.length);
     }
     return nullCount;
   }
@@ -5471,12 +5500,14 @@ var Data = class _Data {
         nullBitmap = new Uint8Array((offset + length2 + 63 & ~63) >> 3).fill(255);
         if (this.nullCount > 0) {
           nullBitmap.set(truncateBitmap(offset, length2, this.nullBitmap), 0);
+          Object.assign(this, { nullBitmap });
+        } else {
+          Object.assign(this, { nullBitmap, _nullCount: 0 });
         }
-        Object.assign(this, { nullBitmap, _nullCount: -1 });
       }
       const byte = nullBitmap[byteOffset];
       prev = (byte & mask) !== 0;
-      value ? nullBitmap[byteOffset] = byte | mask : nullBitmap[byteOffset] = byte & ~mask;
+      nullBitmap[byteOffset] = value ? byte | mask : byte & ~mask;
     }
     if (prev !== !!value) {
       this._nullCount = this.nullCount + (value ? -1 : 1);
@@ -5917,7 +5948,9 @@ var IteratorVisitor = class extends Visitor {
 };
 function vectorIterator(vector) {
   const { type } = vector;
-  if (vector.nullCount === 0 && vector.stride === 1 && (type.typeId === Type2.Timestamp || type instanceof Int_ && type.bitWidth !== 64 || type instanceof Time_ && type.bitWidth !== 64 || type instanceof Float && type.precision !== Precision.HALF)) {
+  if (vector.nullCount === 0 && vector.stride === 1 && // Don't defer to native iterator for timestamps since Numbers are expected
+  // (DataType.isTimestamp(type)) && type.unit === TimeUnit.MILLISECOND ||
+  (DataType.isInt(type) && type.bitWidth !== 64 || DataType.isTime(type) && type.bitWidth !== 64 || DataType.isFloat(type) && type.precision !== Precision.HALF)) {
     return new ChunkedIterator(vector.data.length, (chunkIndex) => {
       const data = vector.data[chunkIndex];
       return data.values.subarray(0, data.length)[Symbol.iterator]();
@@ -6091,6 +6124,13 @@ var Vector = class _Vector {
   get(index) {
     return null;
   }
+  /**
+   * Get an element value by position.
+   * @param index The index of the element to read. A negative index will count back from the last element.
+   */
+  at(index) {
+    return this.get(wrapIndex(index, this.length));
+  }
   /**
    * Set an element value by position.
    * @param index The index of the element to write.
@@ -7368,8 +7408,8 @@ var AsyncByteStreamSource = class {
       return (yield this.next(size, "peek")).value;
     });
   }
-  next(size, cmd = "read") {
-    return __awaiter(this, void 0, void 0, function* () {
+  next(size_1) {
+    return __awaiter(this, arguments, void 0, function* (size, cmd = "read") {
       return yield this.source.next({ cmd, size });
     });
   }
@@ -8946,6 +8986,14 @@ var Table = class _Table {
   get(index) {
     return null;
   }
+  /**
+    * Get an element value by position.
+    * @param index The index of the element to read. A negative index will count back from the last element.
+    */
+  // @ts-ignore
+  at(index) {
+    return this.get(wrapIndex(index, this.numRows));
+  }
   /**
    * Set an element value by position.
    *
@@ -9183,7 +9231,7 @@ var RecordBatch2 = class _RecordBatch {
     return this.data.nullCount;
   }
   /**
-   * Check whether an element is null.
+   * Check whether an row is null.
    * @param index The index at which to read the validity bitmap.
    */
   isValid(index) {
@@ -9191,14 +9239,21 @@ var RecordBatch2 = class _RecordBatch {
   }
   /**
    * Get a row by position.
-   * @param index The index of the element to read.
+   * @param index The index of the row to read.
    */
   get(index) {
     return instance2.visit(this.data, index);
   }
+  /**
+    * Get a row value by position.
+    * @param index The index of the row to read. A negative index will count back from the last row.
+    */
+  at(index) {
+    return this.get(wrapIndex(index, this.numRows));
+  }
   /**
    * Set a row by position.
-   * @param index The index of the element to write.
+   * @param index The index of the row to write.
    * @param value The value to set.
    */
   set(index, value) {
@@ -9235,7 +9290,7 @@ var RecordBatch2 = class _RecordBatch {
   /**
    * Return a zero-copy sub-section of this RecordBatch.
    * @param start The beginning of the specified portion of the RecordBatch.
-   * @param end The end of the specified portion of the RecordBatch. This is exclusive of the element at the index 'end'.
+   * @param end The end of the specified portion of the RecordBatch. This is exclusive of the row at the index 'end'.
    */
   slice(begin, end) {
     const [slice] = new Vector([this.data]).slice(begin, end).data;
@@ -10323,8 +10378,8 @@ var AsyncMessageReader = class {
       );
     });
   }
-  readSchema(throwIfNull = false) {
-    return __awaiter(this, void 0, void 0, function* () {
+  readSchema() {
+    return __awaiter(this, arguments, void 0, function* (throwIfNull = false) {
       const type = MessageHeader.Schema;
       const message = yield this.readMessage(type);
       const schema = message === null || message === void 0 ? void 0 : message.header();
@@ -10572,8 +10627,8 @@ var AsyncRecordBatchStreamReader = class extends RecordBatchReader {
     this._impl = _impl;
   }
   readAll() {
-    var _a9, e_1, _b3, _c3;
     return __awaiter(this, void 0, void 0, function* () {
+      var _a9, e_1, _b3, _c3;
       const batches = new Array();
       try {
         for (var _d3 = true, _e3 = __asyncValues(this), _f3; _f3 = yield _e3.next(), _a9 = _f3.done, !_a9; _d3 = true) {
@@ -10946,8 +11001,8 @@ var AsyncRecordBatchFileReaderImpl = class extends AsyncRecordBatchStreamReaderI
     });
   }
   readRecordBatch(index) {
-    var _a9;
     return __awaiter(this, void 0, void 0, function* () {
+      var _a9;
       if (this.closed) {
         return null;
       }
@@ -10968,8 +11023,8 @@ var AsyncRecordBatchFileReaderImpl = class extends AsyncRecordBatchStreamReaderI
     });
   }
   _readDictionaryBatch(index) {
-    var _a9;
     return __awaiter(this, void 0, void 0, function* () {
+      var _a9;
       const block = (_a9 = this._footer) === null || _a9 === void 0 ? void 0 : _a9.getDictionaryBatch(index);
       if (block && (yield this._handle.seek(block.offset))) {
         const message = yield this._reader.readMessage(MessageHeader.DictionaryBatch);
@@ -11474,9 +11529,9 @@ function writeAll(writer, input) {
   return writer.finish();
 }
 function writeAllAsync(writer, batches) {
-  var _a9, batches_1, batches_1_1;
-  var _b3, e_1, _c3, _d3;
   return __awaiter(this, void 0, void 0, function* () {
+    var _a9, batches_1, batches_1_1;
+    var _b3, e_1, _c3, _d3;
     try {
       for (_a9 = true, batches_1 = __asyncValues(batches); batches_1_1 = yield batches_1.next(), _b3 = batches_1_1.done, !_b3; _a9 = true) {
         _d3 = batches_1_1.value;
@@ -11839,6 +11894,13 @@ function socketConnector(uri = "ws://localhost:3000/") {
     get connected() {
       return connected;
     },
+    /**
+     * Query the DuckDB server.
+     * @param {object} query
+     * @param {'exec' | 'arrow' | 'json'} [query.type] The query type: 'exec', 'arrow', or 'json'.
+     * @param {string} query.sql A SQL query string.
+     * @returns the query result
+     */
     query(query) {
       return new Promise(
         (resolve, reject) => enqueue(query, resolve, reject)
@@ -11909,7 +11971,7 @@ function literalToSQL(value) {
     case "boolean":
       return value ? "TRUE" : "FALSE";
     case "string":
-      return `'${value}'`;
+      return `'${value.replace(`'`, `''`)}'`;
     case "number":
       return Number.isFinite(value) ? String(value) : "NULL";
     default:
@@ -11992,7 +12054,7 @@ var SQLExpression = class {
   /**
    * Annotate this expression instance with additional properties.
    * @param {object[]} [props] One or more objects with properties to add.
-   * @returns {this} This SQL expression.
+   * @returns This SQL expression.
    */
   annotate(...props) {
     return Object.assign(this, ...props);
@@ -12050,6 +12112,12 @@ function sql(strings, ...exprs) {
   return new SQLExpression(spans, cols);
 }
 
+// ../sql/src/literal.js
+var literal = (value) => ({
+  value,
+  toString: () => literalToSQL(value)
+});
+
 // ../sql/src/operators.js
 function visit(callback) {
   callback(this.op, this);
@@ -12248,6 +12316,9 @@ var last_value = winf("LAST_VALUE");
 var nth_value = winf("NTH_VALUE");
 
 // ../sql/src/aggregates.js
+function agg(strings, ...exprs) {
+  return sql(strings, ...exprs).annotate({ aggregate: true });
+}
 var AggregateFunction = class _AggregateFunction extends SQLExpression {
   /**
    * Create a new AggregateFunction instance.
@@ -12378,6 +12449,7 @@ var entropy = aggf("ENTROPY");
 var varPop = aggf("VAR_POP");
 var stddevPop = aggf("STDDEV_POP");
 var corr = aggf("CORR");
+var covariance = aggf("COVAR_SAMP");
 var covarPop = aggf("COVAR_POP");
 var regrIntercept = aggf("REGR_INTERCEPT");
 var regrSlope = aggf("REGR_SLOPE");
@@ -12520,7 +12592,8 @@ var Query = class _Query {
           }
         }
       }
-      query.select = query.select.concat(list);
+      const keys = new Set(list.map((x3) => x3.as));
+      query.select = query.select.filter((x3) => !keys.has(x3.as)).concat(list.filter((x3) => x3.expr));
       return this;
     }
   }
@@ -12993,6 +13066,7 @@ function scaleTime() {
   };
 }
 var scales = {
+  identity: scaleLinear,
   linear: scaleLinear,
   log: scaleLog,
   symlog: scaleSymlog,
@@ -13015,179 +13089,97 @@ function create(name, query, {
   return "CREATE" + (replace ? " OR REPLACE " : " ") + (temp ? "TEMP " : "") + (view ? "VIEW" : "TABLE") + (replace ? " " : " IF NOT EXISTS ") + name + " AS " + query;
 }
 
-// src/util/hash.js
-function fnv_hash(v2) {
-  let a2 = 2166136261;
-  for (let i = 0, n = v2.length; i < n; ++i) {
-    const c = v2.charCodeAt(i);
-    const d = c & 65280;
-    if (d) a2 = fnv_multiply(a2 ^ d >> 8);
-    a2 = fnv_multiply(a2 ^ c & 255);
-  }
-  return fnv_mix(a2);
-}
-function fnv_multiply(a2) {
-  return a2 + (a2 << 1) + (a2 << 4) + (a2 << 7) + (a2 << 8) + (a2 << 24);
-}
-function fnv_mix(a2) {
-  a2 += a2 << 13;
-  a2 ^= a2 >>> 7;
-  a2 += a2 << 3;
-  a2 ^= a2 >>> 17;
-  a2 += a2 << 5;
-  return a2 & 4294967295;
-}
-
-// src/DataCubeIndexer.js
-var DataCubeIndexer = class {
-  /**
-   *
-   * @param {import('./Coordinator.js').Coordinator} mc a Mosaic coordinator
-   * @param {*} options Options hash to configure the data cube indexes and pass selections to the coordinator.
-   */
-  constructor(mc, { selection, temp = true }) {
-    this.mc = mc;
-    this.selection = selection;
-    this.temp = temp;
-    this.reset();
-  }
-  reset() {
-    this.enabled = false;
-    this.clients = null;
-    this.indices = null;
-    this.activeView = null;
-  }
-  clear() {
-    if (this.indices) {
-      this.mc.cancel(Array.from(this.indices.values(), (index) => index.result));
-      this.indices = null;
-    }
-  }
-  index(clients, active) {
-    if (this.clients !== clients) {
-      const cols = Array.from(clients, getIndexColumns);
-      const from = cols[0]?.from;
-      this.enabled = cols.every((c) => c && c.from === from);
-      this.clients = clients;
-      this.activeView = null;
-      this.clear();
-    }
-    if (!this.enabled) return false;
-    active = active || this.selection.active;
-    const { source } = active;
-    if (source && source === this.activeView?.source) return true;
-    this.clear();
-    if (!source) return false;
-    const activeView = this.activeView = getActiveView(active);
-    if (!activeView) return false;
-    this.mc.logger().warn("DATA CUBE INDEX CONSTRUCTION");
-    const sel = this.selection.remove(source);
-    const indices = this.indices = /* @__PURE__ */ new Map();
-    const { mc, temp } = this;
-    for (const client of clients) {
-      if (sel.skip(client, active)) continue;
-      const index = getIndexColumns(client);
-      const query = client.query(sel.predicate(client)).select({ ...activeView.columns, ...index.aux }).groupby(Object.keys(activeView.columns));
-      const [subq] = query.subqueries;
-      if (subq) {
-        const cols = Object.values(activeView.columns).map((c) => c.columns[0]);
-        subqueryPushdown(subq, cols);
-      }
-      const order = query.orderby();
-      query.query.orderby = [];
-      const sql2 = query.toString();
-      const id = (fnv_hash(sql2) >>> 0).toString(16);
-      const table = `cube_index_${id}`;
-      const result = mc.exec(create(table, sql2, { temp }));
-      indices.set(client, { table, result, order, ...index });
-    }
-    return true;
-  }
-  async update() {
-    const { clients, selection, activeView } = this;
-    const filter = activeView.predicate(selection.active.predicate);
-    return Promise.all(
-      Array.from(clients).map((client) => this.updateClient(client, filter))
-    );
-  }
-  async updateClient(client, filter) {
-    const index = this.indices.get(client);
-    if (!index) return;
-    if (!filter) {
-      filter = this.activeView.predicate(this.selection.active.predicate);
-    }
-    const { table, dims, aggr, order = [] } = index;
-    const query = Query.select(dims, aggr).from(table).groupby(dims).where(filter).orderby(order);
-    return this.mc.updateClient(client, query);
-  }
-};
-function getActiveView(clause) {
-  const { source, schema } = clause;
-  let columns = clause.predicate?.columns;
-  if (!schema || !columns) return null;
-  const { type, scales: scales2, pixelSize = 1 } = schema;
-  let predicate;
-  if (type === "interval" && scales2) {
-    const bins = scales2.map((s) => binInterval(s, pixelSize));
-    if (bins.some((b2) => b2 == null)) return null;
-    if (bins.length === 1) {
-      predicate = (p2) => p2 ? isBetween("active0", p2.range.map(bins[0])) : [];
-      columns = { active0: bins[0](clause.predicate.field) };
-    } else {
-      predicate = (p2) => p2 ? and(p2.children.map(({ range }, i) => isBetween(`active${i}`, range.map(bins[i])))) : [];
-      columns = Object.fromEntries(
-        clause.predicate.children.map((p2, i) => [`active${i}`, bins[i](p2.field)])
-      );
-    }
-  } else if (type === "point") {
-    predicate = (x3) => x3;
-    columns = Object.fromEntries(columns.map((col) => [col.toString(), col]));
-  } else {
-    return null;
-  }
-  return { source, columns, predicate };
-}
-function binInterval(scale, pixelSize) {
-  const { apply, sqlApply } = scaleTransform(scale);
-  if (apply) {
-    const { domain, range } = scale;
-    const lo = apply(Math.min(...domain));
-    const hi = apply(Math.max(...domain));
-    const a2 = Math.abs(range[1] - range[0]) / (hi - lo) / pixelSize;
-    const s = pixelSize === 1 ? "" : `${pixelSize}::INTEGER * `;
-    return (value) => sql`${s}FLOOR(${a2}::DOUBLE * (${sqlApply(value)} - ${lo}::DOUBLE))::INTEGER`;
-  }
-}
-var NO_INDEX = { from: NaN };
-function getIndexColumns(client) {
-  if (!client.filterIndexable) return NO_INDEX;
+// src/util/index-columns.js
+function indexColumns(client) {
+  if (!client.filterIndexable) return null;
   const q2 = client.query();
   const from = getBaseTable(q2);
-  if (!from || !q2.groupby) return NO_INDEX;
-  const g2 = new Set(q2.groupby().map((c) => c.column));
+  if (typeof from !== "string" || !q2.select) return null;
   const aggr = [];
   const dims = [];
   const aux = {};
-  let auxAs;
   for (const entry of q2.select()) {
     const { as, expr: { aggregate, args } } = entry;
     const op = aggregate?.toUpperCase?.();
     switch (op) {
       case "COUNT":
       case "SUM":
-        aggr.push({ [as]: sql`SUM("${as}")::DOUBLE` });
+        aggr.push({ [as]: agg`SUM("${as}")::DOUBLE` });
         break;
       case "AVG":
-        aux[auxAs = "__count__"] = sql`COUNT(*)`;
-        aggr.push({ [as]: sql`(SUM("${as}" * ${auxAs}) / SUM(${auxAs}))::DOUBLE` });
+        aggr.push({ [as]: avgExpr(aux, as, args[0]) });
         break;
       case "ARG_MAX":
-        aux[auxAs = `__max_${as}__`] = sql`MAX(${args[1]})`;
-        aggr.push({ [as]: sql`ARG_MAX("${as}", ${auxAs})` });
+        aggr.push({ [as]: argmaxExpr(aux, as, args) });
         break;
       case "ARG_MIN":
-        aux[auxAs = `__min_${as}__`] = sql`MIN(${args[1]})`;
-        aggr.push({ [as]: sql`ARG_MIN("${as}", ${auxAs})` });
+        aggr.push({ [as]: argminExpr(aux, as, args) });
+        break;
+      case "VARIANCE":
+      case "VAR_SAMP":
+        aux[as] = null;
+        aggr.push({ [as]: varianceExpr(aux, args[0], from) });
+        break;
+      case "VAR_POP":
+        aux[as] = null;
+        aggr.push({ [as]: varianceExpr(aux, args[0], from, false) });
+        break;
+      case "STDDEV":
+      case "STDDEV_SAMP":
+        aux[as] = null;
+        aggr.push({ [as]: agg`SQRT(${varianceExpr(aux, args[0], from)})` });
+        break;
+      case "STDDEV_POP":
+        aux[as] = null;
+        aggr.push({ [as]: agg`SQRT(${varianceExpr(aux, args[0], from, false)})` });
+        break;
+      case "COVAR_SAMP":
+        aux[as] = null;
+        aggr.push({ [as]: covarianceExpr(aux, args, from) });
+        break;
+      case "COVAR_POP":
+        aux[as] = null;
+        aggr.push({ [as]: covarianceExpr(aux, args, from, false) });
+        break;
+      case "CORR":
+        aux[as] = null;
+        aggr.push({ [as]: corrExpr(aux, args, from) });
+        break;
+      case "REGR_COUNT":
+        aux[as] = null;
+        aggr.push({ [as]: agg`${regrCountExpr(aux, args)}::DOUBLE` });
+        break;
+      case "REGR_AVGX":
+        aux[as] = null;
+        aggr.push({ [as]: regrAvgXExpr(aux, args) });
+        break;
+      case "REGR_AVGY":
+        aux[as] = null;
+        aggr.push({ [as]: regrAvgYExpr(aux, args) });
+        break;
+      case "REGR_SYY":
+        aux[as] = null;
+        aggr.push({ [as]: regrVarExpr(aux, 0, args, from) });
+        break;
+      case "REGR_SXX":
+        aux[as] = null;
+        aggr.push({ [as]: regrVarExpr(aux, 1, args, from) });
+        break;
+      case "REGR_SXY":
+        aux[as] = null;
+        aggr.push({ [as]: covarianceExpr(aux, args, from, null) });
+        break;
+      case "REGR_SLOPE":
+        aux[as] = null;
+        aggr.push({ [as]: regrSlopeExpr(aux, args, from) });
+        break;
+      case "REGR_INTERCEPT":
+        aux[as] = null;
+        aggr.push({ [as]: regrInterceptExpr(aux, args, from) });
+        break;
+      case "REGR_R2":
+        aux[as] = null;
+        aggr.push({ [as]: agg`(${corrExpr(aux, args, from)}) ** 2` });
         break;
       case "MAX":
       case "MIN":
@@ -13197,14 +13189,22 @@ function getIndexColumns(client) {
       case "BOOL_AND":
       case "BOOL_OR":
       case "PRODUCT":
-        aggr.push({ [as]: sql`${op}("${as}")` });
+        aggr.push({ [as]: agg`${op}("${as}")` });
         break;
       default:
-        if (g2.has(as)) dims.push(as);
+        if (!aggregate) dims.push(as);
         else return null;
     }
   }
-  return { aggr, dims, aux, from };
+  if (!aggr.length) return null;
+  return { from, dims, aggr, aux };
+}
+function auxName(type, ...args) {
+  const cols = args.length ? "_" + args.map(sanitize).join("_") : "";
+  return `__${type}${cols}__`;
+}
+function sanitize(col) {
+  return `${col}`.replaceAll('"', "").replaceAll(" ", "_");
 }
 function getBaseTable(query) {
   const subq = query.subqueries;
@@ -13221,90 +13221,362 @@ function getBaseTable(query) {
   }
   return base;
 }
-function subqueryPushdown(query, cols) {
-  const memo = /* @__PURE__ */ new Set();
-  const pushdown = (q2) => {
-    if (memo.has(q2)) return;
-    memo.add(q2);
-    if (q2.select && q2.from().length) {
-      q2.select(cols);
-    }
-    q2.subqueries.forEach(pushdown);
-  };
-  pushdown(query);
+function countExpr(aux, arg) {
+  const n = auxName("count", arg);
+  aux[n] = agg`COUNT(${arg})`;
+  return agg`SUM(${n})`.annotate({ name: n });
+}
+function avgExpr(aux, as, arg) {
+  const n = countExpr(aux, arg);
+  return agg`(SUM("${as}" * ${n.name}) / ${n})`;
+}
+function avg2(x3, from) {
+  return sql`(SELECT AVG(${x3}) FROM "${from}")`;
+}
+function argmaxExpr(aux, as, [, y3]) {
+  const max2 = auxName("max", y3);
+  aux[max2] = agg`MAX(${y3})`;
+  return agg`ARG_MAX("${as}", ${max2})`;
+}
+function argminExpr(aux, as, [, y3]) {
+  const min2 = auxName("min", y3);
+  aux[min2] = agg`MIN(${y3})`;
+  return agg`ARG_MIN("${as}", ${min2})`;
+}
+function varianceExpr(aux, x3, from, correction = true) {
+  const n = countExpr(aux, x3);
+  const ssq = auxName("rssq", x3);
+  const sum3 = auxName("rsum", x3);
+  const delta = sql`${x3} - ${avg2(x3, from)}`;
+  aux[ssq] = agg`SUM((${delta}) ** 2)`;
+  aux[sum3] = agg`SUM(${delta})`;
+  const adj = correction ? ` - 1` : "";
+  return agg`(SUM(${ssq}) - (SUM(${sum3}) ** 2 / ${n})) / (${n}${adj})`;
+}
+function covarianceExpr(aux, args, from, correction = true) {
+  const n = regrCountExpr(aux, args);
+  const sxy = regrSumXYExpr(aux, args, from);
+  const sx = regrSumExpr(aux, 1, args, from);
+  const sy = regrSumExpr(aux, 0, args, from);
+  const adj = correction === null ? "" : correction ? ` / (${n} - 1)` : ` / ${n}`;
+  return agg`(${sxy} - ${sx} * ${sy} / ${n})${adj}`;
+}
+function corrExpr(aux, args, from) {
+  const n = regrCountExpr(aux, args);
+  const sxy = regrSumXYExpr(aux, args, from);
+  const sxx = regrSumSqExpr(aux, 1, args, from);
+  const syy = regrSumSqExpr(aux, 0, args, from);
+  const sx = regrSumExpr(aux, 1, args, from);
+  const sy = regrSumExpr(aux, 0, args, from);
+  const vx = agg`(${sxx} - (${sx} ** 2) / ${n})`;
+  const vy = agg`(${syy} - (${sy} ** 2) / ${n})`;
+  return agg`(${sxy} - ${sx} * ${sy} / ${n}) / SQRT(${vx} * ${vy})`;
+}
+function regrCountExpr(aux, [y3, x3]) {
+  const n = auxName("count", y3, x3);
+  aux[n] = agg`REGR_COUNT(${y3}, ${x3})`;
+  return agg`SUM(${n})`.annotate({ name: n });
+}
+function regrSumExpr(aux, i, args, from) {
+  const v2 = args[i];
+  const o = args[1 - i];
+  const sum3 = auxName("rs", v2);
+  aux[sum3] = agg`SUM(${v2} - ${avg2(v2, from)}) FILTER (${o} IS NOT NULL)`;
+  return agg`SUM(${sum3})`;
+}
+function regrSumSqExpr(aux, i, args, from) {
+  const v2 = args[i];
+  const u = args[1 - i];
+  const ssq = auxName("rss", v2);
+  aux[ssq] = agg`SUM((${v2} - ${avg2(v2, from)}) ** 2) FILTER (${u} IS NOT NULL)`;
+  return agg`SUM(${ssq})`;
+}
+function regrSumXYExpr(aux, args, from) {
+  const [y3, x3] = args;
+  const sxy = auxName("sxy", y3, x3);
+  aux[sxy] = agg`SUM((${x3} - ${avg2(x3, from)}) * (${y3} - ${avg2(y3, from)}))`;
+  return agg`SUM(${sxy})`;
+}
+function regrAvgXExpr(aux, args) {
+  const [y3, x3] = args;
+  const n = regrCountExpr(aux, args);
+  const a2 = auxName("avg", x3, y3);
+  aux[a2] = agg`REGR_AVGX(${y3}, ${x3})`;
+  return agg`(SUM(${a2} * ${n.name}) / ${n})`;
+}
+function regrAvgYExpr(aux, args) {
+  const [y3, x3] = args;
+  const n = regrCountExpr(aux, args);
+  const a2 = auxName("avg", y3, x3);
+  aux[a2] = agg`REGR_AVGY(${y3}, ${x3})`;
+  return agg`(SUM(${a2} * ${n.name}) / ${n})`;
+}
+function regrVarExpr(aux, i, args, from) {
+  const n = regrCountExpr(aux, args);
+  const sum3 = regrSumExpr(aux, i, args, from);
+  const ssq = regrSumSqExpr(aux, i, args, from);
+  return agg`(${ssq} - (${sum3} ** 2 / ${n}))`;
+}
+function regrSlopeExpr(aux, args, from) {
+  const cov = covarianceExpr(aux, args, from, null);
+  const varx = regrVarExpr(aux, 1, args, from);
+  return agg`(${cov}) / ${varx}`;
+}
+function regrInterceptExpr(aux, args, from) {
+  const ax = regrAvgXExpr(aux, args);
+  const ay = regrAvgYExpr(aux, args);
+  const m2 = regrSlopeExpr(aux, args, from);
+  return agg`${ay} - (${m2}) * ${ax}`;
+}
+
+// src/util/hash.js
+function fnv_hash(v2) {
+  let a2 = 2166136261;
+  for (let i = 0, n = v2.length; i < n; ++i) {
+    const c = v2.charCodeAt(i);
+    const d = c & 65280;
+    if (d) a2 = fnv_multiply(a2 ^ d >> 8);
+    a2 = fnv_multiply(a2 ^ c & 255);
+  }
+  return fnv_mix(a2);
+}
+function fnv_multiply(a2) {
+  return a2 + (a2 << 1) + (a2 << 4) + (a2 << 7) + (a2 << 8) + (a2 << 24);
+}
+function fnv_mix(a2) {
+  a2 += a2 << 13;
+  a2 ^= a2 >>> 7;
+  a2 += a2 << 3;
+  a2 ^= a2 >>> 17;
+  a2 += a2 << 5;
+  return a2 & 4294967295;
 }
 
-// src/FilterGroup.js
-var FilterGroup = class {
+// src/DataCubeIndexer.js
+var Skip = { skip: true, result: null };
+var DataCubeIndexer = class {
   /**
-   * @param {import('./Coordinator.js').Coordinator} coordinator The Mosaic coordinator.
-   * @param {*} selection The shared filter selection.
-   * @param {*} index Boolean flag or options hash for data cube indexer.
-   *  Falsy values disable indexing.
+   * Create a new data cube index table manager.
+   * @param {import('./Coordinator.js').Coordinator} coordinator A Mosaic coordinator.
+   * @param {object} [options] Indexer options.
+   * @param {boolean} [options.enabled=true] Flag to enable/disable indexer.
+   * @param {boolean} [options.temp=true] Flag to indicate if generated data
+   *  cube index tables should be temporary tables.
    */
-  constructor(coordinator2, selection, index = true) {
+  constructor(coordinator2, {
+    enabled = true,
+    temp = true
+  } = {}) {
+    this.indexes = /* @__PURE__ */ new Map();
+    this.active = null;
+    this.temp = temp;
     this.mc = coordinator2;
-    this.selection = selection;
-    this.clients = /* @__PURE__ */ new Set();
-    this.indexer = index ? new DataCubeIndexer(this.mc, { ...index, selection }) : null;
-    const { value, activate } = this.handlers = {
-      value: () => this.update(),
-      activate: (clause) => this.indexer?.index(this.clients, clause)
-    };
-    selection.addEventListener("value", value);
-    selection.addEventListener("activate", activate);
-  }
-  finalize() {
-    const { value, activate } = this.handlers;
-    this.selection.removeEventListener("value", value);
-    this.selection.removeEventListener("activate", activate);
-  }
-  reset() {
-    this.indexer?.reset();
-  }
-  add(client) {
-    (this.clients = new Set(this.clients)).add(client);
-    return this;
+    this._enabled = enabled;
   }
-  remove(client) {
-    if (this.clients.has(client)) {
-      (this.clients = new Set(this.clients)).delete(client);
+  /**
+   * Set the enabled state of this indexer. If false, any cached state is
+   * cleared and subsequent index calls will return null until re-enabled.
+   * @param {boolean} state The enabled state.
+   */
+  enabled(state) {
+    if (state === void 0) {
+      return this._enabled;
+    } else if (this._enabled !== state) {
+      if (!state) this.clear();
+      this._enabled = state;
     }
-    return this;
   }
   /**
-   * Internal method to process a selection update.
-   * The return value is passed as a selection callback value.
-   * @returns {Promise} A Promise that resolves when the update completes.
+   * Clear the cache of data cube index table entries for the current active
+   * selection clause. This method will also cancel any queued data cube table
+   * creation queries that have not yet been submitted to the database. This
+   * method does _not_ drop any existing data cube tables.
    */
-  update() {
-    const { mc, indexer, clients, selection } = this;
-    const hasIndex = indexer?.index(clients);
-    return hasIndex ? indexer.update() : defaultUpdate(mc, clients, selection);
+  clear() {
+    this.mc.cancel(Array.from(this.indexes.values(), (info) => info?.result));
+    this.indexes.clear();
+    this.active = null;
+  }
+  /**
+   * Return data cube index table information for the active state of a
+   * client-selection pair, or null if the client is not indexable. This
+   * method has multiple possible side effects, including data cube table
+   * generation and updating internal caches.
+   * @param {import('./MosaicClient.js').MosaicClient} client A Mosaic client.
+   * @param {import('./Selection.js').Selection} selection A Mosaic selection
+   *  to filter the client by.
+   * @param {import('./util/selection-types.js').SelectionClause} activeClause
+   *  A representative active selection clause for which to (possibly) generate
+   *  data cube index tables.
+   * @returns {DataCubeInfo | Skip | null} Data cube index table
+   *  information and query generator, or null if the client is not indexable.
+   */
+  index(client, selection, activeClause) {
+    if (!this._enabled) return null;
+    const { indexes, mc, temp } = this;
+    const { source } = activeClause;
+    if (!source) return null;
+    if (this.active) {
+      if (this.active.source !== source) this.clear();
+      if (this.active?.source === null) return null;
+    }
+    let { active } = this;
+    if (!active) {
+      this.active = active = activeColumns(activeClause);
+      if (active.source === null) return null;
+    }
+    if (indexes.has(client)) {
+      return indexes.get(client);
+    }
+    const indexCols = indexColumns(client);
+    let info;
+    if (!indexCols) {
+      info = null;
+    } else if (selection.skip(client, activeClause)) {
+      info = Skip;
+    } else {
+      const filter = selection.remove(source).predicate(client);
+      info = dataCubeInfo(client.query(filter), active, indexCols);
+      info.result = mc.exec(create(info.table, info.create, { temp }));
+      info.result.catch((e) => mc.logger().error(e));
+    }
+    indexes.set(client, info);
+    return info;
   }
 };
-function defaultUpdate(mc, clients, selection) {
-  return Promise.all(Array.from(clients).map((client) => {
-    const filter = selection.predicate(client);
-    if (filter != null) {
-      return mc.updateClient(client, client.query(filter));
-    }
-  }));
+function activeColumns(clause) {
+  const { source, meta } = clause;
+  const clausePred = clause.predicate;
+  const clauseCols = clausePred?.columns;
+  let predicate;
+  let columns;
+  if (!meta || !clauseCols) {
+    return { source: null, columns, predicate };
+  }
+  const { type, scales: scales2, bin, pixelSize = 1 } = meta;
+  if (type === "point") {
+    predicate = (x3) => x3;
+    columns = Object.fromEntries(
+      clauseCols.map((col) => [`${col}`, asColumn(col)])
+    );
+  } else if (type === "interval" && scales2) {
+    const bins = scales2.map((s) => binInterval(s, pixelSize, bin));
+    if (bins.some((b2) => !b2)) {
+    } else if (bins.length === 1) {
+      predicate = (p2) => p2 ? isBetween("active0", p2.range.map(bins[0])) : [];
+      columns = { active0: bins[0](clausePred.field) };
+    } else {
+      predicate = (p2) => p2 ? and(p2.children.map(
+        ({ range }, i) => isBetween(`active${i}`, range.map(bins[i]))
+      )) : [];
+      columns = Object.fromEntries(
+        // @ts-ignore
+        clausePred.children.map((p2, i) => [`active${i}`, bins[i](p2.field)])
+      );
+    }
+  }
+  return { source: columns ? source : null, columns, predicate };
+}
+var BIN = { ceil: "CEIL", round: "ROUND" };
+function binInterval(scale, pixelSize, bin) {
+  const { type, domain, range, apply, sqlApply } = scaleTransform(scale);
+  if (!apply) return;
+  const fn = BIN[`${bin}`.toLowerCase()] || "FLOOR";
+  const lo = apply(Math.min(...domain));
+  const hi = apply(Math.max(...domain));
+  const a2 = type === "identity" ? 1 : Math.abs(range[1] - range[0]) / (hi - lo);
+  const s = a2 / pixelSize === 1 ? "" : `${a2 / pixelSize}::DOUBLE * `;
+  const d = lo === 0 ? "" : ` - ${lo}::DOUBLE`;
+  return (value) => sql`${fn}(${s}(${sqlApply(value)}${d}))::INTEGER`;
+}
+function dataCubeInfo(clientQuery, active, indexCols) {
+  const { dims, aggr, aux } = indexCols;
+  const { columns } = active;
+  const query = clientQuery.select({ ...columns, ...aux }).groupby(Object.keys(columns));
+  const [subq] = query.subqueries;
+  if (subq) {
+    const cols = Object.values(columns).flatMap((c) => c.columns);
+    subqueryPushdown(subq, cols);
+  }
+  const order = query.orderby();
+  query.query.orderby = [];
+  const create2 = query.toString();
+  const id = (fnv_hash(create2) >>> 0).toString(16);
+  const table = `cube_index_${id}`;
+  const select = Query.select(dims, aggr).from(table).groupby(dims).orderby(order);
+  return new DataCubeInfo({ table, create: create2, active, select });
+}
+function subqueryPushdown(query, cols) {
+  const memo = /* @__PURE__ */ new Set();
+  const pushdown = (q2) => {
+    if (memo.has(q2)) return;
+    memo.add(q2);
+    if (q2.select && q2.from().length) {
+      q2.select(cols);
+    }
+    q2.subqueries.forEach(pushdown);
+  };
+  pushdown(query);
 }
+var DataCubeInfo = class {
+  /**
+   * Create a new DataCubeInfo instance.
+   * @param {object} options
+   */
+  constructor({ table, create: create2, active, select } = {}) {
+    this.table = table;
+    this.create = create2;
+    this.result = null;
+    this.active = active;
+    this.select = select;
+    this.skip = false;
+  }
+  /**
+   * Generate a data cube index table query for the given predicate.
+   * @param {import('@uwdata/mosaic-sql').SQLExpression} predicate The current
+   *  active clause predicate.
+   * @returns {Query} A data cube index table query.
+   */
+  query(predicate) {
+    return this.select.clone().where(this.active.predicate(predicate));
+  }
+};
 
 // src/util/query-result.js
-function queryResult() {
-  let resolve;
-  let reject;
-  const p2 = new Promise((r, e) => {
-    resolve = r;
-    reject = e;
-  });
-  return Object.assign(p2, {
-    fulfill: (value) => (resolve(value), p2),
-    reject: (err) => (reject(err), p2)
-  });
-}
+var QueryResult = class extends Promise {
+  /**
+   * Create a new query result Promise.
+   */
+  constructor() {
+    let resolve;
+    let reject;
+    super((r, e) => {
+      resolve = r;
+      reject = e;
+    });
+    this._resolve = resolve;
+    this._reject = reject;
+  }
+  /**
+   * Resolve the result Promise with the provided value.
+   * @param {*} value The result value.
+   * @returns {this}
+   */
+  fulfill(value) {
+    this._resolve(value);
+    return this;
+  }
+  /**
+   * Rejects the result Promise with the provided error.
+   * @param {*} error The error value.
+   * @returns {this}
+   */
+  reject(error) {
+    this._reject(error);
+    return this;
+  }
+};
+QueryResult.prototype.constructor = Promise;
 
 // src/QueryConsolidator.js
 function wait(callback) {
@@ -13380,7 +13652,7 @@ function consolidate(group, enqueue, record) {
         record: false,
         query: group.query = consolidatedQuery(group, record)
       },
-      result: group.result = queryResult()
+      result: group.result = new QueryResult()
     });
   } else {
     for (const { entry, priority } of group) {
@@ -13596,115 +13868,124 @@ function priorityQueue(ranks) {
 
 // src/QueryManager.js
 var Priority = { High: 0, Normal: 1, Low: 2 };
-function QueryManager() {
-  const queue = priorityQueue(3);
-  let db;
-  let clientCache;
-  let logger;
-  let recorders = [];
-  let pending = null;
-  let consolidate2;
-  function next() {
-    if (pending || queue.isEmpty()) return;
-    const { request, result } = queue.next();
-    pending = submit(request, result);
-    pending.finally(() => {
-      pending = null;
-      next();
+var QueryManager = class {
+  constructor() {
+    this.queue = priorityQueue(3);
+    this.db = null;
+    this.clientCache = null;
+    this._logger = null;
+    this._logQueries = false;
+    this.recorders = [];
+    this.pending = null;
+    this._consolidate = null;
+  }
+  next() {
+    if (this.pending || this.queue.isEmpty()) return;
+    const { request, result } = this.queue.next();
+    this.pending = this.submit(request, result);
+    this.pending.finally(() => {
+      this.pending = null;
+      this.next();
     });
   }
-  function enqueue(entry, priority = Priority.Normal) {
-    queue.insert(entry, priority);
-    next();
+  enqueue(entry, priority = Priority.Normal) {
+    this.queue.insert(entry, priority);
+    this.next();
   }
-  function recordQuery(sql2) {
-    if (recorders.length && sql2) {
-      recorders.forEach((rec) => rec.add(sql2));
+  recordQuery(sql2) {
+    if (this.recorders.length && sql2) {
+      this.recorders.forEach((rec) => rec.add(sql2));
     }
   }
-  async function submit(request, result) {
+  async submit(request, result) {
     try {
       const { query, type, cache = false, record = true, options } = request;
       const sql2 = query ? `${query}` : null;
       if (record) {
-        recordQuery(sql2);
+        this.recordQuery(sql2);
       }
       if (cache) {
-        const cached = clientCache.get(sql2);
+        const cached = this.clientCache.get(sql2);
         if (cached) {
-          logger.debug("Cache");
+          this._logger.debug("Cache");
           result.fulfill(cached);
           return;
         }
       }
       const t0 = performance.now();
-      const data = await db.query({ type, sql: sql2, ...options });
-      if (cache) clientCache.set(sql2, data);
-      logger.debug(`Request: ${(performance.now() - t0).toFixed(1)}`);
+      if (this._logQueries) {
+        this._logger.debug("Query", { type, sql: sql2, ...options });
+      }
+      const data = await this.db.query({ type, sql: sql2, ...options });
+      if (cache) this.clientCache.set(sql2, data);
+      this._logger.debug(`Request: ${(performance.now() - t0).toFixed(1)}`);
       result.fulfill(data);
     } catch (err) {
       result.reject(err);
     }
   }
-  return {
-    cache(value) {
-      return value !== void 0 ? clientCache = value === true ? lruCache() : value || voidCache() : clientCache;
-    },
-    logger(value) {
-      return value ? logger = value : logger;
-    },
-    connector(connector) {
-      return connector ? db = connector : db;
-    },
-    consolidate(flag) {
-      if (flag && !consolidate2) {
-        consolidate2 = consolidator(enqueue, clientCache, recordQuery);
-      } else if (!flag && consolidate2) {
-        consolidate2 = null;
-      }
-    },
-    request(request, priority = Priority.Normal) {
-      const result = queryResult();
-      const entry = { request, result };
-      if (consolidate2) {
-        consolidate2.add(entry, priority);
-      } else {
-        enqueue(entry, priority);
-      }
-      return result;
-    },
-    cancel(requests) {
-      const set = new Set(requests);
-      queue.remove(({ result }) => set.has(result));
-    },
-    clear() {
-      queue.remove(({ result }) => {
-        result.reject("Cleared");
-        return true;
-      });
-    },
-    record() {
-      let state = [];
-      const recorder = {
-        add(query) {
-          state.push(query);
-        },
-        reset() {
-          state = [];
-        },
-        snapshot() {
-          return state.slice();
-        },
-        stop() {
-          recorders = recorders.filter((x3) => x3 !== recorder);
-          return state;
-        }
-      };
-      recorders.push(recorder);
-      return recorder;
+  cache(value) {
+    return value !== void 0 ? this.clientCache = value === true ? lruCache() : value || voidCache() : this.clientCache;
+  }
+  logger(value) {
+    return value ? this._logger = value : this._logger;
+  }
+  logQueries(value) {
+    return value !== void 0 ? this._logQueries = !!value : this._logQueries;
+  }
+  connector(connector) {
+    return connector ? this.db = connector : this.db;
+  }
+  consolidate(flag) {
+    if (flag && !this._consolidate) {
+      this._consolidate = consolidator(this.enqueue.bind(this), this.clientCache, this.recordQuery.bind(this));
+    } else if (!flag && this._consolidate) {
+      this._consolidate = null;
     }
-  };
-}
+  }
+  request(request, priority = Priority.Normal) {
+    const result = new QueryResult();
+    const entry = { request, result };
+    if (this._consolidate) {
+      this._consolidate.add(entry, priority);
+    } else {
+      this.enqueue(entry, priority);
+    }
+    return result;
+  }
+  cancel(requests) {
+    const set = new Set(requests);
+    if (set.size) {
+      this.queue.remove(({ result }) => set.has(result));
+    }
+  }
+  clear() {
+    this.queue.remove(({ result }) => {
+      result.reject("Cleared");
+      return true;
+    });
+  }
+  record() {
+    let state = [];
+    const recorder = {
+      add(query) {
+        state.push(query);
+      },
+      reset() {
+        state = [];
+      },
+      snapshot() {
+        return state.slice();
+      },
+      stop() {
+        this.recorders = this.recorders.filter((x3) => x3 !== recorder);
+        return state;
+      }
+    };
+    this.recorders.push(recorder);
+    return recorder;
+  }
+};
 
 // src/util/js-type.js
 function jsType(type) {
@@ -13788,23 +14069,26 @@ function convertArrowColumn(column2) {
   }
   if (DataType.isInt(type) && type.bitWidth >= 64) {
     const size = column2.length;
-    const array = new Float64Array(size);
+    const array = column2.nullCount ? new Array(size) : new Float64Array(size);
     for (let row = 0; row < size; ++row) {
       const v2 = column2.get(row);
-      array[row] = v2 == null ? NaN : Number(v2);
+      array[row] = v2 == null ? null : Number(v2);
     }
     return array;
   }
   if (DataType.isDecimal(type)) {
     const scale = 1 / Math.pow(10, type.scale);
     const size = column2.length;
-    const array = new Float64Array(size);
+    const array = column2.nullCount ? new Array(size) : new Float64Array(size);
     for (let row = 0; row < size; ++row) {
       const v2 = column2.get(row);
-      array[row] = v2 == null ? NaN : decimalToNumber(v2, scale);
+      array[row] = v2 == null ? null : decimalToNumber(v2, scale);
     }
     return array;
   }
+  if (column2.nullCount) {
+    return Array.from(column2);
+  }
   return column2.toArray();
 }
 var BASE32 = Array.from(
@@ -13911,58 +14195,92 @@ function coordinator(instance16) {
   return _instance;
 }
 var Coordinator = class {
-  constructor(db = socketConnector(), options = {}) {
-    const {
-      logger = console,
-      manager = QueryManager()
-    } = options;
+  constructor(db = socketConnector(), {
+    logger = console,
+    manager = new QueryManager(),
+    cache = true,
+    consolidate: consolidate2 = true,
+    indexes = {}
+  } = {}) {
     this.manager = manager;
+    this.manager.cache(cache);
+    this.manager.consolidate(consolidate2);
+    this.dataCubeIndexer = new DataCubeIndexer(this, indexes);
     this.logger(logger);
-    this.configure(options);
     this.databaseConnector(db);
     this.clear();
   }
-  logger(logger) {
-    if (arguments.length) {
-      this._logger = logger || voidLogger();
-      this.manager.logger(this._logger);
-    }
-    return this._logger;
-  }
   /**
-   * Set configuration options for this coordinator.
-   * @param {object} [options] Configration options.
-   * @param {boolean} [options.cache=true] Boolean flag to enable/disable query caching.
-   * @param {boolean} [options.consolidate=true] Boolean flag to enable/disable query consolidation.
-   * @param {boolean|object} [options.indexes=true] Boolean flag to enable/disable
-   *  automatic data cube indexes or an index options object.
+   * Clear the coordinator state.
+   * @param {object} [options] Options object.
+   * @param {boolean} [options.clients=true] If true, disconnect all clients.
+   * @param {boolean} [options.cache=true] If true, clear the query cache.
    */
-  configure({ cache = true, consolidate: consolidate2 = true, indexes = true } = {}) {
-    this.manager.cache(cache);
-    this.manager.consolidate(consolidate2);
-    this.indexes = indexes;
-  }
   clear({ clients = true, cache = true } = {}) {
     this.manager.clear();
     if (clients) {
+      this.filterGroups?.forEach((group) => group.disconnect());
+      this.filterGroups = /* @__PURE__ */ new Map();
       this.clients?.forEach((client) => this.disconnect(client));
-      this.filterGroups?.forEach((group) => group.finalize());
       this.clients = /* @__PURE__ */ new Set();
-      this.filterGroups = /* @__PURE__ */ new Map();
     }
     if (cache) this.manager.cache().clear();
   }
+  /**
+   * Get or set the database connector.
+   * @param {*} [db] The database connector to use.
+   * @returns The current database connector.
+   */
   databaseConnector(db) {
     return this.manager.connector(db);
   }
+  /**
+   * Get or set the logger.
+   * @param {*} logger  The logger to use.
+   * @returns The current logger
+   */
+  logger(logger) {
+    if (arguments.length) {
+      this._logger = logger || voidLogger();
+      this.manager.logger(this._logger);
+    }
+    return this._logger;
+  }
   // -- Query Management ----
+  /**
+   * Cancel previosuly submitted query requests. These queries will be
+   * canceled if they are queued but have not yet been submitted.
+   * @param {import('./util/query-result.js').QueryResult[]} requests An array
+   *  of query result objects, such as those returned by the `query` method.
+   */
   cancel(requests) {
     this.manager.cancel(requests);
   }
+  /**
+   * Issue a query for which no result (return value) is needed.
+   * @param {import('@uwdata/mosaic-sql').Query | string} query The query.
+   * @param {object} [options] An options object.
+   * @param {number} [options.priority] The query priority, defaults to
+   *  `Priority.Normal`.
+   * @returns {import('./util/query-result.js').QueryResult} A query result
+   *  promise.
+   */
   exec(query, { priority = Priority.Normal } = {}) {
     query = Array.isArray(query) ? query.join(";\n") : query;
     return this.manager.request({ type: "exec", query }, priority);
   }
+  /**
+   * Issue a query to the backing database. The submitted query may be
+   * consolidate with other queries and its results may be cached.
+   * @param {import('@uwdata/mosaic-sql').Query | string} query The query.
+   * @param {object} [options] An options object.
+   * @param {'arrow' | 'json'} [options.type] The query result format type.
+   * @param {boolean} [options.cache=true] If true, cache the query result.
+   * @param {number} [options.priority] The query priority, defaults to
+   *  `Priority.Normal`.
+   * @returns {import('./util/query-result.js').QueryResult} A query result
+   *  promise.
+   */
   query(query, {
     type = "arrow",
     cache = true,
@@ -13971,6 +14289,15 @@ var Coordinator = class {
   } = {}) {
     return this.manager.request({ type, query, cache, options }, priority);
   }
+  /**
+   * Issue a query to prefetch data for later use. The query result is cached
+   * for efficient future access.
+   * @param {import('@uwdata/mosaic-sql').Query | string} query The query.
+   * @param {object} [options] An options object.
+   * @param {'arrow' | 'json'} [options.type] The query result format type.
+   * @returns {import('./util/query-result.js').QueryResult} A query result
+   *  promise.
+   */
   prefetch(query, options = {}) {
     return this.query(query, { ...options, cache: true, priority: Priority.Low });
   }
@@ -13983,26 +14310,44 @@ var Coordinator = class {
     return this.manager.request({ type: "load-bundle", options }, priority);
   }
   // -- Client Management ----
+  /**
+   * Update client data by submitting the given query and returning the
+   * data (or error) to the client.
+   * @param {import('./MosaicClient.js').MosaicClient} client A Mosaic client.
+   * @param {import('@uwdata/mosaic-sql').Query | string} query The data query.
+   * @param {number} [priority] The query priority.
+   * @returns {Promise} A Promise that resolves upon completion of the update.
+   */
   updateClient(client, query, priority = Priority.Normal) {
     client.queryPending();
     return this.query(query, { priority }).then(
       (data) => client.queryResult(data).update(),
       (err) => {
-        client.queryError(err);
         this._logger.error(err);
+        client.queryError(err);
       }
-    );
+    ).catch((err) => this._logger.error(err));
   }
+  /**
+   * Issue a query request for a client. If the query is null or undefined,
+   * the client is simply updated. Otherwise `updateClient` is called. As a
+   * side effect, this method clears the current data cube indexer state.
+   * @param {import('./MosaicClient.js').MosaicClient} client The client
+   *  to update.
+   * @param {import('@uwdata/mosaic-sql').Query | string | null} [query]
+   *  The query to issue.
+   */
   requestQuery(client, query) {
-    this.filterGroups.get(client.filterBy)?.reset();
+    this.dataCubeIndexer.clear();
     return query ? this.updateClient(client, query) : client.update();
   }
   /**
    * Connect a client to the coordinator.
-   * @param {import('./MosaicClient.js').MosaicClient} client the client to disconnect
+   * @param {import('./MosaicClient.js').MosaicClient} client The Mosaic
+   *  client to connect.
    */
   async connect(client) {
-    const { clients, filterGroups, indexes } = this;
+    const { clients } = this;
     if (clients.has(client)) {
       throw new Error("Client already connected.");
     }
@@ -14012,30 +14357,64 @@ var Coordinator = class {
     if (fields?.length) {
       client.fieldInfo(await queryFieldInfo(this, fields));
     }
-    const filter = client.filterBy;
-    if (filter) {
-      if (filterGroups.has(filter)) {
-        filterGroups.get(filter).add(client);
-      } else {
-        const group = new FilterGroup(this, filter, indexes);
-        filterGroups.set(filter, group.add(client));
-      }
-    }
+    connectSelection(this, client.filterBy, client);
     client.requestQuery();
   }
   /**
    * Disconnect a client from the coordinator.
-   *
-   * @param {import('./MosaicClient.js').MosaicClient} client the client to disconnect
+   * @param {import('./MosaicClient.js').MosaicClient} client The Mosaic
+   *  client to disconnect.
    */
   disconnect(client) {
     const { clients, filterGroups } = this;
     if (!clients.has(client)) return;
     clients.delete(client);
-    filterGroups.get(client.filterBy)?.remove(client);
     client.coordinator = null;
+    const group = filterGroups.get(client.filterBy);
+    if (group) {
+      group.clients.delete(client);
+    }
   }
 };
+function connectSelection(mc, selection, client) {
+  if (!selection) return;
+  let entry = mc.filterGroups.get(selection);
+  if (!entry) {
+    const activate = (clause) => activateSelection(mc, selection, clause);
+    const value = () => updateSelection(mc, selection);
+    selection.addEventListener("activate", activate);
+    selection.addEventListener("value", value);
+    entry = {
+      selection,
+      clients: /* @__PURE__ */ new Set(),
+      disconnect() {
+        selection.removeEventListener("activate", activate);
+        selection.removeEventListener("value", value);
+      }
+    };
+    mc.filterGroups.set(selection, entry);
+  }
+  entry.clients.add(client);
+}
+function activateSelection(mc, selection, clause) {
+  const { dataCubeIndexer, filterGroups } = mc;
+  const { clients } = filterGroups.get(selection);
+  for (const client of clients) {
+    dataCubeIndexer.index(client, selection, clause);
+  }
+}
+function updateSelection(mc, selection) {
+  const { dataCubeIndexer, filterGroups } = mc;
+  const { clients } = filterGroups.get(selection);
+  const { active } = selection;
+  return Promise.allSettled(Array.from(clients, (client) => {
+    const info = dataCubeIndexer.index(client, selection, active);
+    const filter = info ? null : selection.predicate(client);
+    if (info?.skip || !info && !filter) return;
+    const query = info?.query(active.predicate) ?? client.query(filter);
+    return mc.updateClient(client, query);
+  }));
+}
 
 // src/util/AsyncDispatch.js
 var AsyncDispatch = class {
@@ -14092,7 +14471,7 @@ var AsyncDispatch = class {
    * queue of unemitted event values prior to enqueueing a new value.
    * This default implementation simply returns null, indicating that
    * any other unemitted event values should be dropped (that is, all
-   * queued events are filtered)
+   * queued events are filtered).
    * @param {string} type The event type.
    * @param {*} value The new event value that will be enqueued.
    * @returns {(value: *) => boolean|null} A dispatch queue filter
@@ -14109,6 +14488,16 @@ var AsyncDispatch = class {
     const entry = this._callbacks.get(type);
     entry?.queue.clear();
   }
+  /**
+   * Returns a promise that resolves when any pending updates complete for
+   * the event of the given type currently being processed. The Promise will
+   * resolve immediately if the queue for the given event type is empty.
+   * @param {string} type The event type to wait for.
+   * @returns {Promise} A pending event promise.
+   */
+  async pending(type) {
+    await this._callbacks.get(type)?.pending;
+  }
   /**
    * Emit an event value to listeners for the given event type.
    * If a previous emit has not yet resolved, the event value
@@ -14296,10 +14685,13 @@ var Selection = class _Selection extends Param {
    * @param {boolean} [options.cross=false] Boolean flag indicating
    *  cross-filtered resolution. If true, selection clauses will not
    *  be applied to the clients they are associated with.
+   * @param {boolean} [options.empty=false] Boolean flag indicating if a lack
+   *  of clauses should correspond to an empty selection with no records. This
+   *  setting determines the default selection state.
    * @returns {Selection} The new Selection instance.
    */
-  static intersect({ cross = false } = {}) {
-    return new _Selection(new SelectionResolver({ cross }));
+  static intersect({ cross = false, empty = false } = {}) {
+    return new _Selection(new SelectionResolver({ cross, empty }));
   }
   /**
    * Create a new Selection instance with a
@@ -14308,10 +14700,13 @@ var Selection = class _Selection extends Param {
    * @param {boolean} [options.cross=false] Boolean flag indicating
    *  cross-filtered resolution. If true, selection clauses will not
    *  be applied to the clients they are associated with.
+   * @param {boolean} [options.empty=false] Boolean flag indicating if a lack
+   *  of clauses should correspond to an empty selection with no records. This
+   *  setting determines the default selection state.
    * @returns {Selection} The new Selection instance.
    */
-  static union({ cross = false } = {}) {
-    return new _Selection(new SelectionResolver({ cross, union: true }));
+  static union({ cross = false, empty = false } = {}) {
+    return new _Selection(new SelectionResolver({ cross, empty, union: true }));
   }
   /**
    * Create a new Selection instance with a singular resolution strategy
@@ -14320,18 +14715,25 @@ var Selection = class _Selection extends Param {
    * @param {boolean} [options.cross=false] Boolean flag indicating
    *  cross-filtered resolution. If true, selection clauses will not
    *  be applied to the clients they are associated with.
+   * @param {boolean} [options.empty=false] Boolean flag indicating if a lack
+   *  of clauses should correspond to an empty selection with no records. This
+   *  setting determines the default selection state.
    * @returns {Selection} The new Selection instance.
    */
-  static single({ cross = false } = {}) {
-    return new _Selection(new SelectionResolver({ cross, single: true }));
+  static single({ cross = false, empty = false } = {}) {
+    return new _Selection(new SelectionResolver({ cross, empty, single: true }));
   }
   /**
    * Create a new Selection instance with a
    * cross-filtered intersect resolution strategy.
+   * @param {object} [options] The selection options.
+   * @param {boolean} [options.empty=false] Boolean flag indicating if a lack
+   *  of clauses should correspond to an empty selection with no records. This
+   *  setting determines the default selection state.
    * @returns {Selection} The new Selection instance.
    */
-  static crossfilter() {
-    return new _Selection(new SelectionResolver({ cross: true }));
+  static crossfilter({ empty = false } = {}) {
+    return new _Selection(new SelectionResolver({ cross: true, empty }));
   }
   /**
    * Create a new Selection instance.
@@ -14364,6 +14766,24 @@ var Selection = class _Selection extends Param {
     s._value.active = { source };
     return s;
   }
+  /**
+   * The selection clause resolver.
+   */
+  get resolver() {
+    return this._resolver;
+  }
+  /**
+   * Indicate if this selection has a single resolution strategy.
+   */
+  get single() {
+    return this._resolver.single;
+  }
+  /**
+   * The current array of selection clauses.
+   */
+  get clauses() {
+    return super.value;
+  }
   /**
    * The current active (most recently updated) selection clause.
    */
@@ -14378,16 +14798,12 @@ var Selection = class _Selection extends Param {
     return this.active?.value;
   }
   /**
-   * The current array of selection clauses.
-   */
-  get clauses() {
-    return super.value;
-  }
-  /**
-   * Indicate if this selection has a single resolution strategy.
+   * The value corresponding to a given source. Returns undefined if
+   * this selection does not include a clause from this source.
+   * @param {*} source The clause source to look up the value for.
    */
-  get single() {
-    return this._resolver.single;
+  valueFor(source) {
+    return this.clauses.find((c) => c.source === source)?.value;
   }
   /**
    * Emit an activate event with the given selection clause.
@@ -14465,11 +14881,15 @@ var SelectionResolver = class {
    *  If false, an intersection strategy is used.
    * @param {boolean} [options.cross=false] Boolean flag to indicate cross-filtering.
    * @param {boolean} [options.single=false] Boolean flag to indicate single clauses only.
+   * @param {boolean} [options.empty=false] Boolean flag indicating if a lack
+   *  of clauses should correspond to an empty selection with no records. This
+   *  setting determines the default selection state.
    */
-  constructor({ union, cross, single } = {}) {
+  constructor({ union, cross, single, empty } = {}) {
     this.union = !!union;
     this.cross = !!cross;
     this.single = !!single;
+    this.empty = !!empty;
   }
   /**
    * Resolve a list of selection clauses according to the resolution strategy.
@@ -14504,7 +14924,10 @@ var SelectionResolver = class {
    *  based on the current state of this selection.
    */
   predicate(clauseList, active, client) {
-    const { union } = this;
+    const { empty, union } = this;
+    if (empty && !clauseList.length) {
+      return ["FALSE"];
+    }
     if (this.skip(client, active)) return void 0;
     const predicates = clauseList.filter((clause) => !this.skip(client, clause)).map((clause) => clause.predicate);
     return union && predicates.length > 1 ? or(predicates) : predicates;
@@ -14527,6 +14950,13 @@ var SelectionResolver = class {
 // src/connectors/rest.js
 function restConnector(uri = "http://localhost:3000/") {
   return {
+    /**
+     * Query the DuckDB server.
+     * @param {object} query
+     * @param {'exec' | 'arrow' | 'json'} [query.type] The query type: 'exec', 'arrow', or 'json'.
+     * @param {string} query.sql A SQL query string.
+     * @returns the query result
+     */
     async query(query) {
       const req = fetch(uri, {
         method: "POST",
@@ -15168,7 +15598,7 @@ var BufferType2;
 // ../../node_modules/@duckdb/duckdb-wasm/node_modules/apache-arrow/util/vector.mjs
 var vector_exports2 = {};
 __export(vector_exports2, {
-  clampIndex: () => clampIndex2,
+  clampIndex: () => clampIndex,
   clampRange: () => clampRange2,
   createElementComparator: () => createElementComparator2
 });
@@ -16467,15 +16897,15 @@ function wrapSet2(fn) {
 var setEpochMsToDays2 = (data, index, epochMs) => {
   data[index] = Math.trunc(epochMs / 864e5);
 };
-var setEpochMsToMillisecondsLong2 = (data, index, epochMs) => {
+var setEpochMsToMillisecondsLong = (data, index, epochMs) => {
   data[index] = Math.trunc(epochMs % 4294967296);
   data[index + 1] = Math.trunc(epochMs / 4294967296);
 };
-var setEpochMsToMicrosecondsLong2 = (data, index, epochMs) => {
+var setEpochMsToMicrosecondsLong = (data, index, epochMs) => {
   data[index] = Math.trunc(epochMs * 1e3 % 4294967296);
   data[index + 1] = Math.trunc(epochMs * 1e3 / 4294967296);
 };
-var setEpochMsToNanosecondsLong2 = (data, index, epochMs) => {
+var setEpochMsToNanosecondsLong = (data, index, epochMs) => {
   data[index] = Math.trunc(epochMs * 1e6 % 4294967296);
   data[index + 1] = Math.trunc(epochMs * 1e6 / 4294967296);
 };
@@ -16511,7 +16941,7 @@ var setDateDay2 = ({ values }, index, value) => {
   setEpochMsToDays2(values, index, value.valueOf());
 };
 var setDateMillisecond2 = ({ values }, index, value) => {
-  setEpochMsToMillisecondsLong2(values, index * 2, value.valueOf());
+  setEpochMsToMillisecondsLong(values, index * 2, value.valueOf());
 };
 var setFixedSizeBinary2 = ({ stride, values }, index, value) => {
   values.set(value.subarray(0, stride), stride * index);
@@ -16523,10 +16953,10 @@ var setUtf82 = ({ values, valueOffsets }, index, value) => {
 var setDate2 = (data, index, value) => {
   data.type.unit === DateUnit2.DAY ? setDateDay2(data, index, value) : setDateMillisecond2(data, index, value);
 };
-var setTimestampSecond2 = ({ values }, index, value) => setEpochMsToMillisecondsLong2(values, index * 2, value / 1e3);
-var setTimestampMillisecond2 = ({ values }, index, value) => setEpochMsToMillisecondsLong2(values, index * 2, value);
-var setTimestampMicrosecond2 = ({ values }, index, value) => setEpochMsToMicrosecondsLong2(values, index * 2, value);
-var setTimestampNanosecond2 = ({ values }, index, value) => setEpochMsToNanosecondsLong2(values, index * 2, value);
+var setTimestampSecond2 = ({ values }, index, value) => setEpochMsToMillisecondsLong(values, index * 2, value / 1e3);
+var setTimestampMillisecond2 = ({ values }, index, value) => setEpochMsToMillisecondsLong(values, index * 2, value);
+var setTimestampMicrosecond2 = ({ values }, index, value) => setEpochMsToMicrosecondsLong(values, index * 2, value);
+var setTimestampNanosecond2 = ({ values }, index, value) => setEpochMsToNanosecondsLong(values, index * 2, value);
 var setTimestamp2 = (data, index, value) => {
   switch (data.type.unit) {
     case TimeUnit2.SECOND:
@@ -16829,12 +17259,12 @@ function wrapGet2(fn) {
   return (data, _1) => data.getValid(_1) ? fn(data, _1) : null;
 }
 var epochDaysToMs2 = (data, index) => 864e5 * data[index];
-var epochMillisecondsLongToMs2 = (data, index) => 4294967296 * data[index + 1] + (data[index] >>> 0);
-var epochMicrosecondsLongToMs2 = (data, index) => 4294967296 * (data[index + 1] / 1e3) + (data[index] >>> 0) / 1e3;
-var epochNanosecondsLongToMs2 = (data, index) => 4294967296 * (data[index + 1] / 1e6) + (data[index] >>> 0) / 1e6;
-var epochMillisecondsToDate2 = (epochMs) => new Date(epochMs);
-var epochDaysToDate2 = (data, index) => epochMillisecondsToDate2(epochDaysToMs2(data, index));
-var epochMillisecondsLongToDate2 = (data, index) => epochMillisecondsToDate2(epochMillisecondsLongToMs2(data, index));
+var epochMillisecondsLongToMs = (data, index) => 4294967296 * data[index + 1] + (data[index] >>> 0);
+var epochMicrosecondsLongToMs = (data, index) => 4294967296 * (data[index + 1] / 1e3) + (data[index] >>> 0) / 1e3;
+var epochNanosecondsLongToMs = (data, index) => 4294967296 * (data[index + 1] / 1e6) + (data[index] >>> 0) / 1e6;
+var epochMillisecondsToDate = (epochMs) => new Date(epochMs);
+var epochDaysToDate = (data, index) => epochMillisecondsToDate(epochDaysToMs2(data, index));
+var epochMillisecondsLongToDate = (data, index) => epochMillisecondsToDate(epochMillisecondsLongToMs(data, index));
 var getNull2 = (_data, _index) => null;
 var getVariableWidthBytes2 = (values, valueOffsets, index) => {
   if (index + 1 >= valueOffsets.length) {
@@ -16849,8 +17279,8 @@ var getBool3 = ({ offset, values }, index) => {
   const byte = values[idx >> 3];
   return (byte & 1 << idx % 8) !== 0;
 };
-var getDateDay2 = ({ values }, index) => epochDaysToDate2(values, index);
-var getDateMillisecond2 = ({ values }, index) => epochMillisecondsLongToDate2(values, index * 2);
+var getDateDay2 = ({ values }, index) => epochDaysToDate(values, index);
+var getDateMillisecond2 = ({ values }, index) => epochMillisecondsLongToDate(values, index * 2);
 var getNumeric2 = ({ stride, values }, index) => values[stride * index];
 var getFloat162 = ({ stride, values }, index) => uint16ToFloat642(values[stride * index]);
 var getBigInts2 = ({ values }, index) => values[index];
@@ -16863,10 +17293,10 @@ var getUtf82 = ({ values, valueOffsets }, index) => {
 var getInt2 = ({ values }, index) => values[index];
 var getFloat2 = ({ type, values }, index) => type.precision !== Precision2.HALF ? values[index] : uint16ToFloat642(values[index]);
 var getDate2 = (data, index) => data.type.unit === DateUnit2.DAY ? getDateDay2(data, index) : getDateMillisecond2(data, index);
-var getTimestampSecond2 = ({ values }, index) => 1e3 * epochMillisecondsLongToMs2(values, index * 2);
-var getTimestampMillisecond2 = ({ values }, index) => epochMillisecondsLongToMs2(values, index * 2);
-var getTimestampMicrosecond2 = ({ values }, index) => epochMicrosecondsLongToMs2(values, index * 2);
-var getTimestampNanosecond2 = ({ values }, index) => epochNanosecondsLongToMs2(values, index * 2);
+var getTimestampSecond2 = ({ values }, index) => 1e3 * epochMillisecondsLongToMs(values, index * 2);
+var getTimestampMillisecond2 = ({ values }, index) => epochMillisecondsLongToMs(values, index * 2);
+var getTimestampMicrosecond2 = ({ values }, index) => epochMicrosecondsLongToMs(values, index * 2);
+var getTimestampNanosecond2 = ({ values }, index) => epochNanosecondsLongToMs(values, index * 2);
 var getTimestamp2 = (data, index) => {
   switch (data.type.unit) {
     case TimeUnit2.SECOND:
@@ -17121,7 +17551,7 @@ Object.defineProperties(MapRow2.prototype, {
 });
 
 // ../../node_modules/@duckdb/duckdb-wasm/node_modules/apache-arrow/util/vector.mjs
-function clampIndex2(source, index, then) {
+function clampIndex(source, index, then) {
   const length2 = source.length;
   const adjust = index > -1 ? index : length2 + index % length2;
   return then ? then(source, adjust) : adjust;
@@ -18721,133 +19151,880 @@ var Builder5 = class {
     });
   }
   /**
-   * Finalize this `Builder`, and child builders if applicable.
-   * @returns {this} The finalized `Builder` instance.
+   * Finalize this `Builder`, and child builders if applicable.
+   * @returns {this} The finalized `Builder` instance.
+   */
+  finish() {
+    this.finished = true;
+    for (const child of this.children)
+      child.finish();
+    return this;
+  }
+  /**
+   * Clear this Builder's internal state, including child Builders if applicable, and reset the length to 0.
+   * @returns {this} The cleared `Builder` instance.
+   */
+  clear() {
+    var _a9, _b3, _c3, _d3;
+    this.length = 0;
+    (_a9 = this._nulls) === null || _a9 === void 0 ? void 0 : _a9.clear();
+    (_b3 = this._values) === null || _b3 === void 0 ? void 0 : _b3.clear();
+    (_c3 = this._offsets) === null || _c3 === void 0 ? void 0 : _c3.clear();
+    (_d3 = this._typeIds) === null || _d3 === void 0 ? void 0 : _d3.clear();
+    for (const child of this.children)
+      child.clear();
+    return this;
+  }
+};
+Builder5.prototype.length = 1;
+Builder5.prototype.stride = 1;
+Builder5.prototype.children = null;
+Builder5.prototype.finished = false;
+Builder5.prototype.nullValues = null;
+Builder5.prototype._isValid = () => true;
+var FixedWidthBuilder2 = class extends Builder5 {
+  constructor(opts) {
+    super(opts);
+    this._values = new DataBufferBuilder2(new this.ArrayType(0), this.stride);
+  }
+  setValue(index, value) {
+    const values = this._values;
+    values.reserve(index - values.length + 1);
+    return super.setValue(index, value);
+  }
+};
+var VariableWidthBuilder2 = class extends Builder5 {
+  constructor(opts) {
+    super(opts);
+    this._pendingLength = 0;
+    this._offsets = new OffsetsBufferBuilder2();
+  }
+  setValue(index, value) {
+    const pending = this._pending || (this._pending = /* @__PURE__ */ new Map());
+    const current = pending.get(index);
+    current && (this._pendingLength -= current.length);
+    this._pendingLength += value instanceof MapRow2 ? value[kKeys2].length : value.length;
+    pending.set(index, value);
+  }
+  setValid(index, isValid) {
+    if (!super.setValid(index, isValid)) {
+      (this._pending || (this._pending = /* @__PURE__ */ new Map())).set(index, void 0);
+      return false;
+    }
+    return true;
+  }
+  clear() {
+    this._pendingLength = 0;
+    this._pending = void 0;
+    return super.clear();
+  }
+  flush() {
+    this._flush();
+    return super.flush();
+  }
+  finish() {
+    this._flush();
+    return super.finish();
+  }
+  _flush() {
+    const pending = this._pending;
+    const pendingLength = this._pendingLength;
+    this._pendingLength = 0;
+    this._pending = void 0;
+    if (pending && pending.size > 0) {
+      this._flushPending(pending, pendingLength);
+    }
+    return this;
+  }
+};
+
+// ../../node_modules/@duckdb/duckdb-wasm/node_modules/apache-arrow/fb/block.mjs
+var Block2 = class {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i, bb) {
+    this.bb_pos = i;
+    this.bb = bb;
+    return this;
+  }
+  /**
+   * Index to the start of the RecordBlock (note this is past the Message header)
+   */
+  offset() {
+    return this.bb.readInt64(this.bb_pos);
+  }
+  /**
+   * Length of the metadata
+   */
+  metaDataLength() {
+    return this.bb.readInt32(this.bb_pos + 8);
+  }
+  /**
+   * Length of the data (this is aligned so there can be a gap between this and
+   * the metadata).
+   */
+  bodyLength() {
+    return this.bb.readInt64(this.bb_pos + 16);
+  }
+  static sizeOf() {
+    return 24;
+  }
+  static createBlock(builder, offset, metaDataLength, bodyLength) {
+    builder.prep(8, 24);
+    builder.writeInt64(BigInt(bodyLength !== null && bodyLength !== void 0 ? bodyLength : 0));
+    builder.pad(4);
+    builder.writeInt32(metaDataLength);
+    builder.writeInt64(BigInt(offset !== null && offset !== void 0 ? offset : 0));
+    return builder.offset();
+  }
+};
+
+// ../../node_modules/flatbuffers/mjs/constants.js
+var SIZEOF_SHORT2 = 2;
+var SIZEOF_INT2 = 4;
+var FILE_IDENTIFIER_LENGTH2 = 4;
+var SIZE_PREFIX_LENGTH2 = 4;
+
+// ../../node_modules/flatbuffers/mjs/utils.js
+var int322 = new Int32Array(2);
+var float322 = new Float32Array(int322.buffer);
+var float642 = new Float64Array(int322.buffer);
+var isLittleEndian2 = new Uint16Array(new Uint8Array([1, 0]).buffer)[0] === 1;
+
+// ../../node_modules/flatbuffers/mjs/encoding.js
+var Encoding2;
+(function(Encoding3) {
+  Encoding3[Encoding3["UTF8_BYTES"] = 1] = "UTF8_BYTES";
+  Encoding3[Encoding3["UTF16_STRING"] = 2] = "UTF16_STRING";
+})(Encoding2 || (Encoding2 = {}));
+
+// ../../node_modules/flatbuffers/mjs/byte-buffer.js
+var ByteBuffer4 = class _ByteBuffer {
+  /**
+   * Create a new ByteBuffer with a given array of bytes (`Uint8Array`)
+   */
+  constructor(bytes_) {
+    this.bytes_ = bytes_;
+    this.position_ = 0;
+    this.text_decoder_ = new TextDecoder();
+  }
+  /**
+   * Create and allocate a new ByteBuffer with a given size.
+   */
+  static allocate(byte_size) {
+    return new _ByteBuffer(new Uint8Array(byte_size));
+  }
+  clear() {
+    this.position_ = 0;
+  }
+  /**
+   * Get the underlying `Uint8Array`.
+   */
+  bytes() {
+    return this.bytes_;
+  }
+  /**
+   * Get the buffer's position.
+   */
+  position() {
+    return this.position_;
+  }
+  /**
+   * Set the buffer's position.
+   */
+  setPosition(position) {
+    this.position_ = position;
+  }
+  /**
+   * Get the buffer's capacity.
+   */
+  capacity() {
+    return this.bytes_.length;
+  }
+  readInt8(offset) {
+    return this.readUint8(offset) << 24 >> 24;
+  }
+  readUint8(offset) {
+    return this.bytes_[offset];
+  }
+  readInt16(offset) {
+    return this.readUint16(offset) << 16 >> 16;
+  }
+  readUint16(offset) {
+    return this.bytes_[offset] | this.bytes_[offset + 1] << 8;
+  }
+  readInt32(offset) {
+    return this.bytes_[offset] | this.bytes_[offset + 1] << 8 | this.bytes_[offset + 2] << 16 | this.bytes_[offset + 3] << 24;
+  }
+  readUint32(offset) {
+    return this.readInt32(offset) >>> 0;
+  }
+  readInt64(offset) {
+    return BigInt.asIntN(64, BigInt(this.readUint32(offset)) + (BigInt(this.readUint32(offset + 4)) << BigInt(32)));
+  }
+  readUint64(offset) {
+    return BigInt.asUintN(64, BigInt(this.readUint32(offset)) + (BigInt(this.readUint32(offset + 4)) << BigInt(32)));
+  }
+  readFloat32(offset) {
+    int322[0] = this.readInt32(offset);
+    return float322[0];
+  }
+  readFloat64(offset) {
+    int322[isLittleEndian2 ? 0 : 1] = this.readInt32(offset);
+    int322[isLittleEndian2 ? 1 : 0] = this.readInt32(offset + 4);
+    return float642[0];
+  }
+  writeInt8(offset, value) {
+    this.bytes_[offset] = value;
+  }
+  writeUint8(offset, value) {
+    this.bytes_[offset] = value;
+  }
+  writeInt16(offset, value) {
+    this.bytes_[offset] = value;
+    this.bytes_[offset + 1] = value >> 8;
+  }
+  writeUint16(offset, value) {
+    this.bytes_[offset] = value;
+    this.bytes_[offset + 1] = value >> 8;
+  }
+  writeInt32(offset, value) {
+    this.bytes_[offset] = value;
+    this.bytes_[offset + 1] = value >> 8;
+    this.bytes_[offset + 2] = value >> 16;
+    this.bytes_[offset + 3] = value >> 24;
+  }
+  writeUint32(offset, value) {
+    this.bytes_[offset] = value;
+    this.bytes_[offset + 1] = value >> 8;
+    this.bytes_[offset + 2] = value >> 16;
+    this.bytes_[offset + 3] = value >> 24;
+  }
+  writeInt64(offset, value) {
+    this.writeInt32(offset, Number(BigInt.asIntN(32, value)));
+    this.writeInt32(offset + 4, Number(BigInt.asIntN(32, value >> BigInt(32))));
+  }
+  writeUint64(offset, value) {
+    this.writeUint32(offset, Number(BigInt.asUintN(32, value)));
+    this.writeUint32(offset + 4, Number(BigInt.asUintN(32, value >> BigInt(32))));
+  }
+  writeFloat32(offset, value) {
+    float322[0] = value;
+    this.writeInt32(offset, int322[0]);
+  }
+  writeFloat64(offset, value) {
+    float642[0] = value;
+    this.writeInt32(offset, int322[isLittleEndian2 ? 0 : 1]);
+    this.writeInt32(offset + 4, int322[isLittleEndian2 ? 1 : 0]);
+  }
+  /**
+   * Return the file identifier.   Behavior is undefined for FlatBuffers whose
+   * schema does not include a file_identifier (likely points at padding or the
+   * start of a the root vtable).
+   */
+  getBufferIdentifier() {
+    if (this.bytes_.length < this.position_ + SIZEOF_INT2 + FILE_IDENTIFIER_LENGTH2) {
+      throw new Error("FlatBuffers: ByteBuffer is too short to contain an identifier.");
+    }
+    let result = "";
+    for (let i = 0; i < FILE_IDENTIFIER_LENGTH2; i++) {
+      result += String.fromCharCode(this.readInt8(this.position_ + SIZEOF_INT2 + i));
+    }
+    return result;
+  }
+  /**
+   * Look up a field in the vtable, return an offset into the object, or 0 if the
+   * field is not present.
+   */
+  __offset(bb_pos, vtable_offset) {
+    const vtable = bb_pos - this.readInt32(bb_pos);
+    return vtable_offset < this.readInt16(vtable) ? this.readInt16(vtable + vtable_offset) : 0;
+  }
+  /**
+   * Initialize any Table-derived type to point to the union at the given offset.
+   */
+  __union(t, offset) {
+    t.bb_pos = offset + this.readInt32(offset);
+    t.bb = this;
+    return t;
+  }
+  /**
+   * Create a JavaScript string from UTF-8 data stored inside the FlatBuffer.
+   * This allocates a new string and converts to wide chars upon each access.
+   *
+   * To avoid the conversion to string, pass Encoding.UTF8_BYTES as the
+   * "optionalEncoding" argument. This is useful for avoiding conversion when
+   * the data will just be packaged back up in another FlatBuffer later on.
+   *
+   * @param offset
+   * @param opt_encoding Defaults to UTF16_STRING
+   */
+  __string(offset, opt_encoding) {
+    offset += this.readInt32(offset);
+    const length2 = this.readInt32(offset);
+    offset += SIZEOF_INT2;
+    const utf8bytes = this.bytes_.subarray(offset, offset + length2);
+    if (opt_encoding === Encoding2.UTF8_BYTES)
+      return utf8bytes;
+    else
+      return this.text_decoder_.decode(utf8bytes);
+  }
+  /**
+   * Handle unions that can contain string as its member, if a Table-derived type then initialize it,
+   * if a string then return a new one
+   *
+   * WARNING: strings are immutable in JS so we can't change the string that the user gave us, this
+   * makes the behaviour of __union_with_string different compared to __union
+   */
+  __union_with_string(o, offset) {
+    if (typeof o === "string") {
+      return this.__string(offset);
+    }
+    return this.__union(o, offset);
+  }
+  /**
+   * Retrieve the relative offset stored at "offset"
+   */
+  __indirect(offset) {
+    return offset + this.readInt32(offset);
+  }
+  /**
+   * Get the start of data of a vector whose offset is stored at "offset" in this object.
+   */
+  __vector(offset) {
+    return offset + this.readInt32(offset) + SIZEOF_INT2;
+  }
+  /**
+   * Get the length of a vector whose offset is stored at "offset" in this object.
+   */
+  __vector_len(offset) {
+    return this.readInt32(offset + this.readInt32(offset));
+  }
+  __has_identifier(ident) {
+    if (ident.length != FILE_IDENTIFIER_LENGTH2) {
+      throw new Error("FlatBuffers: file identifier must be length " + FILE_IDENTIFIER_LENGTH2);
+    }
+    for (let i = 0; i < FILE_IDENTIFIER_LENGTH2; i++) {
+      if (ident.charCodeAt(i) != this.readInt8(this.position() + SIZEOF_INT2 + i)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * A helper function for generating list for obj api
+   */
+  createScalarList(listAccessor, listLength) {
+    const ret = [];
+    for (let i = 0; i < listLength; ++i) {
+      const val = listAccessor(i);
+      if (val !== null) {
+        ret.push(val);
+      }
+    }
+    return ret;
+  }
+  /**
+   * A helper function for generating list for obj api
+   * @param listAccessor function that accepts an index and return data at that index
+   * @param listLength listLength
+   * @param res result list
+   */
+  createObjList(listAccessor, listLength) {
+    const ret = [];
+    for (let i = 0; i < listLength; ++i) {
+      const val = listAccessor(i);
+      if (val !== null) {
+        ret.push(val.unpack());
+      }
+    }
+    return ret;
+  }
+};
+
+// ../../node_modules/flatbuffers/mjs/builder.js
+var Builder6 = class _Builder {
+  /**
+   * Create a FlatBufferBuilder.
+   */
+  constructor(opt_initial_size) {
+    this.minalign = 1;
+    this.vtable = null;
+    this.vtable_in_use = 0;
+    this.isNested = false;
+    this.object_start = 0;
+    this.vtables = [];
+    this.vector_num_elems = 0;
+    this.force_defaults = false;
+    this.string_maps = null;
+    this.text_encoder = new TextEncoder();
+    let initial_size;
+    if (!opt_initial_size) {
+      initial_size = 1024;
+    } else {
+      initial_size = opt_initial_size;
+    }
+    this.bb = ByteBuffer4.allocate(initial_size);
+    this.space = initial_size;
+  }
+  clear() {
+    this.bb.clear();
+    this.space = this.bb.capacity();
+    this.minalign = 1;
+    this.vtable = null;
+    this.vtable_in_use = 0;
+    this.isNested = false;
+    this.object_start = 0;
+    this.vtables = [];
+    this.vector_num_elems = 0;
+    this.force_defaults = false;
+    this.string_maps = null;
+  }
+  /**
+   * In order to save space, fields that are set to their default value
+   * don't get serialized into the buffer. Forcing defaults provides a
+   * way to manually disable this optimization.
+   *
+   * @param forceDefaults true always serializes default values
+   */
+  forceDefaults(forceDefaults) {
+    this.force_defaults = forceDefaults;
+  }
+  /**
+   * Get the ByteBuffer representing the FlatBuffer. Only call this after you've
+   * called finish(). The actual data starts at the ByteBuffer's current position,
+   * not necessarily at 0.
+   */
+  dataBuffer() {
+    return this.bb;
+  }
+  /**
+   * Get the bytes representing the FlatBuffer. Only call this after you've
+   * called finish().
+   */
+  asUint8Array() {
+    return this.bb.bytes().subarray(this.bb.position(), this.bb.position() + this.offset());
+  }
+  /**
+   * Prepare to write an element of `size` after `additional_bytes` have been
+   * written, e.g. if you write a string, you need to align such the int length
+   * field is aligned to 4 bytes, and the string data follows it directly. If all
+   * you need to do is alignment, `additional_bytes` will be 0.
+   *
+   * @param size This is the of the new element to write
+   * @param additional_bytes The padding size
+   */
+  prep(size, additional_bytes) {
+    if (size > this.minalign) {
+      this.minalign = size;
+    }
+    const align_size = ~(this.bb.capacity() - this.space + additional_bytes) + 1 & size - 1;
+    while (this.space < align_size + size + additional_bytes) {
+      const old_buf_size = this.bb.capacity();
+      this.bb = _Builder.growByteBuffer(this.bb);
+      this.space += this.bb.capacity() - old_buf_size;
+    }
+    this.pad(align_size);
+  }
+  pad(byte_size) {
+    for (let i = 0; i < byte_size; i++) {
+      this.bb.writeInt8(--this.space, 0);
+    }
+  }
+  writeInt8(value) {
+    this.bb.writeInt8(this.space -= 1, value);
+  }
+  writeInt16(value) {
+    this.bb.writeInt16(this.space -= 2, value);
+  }
+  writeInt32(value) {
+    this.bb.writeInt32(this.space -= 4, value);
+  }
+  writeInt64(value) {
+    this.bb.writeInt64(this.space -= 8, value);
+  }
+  writeFloat32(value) {
+    this.bb.writeFloat32(this.space -= 4, value);
+  }
+  writeFloat64(value) {
+    this.bb.writeFloat64(this.space -= 8, value);
+  }
+  /**
+   * Add an `int8` to the buffer, properly aligned, and grows the buffer (if necessary).
+   * @param value The `int8` to add the buffer.
+   */
+  addInt8(value) {
+    this.prep(1, 0);
+    this.writeInt8(value);
+  }
+  /**
+   * Add an `int16` to the buffer, properly aligned, and grows the buffer (if necessary).
+   * @param value The `int16` to add the buffer.
+   */
+  addInt16(value) {
+    this.prep(2, 0);
+    this.writeInt16(value);
+  }
+  /**
+   * Add an `int32` to the buffer, properly aligned, and grows the buffer (if necessary).
+   * @param value The `int32` to add the buffer.
+   */
+  addInt32(value) {
+    this.prep(4, 0);
+    this.writeInt32(value);
+  }
+  /**
+   * Add an `int64` to the buffer, properly aligned, and grows the buffer (if necessary).
+   * @param value The `int64` to add the buffer.
+   */
+  addInt64(value) {
+    this.prep(8, 0);
+    this.writeInt64(value);
+  }
+  /**
+   * Add a `float32` to the buffer, properly aligned, and grows the buffer (if necessary).
+   * @param value The `float32` to add the buffer.
+   */
+  addFloat32(value) {
+    this.prep(4, 0);
+    this.writeFloat32(value);
+  }
+  /**
+   * Add a `float64` to the buffer, properly aligned, and grows the buffer (if necessary).
+   * @param value The `float64` to add the buffer.
+   */
+  addFloat64(value) {
+    this.prep(8, 0);
+    this.writeFloat64(value);
+  }
+  addFieldInt8(voffset, value, defaultValue) {
+    if (this.force_defaults || value != defaultValue) {
+      this.addInt8(value);
+      this.slot(voffset);
+    }
+  }
+  addFieldInt16(voffset, value, defaultValue) {
+    if (this.force_defaults || value != defaultValue) {
+      this.addInt16(value);
+      this.slot(voffset);
+    }
+  }
+  addFieldInt32(voffset, value, defaultValue) {
+    if (this.force_defaults || value != defaultValue) {
+      this.addInt32(value);
+      this.slot(voffset);
+    }
+  }
+  addFieldInt64(voffset, value, defaultValue) {
+    if (this.force_defaults || value !== defaultValue) {
+      this.addInt64(value);
+      this.slot(voffset);
+    }
+  }
+  addFieldFloat32(voffset, value, defaultValue) {
+    if (this.force_defaults || value != defaultValue) {
+      this.addFloat32(value);
+      this.slot(voffset);
+    }
+  }
+  addFieldFloat64(voffset, value, defaultValue) {
+    if (this.force_defaults || value != defaultValue) {
+      this.addFloat64(value);
+      this.slot(voffset);
+    }
+  }
+  addFieldOffset(voffset, value, defaultValue) {
+    if (this.force_defaults || value != defaultValue) {
+      this.addOffset(value);
+      this.slot(voffset);
+    }
+  }
+  /**
+   * Structs are stored inline, so nothing additional is being added. `d` is always 0.
+   */
+  addFieldStruct(voffset, value, defaultValue) {
+    if (value != defaultValue) {
+      this.nested(value);
+      this.slot(voffset);
+    }
+  }
+  /**
+   * Structures are always stored inline, they need to be created right
+   * where they're used.  You'll get this assertion failure if you
+   * created it elsewhere.
+   */
+  nested(obj) {
+    if (obj != this.offset()) {
+      throw new TypeError("FlatBuffers: struct must be serialized inline.");
+    }
+  }
+  /**
+   * Should not be creating any other object, string or vector
+   * while an object is being constructed
+   */
+  notNested() {
+    if (this.isNested) {
+      throw new TypeError("FlatBuffers: object serialization must not be nested.");
+    }
+  }
+  /**
+   * Set the current vtable at `voffset` to the current location in the buffer.
+   */
+  slot(voffset) {
+    if (this.vtable !== null)
+      this.vtable[voffset] = this.offset();
+  }
+  /**
+   * @returns Offset relative to the end of the buffer.
+   */
+  offset() {
+    return this.bb.capacity() - this.space;
+  }
+  /**
+   * Doubles the size of the backing ByteBuffer and copies the old data towards
+   * the end of the new buffer (since we build the buffer backwards).
+   *
+   * @param bb The current buffer with the existing data
+   * @returns A new byte buffer with the old data copied
+   * to it. The data is located at the end of the buffer.
+   *
+   * uint8Array.set() formally takes {Array<number>|ArrayBufferView}, so to pass
+   * it a uint8Array we need to suppress the type check:
+   * @suppress {checkTypes}
+   */
+  static growByteBuffer(bb) {
+    const old_buf_size = bb.capacity();
+    if (old_buf_size & 3221225472) {
+      throw new Error("FlatBuffers: cannot grow buffer beyond 2 gigabytes.");
+    }
+    const new_buf_size = old_buf_size << 1;
+    const nbb = ByteBuffer4.allocate(new_buf_size);
+    nbb.setPosition(new_buf_size - old_buf_size);
+    nbb.bytes().set(bb.bytes(), new_buf_size - old_buf_size);
+    return nbb;
+  }
+  /**
+   * Adds on offset, relative to where it will be written.
+   *
+   * @param offset The offset to add.
+   */
+  addOffset(offset) {
+    this.prep(SIZEOF_INT2, 0);
+    this.writeInt32(this.offset() - offset + SIZEOF_INT2);
+  }
+  /**
+   * Start encoding a new object in the buffer.  Users will not usually need to
+   * call this directly. The FlatBuffers compiler will generate helper methods
+   * that call this method internally.
+   */
+  startObject(numfields) {
+    this.notNested();
+    if (this.vtable == null) {
+      this.vtable = [];
+    }
+    this.vtable_in_use = numfields;
+    for (let i = 0; i < numfields; i++) {
+      this.vtable[i] = 0;
+    }
+    this.isNested = true;
+    this.object_start = this.offset();
+  }
+  /**
+   * Finish off writing the object that is under construction.
+   *
+   * @returns The offset to the object inside `dataBuffer`
+   */
+  endObject() {
+    if (this.vtable == null || !this.isNested) {
+      throw new Error("FlatBuffers: endObject called without startObject");
+    }
+    this.addInt32(0);
+    const vtableloc = this.offset();
+    let i = this.vtable_in_use - 1;
+    for (; i >= 0 && this.vtable[i] == 0; i--) {
+    }
+    const trimmed_size = i + 1;
+    for (; i >= 0; i--) {
+      this.addInt16(this.vtable[i] != 0 ? vtableloc - this.vtable[i] : 0);
+    }
+    const standard_fields = 2;
+    this.addInt16(vtableloc - this.object_start);
+    const len = (trimmed_size + standard_fields) * SIZEOF_SHORT2;
+    this.addInt16(len);
+    let existing_vtable = 0;
+    const vt1 = this.space;
+    outer_loop: for (i = 0; i < this.vtables.length; i++) {
+      const vt2 = this.bb.capacity() - this.vtables[i];
+      if (len == this.bb.readInt16(vt2)) {
+        for (let j2 = SIZEOF_SHORT2; j2 < len; j2 += SIZEOF_SHORT2) {
+          if (this.bb.readInt16(vt1 + j2) != this.bb.readInt16(vt2 + j2)) {
+            continue outer_loop;
+          }
+        }
+        existing_vtable = this.vtables[i];
+        break;
+      }
+    }
+    if (existing_vtable) {
+      this.space = this.bb.capacity() - vtableloc;
+      this.bb.writeInt32(this.space, existing_vtable - vtableloc);
+    } else {
+      this.vtables.push(this.offset());
+      this.bb.writeInt32(this.bb.capacity() - vtableloc, this.offset() - vtableloc);
+    }
+    this.isNested = false;
+    return vtableloc;
+  }
+  /**
+   * Finalize a buffer, poiting to the given `root_table`.
+   */
+  finish(root_table, opt_file_identifier, opt_size_prefix) {
+    const size_prefix = opt_size_prefix ? SIZE_PREFIX_LENGTH2 : 0;
+    if (opt_file_identifier) {
+      const file_identifier = opt_file_identifier;
+      this.prep(this.minalign, SIZEOF_INT2 + FILE_IDENTIFIER_LENGTH2 + size_prefix);
+      if (file_identifier.length != FILE_IDENTIFIER_LENGTH2) {
+        throw new TypeError("FlatBuffers: file identifier must be length " + FILE_IDENTIFIER_LENGTH2);
+      }
+      for (let i = FILE_IDENTIFIER_LENGTH2 - 1; i >= 0; i--) {
+        this.writeInt8(file_identifier.charCodeAt(i));
+      }
+    }
+    this.prep(this.minalign, SIZEOF_INT2 + size_prefix);
+    this.addOffset(root_table);
+    if (size_prefix) {
+      this.addInt32(this.bb.capacity() - this.space);
+    }
+    this.bb.setPosition(this.space);
+  }
+  /**
+   * Finalize a size prefixed buffer, pointing to the given `root_table`.
+   */
+  finishSizePrefixed(root_table, opt_file_identifier) {
+    this.finish(root_table, opt_file_identifier, true);
+  }
+  /**
+   * This checks a required field has been set in a given table that has
+   * just been constructed.
+   */
+  requiredField(table, field) {
+    const table_start = this.bb.capacity() - table;
+    const vtable_start = table_start - this.bb.readInt32(table_start);
+    const ok = field < this.bb.readInt16(vtable_start) && this.bb.readInt16(vtable_start + field) != 0;
+    if (!ok) {
+      throw new TypeError("FlatBuffers: field " + field + " must be set");
+    }
+  }
+  /**
+   * Start a new array/vector of objects.  Users usually will not call
+   * this directly. The FlatBuffers compiler will create a start/end
+   * method for vector types in generated code.
+   *
+   * @param elem_size The size of each element in the array
+   * @param num_elems The number of elements in the array
+   * @param alignment The alignment of the array
    */
-  finish() {
-    this.finished = true;
-    for (const child of this.children)
-      child.finish();
-    return this;
+  startVector(elem_size, num_elems, alignment) {
+    this.notNested();
+    this.vector_num_elems = num_elems;
+    this.prep(SIZEOF_INT2, elem_size * num_elems);
+    this.prep(alignment, elem_size * num_elems);
   }
   /**
-   * Clear this Builder's internal state, including child Builders if applicable, and reset the length to 0.
-   * @returns {this} The cleared `Builder` instance.
+   * Finish off the creation of an array and all its elements. The array must be
+   * created with `startVector`.
+   *
+   * @returns The offset at which the newly created array
+   * starts.
    */
-  clear() {
-    var _a9, _b3, _c3, _d3;
-    this.length = 0;
-    (_a9 = this._nulls) === null || _a9 === void 0 ? void 0 : _a9.clear();
-    (_b3 = this._values) === null || _b3 === void 0 ? void 0 : _b3.clear();
-    (_c3 = this._offsets) === null || _c3 === void 0 ? void 0 : _c3.clear();
-    (_d3 = this._typeIds) === null || _d3 === void 0 ? void 0 : _d3.clear();
-    for (const child of this.children)
-      child.clear();
-    return this;
-  }
-};
-Builder5.prototype.length = 1;
-Builder5.prototype.stride = 1;
-Builder5.prototype.children = null;
-Builder5.prototype.finished = false;
-Builder5.prototype.nullValues = null;
-Builder5.prototype._isValid = () => true;
-var FixedWidthBuilder2 = class extends Builder5 {
-  constructor(opts) {
-    super(opts);
-    this._values = new DataBufferBuilder2(new this.ArrayType(0), this.stride);
-  }
-  setValue(index, value) {
-    const values = this._values;
-    values.reserve(index - values.length + 1);
-    return super.setValue(index, value);
-  }
-};
-var VariableWidthBuilder2 = class extends Builder5 {
-  constructor(opts) {
-    super(opts);
-    this._pendingLength = 0;
-    this._offsets = new OffsetsBufferBuilder2();
-  }
-  setValue(index, value) {
-    const pending = this._pending || (this._pending = /* @__PURE__ */ new Map());
-    const current = pending.get(index);
-    current && (this._pendingLength -= current.length);
-    this._pendingLength += value instanceof MapRow2 ? value[kKeys2].length : value.length;
-    pending.set(index, value);
+  endVector() {
+    this.writeInt32(this.vector_num_elems);
+    return this.offset();
   }
-  setValid(index, isValid) {
-    if (!super.setValid(index, isValid)) {
-      (this._pending || (this._pending = /* @__PURE__ */ new Map())).set(index, void 0);
-      return false;
+  /**
+   * Encode the string `s` in the buffer using UTF-8. If the string passed has
+   * already been seen, we return the offset of the already written string
+   *
+   * @param s The string to encode
+   * @return The offset in the buffer where the encoded string starts
+   */
+  createSharedString(s) {
+    if (!s) {
+      return 0;
     }
-    return true;
-  }
-  clear() {
-    this._pendingLength = 0;
-    this._pending = void 0;
-    return super.clear();
-  }
-  flush() {
-    this._flush();
-    return super.flush();
-  }
-  finish() {
-    this._flush();
-    return super.finish();
-  }
-  _flush() {
-    const pending = this._pending;
-    const pendingLength = this._pendingLength;
-    this._pendingLength = 0;
-    this._pending = void 0;
-    if (pending && pending.size > 0) {
-      this._flushPending(pending, pendingLength);
+    if (!this.string_maps) {
+      this.string_maps = /* @__PURE__ */ new Map();
     }
-    return this;
-  }
-};
-
-// ../../node_modules/@duckdb/duckdb-wasm/node_modules/apache-arrow/fb/block.mjs
-var Block2 = class {
-  constructor() {
-    this.bb = null;
-    this.bb_pos = 0;
-  }
-  __init(i, bb) {
-    this.bb_pos = i;
-    this.bb = bb;
-    return this;
+    if (this.string_maps.has(s)) {
+      return this.string_maps.get(s);
+    }
+    const offset = this.createString(s);
+    this.string_maps.set(s, offset);
+    return offset;
   }
   /**
-   * Index to the start of the RecordBlock (note this is past the Message header)
+   * Encode the string `s` in the buffer using UTF-8. If a Uint8Array is passed
+   * instead of a string, it is assumed to contain valid UTF-8 encoded data.
+   *
+   * @param s The string to encode
+   * @return The offset in the buffer where the encoded string starts
    */
-  offset() {
-    return this.bb.readInt64(this.bb_pos);
+  createString(s) {
+    if (s === null || s === void 0) {
+      return 0;
+    }
+    let utf8;
+    if (s instanceof Uint8Array) {
+      utf8 = s;
+    } else {
+      utf8 = this.text_encoder.encode(s);
+    }
+    this.addInt8(0);
+    this.startVector(1, utf8.length, 1);
+    this.bb.setPosition(this.space -= utf8.length);
+    for (let i = 0, offset = this.space, bytes = this.bb.bytes(); i < utf8.length; i++) {
+      bytes[offset++] = utf8[i];
+    }
+    return this.endVector();
   }
   /**
-   * Length of the metadata
+   * A helper function to pack an object
+   *
+   * @returns offset of obj
    */
-  metaDataLength() {
-    return this.bb.readInt32(this.bb_pos + 8);
+  createObjectOffset(obj) {
+    if (obj === null) {
+      return 0;
+    }
+    if (typeof obj === "string") {
+      return this.createString(obj);
+    } else {
+      return obj.pack(this);
+    }
   }
   /**
-   * Length of the data (this is aligned so there can be a gap between this and
-   * the metadata).
+   * A helper function to pack a list of object
+   *
+   * @returns list of offsets of each non null object
    */
-  bodyLength() {
-    return this.bb.readInt64(this.bb_pos + 16);
-  }
-  static sizeOf() {
-    return 24;
+  createObjectOffsetList(list) {
+    const ret = [];
+    for (let i = 0; i < list.length; ++i) {
+      const val = list[i];
+      if (val !== null) {
+        ret.push(this.createObjectOffset(val));
+      } else {
+        throw new TypeError("FlatBuffers: Argument for createObjectOffsetList cannot contain null.");
+      }
+    }
+    return ret;
   }
-  static createBlock(builder, offset, metaDataLength, bodyLength) {
-    builder.prep(8, 24);
-    builder.writeInt64(BigInt(bodyLength !== null && bodyLength !== void 0 ? bodyLength : 0));
-    builder.pad(4);
-    builder.writeInt32(metaDataLength);
-    builder.writeInt64(BigInt(offset !== null && offset !== void 0 ? offset : 0));
-    return builder.offset();
+  createStructOffsetList(list, startFunc) {
+    startFunc(this, list.length);
+    this.createObjectOffsetList(list.slice().reverse());
+    return this.endVector();
   }
 };
 
@@ -18866,7 +20043,7 @@ var KeyValue2 = class _KeyValue {
     return (obj || new _KeyValue()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static getSizePrefixedRootAsKeyValue(bb, obj) {
-    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH2);
     return (obj || new _KeyValue()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   key(optionalEncoding) {
@@ -18936,7 +20113,7 @@ var Int2 = class _Int {
     return (obj || new _Int()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static getSizePrefixedRootAsInt(bb, obj) {
-    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH2);
     return (obj || new _Int()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   bitWidth() {
@@ -18983,7 +20160,7 @@ var DictionaryEncoding2 = class _DictionaryEncoding {
     return (obj || new _DictionaryEncoding()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static getSizePrefixedRootAsDictionaryEncoding(bb, obj) {
-    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH2);
     return (obj || new _DictionaryEncoding()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   /**
@@ -19056,7 +20233,7 @@ var Binary4 = class _Binary {
     return (obj || new _Binary()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static getSizePrefixedRootAsBinary(bb, obj) {
-    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH2);
     return (obj || new _Binary()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static startBinary(builder) {
@@ -19087,7 +20264,7 @@ var Bool4 = class _Bool {
     return (obj || new _Bool()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static getSizePrefixedRootAsBool(bb, obj) {
-    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH2);
     return (obj || new _Bool()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static startBool(builder) {
@@ -19125,7 +20302,7 @@ var Date3 = class _Date {
     return (obj || new _Date()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static getSizePrefixedRootAsDate(bb, obj) {
-    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH2);
     return (obj || new _Date()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   unit() {
@@ -19164,7 +20341,7 @@ var Decimal4 = class _Decimal {
     return (obj || new _Decimal()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static getSizePrefixedRootAsDecimal(bb, obj) {
-    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH2);
     return (obj || new _Decimal()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   /**
@@ -19238,7 +20415,7 @@ var Duration4 = class _Duration {
     return (obj || new _Duration()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static getSizePrefixedRootAsDuration(bb, obj) {
-    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH2);
     return (obj || new _Duration()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   unit() {
@@ -19277,7 +20454,7 @@ var FixedSizeBinary4 = class _FixedSizeBinary {
     return (obj || new _FixedSizeBinary()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static getSizePrefixedRootAsFixedSizeBinary(bb, obj) {
-    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH2);
     return (obj || new _FixedSizeBinary()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   /**
@@ -19319,7 +20496,7 @@ var FixedSizeList4 = class _FixedSizeList {
     return (obj || new _FixedSizeList()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static getSizePrefixedRootAsFixedSizeList(bb, obj) {
-    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH2);
     return (obj || new _FixedSizeList()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   /**
@@ -19369,7 +20546,7 @@ var FloatingPoint2 = class _FloatingPoint {
     return (obj || new _FloatingPoint()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static getSizePrefixedRootAsFloatingPoint(bb, obj) {
-    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH2);
     return (obj || new _FloatingPoint()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   precision() {
@@ -19416,7 +20593,7 @@ var Interval2 = class _Interval {
     return (obj || new _Interval()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static getSizePrefixedRootAsInterval(bb, obj) {
-    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH2);
     return (obj || new _Interval()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   unit() {
@@ -19455,7 +20632,7 @@ var List4 = class _List {
     return (obj || new _List()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static getSizePrefixedRootAsList(bb, obj) {
-    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH2);
     return (obj || new _List()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static startList(builder) {
@@ -19486,7 +20663,7 @@ var Map3 = class _Map {
     return (obj || new _Map()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static getSizePrefixedRootAsMap(bb, obj) {
-    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH2);
     return (obj || new _Map()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   /**
@@ -19528,7 +20705,7 @@ var Null4 = class _Null {
     return (obj || new _Null()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static getSizePrefixedRootAsNull(bb, obj) {
-    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH2);
     return (obj || new _Null()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static startNull(builder) {
@@ -19559,7 +20736,7 @@ var Struct_2 = class _Struct_ {
     return (obj || new _Struct_()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static getSizePrefixedRootAsStruct_(bb, obj) {
-    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH2);
     return (obj || new _Struct_()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static startStruct_(builder) {
@@ -19590,7 +20767,7 @@ var Time2 = class _Time {
     return (obj || new _Time()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static getSizePrefixedRootAsTime(bb, obj) {
-    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH2);
     return (obj || new _Time()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   unit() {
@@ -19637,7 +20814,7 @@ var Timestamp2 = class _Timestamp {
     return (obj || new _Timestamp()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static getSizePrefixedRootAsTimestamp(bb, obj) {
-    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH2);
     return (obj || new _Timestamp()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   unit() {
@@ -19691,7 +20868,7 @@ var Union2 = class _Union {
     return (obj || new _Union()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static getSizePrefixedRootAsUnion(bb, obj) {
-    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH2);
     return (obj || new _Union()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   mode() {
@@ -19756,7 +20933,7 @@ var Utf84 = class _Utf8 {
     return (obj || new _Utf8()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static getSizePrefixedRootAsUtf8(bb, obj) {
-    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH2);
     return (obj || new _Utf8()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static startUtf8(builder) {
@@ -19815,7 +20992,7 @@ var Field3 = class _Field {
     return (obj || new _Field()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static getSizePrefixedRootAsField(bb, obj) {
-    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH2);
     return (obj || new _Field()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   name(optionalEncoding) {
@@ -19935,7 +21112,7 @@ var Schema3 = class _Schema {
     return (obj || new _Schema()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static getSizePrefixedRootAsSchema(bb, obj) {
-    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH2);
     return (obj || new _Schema()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   /**
@@ -20054,7 +21231,7 @@ var Footer2 = class _Footer {
     return (obj || new _Footer()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static getSizePrefixedRootAsFooter(bb, obj) {
-    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH2);
     return (obj || new _Footer()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   version() {
@@ -20255,19 +21432,19 @@ function generateDictionaryMap2(fields, dictionaries = /* @__PURE__ */ new Map()
 }
 
 // ../../node_modules/@duckdb/duckdb-wasm/node_modules/apache-arrow/ipc/metadata/file.mjs
-var Builder6 = Builder;
-var ByteBuffer4 = ByteBuffer;
+var Builder7 = Builder6;
+var ByteBuffer5 = ByteBuffer4;
 var Footer_2 = class {
   /** @nocollapse */
   static decode(buf) {
-    buf = new ByteBuffer4(toUint8Array2(buf));
+    buf = new ByteBuffer5(toUint8Array2(buf));
     const footer = Footer2.getRootAsFooter(buf);
     const schema = Schema4.decode(footer.schema(), /* @__PURE__ */ new Map(), footer.version());
     return new OffHeapFooter2(schema, footer);
   }
   /** @nocollapse */
   static encode(footer) {
-    const b2 = new Builder6();
+    const b2 = new Builder7();
     const schemaOffset = Schema4.encode(b2, footer.schema);
     Footer2.startRecordBatchesVector(b2, footer.numRecordBatches);
     for (const rb of [...footer.recordBatches()].slice().reverse()) {
@@ -22625,7 +23802,7 @@ var BodyCompression2 = class _BodyCompression {
     return (obj || new _BodyCompression()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static getSizePrefixedRootAsBodyCompression(bb, obj) {
-    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH2);
     return (obj || new _BodyCompression()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   /**
@@ -22755,7 +23932,7 @@ var RecordBatch5 = class _RecordBatch {
     return (obj || new _RecordBatch()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static getSizePrefixedRootAsRecordBatch(bb, obj) {
-    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH2);
     return (obj || new _RecordBatch()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   /**
@@ -22842,7 +24019,7 @@ var DictionaryBatch3 = class _DictionaryBatch {
     return (obj || new _DictionaryBatch()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static getSizePrefixedRootAsDictionaryBatch(bb, obj) {
-    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH2);
     return (obj || new _DictionaryBatch()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   id() {
@@ -22906,7 +24083,7 @@ var Message3 = class _Message {
     return (obj || new _Message()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   static getSizePrefixedRootAsMessage(bb, obj) {
-    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+    bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH2);
     return (obj || new _Message()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
   }
   version() {
@@ -23236,8 +24413,8 @@ function typeFromJSON2(f2, children) {
 }
 
 // ../../node_modules/@duckdb/duckdb-wasm/node_modules/apache-arrow/ipc/metadata/message.mjs
-var Builder7 = Builder;
-var ByteBuffer5 = ByteBuffer;
+var Builder8 = Builder6;
+var ByteBuffer6 = ByteBuffer4;
 var Message4 = class _Message {
   /** @nocollapse */
   static fromJSON(msg, headerType) {
@@ -23247,7 +24424,7 @@ var Message4 = class _Message {
   }
   /** @nocollapse */
   static decode(buf) {
-    buf = new ByteBuffer5(toUint8Array2(buf));
+    buf = new ByteBuffer6(toUint8Array2(buf));
     const _message = Message3.getRootAsMessage(buf);
     const bodyLength = _message.bodyLength();
     const version = _message.version();
@@ -23258,7 +24435,7 @@ var Message4 = class _Message {
   }
   /** @nocollapse */
   static encode(message) {
-    const b2 = new Builder7();
+    const b2 = new Builder8();
     let headerOffset = -1;
     if (message.isSchema()) {
       headerOffset = Schema4.encode(b2, message.header());
@@ -23749,7 +24926,7 @@ var MessageReader2 = class {
   }
   readMetadataLength() {
     const buf = this.source.read(PADDING2);
-    const bb = buf && new ByteBuffer(buf);
+    const bb = buf && new ByteBuffer4(buf);
     const len = (bb === null || bb === void 0 ? void 0 : bb.readInt32(0)) || 0;
     return { done: len === 0, value: len };
   }
@@ -23838,7 +25015,7 @@ var AsyncMessageReader2 = class {
   readMetadataLength() {
     return __awaiter(this, void 0, void 0, function* () {
       const buf = yield this.source.read(PADDING2);
-      const bb = buf && new ByteBuffer(buf);
+      const bb = buf && new ByteBuffer4(buf);
       const len = (bb === null || bb === void 0 ? void 0 : bb.readInt32(0)) || 0;
       return { done: len === 0, value: len };
     });
@@ -25903,7 +27080,7 @@ function wasmConnector(options = {}) {
     /**
      * Query the DuckDB-WASM instance.
      * @param {object} query
-     * @param {string} [query.type] The query type: 'exec', 'arrow', or 'json'.
+     * @param {'exec' | 'arrow' | 'json'} [query.type] The query type: 'exec', 'arrow', or 'json'.
      * @param {string} query.sql A SQL query string.
      * @returns the query result
      */
@@ -25911,7 +27088,7 @@ function wasmConnector(options = {}) {
       const { type, sql: sql2 } = query;
       const con2 = await getConnection();
       const result = await con2.query(sql2);
-      return type === "exec" ? void 0 : type === "arrow" ? result : Array.from(result);
+      return type === "exec" ? void 0 : type === "arrow" ? result : result.toArray();
     }
   };
 }
@@ -25931,6 +27108,74 @@ async function initDatabase({
   return db;
 }
 
+// src/SelectionClause.js
+function clausePoint(field, value, {
+  source,
+  clients = source ? /* @__PURE__ */ new Set([source]) : void 0
+}) {
+  const predicate = value !== void 0 ? isNotDistinct(field, literal(value)) : null;
+  return {
+    meta: { type: "point" },
+    source,
+    clients,
+    value,
+    predicate
+  };
+}
+function clausePoints(fields, value, {
+  source,
+  clients = source ? /* @__PURE__ */ new Set([source]) : void 0
+}) {
+  let predicate = null;
+  if (value) {
+    const clauses = value.map((vals) => {
+      const list = vals.map((v2, i) => isNotDistinct(fields[i], literal(v2)));
+      return list.length > 1 ? and(list) : list[0];
+    });
+    predicate = clauses.length > 1 ? or(clauses) : clauses[0];
+  }
+  return {
+    meta: { type: "point" },
+    source,
+    clients,
+    value,
+    predicate
+  };
+}
+function clauseInterval(field, value, {
+  source,
+  clients = source ? /* @__PURE__ */ new Set([source]) : void 0,
+  bin,
+  scale,
+  pixelSize = 1
+}) {
+  const predicate = value != null ? isBetween(field, value) : null;
+  const meta = { type: "interval", scales: scale && [scale], bin, pixelSize };
+  return { meta, source, clients, value, predicate };
+}
+function clauseIntervals(fields, value, {
+  source,
+  clients = source ? /* @__PURE__ */ new Set([source]) : void 0,
+  bin,
+  scales: scales2 = [],
+  pixelSize = 1
+}) {
+  const predicate = value != null ? and(fields.map((f2, i) => isBetween(f2, value[i]))) : null;
+  const meta = { type: "interval", scales: scales2, bin, pixelSize };
+  return { meta, source, clients, value, predicate };
+}
+var MATCH_METHODS = { contains, prefix, suffix, regexp: regexp_matches };
+function clauseMatch(field, value, {
+  source,
+  clients = void 0,
+  method = "contains"
+}) {
+  let fn = MATCH_METHODS[method];
+  const predicate = value ? fn(field, literal(value)) : null;
+  const meta = { type: "match", method };
+  return { meta, source, clients, value, predicate };
+}
+
 // src/util/synchronizer.js
 function synchronizer() {
   const set = /* @__PURE__ */ new Set();
@@ -25974,12 +27219,50 @@ function synchronizer() {
     }
   };
 }
+
+// src/util/to-data-columns.js
+function toDataColumns(data) {
+  return isArrowTable(data) ? arrowToColumns(data) : arrayToColumns(data);
+}
+function arrowToColumns(data) {
+  const { numRows, numCols, schema: { fields } } = data;
+  const columns = {};
+  for (let col = 0; col < numCols; ++col) {
+    const name = fields[col].name;
+    if (columns[name]) {
+      console.warn(`Redundant column name "${name}". Skipping...`);
+    } else {
+      columns[name] = convertArrowColumn(data.getChildAt(col));
+    }
+  }
+  return { numRows, columns };
+}
+function arrayToColumns(data) {
+  const numRows = data.length;
+  if (typeof data[0] === "object") {
+    const names = numRows ? Object.keys(data[0]) : [];
+    const columns = {};
+    if (names.length > 0) {
+      names.forEach((name) => {
+        columns[name] = data.map((d) => d[name]);
+      });
+    }
+    return { numRows, columns };
+  } else {
+    return { numRows, values: data };
+  }
+}
 export {
   Coordinator,
   MosaicClient,
   Param,
   Priority,
   Selection,
+  clauseInterval,
+  clauseIntervals,
+  clauseMatch,
+  clausePoint,
+  clausePoints,
   convertArrowArrayType,
   convertArrowColumn,
   convertArrowValue,
@@ -25992,5 +27275,6 @@ export {
   socketConnector,
   synchronizer,
   throttle,
+  toDataColumns,
   wasmConnector
 };