@kanzo-tech/graph 0.10.0 → 0.11.0

package/README.md

@@ -1,116 +1,81 @@
 # @kanzo-tech/graph
 
-A GPU graph view over [cosmos.gl](https://cosmosgl.github.io/graph): the DuckDB relation that feeds
-it, the buffers that colour it from the page's own theme, and the hooks that own the renderer's
-lifetime.
-
-## What it is not
-
-**There is no `<GraphCanvas>`.** That is the shape of the package rather than a gap in it. A graph
-canvas is a toolbar, a legend, an inspector, a hover card and a search box wired to one renderer,
-and every one of those answers differently per product. What is genuinely shared sits underneath —
-reading a relation into typed arrays, turning a look and the live theme into GPU buffers, owning the
-renderer across React's lifecycle, and keeping a lasso inside a Mosaic crossfilter. Those are here.
-The arrangement belongs at the call site; `docs/showcases/workspace/graph-canvas.tsx` is one, and it
-is not the only possible one.
-
-## Why a package, and not part of `@kanzo-tech/ui`
-
-The [first admission rule](/docs/philosophy#admission) is *domain-free — nothing about RDF / SHACL / fossil / **graphs**
-/ auth*. Graphs are excluded by name, deliberately: `ui` is the generic vocabulary every product
-shares. A sibling package is also the only honest home for a **required** WebGL peer — as an
-optional peer of `ui` it would have been a lie about what the package is.
+The graph view over a [fossil](https://github.com/kanzo-tech/fossil) 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.
 
 ## Install
 
 ```sh
-pnpm add @kanzo-tech/graph @cosmos.gl/graph
+pnpm add @kanzo-tech/graph @cosmos.gl/graph @fossil-lang/corpus @kanzo-tech/mosaic @kanzo-tech/ui lucide-react @uwdata/mosaic-core @uwdata/mosaic-sql
 ```
 
-`@cosmos.gl/graph` is a required peer: this is a renderer, and there is nothing left of it without
-one. The Mosaic peers and fossil's corpus reader are **optional** — `openCorpus()` needs them and
-the rendering hooks do not.
-
-**So the root barrel draws nothing, and that is the shape rather than an oversight.** The reason for
-the split used to be *a host drawing arrays it already has should not pay for a database*, and that
-host no longer exists here: `memorySource` is deleted and this package sends **one** source, the
-corpus'. What the split protects now is a barrel that is a rendering surface — hooks, looks,
-identity, the buffers a slice implies — for a host whose slices arrive from somewhere else, its own
-`BoundedSource` included. A picture costs `@kanzo-tech/graph/duckdb`.
+Every peer is required. `@fossil-lang/corpus` reads the corpus, `@kanzo-tech/mosaic` is the page's one
+DuckDB-WASM engine and its crossfilter, cosmos.gl draws, and the parts are built from
+`@kanzo-tech/ui` and its icons.
 
-## The two halves
+## The one path
 
-**Data.** A **source** answers one question — *what should I draw* — and `useQueryLoop` asks it.
-The answer is a `Slice`: at most `limit` points as parallel typed arrays, whose size follows the
-question rather than the corpus. Moving the camera re-asks, and a window holding more than `limit`
-is **sampled** rather than truncated — one row every `ceil(matched / limit)` over the corpus'
-Morton-ordered `dense_id`, which spreads the marks over the window instead of drawing a corner of
-it. So a view of everything is still a few thousand marks, and they are still everywhere.
-
-`openCorpus` — on `@kanzo-tech/graph/duckdb`, because that is the half that needs Mosaic and
-fossil's reader — takes the corpus the host opened with fossil's `open` and the page's `engine()`,
-and hands back both halves: the source the canvas draws from, and the names fossil's verbs query
-the relations by, for the charts and the crossfilter.
-
-```ts
+```tsx
 import { open } from "@fossil-lang/corpus";
 import { engine } from "@kanzo-tech/mosaic";
-import { openCorpus } from "@kanzo-tech/graph/duckdb";
+import { GraphCanvas, GraphInspector, GraphLegend, GraphRoot, GraphToolbar } from "@kanzo-tech/graph";
+
+const corpus = engine().then((e) => open(url, { engine: e }));
 
-const e = await engine();
-const corpus = await open("/corpus/people", { query: e.query });
-const { source, nodes, edges } = await openCorpus({ corpus, engine: e });
+<GraphRoot corpus={corpus} fill="kind" r="degree" title="label" filterBy={crossfilter} onFailure={setFailure}>
+  <GraphCanvas>
+    <GraphToolbar />
+    <GraphLegend />
+  </GraphCanvas>
+  <GraphInspector />
+</GraphRoot>;
 ```
 
-Opening is the host's: a host whose files sit behind a signature opens the corpus under a name,
-`` open(`jobs/${id}`, { engine: e, host }) ``, and hands over the same `corpus`. Closing it is the
-host's too. It takes no column names and no type index; those come off the manifest or they do not come.
-Under `limit` it is asked once for everything and never again, so a corpus that fits pays for
-nothing.
-
-**A point is addressed by index and identified by pair.** cosmos.gl numbers points by their position
-in the arrays it was last handed, so index 7 is whatever the current answer put seventh. A vertex is
-therefore `vertexId(type, dense)` — a `bigint`, and `Slice.vertices` a `BigUint64Array`, because the
-pair is 64 bits and a `number` holds 53. Anything that outlives one answer is held as a `VertexId`
-and resolved through the `Resident` that `useQueryLoop` rebuilds per answer. Do not build a second
-map: a copy assembled beside it is the same value one render later, with no way to notice it has
-fallen behind the buffers on screen.
-
-**Appearance.** `buffers(slice, look, host)` turns a look and the *live theme* into per-point
-colours, sizes and shapes. A `Look` carries **geometry only** — colour comes from the page's
-categorical scale (`categoricalColor`, on the **root** barrel of `@kanzo-tech/ui` — not
-`/analytics`, so reaching it costs nobody the DuckDB peer set), because a scale a graph invents is a
-scale that disagrees with the legend explaining it.
-
-`appearance()` is the other side of that line and it matters for performance: everything that is
-*one number for the whole canvas* is a cosmos.gl **uniform**, read fresh on every draw. Multiply a
-slider into 500,000 sizes and every tick re-uploads the array; put it in a uniform and it costs
-nothing.
-
-## Scale
-
-Measured, not asserted — see the [benchmarks page](https://kanzo-tech.github.io/ui/docs/graph/benchmarks), and
-`/view/showcases/graph-bench` to re-run it.
-
-A live simulation is comfortable to about **50,000** points and finished by **200,000** (a step
-costs 62 ms there). A million points render, upload and simulate without failing, but at 440 ms a
-step. **Past 200,000 the honest design is positions computed once and stored as a column** — which
-is why a source names `xField` / `yField`, and why a simulation is off by default: the coordinates a
-source hands back are the index the next spatial question is asked against, and a force that moves
-them moves the picture out from under its own index.
-
-Bounded, over a corpus compiled once, first paint is **253 ms at a million** against the 1,225 ms it
-used to cost to hold two hundred thousand. What is drawn and transferred follows the window — the
-upload is flat at 23–30 ms and the redraw ceiling stays in the thousands of frames per second. What
-is *scanned* does not: the pan grows from 77 ms at a million to 256 ms at five, and the term that
-grows is the edge join, over one file on a DuckDB-WASM that gets a single thread. That is the next
-thing to fix, and it is the corpus layout, not the renderer.
+**Opening is the host's.** Where the corpus is and what signs it are the host's to say — a private
+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 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.
+
+**`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
+dropped. A lasso or a click publishes the reader's pick back into it, exempting the graph itself.
+
+## The pieces
+
+- `GraphRoot` — `useGraph` plus the context. `GraphRootProvider` takes an api a host built with
+  `useGraph`; `useGraphContext` reads it — Ark's four, one for one. The api is the commands and
+  never changes; `useGraphState(selector)` reads a slice of the state.
+- `GraphCanvas` — the element, the grid, the vignette, the labels, the hover card and the marquee
+  and lasso gesture. Children are chrome positioned over it.
+- `GraphLegend`, `GraphToolbar`, `GraphInspector` — the categorical scale with its tally, the
+  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.
+
+## Why a package, and not part of `@kanzo-tech/ui`
+
+The [first admission rule](https://kanzo-tech.github.io/ui/docs/philosophy#admission) is
+*domain-free — nothing about RDF / SHACL / fossil / **graphs** / auth*. Graphs are excluded by name,
+and a sibling package is the only honest home for a required WebGL peer.
 
 ## Gotchas the source will not tell you twice
 
 - **`setConfig` resets everything.** cosmos.gl 3.x resets the whole configuration to defaults and
   then applies the argument. Use `setConfigPartial`. This typechecks either way.
 - **`getConnectedLinkIndices` is not a neighbourhood.** It returns only links whose *other* endpoint
-  is also in the argument — an induced subgraph. Use `neighboursOf(graph, index)`.
-- **`requestAnimationFrame` never fires in a hidden tab**, and cosmos.gl drives its simulation from
-  rendered frames. A backgrounded graph is stopped, not slow.
+  is also in the argument. `getNeighboringPointIndices` is the neighbourhood.
+- **`requestAnimationFrame` never fires in a hidden tab**, and the renderer draws on animation
+  frames. A backgrounded graph is stopped, not slow.

package/dist/core/categories.d.ts

@@ -0,0 +1,12 @@
+import { Corpus } from '@fossil-lang/corpus';
+import { Binding } from './channels';
+/**
+ * **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.
+ */
+export declare function domainOf(corpus: Corpus | null, typeIndex: number, 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;
+//# sourceMappingURL=categories.d.ts.map

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

@@ -0,0 +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"}

package/dist/core/categories.js

@@ -0,0 +1,14 @@
+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) : [];
+}
+const d = (n, t) => (t == null ? void 0 : t[String(n)]) ?? String(n ?? "—");
+export {
+  a as domainOf,
+  d as nameOf
+};
+//# sourceMappingURL=categories.js.map

package/dist/core/categories.js.map

@@ -0,0 +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;"}

package/dist/core/channels.d.ts

@@ -0,0 +1,34 @@
+/**
+ * What each channel is bound to — Plot's names, and Plot's rule that **a CSS colour is a constant
+ * and anything else is a column.** `fill="kind"` spends colour on a category; `fill="var(--foreground)"`
+ * 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. */
+    fill?: string;
+    /**
+     * Which column a point's shape carries. A tile carries one categorical column, so bound beside a
+     * `fill` column this reads the same one; a second would need a second array everywhere.
+     */
+    symbol?: string;
+    /** What tints a link. Absent, a link takes the colour of the vertex it leaves. */
+    stroke?: string;
+}
+/** Narrow on purpose — `var(…)`, a hex, a colour function — so a bare word is always a column. */
+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. */
+    readonly category: string | undefined;
+    /** 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`. */
+    readonly title: string | undefined;
+}
+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[];
+//# sourceMappingURL=channels.d.ts.map

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

@@ -0,0 +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"}

package/dist/core/channels.js

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

package/dist/core/channels.js.map

@@ -0,0 +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;"}

package/dist/core/detail.d.ts

@@ -0,0 +1,18 @@
+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. */
+export interface VertexDetail {
+    readonly vertex: VertexId;
+    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.
+ */
+export declare function readVertex(corpus: Corpus, matrix: TileMatrixSet, vertex: VertexId, signal?: AbortSignal): Promise<VertexDetail | null>;
+//# sourceMappingURL=detail.d.ts.map

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

@@ -0,0 +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"}

package/dist/core/detail.js

@@ -0,0 +1,20 @@
+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 };
+    })
+  };
+}
+export {
+  S as readVertex
+};
+//# sourceMappingURL=detail.js.map

