@uwdata/mosaic-core 0.8.0 → 0.9.0

package/dist/mosaic-core.js

@@ -4914,10 +4914,10 @@ var getDictionary = (data, index) => {
 var getInterval = (data, index) => data.type.unit === IntervalUnit.DAY_TIME ? getIntervalDayTime(data, index) : getIntervalYearMonth(data, index);
 var getIntervalDayTime = ({ values }, index) => values.subarray(2 * index, 2 * (index + 1));
 var getIntervalYearMonth = ({ values }, index) => {
-  const interval = values[index];
+  const interval2 = values[index];
   const int32s = new Int32Array(2);
-  int32s[0] = Math.trunc(interval / 12);
-  int32s[1] = Math.trunc(interval % 12);
+  int32s[0] = Math.trunc(interval2 / 12);
+  int32s[1] = Math.trunc(interval2 % 12);
   return int32s;
 };
 var getDurationSecond = ({ values }, index) => values[index];
@@ -11839,6 +11839,13 @@ function socketConnector(uri = "ws://localhost:3000/") {
     get connected() {
       return connected;
     },
+    /**
+     * Query the DuckDB server.
+     * @param {object} query
+     * @param {'exec' | 'arrow' | 'json'} [query.type] The query type: 'exec', 'arrow', or 'json'.
+     * @param {string} query.sql A SQL query string.
+     * @returns the query result
+     */
     query(query) {
       return new Promise(
         (resolve, reject) => enqueue(query, resolve, reject)
@@ -11909,7 +11916,7 @@ function literalToSQL(value) {
     case "boolean":
       return value ? "TRUE" : "FALSE";
     case "string":
-      return `'${value}'`;
+      return `'${value.replace(`'`, `''`)}'`;
     case "number":
       return Number.isFinite(value) ? String(value) : "NULL";
     default:
@@ -11992,7 +11999,7 @@ var SQLExpression = class {
   /**
    * Annotate this expression instance with additional properties.
    * @param {object[]} [props] One or more objects with properties to add.
-   * @returns {this} This SQL expression.
+   * @returns This SQL expression.
    */
   annotate(...props) {
     return Object.assign(this, ...props);
@@ -12050,6 +12057,12 @@ function sql(strings, ...exprs) {
   return new SQLExpression(spans, cols);
 }
 
+// ../sql/src/literal.js
+var literal = (value) => ({
+  value,
+  toString: () => literalToSQL(value)
+});
+
 // ../sql/src/operators.js
 function visit(callback) {
   callback(this.op, this);
@@ -12248,6 +12261,9 @@ var last_value = winf("LAST_VALUE");
 var nth_value = winf("NTH_VALUE");
 
 // ../sql/src/aggregates.js
+function agg(strings, ...exprs) {
+  return sql(strings, ...exprs).annotate({ aggregate: true });
+}
 var AggregateFunction = class _AggregateFunction extends SQLExpression {
   /**
    * Create a new AggregateFunction instance.
@@ -12378,6 +12394,7 @@ var entropy = aggf("ENTROPY");
 var varPop = aggf("VAR_POP");
 var stddevPop = aggf("STDDEV_POP");
 var corr = aggf("CORR");
+var covariance = aggf("COVAR_SAMP");
 var covarPop = aggf("COVAR_POP");
 var regrIntercept = aggf("REGR_INTERCEPT");
 var regrSlope = aggf("REGR_SLOPE");
@@ -12520,7 +12537,8 @@ var Query = class _Query {
           }
         }
       }
-      query.select = query.select.concat(list);
+      const keys = new Set(list.map((x3) => x3.as));
+      query.select = query.select.filter((x3) => !keys.has(x3.as)).concat(list.filter((x3) => x3.expr));
       return this;
     }
   }
@@ -12993,6 +13011,7 @@ function scaleTime() {
   };
 }
 var scales = {
+  identity: scaleLinear,
   linear: scaleLinear,
   log: scaleLog,
   symlog: scaleSymlog,
@@ -13038,6 +13057,247 @@ function fnv_mix(a2) {
   return a2 & 4294967295;
 }
 
+// src/util/index-columns.js
+var NO_INDEX = { from: NaN };
+function indexColumns(client) {
+  if (!client.filterIndexable) return NO_INDEX;
+  const q2 = client.query();
+  const from = getBaseTable(q2);
+  if (typeof from !== "string" || !q2.groupby) return NO_INDEX;
+  const g2 = new Set(q2.groupby().map((c) => c.column));
+  const aggr = [];
+  const dims = [];
+  const aux = {};
+  for (const entry of q2.select()) {
+    const { as, expr: { aggregate, args } } = entry;
+    const op = aggregate?.toUpperCase?.();
+    switch (op) {
+      case "COUNT":
+      case "SUM":
+        aggr.push({ [as]: agg`SUM("${as}")::DOUBLE` });
+        break;
+      case "AVG":
+        aggr.push({ [as]: avgExpr(aux, as, args[0]) });
+        break;
+      case "ARG_MAX":
+        aggr.push({ [as]: argmaxExpr(aux, as, args) });
+        break;
+      case "ARG_MIN":
+        aggr.push({ [as]: argminExpr(aux, as, args) });
+        break;
+      case "VARIANCE":
+      case "VAR_SAMP":
+        aux[as] = null;
+        aggr.push({ [as]: varianceExpr(aux, args[0], from) });
+        break;
+      case "VAR_POP":
+        aux[as] = null;
+        aggr.push({ [as]: varianceExpr(aux, args[0], from, false) });
+        break;
+      case "STDDEV":
+      case "STDDEV_SAMP":
+        aux[as] = null;
+        aggr.push({ [as]: agg`SQRT(${varianceExpr(aux, args[0], from)})` });
+        break;
+      case "STDDEV_POP":
+        aux[as] = null;
+        aggr.push({ [as]: agg`SQRT(${varianceExpr(aux, args[0], from, false)})` });
+        break;
+      case "COVAR_SAMP":
+        aux[as] = null;
+        aggr.push({ [as]: covarianceExpr(aux, args, from) });
+        break;
+      case "COVAR_POP":
+        aux[as] = null;
+        aggr.push({ [as]: covarianceExpr(aux, args, from, false) });
+        break;
+      case "CORR":
+        aux[as] = null;
+        aggr.push({ [as]: corrExpr(aux, args, from) });
+        break;
+      case "REGR_COUNT":
+        aux[as] = null;
+        aggr.push({ [as]: agg`${regrCountExpr(aux, args)}::DOUBLE` });
+        break;
+      case "REGR_AVGX":
+        aux[as] = null;
+        aggr.push({ [as]: regrAvgXExpr(aux, args) });
+        break;
+      case "REGR_AVGY":
+        aux[as] = null;
+        aggr.push({ [as]: regrAvgYExpr(aux, args) });
+        break;
+      case "REGR_SYY":
+        aux[as] = null;
+        aggr.push({ [as]: regrVarExpr(aux, 0, args, from) });
+        break;
+      case "REGR_SXX":
+        aux[as] = null;
+        aggr.push({ [as]: regrVarExpr(aux, 1, args, from) });
+        break;
+      case "REGR_SXY":
+        aux[as] = null;
+        aggr.push({ [as]: covarianceExpr(aux, args, from, null) });
+        break;
+      case "REGR_SLOPE":
+        aux[as] = null;
+        aggr.push({ [as]: regrSlopeExpr(aux, args, from) });
+        break;
+      case "REGR_INTERCEPT":
+        aux[as] = null;
+        aggr.push({ [as]: regrInterceptExpr(aux, args, from) });
+        break;
+      case "REGR_R2":
+        aux[as] = null;
+        aggr.push({ [as]: agg`(${corrExpr(aux, args, from)}) ** 2` });
+        break;
+      case "MAX":
+      case "MIN":
+      case "BIT_AND":
+      case "BIT_OR":
+      case "BIT_XOR":
+      case "BOOL_AND":
+      case "BOOL_OR":
+      case "PRODUCT":
+        aggr.push({ [as]: agg`${op}("${as}")` });
+        break;
+      default:
+        if (g2.has(as)) dims.push(as);
+        else return null;
+    }
+  }
+  return { from, dims, aggr, aux };
+}
+function auxName(type, ...args) {
+  const cols = args.length ? "_" + args.map(sanitize).join("_") : "";
+  return `__${type}${cols}__`;
+}
+function sanitize(col) {
+  return `${col}`.replaceAll('"', "").replaceAll(" ", "_");
+}
+function getBaseTable(query) {
+  const subq = query.subqueries;
+  if (query.select) {
+    const from = query.from();
+    if (!from.length) return void 0;
+    if (subq.length === 0) return from[0].from.table;
+  }
+  const base = getBaseTable(subq[0]);
+  for (let i = 1; i < subq.length; ++i) {
+    const from = getBaseTable(subq[i]);
+    if (from === void 0) continue;
+    if (from !== base) return NaN;
+  }
+  return base;
+}
+function countExpr(aux, arg) {
+  const n = auxName("count", arg);
+  aux[n] = agg`COUNT(${arg})`;
+  return agg`SUM(${n})`.annotate({ name: n });
+}
+function avgExpr(aux, as, arg) {
+  const n = countExpr(aux, arg);
+  return agg`(SUM("${as}" * ${n.name}) / ${n})`;
+}
+function avg2(x3, from) {
+  return sql`(SELECT AVG(${x3}) FROM "${from}")`;
+}
+function argmaxExpr(aux, as, [, y3]) {
+  const max2 = auxName("max", y3);
+  aux[max2] = agg`MAX(${y3})`;
+  return agg`ARG_MAX("${as}", ${max2})`;
+}
+function argminExpr(aux, as, [, y3]) {
+  const min2 = auxName("min", y3);
+  aux[min2] = agg`MIN(${y3})`;
+  return agg`ARG_MIN("${as}", ${min2})`;
+}
+function varianceExpr(aux, x3, from, correction = true) {
+  const n = countExpr(aux, x3);
+  const ssq = auxName("rssq", x3);
+  const sum3 = auxName("rsum", x3);
+  const delta = sql`${x3} - ${avg2(x3, from)}`;
+  aux[ssq] = agg`SUM((${delta}) ** 2)`;
+  aux[sum3] = agg`SUM(${delta})`;
+  const adj = correction ? ` - 1` : "";
+  return agg`(SUM(${ssq}) - (SUM(${sum3}) ** 2 / ${n})) / (${n}${adj})`;
+}
+function covarianceExpr(aux, args, from, correction = true) {
+  const n = regrCountExpr(aux, args);
+  const sxy = regrSumXYExpr(aux, args, from);
+  const sx = regrSumExpr(aux, 1, args, from);
+  const sy = regrSumExpr(aux, 0, args, from);
+  const adj = correction === null ? "" : correction ? ` / (${n} - 1)` : ` / ${n}`;
+  return agg`(${sxy} - ${sx} * ${sy} / ${n})${adj}`;
+}
+function corrExpr(aux, args, from) {
+  const n = regrCountExpr(aux, args);
+  const sxy = regrSumXYExpr(aux, args, from);
+  const sxx = regrSumSqExpr(aux, 1, args, from);
+  const syy = regrSumSqExpr(aux, 0, args, from);
+  const sx = regrSumExpr(aux, 1, args, from);
+  const sy = regrSumExpr(aux, 0, args, from);
+  const vx = agg`(${sxx} - (${sx} ** 2) / ${n})`;
+  const vy = agg`(${syy} - (${sy} ** 2) / ${n})`;
+  return agg`(${sxy} - ${sx} * ${sy} / ${n}) / SQRT(${vx} * ${vy})`;
+}
+function regrCountExpr(aux, [y3, x3]) {
+  const n = auxName("count", y3, x3);
+  aux[n] = agg`REGR_COUNT(${y3}, ${x3})`;
+  return agg`SUM(${n})`.annotate({ name: n });
+}
+function regrSumExpr(aux, i, args, from) {
+  const v2 = args[i];
+  const o = args[1 - i];
+  const sum3 = auxName("rs", v2);
+  aux[sum3] = agg`SUM(${v2} - ${avg2(v2, from)}) FILTER (${o} IS NOT NULL)`;
+  return agg`SUM(${sum3})`;
+}
+function regrSumSqExpr(aux, i, args, from) {
+  const v2 = args[i];
+  const u = args[1 - i];
+  const ssq = auxName("rss", v2);
+  aux[ssq] = agg`SUM((${v2} - ${avg2(v2, from)}) ** 2) FILTER (${u} IS NOT NULL)`;
+  return agg`SUM(${ssq})`;
+}
+function regrSumXYExpr(aux, args, from) {
+  const [y3, x3] = args;
+  const sxy = auxName("sxy", y3, x3);
+  aux[sxy] = agg`SUM((${x3} - ${avg2(x3, from)}) * (${y3} - ${avg2(y3, from)}))`;
+  return agg`SUM(${sxy})`;
+}
+function regrAvgXExpr(aux, args) {
+  const [y3, x3] = args;
+  const n = regrCountExpr(aux, args);
+  const a2 = auxName("avg", x3, y3);
+  aux[a2] = agg`REGR_AVGX(${y3}, ${x3})`;
+  return agg`(SUM(${a2} * ${n.name}) / ${n})`;
+}
+function regrAvgYExpr(aux, args) {
+  const [y3, x3] = args;
+  const n = regrCountExpr(aux, args);
+  const a2 = auxName("avg", y3, x3);
+  aux[a2] = agg`REGR_AVGY(${y3}, ${x3})`;
+  return agg`(SUM(${a2} * ${n.name}) / ${n})`;
+}
+function regrVarExpr(aux, i, args, from) {
+  const n = regrCountExpr(aux, args);
+  const sum3 = regrSumExpr(aux, i, args, from);
+  const ssq = regrSumSqExpr(aux, i, args, from);
+  return agg`(${ssq} - (${sum3} ** 2 / ${n}))`;
+}
+function regrSlopeExpr(aux, args, from) {
+  const cov = covarianceExpr(aux, args, from, null);
+  const varx = regrVarExpr(aux, 1, args, from);
+  return agg`(${cov}) / ${varx}`;
+}
+function regrInterceptExpr(aux, args, from) {
+  const ax = regrAvgXExpr(aux, args);
+  const ay = regrAvgYExpr(aux, args);
+  const m2 = regrSlopeExpr(aux, args, from);
+  return agg`${ay} - (${m2}) * ${ax}`;
+}
+
 // src/DataCubeIndexer.js
 var DataCubeIndexer = class {
   /**
@@ -13055,42 +13315,49 @@ var DataCubeIndexer = class {
     this.enabled = false;
     this.clients = null;
     this.indices = null;
-    this.activeView = null;
+    this.active = null;
   }
   clear() {
     if (this.indices) {
-      this.mc.cancel(Array.from(this.indices.values(), (index) => index.result));
+      this.mc.cancel(Array.from(this.indices.values(), (index) => index?.result));
       this.indices = null;
     }
   }
-  index(clients, active) {
+  index(clients, activeClause) {
     if (this.clients !== clients) {
-      const cols = Array.from(clients, getIndexColumns);
+      const cols = Array.from(clients, indexColumns).filter((x3) => x3);
       const from = cols[0]?.from;
-      this.enabled = cols.every((c) => c && c.from === from);
+      this.enabled = cols.length && cols.every((c) => c.from === from);
       this.clients = clients;
-      this.activeView = null;
+      this.active = null;
       this.clear();
     }
     if (!this.enabled) return false;
-    active = active || this.selection.active;
-    const { source } = active;
-    if (source && source === this.activeView?.source) return true;
+    activeClause = activeClause || this.selection.active;
+    const { source } = activeClause;
+    if (source && source === this.active?.source) return true;
     this.clear();
     if (!source) return false;
-    const activeView = this.activeView = getActiveView(active);
-    if (!activeView) return false;
-    this.mc.logger().warn("DATA CUBE INDEX CONSTRUCTION");
+    const active = this.active = activeColumns(activeClause);
+    if (!active) return false;
+    const logger = this.mc.logger();
+    logger.warn("DATA CUBE INDEX CONSTRUCTION");
     const sel = this.selection.remove(source);
     const indices = this.indices = /* @__PURE__ */ new Map();
     const { mc, temp } = this;
     for (const client of clients) {
-      if (sel.skip(client, active)) continue;
-      const index = getIndexColumns(client);
-      const query = client.query(sel.predicate(client)).select({ ...activeView.columns, ...index.aux }).groupby(Object.keys(activeView.columns));
+      if (sel.skip(client, activeClause)) {
+        indices.set(client, null);
+        continue;
+      }
+      const index = indexColumns(client);
+      if (!index) {
+        continue;
+      }
+      const query = client.query(sel.predicate(client)).select({ ...active.columns, ...index.aux }).groupby(Object.keys(active.columns));
       const [subq] = query.subqueries;
       if (subq) {
-        const cols = Object.values(activeView.columns).map((c) => c.columns[0]);
+        const cols = Object.values(active.columns).flatMap((c) => c.columns);
         subqueryPushdown(subq, cols);
       }
       const order = query.orderby();
@@ -13099,36 +13366,40 @@ var DataCubeIndexer = class {
       const id = (fnv_hash(sql2) >>> 0).toString(16);
       const table = `cube_index_${id}`;
       const result = mc.exec(create(table, sql2, { temp }));
+      result.catch((e) => logger.error(e));
       indices.set(client, { table, result, order, ...index });
     }
     return true;
   }
   async update() {
-    const { clients, selection, activeView } = this;
-    const filter = activeView.predicate(selection.active.predicate);
+    const { clients, selection, active } = this;
+    const filter = active.predicate(selection.active.predicate);
     return Promise.all(
       Array.from(clients).map((client) => this.updateClient(client, filter))
     );
   }
   async updateClient(client, filter) {
+    const { mc, indices, selection } = this;
+    if (!indices.has(client)) {
+      filter = selection.predicate(client);
+      return mc.updateClient(client, client.query(filter));
+    }
+    ;
     const index = this.indices.get(client);
     if (!index) return;
-    if (!filter) {
-      filter = this.activeView.predicate(this.selection.active.predicate);
-    }
     const { table, dims, aggr, order = [] } = index;
     const query = Query.select(dims, aggr).from(table).groupby(dims).where(filter).orderby(order);
-    return this.mc.updateClient(client, query);
+    return mc.updateClient(client, query);
   }
 };
-function getActiveView(clause) {
-  const { source, schema } = clause;
+function activeColumns(clause) {
+  const { source, meta } = clause;
   let columns = clause.predicate?.columns;
-  if (!schema || !columns) return null;
-  const { type, scales: scales2, pixelSize = 1 } = schema;
+  if (!meta || !columns) return null;
+  const { type, scales: scales2, bin, pixelSize = 1 } = meta;
   let predicate;
   if (type === "interval" && scales2) {
-    const bins = scales2.map((s) => binInterval(s, pixelSize));
+    const bins = scales2.map((s) => binInterval(s, pixelSize, bin));
     if (bins.some((b2) => b2 == null)) return null;
     if (bins.length === 1) {
       predicate = (p2) => p2 ? isBetween("active0", p2.range.map(bins[0])) : [];
@@ -13141,85 +13412,23 @@ function getActiveView(clause) {
     }
   } else if (type === "point") {
     predicate = (x3) => x3;
-    columns = Object.fromEntries(columns.map((col) => [col.toString(), col]));
+    columns = Object.fromEntries(columns.map((col) => [`${col}`, asColumn(col)]));
   } else {
     return null;
   }
   return { source, columns, predicate };
 }
-function binInterval(scale, pixelSize) {
-  const { apply, sqlApply } = scaleTransform(scale);
-  if (apply) {
-    const { domain, range } = scale;
-    const lo = apply(Math.min(...domain));
-    const hi = apply(Math.max(...domain));
-    const a2 = Math.abs(range[1] - range[0]) / (hi - lo) / pixelSize;
-    const s = pixelSize === 1 ? "" : `${pixelSize}::INTEGER * `;
-    return (value) => sql`${s}FLOOR(${a2}::DOUBLE * (${sqlApply(value)} - ${lo}::DOUBLE))::INTEGER`;
-  }
-}
-var NO_INDEX = { from: NaN };
-function getIndexColumns(client) {
-  if (!client.filterIndexable) return NO_INDEX;
-  const q2 = client.query();
-  const from = getBaseTable(q2);
-  if (!from || !q2.groupby) return NO_INDEX;
-  const g2 = new Set(q2.groupby().map((c) => c.column));
-  const aggr = [];
-  const dims = [];
-  const aux = {};
-  let auxAs;
-  for (const entry of q2.select()) {
-    const { as, expr: { aggregate, args } } = entry;
-    const op = aggregate?.toUpperCase?.();
-    switch (op) {
-      case "COUNT":
-      case "SUM":
-        aggr.push({ [as]: sql`SUM("${as}")::DOUBLE` });
-        break;
-      case "AVG":
-        aux[auxAs = "__count__"] = sql`COUNT(*)`;
-        aggr.push({ [as]: sql`(SUM("${as}" * ${auxAs}) / SUM(${auxAs}))::DOUBLE` });
-        break;
-      case "ARG_MAX":
-        aux[auxAs = `__max_${as}__`] = sql`MAX(${args[1]})`;
-        aggr.push({ [as]: sql`ARG_MAX("${as}", ${auxAs})` });
-        break;
-      case "ARG_MIN":
-        aux[auxAs = `__min_${as}__`] = sql`MIN(${args[1]})`;
-        aggr.push({ [as]: sql`ARG_MIN("${as}", ${auxAs})` });
-        break;
-      case "MAX":
-      case "MIN":
-      case "BIT_AND":
-      case "BIT_OR":
-      case "BIT_XOR":
-      case "BOOL_AND":
-      case "BOOL_OR":
-      case "PRODUCT":
-        aggr.push({ [as]: sql`${op}("${as}")` });
-        break;
-      default:
-        if (g2.has(as)) dims.push(as);
-        else return null;
-    }
-  }
-  return { aggr, dims, aux, from };
-}
-function getBaseTable(query) {
-  const subq = query.subqueries;
-  if (query.select) {
-    const from = query.from();
-    if (!from.length) return void 0;
-    if (subq.length === 0) return from[0].from.table;
-  }
-  const base = getBaseTable(subq[0]);
-  for (let i = 1; i < subq.length; ++i) {
-    const from = getBaseTable(subq[i]);
-    if (from === void 0) continue;
-    if (from !== base) return NaN;
-  }
-  return base;
+var BIN = { ceil: "CEIL", round: "ROUND" };
+function binInterval(scale, pixelSize, bin) {
+  const { type, domain, range, apply, sqlApply } = scaleTransform(scale);
+  if (!apply) return;
+  const fn = BIN[`${bin}`.toLowerCase()] || "FLOOR";
+  const lo = apply(Math.min(...domain));
+  const hi = apply(Math.max(...domain));
+  const a2 = type === "identity" ? 1 : Math.abs(range[1] - range[0]) / (hi - lo);
+  const s = a2 / pixelSize === 1 ? "" : `${a2 / pixelSize}::DOUBLE * `;
+  const d = lo === 0 ? "" : ` - ${lo}::DOUBLE`;
+  return (value) => sql`${fn}(${s}(${sqlApply(value)}${d}))::INTEGER`;
 }
 function subqueryPushdown(query, cols) {
   const memo = /* @__PURE__ */ new Set();
@@ -13234,1299 +13443,1400 @@ function subqueryPushdown(query, cols) {
   pushdown(query);
 }
 
-// src/FilterGroup.js
-var FilterGroup = class {
+// src/util/AsyncDispatch.js
+var AsyncDispatch = class {
   /**
-   * @param {import('./Coordinator.js').Coordinator} coordinator The Mosaic coordinator.
-   * @param {*} selection The shared filter selection.
-   * @param {*} index Boolean flag or options hash for data cube indexer.
-   *  Falsy values disable indexing.
+   * Create a new asynchronous dispatcher instance.
    */
-  constructor(coordinator2, selection, index = true) {
-    this.mc = coordinator2;
-    this.selection = selection;
-    this.clients = /* @__PURE__ */ new Set();
-    this.indexer = index ? new DataCubeIndexer(this.mc, { ...index, selection }) : null;
-    const { value, activate } = this.handlers = {
-      value: () => this.update(),
-      activate: (clause) => this.indexer?.index(this.clients, clause)
-    };
-    selection.addEventListener("value", value);
-    selection.addEventListener("activate", activate);
+  constructor() {
+    this._callbacks = /* @__PURE__ */ new Map();
   }
-  finalize() {
-    const { value, activate } = this.handlers;
-    this.selection.removeEventListener("value", value);
-    this.selection.removeEventListener("activate", activate);
+  /**
+   * Add an event listener callback for the provided event type.
+   * @param {string} type The event type.
+   * @param {(value: *) => void | Promise} callback The event handler
+   *  callback function to add. If the callback has already been
+   *  added for the event type, this method has no effect.
+   */
+  addEventListener(type, callback) {
+    if (!this._callbacks.has(type)) {
+      this._callbacks.set(type, {
+        callbacks: /* @__PURE__ */ new Set(),
+        pending: null,
+        queue: new DispatchQueue()
+      });
+    }
+    const entry = this._callbacks.get(type);
+    entry.callbacks.add(callback);
   }
-  reset() {
-    this.indexer?.reset();
+  /**
+   * Remove an event listener callback for the provided event type.
+   * @param {string} type The event type.
+   * @param {(value: *) => void | Promise} callback The event handler
+   *  callback function to remove.
+   */
+  removeEventListener(type, callback) {
+    const entry = this._callbacks.get(type);
+    if (entry) {
+      entry.callbacks.delete(callback);
+    }
   }
-  add(client) {
-    (this.clients = new Set(this.clients)).add(client);
-    return this;
+  /**
+   * 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;
   }
-  remove(client) {
-    if (this.clients.has(client)) {
-      (this.clients = new Set(this.clients)).delete(client);
-    }
-    return this;
+  /**
+   * Lifecycle method that returns a filter function for updating the
+   * queue of unemitted event values prior to enqueueing a new value.
+   * This default implementation simply returns null, indicating that
+   * any other unemitted event values should be dropped (that is, all
+   * queued events are filtered)
+   * @param {string} type The event type.
+   * @param {*} value The new event value that will be enqueued.
+   * @returns {(value: *) => boolean|null} A dispatch queue filter
+   *  function, or null if all unemitted event values should be filtered.
+   */
+  emitQueueFilter(type, value) {
+    return null;
   }
   /**
-   * Internal method to process a selection update.
-   * The return value is passed as a selection callback value.
-   * @returns {Promise} A Promise that resolves when the update completes.
+   * Cancel all unemitted event values for the given event type.
+   * @param {string} type The event type.
    */
-  update() {
-    const { mc, indexer, clients, selection } = this;
-    const hasIndex = indexer?.index(clients);
-    return hasIndex ? indexer.update() : defaultUpdate(mc, clients, selection);
+  cancel(type) {
+    const entry = this._callbacks.get(type);
+    entry?.queue.clear();
   }
-};
-function defaultUpdate(mc, clients, selection) {
-  return Promise.all(Array.from(clients).map((client) => {
-    const filter = selection.predicate(client);
-    if (filter != null) {
-      return mc.updateClient(client, client.query(filter));
-    }
-  }));
-}
-
-// src/util/query-result.js
-function queryResult() {
-  let resolve;
-  let reject;
-  const p2 = new Promise((r, e) => {
-    resolve = r;
-    reject = e;
-  });
-  return Object.assign(p2, {
-    fulfill: (value) => (resolve(value), p2),
-    reject: (err) => (reject(err), p2)
-  });
-}
-
-// src/QueryConsolidator.js
-function wait(callback) {
-  const method = typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame : typeof setImmediate !== "undefined" ? setImmediate : setTimeout;
-  return method(callback);
-}
-function consolidator(enqueue, cache, record) {
-  let pending = [];
-  let id = 0;
-  function run() {
-    const groups = entryGroups(pending, cache);
-    pending = [];
-    id = 0;
-    for (const group of groups) {
-      consolidate(group, enqueue, record);
-      processResults(group, cache);
-    }
-  }
-  return {
-    add(entry, priority) {
-      if (entry.request.type === "arrow") {
-        id = id || wait(() => run());
-        pending.push({ entry, priority, index: pending.length });
-      } else {
-        enqueue(entry, priority);
+  /**
+   * Emit an event value to listeners for the given event type.
+   * If a previous emit has not yet resolved, the event value
+   * will be queued to be emitted later.
+   * The actual event value given to listeners will be the result
+   * of passing the input value through the emitValue() method.
+   * @param {string} type The event type.
+   * @param {*} value The event value.
+   */
+  emit(type, value) {
+    const entry = this._callbacks.get(type) || {};
+    if (entry.pending) {
+      entry.queue.enqueue(value, this.emitQueueFilter(type, value));
+    } else {
+      const event = this.willEmit(type, value);
+      const { callbacks, queue } = entry;
+      if (callbacks?.size) {
+        const callbackValues = Array.from(callbacks, (cb) => cb(event));
+        entry.pending = Promise.allSettled(callbackValues).then(() => {
+          entry.pending = null;
+          if (!queue.isEmpty()) {
+            this.emit(type, queue.dequeue());
+          }
+        });
       }
     }
-  };
-}
-function entryGroups(entries, cache) {
-  const groups = [];
-  const groupMap = /* @__PURE__ */ new Map();
-  for (const query of entries) {
-    const { entry: { request } } = query;
-    const key = consolidationKey(request.query, cache);
-    if (!groupMap.has(key)) {
-      const list = [];
-      groups.push(list);
-      groupMap.set(key, list);
-    }
-    groupMap.get(key).push(query);
   }
-  return groups;
-}
-function consolidationKey(query, cache) {
-  const sql2 = `${query}`;
-  if (query instanceof Query && !cache.get(sql2)) {
-    if (
-      // @ts-ignore
-      query.orderby().length || query.where().length || // @ts-ignore
-      query.qualify().length || query.having().length
-    ) {
-      return sql2;
-    }
-    const q2 = query.clone().$select("*");
-    const groupby = query.groupby();
-    if (groupby.length) {
-      const map = {};
-      query.select().forEach(({ as, expr }) => map[as] = expr);
-      q2.$groupby(groupby.map((e) => e instanceof Ref && map[e.column] || e));
-    }
-    return `${q2}`;
-  } else {
-    return sql2;
+};
+var DispatchQueue = class {
+  /**
+   * Create a new dispatch queue instance.
+   */
+  constructor() {
+    this.clear();
   }
-}
-function consolidate(group, enqueue, record) {
-  if (shouldConsolidate(group)) {
-    enqueue({
-      request: {
-        type: "arrow",
-        cache: false,
-        record: false,
-        query: group.query = consolidatedQuery(group, record)
-      },
-      result: group.result = queryResult()
-    });
-  } else {
-    for (const { entry, priority } of group) {
-      enqueue(entry, priority);
-    }
+  /**
+   * Clear the queue state of all event values.
+   */
+  clear() {
+    this.next = null;
   }
-}
-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;
-      }
-    }
+  /**
+   * Indicate if the queue is empty.
+   * @returns {boolean} True if queue is empty, false otherwise.
+   */
+  isEmpty() {
+    return !this.next;
   }
-  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]);
+  /**
+   * 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;
+        }
       }
-      const [name] = fields.get(e);
-      fieldMap.push([name, as]);
+      curr.next = tail;
+    } else {
+      this.next = tail;
     }
-    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));
+  /**
+   * 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;
   }
-  return query.$select(Array.from(fields.values()));
+};
+
+// src/util/distinct.js
+function distinct(a2, b2) {
+  return a2 === b2 ? false : a2 instanceof Date && b2 instanceof Date ? +a2 !== +b2 : Array.isArray(a2) && Array.isArray(b2) ? distinctArray(a2, b2) : true;
 }
-async function processResults(group, cache) {
-  const { maps, query, result } = group;
-  if (!maps) return;
-  let data;
-  try {
-    data = await result;
-  } catch (err) {
-    for (const { entry } of group) {
-      entry.result.reject(err);
-    }
-    return;
+function distinctArray(a2, b2) {
+  if (a2.length !== b2.length) return true;
+  for (let i = 0; i < a2.length; ++i) {
+    if (a2[i] !== b2[i]) return true;
   }
-  const describe = isDescribeQuery(query);
-  group.forEach(({ entry }, index) => {
-    const { request, result: result2 } = entry;
-    const map = maps[index];
-    const extract = describe && map ? filterResult(data, map) : map ? projectResult(data, map) : data;
-    if (request.cache) {
-      cache.set(String(request.query), extract);
-    }
-    result2.fulfill(extract);
-  });
+  return false;
 }
-function projectResult(data, map) {
-  const cols = {};
-  for (const [name, as] of map) {
-    cols[as] = data.getChild(name);
-  }
-  return new data.constructor(cols);
+
+// src/Param.js
+function isParam(x3) {
+  return x3 instanceof Param;
 }
-function filterResult(data, map) {
-  const lookup = new Map(map);
-  const result = [];
-  for (const d of data) {
-    if (lookup.has(d.column_name)) {
-      result.push({ ...d, column_name: lookup.get(d.column_name) });
-    }
+var Param = class _Param extends AsyncDispatch {
+  /**
+   * Create a new Param instance.
+   * @param {*} value The initial value of the Param.
+   */
+  constructor(value) {
+    super();
+    this._value = value;
   }
-  return result;
-}
-
-// src/util/cache.js
-var requestIdle = typeof requestIdleCallback !== "undefined" ? requestIdleCallback : setTimeout;
-var voidCache = () => ({
-  get: () => void 0,
-  set: (key, value) => value,
-  clear: () => {
+  /**
+   * Create a new Param instance with the given initial value.
+   * @param {*} value The initial value of the Param.
+   * @returns {Param} The new Param instance.
+   */
+  static value(value) {
+    return new _Param(value);
   }
-});
-function lruCache({
-  max: max2 = 1e3,
-  // max entries
-  ttl = 3 * 60 * 60 * 1e3
-  // time-to-live, default 3 hours
-} = {}) {
-  let cache = /* @__PURE__ */ new Map();
-  function evict() {
-    const expire = performance.now() - ttl;
-    let lruKey = null;
-    let lruLast = Infinity;
-    for (const [key, value] of cache) {
-      const { last: last2 } = value;
-      if (last2 < lruLast) {
-        lruKey = key;
-        lruLast = last2;
-      }
-      if (expire > last2) {
-        cache.delete(key);
-      }
+  /**
+   * 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((v2) => isParam(v2))) {
+      const p2 = new _Param();
+      const update2 = () => {
+        p2.update(values.map((v2) => isParam(v2) ? v2.value : v2));
+      };
+      update2();
+      values.forEach((v2) => isParam(v2) ? v2.addEventListener("value", update2) : 0);
+      return p2;
     }
-    if (lruKey) {
-      cache.delete(lruKey);
+    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 shouldEmit = distinct(this._value, value) || force;
+    if (shouldEmit) {
+      this.emit("value", value);
+    } else {
+      this.cancel("value");
     }
+    return this;
   }
-  return {
-    get(key) {
-      const entry = cache.get(key);
-      if (entry) {
-        entry.last = performance.now();
-        return entry.value;
-      }
-    },
-    set(key, value) {
-      cache.set(key, { last: performance.now(), value });
-      if (cache.size > max2) requestIdle(evict);
-      return value;
-    },
-    clear() {
-      cache = /* @__PURE__ */ new Map();
+  /**
+   * Upon value-typed updates, sets the current value to the input value
+   * immediately prior to the event value being emitted to listeners.
+   * @param {string} type The event type.
+   * @param {*} value The input event value.
+   * @returns {*} The input event value.
+   */
+  willEmit(type, value) {
+    if (type === "value") {
+      this._value = value;
     }
-  };
-}
+    return value;
+  }
+};
 
-// 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;
-        }
-      }
+// src/Selection.js
+function isSelection(x3) {
+  return x3 instanceof Selection;
+}
+var Selection = class _Selection extends Param {
+  /**
+   * Create a new Selection instance with an
+   * intersect (conjunction) resolution strategy.
+   * @param {object} [options] The selection options.
+   * @param {boolean} [options.cross=false] Boolean flag indicating
+   *  cross-filtered resolution. If true, selection clauses will not
+   *  be applied to the clients they are associated with.
+   * @returns {Selection} The new Selection instance.
+   */
+  static intersect({ cross = false } = {}) {
+    return new _Selection(new SelectionResolver({ cross }));
+  }
+  /**
+   * Create a new Selection instance with a
+   * union (disjunction) resolution strategy.
+   * @param {object} [options] The selection options.
+   * @param {boolean} [options.cross=false] Boolean flag indicating
+   *  cross-filtered resolution. If true, selection clauses will not
+   *  be applied to the clients they are associated with.
+   * @returns {Selection} The new Selection instance.
+   */
+  static union({ cross = false } = {}) {
+    return new _Selection(new SelectionResolver({ cross, union: true }));
+  }
+  /**
+   * Create a new Selection instance with a singular resolution strategy
+   * that keeps only the most recent selection clause.
+   * @param {object} [options] The selection options.
+   * @param {boolean} [options.cross=false] Boolean flag indicating
+   *  cross-filtered resolution. If true, selection clauses will not
+   *  be applied to the clients they are associated with.
+   * @returns {Selection} The new Selection instance.
+   */
+  static single({ cross = false } = {}) {
+    return new _Selection(new SelectionResolver({ cross, single: true }));
+  }
+  /**
+   * Create a new Selection instance with a
+   * cross-filtered intersect resolution strategy.
+   * @returns {Selection} The new Selection instance.
+   */
+  static crossfilter() {
+    return new _Selection(new SelectionResolver({ cross: true }));
+  }
+  /**
+   * Create a new Selection instance.
+   * @param {SelectionResolver} resolver The selection resolution
+   *  strategy to apply.
+   */
+  constructor(resolver = new SelectionResolver()) {
+    super([]);
+    this._resolved = this._value;
+    this._resolver = resolver;
+  }
+  /**
+   * Create a cloned copy of this Selection instance.
+   * @returns {Selection} A clone of this selection.
+   */
+  clone() {
+    const s = new _Selection(this._resolver);
+    s._value = s._resolved = this._value;
+    return s;
+  }
+  /**
+   * Create a clone of this Selection with clauses corresponding
+   * to the provided source removed.
+   * @param {*} source The clause source to remove.
+   * @returns {Selection} A cloned and updated Selection.
+   */
+  remove(source) {
+    const s = this.clone();
+    s._value = s._resolved = s._resolver.resolve(this._resolved, { source });
+    s._value.active = { source };
+    return s;
+  }
+  /**
+   * The selection clause resolver.
+   */
+  get resolver() {
+    return this._resolver;
+  }
+  /**
+   * Indicate if this selection has a single resolution strategy.
+   */
+  get single() {
+    return this._resolver.single;
+  }
+  /**
+   * The current array of selection clauses.
+   */
+  get clauses() {
+    return super.value;
+  }
+  /**
+   * 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() {
+    return this.active?.value;
+  }
+  /**
+   * The value corresponding to a given source. Returns undefined if
+   * this selection does not include a clause from this source.
+   * @param {*} source The clause source to look up the value for.
+   */
+  valueFor(source) {
+    return this.clauses.find((c) => c.source === source)?.value;
+  }
+  /**
+   * 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;
     }
-  };
-}
-
-// 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();
-    });
+    return value;
   }
-  function enqueue(entry, priority = Priority.Normal) {
-    queue.insert(entry, priority);
-    next();
+  /**
+   * Upon value-typed updates, returns a dispatch queue filter function.
+   * The return value depends on the selection resolution strategy.
+   * @param {string} type The event type.
+   * @param {*} value The new event value that will be enqueued.
+   * @returns {(value: *) => boolean|null} For value-typed events,
+   *  returns a dispatch queue filter function. Otherwise returns null.
+   */
+  emitQueueFilter(type, value) {
+    return type === "value" ? this._resolver.queueFilter(value) : null;
   }
-  function recordQuery(sql2) {
-    if (recorders.length && sql2) {
-      recorders.forEach((rec) => rec.add(sql2));
-    }
+  /**
+   * 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);
   }
-  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 a selection query predicate for the given client.
+   * @param {*} client The client whose data may be filtered.
+   * @param {boolean} [noSkip=false] Disable skipping of active
+   *  cross-filtered sources. If set true, the source of the active
+   *  clause in a cross-filtered selection will not be skipped.
+   * @returns {*} The query predicate for filtering client data,
+   *  based on the current state of this selection.
+   */
+  predicate(client, noSkip = false) {
+    const { clauses } = this;
+    const active = noSkip ? null : clauses.active;
+    return this._resolver.predicate(clauses, active, client);
   }
-  return {
-    cache(value) {
-      return value !== void 0 ? clientCache = value === true ? lruCache() : value || voidCache() : clientCache;
-    },
-    logger(value) {
-      return value ? logger = value : logger;
-    },
-    connector(connector) {
-      return connector ? db = connector : db;
-    },
-    consolidate(flag) {
-      if (flag && !consolidate2) {
-        consolidate2 = consolidator(enqueue, clientCache, recordQuery);
-      } else if (!flag && consolidate2) {
-        consolidate2 = null;
-      }
-    },
-    request(request, priority = Priority.Normal) {
-      const result = queryResult();
-      const entry = { request, result };
-      if (consolidate2) {
-        consolidate2.add(entry, priority);
-      } else {
-        enqueue(entry, priority);
-      }
-      return result;
-    },
-    cancel(requests) {
-      const set = new Set(requests);
-      queue.remove(({ result }) => set.has(result));
-    },
-    clear() {
-      queue.remove(({ result }) => {
-        result.reject("Cleared");
-        return true;
-      });
-    },
-    record() {
-      let state = [];
-      const recorder = {
-        add(query) {
-          state.push(query);
-        },
-        reset() {
-          state = [];
-        },
-        snapshot() {
-          return state.slice();
-        },
-        stop() {
-          recorders = recorders.filter((x3) => x3 !== recorder);
-          return state;
-        }
-      };
-      recorders.push(recorder);
-      return recorder;
-    }
-  };
-}
-
-// src/util/js-type.js
-function jsType(type) {
-  switch (type) {
-    case "BIGINT":
-    case "HUGEINT":
-    case "INTEGER":
-    case "SMALLINT":
-    case "TINYINT":
-    case "UBIGINT":
-    case "UINTEGER":
-    case "USMALLINT":
-    case "UTINYINT":
-    case "DOUBLE":
-    case "FLOAT":
-    case "REAL":
-      return "number";
-    case "DATE":
-    case "TIMESTAMP":
-    case "TIMESTAMPTZ":
-    case "TIMESTAMP WITH TIME ZONE":
-    case "TIME":
-    case "TIMESTAMP_NS":
-      return "date";
-    case "BOOLEAN":
-      return "boolean";
-    case "VARCHAR":
-    case "UUID":
-    case "JSON":
-      return "string";
-    case "ARRAY":
-    case "LIST":
-      return "array";
-    case "BLOB":
-    case "STRUCT":
-    case "MAP":
-    case "GEOMETRY":
-      return "object";
-    default:
-      if (type.startsWith("DECIMAL")) {
-        return "number";
-      } else if (type.startsWith("STRUCT") || type.startsWith("MAP")) {
-        return "object";
-      } else if (type.endsWith("]")) {
-        return "array";
-      }
-      throw new Error(`Unsupported type: ${type}`);
+};
+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;
   }
-}
-
-// src/util/convert-arrow.js
-function isArrowTable(values) {
-  return typeof values?.getChild === "function";
-}
-function convertArrowArrayType(type) {
-  return DataType.isInt(type) || DataType.isFloat(type) || DataType.isDecimal(type) ? Float64Array : Array;
-}
-function convertArrowValue(type) {
-  if (DataType.isTimestamp(type)) {
-    return (v2) => v2 == null ? v2 : new Date(v2);
+  /**
+   * Resolve a list of selection clauses according to the resolution strategy.
+   * @param {*[]} clauseList An array of selection clauses.
+   * @param {*} clause A new selection clause to add.
+   * @returns {*[]} An updated array of selection clauses.
+   */
+  resolve(clauseList, clause, reset = false) {
+    const { source, predicate } = clause;
+    const filtered = clauseList.filter((c) => source !== c.source);
+    const clauses = this.single ? [] : filtered;
+    if (this.single && reset) filtered.forEach((c) => c.source?.reset?.());
+    if (predicate) clauses.push(clause);
+    return clauses;
   }
-  if (DataType.isInt(type) && type.bitWidth >= 64) {
-    return (v2) => v2 == null ? v2 : Number(v2);
+  /**
+   * 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);
   }
-  if (DataType.isDecimal(type)) {
-    const scale = 1 / Math.pow(10, type.scale);
-    return (v2) => v2 == null ? v2 : decimalToNumber(v2, scale);
+  /**
+   * Return a selection query predicate for the given client.
+   * @param {*[]} clauseList An array of selection clauses.
+   * @param {*} active The current active selection clause.
+   * @param {*} client The client whose data may be filtered.
+   * @returns {*} The query predicate for filtering client data,
+   *  based on the current state of this selection.
+   */
+  predicate(clauseList, active, client) {
+    const { union } = this;
+    if (this.skip(client, active)) return void 0;
+    const predicates = clauseList.filter((clause) => !this.skip(client, clause)).map((clause) => clause.predicate);
+    return union && predicates.length > 1 ? or(predicates) : predicates;
   }
-  return (v2) => v2;
-}
-function convertArrowColumn(column2) {
-  const { type } = column2;
-  if (DataType.isTimestamp(type)) {
-    const size = column2.length;
-    const array = new Array(size);
-    for (let row = 0; row < size; ++row) {
-      const v2 = column2.get(row);
-      array[row] = v2 == null ? null : new Date(v2);
+  /**
+   * 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;
     }
-    return array;
+    return null;
   }
-  if (DataType.isInt(type) && type.bitWidth >= 64) {
-    const size = column2.length;
-    const array = new Float64Array(size);
-    for (let row = 0; row < size; ++row) {
-      const v2 = column2.get(row);
-      array[row] = v2 == null ? NaN : Number(v2);
-    }
-    return array;
+};
+
+// src/FilterGroup.js
+var FilterGroup = class {
+  /**
+   * @param {Coordinator} coordinator The Mosaic coordinator.
+   * @param {Selection} selection The shared filter selection.
+   * @param {object|boolean} index Boolean flag or options hash for
+   *  a data cube indexer. Falsy values disable indexing.
+   */
+  constructor(coordinator2, selection, index = true) {
+    this.mc = coordinator2;
+    this.selection = selection;
+    this.clients = /* @__PURE__ */ new Set();
+    this.indexer = null;
+    this.index(index);
+    const { value, activate } = this.handlers = {
+      value: () => this.update(),
+      activate: (clause) => {
+        this.indexer?.index(this.clients, clause);
+      }
+    };
+    selection.addEventListener("value", value);
+    selection.addEventListener("activate", activate);
+  }
+  finalize() {
+    const { value, activate } = this.handlers;
+    this.selection.removeEventListener("value", value);
+    this.selection.removeEventListener("activate", activate);
+  }
+  index(state) {
+    const { selection } = this;
+    const { resolver } = selection;
+    this.indexer = state && (resolver.single || !resolver.union) ? new DataCubeIndexer(this.mc, { ...state, selection }) : null;
+  }
+  reset() {
+    this.indexer?.reset();
   }
-  if (DataType.isDecimal(type)) {
-    const scale = 1 / Math.pow(10, type.scale);
-    const size = column2.length;
-    const array = new Float64Array(size);
-    for (let row = 0; row < size; ++row) {
-      const v2 = column2.get(row);
-      array[row] = v2 == null ? NaN : decimalToNumber(v2, scale);
-    }
-    return array;
+  add(client) {
+    (this.clients = new Set(this.clients)).add(client);
+    return this;
   }
-  return column2.toArray();
-}
-var BASE32 = Array.from(
-  { length: 8 },
-  (_2, i) => Math.pow(2, i * 32)
-);
-function decimalToNumber(v2, scale) {
-  const n = v2.length;
-  let x3 = 0;
-  if (v2.signed && (v2[n - 1] | 0) < 0) {
-    for (let i = 0; i < n; ++i) {
-      x3 += ~v2[i] * BASE32[i];
-    }
-    x3 = -(x3 + 1);
-  } else {
-    for (let i = 0; i < n; ++i) {
-      x3 += v2[i] * BASE32[i];
+  remove(client) {
+    if (this.clients.has(client)) {
+      (this.clients = new Set(this.clients)).delete(client);
     }
+    return this;
   }
-  return x3 * scale;
+  /**
+   * Internal method to process a selection update.
+   * The return value is passed as a selection callback value.
+   * @returns {Promise} A Promise that resolves when the update completes.
+   */
+  update() {
+    const { mc, indexer, clients, selection } = this;
+    const hasIndex = indexer?.index(clients);
+    return hasIndex ? indexer.update() : defaultUpdate(mc, clients, selection);
+  }
+};
+function defaultUpdate(mc, clients, selection) {
+  return Promise.all(Array.from(clients).map((client) => {
+    const filter = selection.predicate(client);
+    if (filter != null) {
+      return mc.updateClient(client, client.query(filter));
+    }
+  }));
 }
 
-// src/util/field-info.js
-var Count = "count";
-var Nulls = "nulls";
-var Max = "max";
-var Min = "min";
-var Distinct = "distinct";
-var statMap = {
-  [Count]: count,
-  [Distinct]: (column2) => count(column2).distinct(),
-  [Max]: max,
-  [Min]: min,
-  [Nulls]: (column2) => count().where(isNull(column2))
-};
-function summarize(table, column2, stats) {
-  return Query.from(table).select(Array.from(stats, (s) => [s, statMap[s](column2)]));
+// src/util/query-result.js
+function queryResult() {
+  let resolve;
+  let reject;
+  const p2 = new Promise((r, e) => {
+    resolve = r;
+    reject = e;
+  });
+  return Object.assign(p2, {
+    fulfill: (value) => (resolve(value), p2),
+    reject: (err) => (reject(err), p2)
+  });
 }
-async function queryFieldInfo(mc, fields) {
-  if (fields.length === 1 && `${fields[0].column}` === "*") {
-    return getTableInfo(mc, fields[0].table);
-  } else {
-    return (await Promise.all(fields.map((f2) => getFieldInfo(mc, f2)))).filter((x3) => x3);
-  }
+
+// src/QueryConsolidator.js
+function wait(callback) {
+  const method = typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame : typeof setImmediate !== "undefined" ? setImmediate : setTimeout;
+  return method(callback);
 }
-async function getFieldInfo(mc, { table, column: column2, stats }) {
-  const q2 = Query.from({ source: table }).select({ column: column2 }).groupby(column2.aggregate ? sql`ALL` : []);
-  const [desc2] = Array.from(await mc.query(Query.describe(q2)));
-  const info = {
-    table,
-    column: `${column2}`,
-    sqlType: desc2.column_type,
-    type: jsType(desc2.column_type),
-    nullable: desc2.null === "YES"
-  };
-  if (!(stats?.length || stats?.size)) return info;
-  const result = await mc.query(
-    summarize(table, column2, stats),
-    { persist: true }
-  );
-  for (let i = 0; i < result.numCols; ++i) {
-    const { name } = result.schema.fields[i];
-    const child = result.getChildAt(i);
-    const convert = convertArrowValue(child.type);
-    info[name] = convert(child.get(0));
+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);
+    }
   }
-  return info;
-}
-async function getTableInfo(mc, table) {
-  const result = await mc.query(`DESCRIBE ${asRelation(table)}`);
-  return Array.from(result).map((desc2) => ({
-    table,
-    column: desc2.column_name,
-    sqlType: desc2.column_type,
-    type: jsType(desc2.column_type),
-    nullable: desc2.null === "YES"
-  }));
-}
-
-// src/util/void-logger.js
-function voidLogger() {
   return {
-    debug() {
-    },
-    info() {
-    },
-    log() {
-    },
-    warn() {
-    },
-    error() {
+    add(entry, priority) {
+      if (entry.request.type === "arrow") {
+        id = id || wait(() => run());
+        pending.push({ entry, priority, index: pending.length });
+      } else {
+        enqueue(entry, priority);
+      }
     }
   };
 }
-
-// src/Coordinator.js
-var _instance;
-function coordinator(instance16) {
-  if (instance16) {
-    _instance = instance16;
-  } else if (_instance == null) {
-    _instance = new Coordinator();
+function entryGroups(entries, cache) {
+  const groups = [];
+  const groupMap = /* @__PURE__ */ new Map();
+  for (const query of entries) {
+    const { entry: { request } } = query;
+    const key = consolidationKey(request.query, cache);
+    if (!groupMap.has(key)) {
+      const list = [];
+      groups.push(list);
+      groupMap.set(key, list);
+    }
+    groupMap.get(key).push(query);
   }
-  return _instance;
+  return groups;
 }
-var Coordinator = class {
-  constructor(db = socketConnector(), options = {}) {
-    const {
-      logger = console,
-      manager = QueryManager()
-    } = options;
-    this.manager = manager;
-    this.logger(logger);
-    this.configure(options);
-    this.databaseConnector(db);
-    this.clear();
+function consolidationKey(query, cache) {
+  const sql2 = `${query}`;
+  if (query instanceof Query && !cache.get(sql2)) {
+    if (
+      // @ts-ignore
+      query.orderby().length || query.where().length || // @ts-ignore
+      query.qualify().length || query.having().length
+    ) {
+      return sql2;
+    }
+    const q2 = query.clone().$select("*");
+    const groupby = query.groupby();
+    if (groupby.length) {
+      const map = {};
+      query.select().forEach(({ as, expr }) => map[as] = expr);
+      q2.$groupby(groupby.map((e) => e instanceof Ref && map[e.column] || e));
+    }
+    return `${q2}`;
+  } else {
+    return sql2;
   }
-  logger(logger) {
-    if (arguments.length) {
-      this._logger = logger || voidLogger();
-      this.manager.logger(this._logger);
+}
+function consolidate(group, enqueue, record) {
+  if (shouldConsolidate(group)) {
+    enqueue({
+      request: {
+        type: "arrow",
+        cache: false,
+        record: false,
+        query: group.query = consolidatedQuery(group, record)
+      },
+      result: group.result = queryResult()
+    });
+  } else {
+    for (const { entry, priority } of group) {
+      enqueue(entry, priority);
     }
-    return this._logger;
   }
-  /**
-   * Set configuration options for this coordinator.
-   * @param {object} [options] Configration options.
-   * @param {boolean} [options.cache=true] Boolean flag to enable/disable query caching.
-   * @param {boolean} [options.consolidate=true] Boolean flag to enable/disable query consolidation.
-   * @param {boolean|object} [options.indexes=true] Boolean flag to enable/disable
-   *  automatic data cube indexes or an index options object.
-   */
-  configure({ cache = true, consolidate: consolidate2 = true, indexes = true } = {}) {
-    this.manager.cache(cache);
-    this.manager.consolidate(consolidate2);
-    this.indexes = indexes;
+}
+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;
+      }
+    }
   }
-  clear({ clients = true, cache = true } = {}) {
-    this.manager.clear();
-    if (clients) {
-      this.clients?.forEach((client) => this.disconnect(client));
-      this.filterGroups?.forEach((group) => group.finalize());
-      this.clients = /* @__PURE__ */ new Set();
-      this.filterGroups = /* @__PURE__ */ new Map();
+  return false;
+}
+function consolidatedQuery(group, record) {
+  const maps = group.maps = [];
+  const fields = /* @__PURE__ */ new Map();
+  for (const item of group) {
+    const { query: query2 } = item.entry.request;
+    const fieldMap = [];
+    maps.push(fieldMap);
+    for (const { as, expr } of query2.select()) {
+      const e = `${expr}`;
+      if (!fields.has(e)) {
+        fields.set(e, [`col${fields.size}`, expr]);
+      }
+      const [name] = fields.get(e);
+      fieldMap.push([name, as]);
     }
-    if (cache) this.manager.cache().clear();
-  }
-  databaseConnector(db) {
-    return this.manager.connector(db);
-  }
-  // -- Query Management ----
-  cancel(requests) {
-    this.manager.cancel(requests);
+    record(`${query2}`);
   }
-  exec(query, { priority = Priority.Normal } = {}) {
-    query = Array.isArray(query) ? query.join(";\n") : query;
-    return this.manager.request({ type: "exec", query }, priority);
+  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));
   }
-  query(query, {
-    type = "arrow",
-    cache = true,
-    priority = Priority.Normal,
-    ...options
-  } = {}) {
-    return this.manager.request({ type, query, cache, options }, priority);
+  return query.$select(Array.from(fields.values()));
+}
+async function processResults(group, cache) {
+  const { maps, query, result } = group;
+  if (!maps) return;
+  let data;
+  try {
+    data = await result;
+  } catch (err) {
+    for (const { entry } of group) {
+      entry.result.reject(err);
+    }
+    return;
   }
-  prefetch(query, options = {}) {
-    return this.query(query, { ...options, cache: true, priority: Priority.Low });
+  const describe = isDescribeQuery(query);
+  group.forEach(({ entry }, index) => {
+    const { request, result: result2 } = entry;
+    const map = maps[index];
+    const extract = describe && map ? filterResult(data, map) : map ? projectResult(data, map) : data;
+    if (request.cache) {
+      cache.set(String(request.query), extract);
+    }
+    result2.fulfill(extract);
+  });
+}
+function projectResult(data, map) {
+  const cols = {};
+  for (const [name, as] of map) {
+    cols[as] = data.getChild(name);
   }
-  createBundle(name, queries, priority = Priority.Low) {
-    const options = { name, queries };
-    return this.manager.request({ type: "create-bundle", options }, priority);
+  return new data.constructor(cols);
+}
+function filterResult(data, map) {
+  const lookup = new Map(map);
+  const result = [];
+  for (const d of data) {
+    if (lookup.has(d.column_name)) {
+      result.push({ ...d, column_name: lookup.get(d.column_name) });
+    }
   }
-  loadBundle(name, priority = Priority.High) {
-    const options = { name };
-    return this.manager.request({ type: "load-bundle", options }, priority);
+  return result;
+}
+
+// src/util/cache.js
+var requestIdle = typeof requestIdleCallback !== "undefined" ? requestIdleCallback : setTimeout;
+var voidCache = () => ({
+  get: () => void 0,
+  set: (key, value) => value,
+  clear: () => {
   }
-  // -- 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);
+});
+function lruCache({
+  max: max2 = 1e3,
+  // max entries
+  ttl = 3 * 60 * 60 * 1e3
+  // time-to-live, default 3 hours
+} = {}) {
+  let cache = /* @__PURE__ */ new Map();
+  function evict() {
+    const expire = performance.now() - ttl;
+    let lruKey = null;
+    let lruLast = Infinity;
+    for (const [key, value] of cache) {
+      const { last: last2 } = value;
+      if (last2 < lruLast) {
+        lruKey = key;
+        lruLast = last2;
+      }
+      if (expire > last2) {
+        cache.delete(key);
       }
-    );
-  }
-  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 { clients, filterGroups, indexes } = this;
-    if (clients.has(client)) {
-      throw new Error("Client already connected.");
     }
-    clients.add(client);
-    client.coordinator = this;
-    const fields = client.fields();
-    if (fields?.length) {
-      client.fieldInfo(await queryFieldInfo(this, fields));
+    if (lruKey) {
+      cache.delete(lruKey);
     }
-    const filter = client.filterBy;
-    if (filter) {
-      if (filterGroups.has(filter)) {
-        filterGroups.get(filter).add(client);
+  }
+  return {
+    get(key) {
+      const entry = cache.get(key);
+      if (entry) {
+        entry.last = performance.now();
+        return entry.value;
+      }
+    },
+    set(key, value) {
+      cache.set(key, { last: performance.now(), value });
+      if (cache.size > max2) requestIdle(evict);
+      return value;
+    },
+    clear() {
+      cache = /* @__PURE__ */ new Map();
+    }
+  };
+}
+
+// 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 {
-        const group = new FilterGroup(this, filter, indexes);
-        filterGroups.set(filter, group.add(client));
+        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;
+        }
       }
     }
-    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)) return;
-    clients.delete(client);
-    filterGroups.get(client.filterBy)?.remove(client);
-    client.coordinator = null;
-  }
-};
+  };
+}
 
-// src/util/AsyncDispatch.js
-var AsyncDispatch = class {
-  /**
-   * Create a new asynchronous dispatcher instance.
-   */
+// src/QueryManager.js
+var Priority = { High: 0, Normal: 1, Low: 2 };
+var QueryManager = class {
   constructor() {
-    this._callbacks = /* @__PURE__ */ new Map();
+    this.queue = priorityQueue(3);
+    this.db = null;
+    this.clientCache = null;
+    this._logger = null;
+    this._logQueries = false;
+    this.recorders = [];
+    this.pending = null;
+    this._consolidate = null;
   }
-  /**
-   * Add an event listener callback for the provided event type.
-   * @param {string} type The event type.
-   * @param {(value: *) => void | Promise} callback The event handler
-   *  callback function to add. If the callback has already been
-   *  added for the event type, this method has no effect.
-   */
-  addEventListener(type, callback) {
-    if (!this._callbacks.has(type)) {
-      this._callbacks.set(type, {
-        callbacks: /* @__PURE__ */ new Set(),
-        pending: null,
-        queue: new DispatchQueue()
-      });
+  next() {
+    if (this.pending || this.queue.isEmpty()) return;
+    const { request, result } = this.queue.next();
+    this.pending = this.submit(request, result);
+    this.pending.finally(() => {
+      this.pending = null;
+      this.next();
+    });
+  }
+  enqueue(entry, priority = Priority.Normal) {
+    this.queue.insert(entry, priority);
+    this.next();
+  }
+  recordQuery(sql2) {
+    if (this.recorders.length && sql2) {
+      this.recorders.forEach((rec) => rec.add(sql2));
     }
-    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: *) => void | Promise} callback The event handler
-   *  callback function to remove.
-   */
-  removeEventListener(type, callback) {
-    const entry = this._callbacks.get(type);
-    if (entry) {
-      entry.callbacks.delete(callback);
+  async submit(request, result) {
+    try {
+      const { query, type, cache = false, record = true, options } = request;
+      const sql2 = query ? `${query}` : null;
+      if (record) {
+        this.recordQuery(sql2);
+      }
+      if (cache) {
+        const cached = this.clientCache.get(sql2);
+        if (cached) {
+          this._logger.debug("Cache");
+          result.fulfill(cached);
+          return;
+        }
+      }
+      const t0 = performance.now();
+      if (this._logQueries) {
+        this._logger.debug("Query", { type, sql: sql2, ...options });
+      }
+      const data = await this.db.query({ type, sql: sql2, ...options });
+      if (cache) this.clientCache.set(sql2, data);
+      this._logger.debug(`Request: ${(performance.now() - t0).toFixed(1)}`);
+      result.fulfill(data);
+    } catch (err) {
+      result.reject(err);
     }
   }
-  /**
-   * 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;
+  cache(value) {
+    return value !== void 0 ? this.clientCache = value === true ? lruCache() : value || voidCache() : this.clientCache;
   }
-  /**
-   * Lifecycle method that returns a filter function for updating the
-   * queue of unemitted event values prior to enqueueing a new value.
-   * This default implementation simply returns null, indicating that
-   * any other unemitted event values should be dropped (that is, all
-   * queued events are filtered)
-   * @param {string} type The event type.
-   * @param {*} value The new event value that will be enqueued.
-   * @returns {(value: *) => boolean|null} A dispatch queue filter
-   *  function, or null if all unemitted event values should be filtered.
-   */
-  emitQueueFilter(type, value) {
-    return null;
+  logger(value) {
+    return value ? this._logger = value : this._logger;
   }
-  /**
-   * 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();
+  logQueries(value) {
+    return value !== void 0 ? this._logQueries = !!value : this._logQueries;
   }
-  /**
-   * 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));
+  connector(connector) {
+    return connector ? this.db = connector : this.db;
+  }
+  consolidate(flag) {
+    if (flag && !this._consolidate) {
+      this._consolidate = consolidator(this.enqueue.bind(this), this.clientCache, this.recordQuery.bind(this));
+    } else if (!flag && this._consolidate) {
+      this._consolidate = null;
+    }
+  }
+  request(request, priority = Priority.Normal) {
+    const result = queryResult();
+    const entry = { request, result };
+    if (this._consolidate) {
+      this._consolidate.add(entry, priority);
     } else {
-      const event = this.willEmit(type, value);
-      const { callbacks, queue } = entry;
-      if (callbacks?.size) {
-        const callbackValues = Array.from(callbacks, (cb) => cb(event));
-        entry.pending = Promise.allSettled(callbackValues).then(() => {
-          entry.pending = null;
-          if (!queue.isEmpty()) {
-            this.emit(type, queue.dequeue());
-          }
-        });
-      }
+      this.enqueue(entry, priority);
     }
+    return result;
   }
-};
-var DispatchQueue = class {
-  /**
-   * Create a new dispatch queue instance.
-   */
-  constructor() {
-    this.clear();
+  cancel(requests) {
+    const set = new Set(requests);
+    this.queue.remove(({ result }) => set.has(result));
   }
-  /**
-   * 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;
+    this.queue.remove(({ result }) => {
+      result.reject("Cleared");
+      return true;
+    });
   }
-  /**
-   * 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;
-        }
+  record() {
+    let state = [];
+    const recorder = {
+      add(query) {
+        state.push(query);
+      },
+      reset() {
+        state = [];
+      },
+      snapshot() {
+        return state.slice();
+      },
+      stop() {
+        this.recorders = this.recorders.filter((x3) => x3 !== recorder);
+        return state;
       }
-      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;
+    };
+    this.recorders.push(recorder);
+    return recorder;
   }
 };
 
-// src/util/distinct.js
-function distinct(a2, b2) {
-  return a2 === b2 ? false : a2 instanceof Date && b2 instanceof Date ? +a2 !== +b2 : Array.isArray(a2) && Array.isArray(b2) ? distinctArray(a2, b2) : true;
-}
-function distinctArray(a2, b2) {
-  if (a2.length !== b2.length) return true;
-  for (let i = 0; i < a2.length; ++i) {
-    if (a2[i] !== b2[i]) return true;
-  }
-  return false;
-}
-
-// src/Param.js
-function isParam(x3) {
-  return x3 instanceof Param;
-}
-var Param = class _Param extends AsyncDispatch {
-  /**
-   * Create a new Param instance.
-   * @param {*} value The initial value of the Param.
-   */
-  constructor(value) {
-    super();
-    this._value = value;
-  }
-  /**
-   * 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((v2) => isParam(v2))) {
-      const p2 = new _Param();
-      const update2 = () => {
-        p2.update(values.map((v2) => isParam(v2) ? v2.value : v2));
-      };
-      update2();
-      values.forEach((v2) => isParam(v2) ? v2.addEventListener("value", update2) : 0);
-      return p2;
-    }
-    return new _Param(values);
+// src/util/js-type.js
+function jsType(type) {
+  switch (type) {
+    case "BIGINT":
+    case "HUGEINT":
+    case "INTEGER":
+    case "SMALLINT":
+    case "TINYINT":
+    case "UBIGINT":
+    case "UINTEGER":
+    case "USMALLINT":
+    case "UTINYINT":
+    case "DOUBLE":
+    case "FLOAT":
+    case "REAL":
+      return "number";
+    case "DATE":
+    case "TIMESTAMP":
+    case "TIMESTAMPTZ":
+    case "TIMESTAMP WITH TIME ZONE":
+    case "TIME":
+    case "TIMESTAMP_NS":
+      return "date";
+    case "BOOLEAN":
+      return "boolean";
+    case "VARCHAR":
+    case "UUID":
+    case "JSON":
+      return "string";
+    case "ARRAY":
+    case "LIST":
+      return "array";
+    case "BLOB":
+    case "STRUCT":
+    case "MAP":
+    case "GEOMETRY":
+      return "object";
+    default:
+      if (type.startsWith("DECIMAL")) {
+        return "number";
+      } else if (type.startsWith("STRUCT") || type.startsWith("MAP")) {
+        return "object";
+      } else if (type.endsWith("]")) {
+        return "array";
+      }
+      throw new Error(`Unsupported type: ${type}`);
   }
-  /**
-   * The current value of the Param.
-   */
-  get value() {
-    return this._value;
+}
+
+// src/util/convert-arrow.js
+function isArrowTable(values) {
+  return typeof values?.getChild === "function";
+}
+function convertArrowArrayType(type) {
+  return DataType.isInt(type) || DataType.isFloat(type) || DataType.isDecimal(type) ? Float64Array : Array;
+}
+function convertArrowValue(type) {
+  if (DataType.isTimestamp(type)) {
+    return (v2) => v2 == null ? v2 : new Date(v2);
   }
-  /**
-   * Update the Param value
-   * @param {*} value The new value of the Param.
-   * @param {object} [options] The update options.
-   * @param {boolean} [options.force] A boolean flag indicating if the Param
-   *  should emit a 'value' event even if the internal value is unchanged.
-   * @returns {this} This Param instance.
-   */
-  update(value, { force } = {}) {
-    const shouldEmit = distinct(this._value, value) || force;
-    if (shouldEmit) {
-      this.emit("value", value);
-    } else {
-      this.cancel("value");
-    }
-    return this;
+  if (DataType.isInt(type) && type.bitWidth >= 64) {
+    return (v2) => v2 == null ? v2 : Number(v2);
   }
-  /**
-   * Upon value-typed updates, sets the current value to the input value
-   * immediately prior to the event value being emitted to listeners.
-   * @param {string} type The event type.
-   * @param {*} value The input event value.
-   * @returns {*} The input event value.
-   */
-  willEmit(type, value) {
-    if (type === "value") {
-      this._value = value;
-    }
-    return value;
+  if (DataType.isDecimal(type)) {
+    const scale = 1 / Math.pow(10, type.scale);
+    return (v2) => v2 == null ? v2 : decimalToNumber(v2, scale);
   }
-};
-
-// src/Selection.js
-function isSelection(x3) {
-  return x3 instanceof Selection;
+  return (v2) => v2;
 }
-var Selection = class _Selection extends Param {
-  /**
-   * Create a new Selection instance with an
-   * intersect (conjunction) resolution strategy.
-   * @param {object} [options] The selection options.
-   * @param {boolean} [options.cross=false] Boolean flag indicating
-   *  cross-filtered resolution. If true, selection clauses will not
-   *  be applied to the clients they are associated with.
-   * @returns {Selection} The new Selection instance.
-   */
-  static intersect({ cross = false } = {}) {
-    return new _Selection(new SelectionResolver({ cross }));
+function convertArrowColumn(column2) {
+  const { type } = column2;
+  if (DataType.isTimestamp(type)) {
+    const size = column2.length;
+    const array = new Array(size);
+    for (let row = 0; row < size; ++row) {
+      const v2 = column2.get(row);
+      array[row] = v2 == null ? null : new Date(v2);
+    }
+    return array;
   }
-  /**
-   * 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 }));
+  if (DataType.isInt(type) && type.bitWidth >= 64) {
+    const size = column2.length;
+    const array = column2.nullCount ? new Array(size) : new Float64Array(size);
+    for (let row = 0; row < size; ++row) {
+      const v2 = column2.get(row);
+      array[row] = v2 == null ? null : Number(v2);
+    }
+    return array;
   }
-  /**
-   * 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 }));
+  if (DataType.isDecimal(type)) {
+    const scale = 1 / Math.pow(10, type.scale);
+    const size = column2.length;
+    const array = column2.nullCount ? new Array(size) : new Float64Array(size);
+    for (let row = 0; row < size; ++row) {
+      const v2 = column2.get(row);
+      array[row] = v2 == null ? null : decimalToNumber(v2, scale);
+    }
+    return array;
   }
-  /**
-   * 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 }));
+  if (column2.nullCount) {
+    return Array.from(column2);
   }
-  /**
-   * Create a new Selection instance.
-   * @param {SelectionResolver} resolver The selection resolution
-   *  strategy to apply.
-   */
-  constructor(resolver = new SelectionResolver()) {
-    super([]);
-    this._resolved = this._value;
-    this._resolver = resolver;
+  return column2.toArray();
+}
+var BASE32 = Array.from(
+  { length: 8 },
+  (_2, i) => Math.pow(2, i * 32)
+);
+function decimalToNumber(v2, scale) {
+  const n = v2.length;
+  let x3 = 0;
+  if (v2.signed && (v2[n - 1] | 0) < 0) {
+    for (let i = 0; i < n; ++i) {
+      x3 += ~v2[i] * BASE32[i];
+    }
+    x3 = -(x3 + 1);
+  } else {
+    for (let i = 0; i < n; ++i) {
+      x3 += v2[i] * BASE32[i];
+    }
   }
-  /**
-   * Create a cloned copy of this Selection instance.
-   * @returns {Selection} A clone of this selection.
-   */
-  clone() {
-    const s = new _Selection(this._resolver);
-    s._value = s._resolved = this._value;
-    return s;
+  return x3 * scale;
+}
+
+// src/util/field-info.js
+var Count = "count";
+var Nulls = "nulls";
+var Max = "max";
+var Min = "min";
+var Distinct = "distinct";
+var statMap = {
+  [Count]: count,
+  [Distinct]: (column2) => count(column2).distinct(),
+  [Max]: max,
+  [Min]: min,
+  [Nulls]: (column2) => count().where(isNull(column2))
+};
+function summarize(table, column2, stats) {
+  return Query.from(table).select(Array.from(stats, (s) => [s, statMap[s](column2)]));
+}
+async function queryFieldInfo(mc, fields) {
+  if (fields.length === 1 && `${fields[0].column}` === "*") {
+    return getTableInfo(mc, fields[0].table);
+  } else {
+    return (await Promise.all(fields.map((f2) => getFieldInfo(mc, f2)))).filter((x3) => x3);
   }
-  /**
-   * Create a clone of this Selection with clauses corresponding
-   * to the provided source removed.
-   * @param {*} source The clause source to remove.
-   * @returns {Selection} A cloned and updated Selection.
-   */
-  remove(source) {
-    const s = this.clone();
-    s._value = s._resolved = s._resolver.resolve(this._resolved, { source });
-    s._value.active = { source };
-    return s;
+}
+async function getFieldInfo(mc, { table, column: column2, stats }) {
+  const q2 = Query.from({ source: table }).select({ column: column2 }).groupby(column2.aggregate ? sql`ALL` : []);
+  const [desc2] = Array.from(await mc.query(Query.describe(q2)));
+  const info = {
+    table,
+    column: `${column2}`,
+    sqlType: desc2.column_type,
+    type: jsType(desc2.column_type),
+    nullable: desc2.null === "YES"
+  };
+  if (!(stats?.length || stats?.size)) return info;
+  const result = await mc.query(
+    summarize(table, column2, stats),
+    { persist: true }
+  );
+  for (let i = 0; i < result.numCols; ++i) {
+    const { name } = result.schema.fields[i];
+    const child = result.getChildAt(i);
+    const convert = convertArrowValue(child.type);
+    info[name] = convert(child.get(0));
   }
-  /**
-   * The current active (most recently updated) selection clause.
-   */
-  get active() {
-    return this.clauses.active;
+  return info;
+}
+async function getTableInfo(mc, table) {
+  const result = await mc.query(`DESCRIBE ${asRelation(table)}`);
+  return Array.from(result).map((desc2) => ({
+    table,
+    column: desc2.column_name,
+    sqlType: desc2.column_type,
+    type: jsType(desc2.column_type),
+    nullable: desc2.null === "YES"
+  }));
+}
+
+// src/util/void-logger.js
+function voidLogger() {
+  return {
+    debug() {
+    },
+    info() {
+    },
+    log() {
+    },
+    warn() {
+    },
+    error() {
+    }
+  };
+}
+
+// src/Coordinator.js
+var _instance;
+function coordinator(instance16) {
+  if (instance16) {
+    _instance = instance16;
+  } else if (_instance == null) {
+    _instance = new Coordinator();
   }
-  /**
-   * The value corresponding to the current active selection clause.
-   * This method ensures compatibility where a normal Param is expected.
-   */
-  get value() {
-    return this.active?.value;
+  return _instance;
+}
+var Coordinator = class {
+  constructor(db = socketConnector(), options = {}) {
+    const {
+      logger = console,
+      manager = new QueryManager()
+    } = options;
+    this.manager = manager;
+    this.logger(logger);
+    this.configure(options);
+    this.databaseConnector(db);
+    this.clear();
   }
-  /**
-   * The current array of selection clauses.
-   */
-  get clauses() {
-    return super.value;
+  logger(logger) {
+    if (arguments.length) {
+      this._logger = logger || voidLogger();
+      this.manager.logger(this._logger);
+    }
+    return this._logger;
   }
   /**
-   * Indicate if this selection has a single resolution strategy.
+   * Set configuration options for this coordinator.
+   * @param {object} [options] Configration options.
+   * @param {boolean} [options.cache=true] Boolean flag to enable/disable query caching.
+   * @param {boolean} [options.consolidate=true] Boolean flag to enable/disable query consolidation.
+   * @param {boolean|object} [options.indexes=true] Boolean flag to enable/disable
+   *  automatic data cube indexes or an index options object.
    */
-  get single() {
-    return this._resolver.single;
+  configure({ cache = true, consolidate: consolidate2 = true, indexes = true } = {}) {
+    this.manager.cache(cache);
+    this.manager.consolidate(consolidate2);
+    this.indexes = indexes;
   }
-  /**
-   * Emit an activate event with the given selection clause.
-   * @param {*} clause The clause repesenting the potential activation.
-   */
-  activate(clause) {
-    this.emit("activate", clause);
+  clear({ clients = true, cache = true } = {}) {
+    this.manager.clear();
+    if (clients) {
+      this.clients?.forEach((client) => this.disconnect(client));
+      this.filterGroups?.forEach((group) => group.finalize());
+      this.clients = /* @__PURE__ */ new Set();
+      this.filterGroups = /* @__PURE__ */ new Map();
+    }
+    if (cache) this.manager.cache().clear();
   }
-  /**
-   * 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);
+  databaseConnector(db) {
+    return this.manager.connector(db);
   }
-  /**
-   * Upon value-typed updates, sets the current clause list to the
-   * input value and returns the active clause value.
-   * @param {string} type The event type.
-   * @param {*} value The input event value.
-   * @returns {*} For value-typed events, returns the active clause
-   *  values. Otherwise returns the input event value as-is.
-   */
-  willEmit(type, value) {
-    if (type === "value") {
-      this._value = value;
-      return this.value;
-    }
-    return value;
+  // -- Query Management ----
+  cancel(requests) {
+    this.manager.cancel(requests);
   }
-  /**
-   * Upon value-typed updates, returns a dispatch queue filter function.
-   * The return value depends on the selection resolution strategy.
-   * @param {string} type The event type.
-   * @param {*} value The new event value that will be enqueued.
-   * @returns {(value: *) => boolean|null} For value-typed events,
-   *  returns a dispatch queue filter function. Otherwise returns null.
-   */
-  emitQueueFilter(type, value) {
-    return type === "value" ? this._resolver.queueFilter(value) : null;
+  exec(query, { priority = Priority.Normal } = {}) {
+    query = Array.isArray(query) ? query.join(";\n") : query;
+    return this.manager.request({ type: "exec", query }, priority);
   }
-  /**
-   * 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);
+  query(query, {
+    type = "arrow",
+    cache = true,
+    priority = Priority.Normal,
+    ...options
+  } = {}) {
+    return this.manager.request({ type, query, cache, options }, priority);
   }
-  /**
-   * Return a selection query predicate for the given client.
-   * @param {*} client The client whose data may be filtered.
-   * @param {boolean} [noSkip=false] Disable skipping of active
-   *  cross-filtered sources. If set true, the source of the active
-   *  clause in a cross-filtered selection will not be skipped.
-   * @returns {*} The query predicate for filtering client data,
-   *  based on the current state of this selection.
-   */
-  predicate(client, noSkip = false) {
-    const { clauses } = this;
-    const active = noSkip ? null : clauses.active;
-    return this._resolver.predicate(clauses, active, client);
+  prefetch(query, options = {}) {
+    return this.query(query, { ...options, cache: true, priority: Priority.Low });
   }
-};
-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;
+  createBundle(name, queries, priority = Priority.Low) {
+    const options = { name, queries };
+    return this.manager.request({ type: "create-bundle", options }, priority);
   }
-  /**
-   * Resolve a list of selection clauses according to the resolution strategy.
-   * @param {*[]} clauseList An array of selection clauses.
-   * @param {*} clause A new selection clause to add.
-   * @returns {*[]} An updated array of selection clauses.
-   */
-  resolve(clauseList, clause, reset = false) {
-    const { source, predicate } = clause;
-    const filtered = clauseList.filter((c) => source !== c.source);
-    const clauses = this.single ? [] : filtered;
-    if (this.single && reset) filtered.forEach((c) => c.source?.reset?.());
-    if (predicate) clauses.push(clause);
-    return clauses;
+  loadBundle(name, priority = Priority.High) {
+    const options = { name };
+    return this.manager.request({ type: "load-bundle", options }, priority);
   }
-  /**
-   * 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);
+  // -- 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();
   }
   /**
-   * 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.
+   * Connect a client to the coordinator.
+   * @param {import('./MosaicClient.js').MosaicClient} client the client to disconnect
    */
-  predicate(clauseList, active, client) {
-    const { union } = this;
-    if (this.skip(client, active)) return void 0;
-    const predicates = clauseList.filter((clause) => !this.skip(client, clause)).map((clause) => clause.predicate);
-    return union && predicates.length > 1 ? or(predicates) : predicates;
+  async connect(client) {
+    const { clients, filterGroups, indexes } = this;
+    if (clients.has(client)) {
+      throw new Error("Client already connected.");
+    }
+    clients.add(client);
+    client.coordinator = this;
+    const fields = client.fields();
+    if (fields?.length) {
+      client.fieldInfo(await queryFieldInfo(this, fields));
+    }
+    const filter = client.filterBy;
+    if (filter) {
+      if (filterGroups.has(filter)) {
+        filterGroups.get(filter).add(client);
+      } else {
+        const group = new FilterGroup(this, filter, indexes);
+        filterGroups.set(filter, group.add(client));
+      }
+    }
+    client.requestQuery();
   }
   /**
-   * Returns a filter function for queued selection updates.
-   * @param {*} value The new event value that will be enqueued.
-   * @returns {(value: *) => boolean|null} A dispatch queue filter
-   *  function, or null if all unemitted event values should be filtered.
+   * Disconnect a client from the coordinator.
+   *
+   * @param {import('./MosaicClient.js').MosaicClient} client the client to disconnect
    */
-  queueFilter(value) {
-    if (this.cross) {
-      const source = value.active?.source;
-      return (clauses) => clauses.active?.source !== source;
-    }
-    return null;
+  disconnect(client) {
+    const { clients, filterGroups } = this;
+    if (!clients.has(client)) return;
+    clients.delete(client);
+    filterGroups.get(client.filterBy)?.remove(client);
+    client.coordinator = null;
   }
 };
 
+// src/SelectionClause.js
+function point(field, value, { source, clients = void 0 }) {
+  const predicate = value !== void 0 ? isNotDistinct(field, literal(value)) : null;
+  return {
+    meta: { type: "point" },
+    source,
+    clients,
+    value,
+    predicate
+  };
+}
+function points(fields, value, { source, clients = void 0 }) {
+  let predicate = null;
+  if (value) {
+    const clauses = value.map((vals) => {
+      const list = vals.map((v2, i) => isNotDistinct(fields[i], literal(v2)));
+      return list.length > 1 ? and(list) : list[0];
+    });
+    predicate = clauses.length > 1 ? or(clauses) : clauses[0];
+  }
+  return {
+    meta: { type: "point" },
+    source,
+    clients,
+    value,
+    predicate
+  };
+}
+function interval(field, value, {
+  source,
+  clients,
+  bin,
+  scale,
+  pixelSize = 1
+}) {
+  const predicate = value != null ? isBetween(field, value) : null;
+  const meta = { type: "interval", scales: [scale], bin, pixelSize };
+  return { meta, source, clients, value, predicate };
+}
+function intervals(fields, value, {
+  source,
+  clients,
+  bin,
+  scales: scales2 = [],
+  pixelSize = 1
+}) {
+  const predicate = value != null ? and(fields.map((f2, i) => isBetween(f2, value[i]))) : null;
+  const meta = { type: "interval", scales: scales2, bin, pixelSize };
+  return { meta, source, clients, value, predicate };
+}
+var MATCH_METHODS = { contains, prefix, suffix, regexp: regexp_matches };
+function match(field, value, {
+  source,
+  clients = void 0,
+  method = "contains"
+}) {
+  let fn = MATCH_METHODS[method];
+  const predicate = value ? fn(field, literal(value)) : null;
+  const meta = { type: "match", method };
+  return { meta, source, clients, value, predicate };
+}
+
 // src/connectors/rest.js
 function restConnector(uri = "http://localhost:3000/") {
   return {
+    /**
+     * Query the DuckDB server.
+     * @param {object} query
+     * @param {'exec' | 'arrow' | 'json'} [query.type] The query type: 'exec', 'arrow', or 'json'.
+     * @param {string} query.sql A SQL query string.
+     * @returns the query result
+     */
     async query(query) {
       const req = fetch(uri, {
         method: "POST",
@@ -16932,10 +17242,10 @@ var getDictionary2 = (data, index) => {
 var getInterval2 = (data, index) => data.type.unit === IntervalUnit2.DAY_TIME ? getIntervalDayTime2(data, index) : getIntervalYearMonth2(data, index);
 var getIntervalDayTime2 = ({ values }, index) => values.subarray(2 * index, 2 * (index + 1));
 var getIntervalYearMonth2 = ({ values }, index) => {
-  const interval = values[index];
+  const interval2 = values[index];
   const int32s = new Int32Array(2);
-  int32s[0] = Math.trunc(interval / 12);
-  int32s[1] = Math.trunc(interval % 12);
+  int32s[0] = Math.trunc(interval2 / 12);
+  int32s[1] = Math.trunc(interval2 % 12);
   return int32s;
 };
 var getDurationSecond2 = ({ values }, index) => values[index];
@@ -25903,7 +26213,7 @@ function wasmConnector(options = {}) {
     /**
      * Query the DuckDB-WASM instance.
      * @param {object} query
-     * @param {string} [query.type] The query type: 'exec', 'arrow', or 'json'.
+     * @param {'exec' | 'arrow' | 'json'} [query.type] The query type: 'exec', 'arrow', or 'json'.
      * @param {string} query.sql A SQL query string.
      * @returns the query result
      */
@@ -25911,7 +26221,7 @@ function wasmConnector(options = {}) {
       const { type, sql: sql2 } = query;
       const con2 = await getConnection();
       const result = await con2.query(sql2);
-      return type === "exec" ? void 0 : type === "arrow" ? result : Array.from(result);
+      return type === "exec" ? void 0 : type === "arrow" ? result : result.toArray();
     }
   };
 }
@@ -25985,9 +26295,14 @@ export {
   convertArrowValue,
   coordinator,
   distinct,
+  interval,
+  intervals,
   isArrowTable,
   isParam,
   isSelection,
+  match,
+  point,
+  points,
   restConnector,
   socketConnector,
   synchronizer,