@uwdata/mosaic-inputs 0.1.0 → 0.3.0

package/dist/mosaic-inputs.js

@@ -328,8 +328,8 @@ function joinUint8Arrays(chunks, size) {
   }
   return [buffer || new Uint8Array(0), result.slice(index), byteLength - (buffer ? buffer.byteLength : 0)];
 }
-function toArrayBufferView(ArrayBufferViewCtor, input) {
-  let value = isIteratorResult(input) ? input.value : input;
+function toArrayBufferView(ArrayBufferViewCtor, input2) {
+  let value = isIteratorResult(input2) ? input2.value : input2;
   if (value instanceof ArrayBufferViewCtor) {
     if (ArrayBufferViewCtor === Uint8Array) {
       return new ArrayBufferViewCtor(value.buffer, value.byteOffset, value.byteLength);
@@ -353,17 +353,17 @@ function toArrayBufferView(ArrayBufferViewCtor, input) {
   }
   return !ArrayBuffer.isView(value) ? ArrayBufferViewCtor.from(value) : value.byteLength <= 0 ? new ArrayBufferViewCtor(0) : new ArrayBufferViewCtor(value.buffer, value.byteOffset, value.byteLength / ArrayBufferViewCtor.BYTES_PER_ELEMENT);
 }
-var toInt8Array = (input) => toArrayBufferView(Int8Array, input);
-var toInt16Array = (input) => toArrayBufferView(Int16Array, input);
-var toInt32Array = (input) => toArrayBufferView(Int32Array, input);
-var toBigInt64Array = (input) => toArrayBufferView(BigInt64ArrayCtor, input);
-var toUint8Array = (input) => toArrayBufferView(Uint8Array, input);
-var toUint16Array = (input) => toArrayBufferView(Uint16Array, input);
-var toUint32Array = (input) => toArrayBufferView(Uint32Array, input);
-var toBigUint64Array = (input) => toArrayBufferView(BigUint64ArrayCtor, input);
-var toFloat32Array = (input) => toArrayBufferView(Float32Array, input);
-var toFloat64Array = (input) => toArrayBufferView(Float64Array, input);
-var toUint8ClampedArray = (input) => toArrayBufferView(Uint8ClampedArray, input);
+var toInt8Array = (input2) => toArrayBufferView(Int8Array, input2);
+var toInt16Array = (input2) => toArrayBufferView(Int16Array, input2);
+var toInt32Array = (input2) => toArrayBufferView(Int32Array, input2);
+var toBigInt64Array = (input2) => toArrayBufferView(BigInt64ArrayCtor, input2);
+var toUint8Array = (input2) => toArrayBufferView(Uint8Array, input2);
+var toUint16Array = (input2) => toArrayBufferView(Uint16Array, input2);
+var toUint32Array = (input2) => toArrayBufferView(Uint32Array, input2);
+var toBigUint64Array = (input2) => toArrayBufferView(BigUint64ArrayCtor, input2);
+var toFloat32Array = (input2) => toArrayBufferView(Float32Array, input2);
+var toFloat64Array = (input2) => toArrayBufferView(Float64Array, input2);
+var toUint8ClampedArray = (input2) => toArrayBufferView(Uint8ClampedArray, input2);
 var pump = (iterator) => {
   iterator.next();
   return iterator;
@@ -381,15 +381,15 @@ function* toArrayBufferViewIterator(ArrayCtor, source) {
   }(buffers[Symbol.iterator]()));
   return new ArrayCtor();
 }
-var toInt8ArrayIterator = (input) => toArrayBufferViewIterator(Int8Array, input);
-var toInt16ArrayIterator = (input) => toArrayBufferViewIterator(Int16Array, input);
-var toInt32ArrayIterator = (input) => toArrayBufferViewIterator(Int32Array, input);
-var toUint8ArrayIterator = (input) => toArrayBufferViewIterator(Uint8Array, input);
-var toUint16ArrayIterator = (input) => toArrayBufferViewIterator(Uint16Array, input);
-var toUint32ArrayIterator = (input) => toArrayBufferViewIterator(Uint32Array, input);
-var toFloat32ArrayIterator = (input) => toArrayBufferViewIterator(Float32Array, input);
-var toFloat64ArrayIterator = (input) => toArrayBufferViewIterator(Float64Array, input);
-var toUint8ClampedArrayIterator = (input) => toArrayBufferViewIterator(Uint8ClampedArray, input);
+var toInt8ArrayIterator = (input2) => toArrayBufferViewIterator(Int8Array, input2);
+var toInt16ArrayIterator = (input2) => toArrayBufferViewIterator(Int16Array, input2);
+var toInt32ArrayIterator = (input2) => toArrayBufferViewIterator(Int32Array, input2);
+var toUint8ArrayIterator = (input2) => toArrayBufferViewIterator(Uint8Array, input2);
+var toUint16ArrayIterator = (input2) => toArrayBufferViewIterator(Uint16Array, input2);
+var toUint32ArrayIterator = (input2) => toArrayBufferViewIterator(Uint32Array, input2);
+var toFloat32ArrayIterator = (input2) => toArrayBufferViewIterator(Float32Array, input2);
+var toFloat64ArrayIterator = (input2) => toArrayBufferViewIterator(Float64Array, input2);
+var toUint8ClampedArrayIterator = (input2) => toArrayBufferViewIterator(Uint8ClampedArray, input2);
 function toArrayBufferViewAsyncIterator(ArrayCtor, source) {
   return __asyncGenerator(this, arguments, function* toArrayBufferViewAsyncIterator_1() {
     if (isPromise(source)) {
@@ -425,15 +425,15 @@ function toArrayBufferViewAsyncIterator(ArrayCtor, source) {
     return yield __await(new ArrayCtor());
   });
 }
-var toInt8ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Int8Array, input);
-var toInt16ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Int16Array, input);
-var toInt32ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Int32Array, input);
-var toUint8ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Uint8Array, input);
-var toUint16ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Uint16Array, input);
-var toUint32ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Uint32Array, input);
-var toFloat32ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Float32Array, input);
-var toFloat64ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Float64Array, input);
-var toUint8ClampedArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Uint8ClampedArray, input);
+var toInt8ArrayAsyncIterator = (input2) => toArrayBufferViewAsyncIterator(Int8Array, input2);
+var toInt16ArrayAsyncIterator = (input2) => toArrayBufferViewAsyncIterator(Int16Array, input2);
+var toInt32ArrayAsyncIterator = (input2) => toArrayBufferViewAsyncIterator(Int32Array, input2);
+var toUint8ArrayAsyncIterator = (input2) => toArrayBufferViewAsyncIterator(Uint8Array, input2);
+var toUint16ArrayAsyncIterator = (input2) => toArrayBufferViewAsyncIterator(Uint16Array, input2);
+var toUint32ArrayAsyncIterator = (input2) => toArrayBufferViewAsyncIterator(Uint32Array, input2);
+var toFloat32ArrayAsyncIterator = (input2) => toArrayBufferViewAsyncIterator(Float32Array, input2);
+var toFloat64ArrayAsyncIterator = (input2) => toArrayBufferViewAsyncIterator(Float64Array, input2);
+var toUint8ClampedArrayAsyncIterator = (input2) => toArrayBufferViewAsyncIterator(Uint8ClampedArray, input2);
 function rebaseValueOffsets(offset, length2, valueOffsets) {
   if (offset !== 0) {
     valueOffsets = valueOffsets.slice(0, length2 + 1);
@@ -2621,31 +2621,31 @@ function clampRange(source, begin, end, then) {
   return then ? then(source, lhs, rhs) : [lhs, rhs];
 }
 var isNaNFast = (value) => value !== value;
-function createElementComparator(search) {
-  const typeofSearch = typeof search;
-  if (typeofSearch !== "object" || search === null) {
-    if (isNaNFast(search)) {
+function createElementComparator(search2) {
+  const typeofSearch = typeof search2;
+  if (typeofSearch !== "object" || search2 === null) {
+    if (isNaNFast(search2)) {
       return isNaNFast;
     }
-    return (value) => value === search;
+    return (value) => value === search2;
   }
-  if (search instanceof Date) {
-    const valueOfSearch = search.valueOf();
+  if (search2 instanceof Date) {
+    const valueOfSearch = search2.valueOf();
     return (value) => value instanceof Date ? value.valueOf() === valueOfSearch : false;
   }
-  if (ArrayBuffer.isView(search)) {
-    return (value) => value ? compareArrayLike(search, value) : false;
+  if (ArrayBuffer.isView(search2)) {
+    return (value) => value ? compareArrayLike(search2, value) : false;
   }
-  if (search instanceof Map) {
-    return createMapComparator(search);
+  if (search2 instanceof Map) {
+    return createMapComparator(search2);
   }
-  if (Array.isArray(search)) {
-    return createArrayLikeComparator(search);
+  if (Array.isArray(search2)) {
+    return createArrayLikeComparator(search2);
   }
-  if (search instanceof Vector) {
-    return createVectorComparator(search);
+  if (search2 instanceof Vector) {
+    return createVectorComparator(search2);
   }
-  return createObjectComparator(search, true);
+  return createObjectComparator(search2, true);
 }
 function createArrayLikeComparator(lhs) {
   const comparators = [];
@@ -3470,21 +3470,21 @@ var getListByteLength = ({ valueOffsets, stride, children }, index) => {
   const child = children[0];
   const { [index * stride]: start } = valueOffsets;
   const { [index * stride + 1]: end } = valueOffsets;
-  const visit = instance5.getVisitFn(child.type);
+  const visit2 = instance5.getVisitFn(child.type);
   const slice = child.slice(start, end - start);
   let size = 8;
   for (let idx = -1, len = end - start; ++idx < len; ) {
-    size += visit(slice, idx);
+    size += visit2(slice, idx);
   }
   return size;
 };
 var getFixedSizeListByteLength = ({ stride, children }, index) => {
   const child = children[0];
   const slice = child.slice(index * stride, stride);
-  const visit = instance5.getVisitFn(child.type);
+  const visit2 = instance5.getVisitFn(child.type);
   let size = 0;
   for (let idx = -1, len = slice.length; ++idx < len; ) {
-    size += visit(slice, idx);
+    size += visit2(slice, idx);
   }
   return size;
 };
@@ -3512,9 +3512,9 @@ var _a2;
 var visitorsByTypeId = {};
 var vectorPrototypesByTypeId = {};
 var Vector = class {
-  constructor(input) {
+  constructor(input2) {
     var _b2, _c2, _d2;
-    const data = input[0] instanceof Vector ? input.flatMap((x) => x.data) : input;
+    const data = input2[0] instanceof Vector ? input2.flatMap((x) => x.data) : input2;
     if (data.length === 0 || data.some((x) => !(x instanceof Data))) {
       throw new TypeError("Vector constructor expects an Array of Data instances.");
     }
@@ -4958,8 +4958,8 @@ var Builder2 = class {
    * This checks a required field has been set in a given table that has
    * just been constructed.
    */
-  requiredField(table, field) {
-    const table_start = this.bb.capacity() - table;
+  requiredField(table2, field) {
+    const table_start = this.bb.capacity() - table2;
     const vtable_start = table_start - this.bb.readInt32(table_start);
     const ok = this.bb.readInt16(vtable_start + field) != 0;
     if (!ok) {
@@ -10903,13 +10903,13 @@ var RecordBatchWriter = class extends ReadableInterop {
   toUint8Array(sync = false) {
     return this._sink.toUint8Array(sync);
   }
-  writeAll(input) {
-    if (isPromise(input)) {
-      return input.then((x) => this.writeAll(x));
-    } else if (isAsyncIterable(input)) {
-      return writeAllAsync(this, input);
+  writeAll(input2) {
+    if (isPromise(input2)) {
+      return input2.then((x) => this.writeAll(x));
+    } else if (isAsyncIterable(input2)) {
+      return writeAllAsync(this, input2);
     }
-    return writeAll(this, input);
+    return writeAll(this, input2);
   }
   get closed() {
     return this._sink.closed;
@@ -11076,26 +11076,26 @@ var RecordBatchWriter = class extends ReadableInterop {
 };
 var RecordBatchStreamWriter = class extends RecordBatchWriter {
   /** @nocollapse */
-  static writeAll(input, options) {
+  static writeAll(input2, options) {
     const writer = new RecordBatchStreamWriter(options);
-    if (isPromise(input)) {
-      return input.then((x) => writer.writeAll(x));
-    } else if (isAsyncIterable(input)) {
-      return writeAllAsync(writer, input);
+    if (isPromise(input2)) {
+      return input2.then((x) => writer.writeAll(x));
+    } else if (isAsyncIterable(input2)) {
+      return writeAllAsync(writer, input2);
     }
-    return writeAll(writer, input);
+    return writeAll(writer, input2);
   }
 };
 var RecordBatchFileWriter = class extends RecordBatchWriter {
   /** @nocollapse */
-  static writeAll(input) {
+  static writeAll(input2) {
     const writer = new RecordBatchFileWriter();
-    if (isPromise(input)) {
-      return input.then((x) => writer.writeAll(x));
-    } else if (isAsyncIterable(input)) {
-      return writeAllAsync(writer, input);
+    if (isPromise(input2)) {
+      return input2.then((x) => writer.writeAll(x));
+    } else if (isAsyncIterable(input2)) {
+      return writeAllAsync(writer, input2);
     }
-    return writeAll(writer, input);
+    return writeAll(writer, input2);
   }
   constructor() {
     super();
@@ -11110,11 +11110,11 @@ var RecordBatchFileWriter = class extends RecordBatchWriter {
     return super._writeFooter(schema)._write(buffer)._write(Int32Array.of(buffer.byteLength))._writeMagic();
   }
 };
-function writeAll(writer, input) {
-  let chunks = input;
-  if (input instanceof Table) {
-    chunks = input.batches;
-    writer.reset(void 0, input.schema);
+function writeAll(writer, input2) {
+  let chunks = input2;
+  if (input2 instanceof Table) {
+    chunks = input2.batches;
+    writer.reset(void 0, input2.schema);
   }
   for (const batch of chunks) {
     writer.write(batch);
@@ -11389,8 +11389,8 @@ function recordBatchWriterThroughDOMStream(writableStrategy, readableStrategy) {
 }
 
 // ../../node_modules/apache-arrow/ipc/serialization.mjs
-function tableFromIPC(input) {
-  const reader = RecordBatchReader.from(input);
+function tableFromIPC(input2) {
+  const reader = RecordBatchReader.from(input2);
   if (isPromise(reader)) {
     return reader.then((reader2) => tableFromIPC(reader2));
   }
@@ -11417,8 +11417,8 @@ RecordBatchWriter["throughDOM"] = recordBatchWriterThroughDOMStream;
 RecordBatchFileWriter["throughDOM"] = recordBatchWriterThroughDOMStream;
 RecordBatchStreamWriter["throughDOM"] = recordBatchWriterThroughDOMStream;
 
-// ../core/src/clients/socket.js
-function socketClient(uri = "ws://localhost:3000/") {
+// ../core/src/connectors/socket.js
+function socketConnector(uri = "ws://localhost:3000/") {
   const queue = [];
   let connected = false;
   let request = null;
@@ -11537,22 +11537,35 @@ function jsType(type) {
 
 // ../sql/src/ref.js
 var Ref = class {
-  constructor(table, column2) {
-    if (table)
-      this.table = String(table);
+  /**
+   * Create a new Ref instance.
+   * @param {string|Ref|null} table The table name.
+   * @param {string|null} column The column name.
+   */
+  constructor(table2, column2) {
+    if (table2)
+      this.table = String(table2);
     if (column2)
       this.column = column2;
   }
+  /**
+   * Get the list of referenced columns. Either a single element array
+   * if column is non-null, otherwise an empty array.
+   */
   get columns() {
     return this.column ? [this.column] : [];
   }
+  /**
+   * Generate a SQL string for this reference.
+   * @returns {string} The SQL string.
+   */
   toString() {
-    const { table, column: column2 } = this;
+    const { table: table2, column: column2 } = this;
     if (column2) {
-      const col = column2 === "*" ? column2 : `"${column2}"`;
-      return (table ? `"${table}".` : "") + col;
+      const col = column2.startsWith("*") ? column2 : `"${column2}"`;
+      return `${table2 ? `"${table2}".` : ""}${col}`;
     } else {
-      return `"${table}"`;
+      return table2 ? `"${table2}"` : "NULL";
     }
   }
 };
@@ -11568,25 +11581,34 @@ function asRelation(value) {
 function relation(name) {
   return new Ref(name);
 }
-function column(table, column2) {
-  return arguments.length === 1 ? new Ref(null, table) : new Ref(table, column2);
+function column(table2, column2) {
+  if (arguments.length === 1) {
+    column2 = table2;
+    table2 = null;
+  }
+  return new Ref(table2, column2);
 }
 
 // ../sql/src/to-sql.js
-function toSQL(value) {
-  return typeof value === "string" ? `"${value}"` : literalToSQL(value);
-}
 function literalToSQL(value) {
   switch (typeof value) {
     case "boolean":
       return value ? "TRUE" : "FALSE";
     case "string":
       return `'${value}'`;
+    case "number":
+      return Number.isFinite(value) ? String(value) : "NULL";
     default:
       if (value == null) {
         return "NULL";
       } else if (value instanceof Date) {
-        return `MAKE_DATE(${value.getUTCFullYear()}, ${value.getUTCMonth() + 1}, ${value.getUTCDate()})`;
+        const ts = +value;
+        if (Number.isNaN(ts))
+          return "NULL";
+        const y = value.getUTCFullYear();
+        const m = value.getUTCMonth();
+        const d = value.getUTCDate();
+        return ts === Date.UTC(y, m, d) ? `MAKE_DATE(${y}, ${m + 1}, ${d})` : `EPOCH_MS(${ts})`;
       } else if (value instanceof RegExp) {
         return `'${value.source}'`;
       } else {
@@ -11596,263 +11618,406 @@ function literalToSQL(value) {
 }
 
 // ../sql/src/expression.js
-function isExpression(e) {
-  return e instanceof SQLExpression;
+var isParamLike = (value) => typeof value?.addEventListener === "function";
+function isSQLExpression(value) {
+  return value instanceof SQLExpression;
 }
 var SQLExpression = class {
-  constructor(sql2, columns, label) {
-    this.expr = sql2;
-    this.label = label;
-    this.columns = columns || [];
-  }
-  toString() {
-    return `${this.expr}`;
-  }
-};
-function expr(sql2, columns, label) {
-  return new SQLExpression(sql2, columns, label);
-}
-function desc(e) {
-  return Object.assign(
-    expr(`${asColumn(e)} DESC NULLS LAST`, e?.columns, e?.label),
-    { desc: true }
-  );
-}
-function transform(func2, label) {
-  return (value) => expr(func2(value), asColumn(value).columns, label);
-}
-
-// ../sql/src/literal.js
-var Literal = class {
-  constructor(value) {
-    this.value = value;
-  }
-  toString() {
-    return literalToSQL(this.value);
+  /**
+   * Create a new SQL expression instance.
+   * @param {(string|SQLExpression|Ref)[]} parts The parts of the expression.
+   * @param {string[]} [columns=[]] The column dependencies
+   * @param {object} [props] Additional properties for this expression.
+   */
+  constructor(parts, columns, props) {
+    this._expr = Array.isArray(parts) ? parts : [parts];
+    this._deps = columns || [];
+    this.annotate(props);
+    const params = this._expr.filter((part) => isParamLike(part));
+    if (params.length > 0) {
+      this._params = Array.from(new Set(params));
+      this._params.forEach((param) => {
+        param.addEventListener("value", () => update(this, this.map?.get("value")));
+      });
+    } else {
+      this.addEventListener = void 0;
+    }
   }
-};
-var literal = (value) => new Literal(value);
-
-// ../sql/src/compare.js
-function extractColumns(...args) {
-  return args.flat().flatMap((arg) => arg?.columns || []);
-}
-var Compare1 = class {
-  constructor(op, a) {
-    this.op = op;
-    this.a = asColumn(a);
+  /**
+   * A reference to this expression.
+   * Provides compatibility with param-like objects.
+   */
+  get value() {
+    return this;
   }
+  /**
+   * The column dependencies of this expression.
+   * @returns {string[]} The columns dependencies.
+   */
   get columns() {
-    return extractColumns(this.a);
-  }
-  visit(callback) {
-    callback(this.op, this);
-  }
-  toString() {
-    const { op, a } = this;
-    return `(${toSQL(a)} ${op})`;
-  }
-};
-function compare1(op) {
-  return (a) => new Compare1(op, a);
-}
-var not = compare1("NOT");
-var isNull = compare1("IS NULL");
-var isNotNull = compare1("IS NOT NULL");
-var Compare2 = class {
-  constructor(op, a, b) {
-    this.op = op;
-    this.a = asColumn(a);
-    this.b = asColumn(b);
+    const { _params, _deps } = this;
+    if (_params) {
+      const pset = new Set(_params.flatMap((p) => {
+        const cols = p.value?.columns;
+        return Array.isArray(cols) ? cols : [];
+      }));
+      if (pset.size) {
+        const set = new Set(_deps);
+        pset.forEach((col) => set.add(col));
+        return Array.from(set);
+      }
+    }
+    return _deps;
   }
-  get columns() {
-    return extractColumns(this.a, this.b);
+  /**
+   * The first column dependency in this expression, or undefined if none.
+   * @returns {string} The first column dependency.
+   */
+  get column() {
+    return this._deps.length ? this._deps[0] : this.columns[0];
   }
-  visit(callback) {
-    callback(this.op, this);
+  /**
+   * Annotate this expression instance with additional properties.
+   * @param {object[]} [props] One or more objects with properties to add.
+   * @returns {this} This SQL expression.
+   */
+  annotate(...props) {
+    return Object.assign(this, ...props);
   }
+  /**
+   * Generate a SQL code string corresponding to this expression.
+   * @returns {string} A SQL code string.
+   */
   toString() {
-    const { op, a, b } = this;
-    return `(${toSQL(a)} ${op} ${toSQL(b)})`;
-  }
-};
-function compare2(op) {
-  return (a, b) => new Compare2(op, a, b);
-}
-var eq = compare2("=");
-var neq = compare2("<>");
-var lt = compare2("<");
-var gt = compare2(">");
-var lte = compare2("<=");
-var gte = compare2(">=");
-var isDistinct = compare2("IS DISTINCT FROM");
-var isNotDistinct = compare2("IS NOT DISTINCT FROM");
-var Range = class {
-  constructor(op, expr2, value) {
-    this.op = op;
-    this.expr = asColumn(expr2);
-    this.value = value?.map(asColumn);
-  }
-  get columns() {
-    return extractColumns(this.expr, this.value);
-  }
-  visit(callback) {
-    callback(this.op, this);
+    return this._expr.map((p) => isParamLike(p) && !isSQLExpression(p) ? literalToSQL(p.value) : p).join("");
   }
-  toString() {
-    const { op, expr: expr2, value } = this;
-    if (!value)
-      return "";
-    const [a, b] = value;
-    return `(${toSQL(expr2)} ${op} ${toSQL(a)} AND ${toSQL(b)})`;
+  /**
+   * Add an event listener callback for the provided event type.
+   * @param {string} type The event type to listen for (for example, "value").
+   * @param {(a: SQLExpression) => Promise?} callback The callback function to
+   *  invoke upon updates. A callback may optionally return a Promise that
+   *  upstream listeners may await before proceeding.
+   */
+  addEventListener(type, callback) {
+    const map = this.map || (this.map = /* @__PURE__ */ new Map());
+    const set = map.get(type) || (map.set(type, /* @__PURE__ */ new Set()), map.get(type));
+    set.add(callback);
   }
 };
-function range(op) {
-  return (a, range2) => new Range(op, a, range2);
-}
-var isBetween = range("BETWEEN");
-var isNotBetween = range("NOT BETWEEN");
-var CompareN = class {
-  constructor(op, value) {
-    this.op = op;
-    this.value = value.map(asColumn);
+function update(expr, callbacks) {
+  if (callbacks?.size) {
+    return Promise.allSettled(Array.from(callbacks, (fn) => fn(expr)));
   }
-  get columns() {
-    return extractColumns(this.value);
-  }
-  visit(callback) {
-    callback(this.op, this);
-    this.value?.forEach((v) => v.visit(callback));
-  }
-  toString() {
-    const { op, value } = this;
-    return !value || value.length === 0 ? "" : value.length === 1 ? toSQL(value[0]) : `(${value.map(toSQL).filter((x) => x).join(` ${op} `)})`;
+}
+function parseSQL(strings, exprs) {
+  const spans = [strings[0]];
+  const cols = /* @__PURE__ */ new Set();
+  const n = exprs.length;
+  for (let i = 0, k = 0; i < n; ) {
+    const e = exprs[i];
+    if (isParamLike(e)) {
+      spans[++k] = e;
+    } else {
+      if (Array.isArray(e?.columns)) {
+        e.columns.forEach((col) => cols.add(col));
+      }
+      spans[k] += typeof e === "string" ? e : literalToSQL(e);
+    }
+    const s = strings[++i];
+    if (isParamLike(spans[k])) {
+      spans[++k] = s;
+    } else {
+      spans[k] += s;
+    }
   }
-};
-function and(...clauses) {
-  return new CompareN("AND", clauses.flat());
+  return { spans, cols: Array.from(cols) };
 }
-function or(...clauses) {
-  return new CompareN("OR", clauses.flat());
+function sql(strings, ...exprs) {
+  const { spans, cols } = parseSQL(strings, exprs);
+  return new SQLExpression(spans, cols);
 }
 
-// ../sql/src/function-call.js
-var FunctionCall = class {
-  constructor(func2, args) {
-    this.func = func2;
-    this.args = (args || []).map(asColumn);
-  }
-  get column() {
-    return this.columns[0];
+// ../sql/src/desc.js
+function desc(expr) {
+  const e = asColumn(expr);
+  return sql`${e} DESC NULLS LAST`.annotate({ label: e?.label, desc: true });
+}
+
+// ../sql/src/literal.js
+var literal = (value) => ({
+  value,
+  toString: () => literalToSQL(value)
+});
+
+// ../sql/src/operators.js
+function visit(callback) {
+  callback(this.op, this);
+  this.children?.forEach((v) => v.visit(callback));
+}
+function logical(op, clauses) {
+  const children = clauses.filter((x) => x != null).map(asColumn);
+  const strings = children.map((c, i) => i ? ` ${op} ` : "");
+  if (clauses.length)
+    strings.push("");
+  return sql(strings, ...children).annotate({ op, children, visit });
+}
+var and = (...clauses) => logical("AND", clauses.flat());
+var or = (...clauses) => logical("OR", clauses.flat());
+var unaryOp = (op) => (a) => sql`(${op} ${asColumn(a)})`.annotate({ op, a, visit });
+var not = unaryOp("NOT");
+var unaryPostOp = (op) => (a) => sql`(${asColumn(a)} ${op})`.annotate({ op, a, visit });
+var isNull = unaryPostOp("IS NULL");
+var isNotNull = unaryPostOp("IS NOT NULL");
+var binaryOp = (op) => (a, b) => sql`(${asColumn(a)} ${op} ${asColumn(b)})`.annotate({ op, a, b, visit });
+var eq = binaryOp("=");
+var neq = binaryOp("<>");
+var lt = binaryOp("<");
+var gt = binaryOp(">");
+var lte = binaryOp("<=");
+var gte = binaryOp(">=");
+var isDistinct = binaryOp("IS DISTINCT FROM");
+var isNotDistinct = binaryOp("IS NOT DISTINCT FROM");
+function rangeOp(op, a, range, exclusive) {
+  a = asColumn(a);
+  const prefix2 = op.startsWith("NOT ") ? "NOT " : "";
+  const expr = !range ? sql`` : exclusive ? sql`${prefix2}(${range[0]} <= ${a} AND ${a} < ${range[1]})` : sql`(${a} ${op} ${range[0]} AND ${range[1]})`;
+  return expr.annotate({ op, visit, field: a, range });
+}
+var isBetween = (a, range, exclusive) => rangeOp("BETWEEN", a, range, exclusive);
+
+// ../sql/src/repeat.js
+function repeat(length2, str) {
+  return Array.from({ length: length2 }, () => str);
+}
+
+// ../sql/src/functions.js
+function functionCall(op, type) {
+  return (...values) => {
+    const args = values.map(asColumn);
+    const cast2 = type ? `::${type}` : "";
+    const expr = args.length ? sql([`${op}(`, ...repeat(args.length - 1, ", "), `)${cast2}`], ...args) : sql`${op}()${cast2}`;
+    return expr.annotate({ func: op, args });
+  };
+}
+var regexp_matches = functionCall("REGEXP_MATCHES");
+var contains = functionCall("CONTAINS");
+var prefix = functionCall("PREFIX");
+var suffix = functionCall("SUFFIX");
+var lower = functionCall("LOWER");
+var upper = functionCall("UPPER");
+var length = functionCall("LENGTH");
+var isNaN2 = functionCall("ISNAN");
+var isFinite = functionCall("ISFINITE");
+var isInfinite = functionCall("ISINF");
+
+// ../sql/src/windows.js
+var WindowFunction = class extends SQLExpression {
+  constructor(op, func, type, name, group = "", order = "", frame = "") {
+    let expr;
+    const noWindowParams = !(group || order || frame);
+    if (name && noWindowParams) {
+      expr = name ? sql`${func} OVER "${name}"` : sql`${func} OVER ()`;
+    } else {
+      const s1 = group && order ? " " : "";
+      const s2 = (group || order) && frame ? " " : "";
+      expr = sql`${func} OVER (${name ? `"${name}" ` : ""}${group}${s1}${order}${s2}${frame})`;
+    }
+    if (type) {
+      expr = sql`(${expr})::${type}`;
+    }
+    const { _expr, _deps } = expr;
+    super(_expr, _deps, { window: op, func, type, name, group, order, frame });
   }
-  get columns() {
-    return this.args.flatMap((a) => a.columns || []);
+  get basis() {
+    return this.column;
   }
-  toString() {
-    const { func: func2, args } = this;
-    return `${func2}(${args.map(toSQL).join(", ")})`;
-  }
-};
-function func(op) {
-  return (...args) => new FunctionCall(op, args);
-}
-var regexp_matches = func("regexp_matches");
-var contains = func("contains");
-var prefix = func("prefix");
-var suffix = func("suffix");
-var lower = func("lower");
-var upper = func("upper");
-var length = func("length");
-var isNaN2 = func("isnan");
-var isFinite = func("isfinite");
-var isInfinite = func("isinf");
-
-// ../sql/src/aggregate.js
-var Aggregate = class {
-  constructor(op, args) {
-    this.aggregate = op;
-    this.args = (args || []).map(asColumn);
+  get label() {
+    const { func } = this;
+    return func.label ?? func.toString();
+  }
+  over(name) {
+    const { window: op, func, type, group, order, frame } = this;
+    return new WindowFunction(op, func, type, name, group, order, frame);
+  }
+  partitionby(...expr) {
+    const exprs = expr.flat().filter((x) => x).map(asColumn);
+    const group = sql(
+      ["PARTITION BY ", repeat(exprs.length - 1, ", "), ""],
+      ...exprs
+    );
+    const { window: op, func, type, name, order, frame } = this;
+    return new WindowFunction(op, func, type, name, group, order, frame);
+  }
+  orderby(...expr) {
+    const exprs = expr.flat().filter((x) => x).map(asColumn);
+    const order = sql(
+      ["ORDER BY ", repeat(exprs.length - 1, ", "), ""],
+      ...exprs
+    );
+    const { window: op, func, type, name, group, frame } = this;
+    return new WindowFunction(op, func, type, name, group, order, frame);
+  }
+  rows(expr) {
+    const frame = windowFrame("ROWS", expr);
+    const { window: op, func, type, name, group, order } = this;
+    return new WindowFunction(op, func, type, name, group, order, frame);
+  }
+  range(expr) {
+    const frame = windowFrame("RANGE", expr);
+    const { window: op, func, type, name, group, order } = this;
+    return new WindowFunction(op, func, type, name, group, order, frame);
+  }
+};
+function windowFrame(type, frame) {
+  if (isParamLike(frame)) {
+    const expr = sql`${frame}`;
+    expr.toString = () => `${type} ${frameToSQL(frame.value)}`;
+    return expr;
+  }
+  return `${type} ${frameToSQL(frame)}`;
+}
+function frameToSQL(frame) {
+  const [prev, next] = frame;
+  const a = prev === 0 ? "CURRENT ROW" : Number.isFinite(prev) ? `${Math.abs(prev)} PRECEDING` : "UNBOUNDED PRECEDING";
+  const b = next === 0 ? "CURRENT ROW" : Number.isFinite(next) ? `${Math.abs(next)} FOLLOWING` : "UNBOUNDED FOLLOWING";
+  return `BETWEEN ${a} AND ${b}`;
+}
+function winf(op, type) {
+  return (...values) => {
+    const func = functionCall(op)(...values);
+    return new WindowFunction(op, func, type);
+  };
+}
+var row_number = winf("ROW_NUMBER", "INTEGER");
+var rank = winf("RANK", "INTEGER");
+var dense_rank = winf("DENSE_RANK", "INTEGER");
+var percent_rank = winf("PERCENT_RANK");
+var cume_dist = winf("CUME_DIST");
+var ntile = winf("NTILE");
+var lag = winf("LAG");
+var lead = winf("LEAD");
+var first_value = winf("FIRST_VALUE");
+var last_value = winf("LAST_VALUE");
+var nth_value = winf("NTH_VALUE");
+
+// ../sql/src/aggregates.js
+var AggregateFunction = class extends SQLExpression {
+  constructor(op, args, type, isDistinct2, filter) {
+    args = (args || []).map(asColumn);
+    const { strings, exprs } = aggExpr(op, args, type, isDistinct2, filter);
+    const { spans, cols } = parseSQL(strings, exprs);
+    super(spans, cols, { aggregate: op, args, type, isDistinct: isDistinct2, filter });
+  }
+  get basis() {
+    return this.column;
   }
   get label() {
-    return this.aggregate.toLowerCase() + (this.args.length ? ` ${this.columns.join(", ")}` : "");
+    const { aggregate: op, args, isDistinct: isDistinct2 } = this;
+    const dist = isDistinct2 ? "DISTINCT" + (args.length ? " " : "") : "";
+    const tail = args.length ? `(${dist}${args.map(unquoted).join(", ")})` : "";
+    return `${op.toLowerCase()}${tail}`;
   }
-  get column() {
-    return this.columns[0];
+  distinct() {
+    const { aggregate: op, args, type, filter } = this;
+    return new AggregateFunction(op, args, type, true, filter);
   }
-  get columns() {
-    return this.args.flatMap((a) => a.columns || []);
+  where(filter) {
+    const { aggregate: op, args, type, isDistinct: isDistinct2 } = this;
+    return new AggregateFunction(op, args, type, isDistinct2, filter);
   }
-  distinct() {
-    this.isDistinct = true;
-    return this;
+  window() {
+    const { aggregate: op, args, type, isDistinct: isDistinct2 } = this;
+    const func = new AggregateFunction(op, args, null, isDistinct2);
+    return new WindowFunction(op, func, type);
   }
-  where(expr2) {
-    this.filter = expr2;
-    return this;
+  partitionby(...expr) {
+    return this.window().partitionby(...expr);
   }
-  toString() {
-    const { aggregate, args, isDistinct: isDistinct2, filter } = this;
-    const arg = args.length === 0 ? "*" : args.map(toSQL).join(", ");
-    const distinct2 = isDistinct2 ? "DISTINCT " : "";
-    const where = filter ? ` FILTER (WHERE ${toSQL(filter)})` : "";
-    const cast = aggregate === "COUNT" ? "::INTEGER" : "";
-    return where && cast ? `(${aggregate}(${distinct2}${arg})${where})${cast}` : `${aggregate}(${distinct2}${arg})${where}${cast}`;
-  }
-};
-function agg(op) {
-  return (...args) => new Aggregate(op, args);
-}
-var count = agg("COUNT");
-var avg = agg("AVG");
-var mean = agg("AVG");
-var mad = agg("MAD");
-var max = agg("MAX");
-var min = agg("MIN");
-var sum2 = agg("SUM");
-var product = agg("PRODUCT");
-var median = agg("MEDIAN");
-var quantile = agg("QUANTILE");
-var mode = agg("MODE");
-var variance = agg("VARIANCE");
-var stddev = agg("STDDEV");
-var skewness = agg("SKEWNESS");
-var kurtosis = agg("KURTOSIS");
-var entropy = agg("ENTROPY");
-var varPop = agg("VAR_POP");
-var stddevPop = agg("STDDEV_POP");
-var corr = agg("CORR");
-var covarPop = agg("COVAR_POP");
-var regrIntercept = agg("REGR_INTERCEPT");
-var regrSlope = agg("REGR_SLOPE");
-var regrCount = agg("REGR_COUNT");
-var regrR2 = agg("REGR_R2");
-var regrSYY = agg("REGR_SYY");
-var regrSXX = agg("REGR_SXX");
-var regrSXY = agg("REGR_SXY");
-var regrAvgX = agg("REGR_AVGX");
-var regrAvgY = agg("REGR_AVGY");
-var first = agg("FIRST");
-var last = agg("LAST");
-var argmin = agg("ARG_MIN");
-var argmax = agg("ARG_MAX");
-var stringAgg = agg("STRING_AGG");
-var arrayAgg = agg("ARRAY_AGG");
+  orderby(...expr) {
+    return this.window().orderby(...expr);
+  }
+  rows(prev, next) {
+    return this.window().rows(prev, next);
+  }
+  range(prev, next) {
+    return this.window().range(prev, next);
+  }
+};
+function aggExpr(op, args, type, isDistinct2, filter) {
+  const close = `)${type ? `::${type}` : ""}`;
+  let strings = [`${op}(${isDistinct2 ? "DISTINCT " : ""}`];
+  let exprs = [];
+  if (args.length) {
+    strings = strings.concat([
+      ...repeat(args.length - 1, ", "),
+      `${close}${filter ? " FILTER (WHERE " : ""}`,
+      ...filter ? [")"] : []
+    ]);
+    exprs = [...args, ...filter ? [filter] : []];
+  } else {
+    strings[0] += "*" + close;
+  }
+  return { exprs, strings };
+}
+function unquoted(value) {
+  const s = literalToSQL(value);
+  return s && s.startsWith('"') && s.endsWith('"') ? s.slice(1, -1) : s;
+}
+function aggf(op, type) {
+  return (...args) => new AggregateFunction(op, args, type);
+}
+var count = aggf("COUNT", "INTEGER");
+var avg = aggf("AVG");
+var mean = aggf("AVG");
+var mad = aggf("MAD");
+var max = aggf("MAX");
+var min = aggf("MIN");
+var sum2 = aggf("SUM", "DOUBLE");
+var product = aggf("PRODUCT");
+var median = aggf("MEDIAN");
+var quantile = aggf("QUANTILE");
+var mode = aggf("MODE");
+var variance = aggf("VARIANCE");
+var stddev = aggf("STDDEV");
+var skewness = aggf("SKEWNESS");
+var kurtosis = aggf("KURTOSIS");
+var entropy = aggf("ENTROPY");
+var varPop = aggf("VAR_POP");
+var stddevPop = aggf("STDDEV_POP");
+var corr = aggf("CORR");
+var covarPop = aggf("COVAR_POP");
+var regrIntercept = aggf("REGR_INTERCEPT");
+var regrSlope = aggf("REGR_SLOPE");
+var regrCount = aggf("REGR_COUNT");
+var regrR2 = aggf("REGR_R2");
+var regrSYY = aggf("REGR_SYY");
+var regrSXX = aggf("REGR_SXX");
+var regrSXY = aggf("REGR_SXY");
+var regrAvgX = aggf("REGR_AVGX");
+var regrAvgY = aggf("REGR_AVGY");
+var first = aggf("FIRST");
+var last = aggf("LAST");
+var argmin = aggf("ARG_MIN");
+var argmax = aggf("ARG_MAX");
+var stringAgg = aggf("STRING_AGG");
+var arrayAgg = aggf("ARRAY_AGG");
 
 // ../sql/src/datetime.js
-var epoch_ms = transform(
-  (d) => `(1000 * (epoch(${d}) - second(${d})) + millisecond(${d}))::DOUBLE`
-);
+var epoch_ms = (expr) => {
+  const d = asColumn(expr);
+  return sql`(1000 * (epoch(${d}) - second(${d})) + millisecond(${d}))::DOUBLE`;
+};
 
 // ../sql/src/Query.js
 var Query = class {
-  static select(...expr2) {
-    return new Query().select(...expr2);
+  static select(...expr) {
+    return new Query().select(...expr);
   }
-  static from(...expr2) {
-    return new Query().from(...expr2);
+  static from(...expr) {
+    return new Query().from(...expr);
   }
-  static with(...expr2) {
-    return new Query().with(...expr2);
+  static with(...expr) {
+    return new Query().with(...expr);
   }
   static union(...queries) {
     return new SetOperation("UNION", queries.flat());
@@ -11884,9 +12049,9 @@ var Query = class {
     q.query = { ...this.query };
     return q;
   }
-  with(...expr2) {
+  with(...expr) {
     const { query } = this;
-    if (expr2.length === 0) {
+    if (expr.length === 0) {
       return query.with;
     } else {
       const list = [];
@@ -11895,7 +12060,7 @@ var Query = class {
         query2.cteFor = this;
         list.push({ as, query: query2 });
       };
-      expr2.flat().forEach((e) => {
+      expr.flat().forEach((e) => {
         if (e == null) {
         } else if (e.as && e.query) {
           add(e.as, e.query);
@@ -11909,13 +12074,13 @@ var Query = class {
       return this;
     }
   }
-  select(...expr2) {
+  select(...expr) {
     const { query } = this;
-    if (expr2.length === 0) {
+    if (expr.length === 0) {
       return query.select;
     } else {
       const list = [];
-      expr2.flat().forEach((e) => {
+      for (const e of expr.flat()) {
         if (e == null) {
         } else if (typeof e === "string") {
           list.push({ as: e, expr: asColumn(e) });
@@ -11928,32 +12093,32 @@ var Query = class {
             list.push({ as: unquote(as), expr: asColumn(e[as]) });
           }
         }
-      });
+      }
       query.select = query.select.concat(list);
       return this;
     }
   }
-  $select(...expr2) {
+  $select(...expr) {
     this.query.select = [];
-    return this.select(...expr2);
+    return this.select(...expr);
   }
   distinct(value = true) {
     this.query.distinct = !!value;
     return this;
   }
-  from(...expr2) {
+  from(...expr) {
     const { query } = this;
-    if (expr2.length === 0) {
+    if (expr.length === 0) {
       return query.from;
     } else {
       const list = [];
-      expr2.flat().forEach((e) => {
+      expr.flat().forEach((e) => {
         if (e == null) {
         } else if (typeof e === "string") {
           list.push({ as: e, from: asRelation(e) });
         } else if (e instanceof Ref) {
           list.push({ as: e.table, from: e });
-        } else if (isQuery(e) || isExpression(e)) {
+        } else if (isQuery(e) || isSQLExpression(e)) {
           list.push({ from: e });
         } else if (Array.isArray(e)) {
           list.push({ as: unquote(e[0]), from: asRelation(e[1]) });
@@ -11967,67 +12132,71 @@ var Query = class {
       return this;
     }
   }
-  $from(...expr2) {
+  $from(...expr) {
     this.query.from = [];
-    return this.from(...expr2);
+    return this.from(...expr);
   }
-  sample(value) {
+  sample(value, method) {
     const { query } = this;
     if (arguments.length === 0) {
       return query.sample;
     } else {
       let spec = value;
       if (typeof value === "number") {
-        spec = value > 0 && value < 1 ? { perc: 100 * value } : { rows: Math.round(value) };
+        spec = value > 0 && value < 1 ? { perc: 100 * value, method } : { rows: Math.round(value), method };
       }
       query.sample = spec;
       return this;
     }
   }
-  where(...expr2) {
+  where(...expr) {
     const { query } = this;
-    if (expr2.length === 0) {
+    if (expr.length === 0) {
       return query.where;
     } else {
       query.where = query.where.concat(
-        expr2.flat().filter((x) => x)
+        expr.flat().filter((x) => x)
       );
       return this;
     }
   }
-  $where(...expr2) {
+  $where(...expr) {
     this.query.where = [];
-    return this.where(...expr2);
+    return this.where(...expr);
   }
-  groupby(...expr2) {
+  groupby(...expr) {
     const { query } = this;
-    if (expr2.length === 0) {
+    if (expr.length === 0) {
       return query.groupby;
     } else {
       query.groupby = query.groupby.concat(
-        expr2.flat().filter((x) => x).map(asColumn)
+        expr.flat().filter((x) => x).map(asColumn)
       );
       return this;
     }
   }
-  having(...expr2) {
+  $groupby(...expr) {
+    this.query.groupby = [];
+    return this.groupby(...expr);
+  }
+  having(...expr) {
     const { query } = this;
-    if (expr2.length === 0) {
+    if (expr.length === 0) {
       return query.having;
     } else {
       query.having = query.having.concat(
-        expr2.flat().filter((x) => x)
+        expr.flat().filter((x) => x)
       );
       return this;
     }
   }
-  window(...expr2) {
+  window(...expr) {
     const { query } = this;
-    if (expr2.length === 0) {
+    if (expr.length === 0) {
       return query.window;
     } else {
       const list = [];
-      expr2.flat().forEach((e) => {
+      expr.flat().forEach((e) => {
         if (e == null) {
         } else {
           for (const as in e) {
@@ -12039,24 +12208,24 @@ var Query = class {
       return this;
     }
   }
-  qualify(...expr2) {
+  qualify(...expr) {
     const { query } = this;
-    if (expr2.length === 0) {
+    if (expr.length === 0) {
       return query.qualify;
     } else {
       query.qualify = query.qualify.concat(
-        expr2.flat().filter((x) => x)
+        expr.flat().filter((x) => x)
       );
       return this;
     }
   }
-  orderby(...expr2) {
+  orderby(...expr) {
     const { query } = this;
-    if (expr2.length === 0) {
+    if (expr.length === 0) {
       return query.orderby;
     } else {
       query.orderby = query.orderby.concat(
-        expr2.flat().filter((x) => x).map(asColumn)
+        expr.flat().filter((x) => x).map(asColumn)
       );
       return this;
     }
@@ -12116,7 +12285,7 @@ var Query = class {
       sql2.push(`WITH ${list.join(", ")}`);
     }
     const sels = select.map(
-      ({ as, expr: expr2 }) => isColumnRefFor(expr2, as) && !expr2.table ? `${expr2}` : `${expr2} AS "${as}"`
+      ({ as, expr }) => isColumnRefFor(expr, as) && !expr.table ? `${expr}` : `${expr} AS "${as}"`
     );
     sql2.push(`SELECT${distinct2 ? " DISTINCT" : ""} ${sels.join(", ")}`);
     if (from.length) {
@@ -12126,17 +12295,17 @@ var Query = class {
       });
       sql2.push(`FROM ${rels.join(", ")}`);
     }
+    if (where.length) {
+      const clauses = where.map(String).filter((x) => x).join(" AND ");
+      if (clauses)
+        sql2.push(`WHERE ${clauses}`);
+    }
     if (sample) {
       const { rows, perc, method, seed } = sample;
       const size = rows ? `${rows} ROWS` : `${perc} PERCENT`;
       const how = method ? ` (${method}${seed != null ? `, ${seed}` : ""})` : "";
       sql2.push(`USING SAMPLE ${size}${how}`);
     }
-    if (where.length) {
-      const clauses = where.map(String).filter((x) => x).join(" AND ");
-      if (clauses)
-        sql2.push(`WHERE ${clauses}`);
-    }
     if (groupby.length) {
       sql2.push(`GROUP BY ${groupby.join(", ")}`);
     }
@@ -12146,7 +12315,7 @@ var Query = class {
         sql2.push(`HAVING ${clauses}`);
     }
     if (window.length) {
-      const windows = window.map(({ as, expr: expr2 }) => `"${as}" AS (${expr2})`);
+      const windows = window.map(({ as, expr }) => `"${as}" AS (${expr})`);
       sql2.push(`WINDOW ${windows.join(", ")}`);
     }
     if (qualify.length) {
@@ -12177,13 +12346,13 @@ var SetOperation = class {
     q.query = { ...this.query };
     return q;
   }
-  orderby(...expr2) {
+  orderby(...expr) {
     const { query } = this;
-    if (expr2.length === 0) {
+    if (expr.length === 0) {
       return query.orderby;
     } else {
       query.orderby = query.orderby.concat(
-        expr2.flat().filter((x) => x).map(asColumn)
+        expr.flat().filter((x) => x).map(asColumn)
       );
       return this;
     }
@@ -12250,8 +12419,8 @@ var statMap = {
   [Min]: min,
   [Nulls]: (column2) => count().where(isNull(column2))
 };
-function summarize({ table, column: column2 }, stats) {
-  return Query.from(table).select(stats.map((s) => [s, statMap[s](column2)]));
+function summarize({ table: table2, column: column2 }, stats) {
+  return Query.from(table2).select(stats.map((s) => [s, statMap[s](column2)]));
 }
 
 // ../core/src/Catalog.js
@@ -12264,38 +12433,35 @@ var Catalog = class {
   clear() {
     this.tables = object();
   }
-  async tableInfo(table) {
+  tableInfo(table2) {
     const cache = this.tables;
-    if (cache[table]) {
-      return cache[table];
+    if (cache[table2]) {
+      return cache[table2];
     }
-    const q = this.mc.query(
-      `DESCRIBE "${table}"`,
-      { type: "json", cache: false }
-    );
-    return cache[table] = q.then((result) => {
-      const columns = object();
-      for (const entry of result) {
-        columns[entry.column_name] = {
-          table,
-          column: entry.column_name,
-          sqlType: entry.column_type,
-          type: jsType(entry.column_type),
-          nullable: entry.null === "YES"
-        };
-      }
-      return columns;
+    const infoPromise = getTableInfo(this.mc, table2).catch((err) => {
+      cache[table2] = null;
+      throw err;
     });
+    return cache[table2] = infoPromise;
   }
-  async fieldInfo({ table, column: column2, stats }) {
-    const tableInfo = await this.tableInfo(table);
+  async fieldInfo({ table: table2, column: column2, stats }) {
+    const tableInfo = await this.tableInfo(table2);
     const colInfo = tableInfo[column2];
     if (colInfo == null)
       return;
     if (!stats?.length)
       return colInfo;
-    const result = await this.mc.query(summarize(colInfo, stats));
+    const result = await this.mc.query(
+      summarize(colInfo, stats),
+      { persist: true }
+    );
     const info = { ...colInfo, ...Array.from(result)[0] };
+    for (const key in info) {
+      const value = info[key];
+      if (typeof value === "bigint") {
+        info[key] = Number(value);
+      }
+    }
     return info;
   }
   async queryFields(fields) {
@@ -12304,6 +12470,23 @@ var Catalog = class {
     return data.filter((x) => x);
   }
 };
+async function getTableInfo(mc, table2) {
+  const result = await mc.query(
+    `DESCRIBE "${table2}"`,
+    { type: "json", cache: false }
+  );
+  const columns = object();
+  for (const entry of result) {
+    columns[entry.column_name] = {
+      table: table2,
+      column: entry.column_name,
+      sqlType: entry.column_type,
+      type: jsType(entry.column_type),
+      nullable: entry.null === "YES"
+    };
+  }
+  return columns;
+}
 async function resolveFields(catalog, list) {
   return list.length === 1 && list[0].column === "*" ? Object.values(await catalog.tableInfo(list[0].table)) : list;
 }
@@ -12332,11 +12515,6 @@ function fnv_mix(a) {
   return a & 4294967295;
 }
 
-// ../core/src/util/skip-client.js
-function skipClient(client, clause) {
-  return clause?.clients?.has(client);
-}
-
 // ../core/src/DataTileIndexer.js
 var identity = (x) => x;
 var DataTileIndexer = class {
@@ -12351,32 +12529,38 @@ var DataTileIndexer = class {
     this.indices = null;
     this.activeView = null;
   }
+  clear() {
+    if (this.indices) {
+      this.mc.cancel(Array.from(this.indices.values(), (index) => index.result));
+      this.indices = null;
+    }
+  }
   index(clients, active) {
     if (this.clients !== clients) {
-      const cols = Array.from(clients).map(getIndexColumns);
+      const cols = Array.from(clients, getIndexColumns);
       const from = cols[0]?.from;
       this.enabled = cols.every((c) => c && c.from === from);
       this.clients = clients;
-      this.indices = null;
       this.activeView = null;
+      this.clear();
     }
     if (!this.enabled)
       return false;
     active = active || this.selection.active;
     const { source } = active;
+    if (source && source === this.activeView?.source)
+      return true;
+    this.clear();
     if (!source)
       return false;
-    if (source === this.activeView?.source)
-      return true;
     const activeView = this.activeView = getActiveView(active);
     if (!activeView)
       return false;
     this.mc.logger().warn("DATA TILE INDEX CONSTRUCTION");
-    const sel = this.selection.clone().update({ source });
+    const sel = this.selection.remove(source);
     const indices = this.indices = /* @__PURE__ */ new Map();
-    const promises = [];
     for (const client of clients) {
-      if (sel.cross && skipClient(client, active))
+      if (sel.skip(client, active))
         continue;
       const index = getIndexColumns(client);
       const query = client.query(sel.predicate(client)).select({ ...activeView.columns, ...index.count }).groupby(Object.keys(activeView.columns));
@@ -12387,11 +12571,10 @@ var DataTileIndexer = class {
       }
       const sql2 = query.toString();
       const id = (fnv_hash(sql2) >>> 0).toString(16);
-      const table = `tile_index_${id}`;
-      indices.set(client, { table, ...index });
-      promises.push(createIndex(this.mc, table, sql2));
+      const table2 = `tile_index_${id}`;
+      const result = createIndex(this.mc, table2, sql2);
+      indices.set(client, { table: table2, result, ...index });
     }
-    return promises;
   }
   async update() {
     const { clients, selection, activeView } = this;
@@ -12407,11 +12590,9 @@ var DataTileIndexer = class {
     if (!filter) {
       filter = this.activeView.predicate(this.selection.active.predicate);
     }
-    const { table, dims, aggr } = index;
-    return this.mc.updateClient(
-      client,
-      Query.select(dims, aggr).from(table).groupby(dims).where(filter)
-    );
+    const { table: table2, dims, aggr } = index;
+    const query = Query.select(dims, aggr).from(table2).groupby(dims).where(filter);
+    return this.mc.updateClient(client, query);
   }
 };
 function getActiveView(clause) {
@@ -12419,19 +12600,19 @@ function getActiveView(clause) {
   let columns = clause.predicate?.columns;
   if (!schema || !columns)
     return null;
-  const { type, scales } = schema;
+  const { type, scales, pixelSize = 1 } = schema;
   let predicate;
   if (type === "interval" && scales) {
-    const bins = scales.map((s) => binInterval(s));
+    const bins = scales.map((s) => binInterval(s, pixelSize));
     if (bins.some((b) => b == null))
       return null;
     if (bins.length === 1) {
-      predicate = (p) => p ? isBetween("active0", p.value.map(bins[0])) : [];
-      columns = { active0: bins[0](clause.predicate.expr) };
+      predicate = (p) => p ? isBetween("active0", p.range.map(bins[0])) : [];
+      columns = { active0: bins[0](clause.predicate.field) };
     } else {
-      predicate = (p) => p ? and(p.value.map(({ value }, i) => isBetween(`active${i}`, value.map(bins[i])))) : [];
+      predicate = (p) => p ? and(p.children.map(({ range }, i) => isBetween(`active${i}`, range.map(bins[i])))) : [];
       columns = Object.fromEntries(
-        clause.predicate.value.map((p, i) => [`active${i}`, bins[i](p.expr)])
+        clause.predicate.children.map((p, i) => [`active${i}`, bins[i](p.field)])
       );
     }
   } else if (type === "point") {
@@ -12442,49 +12623,43 @@ function getActiveView(clause) {
   }
   return { source, columns, predicate };
 }
-function binInterval(scale) {
-  const { type, domain, range: range2 } = scale;
-  let lift, sql2;
+function binInterval(scale, pixelSize) {
+  const { type, domain, range } = scale;
+  let lift, toSql;
   switch (type) {
     case "linear":
       lift = identity;
-      sql2 = asColumn;
+      toSql = asColumn;
       break;
     case "log":
       lift = Math.log;
-      sql2 = (c) => `LN(${asColumn(c)})`;
+      toSql = (c) => sql`LN(${asColumn(c)})`;
       break;
     case "symlog":
       lift = (x) => Math.sign(x) * Math.log1p(Math.abs(x));
-      sql2 = (c) => (c = asColumn(c), `SIGN(${c}) * LN(1 + ABS(${c}))`);
+      toSql = (c) => (c = asColumn(c), sql`SIGN(${c}) * LN(1 + ABS(${c}))`);
       break;
     case "sqrt":
       lift = Math.sqrt;
-      sql2 = (c) => `SQRT(${asColumn(c)})`;
+      toSql = (c) => sql`SQRT(${asColumn(c)})`;
       break;
     case "utc":
     case "time":
       lift = (x) => +x;
-      sql2 = (c) => c instanceof Date ? +c : epoch_ms(asColumn(c));
+      toSql = (c) => c instanceof Date ? +c : epoch_ms(asColumn(c));
       break;
   }
-  return lift ? binFunction(domain, range2, lift, sql2) : null;
+  return lift ? binFunction(domain, range, pixelSize, lift, toSql) : null;
 }
-function binFunction(domain, range2, lift, sql2) {
+function binFunction(domain, range, pixelSize, lift, toSql) {
   const lo = lift(Math.min(domain[0], domain[1]));
   const hi = lift(Math.max(domain[0], domain[1]));
-  const a = Math.abs(lift(range2[1]) - lift(range2[0])) / (hi - lo);
-  return (value) => expr(
-    `FLOOR(${a}::DOUBLE * (${sql2(value)} - ${lo}::DOUBLE))`,
-    asColumn(value).columns
-  );
+  const a = Math.abs(lift(range[1]) - lift(range[0])) / (hi - lo) / pixelSize;
+  const s = pixelSize === 1 ? "" : `${pixelSize}::INTEGER * `;
+  return (value) => sql`${s}FLOOR(${a}::DOUBLE * (${toSql(value)} - ${lo}::DOUBLE))::INTEGER`;
 }
-async function createIndex(mc, table, query) {
-  try {
-    await mc.exec(`CREATE TEMP TABLE IF NOT EXISTS ${table} AS ${query}`);
-  } catch (err) {
-    mc.logger().error(err);
-  }
+function createIndex(mc, table2, query) {
+  return mc.exec(`CREATE TEMP TABLE IF NOT EXISTS ${table2} AS ${query}`);
 }
 var NO_INDEX = { from: NaN };
 function getIndexColumns(client) {
@@ -12495,24 +12670,24 @@ function getIndexColumns(client) {
   if (!from || !q.groupby)
     return NO_INDEX;
   const g = new Set(q.groupby().map((c) => c.column));
-  let aggr = [];
-  let dims = [];
+  const aggr = [];
+  const dims = [];
   let count2;
   for (const { as, expr: { aggregate } } of q.select()) {
     switch (aggregate?.toUpperCase()) {
       case "COUNT":
       case "SUM":
-        aggr.push({ [as]: expr(`SUM("${as}")::DOUBLE`) });
+        aggr.push({ [as]: sql`SUM("${as}")::DOUBLE` });
         break;
       case "AVG":
         count2 = "_count_";
-        aggr.push({ [as]: expr(`(SUM("${as}" * ${count2}) / SUM(${count2}))::DOUBLE`) });
+        aggr.push({ [as]: sql`(SUM("${as}" * ${count2}) / SUM(${count2}))::DOUBLE` });
         break;
       case "MAX":
-        aggr.push({ [as]: expr(`MAX("${as}")`) });
+        aggr.push({ [as]: sql`MAX("${as}")` });
         break;
       case "MIN":
-        aggr.push({ [as]: expr(`MIN("${as}")`) });
+        aggr.push({ [as]: sql`MIN("${as}")` });
         break;
       default:
         if (g.has(as))
@@ -12524,7 +12699,7 @@ function getIndexColumns(client) {
   return {
     aggr,
     dims,
-    count: count2 ? { [count2]: expr("COUNT(*)") } : {},
+    count: count2 ? { [count2]: sql`COUNT(*)` } : {},
     from
   };
 }
@@ -12537,7 +12712,7 @@ function getBaseTable(query) {
     if (subq.length === 0)
       return from[0].from.table;
   }
-  let base = getBaseTable(subq[0]);
+  const base = getBaseTable(subq[0]);
   for (let i = 1; i < subq.length; ++i) {
     const from = getBaseTable(subq[i]);
     if (from === void 0)
@@ -12561,42 +12736,6 @@ function subqueryPushdown(query, cols) {
   pushdown(query);
 }
 
-// ../core/src/util/throttle.js
-var NIL = {};
-function throttle(callback, debounce = false) {
-  let curr;
-  let next;
-  let pending = NIL;
-  function invoke(event) {
-    curr = callback(event).then(() => {
-      if (next) {
-        const { value } = next;
-        next = null;
-        invoke(value);
-      } else {
-        curr = null;
-      }
-    });
-  }
-  function enqueue(event) {
-    next = { event };
-  }
-  function process(event) {
-    curr ? enqueue(event) : invoke(event);
-  }
-  function delay(event) {
-    if (pending !== event) {
-      requestAnimationFrame(() => {
-        const e = pending;
-        pending = NIL;
-        process(e);
-      });
-    }
-    pending = event;
-  }
-  return debounce ? delay : process;
-}
-
 // ../core/src/FilterGroup.js
 var FilterGroup = class {
   constructor(coordinator2, selection, index = true) {
@@ -12605,10 +12744,8 @@ var FilterGroup = class {
     this.clients = /* @__PURE__ */ new Set();
     this.indexer = index ? new DataTileIndexer(this.mc, selection) : null;
     const { value, activate } = this.handlers = {
-      value: throttle(() => this.update()),
-      activate: (clause) => {
-        this.indexer?.index(this.clients, clause);
-      }
+      value: () => this.update(),
+      activate: (clause) => this.indexer?.index(this.clients, clause)
     };
     selection.addEventListener("value", value);
     selection.addEventListener("activate", activate);
@@ -12631,7 +12768,7 @@ var FilterGroup = class {
     }
     return this;
   }
-  async update() {
+  update() {
     const { mc, indexer, clients, selection } = this;
     return indexer?.index(clients) ? indexer.update() : defaultUpdate(mc, clients, selection);
   }
@@ -12645,79 +12782,425 @@ function defaultUpdate(mc, clients, selection) {
   }));
 }
 
-// ../core/src/QueryCache.js
-var requestIdle = typeof requestIdleCallback !== "undefined" ? requestIdleCallback : setTimeout;
-var voidCache = () => ({
-  get: () => void 0,
-  set: (key, result) => result,
-  clear: () => {
+// ../core/src/util/query-result.js
+function queryResult() {
+  let resolve;
+  let reject;
+  const p = new Promise((r, e) => {
+    resolve = r;
+    reject = e;
+  });
+  p.fulfill = (value) => (resolve(value), p);
+  p.reject = (err) => (reject(err), p);
+  return p;
+}
+
+// ../core/src/QueryConsolidator.js
+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);
+    }
   }
-});
-var QueryCache = class {
-  constructor({
-    max: max2 = 1e3,
-    // max entries
-    ttl = 3 * 60 * 60 * 1e3
-    // time-to-live, default 3 hours
-  } = {}) {
-    this.max = max2;
-    this.ttl = ttl;
-    this.clear();
+  return {
+    add(entry, priority) {
+      if (entry.request.type === "arrow") {
+        id = id || requestAnimationFrame(() => 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);
   }
-  clear() {
-    this.cache = /* @__PURE__ */ new Map();
+  return groups;
+}
+function consolidationKey(query, cache) {
+  const sql2 = `${query}`;
+  if (query instanceof Query && !cache.get(sql2)) {
+    if (query.orderby().length || query.where().length || 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;
   }
-  get(key) {
-    const entry = this.cache.get(key);
-    if (entry) {
-      entry.last = performance.now();
-      return entry.promise;
+}
+function consolidate(group, enqueue, record) {
+  if (shouldConsolidate(group)) {
+    enqueue({
+      request: {
+        type: "arrow",
+        cache: false,
+        record: false,
+        query: consolidatedQuery(group, record)
+      },
+      result: group.result = queryResult()
+    });
+  } else {
+    for (const { entry, priority } of group) {
+      enqueue(entry, priority);
+    }
+  }
+}
+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;
+      }
+    }
+  }
+  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]);
+    }
+    record(`${query2}`);
+  }
+  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));
+  }
+  return query.$select(Array.from(fields.values()));
+}
+async function processResults(group, cache) {
+  const { maps, result } = group;
+  if (!maps)
+    return;
+  let data;
+  try {
+    data = await result;
+  } catch (err) {
+    for (const { entry } of group) {
+      entry.result.reject(err);
+    }
+    return;
+  }
+  group.forEach(({ entry }, index) => {
+    const { request, result: result2 } = entry;
+    const projected = projectResult(data, maps[index]);
+    if (request.cache) {
+      cache.set(String(request.query), projected);
+    }
+    result2.fulfill(projected);
+  });
+}
+function projectResult(data, map) {
+  if (map) {
+    const cols = {};
+    for (const [name, as] of map) {
+      cols[as] = data.getChild(name);
     }
+    return new data.constructor(cols);
+  } else {
+    return data;
   }
-  set(key, promise) {
-    const { cache, max: max2 } = this;
-    cache.set(key, { last: performance.now(), promise });
-    if (cache.size > max2)
-      requestIdle(() => this.evict());
-    return promise;
+}
+
+// ../core/src/util/cache.js
+var requestIdle = typeof requestIdleCallback !== "undefined" ? requestIdleCallback : setTimeout;
+var voidCache = () => ({
+  get: () => void 0,
+  set: (key, value) => value,
+  clear: () => {
   }
-  evict() {
-    const expire = performance.now() - this.ttl;
+});
+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 this.cache) {
+    for (const [key, value] of cache) {
       const { last: last2 } = value;
       if (last2 < lruLast) {
         lruKey = key;
         lruLast = last2;
       }
       if (expire > last2) {
-        this.cache.delete(key);
+        cache.delete(key);
       }
     }
     if (lruKey) {
-      this.cache.delete(lruKey);
+      cache.delete(lruKey);
     }
   }
-};
-
-// ../core/src/util/void-logger.js
-function voidLogger() {
   return {
-    debug() {
-    },
-    info() {
-    },
-    log() {
+    get(key) {
+      const entry = cache.get(key);
+      if (entry) {
+        entry.last = performance.now();
+        return entry.value;
+      }
     },
-    warn() {
+    set(key, value) {
+      cache.set(key, { last: performance.now(), value });
+      if (cache.size > max2)
+        requestIdle(evict);
+      return value;
     },
-    error() {
+    clear() {
+      cache = /* @__PURE__ */ new Map();
     }
   };
 }
 
-// ../core/src/Coordinator.js
+// ../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 };
+function QueryManager() {
+  const queue = priorityQueue(3);
+  let db;
+  let clientCache;
+  let logger;
+  let recorders = [];
+  let pending = null;
+  let consolidate2;
+  function next() {
+    if (pending || queue.isEmpty())
+      return;
+    const { request, result } = queue.next();
+    pending = submit(request, result);
+    pending.finally(() => {
+      pending = null;
+      next();
+    });
+  }
+  function enqueue(entry, priority = Priority.Normal) {
+    queue.insert(entry, priority);
+    next();
+  }
+  function recordQuery(sql2) {
+    if (recorders.length && sql2) {
+      recorders.forEach((rec) => rec.add(sql2));
+    }
+  }
+  async function submit(request, result) {
+    try {
+      const { query, type, cache = false, record = true, options } = request;
+      const sql2 = query ? `${query}` : null;
+      if (record) {
+        recordQuery(sql2);
+      }
+      if (cache) {
+        const cached = clientCache.get(sql2);
+        if (cached) {
+          logger.debug("Cache");
+          result.fulfill(cached);
+          return;
+        }
+      }
+      const t0 = performance.now();
+      const data = await db.query({ type, sql: sql2, ...options });
+      if (cache)
+        clientCache.set(sql2, data);
+      logger.debug(`Request: ${(performance.now() - t0).toFixed(1)}`);
+      result.fulfill(data);
+    } catch (err) {
+      result.reject(err);
+    }
+  }
+  return {
+    cache(value) {
+      return value !== void 0 ? clientCache = value === true ? lruCache() : value || voidCache() : clientCache;
+    },
+    logger(value) {
+      return value ? logger = value : logger;
+    },
+    connector(connector) {
+      return connector ? db = connector : db;
+    },
+    consolidate(flag) {
+      if (flag && !consolidate2) {
+        consolidate2 = consolidator(enqueue, clientCache, recordQuery);
+      } else if (!flag && consolidate2) {
+        consolidate2 = null;
+      }
+    },
+    request(request, priority = Priority.Normal) {
+      const result = queryResult();
+      const entry = { request, result };
+      if (consolidate2) {
+        consolidate2.add(entry, priority);
+      } else {
+        enqueue(entry, priority);
+      }
+      return result;
+    },
+    cancel(requests) {
+      const set = new Set(requests);
+      queue.remove(({ result }) => set.has(result));
+    },
+    clear() {
+      queue.remove(({ result }) => {
+        result.reject("Cleared");
+        return true;
+      });
+    },
+    record() {
+      let state = [];
+      const recorder = {
+        add(query) {
+          state.push(query);
+        },
+        reset() {
+          state = [];
+        },
+        snapshot() {
+          return state.slice();
+        },
+        stop() {
+          recorders = recorders.filter((x) => x !== recorder);
+          return state;
+        }
+      };
+      recorders.push(recorder);
+      return recorder;
+    }
+  };
+}
+
+// ../core/src/util/void-logger.js
+function voidLogger() {
+  return {
+    debug() {
+    },
+    info() {
+    },
+    log() {
+    },
+    warn() {
+    },
+    error() {
+    }
+  };
+}
+
+// ../core/src/Coordinator.js
 var _instance;
 function coordinator(instance9) {
   if (instance9) {
@@ -12728,21 +13211,28 @@ function coordinator(instance9) {
   return _instance;
 }
 var Coordinator = class {
-  constructor(db = socketClient(), options = {}) {
+  constructor(db = socketConnector(), options = {}) {
     this.catalog = new Catalog(this);
+    this.manager = options.manager || QueryManager();
     this.logger(options.logger || console);
     this.configure(options);
-    this.databaseClient(db);
+    this.databaseConnector(db);
     this.clear();
   }
   logger(logger) {
-    return arguments.length ? this._logger = logger || voidLogger() : this._logger;
+    if (arguments.length) {
+      this._logger = logger || voidLogger();
+      this.manager.logger(this._logger);
+    }
+    return this._logger;
   }
-  configure({ cache = true, indexes = true }) {
-    this.cache = cache ? new QueryCache() : voidCache();
+  configure({ cache = true, consolidate: consolidate2 = true, indexes = true }) {
+    this.manager.cache(cache);
+    this.manager.consolidate(consolidate2);
     this.indexes = indexes;
   }
   clear({ clients = true, cache = true, catalog = false } = {}) {
+    this.manager.clear();
     if (clients) {
       this.clients?.forEach((client) => this.disconnect(client));
       this.filterGroups?.forEach((group) => group.finalize());
@@ -12750,57 +13240,59 @@ var Coordinator = class {
       this.filterGroups = /* @__PURE__ */ new Map();
     }
     if (cache)
-      this.cache.clear();
+      this.manager.cache().clear();
     if (catalog)
       this.catalog.clear();
   }
-  databaseClient(db) {
-    if (arguments.length > 0) {
-      this.db = db;
-    }
-    return this.db;
+  databaseConnector(db) {
+    return this.manager.connector(db);
   }
-  async exec(sql2) {
-    try {
-      await this.db.query({ type: "exec", sql: sql2 });
-    } catch (err) {
-      this._logger.error(err);
-    }
+  // -- Query Management ----
+  cancel(requests) {
+    this.manager.cancel(requests);
   }
-  query(query, { type = "arrow", cache = true } = {}) {
-    const sql2 = String(query);
-    const t0 = performance.now();
-    const cached = this.cache.get(sql2);
-    if (cached) {
-      this._logger.debug("Cache");
-      return cached;
-    } else {
-      const request = this.db.query({ type, sql: sql2 });
-      const result = cache ? this.cache.set(sql2, request) : request;
-      result.then(() => this._logger.debug(`Query: ${performance.now() - t0}`));
-      return result;
-    }
+  exec(query, { priority = Priority.Normal } = {}) {
+    return this.manager.request({ type: "exec", query }, priority);
   }
-  async updateClient(client, query) {
-    let result;
-    try {
-      client.queryPending();
-      result = await this.query(query);
-    } catch (err) {
-      this._logger.error(err);
-      client.queryError(err);
-      return;
-    }
-    try {
-      client.queryResult(result).update();
-    } catch (err) {
-      this._logger.error(err);
-    }
+  query(query, {
+    type = "arrow",
+    cache = true,
+    priority = Priority.Normal,
+    ...options
+  } = {}) {
+    return this.manager.request({ type, query, cache, options }, priority);
+  }
+  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);
   }
-  async requestQuery(client, query) {
+  // -- 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);
+      }
+    );
+  }
+  requestQuery(client, query) {
     this.filterGroups.get(client.filterBy)?.reset();
     return query ? this.updateClient(client, query) : client.update();
   }
+  /**
+   * Connect a client to the coordinator.
+   *
+   * @param {import('./MosaicClient.js').MosaicClient} client the client to disconnect
+   */
   async connect(client) {
     const { catalog, clients, filterGroups, indexes } = this;
     if (clients.has(client)) {
@@ -12809,7 +13301,7 @@ var Coordinator = class {
     clients.add(client);
     const fields = client.fields();
     if (fields?.length) {
-      client.fieldStats(await catalog.queryFields(fields));
+      client.fieldInfo(await catalog.queryFields(fields));
     }
     const filter = client.filterBy;
     if (filter) {
@@ -12822,6 +13314,11 @@ var Coordinator = class {
     }
     client.requestQuery();
   }
+  /**
+   * Disconnect a client from the coordinator.
+   *
+   * @param {import('./MosaicClient.js').MosaicClient} client the client to disconnect
+   */
   disconnect(client) {
     const { clients, filterGroups } = this;
     if (!clients.has(client))
@@ -12831,6 +13328,42 @@ var Coordinator = class {
   }
 };
 
+// ../core/src/util/throttle.js
+var NIL = {};
+function throttle(callback, debounce = false) {
+  let curr;
+  let next;
+  let pending = NIL;
+  function invoke(event) {
+    curr = callback(event).then(() => {
+      if (next) {
+        const { value } = next;
+        next = null;
+        invoke(value);
+      } else {
+        curr = null;
+      }
+    });
+  }
+  function enqueue(event) {
+    next = { event };
+  }
+  function process(event) {
+    curr ? enqueue(event) : invoke(event);
+  }
+  function delay(event) {
+    if (pending !== event) {
+      requestAnimationFrame(() => {
+        const e = pending;
+        pending = NIL;
+        process(e);
+      });
+    }
+    pending = event;
+  }
+  return debounce ? delay : process;
+}
+
 // ../core/src/MosaicClient.js
 var MosaicClient = class {
   /**
@@ -12864,10 +13397,10 @@ var MosaicClient = class {
     return null;
   }
   /**
-   * Called by the coordinator to set the field statistics for this client.
+   * Called by the coordinator to set the field info for this client.
    * @returns {this}
    */
-  fieldStats() {
+  fieldInfo() {
     return this;
   }
   /**
@@ -12884,6 +13417,9 @@ var MosaicClient = class {
   }
   /**
    * Called by the coordinator to return a query result.
+   * 
+   * @param {*} data the query result
+   * @returns {this}
    */
   queryResult() {
     return this;
@@ -12922,6 +13458,163 @@ var MosaicClient = class {
   }
 };
 
+// ../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: *) => 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);
+  }
+  /**
+   * Remove an event listener callback for the provided event type.
+   * @param {string} type The event type.
+   * @param {(value: *) => Promise?} callback The event handler
+   *  callback function to remove.
+   */
+  removeEventListener(type, callback) {
+    const entry = this._callbacks.get(type);
+    if (entry) {
+      entry.callbacks.delete(callback);
+    }
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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 {*} 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() {
+    return null;
+  }
+  /**
+   * 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();
+  }
+  /**
+   * 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 {
+      const event = this.willEmit(type, value);
+      const { callbacks, queue } = entry;
+      if (callbacks?.size) {
+        const promise = Promise.allSettled(Array.from(callbacks, (callback) => callback(event))).then(() => {
+          entry.pending = null;
+          if (!queue.isEmpty()) {
+            this.emit(type, queue.dequeue());
+          }
+        });
+        entry.pending = promise;
+      }
+    }
+  }
+};
+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;
+  }
+  /**
+   * 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;
+        }
+      }
+      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;
@@ -12940,40 +13633,74 @@ function distinctArray(a, b) {
 function isParam(x) {
   return x instanceof Param;
 }
-var Param = class {
+var Param = class extends AsyncDispatch {
+  /**
+   * Create a new Param instance.
+   * @param {*} value The initial value of the Param.
+   */
   constructor(value) {
+    super();
     this._value = value;
-    this._listeners = /* @__PURE__ */ new Map();
   }
+  /**
+   * 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);
   }
+  /**
+   * 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);
+  }
+  /**
+   * 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 changed = distinct(this._value, value);
-    if (changed)
-      this._value = value;
-    if (changed || force)
-      this.emit("value", this.value);
-    return this;
-  }
-  addEventListener(type, callback) {
-    let list = this._listeners.get(type) || [];
-    if (!list.includes(callback)) {
-      list = list.concat(callback);
+    const shouldEmit = distinct(this._value, value) || force;
+    if (shouldEmit) {
+      this.emit("value", value);
+    } else {
+      this.cancel("value");
     }
-    this._listeners.set(type, list);
+    return this;
   }
-  removeEventListener(type, callback) {
-    const list = this._listeners.get(type);
-    if (list?.length) {
-      this._listeners.set(type, list.filter((x) => x !== callback));
+  /**
+   * 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;
     }
-  }
-  emit(type, event) {
-    this._listeners.get(type)?.forEach((l) => l(event));
+    return value;
   }
 };
 
@@ -12982,66 +13709,254 @@ function isSelection(x) {
   return x instanceof Selection;
 }
 var Selection = class extends Param {
-  static intersect() {
-    return new Selection();
+  /**
+   * 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 }));
   }
-  static crossfilter() {
-    return new Selection({ cross: true });
+  /**
+   * 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 }));
   }
-  static union() {
-    return new Selection({ 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 }));
   }
-  static single() {
-    return new Selection({ 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 }));
   }
-  constructor({ union, cross, single } = {}) {
+  /**
+   * Create a new Selection instance.
+   * @param {SelectionResolver} resolver The selection resolution
+   *  strategy to apply.
+   */
+  constructor(resolver = new SelectionResolver()) {
     super([]);
-    this.active = null;
-    this.union = !!union;
-    this.cross = !!cross;
-    this.single = !!single;
+    this._resolved = this._value;
+    this._resolver = resolver;
   }
+  /**
+   * Create a cloned copy of this Selection instance.
+   * @returns {this} A clone of this selection.
+   */
   clone() {
-    const s = new Selection();
-    s.active = this.active;
-    s.union = this.union;
-    s.cross = this.cross;
-    s._value = this._value;
+    const s = new Selection(this._resolver);
+    s._value = s._resolved = this._value;
+    return s;
+  }
+  /**
+   * Create a clone of this Selection with clauses corresponding
+   * to provided source removed.
+   * @param {*} source The clause source to remove.
+   * @returns {this} 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 current active (most recently updated) selection clause.
+   */
+  get active() {
+    return this.clauses.active;
+  }
+  /**
+   * The value corresponding to the current active selection clause.
+   * This method ensures compatibility where a normal Param is expected.
+   */
   get value() {
-    const { clauses } = this;
-    return clauses[clauses.length - 1]?.value;
+    return this.active?.value;
   }
+  /**
+   * The current array of selection clauses.
+   */
   get clauses() {
     return super.value;
   }
+  /**
+   * Indicate if this selection has a single resolution strategy.
+   */
+  get single() {
+    return this._resolver.single;
+  }
+  /**
+   * Emit an activate event with the given selection clause.
+   * @param {*} clause The clause repesenting the potential activation.
+   */
   activate(clause) {
     this.emit("activate", clause);
   }
+  /**
+   * 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);
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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 input event value.
+   * @returns {*} For value-typed events, returns a dispatch queue filter
+   *  function. Otherwise returns null.
+   */
+  emitQueueFilter(type, value) {
+    return type === "value" ? this._resolver.queueFilter(value) : null;
+  }
+  /**
+   * 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);
+  }
+  /**
+   * Return a selection query predicate for the given client.
+   * @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(client) {
+    const { clauses } = this;
+    return this._resolver.predicate(clauses, clauses.active, client);
+  }
+};
+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;
+  }
+  /**
+   * 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;
-    this.active = clause;
-    const clauses = this.single ? [] : this.clauses.filter((c) => source !== c.source);
+    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 super.update(clauses);
+    return clauses;
   }
-  predicate(client) {
-    const { active, clauses, cross, union } = this;
-    if (cross && skipClient(client, active))
+  /**
+   * 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);
+  }
+  /**
+   * 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 list = (cross ? clauses.filter((clause) => !skipClient(client, clause)) : clauses).map((s) => s.predicate);
-    return union && list.length > 1 ? or(list) : list;
+    const predicates = clauseList.filter((clause) => !this.skip(client, clause)).map((clause) => clause.predicate);
+    return union && predicates.length > 1 ? or(predicates) : predicates;
+  }
+  /**
+   * 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;
+    }
   }
 };
 
+// src/input.js
+function input(InputClass, options) {
+  const input2 = new InputClass(options);
+  coordinator().connect(input2);
+  return input2.element;
+}
+
 // src/Menu.js
 var isObject2 = (v) => {
   return v && typeof v === "object" && !Array.isArray(v);
 };
+var menu = (options) => input(Menu, options);
 var Menu = class extends MosaicClient {
   constructor({
+    element,
     filterBy,
     from,
     column: column2,
@@ -13057,7 +13972,7 @@ var Menu = class extends MosaicClient {
     this.column = column2;
     this.selection = as;
     this.format = format2;
-    this.element = document.createElement("div");
+    this.element = element ?? document.createElement("div");
     this.element.setAttribute("class", "input");
     this.element.value = this;
     const lab = document.createElement("label");
@@ -13069,13 +13984,12 @@ var Menu = class extends MosaicClient {
       this.update();
     }
     value = value ?? this.selection?.value ?? this.data?.[0]?.value;
-    this.select.value = value;
     if (this.selection?.value === void 0)
       this.publish(value);
     this.element.appendChild(this.select);
     if (this.selection) {
       this.select.addEventListener("input", () => {
-        this.publish(this.selectedValue() || null);
+        this.publish(this.selectedValue() ?? null);
       });
       if (!isSelection(this.selection)) {
         this.selection.addEventListener("value", (value2) => {
@@ -13091,9 +14005,17 @@ var Menu = class extends MosaicClient {
       const index = this.select.selectedIndex;
       return this.data[index].value;
     } else {
-      this.select.value = String(value);
+      const index = this.data?.findIndex((opt) => opt.value === value);
+      if (index >= 0) {
+        this.select.selectedIndex = index;
+      } else {
+        this.select.value = String(value);
+      }
     }
   }
+  reset() {
+    this.select.selectedIndex = this.from ? 0 : -1;
+  }
   publish(value) {
     const { selection, column: column2 } = this;
     if (isSelection(selection)) {
@@ -13127,7 +14049,7 @@ var Menu = class extends MosaicClient {
       this.select.appendChild(opt);
     }
     if (this.selection) {
-      this.select.value = this.selection?.value || "";
+      this.selectedValue(this.selection?.value ?? "");
     }
     return this;
   }
@@ -13136,13 +14058,15 @@ var Menu = class extends MosaicClient {
 // src/Search.js
 var FUNCTIONS = { contains, prefix, suffix, regexp: regexp_matches };
 var _id = 0;
+var search = (options) => input(Search, options);
 var Search = class extends MosaicClient {
   constructor({
+    element,
     filterBy,
     from,
     column: column2,
     label,
-    type,
+    type = "contains",
     as
   } = {}) {
     super(filterBy);
@@ -13151,7 +14075,7 @@ var Search = class extends MosaicClient {
     this.from = from;
     this.column = column2;
     this.selection = as;
-    this.element = document.createElement("div");
+    this.element = element ?? document.createElement("div");
     this.element.setAttribute("class", "input");
     this.element.value = this;
     if (label) {
@@ -13178,6 +14102,9 @@ var Search = class extends MosaicClient {
       }
     }
   }
+  reset() {
+    this.searchbox.value = "";
+  }
   publish(value) {
     const { selection, column: column2, type } = this;
     if (isSelection(selection)) {
@@ -13220,8 +14147,10 @@ var Search = class extends MosaicClient {
 
 // src/Slider.js
 var _id2 = 0;
+var slider = (options) => input(Slider, options);
 var Slider = class extends MosaicClient {
   constructor({
+    element,
     filterBy,
     as,
     min: min2,
@@ -13230,7 +14159,8 @@ var Slider = class extends MosaicClient {
     from,
     column: column2,
     label = column2,
-    value = as?.value
+    value = as?.value,
+    width
   } = {}) {
     super(filterBy);
     this.id = "slider_" + ++_id2;
@@ -13240,7 +14170,7 @@ var Slider = class extends MosaicClient {
     this.min = min2;
     this.max = max2;
     this.step = step;
-    this.element = document.createElement("div");
+    this.element = element || document.createElement("div");
     this.element.setAttribute("class", "input");
     this.element.value = this;
     if (label) {
@@ -13252,6 +14182,8 @@ var Slider = class extends MosaicClient {
     this.slider = document.createElement("input");
     this.slider.setAttribute("id", this.id);
     this.slider.setAttribute("type", "range");
+    if (width != null)
+      this.slider.style.width = `${+width}px`;
     if (min2 != null)
       this.slider.setAttribute("min", min2);
     if (max2 != null)
@@ -13347,33 +14279,40 @@ function localize(f) {
 
 // src/Table.js
 var _id3 = -1;
+var table = (options) => input(Table2, options);
 var Table2 = class extends MosaicClient {
   constructor({
+    element,
     filterBy,
     from,
     columns = ["*"],
+    align = {},
     format: format2,
-    rowBatch = 100,
     width,
-    height = 500
+    maxWidth,
+    height = 500,
+    rowBatch = 100
   } = {}) {
     super(filterBy);
     this.id = `table-${++_id3}`;
     this.from = from;
     this.columns = columns;
     this.format = format2;
+    this.align = align;
+    this.widths = typeof width === "object" ? width : {};
     this.offset = 0;
     this.limit = +rowBatch;
     this.pending = false;
     this.sortHeader = null;
     this.sortColumn = null;
     this.sortDesc = false;
-    this.element = document.createElement("div");
+    this.element = element || document.createElement("div");
     this.element.setAttribute("id", this.id);
     this.element.value = this;
-    if (width) {
-      this.element.style.maxWidth = `${width}px`;
-    }
+    if (typeof width === "number")
+      this.element.style.width = `${width}px`;
+    if (maxWidth)
+      this.element.style.maxWidth = `${maxWidth}px`;
     this.element.style.maxHeight = `${height}px`;
     this.element.style.overflow = "auto";
     let prevScrollTop = -1;
@@ -13386,9 +14325,7 @@ var Table2 = class extends MosaicClient {
         return;
       if (scrollHeight - scrollTop < 2 * clientHeight) {
         this.pending = true;
-        this.offset += this.limit;
-        const query = this.queryInternal(this.filterBy?.predicate(this));
-        this.requestQuery(query);
+        this.requestData(this.offset + this.limit);
       }
     });
     this.tbl = document.createElement("table");
@@ -13400,15 +14337,21 @@ var Table2 = class extends MosaicClient {
     this.style = document.createElement("style");
     this.element.appendChild(this.style);
   }
+  requestData(offset = 0) {
+    this.offset = offset;
+    const query = this.query(this.filterBy?.predicate(this));
+    this.requestQuery(query);
+    coordinator().prefetch(query.clone().offset(offset + this.limit));
+  }
   fields() {
     return this.columns.map((name) => column(this.from, name));
   }
-  fieldStats(stats) {
-    this.stats = stats;
+  fieldInfo(info) {
+    this.schema = info;
     const thead = this.head;
     thead.innerHTML = "";
     const tr = document.createElement("tr");
-    for (const { column: column2 } of stats) {
+    for (const { column: column2 } of info) {
       const th = document.createElement("th");
       th.addEventListener("click", (evt) => this.sort(evt, column2));
       th.appendChild(document.createElement("span"));
@@ -13416,17 +14359,17 @@ var Table2 = class extends MosaicClient {
       tr.appendChild(th);
     }
     thead.appendChild(tr);
-    this.formats = formatof(this.format, stats);
-    this.style.innerText = tableCSS(this.id, alignof({}, stats));
+    this.formats = formatof(this.format, info);
+    this.style.innerText = tableCSS(
+      this.id,
+      alignof(this.align, info),
+      widthof(this.widths, info)
+    );
     return this;
   }
-  query(filter) {
-    this.offset = 0;
-    return this.queryInternal(filter);
-  }
-  queryInternal(filter = []) {
-    const { from, limit, offset, stats, sortColumn, sortDesc } = this;
-    return Query.from(from).select(stats.map((s) => s.column)).where(filter).orderby(sortColumn ? sortDesc ? desc(sortColumn) : sortColumn : []).limit(limit).offset(offset);
+  query(filter = []) {
+    const { from, limit, offset, schema, sortColumn, sortDesc } = this;
+    return Query.from(from).select(schema.map((s) => s.column)).where(filter).orderby(sortColumn ? sortDesc ? desc(sortColumn) : sortColumn : []).limit(limit).offset(offset);
   }
   queryResult(data) {
     if (!this.pending) {
@@ -13437,14 +14380,14 @@ var Table2 = class extends MosaicClient {
     return this;
   }
   update() {
-    const { body, formats, data, stats, limit } = this;
-    const nf = stats.length;
+    const { body, formats, data, schema, limit } = this;
+    const nf = schema.length;
     let count2 = 0;
     for (const row of data) {
       ++count2;
       const tr = document.createElement("tr");
       for (let i = 0; i < nf; ++i) {
-        const value = row[stats[i].column];
+        const value = row[schema[i].column];
         const td = document.createElement("td");
         td.innerText = value == null ? "" : formats[i](value);
         tr.appendChild(td);
@@ -13476,12 +14419,11 @@ var Table2 = class extends MosaicClient {
       this.sortHeader = th;
       th.firstChild.textContent = this.sortDesc ? "\u25BE" : "\u25B4";
     }
-    const query = this.query(this.filterBy?.predicate(this));
-    this.requestQuery(query);
+    this.requestData();
   }
 };
-function formatof(base = {}, stats, locale) {
-  return stats.map(({ column: column2, type }) => {
+function formatof(base = {}, schema, locale) {
+  return schema.map(({ column: column2, type }) => {
     if (column2 in base) {
       return base[column2];
     } else {
@@ -13496,8 +14438,8 @@ function formatof(base = {}, stats, locale) {
     }
   });
 }
-function alignof(base = {}, stats) {
-  return stats.map(({ column: column2, type }) => {
+function alignof(base = {}, schema) {
+  return schema.map(({ column: column2, type }) => {
     if (column2 in base) {
       return base[column2];
     } else if (type === "number") {
@@ -13507,11 +14449,17 @@ function alignof(base = {}, stats) {
     }
   });
 }
-function tableCSS(id, align) {
+function widthof(base = {}, schema) {
+  return schema.map(({ column: column2 }) => base[column2]);
+}
+function tableCSS(id, aligns, widths) {
   const styles = [];
-  align.forEach((a, i) => {
-    if (a !== "left") {
-      styles.push(`#${id} tr>:nth-child(${i + 1}) {text-align:${a}}`);
+  aligns.forEach((a, i) => {
+    const w = +widths[i];
+    if (a !== "left" || w) {
+      const align = a !== "left" ? `text-align:${a};` : "";
+      const width = w ? `width:${w}px;max-width:${w}px;` : "";
+      styles.push(`#${id} tr>:nth-child(${i + 1}) {${align}${width}}`);
     }
   });
   return styles.join(" ");
@@ -13520,5 +14468,9 @@ export {
   Menu,
   Search,
   Slider,
-  Table2 as Table
+  Table2 as Table,
+  menu,
+  search,
+  slider,
+  table
 };