package/dist/core/detail.js.map

@@ -0,0 +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;"}

package/dist/core/filter.d.ts

@@ -0,0 +1,34 @@
+import { Filter } from '@fossil-lang/corpus';
+import { MosaicClient, Selection } from '@kanzo-tech/mosaic';
+/**
+ * **The page's crossfilter, as scan's typed filter.** The graph listens to the `Selection` rather
+ * than being a client of the coordinator: a client hands the coordinator SQL to run, and the graph
+ * has none — it hands fossil a `Filter` and fossil binds it. So this takes the half of Mosaic's
+ * protocol that is about filtering: the `value` event, and `selection.predicate(client)`.
+ *
+ * The nodes are read by their `type`, never by importing mosaic-sql's classes: what arrives is
+ * whatever the page's copy of mosaic-sql built.
+ */
+/** A predicate this cannot express as a `Filter` — reported, never dropped. */
+export declare class UntranslatableFilter extends Error {
+    readonly name = "UntranslatableFilter";
+}
+/** One mosaic-sql expression node → one `Filter`. */
+export declare function translate(node: unknown): Filter;
+/**
+ * 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.
+ */
+export declare function filterFor(selection: Selection, self: MosaicClient): Filter | undefined;
+/**
+ * An identity for `clients`, and nothing more: it is never connected, so the coordinator never
+ * queries on its behalf.
+ */
+export declare function graphClient(): MosaicClient;
+/**
+ * **The reader's pick, published** — naming the graph in `clients`, so the crossfilter skips it for
+ * 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;
+//# sourceMappingURL=filter.d.ts.map

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

@@ -0,0 +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"}

package/dist/core/filter.js

@@ -0,0 +1,99 @@
+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 {
+  constructor() {
+    super(...arguments);
+    p(this, "name", "UntranslatableFilter");
+  }
+}
+const A = {
+  "=": "=",
+  "==": "=",
+  "IS NOT DISTINCT FROM": "=",
+  "<>": "!=",
+  "!=": "!=",
+  "<": "<",
+  "<=": "<=",
+  ">": ">",
+  ">=": ">="
+}, N = { "=": "=", "!=": "!=", "<": ">", "<=": ">=", ">": "<", ">=": "<=" }, s = (r) => {
+  throw new m(
+    `the graph cannot express this crossfilter clause as a filter on the corpus: ${String(r)}`
+  );
+};
+function o(r) {
+  const t = r;
+  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", "");
+  }
+  return s(r);
+}
+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 l(r) {
+  const t = r;
+  if (Array.isArray(r)) return c(r.map(l));
+  switch (t == null ? void 0 : t.type) {
+    case "LOGICAL_OPERATOR": {
+      const e = (t.clauses ?? []).map(l);
+      return t.op === "OR" ? { or: e } : c(e);
+    }
+    case "UNARY":
+      return t.op === "NOT" ? { not: l(t.expr) } : s(r);
+    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);
+    }
+    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) };
+    }
+    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) }
+      ]);
+      return t.type === "BETWEEN" ? u : { not: u };
+    }
+    case "IN":
+      return { column: o(t.expr) ?? s(r), op: "in", values: g(t.values) };
+    default:
+      return s(r);
+  }
+}
+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);
+}
+function T() {
+  return new y();
+}
+function I(r, t, e, n) {
+  r.update(
+    O([e], n && n.length > 0 ? n.map((a) => [a]) : void 0, {
+      source: t,
+      clients: /* @__PURE__ */ new Set([t])
+    })
+  );
+}
+export {
+  m as UntranslatableFilter,
+  R as filterFor,
+  T as graphClient,
+  I as publish,
+  l as translate
+};
+//# sourceMappingURL=filter.js.map

