@uwdata/mosaic-core 0.14.1 → 0.16.1

package/dist/types/connectors/wasm.d.ts

@@ -1,16 +1,135 @@
-export function wasmConnector(options?: {}): {
-    getDuckDB: () => Promise<duckdb.AsyncDuckDB>;
-    getConnection: () => Promise<duckdb.AsyncDuckDBConnection>;
-    /**
-     * Query the DuckDB-WASM instance.
-     * @param {object} query
-     * @param {'exec' | 'arrow' | 'json'} [query.type] The query type.
-     * @param {string} query.sql A SQL query string.
-     * @returns the query result
-     */
-    query: (query: {
-        type?: "exec" | "arrow" | "json";
-        sql: string;
-    }) => Promise<import("@uwdata/flechette").Table | Record<string, any>[]>;
+/**
+ * @typedef {object} DuckDBWASMOptions
+ * @property {boolean} [log] Flag to enable logging.
+ */
+/**
+ * @typedef {object} DuckDBWASMConnectorOptions
+ * @property {boolean} [log] Flag to enable logging.
+ * @property {ExtractionOptions} [ipc]
+ *  Arrow IPC extraction options.
+ * @property {duckdb.AsyncDuckDB} [duckdb]
+ *  Optional pre-existing DuckDB-WASM instance.
+ * @property {duckdb.AsyncDuckDBConnection} [connection]
+ *  Optional pre-existing DuckDB-WASM connection.
+ */
+/**
+ * Connect to a DuckDB-WASM instance.
+ * @param {DuckDBWASMConnectorOptions} [options] Connector options.
+ * @returns {DuckDBWASMConnector} A connector instance.
+ */
+export function wasmConnector(options?: DuckDBWASMConnectorOptions): DuckDBWASMConnector;
+/**
+ * DuckDB-WASM connector.
+ * @implements {Connector}
+ */
+export class DuckDBWASMConnector implements Connector {
+    /**
+     * Create a new DuckDB-WASM connector instance.
+     * @param {DuckDBWASMConnectorOptions} [options]
+     */
+    constructor(options?: DuckDBWASMConnectorOptions);
+    /** @type {ExtractionOptions} */
+    _ipc: ExtractionOptions;
+    /** @type {DuckDBWASMOptions} */
+    _options: DuckDBWASMOptions;
+    /** @type {duckdb.AsyncDuckDB} */
+    _db: duckdb.AsyncDuckDB;
+    /** @type {duckdb.AsyncDuckDBConnection} */
+    _con: duckdb.AsyncDuckDBConnection;
+    /** @type {Promise<unknown>} */
+    _loadPromise: Promise<unknown>;
+    /**
+     * Get the backing DuckDB-WASM instance.
+     * Lazily initializes DuckDB-WASM if not already loaded.
+     * @returns {Promise<duckdb.AsyncDuckDB>} The DuckDB-WASM instance.
+     */
+    getDuckDB(): Promise<duckdb.AsyncDuckDB>;
+    /**
+     * Get the backing DuckDB-WASM connection.
+     * Lazily initializes DuckDB-WASM if not already loaded.
+     * @returns {Promise<duckdb.AsyncDuckDBConnection>} The DuckDB-WASM connection.
+     */
+    getConnection(): Promise<duckdb.AsyncDuckDBConnection>;
+    /**
+     * @overload
+     * @param {ArrowQueryRequest} query
+     * @returns {Promise<Table>}
+     *
+     * @overload
+     * @param {ExecQueryRequest} query
+     * @returns {Promise<void>}
+     *
+     * @overload
+     * @param {JSONQueryRequest} query
+     * @returns {Promise<Record<string, any>[]>}
+     *
+     * @param {ArrowQueryRequest | ExecQueryRequest | JSONQueryRequest} query
+     * @returns {Promise<Table | void | Record<string, any>[]>}}
+     */
+    query(query: ArrowQueryRequest): Promise<Table>;
+    /**
+     * @overload
+     * @param {ArrowQueryRequest} query
+     * @returns {Promise<Table>}
+     *
+     * @overload
+     * @param {ExecQueryRequest} query
+     * @returns {Promise<void>}
+     *
+     * @overload
+     * @param {JSONQueryRequest} query
+     * @returns {Promise<Record<string, any>[]>}
+     *
+     * @param {ArrowQueryRequest | ExecQueryRequest | JSONQueryRequest} query
+     * @returns {Promise<Table | void | Record<string, any>[]>}}
+     */
+    query(query: ExecQueryRequest): Promise<void>;
+    /**
+     * @overload
+     * @param {ArrowQueryRequest} query
+     * @returns {Promise<Table>}
+     *
+     * @overload
+     * @param {ExecQueryRequest} query
+     * @returns {Promise<void>}
+     *
+     * @overload
+     * @param {JSONQueryRequest} query
+     * @returns {Promise<Record<string, any>[]>}
+     *
+     * @param {ArrowQueryRequest | ExecQueryRequest | JSONQueryRequest} query
+     * @returns {Promise<Table | void | Record<string, any>[]>}}
+     */
+    query(query: JSONQueryRequest): Promise<Record<string, any>[]>;
+}
+export type DuckDBWASMOptions = {
+    /**
+     * Flag to enable logging.
+     */
+    log?: boolean;
+};
+export type DuckDBWASMConnectorOptions = {
+    /**
+     * Flag to enable logging.
+     */
+    log?: boolean;
+    /**
+     * Arrow IPC extraction options.
+     */
+    ipc?: ExtractionOptions;
+    /**
+     * Optional pre-existing DuckDB-WASM instance.
+     */
+    duckdb?: duckdb.AsyncDuckDB;
+    /**
+     * Optional pre-existing DuckDB-WASM connection.
+     */
+    connection?: duckdb.AsyncDuckDBConnection;
 };
+import type { Connector } from './Connector.js';
+import type { ExtractionOptions } from '@uwdata/flechette';
 import * as duckdb from '@duckdb/duckdb-wasm';
+import type { ArrowQueryRequest } from './Connector.js';
+import type { Table } from '@uwdata/flechette';
+import type { ExecQueryRequest } from './Connector.js';
+import type { JSONQueryRequest } from './Connector.js';

package/dist/types/index-types.d.ts

@@ -1,3 +1,4 @@
 export * from './index.js';
 export * from './types.js';
+export * from './connectors/Connector.js';
 export * from './util/selection-types.js';

package/dist/types/make-client.d.ts

@@ -1,48 +1,78 @@
 /**
  * @typedef {Object} MakeClientOptions
- * @property {import('./Coordinator.js').Coordinator} [coordinator] - Mosaic coordinator. Default to the global coordinator.
- * @property {import('./Selection.js').Selection|null} [selection] - A selection whose predicates will be fed into the query function to produce the SQL query.
- * @property {function(): Promise<void>} [prepare] - An async function to prepare the client before running queries.
- * @property {function(any): any} query - A function that returns a query from a list of selection predicates.
- * @property {function(any): void} [queryResult] - Called by the coordinator to return a query result.
- * @property {function(): void} [queryPending] - Called by the coordinator to report a query execution error.
- * @property {function(any): void} [queryError] - Called by the coordinator to inform the client that a query is pending.
+ * @property {Coordinator} [coordinator] Mosaic coordinator.
+ *  Defaults to the global coordinator.
+ * @property {Selection|null} [selection] A selection whose predicates are
+ *  fed into the query function to produce the SQL query.
+ * @property {boolean} [enabled] A flag (default `true`) indicating if the
+ *  client should initially be enabled or not.
+ * @property {boolean} [filterStable] A flag (default `true`) indicating if the
+ *  if client queries can be sped up using pre-aggregated data. Should be set
+ *  to `false` if filtering changes the groupby domain of the query.
+ * @property {function(): Promise<void>} [prepare]
+ *  An async function to prepare the client before running queries.
+ * @property {function(any): any} [query]
+ *  A function that returns a query from a list of selection predicates.
+ * @property {function(any): void} [queryResult]
+ *  Called by the coordinator to return a query result.
+ * @property {function(): void} [queryPending]
+ *  Called by the coordinator to report a query execution error.
+ * @property {function(any): void} [queryError]
+ *  Called by the coordinator to inform the client that a query is pending.
  */
-/** Make a new client with the given options, and connect the client to the provided coordinator.
- * @param {MakeClientOptions} options - The options for making the client
- * @returns {MosaicClient & { destroy: () => void }} - The result object with methods to request an update or destroy the client.
+/**
+ * Make a new client with the given options, and connect the client to the
+ * provided coordinator.
+ * @param {MakeClientOptions} options The options for making the client.
+ * @returns {MosaicClient & { destroy: () => void }} The resulting client,
+ *  along with a method to destroy the client when no longer needed.
  */
 export function makeClient(options: MakeClientOptions): MosaicClient & {
     destroy: () => void;
 };
 export type MakeClientOptions = {
     /**
-     * - Mosaic coordinator. Default to the global coordinator.
+     * Mosaic coordinator.
+     * Defaults to the global coordinator.
+     */
+    coordinator?: Coordinator;
+    /**
+     * A selection whose predicates are
+     * fed into the query function to produce the SQL query.
+     */
+    selection?: Selection | null;
+    /**
+     * A flag (default `true`) indicating if the
+     * client should initially be enabled or not.
      */
-    coordinator?: import("./Coordinator.js").Coordinator;
+    enabled?: boolean;
     /**
-     * - A selection whose predicates will be fed into the query function to produce the SQL query.
+     * A flag (default `true`) indicating if the
+     * if client queries can be sped up using pre-aggregated data. Should be set
+     * to `false` if filtering changes the groupby domain of the query.
      */
-    selection?: import("./Selection.js").Selection | null;
+    filterStable?: boolean;
     /**
-     * - An async function to prepare the client before running queries.
+     * An async function to prepare the client before running queries.
      */
     prepare?: () => Promise<void>;
     /**
-     * - A function that returns a query from a list of selection predicates.
+     * A function that returns a query from a list of selection predicates.
      */
-    query: (arg0: any) => any;
+    query?: (arg0: any) => any;
     /**
-     * - Called by the coordinator to return a query result.
+     * Called by the coordinator to return a query result.
      */
     queryResult?: (arg0: any) => void;
     /**
-     * - Called by the coordinator to report a query execution error.
+     * Called by the coordinator to report a query execution error.
      */
     queryPending?: () => void;
     /**
-     * - Called by the coordinator to inform the client that a query is pending.
+     * Called by the coordinator to inform the client that a query is pending.
      */
     queryError?: (arg0: any) => void;
 };
-import { MosaicClient } from "./MosaicClient.js";
+import { MosaicClient } from './MosaicClient.js';
+import type { Coordinator } from './Coordinator.js';
+import type { Selection } from './Selection.js';

package/dist/types/preagg/PreAggregator.d.ts

@@ -27,17 +27,17 @@
 export class PreAggregator {
     /**
      * Create a new manager of materialized views of pre-aggregated data.
-     * @param {import('../Coordinator.js').Coordinator} coordinator A Mosaic coordinator.
+     * @param {Coordinator} coordinator A Mosaic coordinator.
      * @param {PreAggregateOptions} [options] Pre-aggregation options.
      */
-    constructor(coordinator: import("../Coordinator.js").Coordinator, { schema, enabled }?: PreAggregateOptions);
-    /** @type {Map<import('../MosaicClient.js').MosaicClient, PreAggregateInfo | Skip | null>} */
-    entries: Map<import("../MosaicClient.js").MosaicClient, PreAggregateInfo | {
+    constructor(coordinator: Coordinator, { schema, enabled }?: PreAggregateOptions);
+    /** @type {Map<MosaicClient, PreAggregateInfo | Skip | null>} */
+    entries: Map<MosaicClient, PreAggregateInfo | {
         skip: boolean;
         result: any;
     } | null>;
     active: any;
-    mc: import("../Coordinator.js").Coordinator;
+    mc: Coordinator;
     _schema: string;
     _enabled: boolean;
     /**
@@ -88,16 +88,14 @@ export class PreAggregator {
      * client-selection pair, or null if the client has unstable filters.
      * This method has multiple possible side effects, including materialized
      * view creation and updating internal caches.
-     * @param {import('../MosaicClient.js').MosaicClient} client A Mosaic client.
-     * @param {import('../Selection.js').Selection} selection A Mosaic selection
-     *  to filter the client by.
-     * @param {import('../util/selection-types.js').SelectionClause} activeClause
-     *  A representative active selection clause for which to (possibly) generate
-     *  materialized views of pre-aggregates.
+     * @param {MosaicClient} client A Mosaic client.
+     * @param {Selection} selection A Mosaic selection to filter the client by.
+     * @param {SelectionClause} activeClause A representative active selection
+     *  clause for which to generate materialized views of pre-aggregates.
      * @returns {PreAggregateInfo | Skip | null} Information and query generator
      * for pre-aggregated tables, or null if the client has unstable filters.
      */
-    request(client: import("../MosaicClient.js").MosaicClient, selection: import("../Selection.js").Selection, activeClause: import("../util/selection-types.js").SelectionClause): PreAggregateInfo | {
+    request(client: MosaicClient, selection: Selection, activeClause: SelectionClause): PreAggregateInfo | {
         skip: boolean;
         result: any;
     } | null;
@@ -157,11 +155,10 @@ export class PreAggregateInfo {
     skip: boolean;
     /**
      * Generate a materialized view query for the given predicate.
-     * @param {import('@uwdata/mosaic-sql').ExprNode} predicate The current
-     *  active clause predicate.
+     * @param {ExprNode} predicate The current active clause predicate.
      * @returns {SelectQuery} A materialized view query.
      */
-    query(predicate: import("@uwdata/mosaic-sql").ExprNode): SelectQuery;
+    query(predicate: ExprNode): SelectQuery;
 }
 export type PreAggregateOptions = {
     /**
@@ -175,4 +172,9 @@ export type PreAggregateOptions = {
      */
     enabled?: boolean;
 };
-import { SelectQuery } from '@uwdata/mosaic-sql';
+import type { MosaicClient } from '../MosaicClient.js';
+import type { Coordinator } from '../Coordinator.js';
+import type { Selection } from '../Selection.js';
+import type { SelectionClause } from '../util/selection-types.js';
+import type { SelectQuery } from '@uwdata/mosaic-sql';
+import type { ExprNode } from '@uwdata/mosaic-sql';

package/dist/types/preagg/preagg-columns.d.ts

@@ -10,5 +10,5 @@ export function preaggColumns(client: MosaicClient): {
     preagg: Record<string, ExprNode>;
     output: Record<string, ExprNode>;
 };
-import { MosaicClient } from '../MosaicClient.js';
-import { ExprNode } from '@uwdata/mosaic-sql';
+import type { MosaicClient } from '../MosaicClient.js';
+import type { ExprNode } from '@uwdata/mosaic-sql';

package/dist/types/preagg/sufficient-statistics.d.ts

@@ -9,5 +9,5 @@
  *  sufficient statistics to service updates.
  */
 export function sufficientStatistics(node: AggregateNode, preagg: Record<string, ExprNode>, avg: any): ExprNode;
-import { AggregateNode } from '@uwdata/mosaic-sql';
-import { ExprNode } from '@uwdata/mosaic-sql';
+import type { AggregateNode } from '@uwdata/mosaic-sql';
+import type { ExprNode } from '@uwdata/mosaic-sql';

package/dist/types/types.d.ts

@@ -40,3 +40,24 @@ export interface Activatable {
      */
     activate(): void;
 }
+/**
+ * Interface for cache implementations.
+ */
+export interface Cache {
+    get(key: string): any;
+    set(key: string, value: any): any;
+    clear(): void;
+}
+/**
+ * Interface for logger implementations
+ */
+export interface Logger {
+    debug(...args: any[]): void;
+    info(...args: any[]): void;
+    log(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    group(label?: any): void;
+    groupCollapsed(label?: any): void;
+    groupEnd(): void;
+}

package/dist/types/util/cache.d.ts

@@ -1,13 +1,17 @@
+/**
+ * Create a new cache that ignores all values.
+ * @returns {Cache}
+ */
+export function voidCache(): Cache;
+/**
+ * Create a new cache that uses an LRU eviction policy.
+ * @param {object} [options] Cache options.
+ * @param {number} [options.max] Maximum number of cache entries.
+ * @param {number} [options.ttl] Time-to-live for cache entries.
+ * @returns {Cache}
+ */
 export function lruCache({ max, ttl }?: {
     max?: number;
     ttl?: number;
-}): {
-    get(key: any): any;
-    set(key: any, value: any): any;
-    clear(): void;
-};
-export function voidCache(): {
-    get: () => any;
-    set: (key: any, value: any) => any;
-    clear: () => void;
-};
+}): Cache;
+import type { Cache } from '../types.js';

package/dist/types/util/decode-ipc.d.ts

@@ -1,7 +1,12 @@
 /**
- * Decode Arrow IPC bytes to a table instance, with an option to map date and
- * timestamp values to JS Date objects.
+ * Decode Arrow IPC bytes to a table instance.
+ * The default options map date and timestamp values to JS Date objects.
  * @param {ArrayBuffer | Uint8Array} data Arrow IPC bytes.
- * @returns {import('@uwdata/flechette').Table} A table instance.
+ * @param {ExtractionOptions} [options] Arrow IPC extraction options.
+ *  If unspecified, the default options will extract date and timestamp
+ *  values to JS Date objects.
+ * @returns {Table} A table instance.
  */
-export function decodeIPC(data: ArrayBuffer | Uint8Array): import("@uwdata/flechette").Table;
+export function decodeIPC(data: ArrayBuffer | Uint8Array, options?: ExtractionOptions): Table;
+import type { ExtractionOptions } from '@uwdata/flechette';
+import type { Table } from '@uwdata/flechette';

package/dist/types/util/void-logger.d.ts

@@ -4,4 +4,7 @@ export function voidLogger(): {
     log(..._: any[]): void;
     warn(..._: any[]): void;
     error(..._: any[]): void;
+    group(label: any): void;
+    groupCollapsed(label: any): void;
+    groupEnd(): void;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uwdata/mosaic-core",
-  "version": "0.14.1",
+  "version": "0.16.1",
   "description": "Scalable and extensible linked data views.",
   "keywords": [
     "mosaic",
@@ -32,10 +32,10 @@
   "dependencies": {
     "@duckdb/duckdb-wasm": "^1.29.0",
     "@uwdata/flechette": "^2.0.0",
-    "@uwdata/mosaic-sql": "^0.14.1"
+    "@uwdata/mosaic-sql": "^0.16.1"
   },
   "devDependencies": {
-    "@uwdata/mosaic-duckdb": "^0.14.1"
+    "@uwdata/mosaic-duckdb": "^0.16.1"
   },
-  "gitHead": "5959cb169e95bd8467e1e5d7a9b98954f09474f3"
+  "gitHead": "e12af9927b0a35a0e3194850ef569d0d24a022ce"
 }

package/src/Coordinator.js

@@ -1,9 +1,13 @@
+/** @import { Connector } from './connectors/Connector.js' */
+/** @import { PreAggregateOptions } from './preagg/PreAggregator.js' */
+/** @import { QueryResult } from './util/query-result.js' */
+/** @import { SelectionClause } from './util/selection-types.js' */
+/** @import { MosaicClient } from './MosaicClient.js' */
+/** @import { Selection } from './Selection.js' */
+/** @import { Logger, QueryType } from './types.js' */
 import { socketConnector } from './connectors/socket.js';
 import { PreAggregator } from './preagg/PreAggregator.js';
-import { queryFieldInfo } from './util/field-info.js';
-import { QueryResult } from './util/query-result.js';
 import { voidLogger } from './util/void-logger.js';
-import { MosaicClient } from './MosaicClient.js';
 import { QueryManager, Priority } from './QueryManager.js';
 
 /**
@@ -30,16 +34,17 @@ export function coordinator(instance) {
  * A Mosaic Coordinator manages all database communication for clients and
  * handles selection updates. The Coordinator also performs optimizations
  * including query caching, consolidation, and pre-aggregation.
- * @param {*} [db] Database connector. Defaults to a web socket connection.
- * @param {object} [options] Coordinator options.
- * @param {*} [options.logger=console] The logger to use, defaults to `console`.
- * @param {*} [options.manager] The query manager to use.
- * @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 {import('./preagg/PreAggregator.js').PreAggregateOptions} [options.preagg]
- *  Options for the Pre-aggregator.
  */
 export class Coordinator {
+  /**
+   * @param {Connector} [db] Database connector. Defaults to a web socket connection.
+   * @param {object} [options] Coordinator options.
+   * @param {Logger} [options.logger=console] The logger to use, defaults to `console`.
+   * @param {QueryManager} [options.manager] The query manager to use.
+   * @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 {PreAggregateOptions} [options.preagg] Options for the Pre-aggregator.
+   */
   constructor(db = socketConnector(), {
     logger = console,
     manager = new QueryManager(),
@@ -76,8 +81,8 @@ export class Coordinator {
 
   /**
    * Get or set the database connector.
-   * @param {*} [db] The database connector to use.
-   * @returns The current database connector.
+   * @param {Connector} [db] The database connector to use.
+   * @returns {Connector} The current database connector.
    */
   databaseConnector(db) {
     return this.manager.connector(db);
@@ -85,8 +90,8 @@ export class Coordinator {
 
   /**
    * Get or set the logger.
-   * @param {*} logger  The logger to use.
-   * @returns The current logger
+   * @param {Logger} [logger] The logger to use.
+   * @returns {Logger} The current logger
    */
   logger(logger) {
     if (arguments.length) {
@@ -110,8 +115,7 @@ export class Coordinator {
 
   /**
    * Issue a query for which no result (return value) is needed.
-   * @param { import('./types.js').QueryType[] |
-   *  import('./types.js').QueryType} query The query or an array of queries.
+   * @param {QueryType[] | QueryType} query The query or an array of queries.
    *  Each query should be either a Query builder object or a SQL string.
    * @param {object} [options] An options object.
    * @param {number} [options.priority] The query priority, defaults to
@@ -126,8 +130,8 @@ export class Coordinator {
   /**
    * Issue a query to the backing database. The submitted query may be
    * consolidate with other queries and its results may be cached.
-   * @param {import('./types.js').QueryType} query The query as either a Query
-   *  builder object or a SQL string.
+   * @param {QueryType} query The query as either a Query builder objec
+   *   or a SQL string.
    * @param {object} [options] An options object.
    * @param {'arrow' | 'json'} [options.type] The query result format type.
    * @param {boolean} [options.cache=true] If true, cache the query result
@@ -150,8 +154,8 @@ export class Coordinator {
   /**
    * Issue a query to prefetch data for later use. The query result is cached
    * for efficient future access.
-   * @param {import('./types.js').QueryType} query The query as either a Query
-   *  builder object or a SQL string.
+   * @param {QueryType} query The query as either a Query builder object
+   *  or a SQL string.
    * @param {object} [options] An options object.
    * @param {'arrow' | 'json'} [options.type] The query result format type.
    * @returns {QueryResult} A query result promise.
@@ -190,7 +194,7 @@ export class Coordinator {
    * Update client data by submitting the given query and returning the
    * data (or error) to the client.
    * @param {MosaicClient} client A Mosaic client.
-   * @param {import('./types.js').QueryType} query The data query.
+   * @param {QueryType} query The data query.
    * @param {number} [priority] The query priority.
    * @returns {Promise} A Promise that resolves upon completion of the update.
    */
@@ -209,7 +213,7 @@ export class Coordinator {
    * the client is simply updated. Otherwise `updateClient` is called. As a
    * side effect, this method clears the current preaggregator state.
    * @param {MosaicClient} client The client to update.
-   * @param {import('./types.js').QueryType | null} [query] The query to issue.
+   * @param {QueryType | null} [query] The query to issue.
    */
   requestQuery(client, query) {
     this.preaggregator.clear();
@@ -236,26 +240,12 @@ export class Coordinator {
     client.coordinator = this;
 
     // initialize client lifecycle
-    client._pending = this.initializeClient(client);
+    client.initialize();
 
     // connect filter selection
     connectSelection(this, client.filterBy, client);
   }
 
-  async initializeClient(client) {
-    // retrieve field statistics
-    const fields = client.fields();
-    if (fields?.length) {
-      client.fieldInfo(await queryFieldInfo(this, fields));
-    }
-
-    // prepare the client
-    await client.prepare();
-
-    // request data query
-    return client.requestQuery();
-  }
-
   /**
    * Disconnect a client from the coordinator.
    * @param {MosaicClient} client The Mosaic client to disconnect.
@@ -276,7 +266,7 @@ export class Coordinator {
 /**
  * Connect a selection-client pair to the coordinator to process updates.
  * @param {Coordinator} mc The Mosaic coordinator.
- * @param {import('./Selection.js').Selection} selection A selection.
+ * @param {Selection} selection A selection.
  * @param {MosaicClient} client A Mosiac client that is filtered by the
  *  given selection.
  */
@@ -308,15 +298,16 @@ function connectSelection(mc, selection, client) {
  * next updates. Activation provides a preview of likely next events,
  * enabling potential precomputation to optimize updates.
  * @param {Coordinator} mc The Mosaic coordinator.
- * @param {import('./Selection.js').Selection} selection A selection.
- * @param {import('./util/selection-types.js').SelectionClause} clause A
- *  selection clause representative of the activation.
+ * @param {Selection} selection A selection.
+ * @param {SelectionClause} clause A selection clause for the activation.
  */
 function activateSelection(mc, selection, clause) {
   const { preaggregator, filterGroups } = mc;
   const { clients } = filterGroups.get(selection);
   for (const client of clients) {
-    preaggregator.request(client, selection, clause);
+    if (client.enabled) {
+      preaggregator.request(client, selection, clause);
+    }
   }
 }
 
@@ -324,7 +315,7 @@ function activateSelection(mc, selection, clause) {
  * Process an updated selection value, querying filtered data for any
  * associated clients.
  * @param {Coordinator} mc The Mosaic coordinator.
- * @param {import('./Selection.js').Selection} selection A selection.
+ * @param {Selection} selection A selection.
  * @returns {Promise} A Promise that resolves when the update completes.
  */
 function updateSelection(mc, selection) {
@@ -332,6 +323,7 @@ function updateSelection(mc, selection) {
   const { clients } = filterGroups.get(selection);
   const { active } = selection;
   return Promise.allSettled(Array.from(clients, client => {
+    if (!client.enabled) return client.requestQuery();
     const info = preaggregator.request(client, selection, active);
     const filter = info ? null : selection.predicate(client);