@kanzo-tech/mosaic 0.1.0

package/README.md

@@ -0,0 +1,42 @@
+# @kanzo-tech/mosaic
+
+The Mosaic conversation, without React.
+
+```bash
+npm install @kanzo-tech/mosaic @uwdata/mosaic-core @uwdata/mosaic-sql
+```
+
+`mosaic-core` and `mosaic-sql` are **required** peers, not optional ones. There is nothing here
+without them — that is what this package is. Installing them once is also the point: two copies of
+Mosaic are two coordinators, and two coordinators are two crossfilters that never hear each other.
+
+## What it holds
+
+```ts
+import { Coordinator, Selection, MosaicClient, clausePoints } from "@kanzo-tech/mosaic";
+import { column, fillColumn, numbers, IdSetClient } from "@kanzo-tech/mosaic";
+```
+
+- **Re-exports** of the coordinator, the clients, the five clause builders, the loaders and the
+  connector — so a consumer boots a coordinator without a direct `@uwdata` import.
+- **`column` / `fillColumn` / `numbers`** — the half of the client protocol the protocol does not
+  give you. The coordinator answers with an Arrow table, and Arrow offers a typed column only when
+  the type allows one: an integer id gives an array, a dictionary-encoded label gives nothing
+  usable. Every call site was writing `as { getChild(name: string): … }`, which asserts Arrow's
+  shape rather than checking it, and is wrong on the first query that selects a string.
+- **`IdSetClient`** — the crossfilter adapter for a view whose positions are not in the database.
+  A GPU canvas or a map cannot publish `weight BETWEEN …`; there is no column to write the
+  predicate over. It can only enumerate what was hit.
+
+## Why it is not part of `@kanzo-tech/ui`
+
+It was, and the cost landed somewhere else. `@kanzo-tech/graph/duckdb` reached its coordinator
+through `@kanzo-tech/ui/analytics`, whose barrel re-exports the React charts first — and calls
+`@uwdata/vgplot` doing it. The import is static, so a host that installed the two peers the docs
+asked for still could not open that subpath: vgplot came along, unasked and unused.
+
+Reading a column out of an answer and publishing a clause are not user-interface concerns. They
+lived in a component library only because that is where the first chart needed them.
+
+The charts did not move. [`@kanzo-tech/ui/analytics`](https://kanzo-tech.github.io/ui) exports
+every name it exported before, these among them.

package/dist/arrow.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Reading one column out of whatever a Mosaic query handed back.
+ *
+ * The coordinator answers with an Arrow table, and Arrow only offers a typed column when the type
+ * allows one: `getChild` gives an array for an integer column and nothing usable for a
+ * dictionary-encoded string. Both shapes come back from ordinary queries — an `id` is the first, a
+ * `label` is the second — so a `queryResult` that assumes the typed path is a crash waiting for the
+ * first query that selects a string.
+ *
+ * This is the half of the client protocol the protocol itself does not give you. Declaring a query
+ * and publishing a clause is documented and small; turning the answer into values is where every
+ * call site independently writes `as { getChild(name: string): … }`, which is a cast asserting the
+ * shape rather than checking it.
+ */
+/** Every value in `field`, in row order. */
+export declare function column(data: unknown, field: string): unknown[];
+/** The same, coerced — Arrow hands back `BigInt` for some integer widths. */
+export declare function numbers(data: unknown, field: string): number[];
+/** A pre-sized destination `fillColumn` can write into. */
+export type NumericArray = Float32Array | Float64Array | Uint32Array | Uint16Array | Int32Array;
+/**
+ * One numeric column, written straight into a typed array the caller already owns.
+ *
+ * `numbers()` is the wrong tool once a result is large: `toArray()` already hands back a typed
+ * buffer, and `Array.from(...).map(Number)` turns it into two full-length boxed `number[]` on the
+ * way to a third array that was the actual destination. Three allocations to move nothing. This is
+ * the same pass with none of them — which is what lets a caller size once against its own limit and
+ * fill from the Arrow batches as they arrive.
+ *
+ * `stride` and `offset` are how interleaving is expressed: `x` at `(0, 2)` and `y` at `(1, 2)` fill
+ * one `[x0, y0, x1, y1, …]` buffer with no seam between them.
+ *
+ * Returns how many rows were written, which is `min(rows, capacity)` — a caller that sized against
+ * a `LIMIT` uses it to `subarray` down to what actually came back.
+ */
+export declare function fillColumn(data: unknown, field: string, into: NumericArray, offset?: number, stride?: number): number;
+//# sourceMappingURL=arrow.d.ts.map

package/dist/arrow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrow.d.ts","sourceRoot":"","sources":["../src/arrow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAMH,4CAA4C;AAC5C,wBAAgB,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,EAAE,CAI9D;AAED,6EAA6E;AAC7E,wBAAgB,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAE9D;AAED,2DAA2D;AAC3D,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG,YAAY,GAAG,WAAW,GAAG,WAAW,GAAG,UAAU,CAAC;AAEhG;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,OAAO,EACb,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,YAAY,EAClB,MAAM,SAAI,EACV,MAAM,SAAI,GACT,MAAM,CAiBR"}

package/dist/arrow.js

@@ -0,0 +1,29 @@
+function b(r, n) {
+  var u;
+  const o = (u = r.getChild) == null ? void 0 : u.call(r, n);
+  return o ? Array.from(o.toArray()) : Array.from(r, (c) => c[n]);
+}
+function y(r, n) {
+  return b(r, n).map(Number);
+}
+function g(r, n, o, u = 0, c = 1) {
+  var h, f;
+  const i = Math.max(0, Math.ceil((o.length - u) / c)), t = (f = (h = r.getChild) == null ? void 0 : h.call(r, n)) == null ? void 0 : f.toArray();
+  if (t) {
+    const l = Math.min(t.length, i);
+    for (let m = 0; m < l; m++) o[u + m * c] = Number(t[m]);
+    return l;
+  }
+  let e = 0;
+  for (const l of r) {
+    if (e >= i) break;
+    o[u + e * c] = Number(l[n]), e++;
+  }
+  return e;
+}
+export {
+  b as column,
+  g as fillColumn,
+  y as numbers
+};
+//# sourceMappingURL=arrow.js.map

package/dist/arrow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrow.js","sources":["../src/arrow.ts"],"sourcesContent":["/**\n * Reading one column out of whatever a Mosaic query handed back.\n *\n * The coordinator answers with an Arrow table, and Arrow only offers a typed column when the type\n * allows one: `getChild` gives an array for an integer column and nothing usable for a\n * dictionary-encoded string. Both shapes come back from ordinary queries — an `id` is the first, a\n * `label` is the second — so a `queryResult` that assumes the typed path is a crash waiting for the\n * first query that selects a string.\n *\n * This is the half of the client protocol the protocol itself does not give you. Declaring a query\n * and publishing a clause is documented and small; turning the answer into values is where every\n * call site independently writes `as { getChild(name: string): … }`, which is a cast asserting the\n * shape rather than checking it.\n */\n\ninterface ArrowLike {\n  getChild?: (name: string) => { toArray(): ArrayLike<unknown> } | null;\n}\n\n/** Every value in `field`, in row order. */\nexport function column(data: unknown, field: string): unknown[] {\n  const child = (data as ArrowLike).getChild?.(field);\n  if (child) return Array.from(child.toArray());\n  return Array.from(data as Iterable<Record<string, unknown>>, (row) => row[field]);\n}\n\n/** The same, coerced — Arrow hands back `BigInt` for some integer widths. */\nexport function numbers(data: unknown, field: string): number[] {\n  return column(data, field).map(Number);\n}\n\n/** A pre-sized destination `fillColumn` can write into. */\nexport type NumericArray = Float32Array | Float64Array | Uint32Array | Uint16Array | Int32Array;\n\n/**\n * One numeric column, written straight into a typed array the caller already owns.\n *\n * `numbers()` is the wrong tool once a result is large: `toArray()` already hands back a typed\n * buffer, and `Array.from(...).map(Number)` turns it into two full-length boxed `number[]` on the\n * way to a third array that was the actual destination. Three allocations to move nothing. This is\n * the same pass with none of them — which is what lets a caller size once against its own limit and\n * fill from the Arrow batches as they arrive.\n *\n * `stride` and `offset` are how interleaving is expressed: `x` at `(0, 2)` and `y` at `(1, 2)` fill\n * one `[x0, y0, x1, y1, …]` buffer with no seam between them.\n *\n * Returns how many rows were written, which is `min(rows, capacity)` — a caller that sized against\n * a `LIMIT` uses it to `subarray` down to what actually came back.\n */\nexport function fillColumn(\n  data: unknown,\n  field: string,\n  into: NumericArray,\n  offset = 0,\n  stride = 1,\n): number {\n  const capacity = Math.max(0, Math.ceil((into.length - offset) / stride));\n  const values = (data as ArrowLike).getChild?.(field)?.toArray();\n  if (values) {\n    const n = Math.min(values.length, capacity);\n    // `Number` is identity on the numeric widths and the conversion on the BigInt ones; either way\n    // it reads an element rather than allocating one.\n    for (let i = 0; i < n; i++) into[offset + i * stride] = Number(values[i]);\n    return n;\n  }\n  let i = 0;\n  for (const row of data as Iterable<Record<string, unknown>>) {\n    if (i >= capacity) break;\n    into[offset + i * stride] = Number(row[field]);\n    i++;\n  }\n  return i;\n}\n"],"names":["column","data","field","_a","child","row","numbers","fillColumn","into","offset","stride","_b","capacity","values","n","i"],"mappings":"AAoBO,SAASA,EAAOC,GAAeC,GAA0B;AAAzD,MAAAC;AACL,QAAMC,KAASD,IAAAF,EAAmB,aAAnB,gBAAAE,EAAA,KAAAF,GAA8BC;AAC7C,SAAIE,IAAc,MAAM,KAAKA,EAAM,SAAS,IACrC,MAAM,KAAKH,GAA2C,CAACI,MAAQA,EAAIH,CAAK,CAAC;AAClF;AAGO,SAASI,EAAQL,GAAeC,GAAyB;AAC9D,SAAOF,EAAOC,GAAMC,CAAK,EAAE,IAAI,MAAM;AACvC;AAoBO,SAASK,EACdN,GACAC,GACAM,GACAC,IAAS,GACTC,IAAS,GACD;AAnCH,MAAAP,GAAAQ;AAoCL,QAAMC,IAAW,KAAK,IAAI,GAAG,KAAK,MAAMJ,EAAK,SAASC,KAAUC,CAAM,CAAC,GACjEG,KAAUF,KAAAR,IAAAF,EAAmB,aAAnB,gBAAAE,EAAA,KAAAF,GAA8BC,OAA9B,gBAAAS,EAAsC;AACtD,MAAIE,GAAQ;AACV,UAAMC,IAAI,KAAK,IAAID,EAAO,QAAQD,CAAQ;AAG1C,aAASG,IAAI,GAAGA,IAAID,GAAGC,IAAK,CAAAP,EAAKC,IAASM,IAAIL,CAAM,IAAI,OAAOG,EAAOE,CAAC,CAAC;AACxE,WAAOD;AAAA,EACT;AACA,MAAIC,IAAI;AACR,aAAWV,KAAOJ,GAA2C;AAC3D,QAAIc,KAAKH,EAAU;AACnB,IAAAJ,EAAKC,IAASM,IAAIL,CAAM,IAAI,OAAOL,EAAIH,CAAK,CAAC,GAC7Ca;AAAA,EACF;AACA,SAAOA;AACT;"}

package/dist/id-set-client.d.ts

@@ -0,0 +1,42 @@
+import { MosaicClient, Selection } from '@uwdata/mosaic-core';
+import { FilterExpr } from '@uwdata/mosaic-sql';
+/**
+ * The crossfilter adapter for a view whose positions are not in the database.
+ *
+ * A `MosaicClient` asks for two things, and this is both:
+ *
+ *   `query(filter)` — which rows survive the page's filters? The coordinator answers with a column
+ *     of ids, and the view fades everything else. The **observable** half.
+ *   `publish(ids)` — the user selected these. A points clause, `id IN (…)`, which every other chart
+ *     on the page filters by. The **controllable** half.
+ *
+ * The id list is not a shortcut, it is the only thing such a view can say. A Plot brush publishes
+ * `weight BETWEEN …`, an interval in data space, because Plot's `x` IS a column. A GPU simulation's
+ * `x` exists nowhere in the database, so no predicate over columns can describe the loop the user
+ * drew. Enumerating what was hit is the honest translation — and its cost is the length of the `IN`
+ * list, which is the real ceiling on the whole approach.
+ *
+ * Nothing here knows what draws. It is named for what it exchanges rather than for the renderer it
+ * was first written against, because a canvas, a map and an imperative widget all reach the
+ * crossfilter through exactly this shape.
+ */
+export interface IdSetClientOptions {
+    /** The relation. Its `idField` column is what gets published and matched. */
+    table: string;
+    idField: string;
+    /** What the view fades by. */
+    filterBy: Selection;
+    /** Where the selection publishes. */
+    as: Selection;
+    /** The surviving ids, in relation order, on every filter change. */
+    onSurvivors: (ids: readonly unknown[]) => void;
+}
+export declare class IdSetClient extends MosaicClient {
+    #private;
+    constructor(options: IdSetClientOptions);
+    query(filter?: FilterExpr): import('@uwdata/mosaic-sql').SelectQuery;
+    queryResult(data: unknown): this;
+    /** `null` retracts the selection: an empty clause has a null predicate, which the resolver drops. */
+    publish(ids: readonly unknown[] | null): void;
+}
+//# sourceMappingURL=id-set-client.d.ts.map

package/dist/id-set-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"id-set-client.d.ts","sourceRoot":"","sources":["../src/id-set-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAgB,KAAK,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACjF,OAAO,EAAS,KAAK,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAG5D;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,MAAM,WAAW,kBAAkB;IACjC,6EAA6E;IAC7E,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,8BAA8B;IAC9B,QAAQ,EAAE,SAAS,CAAC;IACpB,qCAAqC;IACrC,EAAE,EAAE,SAAS,CAAC;IACd,oEAAoE;IACpE,WAAW,EAAE,CAAC,GAAG,EAAE,SAAS,OAAO,EAAE,KAAK,IAAI,CAAC;CAChD;AAED,qBAAa,WAAY,SAAQ,YAAY;;gBAM/B,OAAO,EAAE,kBAAkB;IAQ9B,KAAK,CAAC,MAAM,GAAE,UAAe;IAI7B,WAAW,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;IAKzC,qGAAqG;IACrG,OAAO,CAAC,GAAG,EAAE,SAAS,OAAO,EAAE,GAAG,IAAI,GAAG,IAAI;CAY9C"}

package/dist/id-set-client.js

@@ -0,0 +1,43 @@
+var o = (t) => {
+  throw TypeError(t);
+};
+var n = (t, r, e) => r.has(t) || o("Cannot " + e);
+var i = (t, r, e) => (n(t, r, "read from private field"), e ? e.call(t) : r.get(t)), l = (t, r, e) => r.has(t) ? o("Cannot add the same private member more than once") : r instanceof WeakSet ? r.add(t) : r.set(t, e), u = (t, r, e, c) => (n(t, r, "write to private field"), c ? c.call(t, e) : r.set(t, e), e);
+import { MosaicClient as d, clausePoints as f } from "@uwdata/mosaic-core";
+import { Query as p } from "@uwdata/mosaic-sql";
+import { column as y } from "./arrow.js";
+var h, s, m, a;
+class w extends d {
+  constructor(e) {
+    super(e.filterBy);
+    l(this, h);
+    l(this, s);
+    l(this, m);
+    l(this, a);
+    u(this, h, e.table), u(this, s, e.idField), u(this, m, e.as), u(this, a, e.onSurvivors);
+  }
+  query(e = []) {
+    return p.from(i(this, h)).select({ id: i(this, s) }).where(e);
+  }
+  queryResult(e) {
+    return i(this, a).call(this, y(e, "id")), this;
+  }
+  /** `null` retracts the selection: an empty clause has a null predicate, which the resolver drops. */
+  publish(e) {
+    i(this, m).update(
+      f([i(this, s)], e == null ? void 0 : e.map((c) => [c]), {
+        source: this,
+        // A crossfilter normally exempts a client from its own clause, so a brush can be widened
+        // after it has collapsed the chart under it. A view that FADES an excluded row instead of
+        // removing it does not need the exemption: the row is still on screen and still
+        // selectable. Declining it is what makes the selection visible — the fade is the brush.
+        clients: /* @__PURE__ */ new Set()
+      })
+    );
+  }
+}
+h = new WeakMap(), s = new WeakMap(), m = new WeakMap(), a = new WeakMap();
+export {
+  w as IdSetClient
+};
+//# sourceMappingURL=id-set-client.js.map

package/dist/id-set-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"id-set-client.js","sources":["../src/id-set-client.ts"],"sourcesContent":["import { MosaicClient, clausePoints, type Selection } from \"@uwdata/mosaic-core\";\nimport { Query, type FilterExpr } from \"@uwdata/mosaic-sql\";\nimport { column } from \"./arrow.js\";\n\n/**\n * The crossfilter adapter for a view whose positions are not in the database.\n *\n * A `MosaicClient` asks for two things, and this is both:\n *\n *   `query(filter)` — which rows survive the page's filters? The coordinator answers with a column\n *     of ids, and the view fades everything else. The **observable** half.\n *   `publish(ids)` — the user selected these. A points clause, `id IN (…)`, which every other chart\n *     on the page filters by. The **controllable** half.\n *\n * The id list is not a shortcut, it is the only thing such a view can say. A Plot brush publishes\n * `weight BETWEEN …`, an interval in data space, because Plot's `x` IS a column. A GPU simulation's\n * `x` exists nowhere in the database, so no predicate over columns can describe the loop the user\n * drew. Enumerating what was hit is the honest translation — and its cost is the length of the `IN`\n * list, which is the real ceiling on the whole approach.\n *\n * Nothing here knows what draws. It is named for what it exchanges rather than for the renderer it\n * was first written against, because a canvas, a map and an imperative widget all reach the\n * crossfilter through exactly this shape.\n */\n\nexport interface IdSetClientOptions {\n  /** The relation. Its `idField` column is what gets published and matched. */\n  table: string;\n  idField: string;\n  /** What the view fades by. */\n  filterBy: Selection;\n  /** Where the selection publishes. */\n  as: Selection;\n  /** The surviving ids, in relation order, on every filter change. */\n  onSurvivors: (ids: readonly unknown[]) => void;\n}\n\nexport class IdSetClient extends MosaicClient {\n  #table: string;\n  #idField: string;\n  #as: Selection;\n  #emit: (ids: readonly unknown[]) => void;\n\n  constructor(options: IdSetClientOptions) {\n    super(options.filterBy);\n    this.#table = options.table;\n    this.#idField = options.idField;\n    this.#as = options.as;\n    this.#emit = options.onSurvivors;\n  }\n\n  override query(filter: FilterExpr = []) {\n    return Query.from(this.#table).select({ id: this.#idField }).where(filter);\n  }\n\n  override queryResult(data: unknown): this {\n    this.#emit(column(data, \"id\"));\n    return this;\n  }\n\n  /** `null` retracts the selection: an empty clause has a null predicate, which the resolver drops. */\n  publish(ids: readonly unknown[] | null): void {\n    this.#as.update(\n      clausePoints([this.#idField], ids?.map((id) => [id]), {\n        source: this,\n        // A crossfilter normally exempts a client from its own clause, so a brush can be widened\n        // after it has collapsed the chart under it. A view that FADES an excluded row instead of\n        // removing it does not need the exemption: the row is still on screen and still\n        // selectable. Declining it is what makes the selection visible — the fade is the brush.\n        clients: new Set<MosaicClient>(),\n      }),\n    );\n  }\n}\n"],"names":["IdSetClient","MosaicClient","options","__privateAdd","_table","_idField","_as","_emit","__privateSet","filter","Query","__privateGet","data","column","ids","clausePoints","id"],"mappings":";;;;;;;;;AAqCO,MAAMA,UAAoBC,EAAa;AAAA,EAM5C,YAAYC,GAA6B;AACvC,UAAMA,EAAQ,QAAQ;AANxB,IAAAC,EAAA,MAAAC;AACA,IAAAD,EAAA,MAAAE;AACA,IAAAF,EAAA,MAAAG;AACA,IAAAH,EAAA,MAAAI;AAIE,IAAAC,EAAA,MAAKJ,GAASF,EAAQ,QACtBM,EAAA,MAAKH,GAAWH,EAAQ,UACxBM,EAAA,MAAKF,GAAMJ,EAAQ,KACnBM,EAAA,MAAKD,GAAQL,EAAQ;AAAA,EACvB;AAAA,EAES,MAAMO,IAAqB,IAAI;AACtC,WAAOC,EAAM,KAAKC,EAAA,MAAKP,EAAM,EAAE,OAAO,EAAE,IAAIO,EAAA,MAAKN,GAAA,CAAU,EAAE,MAAMI,CAAM;AAAA,EAC3E;AAAA,EAES,YAAYG,GAAqB;AACxC,WAAAD,EAAA,MAAKJ,GAAL,WAAWM,EAAOD,GAAM,IAAI,IACrB;AAAA,EACT;AAAA;AAAA,EAGA,QAAQE,GAAsC;AAC5C,IAAAH,EAAA,MAAKL,GAAI;AAAA,MACPS,EAAa,CAACJ,EAAA,MAAKN,EAAQ,GAAGS,KAAA,gBAAAA,EAAK,IAAI,CAACE,MAAO,CAACA,CAAE,IAAI;AAAA,QACpD,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA,QAKR,6BAAa,IAAA;AAAA,MAAkB,CAChC;AAAA,IAAA;AAAA,EAEL;AACF;AAnCEZ,IAAA,eACAC,IAAA,eACAC,IAAA,eACAC,IAAA;"}

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The Mosaic conversation, as one import.
+ *
+ * This package exists because of a bug that shipped. `@kanzo-tech/graph/duckdb` reached its
+ * coordinator, clients and clauses through `@kanzo-tech/ui/analytics`, whose barrel re-exports the
+ * React charts first — and `@uwdata/vgplot` with them. The import is static, so a host that
+ * installed the two peers the documentation asked for, `mosaic-core` and `mosaic-sql`, still could
+ * not open the subpath: vgplot came along, unasked and unused. `@kanzo-tech/graph` ended up
+ * declaring vgplot as an optional peer to paper over a dependency it never names.
+ *
+ * The cause was a layer in the wrong package rather than a missing entry in a list. Reading a
+ * column out of an Arrow answer and publishing a points clause are not user-interface concerns;
+ * they were only in a component library because that is where the first chart needed them.
+ *
+ * So: the data half lives here, with no React anywhere in it, and both consumers depend on this
+ * rather than on each other. `@kanzo-tech/ui/analytics` keeps every chart and re-exports these
+ * names unchanged, so nothing on that surface moves.
+ *
+ * The re-exports below are deliberate rather than lazy. A single import site for `Coordinator` and
+ * `Selection` is what makes one copy of Mosaic the easy outcome, and two copies would be two
+ * crossfilters that never hear each other.
+ */
+export { Coordinator, MosaicClient, Selection, makeClient, clausePoint, clausePoints, clauseInterval, clauseIntervals, clauseMatch, wasmConnector, type SelectionClause, } from '@uwdata/mosaic-core';
+export { Query, loadCSV, loadJSON, loadObjects, loadParquet, loadSpatial, loadExtension, type ExprValue, type FilterExpr, } from '@uwdata/mosaic-sql';
+/** Ours: turning an Arrow answer into values, which the client protocol does not do for you. */
+export { column, fillColumn, numbers, type NumericArray } from './arrow.js';
+/** Ours: the crossfilter adapter for a view whose positions are not in the database. */
+export { IdSetClient, type IdSetClientOptions } from './id-set-client.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EACL,WAAW,EACX,YAAY,EACZ,SAAS,EACT,UAAU,EACV,WAAW,EACX,YAAY,EACZ,cAAc,EACd,eAAe,EACf,WAAW,EACX,aAAa,EACb,KAAK,eAAe,GACrB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,KAAK,EACL,OAAO,EACP,QAAQ,EACR,WAAW,EACX,WAAW,EACX,WAAW,EACX,aAAa,EACb,KAAK,SAAS,EACd,KAAK,UAAU,GAChB,MAAM,oBAAoB,CAAC;AAE5B,gGAAgG;AAChG,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAE5E,wFAAwF;AACxF,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -0,0 +1,28 @@
+import { Coordinator as l, MosaicClient as a, Selection as t, clauseInterval as n, clauseIntervals as r, clauseMatch as s, clausePoint as c, clausePoints as i, makeClient as u, wasmConnector as m } from "@uwdata/mosaic-core";
+import { Query as C, loadCSV as f, loadExtension as p, loadJSON as x, loadObjects as S, loadParquet as I, loadSpatial as P } from "@uwdata/mosaic-sql";
+import { column as v, fillColumn as M, numbers as O } from "./arrow.js";
+import { IdSetClient as j } from "./id-set-client.js";
+export {
+  l as Coordinator,
+  j as IdSetClient,
+  a as MosaicClient,
+  C as Query,
+  t as Selection,
+  n as clauseInterval,
+  r as clauseIntervals,
+  s as clauseMatch,
+  c as clausePoint,
+  i as clausePoints,
+  v as column,
+  M as fillColumn,
+  f as loadCSV,
+  p as loadExtension,
+  x as loadJSON,
+  S as loadObjects,
+  I as loadParquet,
+  P as loadSpatial,
+  u as makeClient,
+  O as numbers,
+  m as wasmConnector
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;"}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@kanzo-tech/mosaic",
+  "version": "0.1.0",
+  "description": "The Mosaic conversation, without React — coordinator, clients and clauses re-exported as one surface, plus the Arrow column reader and the id-set client that every consumer of them was writing by hand.",
+  "type": "module",
+  "license": "MIT",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "//peers": "mosaic-core and mosaic-sql are REQUIRED, not optional, and that is the whole point of this package: there is nothing here without them, so a host installs them once and both @kanzo-tech/ui/analytics and @kanzo-tech/graph/duckdb see the same coordinator. Two copies would be two crossfilters. @uwdata/vgplot is deliberately absent — it is a plotting library, it belongs to the charts in @kanzo-tech/ui, and its accidental presence on this path is exactly the bug this package exists to end. @duckdb/duckdb-wasm is absent for the same reason it is absent from @kanzo-tech/graph: nothing here names it, and a host that boots its own DuckDB depends on it directly. The two ranges differ — mosaic-core ^0.29.2, mosaic-sql ^0.29.0 — and that is not drift: mosaic-sql published exactly one release in the 0.29 line, so ^0.29.2 does not resolve. Each range names the newest patch that exists.",
+  "peerDependencies": {
+    "@uwdata/mosaic-core": "^0.29.2",
+    "@uwdata/mosaic-sql": "^0.29.0"
+  },
+  "devDependencies": {
+    "@uwdata/mosaic-core": "^0.29.2",
+    "@uwdata/mosaic-sql": "^0.29.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Kanzo-Tech/ui.git",
+    "directory": "packages/mosaic"
+  },
+  "homepage": "https://kanzo-tech.github.io/ui",
+  "bugs": {
+    "url": "https://github.com/Kanzo-Tech/ui/issues"
+  },
+  "scripts": {
+    "build": "vite build",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}