@uwdata/mosaic-inputs 0.9.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:
@@ -4914,10 +4937,10 @@ var getDictionary = (data, index) => {
 var getInterval = (data, index) => data.type.unit === IntervalUnit.DAY_TIME ? getIntervalDayTime(data, index) : getIntervalYearMonth(data, index);
 var getIntervalDayTime = ({ values }, index) => values.subarray(2 * index, 2 * (index + 1));
 var getIntervalYearMonth = ({ values }, index) => {
-  const interval2 = values[index];
+  const interval = values[index];
   const int32s = new Int32Array(2);
-  int32s[0] = Math.trunc(interval2 / 12);
-  int32s[1] = Math.trunc(interval2 % 12);
+  int32s[0] = Math.trunc(interval / 12);
+  int32s[1] = Math.trunc(interval % 12);
   return int32s;
 };
 var getDurationSecond = ({ values }, index) => values[index];
@@ -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;
@@ -13040,37 +13095,12 @@ 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/util/index-columns.js
-var NO_INDEX = { from: NaN };
 function indexColumns(client) {
-  if (!client.filterIndexable) return NO_INDEX;
+  if (!client.filterIndexable) return null;
   const q = client.query();
   const from = getBaseTable(q);
-  if (typeof from !== "string" || !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 = {};
@@ -13168,10 +13198,11 @@ function indexColumns(client) {
         aggr.push({ [as]: agg`${op}("${as}")` });
         break;
       default:
-        if (g.has(as)) dims.push(as);
+        if (!aggregate) dims.push(as);
         else return null;
     }
   }
+  if (!aggr.length) return null;
   return { from, dims, aggr, aux };
 }
 function auxName(type, ...args) {
@@ -13304,125 +13335,153 @@ function regrInterceptExpr(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 {
   /**
-   *
-   * @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.
+   * 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(mc, { selection, temp = true }) {
-    this.mc = mc;
-    this.selection = selection;
+  constructor(coordinator2, {
+    enabled = true,
+    temp = true
+  } = {}) {
+    this.indexes = /* @__PURE__ */ new Map();
+    this.active = null;
     this.temp = temp;
-    this.reset();
+    this.mc = coordinator2;
+    this._enabled = enabled;
   }
-  reset() {
-    this.enabled = false;
-    this.clients = null;
-    this.indices = null;
-    this.active = null;
+  /**
+   * 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() {
-    if (this.indices) {
-      this.mc.cancel(Array.from(this.indices.values(), (index) => index?.result));
-      this.indices = null;
-    }
-  }
-  index(clients, activeClause) {
-    if (this.clients !== clients) {
-      const cols = Array.from(clients, indexColumns).filter((x2) => x2);
-      const from = cols[0]?.from;
-      this.enabled = cols.length && cols.every((c) => c.from === from);
-      this.clients = clients;
-      this.active = null;
-      this.clear();
-    }
-    if (!this.enabled) return false;
-    activeClause = activeClause || this.selection.active;
+    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 && source === this.active?.source) return true;
-    this.clear();
-    if (!source) return false;
-    const active = this.active = activeColumns(activeClause);
-    if (!active) return false;
-    const logger = this.mc.logger();
-    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, activeClause)) {
-        indices.set(client, null);
-        continue;
-      }
-      const index = indexColumns(client);
-      if (!index) {
-        continue;
-      }
-      const query = client.query(sel.predicate(client)).select({ ...active.columns, ...index.aux }).groupby(Object.keys(active.columns));
-      const [subq] = query.subqueries;
-      if (subq) {
-        const cols = Object.values(active.columns).flatMap((c) => c.columns);
-        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 }));
-      result.catch((e) => logger.error(e));
-      indices.set(client, { table: table2, result, order, ...index });
+    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));
     }
-    return true;
-  }
-  async update() {
-    const { clients, selection, active } = this;
-    const filter = active.predicate(selection.active.predicate);
-    return Promise.all(
-      Array.from(clients).map((client) => this.updateClient(client, filter))
-    );
-  }
-  async updateClient(client, filter) {
-    const { mc, indices, selection } = this;
-    if (!indices.has(client)) {
-      filter = selection.predicate(client);
-      return mc.updateClient(client, client.query(filter));
-    }
-    ;
-    const index = this.indices.get(client);
-    if (!index) return;
-    const { table: table2, dims, aggr, order = [] } = index;
-    const query = Query.select(dims, aggr).from(table2).groupby(dims).where(filter).orderby(order);
-    return mc.updateClient(client, query);
+    indexes.set(client, info);
+    return info;
   }
 };
 function activeColumns(clause) {
   const { source, meta } = clause;
-  let columns = clause.predicate?.columns;
-  if (!meta || !columns) return null;
-  const { type, scales: scales2, bin, pixelSize = 1 } = meta;
+  const clausePred = clause.predicate;
+  const clauseCols = clausePred?.columns;
   let predicate;
-  if (type === "interval" && scales2) {
+  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 == null)) return null;
-    if (bins.length === 1) {
+    if (bins.some((b) => !b)) {
+    } else if (bins.length === 1) {
       predicate = (p) => p ? isBetween("active0", p.range.map(bins[0])) : [];
-      columns = { active0: bins[0](clause.predicate.field) };
+      columns = { active0: bins[0](clausePred.field) };
     } else {
-      predicate = (p) => p ? and(p.children.map(({ range }, i) => isBetween(`active${i}`, range.map(bins[i])))) : [];
+      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)])
+        // @ts-ignore
+        clausePred.children.map((p, i) => [`active${i}`, bins[i](p.field)])
       );
     }
-  } else if (type === "point") {
-    predicate = (x2) => x2;
-    columns = Object.fromEntries(columns.map((col) => [`${col}`, asColumn(col)]));
-  } else {
-    return null;
   }
-  return { source, columns, predicate };
+  return { source: columns ? source : null, columns, predicate };
 }
 var BIN = { ceil: "CEIL", round: "ROUND" };
 function binInterval(scale, pixelSize, bin) {
@@ -13436,6 +13495,23 @@ function binInterval(scale, pixelSize, bin) {
   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) => {
@@ -13448,1290 +13524,1437 @@ function subqueryPushdown(query, cols) {
   };
   pushdown(query);
 }
-
-// ../core/src/util/AsyncDispatch.js
-var AsyncDispatch = class {
-  /**
-   * Create a new asynchronous dispatcher instance.
-   */
-  constructor() {
-    this._callbacks = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Add an event listener callback for the provided event type.
-   * @param {string} type The event type.
-   * @param {(value: *) => void | Promise} callback The event handler
-   *  callback function to add. If the callback has already been
-   *  added for the event type, this method has no effect.
-   */
-  addEventListener(type, callback) {
-    if (!this._callbacks.has(type)) {
-      this._callbacks.set(type, {
-        callbacks: /* @__PURE__ */ new Set(),
-        pending: null,
-        queue: new DispatchQueue()
-      });
-    }
-    const entry = this._callbacks.get(type);
-    entry.callbacks.add(callback);
-  }
+var DataCubeInfo = class {
   /**
-   * Remove an event listener callback for the provided event type.
-   * @param {string} type The event type.
-   * @param {(value: *) => void | Promise} callback The event handler
-   *  callback function to remove.
+   * Create a new DataCubeInfo instance.
+   * @param {object} options
    */
-  removeEventListener(type, callback) {
-    const entry = this._callbacks.get(type);
-    if (entry) {
-      entry.callbacks.delete(callback);
-    }
+  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;
   }
   /**
-   * Lifecycle method that returns the event value to emit.
-   * This default implementation simply returns the input value as-is.
-   * Subclasses may override this method to implement custom transformations
-   * prior to emitting an event value to all listeners.
-   * @param {string} type The event type.
-   * @param {*} value The event value.
-   * @returns The (possibly transformed) event value to emit.
+   * 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.
    */
-  willEmit(type, value) {
-    return value;
+  query(predicate) {
+    return this.select.clone().where(this.active.predicate(predicate));
   }
+};
+
+// ../core/src/util/query-result.js
+var QueryResult = class extends Promise {
   /**
-   * Lifecycle method that returns a filter function for updating the
-   * 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)
-   * @param {string} type The event type.
-   * @param {*} value The new event value that will be enqueued.
-   * @returns {(value: *) => boolean|null} A dispatch queue filter
-   *  function, or null if all unemitted event values should be filtered.
+   * Create a new query result Promise.
    */
-  emitQueueFilter(type, value) {
-    return null;
+  constructor() {
+    let resolve;
+    let reject;
+    super((r, e) => {
+      resolve = r;
+      reject = e;
+    });
+    this._resolve = resolve;
+    this._reject = reject;
   }
   /**
-   * Cancel all unemitted event values for the given event type.
-   * @param {string} type The event type.
+   * Resolve the result Promise with the provided value.
+   * @param {*} value The result value.
+   * @returns {this}
    */
-  cancel(type) {
-    const entry = this._callbacks.get(type);
-    entry?.queue.clear();
+  fulfill(value) {
+    this._resolve(value);
+    return this;
   }
   /**
-   * Emit an event value to listeners for the given event type.
-   * If a previous emit has not yet resolved, the event value
-   * will be queued to be emitted later.
-   * The actual event value given to listeners will be the result
-   * of passing the input value through the emitValue() method.
-   * @param {string} type The event type.
-   * @param {*} value The event value.
+   * Rejects the result Promise with the provided error.
+   * @param {*} error The error value.
+   * @returns {this}
    */
-  emit(type, value) {
-    const entry = this._callbacks.get(type) || {};
-    if (entry.pending) {
-      entry.queue.enqueue(value, this.emitQueueFilter(type, value));
-    } else {
-      const event = this.willEmit(type, value);
-      const { callbacks, queue } = entry;
-      if (callbacks?.size) {
-        const callbackValues = Array.from(callbacks, (cb) => cb(event));
-        entry.pending = Promise.allSettled(callbackValues).then(() => {
-          entry.pending = null;
-          if (!queue.isEmpty()) {
-            this.emit(type, queue.dequeue());
-          }
-        });
-      }
-    }
+  reject(error) {
+    this._reject(error);
+    return this;
   }
 };
-var DispatchQueue = class {
-  /**
-   * Create a new dispatch queue instance.
-   */
-  constructor() {
-    this.clear();
-  }
-  /**
-   * Clear the queue state of all event values.
-   */
-  clear() {
-    this.next = null;
-  }
-  /**
-   * Indicate if the queue is empty.
-   * @returns {boolean} True if queue is empty, false otherwise.
-   */
-  isEmpty() {
-    return !this.next;
+QueryResult.prototype.constructor = Promise;
+
+// ../core/src/QueryConsolidator.js
+function wait(callback) {
+  const method = typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame : typeof setImmediate !== "undefined" ? setImmediate : setTimeout;
+  return method(callback);
+}
+function consolidator(enqueue, cache, record) {
+  let pending = [];
+  let id = 0;
+  function run() {
+    const groups = entryGroups(pending, cache);
+    pending = [];
+    id = 0;
+    for (const group of groups) {
+      consolidate(group, enqueue, record);
+      processResults(group, cache);
+    }
   }
-  /**
-   * Add a new value to the queue, and optionally filter the
-   * current queue content in response.
-   * @param {*} value The value to add.
-   * @param {(value: *) => boolean} [filter] An optional filter
-   *  function to apply to existing queue content. If unspecified
-   *  or falsy, all previously queued values are removed. Otherwise,
-   *  the provided function is applied to all queue entries. The
-   *  entry is retained if the filter function returns a truthy value,
-   *  otherwise the entry is removed.
-   */
-  enqueue(value, filter) {
-    const tail = { value };
-    if (filter && this.next) {
-      let curr = this;
-      while (curr.next) {
-        if (filter(curr.next.value)) {
-          curr = curr.next;
-        } else {
-          curr.next = curr.next.next;
-        }
+  return {
+    add(entry, priority) {
+      if (entry.request.type === "arrow") {
+        id = id || wait(() => run());
+        pending.push({ entry, priority, index: pending.length });
+      } else {
+        enqueue(entry, priority);
       }
-      curr.next = tail;
-    } else {
-      this.next = tail;
     }
-  }
-  /**
-   * Remove and return the next queued event value.
-   * @returns {*} The next event value in the queue.
-   */
-  dequeue() {
-    const { next } = this;
-    this.next = next?.next;
-    return next?.value;
-  }
-};
-
-// ../core/src/util/distinct.js
-function distinct(a, b) {
-  return a === b ? false : a instanceof Date && b instanceof Date ? +a !== +b : Array.isArray(a) && Array.isArray(b) ? distinctArray(a, b) : true;
+  };
 }
-function distinctArray(a, b) {
-  if (a.length !== b.length) return true;
-  for (let i = 0; i < a.length; ++i) {
-    if (a[i] !== b[i]) return true;
+function entryGroups(entries, cache) {
+  const groups = [];
+  const groupMap = /* @__PURE__ */ new Map();
+  for (const query of entries) {
+    const { entry: { request } } = query;
+    const key = consolidationKey(request.query, cache);
+    if (!groupMap.has(key)) {
+      const list = [];
+      groups.push(list);
+      groupMap.set(key, list);
+    }
+    groupMap.get(key).push(query);
   }
-  return false;
+  return groups;
 }
-
-// ../core/src/Param.js
-function isParam(x2) {
-  return x2 instanceof Param;
+function consolidationKey(query, cache) {
+  const sql2 = `${query}`;
+  if (query instanceof Query && !cache.get(sql2)) {
+    if (
+      // @ts-ignore
+      query.orderby().length || query.where().length || // @ts-ignore
+      query.qualify().length || query.having().length
+    ) {
+      return sql2;
+    }
+    const q = query.clone().$select("*");
+    const groupby = query.groupby();
+    if (groupby.length) {
+      const map = {};
+      query.select().forEach(({ as, expr }) => map[as] = expr);
+      q.$groupby(groupby.map((e) => e instanceof Ref && map[e.column] || e));
+    }
+    return `${q}`;
+  } else {
+    return sql2;
+  }
 }
-var Param = class _Param extends AsyncDispatch {
-  /**
-   * Create a new Param instance.
-   * @param {*} value The initial value of the Param.
-   */
-  constructor(value) {
-    super();
-    this._value = value;
+function consolidate(group, enqueue, record) {
+  if (shouldConsolidate(group)) {
+    enqueue({
+      request: {
+        type: "arrow",
+        cache: false,
+        record: false,
+        query: group.query = consolidatedQuery(group, record)
+      },
+      result: group.result = new QueryResult()
+    });
+  } else {
+    for (const { entry, priority } of group) {
+      enqueue(entry, priority);
+    }
   }
-  /**
-   * Create a new Param instance with the given initial value.
-   * @param {*} value The initial value of the Param.
-   * @returns {Param} The new Param instance.
-   */
-  static value(value) {
-    return new _Param(value);
+}
+function shouldConsolidate(group) {
+  if (group.length > 1) {
+    const sql2 = `${group[0].entry.request.query}`;
+    for (let i = 1; i < group.length; ++i) {
+      if (sql2 !== `${group[i].entry.request.query}`) {
+        return true;
+      }
+    }
   }
-  /**
-   * Create a new Param instance over an array of initial values,
-   * which may contain nested Params.
-   * @param {*} values The initial values of the Param.
-   * @returns {Param} The new Param instance.
-   */
-  static array(values) {
-    if (values.some((v) => isParam(v))) {
-      const p = new _Param();
-      const update2 = () => {
-        p.update(values.map((v) => isParam(v) ? v.value : v));
-      };
-      update2();
-      values.forEach((v) => isParam(v) ? v.addEventListener("value", update2) : 0);
-      return p;
+  return false;
+}
+function consolidatedQuery(group, record) {
+  const maps = group.maps = [];
+  const fields = /* @__PURE__ */ new Map();
+  for (const item of group) {
+    const { query: query2 } = item.entry.request;
+    const fieldMap = [];
+    maps.push(fieldMap);
+    for (const { as, expr } of query2.select()) {
+      const e = `${expr}`;
+      if (!fields.has(e)) {
+        fields.set(e, [`col${fields.size}`, expr]);
+      }
+      const [name] = fields.get(e);
+      fieldMap.push([name, as]);
     }
-    return new _Param(values);
+    record(`${query2}`);
   }
-  /**
-   * The current value of the Param.
-   */
-  get value() {
-    return this._value;
+  const query = group[0].entry.request.query.clone();
+  const groupby = query.groupby();
+  if (groupby.length) {
+    const map = {};
+    group.maps[0].forEach(([name, as]) => map[as] = name);
+    query.$groupby(groupby.map((e) => e instanceof Ref && map[e.column] || e));
   }
-  /**
-   * Update the Param value
-   * @param {*} value The new value of the Param.
-   * @param {object} [options] The update options.
-   * @param {boolean} [options.force] A boolean flag indicating if the Param
-   *  should emit a 'value' event even if the internal value is unchanged.
-   * @returns {this} This Param instance.
-   */
-  update(value, { force } = {}) {
-    const shouldEmit = distinct(this._value, value) || force;
-    if (shouldEmit) {
-      this.emit("value", value);
-    } else {
-      this.cancel("value");
+  return query.$select(Array.from(fields.values()));
+}
+async function processResults(group, cache) {
+  const { maps, query, result } = group;
+  if (!maps) return;
+  let data;
+  try {
+    data = await result;
+  } catch (err) {
+    for (const { entry } of group) {
+      entry.result.reject(err);
     }
-    return this;
+    return;
   }
-  /**
-   * Upon value-typed updates, sets the current value to the input value
-   * immediately prior to the event value being emitted to listeners.
-   * @param {string} type The event type.
-   * @param {*} value The input event value.
-   * @returns {*} The input event value.
-   */
-  willEmit(type, value) {
-    if (type === "value") {
-      this._value = value;
+  const describe = isDescribeQuery(query);
+  group.forEach(({ entry }, index) => {
+    const { request, result: result2 } = entry;
+    const map = maps[index];
+    const extract = describe && map ? filterResult(data, map) : map ? projectResult(data, map) : data;
+    if (request.cache) {
+      cache.set(String(request.query), extract);
     }
-    return value;
-  }
-};
-
-// ../core/src/Selection.js
-function isSelection(x2) {
-  return x2 instanceof Selection;
+    result2.fulfill(extract);
+  });
 }
-var Selection = class _Selection extends Param {
-  /**
-   * Create a new Selection instance with an
-   * intersect (conjunction) resolution strategy.
-   * @param {object} [options] The selection options.
-   * @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.
-   * @returns {Selection} The new Selection instance.
-   */
-  static intersect({ cross = false } = {}) {
-    return new _Selection(new SelectionResolver({ cross }));
-  }
-  /**
-   * Create a new Selection instance with a
-   * union (disjunction) resolution strategy.
-   * @param {object} [options] The selection options.
-   * @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.
-   * @returns {Selection} The new Selection instance.
-   */
-  static union({ cross = false } = {}) {
-    return new _Selection(new SelectionResolver({ cross, union: true }));
-  }
-  /**
-   * Create a new Selection instance with a singular resolution strategy
-   * that keeps only the most recent selection clause.
-   * @param {object} [options] The selection options.
-   * @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.
-   * @returns {Selection} The new Selection instance.
-   */
-  static single({ cross = false } = {}) {
-    return new _Selection(new SelectionResolver({ cross, single: true }));
-  }
-  /**
-   * Create a new Selection instance with a
-   * cross-filtered intersect resolution strategy.
-   * @returns {Selection} The new Selection instance.
-   */
-  static crossfilter() {
-    return new _Selection(new SelectionResolver({ cross: true }));
-  }
-  /**
-   * Create a new Selection instance.
-   * @param {SelectionResolver} resolver The selection resolution
-   *  strategy to apply.
-   */
-  constructor(resolver = new SelectionResolver()) {
-    super([]);
-    this._resolved = this._value;
-    this._resolver = resolver;
-  }
-  /**
-   * Create a cloned copy of this Selection instance.
-   * @returns {Selection} A clone of this selection.
-   */
-  clone() {
-    const s = new _Selection(this._resolver);
-    s._value = s._resolved = this._value;
-    return s;
-  }
-  /**
-   * Create a clone of this Selection with clauses corresponding
-   * to the provided source removed.
-   * @param {*} source The clause source to remove.
-   * @returns {Selection} A cloned and updated Selection.
-   */
-  remove(source) {
-    const s = this.clone();
-    s._value = s._resolved = s._resolver.resolve(this._resolved, { source });
-    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;
+function projectResult(data, map) {
+  const cols = {};
+  for (const [name, as] of map) {
+    cols[as] = data.getChild(name);
   }
-  /**
-   * The current active (most recently updated) selection clause.
-   */
-  get active() {
-    return this.clauses.active;
+  return new data.constructor(cols);
+}
+function filterResult(data, map) {
+  const lookup = new Map(map);
+  const result = [];
+  for (const d of data) {
+    if (lookup.has(d.column_name)) {
+      result.push({ ...d, column_name: lookup.get(d.column_name) });
+    }
   }
-  /**
-   * The value corresponding to the current active selection clause.
-   * This method ensures compatibility where a normal Param is expected.
-   */
-  get value() {
-    return this.active?.value;
+  return result;
+}
+
+// ../core/src/util/cache.js
+var requestIdle = typeof requestIdleCallback !== "undefined" ? requestIdleCallback : setTimeout;
+var voidCache = () => ({
+  get: () => void 0,
+  set: (key, value) => value,
+  clear: () => {
   }
-  /**
-   * 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.
-   */
-  valueFor(source) {
-    return this.clauses.find((c) => c.source === source)?.value;
+});
+function lruCache({
+  max: max2 = 1e3,
+  // max entries
+  ttl = 3 * 60 * 60 * 1e3
+  // time-to-live, default 3 hours
+} = {}) {
+  let cache = /* @__PURE__ */ new Map();
+  function evict() {
+    const expire = performance.now() - ttl;
+    let lruKey = null;
+    let lruLast = Infinity;
+    for (const [key, value] of cache) {
+      const { last: last2 } = value;
+      if (last2 < lruLast) {
+        lruKey = key;
+        lruLast = last2;
+      }
+      if (expire > last2) {
+        cache.delete(key);
+      }
+    }
+    if (lruKey) {
+      cache.delete(lruKey);
+    }
   }
-  /**
-   * Emit an activate event with the given selection clause.
-   * @param {*} clause The clause repesenting the potential activation.
-   */
-  activate(clause) {
-    this.emit("activate", clause);
+  return {
+    get(key) {
+      const entry = cache.get(key);
+      if (entry) {
+        entry.last = performance.now();
+        return entry.value;
+      }
+    },
+    set(key, value) {
+      cache.set(key, { last: performance.now(), value });
+      if (cache.size > max2) requestIdle(evict);
+      return value;
+    },
+    clear() {
+      cache = /* @__PURE__ */ new Map();
+    }
+  };
+}
+
+// ../core/src/util/priority-queue.js
+function priorityQueue(ranks) {
+  const queue = Array.from(
+    { length: ranks },
+    () => ({ head: null, tail: null })
+  );
+  return {
+    /**
+     * Indicate if the queue is empty.
+     * @returns [boolean] true if empty, false otherwise.
+     */
+    isEmpty() {
+      return queue.every((list) => !list.head);
+    },
+    /**
+     * Insert an item into the queue with a given priority rank.
+     * @param {*} item The item to add.
+     * @param {number} rank The integer priority rank.
+     *  Priority ranks are integers starting at zero.
+     *  Lower ranks indicate higher priority.
+     */
+    insert(item, rank2) {
+      const list = queue[rank2];
+      if (!list) {
+        throw new Error(`Invalid queue priority rank: ${rank2}`);
+      }
+      const node = { item, next: null };
+      if (list.head === null) {
+        list.head = list.tail = node;
+      } else {
+        list.tail = list.tail.next = node;
+      }
+    },
+    /**
+     * Remove a set of items from the queue, regardless of priority rank.
+     * If a provided item is not in the queue it will be ignored.
+     * @param {(item: *) => boolean} test A predicate function to test
+     * 	if an item should be removed (true to drop, false to keep).
+     */
+    remove(test) {
+      for (const list of queue) {
+        let { head, tail } = list;
+        for (let prev = null, curr = head; curr; prev = curr, curr = curr.next) {
+          if (test(curr.item)) {
+            if (curr === head) {
+              head = curr.next;
+            } else {
+              prev.next = curr.next;
+            }
+            if (curr === tail) tail = prev || head;
+          }
+        }
+        list.head = head;
+        list.tail = tail;
+      }
+    },
+    /**
+     * Remove and return the next highest priority item.
+     * @returns {*} The next item in the queue,
+     *  or undefined if this queue is empty.
+     */
+    next() {
+      for (const list of queue) {
+        const { head } = list;
+        if (head !== null) {
+          list.head = head.next;
+          if (list.tail === head) {
+            list.tail = null;
+          }
+          return head.item;
+        }
+      }
+    }
+  };
+}
+
+// ../core/src/QueryManager.js
+var Priority = { High: 0, Normal: 1, Low: 2 };
+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;
   }
-  /**
-   * Update the selection with a new selection clause.
-   * @param {*} clause The selection clause to add.
-   * @returns {this} This Selection instance.
-   */
-  update(clause) {
-    this._resolved = this._resolver.resolve(this._resolved, clause, true);
-    this._resolved.active = clause;
-    return super.update(this._resolved);
+  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();
+    });
   }
-  /**
-   * Upon value-typed updates, sets the current clause list to the
-   * input value and returns the active clause value.
-   * @param {string} type The event type.
-   * @param {*} value The input event value.
-   * @returns {*} For value-typed events, returns the active clause
-   *  values. Otherwise returns the input event value as-is.
-   */
-  willEmit(type, value) {
-    if (type === "value") {
-      this._value = value;
-      return this.value;
+  enqueue(entry, priority = Priority.Normal) {
+    this.queue.insert(entry, priority);
+    this.next();
+  }
+  recordQuery(sql2) {
+    if (this.recorders.length && sql2) {
+      this.recorders.forEach((rec) => rec.add(sql2));
     }
-    return value;
   }
-  /**
-   * Upon value-typed updates, returns a dispatch queue filter function.
-   * The return value depends on the selection resolution strategy.
-   * @param {string} type The event type.
-   * @param {*} value The new event value that will be enqueued.
-   * @returns {(value: *) => boolean|null} For value-typed events,
-   *  returns a dispatch queue filter function. Otherwise returns null.
-   */
-  emitQueueFilter(type, value) {
-    return type === "value" ? this._resolver.queueFilter(value) : null;
+  async submit(request, result) {
+    try {
+      const { query, type, cache = false, record = true, options } = request;
+      const sql2 = query ? `${query}` : null;
+      if (record) {
+        this.recordQuery(sql2);
+      }
+      if (cache) {
+        const cached = this.clientCache.get(sql2);
+        if (cached) {
+          this._logger.debug("Cache");
+          result.fulfill(cached);
+          return;
+        }
+      }
+      const t0 = performance.now();
+      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);
+    }
   }
-  /**
-   * Indicates if a selection clause should not be applied to a given client.
-   * The return value depends on the selection resolution strategy.
-   * @param {*} client The selection clause.
-   * @param {*} clause The client to test.
-   * @returns True if the client should be skipped, false otherwise.
-   */
-  skip(client, clause) {
-    return this._resolver.skip(client, clause);
+  cache(value) {
+    return value !== void 0 ? this.clientCache = value === true ? lruCache() : value || voidCache() : this.clientCache;
   }
-  /**
-   * Return a selection query predicate for the given client.
-   * @param {*} client The client whose data may be filtered.
-   * @param {boolean} [noSkip=false] Disable skipping of active
-   *  cross-filtered sources. If set true, the source of the active
-   *  clause in a cross-filtered selection will not be skipped.
-   * @returns {*} The query predicate for filtering client data,
-   *  based on the current state of this selection.
-   */
-  predicate(client, noSkip = false) {
-    const { clauses } = this;
-    const active = noSkip ? null : clauses.active;
-    return this._resolver.predicate(clauses, active, client);
+  logger(value) {
+    return value ? this._logger = value : this._logger;
   }
-};
-var SelectionResolver = class {
-  /**
-   * Create a new selection resolved instance.
-   * @param {object} [options] The resolution strategy options.
-   * @param {boolean} [options.union=false] Boolean flag to indicate a union strategy.
-   *  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.
-   */
-  constructor({ union, cross, single } = {}) {
-    this.union = !!union;
-    this.cross = !!cross;
-    this.single = !!single;
+  logQueries(value) {
+    return value !== void 0 ? this._logQueries = !!value : this._logQueries;
   }
-  /**
-   * Resolve a list of selection clauses according to the resolution strategy.
-   * @param {*[]} clauseList An array of selection clauses.
-   * @param {*} clause A new selection clause to add.
-   * @returns {*[]} An updated array of selection clauses.
-   */
-  resolve(clauseList, clause, reset = false) {
-    const { source, predicate } = clause;
-    const filtered = clauseList.filter((c) => source !== c.source);
-    const clauses = this.single ? [] : filtered;
-    if (this.single && reset) filtered.forEach((c) => c.source?.reset?.());
-    if (predicate) clauses.push(clause);
-    return clauses;
+  connector(connector) {
+    return connector ? this.db = connector : this.db;
   }
-  /**
-   * Indicates if a selection clause should not be applied to a given client.
-   * The return value depends on the resolution strategy.
-   * @param {*} client The selection clause.
-   * @param {*} clause The client to test.
-   * @returns True if the client should be skipped, false otherwise.
-   */
-  skip(client, clause) {
-    return this.cross && clause?.clients?.has(client);
+  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;
+    }
   }
-  /**
-   * Return a selection query predicate for the given client.
-   * @param {*[]} clauseList An array of selection clauses.
-   * @param {*} active The current active selection clause.
-   * @param {*} client The client whose data may be filtered.
-   * @returns {*} The query predicate for filtering client data,
-   *  based on the current state of this selection.
-   */
-  predicate(clauseList, active, client) {
-    const { union } = this;
-    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;
+  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;
   }
-  /**
-   * Returns a filter function for queued selection updates.
-   * @param {*} value The new event value that will be enqueued.
-   * @returns {(value: *) => boolean|null} A dispatch queue filter
-   *  function, or null if all unemitted event values should be filtered.
-   */
-  queueFilter(value) {
-    if (this.cross) {
-      const source = value.active?.source;
-      return (clauses) => clauses.active?.source !== source;
+  cancel(requests) {
+    const set = new Set(requests);
+    if (set.size) {
+      this.queue.remove(({ result }) => set.has(result));
     }
-    return null;
   }
-};
-
-// ../core/src/FilterGroup.js
-var FilterGroup = class {
-  /**
-   * @param {Coordinator} coordinator The Mosaic coordinator.
-   * @param {Selection} selection The shared filter selection.
-   * @param {object|boolean} index Boolean flag or options hash for
-   *  a data cube indexer. Falsy values disable indexing.
-   */
-  constructor(coordinator2, selection, index = true) {
-    this.mc = coordinator2;
-    this.selection = selection;
-    this.clients = /* @__PURE__ */ new Set();
-    this.indexer = null;
-    this.index(index);
-    const { value, activate } = this.handlers = {
-      value: () => this.update(),
-      activate: (clause) => {
-        this.indexer?.index(this.clients, clause);
+  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;
       }
     };
-    selection.addEventListener("value", value);
-    selection.addEventListener("activate", activate);
-  }
-  finalize() {
-    const { value, activate } = this.handlers;
-    this.selection.removeEventListener("value", value);
-    this.selection.removeEventListener("activate", activate);
-  }
-  index(state) {
-    const { selection } = this;
-    const { resolver } = selection;
-    this.indexer = state && (resolver.single || !resolver.union) ? new DataCubeIndexer(this.mc, { ...state, selection }) : null;
-  }
-  reset() {
-    this.indexer?.reset();
-  }
-  add(client) {
-    (this.clients = new Set(this.clients)).add(client);
-    return this;
-  }
-  remove(client) {
-    if (this.clients.has(client)) {
-      (this.clients = new Set(this.clients)).delete(client);
-    }
-    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.
-   */
-  update() {
-    const { mc, indexer, clients, selection } = this;
-    const hasIndex = indexer?.index(clients);
-    return hasIndex ? indexer.update() : defaultUpdate(mc, clients, selection);
+    this.recorders.push(recorder);
+    return recorder;
   }
 };
-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)
-  });
+// ../core/src/util/js-type.js
+function jsType(type) {
+  switch (type) {
+    case "BIGINT":
+    case "HUGEINT":
+    case "INTEGER":
+    case "SMALLINT":
+    case "TINYINT":
+    case "UBIGINT":
+    case "UINTEGER":
+    case "USMALLINT":
+    case "UTINYINT":
+    case "DOUBLE":
+    case "FLOAT":
+    case "REAL":
+      return "number";
+    case "DATE":
+    case "TIMESTAMP":
+    case "TIMESTAMPTZ":
+    case "TIMESTAMP WITH TIME ZONE":
+    case "TIME":
+    case "TIMESTAMP_NS":
+      return "date";
+    case "BOOLEAN":
+      return "boolean";
+    case "VARCHAR":
+    case "UUID":
+    case "JSON":
+      return "string";
+    case "ARRAY":
+    case "LIST":
+      return "array";
+    case "BLOB":
+    case "STRUCT":
+    case "MAP":
+    case "GEOMETRY":
+      return "object";
+    default:
+      if (type.startsWith("DECIMAL")) {
+        return "number";
+      } else if (type.startsWith("STRUCT") || type.startsWith("MAP")) {
+        return "object";
+      } else if (type.endsWith("]")) {
+        return "array";
+      }
+      throw new Error(`Unsupported type: ${type}`);
+  }
 }
 
-// ../core/src/QueryConsolidator.js
-function wait(callback) {
-  const method = typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame : typeof setImmediate !== "undefined" ? setImmediate : setTimeout;
-  return method(callback);
+// ../core/src/util/convert-arrow.js
+function isArrowTable(values) {
+  return typeof values?.getChild === "function";
 }
-function consolidator(enqueue, cache, record) {
-  let pending = [];
-  let id = 0;
-  function run() {
-    const groups = entryGroups(pending, cache);
-    pending = [];
-    id = 0;
-    for (const group of groups) {
-      consolidate(group, enqueue, record);
-      processResults(group, cache);
-    }
+function convertArrowValue(type) {
+  if (DataType.isTimestamp(type)) {
+    return (v) => v == null ? v : new Date(v);
   }
-  return {
-    add(entry, priority) {
-      if (entry.request.type === "arrow") {
-        id = id || wait(() => run());
-        pending.push({ entry, priority, index: pending.length });
-      } else {
-        enqueue(entry, priority);
-      }
-    }
-  };
-}
-function entryGroups(entries, cache) {
-  const groups = [];
-  const groupMap = /* @__PURE__ */ new Map();
-  for (const query of entries) {
-    const { entry: { request } } = query;
-    const key = consolidationKey(request.query, cache);
-    if (!groupMap.has(key)) {
-      const list = [];
-      groups.push(list);
-      groupMap.set(key, list);
-    }
-    groupMap.get(key).push(query);
+  if (DataType.isInt(type) && type.bitWidth >= 64) {
+    return (v) => v == null ? v : Number(v);
   }
-  return groups;
-}
-function consolidationKey(query, cache) {
-  const sql2 = `${query}`;
-  if (query instanceof Query && !cache.get(sql2)) {
-    if (
-      // @ts-ignore
-      query.orderby().length || query.where().length || // @ts-ignore
-      query.qualify().length || query.having().length
-    ) {
-      return sql2;
-    }
-    const q = query.clone().$select("*");
-    const groupby = query.groupby();
-    if (groupby.length) {
-      const map = {};
-      query.select().forEach(({ as, expr }) => map[as] = expr);
-      q.$groupby(groupby.map((e) => e instanceof Ref && map[e.column] || e));
-    }
-    return `${q}`;
-  } else {
-    return sql2;
+  if (DataType.isDecimal(type)) {
+    const scale = 1 / Math.pow(10, type.scale);
+    return (v) => v == null ? v : decimalToNumber(v, scale);
   }
+  return (v) => v;
 }
-function consolidate(group, enqueue, record) {
-  if (shouldConsolidate(group)) {
-    enqueue({
-      request: {
-        type: "arrow",
-        cache: false,
-        record: false,
-        query: group.query = consolidatedQuery(group, record)
-      },
-      result: group.result = queryResult()
-    });
-  } else {
-    for (const { entry, priority } of group) {
-      enqueue(entry, priority);
+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;
   }
-}
-function shouldConsolidate(group) {
-  if (group.length > 1) {
-    const sql2 = `${group[0].entry.request.query}`;
-    for (let i = 1; i < group.length; ++i) {
-      if (sql2 !== `${group[i].entry.request.query}`) {
-        return true;
-      }
+  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;
   }
-  return false;
-}
-function consolidatedQuery(group, record) {
-  const maps = group.maps = [];
-  const fields = /* @__PURE__ */ new Map();
-  for (const item of group) {
-    const { query: query2 } = item.entry.request;
-    const fieldMap = [];
-    maps.push(fieldMap);
-    for (const { as, expr } of query2.select()) {
-      const e = `${expr}`;
-      if (!fields.has(e)) {
-        fields.set(e, [`col${fields.size}`, expr]);
-      }
-      const [name] = fields.get(e);
-      fieldMap.push([name, as]);
+  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);
     }
-    record(`${query2}`);
+    return array;
   }
-  const query = group[0].entry.request.query.clone();
-  const groupby = query.groupby();
-  if (groupby.length) {
-    const map = {};
-    group.maps[0].forEach(([name, as]) => map[as] = name);
-    query.$groupby(groupby.map((e) => e instanceof Ref && map[e.column] || e));
+  if (column2.nullCount) {
+    return Array.from(column2);
   }
-  return query.$select(Array.from(fields.values()));
+  return column2.toArray();
 }
-async function processResults(group, cache) {
-  const { maps, query, result } = group;
-  if (!maps) return;
-  let data;
-  try {
-    data = await result;
-  } catch (err) {
-    for (const { entry } of group) {
-      entry.result.reject(err);
-    }
-    return;
-  }
-  const describe = isDescribeQuery(query);
-  group.forEach(({ entry }, index) => {
-    const { request, result: result2 } = entry;
-    const map = maps[index];
-    const extract = describe && map ? filterResult(data, map) : map ? projectResult(data, map) : data;
-    if (request.cache) {
-      cache.set(String(request.query), extract);
+var BASE32 = Array.from(
+  { length: 8 },
+  (_, i) => Math.pow(2, i * 32)
+);
+function decimalToNumber(v, scale) {
+  const n = v.length;
+  let x2 = 0;
+  if (v.signed && (v[n - 1] | 0) < 0) {
+    for (let i = 0; i < n; ++i) {
+      x2 += ~v[i] * BASE32[i];
     }
-    result2.fulfill(extract);
-  });
-}
-function projectResult(data, map) {
-  const cols = {};
-  for (const [name, as] of map) {
-    cols[as] = data.getChild(name);
-  }
-  return new data.constructor(cols);
-}
-function filterResult(data, map) {
-  const lookup = new Map(map);
-  const result = [];
-  for (const d of data) {
-    if (lookup.has(d.column_name)) {
-      result.push({ ...d, column_name: lookup.get(d.column_name) });
+    x2 = -(x2 + 1);
+  } else {
+    for (let i = 0; i < n; ++i) {
+      x2 += v[i] * BASE32[i];
     }
   }
-  return result;
+  return x2 * scale;
 }
 
-// ../core/src/util/cache.js
-var requestIdle = typeof requestIdleCallback !== "undefined" ? requestIdleCallback : setTimeout;
-var voidCache = () => ({
-  get: () => void 0,
-  set: (key, value) => value,
-  clear: () => {
-  }
-});
-function lruCache({
-  max: max2 = 1e3,
-  // max entries
-  ttl = 3 * 60 * 60 * 1e3
-  // time-to-live, default 3 hours
-} = {}) {
-  let cache = /* @__PURE__ */ new Map();
-  function evict() {
-    const expire = performance.now() - ttl;
-    let lruKey = null;
-    let lruLast = Infinity;
-    for (const [key, value] of cache) {
-      const { last: last2 } = value;
-      if (last2 < lruLast) {
-        lruKey = key;
-        lruLast = last2;
-      }
-      if (expire > last2) {
-        cache.delete(key);
-      }
-    }
-    if (lruKey) {
-      cache.delete(lruKey);
-    }
+// ../core/src/util/field-info.js
+var Count = "count";
+var Nulls = "nulls";
+var Max = "max";
+var Min = "min";
+var Distinct = "distinct";
+var statMap = {
+  [Count]: count,
+  [Distinct]: (column2) => count(column2).distinct(),
+  [Max]: max,
+  [Min]: min,
+  [Nulls]: (column2) => count().where(isNull(column2))
+};
+function summarize(table2, column2, stats) {
+  return Query.from(table2).select(Array.from(stats, (s) => [s, statMap[s](column2)]));
+}
+async function queryFieldInfo(mc, fields) {
+  if (fields.length === 1 && `${fields[0].column}` === "*") {
+    return getTableInfo(mc, fields[0].table);
+  } else {
+    return (await Promise.all(fields.map((f) => getFieldInfo(mc, f)))).filter((x2) => x2);
   }
-  return {
-    get(key) {
-      const entry = cache.get(key);
-      if (entry) {
-        entry.last = performance.now();
-        return entry.value;
-      }
-    },
-    set(key, value) {
-      cache.set(key, { last: performance.now(), value });
-      if (cache.size > max2) requestIdle(evict);
-      return value;
-    },
-    clear() {
-      cache = /* @__PURE__ */ new Map();
-    }
+}
+async function getFieldInfo(mc, { table: table2, column: column2, stats }) {
+  const q = Query.from({ source: table2 }).select({ column: column2 }).groupby(column2.aggregate ? sql`ALL` : []);
+  const [desc2] = Array.from(await mc.query(Query.describe(q)));
+  const info = {
+    table: table2,
+    column: `${column2}`,
+    sqlType: desc2.column_type,
+    type: jsType(desc2.column_type),
+    nullable: desc2.null === "YES"
   };
+  if (!(stats?.length || stats?.size)) return info;
+  const result = await mc.query(
+    summarize(table2, column2, stats),
+    { persist: true }
+  );
+  for (let i = 0; i < result.numCols; ++i) {
+    const { name } = result.schema.fields[i];
+    const child = result.getChildAt(i);
+    const convert = convertArrowValue(child.type);
+    info[name] = convert(child.get(0));
+  }
+  return info;
+}
+async function getTableInfo(mc, table2) {
+  const result = await mc.query(`DESCRIBE ${asRelation(table2)}`);
+  return Array.from(result).map((desc2) => ({
+    table: table2,
+    column: desc2.column_name,
+    sqlType: desc2.column_type,
+    type: jsType(desc2.column_type),
+    nullable: desc2.null === "YES"
+  }));
 }
 
-// ../core/src/util/priority-queue.js
-function priorityQueue(ranks) {
-  const queue = Array.from(
-    { length: ranks },
-    () => ({ head: null, tail: null })
-  );
+// ../core/src/util/void-logger.js
+function voidLogger() {
   return {
-    /**
-     * Indicate if the queue is empty.
-     * @returns [boolean] true if empty, false otherwise.
-     */
-    isEmpty() {
-      return queue.every((list) => !list.head);
+    debug() {
     },
-    /**
-     * Insert an item into the queue with a given priority rank.
-     * @param {*} item The item to add.
-     * @param {number} rank The integer priority rank.
-     *  Priority ranks are integers starting at zero.
-     *  Lower ranks indicate higher priority.
-     */
-    insert(item, rank2) {
-      const list = queue[rank2];
-      if (!list) {
-        throw new Error(`Invalid queue priority rank: ${rank2}`);
-      }
-      const node = { item, next: null };
-      if (list.head === null) {
-        list.head = list.tail = node;
-      } else {
-        list.tail = list.tail.next = node;
-      }
+    info() {
     },
-    /**
-     * Remove a set of items from the queue, regardless of priority rank.
-     * If a provided item is not in the queue it will be ignored.
-     * @param {(item: *) => boolean} test A predicate function to test
-     * 	if an item should be removed (true to drop, false to keep).
-     */
-    remove(test) {
-      for (const list of queue) {
-        let { head, tail } = list;
-        for (let prev = null, curr = head; curr; prev = curr, curr = curr.next) {
-          if (test(curr.item)) {
-            if (curr === head) {
-              head = curr.next;
-            } else {
-              prev.next = curr.next;
-            }
-            if (curr === tail) tail = prev || head;
-          }
-        }
-        list.head = head;
-        list.tail = tail;
-      }
+    log() {
     },
-    /**
-     * Remove and return the next highest priority item.
-     * @returns {*} The next item in the queue,
-     *  or undefined if this queue is empty.
-     */
-    next() {
-      for (const list of queue) {
-        const { head } = list;
-        if (head !== null) {
-          list.head = head.next;
-          if (list.tail === head) {
-            list.tail = null;
-          }
-          return head.item;
-        }
-      }
+    warn() {
+    },
+    error() {
     }
   };
 }
 
-// ../core/src/QueryManager.js
-var Priority = { High: 0, Normal: 1, Low: 2 };
-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;
+// ../core/src/Coordinator.js
+var _instance;
+function coordinator(instance8) {
+  if (instance8) {
+    _instance = instance8;
+  } else if (_instance == null) {
+    _instance = new Coordinator();
   }
-  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();
-    });
+  return _instance;
+}
+var Coordinator = class {
+  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.databaseConnector(db);
+    this.clear();
   }
-  enqueue(entry, priority = Priority.Normal) {
-    this.queue.insert(entry, priority);
-    this.next();
+  /**
+   * 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.
+   */
+  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.clients = /* @__PURE__ */ new Set();
+    }
+    if (cache) this.manager.cache().clear();
   }
-  recordQuery(sql2) {
-    if (this.recorders.length && sql2) {
-      this.recorders.forEach((rec) => rec.add(sql2));
+  /**
+   * 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;
   }
-  async submit(request, result) {
-    try {
-      const { query, type, cache = false, record = true, options } = request;
-      const sql2 = query ? `${query}` : null;
-      if (record) {
-        this.recordQuery(sql2);
-      }
-      if (cache) {
-        const cached = this.clientCache.get(sql2);
-        if (cached) {
-          this._logger.debug("Cache");
-          result.fulfill(cached);
-          return;
-        }
+  // -- 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,
+    priority = Priority.Normal,
+    ...options
+  } = {}) {
+    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 });
+  }
+  createBundle(name, queries, priority = Priority.Low) {
+    const options = { name, queries };
+    return this.manager.request({ type: "create-bundle", options }, priority);
+  }
+  loadBundle(name, priority = Priority.High) {
+    const options = { name };
+    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) => {
+        this._logger.error(err);
+        client.queryError(err);
       }
-      const t0 = performance.now();
-      if (this._logQueries) {
-        this._logger.debug("Query", { type, sql: sql2, ...options });
+    ).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.dataCubeIndexer.clear();
+    return query ? this.updateClient(client, query) : client.update();
+  }
+  /**
+   * Connect a client to the coordinator.
+   * @param {import('./MosaicClient.js').MosaicClient} client The Mosaic
+   *  client to connect.
+   */
+  async connect(client) {
+    const { clients } = this;
+    if (clients.has(client)) {
+      throw new Error("Client already connected.");
+    }
+    clients.add(client);
+    client.coordinator = this;
+    const fields = client.fields();
+    if (fields?.length) {
+      client.fieldInfo(await queryFieldInfo(this, fields));
+    }
+    connectSelection(this, client.filterBy, client);
+    client.requestQuery();
+  }
+  /**
+   * Disconnect a client from the coordinator.
+   * @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);
+    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);
       }
-      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);
+    };
+    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 {
+  /**
+   * Create a new asynchronous dispatcher instance.
+   */
+  constructor() {
+    this._callbacks = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Add an event listener callback for the provided event type.
+   * @param {string} type The event type.
+   * @param {(value: *) => void | Promise} callback The event handler
+   *  callback function to add. If the callback has already been
+   *  added for the event type, this method has no effect.
+   */
+  addEventListener(type, callback) {
+    if (!this._callbacks.has(type)) {
+      this._callbacks.set(type, {
+        callbacks: /* @__PURE__ */ new Set(),
+        pending: null,
+        queue: new DispatchQueue()
+      });
     }
+    const entry = this._callbacks.get(type);
+    entry.callbacks.add(callback);
   }
-  cache(value) {
-    return value !== void 0 ? this.clientCache = value === true ? lruCache() : value || voidCache() : this.clientCache;
+  /**
+   * Remove an event listener callback for the provided event type.
+   * @param {string} type The event type.
+   * @param {(value: *) => void | Promise} callback The event handler
+   *  callback function to remove.
+   */
+  removeEventListener(type, callback) {
+    const entry = this._callbacks.get(type);
+    if (entry) {
+      entry.callbacks.delete(callback);
+    }
   }
-  logger(value) {
-    return value ? this._logger = value : this._logger;
+  /**
+   * Lifecycle method that returns the event value to emit.
+   * This default implementation simply returns the input value as-is.
+   * Subclasses may override this method to implement custom transformations
+   * prior to emitting an event value to all listeners.
+   * @param {string} type The event type.
+   * @param {*} value The event value.
+   * @returns The (possibly transformed) event value to emit.
+   */
+  willEmit(type, value) {
+    return value;
   }
-  logQueries(value) {
-    return value !== void 0 ? this._logQueries = !!value : this._logQueries;
+  /**
+   * Lifecycle method that returns a filter function for updating the
+   * 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).
+   * @param {string} type The event type.
+   * @param {*} value The new event value that will be enqueued.
+   * @returns {(value: *) => boolean|null} A dispatch queue filter
+   *  function, or null if all unemitted event values should be filtered.
+   */
+  emitQueueFilter(type, value) {
+    return null;
   }
-  connector(connector) {
-    return connector ? this.db = connector : this.db;
+  /**
+   * Cancel all unemitted event values for the given event type.
+   * @param {string} type The event type.
+   */
+  cancel(type) {
+    const entry = this._callbacks.get(type);
+    entry?.queue.clear();
   }
-  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;
-    }
+  /**
+   * 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;
   }
-  request(request, priority = Priority.Normal) {
-    const result = queryResult();
-    const entry = { request, result };
-    if (this._consolidate) {
-      this._consolidate.add(entry, priority);
+  /**
+   * Emit an event value to listeners for the given event type.
+   * If a previous emit has not yet resolved, the event value
+   * will be queued to be emitted later.
+   * The actual event value given to listeners will be the result
+   * of passing the input value through the emitValue() method.
+   * @param {string} type The event type.
+   * @param {*} value The event value.
+   */
+  emit(type, value) {
+    const entry = this._callbacks.get(type) || {};
+    if (entry.pending) {
+      entry.queue.enqueue(value, this.emitQueueFilter(type, value));
     } else {
-      this.enqueue(entry, priority);
+      const event = this.willEmit(type, value);
+      const { callbacks, queue } = entry;
+      if (callbacks?.size) {
+        const callbackValues = Array.from(callbacks, (cb) => cb(event));
+        entry.pending = Promise.allSettled(callbackValues).then(() => {
+          entry.pending = null;
+          if (!queue.isEmpty()) {
+            this.emit(type, queue.dequeue());
+          }
+        });
+      }
     }
-    return result;
   }
-  cancel(requests) {
-    const set = new Set(requests);
-    this.queue.remove(({ result }) => set.has(result));
+};
+var DispatchQueue = class {
+  /**
+   * Create a new dispatch queue instance.
+   */
+  constructor() {
+    this.clear();
   }
+  /**
+   * Clear the queue state of all event values.
+   */
   clear() {
-    this.queue.remove(({ result }) => {
-      result.reject("Cleared");
-      return true;
-    });
+    this.next = null;
   }
-  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;
+  /**
+   * Indicate if the queue is empty.
+   * @returns {boolean} True if queue is empty, false otherwise.
+   */
+  isEmpty() {
+    return !this.next;
+  }
+  /**
+   * Add a new value to the queue, and optionally filter the
+   * current queue content in response.
+   * @param {*} value The value to add.
+   * @param {(value: *) => boolean} [filter] An optional filter
+   *  function to apply to existing queue content. If unspecified
+   *  or falsy, all previously queued values are removed. Otherwise,
+   *  the provided function is applied to all queue entries. The
+   *  entry is retained if the filter function returns a truthy value,
+   *  otherwise the entry is removed.
+   */
+  enqueue(value, filter) {
+    const tail = { value };
+    if (filter && this.next) {
+      let curr = this;
+      while (curr.next) {
+        if (filter(curr.next.value)) {
+          curr = curr.next;
+        } else {
+          curr.next = curr.next.next;
+        }
       }
-    };
-    this.recorders.push(recorder);
-    return recorder;
+      curr.next = tail;
+    } else {
+      this.next = tail;
+    }
+  }
+  /**
+   * Remove and return the next queued event value.
+   * @returns {*} The next event value in the queue.
+   */
+  dequeue() {
+    const { next } = this;
+    this.next = next?.next;
+    return next?.value;
   }
 };
 
-// ../core/src/util/js-type.js
-function jsType(type) {
-  switch (type) {
-    case "BIGINT":
-    case "HUGEINT":
-    case "INTEGER":
-    case "SMALLINT":
-    case "TINYINT":
-    case "UBIGINT":
-    case "UINTEGER":
-    case "USMALLINT":
-    case "UTINYINT":
-    case "DOUBLE":
-    case "FLOAT":
-    case "REAL":
-      return "number";
-    case "DATE":
-    case "TIMESTAMP":
-    case "TIMESTAMPTZ":
-    case "TIMESTAMP WITH TIME ZONE":
-    case "TIME":
-    case "TIMESTAMP_NS":
-      return "date";
-    case "BOOLEAN":
-      return "boolean";
-    case "VARCHAR":
-    case "UUID":
-    case "JSON":
-      return "string";
-    case "ARRAY":
-    case "LIST":
-      return "array";
-    case "BLOB":
-    case "STRUCT":
-    case "MAP":
-    case "GEOMETRY":
-      return "object";
-    default:
-      if (type.startsWith("DECIMAL")) {
-        return "number";
-      } else if (type.startsWith("STRUCT") || type.startsWith("MAP")) {
-        return "object";
-      } else if (type.endsWith("]")) {
-        return "array";
-      }
-      throw new Error(`Unsupported type: ${type}`);
+// ../core/src/util/distinct.js
+function distinct(a, b) {
+  return a === b ? false : a instanceof Date && b instanceof Date ? +a !== +b : Array.isArray(a) && Array.isArray(b) ? distinctArray(a, b) : true;
+}
+function distinctArray(a, b) {
+  if (a.length !== b.length) return true;
+  for (let i = 0; i < a.length; ++i) {
+    if (a[i] !== b[i]) return true;
   }
+  return false;
 }
 
-// ../core/src/util/convert-arrow.js
-function convertArrowValue(type) {
-  if (DataType.isTimestamp(type)) {
-    return (v) => v == null ? v : new Date(v);
+// ../core/src/Param.js
+function isParam(x2) {
+  return x2 instanceof Param;
+}
+var Param = class _Param extends AsyncDispatch {
+  /**
+   * Create a new Param instance.
+   * @param {*} value The initial value of the Param.
+   */
+  constructor(value) {
+    super();
+    this._value = value;
   }
-  if (DataType.isInt(type) && type.bitWidth >= 64) {
-    return (v) => v == null ? v : Number(v);
+  /**
+   * Create a new Param instance with the given initial value.
+   * @param {*} value The initial value of the Param.
+   * @returns {Param} The new Param instance.
+   */
+  static value(value) {
+    return new _Param(value);
   }
-  if (DataType.isDecimal(type)) {
-    const scale = 1 / Math.pow(10, type.scale);
-    return (v) => v == null ? v : decimalToNumber(v, scale);
+  /**
+   * Create a new Param instance over an array of initial values,
+   * which may contain nested Params.
+   * @param {*} values The initial values of the Param.
+   * @returns {Param} The new Param instance.
+   */
+  static array(values) {
+    if (values.some((v) => isParam(v))) {
+      const p = new _Param();
+      const update2 = () => {
+        p.update(values.map((v) => isParam(v) ? v.value : v));
+      };
+      update2();
+      values.forEach((v) => isParam(v) ? v.addEventListener("value", update2) : 0);
+      return p;
+    }
+    return new _Param(values);
   }
-  return (v) => v;
-}
-var BASE32 = Array.from(
-  { length: 8 },
-  (_, i) => Math.pow(2, i * 32)
-);
-function decimalToNumber(v, scale) {
-  const n = v.length;
-  let x2 = 0;
-  if (v.signed && (v[n - 1] | 0) < 0) {
-    for (let i = 0; i < n; ++i) {
-      x2 += ~v[i] * BASE32[i];
+  /**
+   * The current value of the Param.
+   */
+  get value() {
+    return this._value;
+  }
+  /**
+   * Update the Param value
+   * @param {*} value The new value of the Param.
+   * @param {object} [options] The update options.
+   * @param {boolean} [options.force] A boolean flag indicating if the Param
+   *  should emit a 'value' event even if the internal value is unchanged.
+   * @returns {this} This Param instance.
+   */
+  update(value, { force } = {}) {
+    const shouldEmit = distinct(this._value, value) || force;
+    if (shouldEmit) {
+      this.emit("value", value);
+    } else {
+      this.cancel("value");
     }
-    x2 = -(x2 + 1);
-  } else {
-    for (let i = 0; i < n; ++i) {
-      x2 += v[i] * BASE32[i];
+    return this;
+  }
+  /**
+   * Upon value-typed updates, sets the current value to the input value
+   * immediately prior to the event value being emitted to listeners.
+   * @param {string} type The event type.
+   * @param {*} value The input event value.
+   * @returns {*} The input event value.
+   */
+  willEmit(type, value) {
+    if (type === "value") {
+      this._value = value;
     }
+    return value;
   }
-  return x2 * scale;
-}
-
-// ../core/src/util/field-info.js
-var Count = "count";
-var Nulls = "nulls";
-var Max = "max";
-var Min = "min";
-var Distinct = "distinct";
-var statMap = {
-  [Count]: count,
-  [Distinct]: (column2) => count(column2).distinct(),
-  [Max]: max,
-  [Min]: min,
-  [Nulls]: (column2) => count().where(isNull(column2))
 };
-function summarize(table2, column2, stats) {
-  return Query.from(table2).select(Array.from(stats, (s) => [s, statMap[s](column2)]));
+
+// ../core/src/Selection.js
+function isSelection(x2) {
+  return x2 instanceof Selection;
 }
-async function queryFieldInfo(mc, fields) {
-  if (fields.length === 1 && `${fields[0].column}` === "*") {
-    return getTableInfo(mc, fields[0].table);
-  } else {
-    return (await Promise.all(fields.map((f) => getFieldInfo(mc, f)))).filter((x2) => x2);
+var Selection = class _Selection extends Param {
+  /**
+   * Create a new Selection instance with an
+   * intersect (conjunction) resolution strategy.
+   * @param {object} [options] The selection options.
+   * @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, empty = false } = {}) {
+    return new _Selection(new SelectionResolver({ cross, empty }));
   }
-}
-async function getFieldInfo(mc, { table: table2, column: column2, stats }) {
-  const q = Query.from({ source: table2 }).select({ column: column2 }).groupby(column2.aggregate ? sql`ALL` : []);
-  const [desc2] = Array.from(await mc.query(Query.describe(q)));
-  const info = {
-    table: table2,
-    column: `${column2}`,
-    sqlType: desc2.column_type,
-    type: jsType(desc2.column_type),
-    nullable: desc2.null === "YES"
-  };
-  if (!(stats?.length || stats?.size)) return info;
-  const result = await mc.query(
-    summarize(table2, column2, stats),
-    { persist: true }
-  );
-  for (let i = 0; i < result.numCols; ++i) {
-    const { name } = result.schema.fields[i];
-    const child = result.getChildAt(i);
-    const convert = convertArrowValue(child.type);
-    info[name] = convert(child.get(0));
+  /**
+   * Create a new Selection instance with a
+   * union (disjunction) resolution strategy.
+   * @param {object} [options] The selection options.
+   * @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, empty = false } = {}) {
+    return new _Selection(new SelectionResolver({ cross, empty, union: true }));
   }
-  return info;
-}
-async function getTableInfo(mc, table2) {
-  const result = await mc.query(`DESCRIBE ${asRelation(table2)}`);
-  return Array.from(result).map((desc2) => ({
-    table: table2,
-    column: desc2.column_name,
-    sqlType: desc2.column_type,
-    type: jsType(desc2.column_type),
-    nullable: desc2.null === "YES"
-  }));
-}
-
-// ../core/src/util/void-logger.js
-function voidLogger() {
-  return {
-    debug() {
-    },
-    info() {
-    },
-    log() {
-    },
-    warn() {
-    },
-    error() {
-    }
-  };
-}
-
-// ../core/src/Coordinator.js
-var _instance;
-function coordinator(instance8) {
-  if (instance8) {
-    _instance = instance8;
-  } else if (_instance == null) {
-    _instance = new Coordinator();
+  /**
+   * Create a new Selection instance with a singular resolution strategy
+   * that keeps only the most recent selection clause.
+   * @param {object} [options] The selection options.
+   * @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, 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({ empty = false } = {}) {
+    return new _Selection(new SelectionResolver({ cross: true, empty }));
+  }
+  /**
+   * Create a new Selection instance.
+   * @param {SelectionResolver} resolver The selection resolution
+   *  strategy to apply.
+   */
+  constructor(resolver = new SelectionResolver()) {
+    super([]);
+    this._resolved = this._value;
+    this._resolver = resolver;
+  }
+  /**
+   * Create a cloned copy of this Selection instance.
+   * @returns {Selection} A clone of this selection.
+   */
+  clone() {
+    const s = new _Selection(this._resolver);
+    s._value = s._resolved = this._value;
+    return s;
+  }
+  /**
+   * Create a clone of this Selection with clauses corresponding
+   * to the provided source removed.
+   * @param {*} source The clause source to remove.
+   * @returns {Selection} A cloned and updated Selection.
+   */
+  remove(source) {
+    const s = this.clone();
+    s._value = s._resolved = s._resolver.resolve(this._resolved, { source });
+    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;
   }
-  return _instance;
-}
-var Coordinator = class {
-  constructor(db = socketConnector(), options = {}) {
-    const {
-      logger = console,
-      manager = new QueryManager()
-    } = options;
-    this.manager = manager;
-    this.logger(logger);
-    this.configure(options);
-    this.databaseConnector(db);
-    this.clear();
+  /**
+   * The current array of selection clauses.
+   */
+  get clauses() {
+    return super.value;
   }
-  logger(logger) {
-    if (arguments.length) {
-      this._logger = logger || voidLogger();
-      this.manager.logger(this._logger);
-    }
-    return this._logger;
+  /**
+   * The current active (most recently updated) selection clause.
+   */
+  get active() {
+    return this.clauses.active;
   }
   /**
-   * 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.
+   * The value corresponding to the current active selection clause.
+   * This method ensures compatibility where a normal Param is expected.
    */
-  configure({ cache = true, consolidate: consolidate2 = true, indexes = true } = {}) {
-    this.manager.cache(cache);
-    this.manager.consolidate(consolidate2);
-    this.indexes = indexes;
+  get value() {
+    return this.active?.value;
   }
-  clear({ clients = true, cache = true } = {}) {
-    this.manager.clear();
-    if (clients) {
-      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();
+  /**
+   * 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.
+   */
+  valueFor(source) {
+    return this.clauses.find((c) => c.source === source)?.value;
   }
-  databaseConnector(db) {
-    return this.manager.connector(db);
+  /**
+   * Emit an activate event with the given selection clause.
+   * @param {*} clause The clause repesenting the potential activation.
+   */
+  activate(clause) {
+    this.emit("activate", clause);
   }
-  // -- Query Management ----
-  cancel(requests) {
-    this.manager.cancel(requests);
+  /**
+   * Update the selection with a new selection clause.
+   * @param {*} clause The selection clause to add.
+   * @returns {this} This Selection instance.
+   */
+  update(clause) {
+    this._resolved = this._resolver.resolve(this._resolved, clause, true);
+    this._resolved.active = clause;
+    return super.update(this._resolved);
   }
-  exec(query, { priority = Priority.Normal } = {}) {
-    query = Array.isArray(query) ? query.join(";\n") : query;
-    return this.manager.request({ type: "exec", query }, priority);
+  /**
+   * Upon value-typed updates, sets the current clause list to the
+   * input value and returns the active clause value.
+   * @param {string} type The event type.
+   * @param {*} value The input event value.
+   * @returns {*} For value-typed events, returns the active clause
+   *  values. Otherwise returns the input event value as-is.
+   */
+  willEmit(type, value) {
+    if (type === "value") {
+      this._value = value;
+      return this.value;
+    }
+    return value;
   }
-  query(query, {
-    type = "arrow",
-    cache = true,
-    priority = Priority.Normal,
-    ...options
-  } = {}) {
-    return this.manager.request({ type, query, cache, options }, priority);
+  /**
+   * Upon value-typed updates, returns a dispatch queue filter function.
+   * The return value depends on the selection resolution strategy.
+   * @param {string} type The event type.
+   * @param {*} value The new event value that will be enqueued.
+   * @returns {(value: *) => boolean|null} For value-typed events,
+   *  returns a dispatch queue filter function. Otherwise returns null.
+   */
+  emitQueueFilter(type, value) {
+    return type === "value" ? this._resolver.queueFilter(value) : null;
   }
-  prefetch(query, options = {}) {
-    return this.query(query, { ...options, cache: true, priority: Priority.Low });
+  /**
+   * Indicates if a selection clause should not be applied to a given client.
+   * The return value depends on the selection resolution strategy.
+   * @param {*} client The selection clause.
+   * @param {*} clause The client to test.
+   * @returns True if the client should be skipped, false otherwise.
+   */
+  skip(client, clause) {
+    return this._resolver.skip(client, clause);
   }
-  createBundle(name, queries, priority = Priority.Low) {
-    const options = { name, queries };
-    return this.manager.request({ type: "create-bundle", options }, priority);
+  /**
+   * Return a selection query predicate for the given client.
+   * @param {*} client The client whose data may be filtered.
+   * @param {boolean} [noSkip=false] Disable skipping of active
+   *  cross-filtered sources. If set true, the source of the active
+   *  clause in a cross-filtered selection will not be skipped.
+   * @returns {*} The query predicate for filtering client data,
+   *  based on the current state of this selection.
+   */
+  predicate(client, noSkip = false) {
+    const { clauses } = this;
+    const active = noSkip ? null : clauses.active;
+    return this._resolver.predicate(clauses, active, client);
   }
-  loadBundle(name, priority = Priority.High) {
-    const options = { name };
-    return this.manager.request({ type: "load-bundle", options }, priority);
+};
+var SelectionResolver = class {
+  /**
+   * Create a new selection resolved instance.
+   * @param {object} [options] The resolution strategy options.
+   * @param {boolean} [options.union=false] Boolean flag to indicate a union strategy.
+   *  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, empty } = {}) {
+    this.union = !!union;
+    this.cross = !!cross;
+    this.single = !!single;
+    this.empty = !!empty;
   }
-  // -- Client Management ----
-  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);
-      }
-    );
+  /**
+   * Resolve a list of selection clauses according to the resolution strategy.
+   * @param {*[]} clauseList An array of selection clauses.
+   * @param {*} clause A new selection clause to add.
+   * @returns {*[]} An updated array of selection clauses.
+   */
+  resolve(clauseList, clause, reset = false) {
+    const { source, predicate } = clause;
+    const filtered = clauseList.filter((c) => source !== c.source);
+    const clauses = this.single ? [] : filtered;
+    if (this.single && reset) filtered.forEach((c) => c.source?.reset?.());
+    if (predicate) clauses.push(clause);
+    return clauses;
   }
-  requestQuery(client, query) {
-    this.filterGroups.get(client.filterBy)?.reset();
-    return query ? this.updateClient(client, query) : client.update();
+  /**
+   * Indicates if a selection clause should not be applied to a given client.
+   * The return value depends on the resolution strategy.
+   * @param {*} client The selection clause.
+   * @param {*} clause The client to test.
+   * @returns True if the client should be skipped, false otherwise.
+   */
+  skip(client, clause) {
+    return this.cross && clause?.clients?.has(client);
   }
   /**
-   * Connect a client to the coordinator.
-   * @param {import('./MosaicClient.js').MosaicClient} client the client to disconnect
+   * Return a selection query predicate for the given client.
+   * @param {*[]} clauseList An array of selection clauses.
+   * @param {*} active The current active selection clause.
+   * @param {*} client The client whose data may be filtered.
+   * @returns {*} The query predicate for filtering client data,
+   *  based on the current state of this selection.
    */
-  async connect(client) {
-    const { clients, filterGroups, indexes } = this;
-    if (clients.has(client)) {
-      throw new Error("Client already connected.");
-    }
-    clients.add(client);
-    client.coordinator = this;
-    const fields = client.fields();
-    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));
-      }
+  predicate(clauseList, active, client) {
+    const { empty, union } = this;
+    if (empty && !clauseList.length) {
+      return ["FALSE"];
     }
-    client.requestQuery();
+    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;
   }
   /**
-   * Disconnect a client from the coordinator.
-   *
-   * @param {import('./MosaicClient.js').MosaicClient} client the client to disconnect
+   * Returns a filter function for queued selection updates.
+   * @param {*} value The new event value that will be enqueued.
+   * @returns {(value: *) => boolean|null} A dispatch queue filter
+   *  function, or null if all unemitted event values should be filtered.
    */
-  disconnect(client) {
-    const { clients, filterGroups } = this;
-    if (!clients.has(client)) return;
-    clients.delete(client);
-    filterGroups.get(client.filterBy)?.remove(client);
-    client.coordinator = null;
+  queueFilter(value) {
+    if (this.cross) {
+      const source = value.active?.source;
+      return (clauses) => clauses.active?.source !== source;
+    }
+    return null;
   }
 };
 
 // ../core/src/SelectionClause.js
-function point(field, value, { source, clients = void 0 }) {
+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" },
@@ -14741,19 +14964,39 @@ function point(field, value, { source, clients = void 0 }) {
     predicate
   };
 }
-function interval(field, value, {
+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,
+  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], bin, pixelSize };
+  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 match(field, value, {
+function clauseMatch(field, value, {
   source,
   clients = void 0,
   method = "contains"
@@ -14764,6 +15007,39 @@ function match(field, value, {
   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);
@@ -14873,7 +15149,7 @@ var Menu = class extends MosaicClient {
     const { selection, field } = this;
     if (isSelection(selection)) {
       if (value === "") value = void 0;
-      const clause = point(field, value, { source: this });
+      const clause = clausePoint(field, value, { source: this });
       selection.update(clause);
     } else if (isParam(selection)) {
       selection.update(value);
@@ -14984,7 +15260,7 @@ var Search = class extends MosaicClient {
   publish(value) {
     const { selection, field, type } = this;
     if (isSelection(selection)) {
-      const clause = match(field, value, { source: this, method: type });
+      const clause = clauseMatch(field, value, { source: this, method: type });
       selection.update(clause);
     } else if (isParam(selection)) {
       selection.update(value);
@@ -15140,14 +15416,14 @@ var Slider = class extends MosaicClient {
     if (isSelection(selection)) {
       if (selectionType === "interval") {
         const domain = [this.min ?? 0, value];
-        selection.update(interval(field, domain, {
+        selection.update(clauseInterval(field, domain, {
           source: this,
           bin: "ceil",
           scale: { type: "identity", domain },
           pixelSize: this.step
         }));
       } else {
-        selection.update(point(field, value, { source: this }));
+        selection.update(clausePoint(field, value, { source: this }));
       }
     } else if (isParam(this.selection)) {
       selection.update(value);
@@ -15209,7 +15485,8 @@ var Table2 = class extends MosaicClient {
     width,
     maxWidth,
     height = 500,
-    rowBatch = 100
+    rowBatch = 100,
+    as
   } = {}) {
     super(filterBy);
     this.id = `table-${++_id3}`;
@@ -15221,6 +15498,8 @@ 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;
@@ -15249,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));
@@ -15289,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;
@@ -15336,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) {