package/dist/core/filter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.js","sources":["../../src/core/filter.ts"],"sourcesContent":["import type { Filter, Literal } from \"@fossil-lang/corpus\";\nimport { MosaicClient, clausePoints, type Selection } from \"@kanzo-tech/mosaic\";\n\n/**\n * **The page's crossfilter, as scan's typed filter.** The graph listens to the `Selection` rather\n * than being a client of the coordinator: a client hands the coordinator SQL to run, and the graph\n * has none — it hands fossil a `Filter` and fossil binds it. So this takes the half of Mosaic's\n * protocol that is about filtering: the `value` event, and `selection.predicate(client)`.\n *\n * The nodes are read by their `type`, never by importing mosaic-sql's classes: what arrives is\n * whatever the page's copy of mosaic-sql built.\n */\n\n/** A predicate this cannot express as a `Filter` — reported, never dropped. */\nexport class UntranslatableFilter extends Error {\n  override readonly name = \"UntranslatableFilter\";\n}\n\ninterface Node {\n  readonly type?: string;\n  readonly op?: string;\n  readonly [field: string]: unknown;\n}\n\nconst COMPARISONS: Record<string, \"=\" | \"!=\" | \"<\" | \"<=\" | \">\" | \">=\"> = {\n  \"=\": \"=\",\n  \"==\": \"=\",\n  \"IS NOT DISTINCT FROM\": \"=\",\n  \"<>\": \"!=\",\n  \"!=\": \"!=\",\n  \"<\": \"<\",\n  \"<=\": \"<=\",\n  \">\": \">\",\n  \">=\": \">=\",\n};\nconst MIRRORED = { \"=\": \"=\", \"!=\": \"!=\", \"<\": \">\", \"<=\": \">=\", \">\": \"<\", \">=\": \"<=\" } as const;\n\nconst fail = (what: unknown): never => {\n  throw new UntranslatableFilter(\n    `the graph cannot express this crossfilter clause as a filter on the corpus: ${String(what)}`,\n  );\n};\n\nfunction columnOf(node: unknown): string | null {\n  const n = node as Node | null;\n  if (n?.type === \"COLUMN_REF\" && typeof n.name === \"string\") return n.name;\n  return null;\n}\n\nfunction literalOf(node: unknown): Literal {\n  const n = node as Node | null;\n  const value = n?.type === \"LITERAL\" || n?.type === \"PARAM\" ? n.value : fail(node);\n  if (typeof value === \"number\" || typeof value === \"bigint\" || typeof value === \"string\" || typeof value === \"boolean\") {\n    return value;\n  }\n  if (value instanceof Date) {\n    const iso = value.toISOString();\n    return iso.endsWith(\"T00:00:00.000Z\") ? iso.slice(0, 10) : iso.replace(\"T\", \" \").replace(\"Z\", \"\");\n  }\n  return fail(node);\n}\n\nfunction valuesOf(node: unknown): Literal[] {\n  const n = node as Node | null;\n  const list = Array.isArray(node) ? node : Array.isArray(n?.values) ? n.values : fail(node);\n  return (list as unknown[]).map(literalOf);\n}\n\n/** One mosaic-sql expression node → one `Filter`. */\nexport function translate(node: unknown): Filter {\n  const n = node as Node | null;\n  if (Array.isArray(node)) return and(node.map(translate));\n  switch (n?.type) {\n    case \"LOGICAL_OPERATOR\": {\n      const clauses = ((n.clauses as unknown[] | undefined) ?? []).map(translate);\n      return n.op === \"OR\" ? { or: clauses } : and(clauses);\n    }\n    case \"UNARY\":\n      if (n.op === \"NOT\") return { not: translate(n.expr) };\n      return fail(node);\n    case \"UNARY_POSTFIX\": {\n      const column = columnOf(n.expr) ?? fail(node);\n      if (n.op === \"IS NULL\") return { column, op: \"is null\" };\n      if (n.op === \"IS NOT NULL\") return { column, op: \"not null\" };\n      return fail(node);\n    }\n    case \"BINARY\": {\n      const op = COMPARISONS[String(n.op).toUpperCase()] ?? fail(node);\n      const left = columnOf(n.left);\n      if (left !== null) return { column: left, op, value: literalOf(n.right) };\n      const right = columnOf(n.right) ?? fail(node);\n      return { column: right, op: MIRRORED[op], value: literalOf(n.left) };\n    }\n    case \"BETWEEN\":\n    case \"NOT_BETWEEN\": {\n      const column = columnOf(n.expr) ?? fail(node);\n      const [lo, hi] = (n.extent as unknown[] | undefined) ?? fail(node);\n      const within: Filter = and([\n        { column, op: \">=\", value: literalOf(lo) },\n        { column, op: \"<=\", value: literalOf(hi) },\n      ]);\n      return n.type === \"BETWEEN\" ? within : { not: within };\n    }\n    case \"IN\": {\n      const column = columnOf(n.expr) ?? fail(node);\n      return { column, op: \"in\", values: valuesOf(n.values) };\n    }\n    default:\n      return fail(node);\n  }\n}\n\nconst and = (clauses: Filter[]): Filter => (clauses.length === 1 ? (clauses[0] as Filter) : { and: clauses });\n\n/**\n * The page's filter for the graph, or `undefined` for none. `selection.predicate` skips the clause\n * the graph published itself, which is the exemption the next function takes back.\n */\nexport function filterFor(selection: Selection, self: MosaicClient): Filter | undefined {\n  const predicate = selection.predicate(self) as unknown;\n  const clauses = (Array.isArray(predicate) ? predicate : [predicate]).filter((p) => p !== undefined && p !== null);\n  return clauses.length === 0 ? undefined : translate(clauses);\n}\n\n/**\n * An identity for `clients`, and nothing more: it is never connected, so the coordinator never\n * queries on its behalf.\n */\nexport function graphClient(): MosaicClient {\n  return new MosaicClient();\n}\n\n/**\n * **The reader's pick, published** — naming the graph in `clients`, so the crossfilter skips it for\n * the graph and applies it to every chart. A canvas that draws only what survives would otherwise\n * answer a lasso of thirteen by removing the other 1,530.\n */\nexport function publish(\n  selection: Selection,\n  self: MosaicClient,\n  column: string,\n  dense: readonly number[] | null,\n): void {\n  selection.update(\n    clausePoints([column], dense && dense.length > 0 ? dense.map((d) => [d]) : undefined, {\n      source: self,\n      clients: new Set([self]),\n    }),\n  );\n}\n"],"names":["UntranslatableFilter","__publicField","COMPARISONS","MIRRORED","fail","what","columnOf","node","n","literalOf","value","iso","valuesOf","translate","and","clauses","column","op","left","lo","hi","within","filterFor","selection","self","predicate","p","graphClient","MosaicClient","publish","dense","clausePoints","d"],"mappings":"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"}

