@kanzo-tech/graph 0.14.0 → 0.15.1

package/README.md

@@ -1,8 +1,8 @@
 # @kanzo-tech/graph
 
-The graph view over a [fossil](https://github.com/kanzo-tech/fossil) corpus, drawn with
+The graph view over a [fossil](https://github.com/Kanzo-Tech/fossil-lang) corpus, drawn with
 [cosmos.gl](https://cosmosgl.github.io/graph). fossil is the backend and this package is the view:
-the host opens the corpus, and `GraphRoot` draws it by tile — no SQL is written here.
+the host opens the corpus, and `GraphRoot` draws the whole of it — no SQL is written here.
 
 ## Install
 
@@ -23,7 +23,7 @@ import { GraphCanvas, GraphInspector, GraphLegend, GraphRoot, GraphToolbar } fro
 
 const corpus = engine().then((e) => open(url, { engine: e }));
 
-<GraphRoot corpus={corpus} fill="kind" r="degree" title="label" filterBy={crossfilter} onFailure={setFailure}>
+<GraphRoot corpus={corpus} r="degree" filterBy={crossfilter} onFailure={setFailure}>
   <GraphCanvas>
     <GraphToolbar />
     <GraphLegend />
@@ -36,20 +36,25 @@ const corpus = engine().then((e) => open(url, { engine: e }));
 corpus opens as `` open(`jobs/${id}`, { engine, host }) `` — and `GraphRoot` takes what came back,
 or the promise of it, which is what lets it say it is opening. Closing it is the host's too.
 
-**The channels are Plot's**: `fill`, `symbol`, `r`, `stroke` and `title`, where a CSS colour is a
-constant and anything else is a column. A column binding is a projection: changing one builds a new
-scan and reloads the tiles while keeping the picture.
+**The whole corpus is drawn**: every vertex table with a position — fossil's layout or the
+program's own columns — and every relation whose two ends are drawn, read once, one scan per table,
+and uploaded once. A vertex's `dense_id` is its index in the buffers. The camera reads nothing.
 
-**The camera is addressed.** A tileset in deck.gl's `Tileset2D` shape culls the tile matrix fossil
-published, picks the finest zoom whose tiles in view hold at most `limit` rows (20,000 by default),
-reads one tile at a time nearest the centre first, cancels what the camera has left, and keeps five
-times what it selected. A far view is a coarser rung of fossil's cell pyramid; an edge is drawn when
-both of its ends are in tiles already read.
+**The channels are Plot's**: `fill`, `symbol`, `r`, `stroke` and `title`, where a CSS colour is a
+constant and anything else is a column. Unbound, colour is the vertex type and a label is the table's
+`identity`. Changing a column binding re-reads that column and nothing else.
 
-**`filterBy` is the page's crossfilter.** Its clauses are translated into scan's filter, so the
-canvas draws what survives; a clause that cannot be translated reaches `onFailure` rather than being
+**`filterBy` is the page's crossfilter.** Its clauses are translated into scan's filter, and what
+does not survive is hidden; a clause that cannot be translated reaches `onFailure` rather than being
 dropped. A lasso or a click publishes the reader's pick back into it, exempting the graph itself.
 
+**The layout is off at load.** The corpus's positions are drawn as they are; `GraphToolbar` runs and
+stops a force layout from where the points are, and dragging a node pins it either way. At 200,000
+vertices the viewer's p95 frame interval is 9.0 ms against 9.3 ms for cosmos.gl alone.
+
+The reference composition is the docs' workspace showcase: one `GraphRoot` around a shell with the
+graph, a second main view and a dock of panels.
+
 ## The pieces
 
 - `GraphRoot` — `useGraph` plus the context. `GraphRootProvider` takes an api a host built with
@@ -61,9 +66,8 @@ dropped. A lasso or a click publishes the reader's pick back into it, exempting
   commands drawn, and the focused vertex's row with a render prop for a product's own fields. No
   part takes a callback: what a click means is `onSelect`, `onFocus` and `onFailure` on the root.
 - `lookFrom`, `simFrom`, `useGraphPrefs` — the form and the forces from a preferences panel's
-  answers; `scaleOf` — what colour and shape a category wears; `adaptive` — simulation tuning by size.
-- `vertexId`, `typeOf`, `denseOf` — a vertex is `(type_idx, dense_id)` packed into a `bigint`, and
-  everything that outlives one composition is held as one.
+  answers; `scaleOf` — what colour and shape a category wears.
+- `VertexId` — a vertex is its `dense_id`, a `number`.
 
 ## Why a package, and not part of `@kanzo-tech/ui`
 

package/dist/core/categories.d.ts

@@ -1,12 +1,24 @@
-import { Corpus } from '@fossil-lang/corpus';
 import { Binding } from './channels';
+import { VertexTable } from '@fossil-lang/corpus';
 /**
- * **The categorical domain, fixed before a tile arrives.** A column the manifest's `channels:`
- * declares as categorical ranks by its own ordinal, `0` to `domain − 1`; otherwise the host's
- * `categories` keys are the order. Only a value neither names is ranked as it is seen, after them —
- * which is what a legend whose colours moved as tiles arrived was doing for every value.
+ * **The categorical domain, fixed before the graph loads.** Colour by vertex type ranks the drawn
+ * tables in the manifest's order; a column ranks by the keys of the host's `categories`. Only a value
+ * neither names is ranked as it is seen, after them.
  */
-export declare function domainOf(corpus: Corpus | null, typeIndex: number, binding: Binding, categories: Readonly<Record<string, string>> | undefined): readonly unknown[];
+export declare function domainOf(tables: readonly VertexTable[], binding: Binding, categories: Readonly<Record<string, string>> | undefined): readonly unknown[];
 /** What a legend, a card or an inspector calls a category value. */
 export declare const nameOf: (value: unknown, categories: Readonly<Record<string, string>> | undefined) => string;
+/**
+ * Values to codes, in the order first seen. **The seed ranks first, in its own order**, so a colour
+ * is decided before a row arrives; a value outside it is ranked after the seed, numbers before
+ * strings. Values meet by their text, so a column's `0` is the host's key `"0"`.
+ */
+export declare class Dictionary {
+    #private;
+    readonly values: unknown[];
+    constructor(seed?: readonly unknown[]);
+    code(value: unknown): number;
+    /** Each code's rank: the seed's own order, then every other value seen. */
+    ranks(): Uint32Array;
+}
 //# sourceMappingURL=categories.d.ts.map

package/dist/core/categories.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"categories.d.ts","sourceRoot":"","sources":["../../src/core/categories.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C;;;;;GAKG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,MAAM,GAAG,IAAI,EACrB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,SAAS,GACvD,SAAS,OAAO,EAAE,CAOpB;AAED,oEAAoE;AACpE,eAAO,MAAM,MAAM,GAAI,OAAO,OAAO,EAAE,YAAY,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,SAAS,KAAG,MAC7C,CAAC"}
+{"version":3,"file":"categories.d.ts","sourceRoot":"","sources":["../../src/core/categories.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD;;;;GAIG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,SAAS,WAAW,EAAE,EAC9B,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,SAAS,GACvD,SAAS,OAAO,EAAE,CAIpB;AAED,oEAAoE;AACpE,eAAO,MAAM,MAAM,GAAI,OAAO,OAAO,EAAE,YAAY,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,SAAS,KAAG,MAC7C,CAAC;AAEtD;;;;GAIG;AACH,qBAAa,UAAU;;IACrB,QAAQ,CAAC,MAAM,EAAE,OAAO,EAAE,CAAM;gBAIpB,IAAI,GAAE,SAAS,OAAO,EAAO;IAKzC,IAAI,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM;IAW5B,2EAA2E;IAC3E,KAAK,IAAI,WAAW;CAUrB"}

package/dist/core/categories.js

@@ -1,14 +1,45 @@
-function a(n, t, i, r) {
-  var o;
-  if (i.category === void 0) return [];
-  const f = (o = n == null ? void 0 : n.types.vertices[t]) == null ? void 0 : o.channels.find(
-    (m) => m.column === i.category && m.scale === "categorical" && m.domain !== null
-  );
-  return f != null && f.domain ? Array.from({ length: f.domain }, (m, y) => y) : r ? Object.keys(r) : [];
+var m = Object.defineProperty;
+var l = (e) => {
+  throw TypeError(e);
+};
+var p = (e, t, n) => t in e ? m(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var c = (e, t, n) => p(e, typeof t != "symbol" ? t + "" : t, n), h = (e, t, n) => t.has(e) || l("Cannot " + n);
+var o = (e, t, n) => (h(e, t, "read from private field"), n ? n.call(e) : t.get(e)), f = (e, t, n) => t.has(e) ? l("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, n), a = (e, t, n, r) => (h(e, t, "write to private field"), r ? r.call(e, n) : t.set(e, n), n);
+function v(e, t, n) {
+  return t.byTable ? e.map((r) => r.name) : t.category === void 0 ? [] : n ? Object.keys(n) : [];
+}
+const b = (e, t) => (t == null ? void 0 : t[String(e)]) ?? String(e ?? "—");
+var u, s;
+class g {
+  constructor(t = []) {
+    c(this, "values", []);
+    f(this, u, /* @__PURE__ */ new Map());
+    f(this, s);
+    for (const n of t) this.code(n);
+    a(this, s, this.values.length);
+  }
+  code(t) {
+    const n = t == null ? null : String(t);
+    let r = o(this, u).get(n);
+    return r === void 0 && (r = this.values.length, this.values.push(typeof t == "bigint" ? Number(t) : t ?? null), o(this, u).set(n, r)), r;
+  }
+  /** Each code's rank: the seed's own order, then every other value seen. */
+  ranks() {
+    const t = new Uint32Array(this.values.length);
+    for (let r = 0; r < o(this, s); r++) t[r] = r;
+    const n = this.values.slice(o(this, s)).map((r, i) => ({ value: r, code: o(this, s) + i }));
+    return n.sort((r, i) => d(r.value, i.value)), n.forEach(({ code: r }, i) => {
+      t[r] = o(this, s) + i;
+    }), t;
+  }
+}
+u = new WeakMap(), s = new WeakMap();
+function d(e, t) {
+  return typeof e == "number" && typeof t == "number" ? e - t : typeof e == "number" ? -1 : typeof t == "number" ? 1 : String(e ?? "").localeCompare(String(t ?? ""));
 }
-const d = (n, t) => (t == null ? void 0 : t[String(n)]) ?? String(n ?? "—");
 export {
-  a as domainOf,
-  d as nameOf
+  g as Dictionary,
+  v as domainOf,
+  b as nameOf
 };
 //# sourceMappingURL=categories.js.map

package/dist/core/categories.js.map

@@ -1 +1 @@
-{"version":3,"file":"categories.js","sources":["../../src/core/categories.ts"],"sourcesContent":["import type { Corpus } from \"@fossil-lang/corpus\";\nimport type { Binding } from \"./channels\";\n\n/**\n * **The categorical domain, fixed before a tile arrives.** A column the manifest's `channels:`\n * declares as categorical ranks by its own ordinal, `0` to `domain − 1`; otherwise the host's\n * `categories` keys are the order. Only a value neither names is ranked as it is seen, after them —\n * which is what a legend whose colours moved as tiles arrived was doing for every value.\n */\nexport function domainOf(\n  corpus: Corpus | null,\n  typeIndex: number,\n  binding: Binding,\n  categories: Readonly<Record<string, string>> | undefined,\n): readonly unknown[] {\n  if (binding.category === undefined) return [];\n  const declared = corpus?.types.vertices[typeIndex]?.channels.find(\n    (channel) => channel.column === binding.category && channel.scale === \"categorical\" && channel.domain !== null,\n  );\n  if (declared?.domain) return Array.from({ length: declared.domain }, (_, ordinal) => ordinal);\n  return categories ? Object.keys(categories) : [];\n}\n\n/** What a legend, a card or an inspector calls a category value. */\nexport const nameOf = (value: unknown, categories: Readonly<Record<string, string>> | undefined): string =>\n  categories?.[String(value)] ?? String(value ?? \"—\");\n"],"names":["domainOf","corpus","typeIndex","binding","categories","_a","declared","channel","_","ordinal","nameOf","value"],"mappings":"AASO,SAASA,EACdC,GACAC,GACAC,GACAC,GACoB;AALf,MAAAC;AAML,MAAIF,EAAQ,aAAa,OAAW,QAAO,CAAA;AAC3C,QAAMG,KAAWD,IAAAJ,KAAA,gBAAAA,EAAQ,MAAM,SAASC,OAAvB,gBAAAG,EAAmC,SAAS;AAAA,IAC3D,CAACE,MAAYA,EAAQ,WAAWJ,EAAQ,YAAYI,EAAQ,UAAU,iBAAiBA,EAAQ,WAAW;AAAA;AAE5G,SAAID,KAAA,QAAAA,EAAU,SAAe,MAAM,KAAK,EAAE,QAAQA,EAAS,OAAA,GAAU,CAACE,GAAGC,MAAYA,CAAO,IACrFL,IAAa,OAAO,KAAKA,CAAU,IAAI,CAAA;AAChD;AAGO,MAAMM,IAAS,CAACC,GAAgBP,OACrCA,KAAA,gBAAAA,EAAa,OAAOO,CAAK,OAAM,OAAOA,KAAS,GAAG;"}
+{"version":3,"file":"categories.js","sources":["../../src/core/categories.ts"],"sourcesContent":["import type { Binding } from \"./channels\";\nimport type { VertexTable } from \"@fossil-lang/corpus\";\n\n/**\n * **The categorical domain, fixed before the graph loads.** Colour by vertex type ranks the drawn\n * tables in the manifest's order; a column ranks by the keys of the host's `categories`. Only a value\n * neither names is ranked as it is seen, after them.\n */\nexport function domainOf(\n  tables: readonly VertexTable[],\n  binding: Binding,\n  categories: Readonly<Record<string, string>> | undefined,\n): readonly unknown[] {\n  if (binding.byTable) return tables.map((table) => table.name);\n  if (binding.category === undefined) return [];\n  return categories ? Object.keys(categories) : [];\n}\n\n/** What a legend, a card or an inspector calls a category value. */\nexport const nameOf = (value: unknown, categories: Readonly<Record<string, string>> | undefined): string =>\n  categories?.[String(value)] ?? String(value ?? \"—\");\n\n/**\n * Values to codes, in the order first seen. **The seed ranks first, in its own order**, so a colour\n * is decided before a row arrives; a value outside it is ranked after the seed, numbers before\n * strings. Values meet by their text, so a column's `0` is the host's key `\"0\"`.\n */\nexport class Dictionary {\n  readonly values: unknown[] = [];\n  readonly #codes = new Map<string | null, number>();\n  readonly #seeded: number;\n\n  constructor(seed: readonly unknown[] = []) {\n    for (const value of seed) this.code(value);\n    this.#seeded = this.values.length;\n  }\n\n  code(value: unknown): number {\n    const key = value === null || value === undefined ? null : String(value);\n    let code = this.#codes.get(key);\n    if (code === undefined) {\n      code = this.values.length;\n      this.values.push(typeof value === \"bigint\" ? Number(value) : (value ?? null));\n      this.#codes.set(key, code);\n    }\n    return code;\n  }\n\n  /** Each code's rank: the seed's own order, then every other value seen. */\n  ranks(): Uint32Array {\n    const ranks = new Uint32Array(this.values.length);\n    for (let code = 0; code < this.#seeded; code++) ranks[code] = code;\n    const rest = this.values.slice(this.#seeded).map((value, i) => ({ value, code: this.#seeded + i }));\n    rest.sort((a, b) => compare(a.value, b.value));\n    rest.forEach(({ code }, i) => {\n      ranks[code] = this.#seeded + i;\n    });\n    return ranks;\n  }\n}\n\nfunction compare(a: unknown, b: unknown): number {\n  if (typeof a === \"number\" && typeof b === \"number\") return a - b;\n  if (typeof a === \"number\") return -1;\n  if (typeof b === \"number\") return 1;\n  return String(a ?? \"\").localeCompare(String(b ?? \"\"));\n}\n"],"names":["domainOf","tables","binding","categories","table","nameOf","value","_codes","_seeded","Dictionary","seed","__publicField","__privateAdd","__privateSet","key","code","__privateGet","ranks","rest","a","b","compare"],"mappings":";;;;;;;AAQO,SAASA,EACdC,GACAC,GACAC,GACoB;AACpB,SAAID,EAAQ,UAAgBD,EAAO,IAAI,CAACG,MAAUA,EAAM,IAAI,IACxDF,EAAQ,aAAa,SAAkB,CAAA,IACpCC,IAAa,OAAO,KAAKA,CAAU,IAAI,CAAA;AAChD;AAGO,MAAME,IAAS,CAACC,GAAgBH,OACrCA,KAAA,gBAAAA,EAAa,OAAOG,CAAK,OAAM,OAAOA,KAAS,GAAG;AAZ7C,IAAAC,GAAAC;AAmBA,MAAMC,EAAW;AAAA,EAKtB,YAAYC,IAA2B,IAAI;AAJlC,IAAAC,EAAA,gBAAoB,CAAA;AACpB,IAAAC,EAAA,MAAAL,uBAAa,IAAA;AACb,IAAAK,EAAA,MAAAJ;AAGP,eAAWF,KAASI,EAAM,MAAK,KAAKJ,CAAK;AACzC,IAAAO,EAAA,MAAKL,GAAU,KAAK,OAAO;AAAA,EAC7B;AAAA,EAEA,KAAKF,GAAwB;AAC3B,UAAMQ,IAAMR,KAAU,OAA8B,OAAO,OAAOA,CAAK;AACvE,QAAIS,IAAOC,EAAA,MAAKT,GAAO,IAAIO,CAAG;AAC9B,WAAIC,MAAS,WACXA,IAAO,KAAK,OAAO,QACnB,KAAK,OAAO,KAAK,OAAOT,KAAU,WAAW,OAAOA,CAAK,IAAKA,KAAS,IAAK,GAC5EU,EAAA,MAAKT,GAAO,IAAIO,GAAKC,CAAI,IAEpBA;AAAA,EACT;AAAA;AAAA,EAGA,QAAqB;AACnB,UAAME,IAAQ,IAAI,YAAY,KAAK,OAAO,MAAM;AAChD,aAASF,IAAO,GAAGA,IAAOC,EAAA,MAAKR,IAASO,IAAQ,CAAAE,EAAMF,CAAI,IAAIA;AAC9D,UAAMG,IAAO,KAAK,OAAO,MAAMF,EAAA,MAAKR,EAAO,EAAE,IAAI,CAACF,GAAO,OAAO,EAAE,OAAAA,GAAO,MAAMU,EAAA,MAAKR,KAAU,IAAI;AAClG,WAAAU,EAAK,KAAK,CAACC,GAAGC,MAAMC,EAAQF,EAAE,OAAOC,EAAE,KAAK,CAAC,GAC7CF,EAAK,QAAQ,CAAC,EAAE,MAAAH,EAAA,GAAQ,MAAM;AAC5B,MAAAE,EAAMF,CAAI,IAAIC,EAAA,MAAKR,KAAU;AAAA,IAC/B,CAAC,GACMS;AAAA,EACT;AACF;AA9BWV,IAAA,eACAC,IAAA;AA+BX,SAASa,EAAQF,GAAYC,GAAoB;AAC/C,SAAI,OAAOD,KAAM,YAAY,OAAOC,KAAM,WAAiBD,IAAIC,IAC3D,OAAOD,KAAM,WAAiB,KAC9B,OAAOC,KAAM,WAAiB,IAC3B,OAAOD,KAAK,EAAE,EAAE,cAAc,OAAOC,KAAK,EAAE,CAAC;AACtD;"}

package/dist/core/channels.d.ts

@@ -4,10 +4,10 @@
  * paints every point one ink and leaves colour free to mean the selection.
  */
 export interface Channels {
-    /** Which column colours a point, or a CSS colour every point wears. */
+    /** Which column colours a point, or a CSS colour every point wears. Absent, colour is the vertex type. */
     fill?: string;
     /**
-     * Which column a point's shape carries. A tile carries one categorical column, so bound beside a
+     * Which column a point's shape carries. The graph holds one categorical column, so bound beside a
      * `fill` column this reads the same one; a second would need a second array everywhere.
      */
     symbol?: string;
@@ -18,8 +18,10 @@ export interface Channels {
 export declare function isColour(value: string | undefined): value is string;
 /** The columns a binding reads, which is what a scan projects. */
 export interface Binding {
-    /** The one categorical column: `fill` when it names one, `symbol` when `fill` is a constant. */
+    /** The one categorical column: `fill` when it names one, `symbol` when `fill` is a constant or absent. */
     readonly category: string | undefined;
+    /** No column and no constant: the category is the vertex type. */
+    readonly byTable: boolean;
     /** What the size ramp is spent on — Plot's `r`. */
     readonly size: string | undefined;
     /** The text a label and the hover card show — Plot's `title`. */
@@ -29,6 +31,9 @@ export declare function bindingOf(options: Channels & {
     r?: string;
     title?: string;
 }): Binding;
-/** A binding is a projection: `fill`, `r` and `title` as columns become the scan's `select`. */
-export declare function projectionOf(binding: Binding, fixed: readonly string[]): string[];
+/**
+ * A binding is a projection: `fill` and `r` as columns become the scan's `select`, where the table
+ * has them. `title` is not: a label's text is read for the few vertices that carry one.
+ */
+export declare function projectionOf(binding: Binding, fixed: readonly string[], has: (column: string) => boolean): string[];
 //# sourceMappingURL=channels.d.ts.map

package/dist/core/channels.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"channels.d.ts","sourceRoot":"","sources":["../../src/core/channels.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACvB,uEAAuE;IACvE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kFAAkF;IAClF,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,kGAAkG;AAClG,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,KAAK,IAAI,MAAM,CAEnE;AAED,kEAAkE;AAClE,MAAM,WAAW,OAAO;IACtB,gGAAgG;IAChG,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,mDAAmD;IACnD,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,iEAAiE;IACjE,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;CACpC;AAED,wBAAgB,SAAS,CAAC,OAAO,EAAE,QAAQ,GAAG;IAAE,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAMrF;AAED,gGAAgG;AAChG,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAEjF"}
+{"version":3,"file":"channels.d.ts","sourceRoot":"","sources":["../../src/core/channels.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACvB,0GAA0G;IAC1G,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kFAAkF;IAClF,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,kGAAkG;AAClG,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,KAAK,IAAI,MAAM,CAEnE;AAED,kEAAkE;AAClE,MAAM,WAAW,OAAO;IACtB,0GAA0G;IAC1G,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,kEAAkE;IAClE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,mDAAmD;IACnD,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,iEAAiE;IACjE,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;CACpC;AAED,wBAAgB,SAAS,CAAC,OAAO,EAAE,QAAQ,GAAG;IAAE,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAIrF;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,GAAG,MAAM,EAAE,CAGnH"}

package/dist/core/channels.js

@@ -1,19 +1,17 @@
-function l(r) {
-  return r !== void 0 && /^(var\(|#|rgb|hsl|oklch|oklab|lab|lch|color\()/i.test(r);
+function c(t) {
+  return t !== void 0 && /^(var\(|#|rgb|hsl|oklch|oklab|lab|lch|color\()/i.test(t);
 }
-function i(r) {
-  return {
-    category: l(r.fill) ? r.symbol : r.fill,
-    size: r.r,
-    title: r.title
-  };
+function n(t) {
+  const l = c(t.fill), r = l ? t.symbol : t.fill ?? t.symbol;
+  return { category: r, byTable: !l && r === void 0, size: t.r, title: t.title };
 }
-function c(r, t) {
-  return [...new Set([...t, r.category, r.size, r.title].filter((e) => e !== void 0))];
+function i(t, l, r) {
+  const o = [t.category, t.size].filter((e) => e !== void 0 && r(e));
+  return [.../* @__PURE__ */ new Set([...l, ...o])];
 }
 export {
-  i as bindingOf,
-  l as isColour,
-  c as projectionOf
+  n as bindingOf,
+  c as isColour,
+  i as projectionOf
 };
 //# sourceMappingURL=channels.js.map

package/dist/core/channels.js.map

@@ -1 +1 @@
-{"version":3,"file":"channels.js","sources":["../../src/core/channels.ts"],"sourcesContent":["/**\n * What each channel is bound to — Plot's names, and Plot's rule that **a CSS colour is a constant\n * and anything else is a column.** `fill=\"kind\"` spends colour on a category; `fill=\"var(--foreground)\"`\n * paints every point one ink and leaves colour free to mean the selection.\n */\nexport interface Channels {\n  /** Which column colours a point, or a CSS colour every point wears. */\n  fill?: string;\n  /**\n   * Which column a point's shape carries. A tile carries one categorical column, so bound beside a\n   * `fill` column this reads the same one; a second would need a second array everywhere.\n   */\n  symbol?: string;\n  /** What tints a link. Absent, a link takes the colour of the vertex it leaves. */\n  stroke?: string;\n}\n\n/** Narrow on purpose — `var(…)`, a hex, a colour function — so a bare word is always a column. */\nexport function isColour(value: string | undefined): value is string {\n  return value !== undefined && /^(var\\(|#|rgb|hsl|oklch|oklab|lab|lch|color\\()/i.test(value);\n}\n\n/** The columns a binding reads, which is what a scan projects. */\nexport interface Binding {\n  /** The one categorical column: `fill` when it names one, `symbol` when `fill` is a constant. */\n  readonly category: string | undefined;\n  /** What the size ramp is spent on — Plot's `r`. */\n  readonly size: string | undefined;\n  /** The text a label and the hover card show — Plot's `title`. */\n  readonly title: string | undefined;\n}\n\nexport function bindingOf(options: Channels & { r?: string; title?: string }): Binding {\n  return {\n    category: isColour(options.fill) ? options.symbol : options.fill,\n    size: options.r,\n    title: options.title,\n  };\n}\n\n/** A binding is a projection: `fill`, `r` and `title` as columns become the scan's `select`. */\nexport function projectionOf(binding: Binding, fixed: readonly string[]): string[] {\n  return [...new Set([...fixed, binding.category, binding.size, binding.title].filter((c) => c !== undefined))];\n}\n"],"names":["isColour","value","bindingOf","options","projectionOf","binding","fixed","c"],"mappings":"AAkBO,SAASA,EAASC,GAA4C;AACnE,SAAOA,MAAU,UAAa,kDAAkD,KAAKA,CAAK;AAC5F;AAYO,SAASC,EAAUC,GAA6D;AACrF,SAAO;AAAA,IACL,UAAUH,EAASG,EAAQ,IAAI,IAAIA,EAAQ,SAASA,EAAQ;AAAA,IAC5D,MAAMA,EAAQ;AAAA,IACd,OAAOA,EAAQ;AAAA,EAAA;AAEnB;AAGO,SAASC,EAAaC,GAAkBC,GAAoC;AACjF,SAAO,CAAC,GAAG,IAAI,IAAI,CAAC,GAAGA,GAAOD,EAAQ,UAAUA,EAAQ,MAAMA,EAAQ,KAAK,EAAE,OAAO,CAACE,MAAMA,MAAM,MAAS,CAAC,CAAC;AAC9G;"}
+{"version":3,"file":"channels.js","sources":["../../src/core/channels.ts"],"sourcesContent":["/**\n * What each channel is bound to — Plot's names, and Plot's rule that **a CSS colour is a constant\n * and anything else is a column.** `fill=\"kind\"` spends colour on a category; `fill=\"var(--foreground)\"`\n * paints every point one ink and leaves colour free to mean the selection.\n */\nexport interface Channels {\n  /** Which column colours a point, or a CSS colour every point wears. Absent, colour is the vertex type. */\n  fill?: string;\n  /**\n   * Which column a point's shape carries. The graph holds one categorical column, so bound beside a\n   * `fill` column this reads the same one; a second would need a second array everywhere.\n   */\n  symbol?: string;\n  /** What tints a link. Absent, a link takes the colour of the vertex it leaves. */\n  stroke?: string;\n}\n\n/** Narrow on purpose — `var(…)`, a hex, a colour function — so a bare word is always a column. */\nexport function isColour(value: string | undefined): value is string {\n  return value !== undefined && /^(var\\(|#|rgb|hsl|oklch|oklab|lab|lch|color\\()/i.test(value);\n}\n\n/** The columns a binding reads, which is what a scan projects. */\nexport interface Binding {\n  /** The one categorical column: `fill` when it names one, `symbol` when `fill` is a constant or absent. */\n  readonly category: string | undefined;\n  /** No column and no constant: the category is the vertex type. */\n  readonly byTable: boolean;\n  /** What the size ramp is spent on — Plot's `r`. */\n  readonly size: string | undefined;\n  /** The text a label and the hover card show — Plot's `title`. */\n  readonly title: string | undefined;\n}\n\nexport function bindingOf(options: Channels & { r?: string; title?: string }): Binding {\n  const constant = isColour(options.fill);\n  const category = constant ? options.symbol : (options.fill ?? options.symbol);\n  return { category, byTable: !constant && category === undefined, size: options.r, title: options.title };\n}\n\n/**\n * A binding is a projection: `fill` and `r` as columns become the scan's `select`, where the table\n * has them. `title` is not: a label's text is read for the few vertices that carry one.\n */\nexport function projectionOf(binding: Binding, fixed: readonly string[], has: (column: string) => boolean): string[] {\n  const bound = [binding.category, binding.size].filter((c): c is string => c !== undefined && has(c));\n  return [...new Set([...fixed, ...bound])];\n}\n"],"names":["isColour","value","bindingOf","options","constant","category","projectionOf","binding","fixed","has","bound","c"],"mappings":"AAkBO,SAASA,EAASC,GAA4C;AACnE,SAAOA,MAAU,UAAa,kDAAkD,KAAKA,CAAK;AAC5F;AAcO,SAASC,EAAUC,GAA6D;AACrF,QAAMC,IAAWJ,EAASG,EAAQ,IAAI,GAChCE,IAAWD,IAAWD,EAAQ,SAAUA,EAAQ,QAAQA,EAAQ;AACtE,SAAO,EAAE,UAAAE,GAAU,SAAS,CAACD,KAAYC,MAAa,QAAW,MAAMF,EAAQ,GAAG,OAAOA,EAAQ,MAAA;AACnG;AAMO,SAASG,EAAaC,GAAkBC,GAA0BC,GAA4C;AACnH,QAAMC,IAAQ,CAACH,EAAQ,UAAUA,EAAQ,IAAI,EAAE,OAAO,CAACI,MAAmBA,MAAM,UAAaF,EAAIE,CAAC,CAAC;AACnG,SAAO,CAAC,GAAG,oBAAI,IAAI,CAAC,GAAGH,GAAO,GAAGE,CAAK,CAAC,CAAC;AAC1C;"}

package/dist/core/detail.d.ts

@@ -1,18 +1,24 @@
-import { Corpus, TileMatrixSet } from '@fossil-lang/corpus';
-import { VertexId } from './resident';
-/** One vertex's row, as its type's fields order it — every column but the address and the position. */
+import { Corpus } from '@fossil-lang/corpus';
+import { Geometry } from './load';
+import { VertexId } from './types';
+/** One vertex's row, as its table's properties order it — every column but the key and the position. */
 export interface VertexDetail {
     readonly vertex: VertexId;
+    /** The vertex table it belongs to. */
+    readonly table: string;
     readonly fields: readonly {
         readonly name: string;
         readonly value: unknown;
     }[];
 }
 /**
- * **Detail is fetched, not carried** — ADR 0001. A tile holds what the channels project; the rest of a
- * row is asked for when a reader focuses the vertex, as a scan of the one payload tile its `dense_id`
- * falls in, filtered to it. `corpus.node` takes an identity, and a tile carries an address, so the
- * address is what asks.
+ * **Detail is fetched, not carried.** The loaded graph holds positions and channels; the rest of a
+ * row is asked for when a reader focuses the vertex — a scan of its table, filtered to its key.
  */
-export declare function readVertex(corpus: Corpus, matrix: TileMatrixSet, vertex: VertexId, signal?: AbortSignal): Promise<VertexDetail | null>;
+export declare function readVertex(corpus: Corpus, geometry: Geometry, vertex: VertexId, signal?: AbortSignal): Promise<VertexDetail | null>;
+/**
+ * **A label's text, for the few vertices that carry one** — `title` where the vertex's table has the
+ * column, and the table's declared `identity` where it does not. One scan per table they fall in.
+ */
+export declare function readTitles(corpus: Corpus, geometry: Geometry, vertices: readonly VertexId[], title: string | undefined, signal?: AbortSignal): Promise<Map<VertexId, string>>;
 //# sourceMappingURL=detail.d.ts.map

package/dist/core/detail.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"detail.d.ts","sourceRoot":"","sources":["../../src/core/detail.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwC,KAAK,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAC5G,OAAO,EAAW,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAGpD,uGAAuG;AACvG,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,SAAS;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;KAAE,EAAE,CAAC;CAChF;AAKD;;;;;GAKG;AACH,wBAAsB,UAAU,CAC9B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,QAAQ,EAChB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAa9B"}
+{"version":3,"file":"detail.d.ts","sourceRoot":"","sources":["../../src/core/detail.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,qBAAqB,CAAC;AAC/D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC,wGAAwG;AACxG,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B,sCAAsC;IACtC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,SAAS;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;KAAE,EAAE,CAAC;CAChF;AAKD;;;GAGG;AACH,wBAAsB,UAAU,CAC9B,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,QAAQ,EAChB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAa9B;AAED;;;GAGG;AACH,wBAAsB,UAAU,CAC9B,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EAAE,SAAS,QAAQ,EAAE,EAC7B,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,CAmBhC"}

package/dist/core/detail.js

@@ -1,20 +1,38 @@
-import { PAYLOAD_ADDRESS as u, PAYLOAD_COORDINATES as m } from "@fossil-lang/corpus";
-import { denseOf as y } from "./resident.js";
-import { tileOfDense as D } from "./tile-matrix.js";
-const s = u[0], A = /* @__PURE__ */ new Set([s, ...m]);
-async function S(o, t, r, p) {
-  const l = y(r), c = D(t, l), a = o.types.vertices.find((e) => e.type === t.type);
-  if (!c || !a) return null;
-  const f = a.fields.map((e) => e.name).filter((e) => !A.has(e)), d = o.scan({ type: t.type, filter: { column: s, op: "=", value: l }, select: [s, ...f] }), [n] = await d.read([c], { signal: p });
-  return !n || n.numRows === 0 ? null : {
-    vertex: r,
-    fields: f.map((e) => {
-      var i;
-      return { name: e, value: ((i = n.getChild(e)) == null ? void 0 : i.toArray()[0]) ?? null };
+const y = (o, a) => a < o.size ? o.tables[o.table[a]] : void 0;
+async function k(o, a, i, c) {
+  var u, f;
+  const e = y(a, i);
+  if (!e) return null;
+  const l = /* @__PURE__ */ new Set([e.key, (u = e.position) == null ? void 0 : u.x, (f = e.position) == null ? void 0 : f.y]), r = e.properties.map((t) => t.name).filter((t) => !l.has(t)), n = o.scan({ table: e.name, filter: { column: e.key, op: "=", value: i }, select: [e.key, ...r], limit: 1 }), s = (await n.read(n.plan(), { signal: c })).find((t) => t.numRows > 0);
+  return s ? {
+    vertex: i,
+    table: e.name,
+    fields: r.map((t) => {
+      var p;
+      return { name: t, value: ((p = s.getChild(t)) == null ? void 0 : p.toArray()[0]) ?? null };
     })
-  };
+  } : null;
+}
+async function h(o, a, i, c, e) {
+  const l = /* @__PURE__ */ new Map();
+  for (const n of i) {
+    const s = y(a, n);
+    s && l.set(s, [...l.get(s) ?? [], n]);
+  }
+  const r = /* @__PURE__ */ new Map();
+  return await Promise.all(
+    [...l].map(async ([n, s]) => {
+      var t, p;
+      const u = c !== void 0 && n.properties.some((d) => d.name === c) ? c : n.identity, f = o.scan({ table: n.name, filter: { column: n.key, op: "in", values: s }, select: [n.key, u] });
+      for (const d of await f.read(f.plan(), { signal: e })) {
+        const w = ((t = d.getChild(n.key)) == null ? void 0 : t.toArray()) ?? [], b = ((p = d.getChild(u)) == null ? void 0 : p.toArray()) ?? [];
+        for (let m = 0; m < d.numRows; m++) r.set(Number(w[m]), String(b[m] ?? ""));
+      }
+    })
+  ), r;
 }
 export {
-  S as readVertex
+  h as readTitles,
+  k as readVertex
 };
 //# sourceMappingURL=detail.js.map

package/dist/core/detail.js.map

@@ -1 +1 @@
-{"version":3,"file":"detail.js","sources":["../../src/core/detail.ts"],"sourcesContent":["import { PAYLOAD_ADDRESS, PAYLOAD_COORDINATES, type Corpus, type TileMatrixSet } from \"@fossil-lang/corpus\";\nimport { denseOf, type VertexId } from \"./resident\";\nimport { tileOfDense } from \"./tile-matrix\";\n\n/** One vertex's row, as its type's fields order it — every column but the address and the position. */\nexport interface VertexDetail {\n  readonly vertex: VertexId;\n  readonly fields: readonly { readonly name: string; readonly value: unknown }[];\n}\n\nconst KEY = PAYLOAD_ADDRESS[0] as string;\nconst HIDDEN = new Set<string>([KEY, ...PAYLOAD_COORDINATES]);\n\n/**\n * **Detail is fetched, not carried** — ADR 0001. A tile holds what the channels project; the rest of a\n * row is asked for when a reader focuses the vertex, as a scan of the one payload tile its `dense_id`\n * falls in, filtered to it. `corpus.node` takes an identity, and a tile carries an address, so the\n * address is what asks.\n */\nexport async function readVertex(\n  corpus: Corpus,\n  matrix: TileMatrixSet,\n  vertex: VertexId,\n  signal?: AbortSignal,\n): Promise<VertexDetail | null> {\n  const dense = denseOf(vertex);\n  const address = tileOfDense(matrix, dense);\n  const type = corpus.types.vertices.find((t) => t.type === matrix.type);\n  if (!address || !type) return null;\n  const names = type.fields.map((field) => field.name).filter((name) => !HIDDEN.has(name));\n  const scan = corpus.scan({ type: matrix.type, filter: { column: KEY, op: \"=\", value: dense }, select: [KEY, ...names] });\n  const [rows] = await scan.read([address], { signal });\n  if (!rows || rows.numRows === 0) return null;\n  return {\n    vertex,\n    fields: names.map((name) => ({ name, value: rows.getChild(name)?.toArray()[0] ?? null })),\n  };\n}\n"],"names":["KEY","PAYLOAD_ADDRESS","HIDDEN","PAYLOAD_COORDINATES","readVertex","corpus","matrix","vertex","signal","dense","denseOf","address","tileOfDense","type","t","names","field","name","scan","rows","_a"],"mappings":";;;AAUA,MAAMA,IAAMC,EAAgB,CAAC,GACvBC,IAAS,oBAAI,IAAY,CAACF,GAAK,GAAGG,CAAmB,CAAC;AAQ5D,eAAsBC,EACpBC,GACAC,GACAC,GACAC,GAC8B;AAC9B,QAAMC,IAAQC,EAAQH,CAAM,GACtBI,IAAUC,EAAYN,GAAQG,CAAK,GACnCI,IAAOR,EAAO,MAAM,SAAS,KAAK,CAACS,MAAMA,EAAE,SAASR,EAAO,IAAI;AACrE,MAAI,CAACK,KAAW,CAACE,EAAM,QAAO;AAC9B,QAAME,IAAQF,EAAK,OAAO,IAAI,CAACG,MAAUA,EAAM,IAAI,EAAE,OAAO,CAACC,MAAS,CAACf,EAAO,IAAIe,CAAI,CAAC,GACjFC,IAAOb,EAAO,KAAK,EAAE,MAAMC,EAAO,MAAM,QAAQ,EAAE,QAAQN,GAAK,IAAI,KAAK,OAAOS,KAAS,QAAQ,CAACT,GAAK,GAAGe,CAAK,GAAG,GACjH,CAACI,CAAI,IAAI,MAAMD,EAAK,KAAK,CAACP,CAAO,GAAG,EAAE,QAAAH,GAAQ;AACpD,SAAI,CAACW,KAAQA,EAAK,YAAY,IAAU,OACjC;AAAA,IACL,QAAAZ;AAAA,IACA,QAAQQ,EAAM,IAAI,CAACE,MAAA;;AAAU,eAAE,MAAAA,GAAM,SAAOG,IAAAD,EAAK,SAASF,CAAI,MAAlB,gBAAAG,EAAqB,UAAU,OAAM;KAAO;AAAA,EAAA;AAE5F;"}
+{"version":3,"file":"detail.js","sources":["../../src/core/detail.ts"],"sourcesContent":["import type { Corpus, VertexTable } from \"@fossil-lang/corpus\";\nimport type { Geometry } from \"./load\";\nimport type { VertexId } from \"./types\";\n\n/** One vertex's row, as its table's properties order it — every column but the key and the position. */\nexport interface VertexDetail {\n  readonly vertex: VertexId;\n  /** The vertex table it belongs to. */\n  readonly table: string;\n  readonly fields: readonly { readonly name: string; readonly value: unknown }[];\n}\n\nconst tableOf = (geometry: Geometry, vertex: VertexId): VertexTable | undefined =>\n  vertex < geometry.size ? geometry.tables[geometry.table[vertex] as number] : undefined;\n\n/**\n * **Detail is fetched, not carried.** The loaded graph holds positions and channels; the rest of a\n * row is asked for when a reader focuses the vertex — a scan of its table, filtered to its key.\n */\nexport async function readVertex(\n  corpus: Corpus,\n  geometry: Geometry,\n  vertex: VertexId,\n  signal?: AbortSignal,\n): Promise<VertexDetail | null> {\n  const table = tableOf(geometry, vertex);\n  if (!table) return null;\n  const hidden = new Set([table.key, table.position?.x, table.position?.y]);\n  const names = table.properties.map((p) => p.name).filter((name) => !hidden.has(name));\n  const scan = corpus.scan({ table: table.name, filter: { column: table.key, op: \"=\", value: vertex }, select: [table.key, ...names], limit: 1 });\n  const rows = (await scan.read(scan.plan(), { signal })).find((batch) => batch.numRows > 0);\n  if (!rows) return null;\n  return {\n    vertex,\n    table: table.name,\n    fields: names.map((name) => ({ name, value: rows.getChild(name)?.toArray()[0] ?? null })),\n  };\n}\n\n/**\n * **A label's text, for the few vertices that carry one** — `title` where the vertex's table has the\n * column, and the table's declared `identity` where it does not. One scan per table they fall in.\n */\nexport async function readTitles(\n  corpus: Corpus,\n  geometry: Geometry,\n  vertices: readonly VertexId[],\n  title: string | undefined,\n  signal?: AbortSignal,\n): Promise<Map<VertexId, string>> {\n  const byTable = new Map<VertexTable, VertexId[]>();\n  for (const vertex of vertices) {\n    const table = tableOf(geometry, vertex);\n    if (table) byTable.set(table, [...(byTable.get(table) ?? []), vertex]);\n  }\n  const found = new Map<VertexId, string>();\n  await Promise.all(\n    [...byTable].map(async ([table, ids]) => {\n      const column = title !== undefined && table.properties.some((p) => p.name === title) ? title : table.identity;\n      const scan = corpus.scan({ table: table.name, filter: { column: table.key, op: \"in\", values: ids }, select: [table.key, column] });\n      for (const batch of await scan.read(scan.plan(), { signal })) {\n        const keys = batch.getChild(table.key)?.toArray() ?? [];\n        const texts = batch.getChild(column)?.toArray() ?? [];\n        for (let i = 0; i < batch.numRows; i++) found.set(Number(keys[i]), String(texts[i] ?? \"\"));\n      }\n    }),\n  );\n  return found;\n}\n"],"names":["tableOf","geometry","vertex","readVertex","corpus","signal","_a","_b","table","hidden","names","p","name","scan","rows","batch","readTitles","vertices","title","byTable","found","ids","column","keys","texts","i"],"mappings":"AAYA,MAAMA,IAAU,CAACC,GAAoBC,MACnCA,IAASD,EAAS,OAAOA,EAAS,OAAOA,EAAS,MAAMC,CAAM,CAAW,IAAI;AAM/E,eAAsBC,EACpBC,GACAH,GACAC,GACAG,GAC8B;AAZhC,MAAAC,GAAAC;AAaE,QAAMC,IAAQR,EAAQC,GAAUC,CAAM;AACtC,MAAI,CAACM,EAAO,QAAO;AACnB,QAAMC,IAAS,oBAAI,IAAI,CAACD,EAAM,MAAKF,IAAAE,EAAM,aAAN,gBAAAF,EAAgB,IAAGC,IAAAC,EAAM,aAAN,gBAAAD,EAAgB,CAAC,CAAC,GAClEG,IAAQF,EAAM,WAAW,IAAI,CAACG,MAAMA,EAAE,IAAI,EAAE,OAAO,CAACC,MAAS,CAACH,EAAO,IAAIG,CAAI,CAAC,GAC9EC,IAAOT,EAAO,KAAK,EAAE,OAAOI,EAAM,MAAM,QAAQ,EAAE,QAAQA,EAAM,KAAK,IAAI,KAAK,OAAON,EAAA,GAAU,QAAQ,CAACM,EAAM,KAAK,GAAGE,CAAK,GAAG,OAAO,EAAA,CAAG,GACxII,KAAQ,MAAMD,EAAK,KAAKA,EAAK,QAAQ,EAAE,QAAAR,EAAA,CAAQ,GAAG,KAAK,CAACU,MAAUA,EAAM,UAAU,CAAC;AACzF,SAAKD,IACE;AAAA,IACL,QAAAZ;AAAA,IACA,OAAOM,EAAM;AAAA,IACb,QAAQE,EAAM,IAAI,CAACE,MAAA;AAvBvB,UAAAN;AAuBiC,eAAE,MAAAM,GAAM,SAAON,IAAAQ,EAAK,SAASF,CAAI,MAAlB,gBAAAN,EAAqB,UAAU,OAAM;KAAO;AAAA,EAAA,IAJxE;AAMpB;AAMA,eAAsBU,EACpBZ,GACAH,GACAgB,GACAC,GACAb,GACgC;AAChC,QAAMc,wBAAc,IAAA;AACpB,aAAWjB,KAAUe,GAAU;AAC7B,UAAMT,IAAQR,EAAQC,GAAUC,CAAM;AACtC,IAAIM,KAAOW,EAAQ,IAAIX,GAAO,CAAC,GAAIW,EAAQ,IAAIX,CAAK,KAAK,CAAA,GAAKN,CAAM,CAAC;AAAA,EACvE;AACA,QAAMkB,wBAAY,IAAA;AAClB,eAAM,QAAQ;AAAA,IACZ,CAAC,GAAGD,CAAO,EAAE,IAAI,OAAO,CAACX,GAAOa,CAAG,MAAM;AA7C7C,UAAAf,GAAAC;AA8CM,YAAMe,IAASJ,MAAU,UAAaV,EAAM,WAAW,KAAK,CAACG,MAAMA,EAAE,SAASO,CAAK,IAAIA,IAAQV,EAAM,UAC/FK,IAAOT,EAAO,KAAK,EAAE,OAAOI,EAAM,MAAM,QAAQ,EAAE,QAAQA,EAAM,KAAK,IAAI,MAAM,QAAQa,EAAA,GAAO,QAAQ,CAACb,EAAM,KAAKc,CAAM,GAAG;AACjI,iBAAWP,KAAS,MAAMF,EAAK,KAAKA,EAAK,QAAQ,EAAE,QAAAR,EAAA,CAAQ,GAAG;AAC5D,cAAMkB,MAAOjB,IAAAS,EAAM,SAASP,EAAM,GAAG,MAAxB,gBAAAF,EAA2B,cAAa,CAAA,GAC/CkB,MAAQjB,IAAAQ,EAAM,SAASO,CAAM,MAArB,gBAAAf,EAAwB,cAAa,CAAA;AACnD,iBAASkB,IAAI,GAAGA,IAAIV,EAAM,SAASU,OAAW,IAAI,OAAOF,EAAKE,CAAC,CAAC,GAAG,OAAOD,EAAMC,CAAC,KAAK,EAAE,CAAC;AAAA,MAC3F;AAAA,IACF,CAAC;AAAA,EAAA,GAEIL;AACT;"}

package/dist/core/filter.d.ts

@@ -15,6 +15,8 @@ export declare class UntranslatableFilter extends Error {
 }
 /** One mosaic-sql expression node → one `Filter`. */
 export declare function translate(node: unknown): Filter;
+/** Every column a filter names, once each. */
+export declare function columnsOf(filter: Filter): string[];
 /**
  * The page's filter for the graph, or `undefined` for none. `selection.predicate` skips the clause
  * the graph published itself, which is the exemption the next function takes back.
@@ -30,5 +32,5 @@ export declare function graphClient(): MosaicClient;
  * the graph and applies it to every chart. A canvas that draws only what survives would otherwise
  * answer a lasso of thirteen by removing the other 1,530.
  */
-export declare function publish(selection: Selection, self: MosaicClient, column: string, dense: readonly number[] | null): void;
+export declare function publish(selection: Selection, self: MosaicClient, column: string, ids: readonly number[] | null): void;
 //# sourceMappingURL=filter.d.ts.map

package/dist/core/filter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../src/core/filter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAW,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,YAAY,EAAgB,KAAK,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEhF;;;;;;;;GAQG;AAEH,+EAA+E;AAC/E,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,SAAkB,IAAI,0BAA0B;CACjD;AAoDD,qDAAqD;AACrD,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAyC/C;AAID;;;GAGG;AACH,wBAAgB,SAAS,CAAC,SAAS,EAAE,SAAS,EAAE,IAAI,EAAE,YAAY,GAAG,MAAM,GAAG,SAAS,CAItF;AAED;;;GAGG;AACH,wBAAgB,WAAW,IAAI,YAAY,CAE1C;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CACrB,SAAS,EAAE,SAAS,EACpB,IAAI,EAAE,YAAY,EAClB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,GAC9B,IAAI,CAON"}
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../src/core/filter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAW,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,YAAY,EAAgB,KAAK,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEhF;;;;;;;;GAQG;AAEH,+EAA+E;AAC/E,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,SAAkB,IAAI,0BAA0B;CACjD;AAoDD,qDAAqD;AACrD,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAyC/C;AAID,8CAA8C;AAC9C,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAMlD;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,SAAS,EAAE,SAAS,EAAE,IAAI,EAAE,YAAY,GAAG,MAAM,GAAG,SAAS,CAItF;AAED;;;GAGG;AACH,wBAAgB,WAAW,IAAI,YAAY,CAE1C;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CACrB,SAAS,EAAE,SAAS,EACpB,IAAI,EAAE,YAAY,EAClB,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,GAC5B,IAAI,CAON"}

package/dist/core/filter.js

@@ -1,14 +1,14 @@
-var f = Object.defineProperty;
-var h = (r, t, e) => t in r ? f(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
-var p = (r, t, e) => h(r, typeof t != "symbol" ? t + "" : t, e);
-import { MosaicClient as y, clausePoints as O } from "@kanzo-tech/mosaic";
-class m extends Error {
+var m = Object.defineProperty;
+var O = (n, t, r) => t in n ? m(n, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : n[t] = r;
+var f = (n, t, r) => O(n, typeof t != "symbol" ? t + "" : t, r);
+import { MosaicClient as h, clausePoints as y } from "@kanzo-tech/mosaic";
+class A extends Error {
   constructor() {
     super(...arguments);
-    p(this, "name", "UntranslatableFilter");
+    f(this, "name", "UntranslatableFilter");
   }
 }
-const A = {
+const N = {
   "=": "=",
   "==": "=",
   "IS NOT DISTINCT FROM": "=",
@@ -18,82 +18,86 @@ const A = {
   "<=": "<=",
   ">": ">",
   ">=": ">="
-}, N = { "=": "=", "!=": "!=", "<": ">", "<=": ">=", ">": "<", ">=": "<=" }, s = (r) => {
-  throw new m(
-    `the graph cannot express this crossfilter clause as a filter on the corpus: ${String(r)}`
+}, g = { "=": "=", "!=": "!=", "<": ">", "<=": ">=", ">": "<", ">=": "<=" }, o = (n) => {
+  throw new A(
+    `the graph cannot express this crossfilter clause as a filter on the corpus: ${String(n)}`
   );
 };
-function o(r) {
-  const t = r;
+function s(n) {
+  const t = n;
   return (t == null ? void 0 : t.type) === "COLUMN_REF" && typeof t.name == "string" ? t.name : null;
 }
-function i(r) {
-  const t = r, e = (t == null ? void 0 : t.type) === "LITERAL" || (t == null ? void 0 : t.type) === "PARAM" ? t.value : s(r);
-  if (typeof e == "number" || typeof e == "bigint" || typeof e == "string" || typeof e == "boolean")
-    return e;
-  if (e instanceof Date) {
-    const n = e.toISOString();
-    return n.endsWith("T00:00:00.000Z") ? n.slice(0, 10) : n.replace("T", " ").replace("Z", "");
+function u(n) {
+  const t = n, r = (t == null ? void 0 : t.type) === "LITERAL" || (t == null ? void 0 : t.type) === "PARAM" ? t.value : o(n);
+  if (typeof r == "number" || typeof r == "bigint" || typeof r == "string" || typeof r == "boolean")
+    return r;
+  if (r instanceof Date) {
+    const e = r.toISOString();
+    return e.endsWith("T00:00:00.000Z") ? e.slice(0, 10) : e.replace("T", " ").replace("Z", "");
   }
-  return s(r);
+  return o(n);
 }
-function g(r) {
-  const t = r;
-  return (Array.isArray(r) ? r : Array.isArray(t == null ? void 0 : t.values) ? t.values : s(r)).map(i);
+function v(n) {
+  const t = n;
+  return (Array.isArray(n) ? n : Array.isArray(t == null ? void 0 : t.values) ? t.values : o(n)).map(u);
 }
-function l(r) {
-  const t = r;
-  if (Array.isArray(r)) return c(r.map(l));
+function c(n) {
+  const t = n;
+  if (Array.isArray(n)) return i(n.map(c));
   switch (t == null ? void 0 : t.type) {
     case "LOGICAL_OPERATOR": {
-      const e = (t.clauses ?? []).map(l);
-      return t.op === "OR" ? { or: e } : c(e);
+      const r = (t.clauses ?? []).map(c);
+      return t.op === "OR" ? { or: r } : i(r);
     }
     case "UNARY":
-      return t.op === "NOT" ? { not: l(t.expr) } : s(r);
+      return t.op === "NOT" ? { not: c(t.expr) } : o(n);
     case "UNARY_POSTFIX": {
-      const e = o(t.expr) ?? s(r);
-      return t.op === "IS NULL" ? { column: e, op: "is null" } : t.op === "IS NOT NULL" ? { column: e, op: "not null" } : s(r);
+      const r = s(t.expr) ?? o(n);
+      return t.op === "IS NULL" ? { column: r, op: "is null" } : t.op === "IS NOT NULL" ? { column: r, op: "not null" } : o(n);
     }
     case "BINARY": {
-      const e = A[String(t.op).toUpperCase()] ?? s(r), n = o(t.left);
-      return n !== null ? { column: n, op: e, value: i(t.right) } : { column: o(t.right) ?? s(r), op: N[e], value: i(t.left) };
+      const r = N[String(t.op).toUpperCase()] ?? o(n), e = s(t.left);
+      return e !== null ? { column: e, op: r, value: u(t.right) } : { column: s(t.right) ?? o(n), op: g[r], value: u(t.left) };
     }
     case "BETWEEN":
     case "NOT_BETWEEN": {
-      const e = o(t.expr) ?? s(r), [n, a] = t.extent ?? s(r), u = c([
-        { column: e, op: ">=", value: i(n) },
-        { column: e, op: "<=", value: i(a) }
+      const r = s(t.expr) ?? o(n), [e, a] = t.extent ?? o(n), p = i([
+        { column: r, op: ">=", value: u(e) },
+        { column: r, op: "<=", value: u(a) }
       ]);
-      return t.type === "BETWEEN" ? u : { not: u };
+      return t.type === "BETWEEN" ? p : { not: p };
     }
     case "IN":
-      return { column: o(t.expr) ?? s(r), op: "in", values: g(t.values) };
+      return { column: s(t.expr) ?? o(n), op: "in", values: v(t.values) };
     default:
-      return s(r);
+      return o(n);
   }
 }
-const c = (r) => r.length === 1 ? r[0] : { and: r };
-function R(r, t) {
-  const e = r.predicate(t), n = (Array.isArray(e) ? e : [e]).filter((a) => a != null);
-  return n.length === 0 ? void 0 : l(n);
+const i = (n) => n.length === 1 ? n[0] : { and: n };
+function l(n) {
+  return "column" in n ? [n.column] : "and" in n ? [...new Set(n.and.flatMap(l))] : "or" in n ? [...new Set(n.or.flatMap(l))] : "not" in n ? l(n.not) : [];
+}
+function S(n, t) {
+  const r = n.predicate(t), e = (Array.isArray(r) ? r : [r]).filter((a) => a != null);
+  return e.length === 0 ? void 0 : c(e);
 }
 function T() {
-  return new y();
+  return new h();
 }
-function I(r, t, e, n) {
-  r.update(
-    O([e], n && n.length > 0 ? n.map((a) => [a]) : void 0, {
+function I(n, t, r, e) {
+  n.update(
+    y([r], e && e.length > 0 ? e.map((a) => [a]) : void 0, {
       source: t,
       clients: /* @__PURE__ */ new Set([t])
     })
   );
 }
 export {
-  m as UntranslatableFilter,
-  R as filterFor,
+  A as UntranslatableFilter,
+  l as columnsOf,
+  S as filterFor,
   T as graphClient,
   I as publish,
-  l as translate
+  c as translate
 };
 //# sourceMappingURL=filter.js.map