@uwdata/mosaic-inputs 0.8.0 → 0.10.0

package/dist/mosaic-inputs.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(v) {
 function __asyncGenerator(thisArg, _arguments, generator) {
   if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
   var g = generator.apply(thisArg, _arguments || []), i, q = [];
-  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 (g[n]) i[n] = function(v) {
-      return new Promise(function(a, b) {
-        q.push([n, v, a, b]) > 1 || resume(n, v);
-      });
+  function awaitReturn(f) {
+    return function(v) {
+      return Promise.resolve(v).then(f, reject);
     };
   }
+  function verb(n, f) {
+    if (g[n]) {
+      i[n] = function(v) {
+        return new Promise(function(a, b) {
+          q.push([n, v, a, b]) > 1 || resume(n, v);
+        });
+      };
+      if (f) i[n] = f(i[n]);
+    }
+  }
   function resume(n, v) {
     try {
       step(g[n](v));
@@ -840,26 +847,26 @@ var IntervalUnit;
   IntervalUnit2[IntervalUnit2["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";
 })(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(v) {
+    if (v === null || v === void 0) {
+      return 0;
     }
+    this.startVector(1, v.length, 1);
+    this.bb.setPosition(this.space -= v.length);
+    this.bb.bytes().set(v, 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(x2, ...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 = (a) => {
+function bigNumToString(a) {
   if (a.byteLength === 8) {
     const bigIntArray = new a["BigIntArray"](a.buffer, a.byteOffset, 1);
     return `${bigIntArray[0]}`;
@@ -3278,15 +3321,15 @@ var bigNumToString = (a) => {
   }
   const negated = unsignedBigNumToString(array);
   return `-${negated}`;
-};
-var bigNumToBigInt = (a) => {
+}
+function bigNumToBigInt(a) {
   if (a.byteLength === 8) {
     const bigIntArray = new a["BigIntArray"](a.buffer, a.byteOffset, 1);
     return bigIntArray[0];
   } else {
     return bigNumToString(a);
   }
-};
+}
 function unsignedBigNumToString(a) {
   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(search2) {
   const typeofSearch = typeof search2;
@@ -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 _a5, e_1, _b2, _c2;
     return __awaiter(this, void 0, void 0, function* () {
+      var _a5, e_1, _b2, _c2;
       const batches = new Array();
       try {
         for (var _d2 = true, _e2 = __asyncValues(this), _f2; _f2 = yield _e2.next(), _a5 = _f2.done, !_a5; _d2 = true) {
@@ -10946,8 +11001,8 @@ var AsyncRecordBatchFileReaderImpl = class extends AsyncRecordBatchStreamReaderI
     });
   }
   readRecordBatch(index) {
-    var _a5;
     return __awaiter(this, void 0, void 0, function* () {
+      var _a5;
       if (this.closed) {
         return null;
       }
@@ -10968,8 +11023,8 @@ var AsyncRecordBatchFileReaderImpl = class extends AsyncRecordBatchStreamReaderI
     });
   }
   _readDictionaryBatch(index) {
-    var _a5;
     return __awaiter(this, void 0, void 0, function* () {
+      var _a5;
       const block = (_a5 = this._footer) === null || _a5 === void 0 ? void 0 : _a5.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, input2) {
   return writer.finish();
 }
 function writeAllAsync(writer, batches) {
-  var _a5, batches_1, batches_1_1;
-  var _b2, e_1, _c2, _d2;
   return __awaiter(this, void 0, void 0, function* () {
+    var _a5, batches_1, batches_1_1;
+    var _b2, e_1, _c2, _d2;
     try {
       for (_a5 = true, batches_1 = __asyncValues(batches); batches_1_1 = yield batches_1.next(), _b2 = batches_1_1.done, !_b2; _a5 = true) {
         _d2 = 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);
@@ -12260,6 +12322,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.
@@ -12390,6 +12455,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");
@@ -12532,7 +12598,8 @@ var Query = class _Query {
           }
         }
       }
-      query.select = query.select.concat(list);
+      const keys = new Set(list.map((x2) => x2.as));
+      query.select = query.select.filter((x2) => !keys.has(x2.as)).concat(list.filter((x2) => x2.expr));
       return this;
     }
   }
@@ -13005,6 +13072,7 @@ function scaleTime() {
   };
 }
 var scales = {
+  identity: scaleLinear,
   linear: scaleLinear,
   log: scaleLog,
   symlog: scaleSymlog,
@@ -13027,179 +13095,97 @@ function create(name, query, {
   return "CREATE" + (replace ? " OR REPLACE " : " ") + (temp ? "TEMP " : "") + (view ? "VIEW" : "TABLE") + (replace ? " " : " IF NOT EXISTS ") + name + " AS " + query;
 }
 
-// ../core/src/util/hash.js
-function fnv_hash(v) {
-  let a = 2166136261;
-  for (let i = 0, n = v.length; i < n; ++i) {
-    const c = v.charCodeAt(i);
-    const d = c & 65280;
-    if (d) a = fnv_multiply(a ^ d >> 8);
-    a = fnv_multiply(a ^ c & 255);
-  }
-  return fnv_mix(a);
-}
-function fnv_multiply(a) {
-  return a + (a << 1) + (a << 4) + (a << 7) + (a << 8) + (a << 24);
-}
-function fnv_mix(a) {
-  a += a << 13;
-  a ^= a >>> 7;
-  a += a << 3;
-  a ^= a >>> 17;
-  a += a << 5;
-  return a & 4294967295;
-}
-
-// ../core/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 table2 = `cube_index_${id}`;
-      const result = mc.exec(create(table2, sql2, { temp }));
-      indices.set(client, { table: table2, 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: table2, dims, aggr, order = [] } = index;
-    const query = Query.select(dims, aggr).from(table2).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((b) => b == null)) return null;
-    if (bins.length === 1) {
-      predicate = (p) => p ? isBetween("active0", p.range.map(bins[0])) : [];
-      columns = { active0: bins[0](clause.predicate.field) };
-    } else {
-      predicate = (p) => p ? and(p.children.map(({ range }, i) => isBetween(`active${i}`, range.map(bins[i])))) : [];
-      columns = Object.fromEntries(
-        clause.predicate.children.map((p, i) => [`active${i}`, bins[i](p.field)])
-      );
-    }
-  } else if (type === "point") {
-    predicate = (x2) => x2;
-    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 a = Math.abs(range[1] - range[0]) / (hi - lo) / pixelSize;
-    const s = pixelSize === 1 ? "" : `${pixelSize}::INTEGER * `;
-    return (value) => sql`${s}FLOOR(${a}::DOUBLE * (${sqlApply(value)} - ${lo}::DOUBLE))::INTEGER`;
-  }
-}
-var NO_INDEX = { from: NaN };
-function getIndexColumns(client) {
-  if (!client.filterIndexable) return NO_INDEX;
+// ../core/src/util/index-columns.js
+function indexColumns(client) {
+  if (!client.filterIndexable) return null;
   const q = client.query();
   const from = getBaseTable(q);
-  if (!from || !q.groupby) return NO_INDEX;
-  const g = new Set(q.groupby().map((c) => c.column));
+  if (typeof from !== "string" || !q.select) return null;
   const aggr = [];
   const dims = [];
   const aux = {};
-  let auxAs;
   for (const entry of q.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":
@@ -13209,14 +13195,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 (g.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;
@@ -13233,6 +13227,291 @@ function getBaseTable(query) {
   }
   return base;
 }
+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(x2, from) {
+  return sql`(SELECT AVG(${x2}) FROM "${from}")`;
+}
+function argmaxExpr(aux, as, [, y2]) {
+  const max2 = auxName("max", y2);
+  aux[max2] = agg`MAX(${y2})`;
+  return agg`ARG_MAX("${as}", ${max2})`;
+}
+function argminExpr(aux, as, [, y2]) {
+  const min2 = auxName("min", y2);
+  aux[min2] = agg`MIN(${y2})`;
+  return agg`ARG_MIN("${as}", ${min2})`;
+}
+function varianceExpr(aux, x2, from, correction = true) {
+  const n = countExpr(aux, x2);
+  const ssq = auxName("rssq", x2);
+  const sum2 = auxName("rsum", x2);
+  const delta = sql`${x2} - ${avg2(x2, from)}`;
+  aux[ssq] = agg`SUM((${delta}) ** 2)`;
+  aux[sum2] = agg`SUM(${delta})`;
+  const adj = correction ? ` - 1` : "";
+  return agg`(SUM(${ssq}) - (SUM(${sum2}) ** 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, [y2, x2]) {
+  const n = auxName("count", y2, x2);
+  aux[n] = agg`REGR_COUNT(${y2}, ${x2})`;
+  return agg`SUM(${n})`.annotate({ name: n });
+}
+function regrSumExpr(aux, i, args, from) {
+  const v = args[i];
+  const o = args[1 - i];
+  const sum2 = auxName("rs", v);
+  aux[sum2] = agg`SUM(${v} - ${avg2(v, from)}) FILTER (${o} IS NOT NULL)`;
+  return agg`SUM(${sum2})`;
+}
+function regrSumSqExpr(aux, i, args, from) {
+  const v = args[i];
+  const u = args[1 - i];
+  const ssq = auxName("rss", v);
+  aux[ssq] = agg`SUM((${v} - ${avg2(v, from)}) ** 2) FILTER (${u} IS NOT NULL)`;
+  return agg`SUM(${ssq})`;
+}
+function regrSumXYExpr(aux, args, from) {
+  const [y2, x2] = args;
+  const sxy = auxName("sxy", y2, x2);
+  aux[sxy] = agg`SUM((${x2} - ${avg2(x2, from)}) * (${y2} - ${avg2(y2, from)}))`;
+  return agg`SUM(${sxy})`;
+}
+function regrAvgXExpr(aux, args) {
+  const [y2, x2] = args;
+  const n = regrCountExpr(aux, args);
+  const a = auxName("avg", x2, y2);
+  aux[a] = agg`REGR_AVGX(${y2}, ${x2})`;
+  return agg`(SUM(${a} * ${n.name}) / ${n})`;
+}
+function regrAvgYExpr(aux, args) {
+  const [y2, x2] = args;
+  const n = regrCountExpr(aux, args);
+  const a = auxName("avg", y2, x2);
+  aux[a] = agg`REGR_AVGY(${y2}, ${x2})`;
+  return agg`(SUM(${a} * ${n.name}) / ${n})`;
+}
+function regrVarExpr(aux, i, args, from) {
+  const n = regrCountExpr(aux, args);
+  const sum2 = regrSumExpr(aux, i, args, from);
+  const ssq = regrSumSqExpr(aux, i, args, from);
+  return agg`(${ssq} - (${sum2} ** 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 m = regrSlopeExpr(aux, args, from);
+  return agg`${ay} - (${m}) * ${ax}`;
+}
+
+// ../core/src/util/hash.js
+function fnv_hash(v) {
+  let a = 2166136261;
+  for (let i = 0, n = v.length; i < n; ++i) {
+    const c = v.charCodeAt(i);
+    const d = c & 65280;
+    if (d) a = fnv_multiply(a ^ d >> 8);
+    a = fnv_multiply(a ^ c & 255);
+  }
+  return fnv_mix(a);
+}
+function fnv_multiply(a) {
+  return a + (a << 1) + (a << 4) + (a << 7) + (a << 8) + (a << 24);
+}
+function fnv_mix(a) {
+  a += a << 13;
+  a ^= a >>> 7;
+  a += a << 3;
+  a ^= a >>> 17;
+  a += a << 5;
+  return a & 4294967295;
+}
+
+// ../core/src/DataCubeIndexer.js
+var Skip = { skip: true, result: null };
+var DataCubeIndexer = class {
+  /**
+   * 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, {
+    enabled = true,
+    temp = true
+  } = {}) {
+    this.indexes = /* @__PURE__ */ new Map();
+    this.active = null;
+    this.temp = temp;
+    this.mc = coordinator2;
+    this._enabled = enabled;
+  }
+  /**
+   * 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;
+    }
+  }
+  /**
+   * 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.
+   */
+  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 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 = (x2) => x2;
+    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((b) => !b)) {
+    } else if (bins.length === 1) {
+      predicate = (p) => p ? isBetween("active0", p.range.map(bins[0])) : [];
+      columns = { active0: bins[0](clausePred.field) };
+    } else {
+      predicate = (p) => p ? and(p.children.map(
+        ({ range }, i) => isBetween(`active${i}`, range.map(bins[i]))
+      )) : [];
+      columns = Object.fromEntries(
+        // @ts-ignore
+        clausePred.children.map((p, i) => [`active${i}`, bins[i](p.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 a = type === "identity" ? 1 : Math.abs(range[1] - range[0]) / (hi - lo);
+  const s = a / pixelSize === 1 ? "" : `${a / 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 table2 = `cube_index_${id}`;
+  const select = Query.select(dims, aggr).from(table2).groupby(dims).orderby(order);
+  return new DataCubeInfo({ table: table2, create: create2, active, select });
+}
 function subqueryPushdown(query, cols) {
   const memo = /* @__PURE__ */ new Set();
   const pushdown = (q) => {
@@ -13245,78 +13524,65 @@ function subqueryPushdown(query, cols) {
   };
   pushdown(query);
 }
-
-// ../core/src/FilterGroup.js
-var FilterGroup = class {
+var DataCubeInfo = 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 DataCubeInfo instance.
+   * @param {object} options
    */
-  constructor(coordinator2, selection, index = true) {
-    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);
+  constructor({ table: table2, create: create2, active, select } = {}) {
+    this.table = table2;
+    this.create = create2;
+    this.result = null;
+    this.active = active;
+    this.select = select;
+    this.skip = false;
   }
-  finalize() {
-    const { value, activate } = this.handlers;
-    this.selection.removeEventListener("value", value);
-    this.selection.removeEventListener("activate", activate);
-  }
-  reset() {
-    this.indexer?.reset();
+  /**
+   * 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));
   }
-  add(client) {
-    (this.clients = new Set(this.clients)).add(client);
-    return this;
+};
+
+// ../core/src/util/query-result.js
+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;
   }
-  remove(client) {
-    if (this.clients.has(client)) {
-      (this.clients = new Set(this.clients)).delete(client);
-    }
+  /**
+   * Resolve the result Promise with the provided value.
+   * @param {*} value The result value.
+   * @returns {this}
+   */
+  fulfill(value) {
+    this._resolve(value);
     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.
+   * Rejects the result Promise with the provided error.
+   * @param {*} error The error value.
+   * @returns {this}
    */
-  update() {
-    const { mc, indexer, clients, selection } = this;
-    const hasIndex = indexer?.index(clients);
-    return hasIndex ? indexer.update() : defaultUpdate(mc, clients, selection);
+  reject(error) {
+    this._reject(error);
+    return this;
   }
 };
-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));
-    }
-  }));
-}
-
-// ../core/src/util/query-result.js
-function queryResult() {
-  let resolve;
-  let reject;
-  const p = new Promise((r, e) => {
-    resolve = r;
-    reject = e;
-  });
-  return Object.assign(p, {
-    fulfill: (value) => (resolve(value), p),
-    reject: (err) => (reject(err), p)
-  });
-}
+QueryResult.prototype.constructor = Promise;
 
 // ../core/src/QueryConsolidator.js
 function wait(callback) {
@@ -13392,7 +13658,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) {
@@ -13608,115 +13874,124 @@ function priorityQueue(ranks) {
 
 // ../core/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((x2) => x2 !== 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((x2) => x2 !== recorder);
+        return state;
+      }
+    };
+    this.recorders.push(recorder);
+    return recorder;
+  }
+};
 
 // ../core/src/util/js-type.js
 function jsType(type) {
@@ -13768,6 +14043,9 @@ function jsType(type) {
 }
 
 // ../core/src/util/convert-arrow.js
+function isArrowTable(values) {
+  return typeof values?.getChild === "function";
+}
 function convertArrowValue(type) {
   if (DataType.isTimestamp(type)) {
     return (v) => v == null ? v : new Date(v);
@@ -13781,6 +14059,41 @@ function convertArrowValue(type) {
   }
   return (v) => v;
 }
+function convertArrowColumn(column2) {
+  const { type } = column2;
+  if (DataType.isTimestamp(type)) {
+    const size = column2.length;
+    const array = new Array(size);
+    for (let row = 0; row < size; ++row) {
+      const v = column2.get(row);
+      array[row] = v == null ? null : new Date(v);
+    }
+    return array;
+  }
+  if (DataType.isInt(type) && type.bitWidth >= 64) {
+    const size = column2.length;
+    const array = column2.nullCount ? new Array(size) : new Float64Array(size);
+    for (let row = 0; row < size; ++row) {
+      const v = column2.get(row);
+      array[row] = v == null ? null : Number(v);
+    }
+    return array;
+  }
+  if (DataType.isDecimal(type)) {
+    const scale = 1 / Math.pow(10, type.scale);
+    const size = column2.length;
+    const array = column2.nullCount ? new Array(size) : new Float64Array(size);
+    for (let row = 0; row < size; ++row) {
+      const v = column2.get(row);
+      array[row] = v == null ? null : decimalToNumber(v, scale);
+    }
+    return array;
+  }
+  if (column2.nullCount) {
+    return Array.from(column2);
+  }
+  return column2.toArray();
+}
 var BASE32 = Array.from(
   { length: 8 },
   (_, i) => Math.pow(2, i * 32)
@@ -13885,58 +14198,92 @@ function coordinator(instance8) {
   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,
@@ -13945,6 +14292,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 });
   }
@@ -13957,26 +14313,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.");
     }
@@ -13986,30 +14360,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);
+  }));
+}
 
 // ../core/src/util/AsyncDispatch.js
 var AsyncDispatch = class {
@@ -14066,7 +14474,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
@@ -14083,6 +14491,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
@@ -14270,10 +14688,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
@@ -14282,10 +14703,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
@@ -14294,18 +14718,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.
@@ -14338,6 +14769,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.
    */
@@ -14352,16 +14801,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.
@@ -14439,11 +14884,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.
@@ -14478,7 +14927,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;
@@ -14498,6 +14950,96 @@ var SelectionResolver = class {
   }
 };
 
+// ../core/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((v, i) => isNotDistinct(fields[i], literal(v)));
+      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 };
+}
+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 };
+}
+
+// ../core/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 };
+  }
+}
+
 // src/input.js
 function input(InputClass, options) {
   const input2 = new InputClass(options);
@@ -14512,8 +15054,31 @@ var isObject2 = (v) => {
 var menu = (options) => input(Menu, options);
 var Menu = class extends MosaicClient {
   /**
-   * Create a new Menu instance.
-   * @param {object} options Options object
+   * Create a new menu input.
+   * @param {object} [options] Options object
+   * @param {HTMLElement} [options.element] The parent DOM element in which to
+   *  place the menu elements. If undefined, a new `div` element is created.
+   * @param {Selection} [options.filterBy] A selection to filter the database
+   *  table indicated by the *from* option.
+   * @param {Param} [options.as] The output param or selection. A selection
+   *  clause is added for the currently selected menu option.
+   * @param {string} [options.field] The database column name to use within
+   *  generated selection clause predicates. Defaults to the *column* option.
+   * @param {(any | { value: any, label?: string })[]} [options.options] An
+   *  array of menu options, as literal values or option objects. Option
+   *  objects have a `value` property and an optional `label` property. If no
+   *  label or *format* function is provided, the string-coerced value is used.
+   * @param {(value: any) => string} [options.format] A format function that
+   *  takes an option value as input and generates a string label. The format
+   *  function is not applied when an explicit label is provided in an option
+   *  object.
+   * @param {*} [options.value] The initial selected menu value.
+   * @param {string} [options.from] The name of a database table to use as a data
+   *  source for this widget. Used in conjunction with the *column* option.
+   * @param {string} [options.column] The name of a database column from which
+   *  to pull menu options. The unique column values are used as menu options.
+   *  Used in conjunction with the *from* option.
+   * @param {string} [options.label] A text label for this input.
    */
   constructor({
     element,
@@ -14525,32 +15090,37 @@ var Menu = class extends MosaicClient {
     // TODO
     options,
     value,
+    field = column2,
     as
   } = {}) {
     super(filterBy);
     this.from = from;
     this.column = column2;
-    this.selection = as;
     this.format = format2;
+    this.field = field;
+    const selection = this.selection = as;
     this.element = element ?? document.createElement("div");
     this.element.setAttribute("class", "input");
-    this.element.value = this;
+    Object.defineProperty(this.element, "value", { value: this });
     const lab = document.createElement("label");
     lab.innerText = label || column2;
     this.element.appendChild(lab);
     this.select = document.createElement("select");
+    this.element.appendChild(this.select);
     if (options) {
       this.data = options.map((value2) => isObject2(value2) ? value2 : { value: value2 });
+      this.selectedValue(value ?? "");
       this.update();
     }
-    value = value ?? this.selection?.value ?? this.data?.[0]?.value;
-    if (this.selection?.value === void 0) this.publish(value);
-    this.element.appendChild(this.select);
-    if (this.selection) {
+    if (selection) {
+      const isParam2 = !isSelection(selection);
+      if (value != null && (!isParam2 || selection.value === void 0)) {
+        this.publish(value);
+      }
       this.select.addEventListener("input", () => {
         this.publish(this.selectedValue() ?? null);
       });
-      if (!isSelection(this.selection)) {
+      if (isParam2) {
         this.selection.addEventListener("value", (value2) => {
           if (value2 !== this.select.value) {
             this.selectedValue(value2);
@@ -14576,14 +15146,11 @@ var Menu = class extends MosaicClient {
     this.select.selectedIndex = this.from ? 0 : -1;
   }
   publish(value) {
-    const { selection, column: column2 } = this;
+    const { selection, field } = this;
     if (isSelection(selection)) {
-      selection.update({
-        source: this,
-        schema: { type: "point" },
-        value,
-        predicate: value !== "" && value !== void 0 ? eq(column2, literal(value)) : null
-      });
+      if (value === "") value = void 0;
+      const clause = clausePoint(field, value, { source: this });
+      selection.update(clause);
     } else if (isParam(selection)) {
       selection.update(value);
     }
@@ -14598,7 +15165,7 @@ var Menu = class extends MosaicClient {
     return this;
   }
   update() {
-    const { data, format: format2, select } = this;
+    const { data, format: format2, select, selection } = this;
     select.replaceChildren();
     for (const { value, label } of data) {
       const opt = document.createElement("option");
@@ -14606,21 +15173,42 @@ var Menu = class extends MosaicClient {
       opt.innerText = label ?? format2(value);
       this.select.appendChild(opt);
     }
-    if (this.selection) {
-      this.selectedValue(this.selection?.value ?? "");
+    if (selection) {
+      const value = isSelection(selection) ? selection.valueFor(this) : selection.value;
+      this.selectedValue(value ?? "");
     }
     return this;
   }
 };
 
 // src/Search.js
-var FUNCTIONS = { contains, prefix, suffix, regexp: regexp_matches };
 var _id = 0;
 var search = (options) => input(Search, options);
 var Search = class extends MosaicClient {
   /**
-   * Create a new Search instance.
-   * @param {object} options Options object
+   * Create a new text search input.
+   * @param {object} [options] Options object
+   * @param {HTMLElement} [options.element] The parent DOM element in which to
+   *  place the search elements. If undefined, a new `div` element is created.
+   * @param {Selection} [options.filterBy] A selection to filter the database
+   *  table indicated by the *from* option.
+   * @param {Param} [options.as] The output param or selection. A selection
+   *  clause is added based on the current text search query.
+   * @param {string} [options.field] The database column name to use within
+   *  generated selection clause predicates. Defaults to the *column* option.
+   * @param {'contains' | 'prefix' | 'suffix' | 'regexp'} [options.type] The
+   *  type of text search query to perform. One of:
+   *  - `"contains"` (default): the query string may appear anywhere in the text
+   *  - `"prefix"`: the query string must appear at the start of the text
+   *  - `"suffix"`: the query string must appear at the end of the text
+   *  - `"regexp"`: the query string is a regular expression the text must match
+   * @param {string} [options.from] The name of a database table to use as an
+   *  autocomplete data source for this widget. Used in conjunction with the
+   *  *column* option.
+   * @param {string} [options.column] The name of a database column from which
+   *  to pull valid search results. The unique column values are used as search
+   *  autocomplete values. Used in conjunction with the *from* option.
+   * @param {string} [options.label] A text label for this input.
    */
   constructor({
     element,
@@ -14629,6 +15217,7 @@ var Search = class extends MosaicClient {
     column: column2,
     label,
     type = "contains",
+    field = column2,
     as
   } = {}) {
     super(filterBy);
@@ -14637,9 +15226,10 @@ var Search = class extends MosaicClient {
     this.from = from;
     this.column = column2;
     this.selection = as;
+    this.field = field;
     this.element = element ?? document.createElement("div");
     this.element.setAttribute("class", "input");
-    this.element.value = this;
+    Object.defineProperty(this.element, "value", { value: this });
     if (label) {
       const lab = document.createElement("label");
       lab.setAttribute("for", this.id);
@@ -14668,14 +15258,10 @@ var Search = class extends MosaicClient {
     this.searchbox.value = "";
   }
   publish(value) {
-    const { selection, column: column2, type } = this;
+    const { selection, field, type } = this;
     if (isSelection(selection)) {
-      selection.update({
-        source: this,
-        schema: { type },
-        value,
-        predicate: value ? FUNCTIONS[type](column2, literal(value)) : null
-      });
+      const clause = clauseMatch(field, value, { source: this, method: type });
+      selection.update(clause);
     } else if (isParam(selection)) {
       selection.update(value);
     }
@@ -14710,8 +15296,34 @@ var _id2 = 0;
 var slider = (options) => input(Slider, options);
 var Slider = class extends MosaicClient {
   /**
-   * Create a new Slider instance.
-   * @param {object} options Options object
+   * Create a new slider input.
+   * @param {object} [options] Options object
+   * @param {HTMLElement} [options.element] The parent DOM element in which to
+   *  place the slider elements. If undefined, a new `div` element is created.
+   * @param {Selection} [options.filterBy] A selection to filter the database
+   *  table indicated by the *from* option.
+   * @param {Param} [options.as] The output param or selection. A selection
+   *  clause is added based on the currently selected slider option.
+   * @param {string} [options.field] The database column name to use within
+   *  generated selection clause predicates. Defaults to the *column* option.
+   * @param {'point' | 'interval'} [options.select] The type of selection clause
+   *  predicate to generate if the **as** option is a Selection.  If `'point'`
+   *  (the default), the selection predicate is an equality check for the slider
+   *  value. If `'interval'`, the predicate checks an interval from the minimum
+   *  to the current slider value.
+   * @param {number} [options.min] The minimum slider value.
+   * @param {number} [options.max] The maximum slider value.
+   * @param {number} [options.step] The slider step, the amount to increment
+   *  between consecutive values.
+   * @param {number} [options.value] The initial slider value.
+   * @param {string} [options.from] The name of a database table to use as a data
+   *  source for this widget. Used in conjunction with the *column* option.
+   *  The minimum and maximum values of the column determine the slider range.
+   * @param {string} [options.column] The name of a database column whose values
+   *  determine the slider range. Used in conjunction with the *from* option.
+   *  The minimum and maximum values of the column determine the slider range.
+   * @param {string} [options.label] A text label for this input.
+   * @param {number} [options.width] The width of the slider in screen pixels.
    */
   constructor({
     element,
@@ -14724,6 +15336,8 @@ var Slider = class extends MosaicClient {
     column: column2,
     label = column2,
     value = as?.value,
+    select = "point",
+    field = column2,
     width
   } = {}) {
     super(filterBy);
@@ -14731,41 +15345,49 @@ var Slider = class extends MosaicClient {
     this.from = from;
     this.column = column2 || "value";
     this.selection = as;
+    this.selectionType = select;
+    this.field = field;
     this.min = min2;
     this.max = max2;
     this.step = step;
     this.element = element || document.createElement("div");
     this.element.setAttribute("class", "input");
-    this.element.value = this;
+    Object.defineProperty(this.element, "value", { value: this });
     if (label) {
-      const lab = document.createElement("label");
-      lab.setAttribute("for", this.id);
-      lab.innerText = label;
-      this.element.appendChild(lab);
+      const desc2 = document.createElement("label");
+      desc2.setAttribute("for", this.id);
+      desc2.innerText = label;
+      this.element.appendChild(desc2);
     }
     this.slider = document.createElement("input");
     this.slider.setAttribute("id", this.id);
     this.slider.setAttribute("type", "range");
     if (width != null) this.slider.style.width = `${+width}px`;
-    if (min2 != null) this.slider.setAttribute("min", min2);
-    if (max2 != null) this.slider.setAttribute("max", max2);
-    if (step != null) this.slider.setAttribute("step", step);
+    if (min2 != null) this.slider.setAttribute("min", `${min2}`);
+    if (max2 != null) this.slider.setAttribute("max", `${max2}`);
+    if (step != null) this.slider.setAttribute("step", `${step}`);
+    this.element.appendChild(this.slider);
+    this.curval = document.createElement("label");
+    this.curval.setAttribute("for", this.id);
+    this.curval.setAttribute("class", "value");
+    this.element.appendChild(this.curval);
     if (value != null) {
-      this.slider.setAttribute("value", value);
+      this.slider.setAttribute("value", `${value}`);
       if (this.selection?.value === void 0) this.publish(value);
     }
-    this.element.appendChild(this.slider);
-    if (this.selection) {
-      this.slider.addEventListener("input", () => {
-        this.publish(+this.slider.value);
+    this.curval.innerText = this.slider.value;
+    this.slider.addEventListener("input", () => {
+      const { value: value2 } = this.slider;
+      this.curval.innerText = value2;
+      if (this.selection) this.publish(+value2);
+    });
+    if (this.selection && !isSelection(this.selection)) {
+      this.selection.addEventListener("value", (value2) => {
+        if (value2 !== +this.slider.value) {
+          this.slider.value = value2;
+          this.curval.innerText = value2;
+        }
       });
-      if (!isSelection(this.selection)) {
-        this.selection.addEventListener("value", (value2) => {
-          if (value2 !== +this.slider.value) {
-            this.slider.value = value2;
-          }
-        });
-      }
     }
   }
   query(filter = []) {
@@ -14775,20 +15397,34 @@ var Slider = class extends MosaicClient {
   }
   queryResult(data) {
     const { min: min2, max: max2 } = Array.from(data)[0];
-    if (this.min == null) this.slider.setAttribute("min", min2);
-    if (this.max == null) this.slider.setAttribute("max", max2);
-    if (this.step == null) this.slider.setAttribute("step", String((max2 - min2) / 500));
+    if (this.min == null) {
+      this.min = min2;
+      this.slider.setAttribute("min", `${min2}`);
+    }
+    if (this.max == null) {
+      this.max = max2;
+      this.slider.setAttribute("max", `${max2}`);
+    }
+    if (this.step == null) {
+      this.step = (max2 - min2) / 500;
+      this.slider.setAttribute("step", `${this.step}`);
+    }
     return this;
   }
   publish(value) {
-    const { selection, column: column2 } = this;
+    const { field, selectionType, selection } = this;
     if (isSelection(selection)) {
-      selection.update({
-        source: this,
-        schema: { type: "point" },
-        value,
-        predicate: eq(column2, literal(value))
-      });
+      if (selectionType === "interval") {
+        const domain = [this.min ?? 0, value];
+        selection.update(clauseInterval(field, domain, {
+          source: this,
+          bin: "ceil",
+          scale: { type: "identity", domain },
+          pixelSize: this.step
+        }));
+      } else {
+        selection.update(clausePoint(field, value, { source: this }));
+      }
     } else if (isParam(this.selection)) {
       selection.update(value);
     }
@@ -14849,7 +15485,8 @@ var Table2 = class extends MosaicClient {
     width,
     maxWidth,
     height = 500,
-    rowBatch = 100
+    rowBatch = 100,
+    as
   } = {}) {
     super(filterBy);
     this.id = `table-${++_id3}`;
@@ -14861,12 +15498,14 @@ var Table2 = class extends MosaicClient {
     this.offset = 0;
     this.limit = +rowBatch;
     this.pending = false;
+    this.selection = as;
+    this.currentRow = -1;
     this.sortHeader = null;
     this.sortColumn = null;
     this.sortDesc = false;
     this.element = element || document.createElement("div");
     this.element.setAttribute("id", this.id);
-    this.element.value = this;
+    Object.defineProperty(this.element, "value", { value: this });
     if (typeof width === "number") this.element.style.width = `${width}px`;
     if (maxWidth) this.element.style.maxWidth = `${maxWidth}px`;
     this.element.style.maxHeight = `${height}px`;
@@ -14889,9 +15528,31 @@ var Table2 = class extends MosaicClient {
     this.tbl.appendChild(this.head);
     this.body = document.createElement("tbody");
     this.tbl.appendChild(this.body);
+    if (this.selection) {
+      this.body.addEventListener("pointerover", (evt) => {
+        const row = resolveRow(evt.target);
+        if (row > -1 && row !== this.currentRow) {
+          this.currentRow = row;
+          this.selection.update(this.clause([row]));
+        }
+      });
+      this.body.addEventListener("pointerleave", () => {
+        this.currentRow = -1;
+        this.selection.update(this.clause());
+      });
+    }
     this.style = document.createElement("style");
     this.element.appendChild(this.style);
   }
+  clause(rows = []) {
+    const { data, limit, schema } = this;
+    const fields = schema.map((s) => s.column);
+    const values = rows.map((row) => {
+      const { columns } = data[~~(row / limit)];
+      return fields.map((f) => columns[f][row % limit]);
+    });
+    return clausePoints(fields, values, { source: this });
+  }
   requestData(offset = 0) {
     this.offset = offset;
     const query = this.query(this.filterBy?.predicate(this));
@@ -14929,27 +15590,32 @@ var Table2 = class extends MosaicClient {
   queryResult(data) {
     if (!this.pending) {
       this.loaded = false;
+      this.data = [];
       this.body.replaceChildren();
+      this.offset = 0;
     }
-    this.data = data;
+    this.data.push(toDataColumns(data));
     return this;
   }
   update() {
     const { body, formats, data, schema, limit } = this;
     const nf = schema.length;
-    let count2 = 0;
-    for (const row of data) {
-      ++count2;
+    const n = data.length - 1;
+    const rowCount = limit * n;
+    const { numRows, columns } = data[n];
+    const cols = schema.map((s) => columns[s.column]);
+    for (let i = 0; i < numRows; ++i) {
       const tr = document.createElement("tr");
-      for (let i = 0; i < nf; ++i) {
-        const value = row[schema[i].column];
+      Object.assign(tr, { __row__: rowCount + i });
+      for (let j = 0; j < nf; ++j) {
+        const value = cols[j][i];
         const td = document.createElement("td");
-        td.innerText = value == null ? "" : formats[i](value);
+        td.innerText = value == null ? "" : formats[j](value);
         tr.appendChild(td);
       }
       body.appendChild(tr);
     }
-    if (count2 < limit) {
+    if (numRows < limit) {
       this.loaded = true;
     }
     this.pending = false;
@@ -14976,6 +15642,10 @@ var Table2 = class extends MosaicClient {
     this.requestData();
   }
 };
+function resolveRow(element) {
+  const p = element.parentElement;
+  return Object.hasOwn(p, "__row__") ? +p.__row__ : -1;
+}
 function formatof(base = {}, schema, locale) {
   return schema.map(({ column: column2, type }) => {
     if (column2 in base) {