package/dist/core/refine.d.ts

@@ -0,0 +1,14 @@
+import { Tile } from './tile';
+/**
+ * deck.gl's `'best-available'` refinement — `updateTileStateDefault`, the only strategy.
+ *
+ * A selected tile with content is drawn. One without is covered by its nearest ancestor holding
+ * content, and failing that by whatever of its descendants holds some, so a pan never shows a hole.
+ * A parent is therefore drawn only while a selected child is loading: at rest every selected tile
+ * holds content and no stand-in is needed.
+ *
+ * "Holding content" rather than deck.gl's `isLoaded`, because a tile reloading for a new question
+ * keeps its old picture until the new one arrives.
+ */
+export declare function refine(tiles: Iterable<Tile>): void;
+//# sourceMappingURL=refine.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"refine.d.ts","sourceRoot":"","sources":["../../src/core/refine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC;;;;;;;;;;GAUG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,IAAI,CAAC,GAAG,IAAI,CAOlD"}

package/dist/core/refine.js

@@ -0,0 +1,20 @@
+function f(o) {
+  const n = [...o], e = /* @__PURE__ */ new Set();
+  for (const t of n)
+    t.isSelected && !c(t, e) && i(t, e);
+  for (const t of n) t.isVisible = e.has(t);
+}
+function c(o, n) {
+  for (let e = o; e; e = e.parent)
+    if (e.content)
+      return n.add(e), !0;
+  return !1;
+}
+function i(o, n) {
+  for (const e of o.children)
+    e.content ? n.add(e) : i(e, n);
+}
+export {
+  f as refine
+};
+//# sourceMappingURL=refine.js.map

