@uwdata/mosaic-core 0.0.1 → 0.1.0

package/dist/mosaic-core.js

@@ -4,41 +4,6 @@ var __export = (target, all2) => {
     __defProp(target, name, { get: all2[name], enumerable: true });
 };
 
-// src/MosaicClient.js
-var MosaicClient = class {
-  constructor(filterSelection) {
-    this._filterBy = filterSelection;
-  }
-  get filterBy() {
-    return this._filterBy;
-  }
-  get filterIndexable() {
-    return true;
-  }
-  fields() {
-    return null;
-  }
-  fieldStats() {
-    return this;
-  }
-  query() {
-    return null;
-  }
-  queryPending() {
-    return this;
-  }
-  queryResult() {
-    return this;
-  }
-  queryError(error) {
-    console.error(error);
-    return this;
-  }
-  update() {
-    return this;
-  }
-};
-
 // ../../node_modules/tslib/tslib.es6.js
 function __rest(s, e) {
   var t = {};
@@ -11532,6 +11497,44 @@ function socketClient(uri = "ws://localhost:3000/") {
   };
 }
 
+// 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":
+    case "DECIMAL":
+      return "number";
+    case "DATE":
+    case "TIMESTAMP":
+    case "TIMESTAMPTZ":
+    case "TIME":
+      return "date";
+    case "BOOLEAN":
+      return "boolean";
+    case "VARCHAR":
+    case "UUID":
+      return "string";
+    case "LIST":
+      return "array";
+    case "BLOB":
+    case "STRUCT":
+    case "MAP":
+      return "object";
+    default:
+      throw new Error(`Unsupported type: ${type}`);
+  }
+}
+
 // ../sql/src/ref.js
 var Ref = class {
   constructor(table, column2) {
@@ -11568,23 +11571,6 @@ function relation(name) {
 function column(table, column2) {
   return arguments.length === 1 ? new Ref(null, table) : new Ref(table, column2);
 }
-function expr(sql, columns, label) {
-  return {
-    expr: sql,
-    label,
-    toString: () => `${sql}`,
-    get columns() {
-      return columns || [];
-    }
-  };
-}
-function transform(func2, label) {
-  return (value) => expr(
-    func2(value),
-    asColumn(value).columns,
-    label
-  );
-}
 
 // ../sql/src/to-sql.js
 function toSQL(value) {
@@ -11609,6 +11595,27 @@ function literalToSQL(value) {
   }
 }
 
+// ../sql/src/expression.js
+function isExpression(e) {
+  return e instanceof SQLExpression;
+}
+var SQLExpression = class {
+  constructor(sql2, columns, label) {
+    this.expr = sql2;
+    this.label = label;
+    this.columns = columns || [];
+  }
+  toString() {
+    return `${this.expr}`;
+  }
+};
+function expr(sql2, columns, label) {
+  return new SQLExpression(sql2, columns, label);
+}
+function transform(func2, label) {
+  return (value) => expr(func2(value), asColumn(value).columns, label);
+}
+
 // ../sql/src/compare.js
 function extractColumns(...args) {
   return args.flat().flatMap((arg) => arg?.columns || []);
@@ -11769,10 +11776,10 @@ var Aggregate = class {
   toString() {
     const { aggregate, args, isDistinct: isDistinct2, filter } = this;
     const arg = args.length === 0 ? "*" : args.map(toSQL).join(", ");
-    const distinct = isDistinct2 ? "DISTINCT " : "";
+    const distinct2 = isDistinct2 ? "DISTINCT " : "";
     const where = filter ? ` FILTER (WHERE ${toSQL(filter)})` : "";
     const cast = aggregate === "COUNT" ? "::INTEGER" : "";
-    return where && cast ? `(${aggregate}(${distinct}${arg})${where})${cast}` : `${aggregate}(${distinct}${arg})${where}${cast}`;
+    return where && cast ? `(${aggregate}(${distinct2}${arg})${where})${cast}` : `${aggregate}(${distinct2}${arg})${where}${cast}`;
   }
 };
 function agg(op) {
@@ -11929,7 +11936,7 @@ var Query = class {
           list.push({ as: e, from: asRelation(e) });
         } else if (e instanceof Ref) {
           list.push({ as: e.table, from: e });
-        } else if (isQuery(e) || Object.hasOwn(e, "toString")) {
+        } else if (isQuery(e) || isExpression(e)) {
           list.push({ from: e });
         } else if (Array.isArray(e)) {
           list.push({ as: unquote(e[0]), from: asRelation(e[1]) });
@@ -12073,7 +12080,7 @@ var Query = class {
   toString() {
     const {
       select,
-      distinct,
+      distinct: distinct2,
       from,
       sample,
       where,
@@ -12086,60 +12093,60 @@ var Query = class {
       offset,
       with: cte
     } = this.query;
-    const sql = [];
+    const sql2 = [];
     if (cte.length) {
       const list = cte.map(({ as, query }) => `"${as}" AS (${query})`);
-      sql.push(`WITH ${list.join(", ")}`);
+      sql2.push(`WITH ${list.join(", ")}`);
     }
     const sels = select.map(
       ({ as, expr: expr2 }) => isColumnRefFor(expr2, as) && !expr2.table ? `${expr2}` : `${expr2} AS "${as}"`
     );
-    sql.push(`SELECT${distinct ? " DISTINCT" : ""} ${sels.join(", ")}`);
+    sql2.push(`SELECT${distinct2 ? " DISTINCT" : ""} ${sels.join(", ")}`);
     if (from.length) {
       const rels = from.map(({ as, from: from2 }) => {
         const rel = isQuery(from2) ? `(${from2})` : `${from2}`;
         return !as || as === from2.table ? rel : `${rel} AS "${as}"`;
       });
-      sql.push(`FROM ${rels.join(", ")}`);
+      sql2.push(`FROM ${rels.join(", ")}`);
     }
     if (sample) {
       const { rows, perc, method, seed } = sample;
       const size = rows ? `${rows} ROWS` : `${perc} PERCENT`;
       const how = method ? ` (${method}${seed != null ? `, ${seed}` : ""})` : "";
-      sql.push(`USING SAMPLE ${size}${how}`);
+      sql2.push(`USING SAMPLE ${size}${how}`);
     }
     if (where.length) {
       const clauses = where.map(String).filter((x2) => x2).join(" AND ");
       if (clauses)
-        sql.push(`WHERE ${clauses}`);
+        sql2.push(`WHERE ${clauses}`);
     }
     if (groupby.length) {
-      sql.push(`GROUP BY ${groupby.join(", ")}`);
+      sql2.push(`GROUP BY ${groupby.join(", ")}`);
     }
     if (having.length) {
       const clauses = having.map(String).filter((x2) => x2).join(" AND ");
       if (clauses)
-        sql.push(`HAVING ${clauses}`);
+        sql2.push(`HAVING ${clauses}`);
     }
     if (window.length) {
       const windows = window.map(({ as, expr: expr2 }) => `"${as}" AS (${expr2})`);
-      sql.push(`WINDOW ${windows.join(", ")}`);
+      sql2.push(`WINDOW ${windows.join(", ")}`);
     }
     if (qualify.length) {
       const clauses = qualify.map(String).filter((x2) => x2).join(" AND ");
       if (clauses)
-        sql.push(`QUALIFY ${clauses}`);
+        sql2.push(`QUALIFY ${clauses}`);
     }
     if (orderby.length) {
-      sql.push(`ORDER BY ${orderby.join(", ")}`);
+      sql2.push(`ORDER BY ${orderby.join(", ")}`);
     }
     if (Number.isFinite(limit)) {
-      sql.push(`LIMIT ${limit}`);
+      sql2.push(`LIMIT ${limit}`);
     }
     if (Number.isFinite(offset)) {
-      sql.push(`OFFSET ${offset}`);
+      sql2.push(`OFFSET ${offset}`);
     }
-    return sql.join(" ");
+    return sql2.join(" ");
   }
 };
 var SetOperation = class {
@@ -12190,17 +12197,17 @@ var SetOperation = class {
   }
   toString() {
     const { op, queries, query: { orderby, limit, offset } } = this;
-    const sql = [queries.join(` ${op} `)];
+    const sql2 = [queries.join(` ${op} `)];
     if (orderby.length) {
-      sql.push(`ORDER BY ${orderby.join(", ")}`);
+      sql2.push(`ORDER BY ${orderby.join(", ")}`);
     }
     if (Number.isFinite(limit)) {
-      sql.push(`LIMIT ${limit}`);
+      sql2.push(`LIMIT ${limit}`);
     }
     if (Number.isFinite(offset)) {
-      sql.push(`OFFSET ${offset}`);
+      sql2.push(`OFFSET ${offset}`);
     }
-    return sql.join(" ");
+    return sql2.join(" ");
   }
 };
 function isQuery(value) {
@@ -12213,54 +12220,32 @@ function isDoubleQuoted(s) {
   return s[0] === '"' && s[s.length - 1] === '"';
 }
 
-// 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":
-    case "DECIMAL":
-      return "number";
-    case "DATE":
-    case "TIMESTAMP":
-    case "TIMESTAMPTZ":
-    case "TIME":
-      return "date";
-    case "BOOLEAN":
-      return "boolean";
-    case "VARCHAR":
-    case "UUID":
-      return "string";
-    case "LIST":
-      return "array";
-    case "BLOB":
-    case "STRUCT":
-    case "MAP":
-      return "object";
-    default:
-      throw new Error(`Unsupported type: ${type}`);
-  }
+// src/util/summarize.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, column: column2 }, stats) {
+  return Query.from(table).select(stats.map((s) => [s, statMap[s](column2)]));
 }
 
 // src/Catalog.js
 var object = () => /* @__PURE__ */ Object.create(null);
 var Catalog = class {
-  constructor(mc) {
-    this.mc = mc;
+  constructor(coordinator2) {
+    this.mc = coordinator2;
     this.clear();
   }
   clear() {
     this.tables = object();
-    this.fields = object();
   }
   async tableInfo(table) {
     const cache = this.tables;
@@ -12268,56 +12253,42 @@ var Catalog = class {
       return cache[table];
     }
     const q2 = this.mc.query(
-      `PRAGMA table_info('${table}')`,
-      { type: "json" }
+      `DESCRIBE "${table}"`,
+      { type: "json", cache: false }
     );
     return cache[table] = q2.then((result) => {
       const columns = object();
       for (const entry of result) {
-        columns[entry.name] = { ...entry, jstype: jsType(entry.type) };
+        columns[entry.column_name] = {
+          table,
+          column: entry.column_name,
+          sqlType: entry.column_type,
+          type: jsType(entry.column_type),
+          nullable: entry.null === "YES"
+        };
       }
       return columns;
     });
   }
-  async fieldInfo(table, column2) {
-    const info = await this.tableInfo(table);
-    const colInfo = info[column2];
+  async fieldInfo({ table, column: column2, stats }) {
+    const tableInfo = await this.tableInfo(table);
+    const colInfo = tableInfo[column2];
     if (colInfo == null)
       return;
-    const cache = this.fields;
-    const key = `${table}.${column2}`;
-    if (cache[key]) {
-      return cache[key];
-    }
-    const promise = this.mc.query(
-      Query.from(table).select({
-        rows: count(),
-        nulls: count().where(isNull(column2)),
-        min: min(column2),
-        max: max(column2)
-      }, { cache: false })
-    ).then((result) => {
-      const [stats] = Array.from(result);
-      return { table, column: column2, type: colInfo.jstype, ...stats };
-    });
-    return cache[key] = promise;
+    if (!stats?.length)
+      return colInfo;
+    const result = await this.mc.query(summarize(colInfo, stats));
+    const info = { ...colInfo, ...Array.from(result)[0] };
+    return info;
   }
   async queryFields(fields) {
     const list = await resolveFields(this, fields);
-    const data = await Promise.all(
-      list.map((f2) => this.fieldInfo(f2.table, f2.column))
-    );
+    const data = await Promise.all(list.map((f2) => this.fieldInfo(f2)));
     return data.filter((x2) => x2);
   }
 };
 async function resolveFields(catalog, list) {
-  if (list.length === 1 && list[0].column === "*") {
-    const table = list[0].table;
-    const info = await catalog.tableInfo(table);
-    return Object.keys(info).map((column2) => ({ table, column: column2 }));
-  } else {
-    return list;
-  }
+  return list.length === 1 && list[0].column === "*" ? Object.values(await catalog.tableInfo(list[0].table)) : list;
 }
 
 // src/util/hash.js
@@ -12383,9 +12354,10 @@ var DataTileIndexer = class {
     const activeView = this.activeView = getActiveView(active);
     if (!activeView)
       return false;
-    console.warn("DATA TILE INDEX CONSTRUCTION");
+    this.mc.logger().warn("DATA TILE INDEX CONSTRUCTION");
     const sel = this.selection.clone().update({ source });
     const indices = this.indices = /* @__PURE__ */ new Map();
+    const promises = [];
     for (const client of clients) {
       if (sel.cross && skipClient(client, active))
         continue;
@@ -12396,13 +12368,13 @@ var DataTileIndexer = class {
         const cols = Object.values(activeView.columns).map((c) => c.columns[0]);
         subqueryPushdown(subq, cols);
       }
-      const sql = query.toString();
-      const id = (fnv_hash(sql) >>> 0).toString(16);
+      const sql2 = query.toString();
+      const id = (fnv_hash(sql2) >>> 0).toString(16);
       const table = `tile_index_${id}`;
       indices.set(client, { table, ...index });
-      createIndex(this.mc, table, sql);
+      promises.push(createIndex(this.mc, table, sql2));
     }
-    return true;
+    return promises;
   }
   async update() {
     const { clients, selection, activeView } = this;
@@ -12455,38 +12427,38 @@ function getActiveView(clause) {
 }
 function binInterval(scale) {
   const { type, domain, range: range2 } = scale;
-  let lift, sql;
+  let lift, sql2;
   switch (type) {
     case "linear":
       lift = identity;
-      sql = asColumn;
+      sql2 = asColumn;
       break;
     case "log":
       lift = Math.log;
-      sql = (c) => `LN(${asColumn(c)})`;
+      sql2 = (c) => `LN(${asColumn(c)})`;
       break;
     case "symlog":
       lift = (x2) => Math.sign(x2) * Math.log1p(Math.abs(x2));
-      sql = (c) => (c = asColumn(c), `SIGN(${c}) * LN(1 + ABS(${c}))`);
+      sql2 = (c) => (c = asColumn(c), `SIGN(${c}) * LN(1 + ABS(${c}))`);
       break;
     case "sqrt":
       lift = Math.sqrt;
-      sql = (c) => `SQRT(${asColumn(c)})`;
+      sql2 = (c) => `SQRT(${asColumn(c)})`;
       break;
     case "utc":
     case "time":
       lift = (x2) => +x2;
-      sql = (c) => c instanceof Date ? +c : epoch_ms(asColumn(c));
+      sql2 = (c) => c instanceof Date ? +c : epoch_ms(asColumn(c));
       break;
   }
-  return lift ? binFunction(domain, range2, lift, sql) : null;
+  return lift ? binFunction(domain, range2, lift, sql2) : null;
 }
-function binFunction(domain, range2, lift, sql) {
+function binFunction(domain, range2, lift, sql2) {
   const lo = lift(Math.min(domain[0], domain[1]));
   const hi = lift(Math.max(domain[0], domain[1]));
   const a = Math.abs(lift(range2[1]) - lift(range2[0])) / (hi - lo);
   return (value) => expr(
-    `FLOOR(${a}::DOUBLE * (${sql(value)} - ${lo}::DOUBLE))`,
+    `FLOOR(${a}::DOUBLE * (${sql2(value)} - ${lo}::DOUBLE))`,
     asColumn(value).columns
   );
 }
@@ -12494,15 +12466,17 @@ async function createIndex(mc, table, query) {
   try {
     await mc.exec(`CREATE TEMP TABLE IF NOT EXISTS ${table} AS ${query}`);
   } catch (err) {
-    console.error(err);
+    mc.logger().error(err);
   }
 }
+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 || !client.filterIndexable) {
-    return { from: NaN };
-  }
+  if (!from || !q2.groupby)
+    return NO_INDEX;
   const g2 = new Set(q2.groupby().map((c) => c.column));
   let aggr = [];
   let dims = [];
@@ -12571,13 +12545,15 @@ function subqueryPushdown(query, cols) {
 }
 
 // src/util/throttle.js
-function throttle(callback) {
+var NIL = {};
+function throttle(callback, debounce = false) {
   let curr;
   let next;
+  let pending = NIL;
   function invoke(event) {
     curr = callback(event).then(() => {
       if (next) {
-        const value = next;
+        const { value } = next;
         next = null;
         invoke(value);
       } else {
@@ -12586,18 +12562,31 @@ function throttle(callback) {
     });
   }
   function enqueue(event) {
-    next = event;
+    next = { event };
+  }
+  function process(event) {
+    curr ? enqueue(event) : invoke(event);
+  }
+  function delay(event) {
+    if (pending !== event) {
+      requestAnimationFrame(() => {
+        const e = pending;
+        pending = NIL;
+        process(e);
+      });
+    }
+    pending = event;
   }
-  return (event) => curr ? enqueue(event) : invoke(event);
+  return debounce ? delay : process;
 }
 
 // src/FilterGroup.js
 var FilterGroup = class {
-  constructor(mc, selection, index = true) {
-    this.mc = mc;
+  constructor(coordinator2, selection, index = true) {
+    this.mc = coordinator2;
     this.selection = selection;
     this.clients = /* @__PURE__ */ new Set();
-    this.indexer = index ? new DataTileIndexer(mc, selection) : null;
+    this.indexer = index ? new DataTileIndexer(this.mc, selection) : null;
     const { value, activate } = this.handlers = {
       value: throttle(() => this.update()),
       activate: (clause) => {
@@ -12640,6 +12629,13 @@ function defaultUpdate(mc, clients, selection) {
 }
 
 // src/QueryCache.js
+var requestIdle = typeof requestIdleCallback !== "undefined" ? requestIdleCallback : setTimeout;
+var voidCache = () => ({
+  get: () => void 0,
+  set: (key, result) => result,
+  clear: () => {
+  }
+});
 var QueryCache = class {
   constructor({
     max: max2 = 1e3,
@@ -12663,16 +12659,10 @@ var QueryCache = class {
   }
   set(key, promise) {
     const { cache, max: max2 } = this;
-    const now = performance.now();
-    const receive = promise.then((result) => {
-      console.log(`Query: ${Math.round(performance.now() - now)}`);
-      return result;
-    });
-    cache.set(key, { last: now, promise });
-    if (cache.size > max2) {
-      setTimeout(() => this.evict());
-    }
-    return receive;
+    cache.set(key, { last: performance.now(), promise });
+    if (cache.size > max2)
+      requestIdle(() => this.evict());
+    return promise;
   }
   evict() {
     const expire = performance.now() - this.ttl;
@@ -12694,6 +12684,22 @@ var QueryCache = class {
   }
 };
 
+// src/util/void-logger.js
+function voidLogger() {
+  return {
+    debug() {
+    },
+    info() {
+    },
+    log() {
+    },
+    warn() {
+    },
+    error() {
+    }
+  };
+}
+
 // src/Coordinator.js
 var _instance;
 function coordinator(instance17) {
@@ -12705,27 +12711,25 @@ function coordinator(instance17) {
   return _instance;
 }
 var Coordinator = class {
-  constructor(db = socketClient()) {
-    this.cache = new QueryCache();
+  constructor(db = socketClient(), options = {}) {
     this.catalog = new Catalog(this);
-    this.indexes = true;
+    this.logger(options.logger || console);
+    this.configure(options);
     this.databaseClient(db);
     this.clear();
   }
+  logger(logger) {
+    return arguments.length ? this._logger = logger || voidLogger() : this._logger;
+  }
   configure({ cache = true, indexes = true }) {
-    this.cache = cache ? new QueryCache() : {
-      get: () => void 0,
-      set: (key, result) => result,
-      clear: () => {
-      }
-    };
+    this.cache = cache ? new QueryCache() : voidCache();
     this.indexes = indexes;
   }
   clear({ clients = true, cache = true, catalog = false } = {}) {
     if (clients) {
-      this.clients?.forEach((_2, client) => this.disconnect(client));
+      this.clients?.forEach((client) => this.disconnect(client));
       this.filterGroups?.forEach((group) => group.finalize());
-      this.clients = /* @__PURE__ */ new Map();
+      this.clients = /* @__PURE__ */ new Set();
       this.filterGroups = /* @__PURE__ */ new Map();
     }
     if (cache)
@@ -12739,21 +12743,25 @@ var Coordinator = class {
     }
     return this.db;
   }
-  async exec(sql) {
+  async exec(sql2) {
     try {
-      await this.db.query({ type: "exec", sql });
+      await this.db.query({ type: "exec", sql: sql2 });
     } catch (err) {
-      console.error(err);
+      this._logger.error(err);
     }
   }
-  async query(query, { type = "arrow", cache = true } = {}) {
-    const sql = String(query);
-    const cached = this.cache.get(sql);
+  query(query, { type = "arrow", cache = true } = {}) {
+    const sql2 = String(query);
+    const t0 = performance.now();
+    const cached = this.cache.get(sql2);
     if (cached) {
+      this._logger.debug("Cache");
       return cached;
     } else {
-      const request = this.db.query({ type, sql });
-      return cache ? this.cache.set(sql, request) : request;
+      const request = this.db.query({ type, sql: sql2 });
+      const result = cache ? this.cache.set(sql2, request) : request;
+      result.then(() => this._logger.debug(`Query: ${performance.now() - t0}`));
+      return result;
     }
   }
   async updateClient(client, query) {
@@ -12762,22 +12770,26 @@ var Coordinator = class {
       client.queryPending();
       result = await this.query(query);
     } catch (err) {
-      console.error(err);
+      this._logger.error(err);
       client.queryError(err);
       return;
     }
     try {
       client.queryResult(result).update();
     } catch (err) {
-      console.error(err);
+      this._logger.error(err);
     }
   }
+  async requestQuery(client, query) {
+    this.filterGroups.get(client.filterBy)?.reset();
+    return query ? this.updateClient(client, query) : client.update();
+  }
   async connect(client) {
     const { catalog, clients, filterGroups, indexes } = this;
     if (clients.has(client)) {
       throw new Error("Client already connected.");
     }
-    clients.set(client, null);
+    clients.add(client);
     const fields = client.fields();
     if (fields?.length) {
       client.fieldStats(await catalog.queryFields(fields));
@@ -12791,41 +12803,139 @@ var Coordinator = class {
         filterGroups.set(filter, group.add(client));
       }
     }
-    const handler = async (query) => {
-      const q2 = query || client.query(filter?.predicate(client));
-      filterGroups.get(filter)?.reset();
-      if (q2)
-        this.updateClient(client, q2);
-    };
-    clients.set(client, handler);
-    client.request?.addEventListener("value", handler);
-    handler();
+    client.requestQuery();
   }
   disconnect(client) {
     const { clients, filterGroups } = this;
     if (!clients.has(client))
       return;
-    const handler = clients.get(client);
     clients.delete(client);
     filterGroups.get(client.filterBy)?.remove(client);
-    client.request?.removeEventListener(handler);
   }
 };
 
-// src/Signal.js
-function isSignal(x2) {
-  return x2 instanceof Signal;
+// src/MosaicClient.js
+var MosaicClient = class {
+  /**
+   * Constructor.
+   * @param {*} filterSelection An optional selection to interactively filter
+   *  this client's data. If provided, a coordinator will re-query and update
+   *  the client when the selection updates.
+   */
+  constructor(filterSelection) {
+    this._filterBy = filterSelection;
+    this._requestUpdate = throttle(() => this.requestQuery(), true);
+  }
+  /**
+   * Return this client's filter selection.
+   */
+  get filterBy() {
+    return this._filterBy;
+  }
+  /**
+   * Return a boolean indicating if the client query can be indexed. Should
+   * return true if changes to the filterBy selection does not change the
+   * groupby domain of the client query.
+   */
+  get filterIndexable() {
+    return true;
+  }
+  /**
+   * Return an array of fields queried by this client.
+   */
+  fields() {
+    return null;
+  }
+  /**
+   * Called by the coordinator to set the field statistics for this client.
+   * @returns {this}
+   */
+  fieldStats() {
+    return this;
+  }
+  /**
+   * Return a query specifying the data needed by this client.
+   */
+  query() {
+    return null;
+  }
+  /**
+   * Called by the coordinator to inform the client that a query is pending.
+   */
+  queryPending() {
+    return this;
+  }
+  /**
+   * Called by the coordinator to return a query result.
+   */
+  queryResult() {
+    return this;
+  }
+  /**
+   * Called by the coordinator to report a query execution error.
+   */
+  queryError(error) {
+    console.error(error);
+    return this;
+  }
+  /**
+   * Request the coordinator to execute a query for this client.
+   * If an explicit query is not provided, the client query method will
+   * be called, filtered by the current filterBy selection.
+   */
+  requestQuery(query) {
+    const q2 = query || this.query(this.filterBy?.predicate(this));
+    return coordinator().requestQuery(this, q2);
+  }
+  /**
+   * Request that the coordinator perform a throttled update of this client
+   * using the default query. Unlike requestQuery, for which every call will
+   * result in an executed query, multiple calls to requestUpdate may be
+   * consolidated into a single update.
+   */
+  requestUpdate() {
+    this._requestUpdate();
+  }
+  /**
+   * Requests a client update.
+   * For example to (re-)render an interface component.
+   */
+  update() {
+    return this;
+  }
+};
+
+// src/util/distinct.js
+function distinct(a, b2) {
+  return a === b2 ? false : a instanceof Date && b2 instanceof Date ? +a !== +b2 : Array.isArray(a) && Array.isArray(b2) ? distinctArray(a, b2) : true;
+}
+function distinctArray(a, b2) {
+  if (a.length !== b2.length)
+    return true;
+  for (let i2 = 0; i2 < a.length; ++i2) {
+    if (a[i2] !== b2[i2])
+      return true;
+  }
+  return false;
+}
+
+// src/Param.js
+function isParam(x2) {
+  return x2 instanceof Param;
 }
-var Signal = class {
+var Param = class {
   constructor(value) {
     this._value = value;
     this._listeners = /* @__PURE__ */ new Map();
   }
+  static value(value) {
+    return new Param(value);
+  }
   get value() {
     return this._value;
   }
   update(value, { force } = {}) {
-    const changed = this._value !== value;
+    const changed = distinct(this._value, value);
     if (changed)
       this._value = value;
     if (changed || force)
@@ -12834,7 +12944,7 @@ var Signal = class {
   }
   addEventListener(type, callback) {
     let list = this._listeners.get(type) || [];
-    if (list.indexOf(callback) < 0) {
+    if (!list.includes(callback)) {
       list = list.concat(callback);
     }
     this._listeners.set(type, list);
@@ -12854,7 +12964,7 @@ var Signal = class {
 function isSelection(x2) {
   return x2 instanceof Selection;
 }
-var Selection = class extends Signal {
+var Selection = class extends Param {
   static intersect() {
     return new Selection();
   }
@@ -24029,8 +24139,8 @@ async function wasmClient(options) {
     db,
     con,
     query: async (query) => {
-      const { type, sql } = query;
-      const result = await con.query(sql);
+      const { type, sql: sql2 } = query;
+      const result = await con.query(sql2);
       return type === "exec" ? void 0 : type === "arrow" ? result : Array.from(result);
     }
   };
@@ -24053,11 +24163,12 @@ async function initDatabase({
 export {
   Coordinator,
   MosaicClient,
+  Param,
   Selection,
-  Signal,
   coordinator,
+  distinct,
+  isParam,
   isSelection,
-  isSignal,
   restClient,
   socketClient,
   sqlFrom,