package/dist/core/refine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"refine.js","sources":["../../src/core/refine.ts"],"sourcesContent":["import type { Tile } from \"./tile\";\n\n/**\n * deck.gl's `'best-available'` refinement — `updateTileStateDefault`, the only strategy.\n *\n * A selected tile with content is drawn. One without is covered by its nearest ancestor holding\n * content, and failing that by whatever of its descendants holds some, so a pan never shows a hole.\n * A parent is therefore drawn only while a selected child is loading: at rest every selected tile\n * holds content and no stand-in is needed.\n *\n * \"Holding content\" rather than deck.gl's `isLoaded`, because a tile reloading for a new question\n * keeps its old picture until the new one arrives.\n */\nexport function refine(tiles: Iterable<Tile>): void {\n  const all = [...tiles];\n  const visible = new Set<Tile>();\n  for (const tile of all) {\n    if (tile.isSelected && !inAncestors(tile, visible)) inDescendants(tile, visible);\n  }\n  for (const tile of all) tile.isVisible = visible.has(tile);\n}\n\nfunction inAncestors(start: Tile, visible: Set<Tile>): boolean {\n  for (let tile: Tile | null = start; tile; tile = tile.parent) {\n    if (tile.content) {\n      visible.add(tile);\n      return true;\n    }\n  }\n  return false;\n}\n\nfunction inDescendants(tile: Tile, visible: Set<Tile>): void {\n  for (const child of tile.children) {\n    if (child.content) visible.add(child);\n    else inDescendants(child, visible);\n  }\n}\n"],"names":["refine","tiles","all","visible","tile","inAncestors","inDescendants","start","child"],"mappings":"AAaO,SAASA,EAAOC,GAA6B;AAClD,QAAMC,IAAM,CAAC,GAAGD,CAAK,GACfE,wBAAc,IAAA;AACpB,aAAWC,KAAQF;AACjB,IAAIE,EAAK,cAAc,CAACC,EAAYD,GAAMD,CAAO,KAAGG,EAAcF,GAAMD,CAAO;AAEjF,aAAWC,KAAQF,EAAK,CAAAE,EAAK,YAAYD,EAAQ,IAAIC,CAAI;AAC3D;AAEA,SAASC,EAAYE,GAAaJ,GAA6B;AAC7D,WAASC,IAAoBG,GAAOH,GAAMA,IAAOA,EAAK;AACpD,QAAIA,EAAK;AACP,aAAAD,EAAQ,IAAIC,CAAI,GACT;AAGX,SAAO;AACT;AAEA,SAASE,EAAcF,GAAYD,GAA0B;AAC3D,aAAWK,KAASJ,EAAK;AACvB,IAAII,EAAM,UAASL,EAAQ,IAAIK,CAAK,IAC/BF,EAAcE,GAAOL,CAAO;AAErC;"}

package/dist/{resident.d.ts → core/resident.d.ts}

@@ -1,4 +1,3 @@
-import { Slice } from './bounded';
 /**
  * Who is drawn, and where the GPU is drawing them.
  *
@@ -52,7 +51,7 @@ export declare function denseOf(vertex: VertexId): number;
  *
  * Built once per residency change and never mutated, because that is what a residency change *is*: a
  * different set of vertices, in a different order. It belongs to whoever owns residency — that is
- * `useQueryLoop`, which holds the answer — and is read from there by everything else, because a
+ * the renderer, which composes the buffers — and is read from there by everything else, because a
  * second copy is a second copy that can disagree with the buffers on screen.
  */
 export interface Resident {
@@ -68,12 +67,13 @@ export interface Resident {
     verticesAt(indices: Iterable<number>): VertexId[];
 }
 /**
- * The map an answer implies. `null` — before the first answer — is nobody resident, not an error.
+ * The map a composition implies, over its first `size` slots. A composition puts its vertices
+ * first — then the cells, which have no identity, then the far ends drawn only so an edge has one —
+ * so nothing hovers, selects or frames a slot past them. Before the first composition nobody is
+ * resident, which is not an error.
  *
  * Keyed by the identity itself. `Map` and `Set` compare keys by SameValueZero, which for a `bigint`
- * is *value* equality and not reference equality — two separately-constructed `vertexId(0, 5)`
- * reach the same entry. That is asserted rather than assumed in `resident.test.ts`, because the
- * whole file rests on it and BigInt being an object-shaped primitive makes it a fair thing to doubt.
+ * is *value* equality — asserted in `resident.test.ts`, because the whole file rests on it.
  */
-export declare function residentOf(slice: Slice | null): Resident;
+export declare function residentOf(vertices?: BigUint64Array | null, size?: number): Resident;
 //# sourceMappingURL=resident.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resident.d.ts","sourceRoot":"","sources":["../../src/core/resident.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;GAaG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,OAAO,MAAM,CAAA;CAAE,CAAC;AAYnE,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,QAAQ,CAE9D;AAED,8FAA8F;AAC9F,wBAAgB,MAAM,CAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,CAE/C;AAED,wBAAgB,OAAO,CAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,CAEhD;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,QAAQ;IACvB,iCAAiC;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,uEAAuE;IACvE,OAAO,CAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,GAAG,SAAS,CAAC;IAC9C,0FAA0F;IAC1F,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;IACxC,+EAA+E;IAC/E,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,GAAG,MAAM,EAAE,CAAC;IAClD,+FAA+F;IAC/F,UAAU,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,QAAQ,EAAE,CAAC;CACnD;AAID;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,QAAQ,GAAE,cAAc,GAAG,IAAa,EAAE,IAAI,SAAwB,GAAG,QAAQ,CA6B3G"}