@kanzo-tech/graph 0.9.0 → 0.11.0

package/dist/core/resident.js

@@ -0,0 +1,44 @@
+const O = 32n, a = 0xffffffffn;
+function g(t, e) {
+  return BigInt(t) << O | BigInt(e);
+}
+function h(t) {
+  return Number(t >> O);
+}
+function l(t) {
+  return Number(t & a);
+}
+const x = new BigUint64Array(0);
+function p(t = x, e = (t == null ? void 0 : t.length) ?? 0) {
+  const r = t ?? x, i = Math.min(e, r.length), u = /* @__PURE__ */ new Map();
+  for (let n = 0; n < i; n++) u.set(r[n], n);
+  const c = (n) => n >= 0 && n < i ? r[n] : void 0, d = (n) => u.get(n);
+  return {
+    size: i,
+    indexOf: d,
+    at: c,
+    indicesOf(n) {
+      const o = [];
+      for (const s of n) {
+        const f = d(s);
+        f !== void 0 && o.push(f);
+      }
+      return o;
+    },
+    verticesAt(n) {
+      const o = [];
+      for (const s of n) {
+        const f = c(s);
+        f !== void 0 && o.push(f);
+      }
+      return o;
+    }
+  };
+}
+export {
+  l as denseOf,
+  p as residentOf,
+  h as typeOf,
+  g as vertexId
+};
+//# sourceMappingURL=resident.js.map

package/dist/core/resident.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resident.js","sources":["../../src/core/resident.ts"],"sourcesContent":["\n/**\n * Who is drawn, and where the GPU is drawing them.\n *\n * **A buffer index numbers the answer, not the corpus.** cosmos.gl addresses every point by its\n * position in the arrays it was last handed, so index 7 is whatever the current answer put seventh —\n * and a resident set that comes and goes reuses every index while the vertices behind them change.\n * Anything that outlives one answer — a selection, a label, a hover, a pin — therefore has to be\n * held as an identity and re-resolved against whatever is drawn now.\n *\n * **A vertex is the pair `(type_idx, dense_id)`.** Not `dense_id` alone: it numbers\n * within one vertex type, so a union of two types repeats every value and the same number names two\n * different vertices. A `LIMIT` breaks the correspondence between an id and a position regardless of\n * how many types there are.\n */\n\n/**\n * A vertex identity — the pair, packed into one 64-bit integer so it can key a `Map` and a `Set`.\n *\n * **A `bigint`, which is strictly stronger than the brand it also wears.** A buffer index is a\n * `number`; an identity is a `bigint`. Confusing the two therefore stops being a branding\n * convention that holds while everyone remembers it and becomes a *primitive* type error — and no\n * cast quietly launders one: `7 as VertexId` was legal against `number & brand` and is a compile\n * error against `bigint & brand`. Getting one wrong now costs `as unknown as`, which is loud.\n *\n * **The evidence this is worth the friction, because it is not a precaution we invented.** Across\n * every multi-language format surveyed — Arrow, Parquet, Iceberg, Delta, MVT, PMTiles, Zarr,\n * GraphAr, H3, S2 — the failure that recurs is a 64-bit value crossing into JavaScript.\n * `mapbox/node-s2` is a **binding**, not a port: it calls the same C++ the reference implementation\n * does, and it still returned wrong cell ids — issue #92, open since 2017, `1152921504606847000`\n * where Java and Go both give `1152921504606846977`. JavaScript's `number` is 53 bits and a cell id\n * is 64, and a binding cannot protect a language boundary that cannot hold the value. H3 settled it\n * by decree before anyone could get it wrong: `h3-js` types `H3Index` as a string. This is the same\n * decree with the type JavaScript grew for it.\n *\n * **And `>>` means three different things across our three layers.** In JavaScript it converts its\n * operand to *32 bits* and takes the shift count modulo 32, so the obvious `dense | (type << 32)`\n * is not a lost high word — it is `type | dense`, silently. The packing below cannot be written on\n * `number` at all and be right.\n *\n * What goes to the GPU does not change: positions and buffer indices stay `number` and\n * `Float32Array`. The conversion happens at the edge, which is where it belongs.\n */\nexport type VertexId = bigint & { readonly vertex: unique symbol };\n\n/**\n * One type's worth of dense ids.\n *\n * `dense_id` is a `UInt32`, so the type index occupies everything above bit 32 — exactly, for all\n * 2³² of them, which is the whole point of the width. The old packing was `type * 2**32 + dense` in\n * `float64` and ran out of exactness at type index 2²¹.\n */\nconst TYPE_SHIFT = 32n;\nconst DENSE_MASK = 0xffff_ffffn;\n\nexport function vertexId(type: number, dense: number): VertexId {\n  return ((BigInt(type) << TYPE_SHIFT) | BigInt(dense)) as VertexId;\n}\n\n/** Both halves come back as `number`: each is 32 bits, and a `number` holds those exactly. */\nexport function typeOf(vertex: VertexId): number {\n  return Number(vertex >> TYPE_SHIFT);\n}\n\nexport function denseOf(vertex: VertexId): number {\n  return Number(vertex & DENSE_MASK);\n}\n\n/**\n * The identity↔index map for whatever is drawn right now.\n *\n * Built once per residency change and never mutated, because that is what a residency change *is*: a\n * different set of vertices, in a different order. It belongs to whoever owns residency — that is\n * the renderer, which composes the buffers — and is read from there by everything else, because a\n * second copy is a second copy that can disagree with the buffers on screen.\n */\nexport interface Resident {\n  /** How many points are drawn. */\n  readonly size: number;\n  /** Where a vertex is drawn, or `undefined` when it is not resident. */\n  indexOf(vertex: VertexId): number | undefined;\n  /** Which vertex is drawn at a buffer index, or `undefined` past the end of the answer. */\n  at(index: number): VertexId | undefined;\n  /** Where these vertices are drawn, skipping every one that is not resident. */\n  indicesOf(vertices: Iterable<VertexId>): number[];\n  /** Which vertices are drawn at these buffer indices, skipping any the answer does not hold. */\n  verticesAt(indices: Iterable<number>): VertexId[];\n}\n\nconst NOBODY = new BigUint64Array(0);\n\n/**\n * The map a composition implies, over its first `size` slots. A composition puts its vertices\n * first — then the cells, which have no identity, then the far ends drawn only so an edge has one —\n * so nothing hovers, selects or frames a slot past them. Before the first composition nobody is\n * resident, which is not an error.\n *\n * Keyed by the identity itself. `Map` and `Set` compare keys by SameValueZero, which for a `bigint`\n * is *value* equality — asserted in `resident.test.ts`, because the whole file rests on it.\n */\nexport function residentOf(vertices: BigUint64Array | null = NOBODY, size = vertices?.length ?? 0): Resident {\n  const all = vertices ?? NOBODY;\n  const drawn = Math.min(size, all.length);\n  const index = new Map<bigint, number>();\n  for (let i = 0; i < drawn; i++) index.set(all[i] as bigint, i);\n  const at = (i: number): VertexId | undefined => (i >= 0 && i < drawn ? (all[i] as VertexId) : undefined);\n  const indexOf = (vertex: VertexId): number | undefined => index.get(vertex);\n\n  return {\n    size: drawn,\n    indexOf,\n    at,\n    indicesOf(wanted) {\n      const found: number[] = [];\n      for (const vertex of wanted) {\n        const i = indexOf(vertex);\n        if (i !== undefined) found.push(i);\n      }\n      return found;\n    },\n    verticesAt(indices) {\n      const found: VertexId[] = [];\n      for (const i of indices) {\n        const vertex = at(i);\n        if (vertex !== undefined) found.push(vertex);\n      }\n      return found;\n    },\n  };\n}\n"],"names":["TYPE_SHIFT","DENSE_MASK","vertexId","type","dense","typeOf","vertex","denseOf","NOBODY","residentOf","vertices","size","all","drawn","index","i","at","indexOf","wanted","found","indices"],"mappings":"AAoDA,MAAMA,IAAa,KACbC,IAAa;AAEZ,SAASC,EAASC,GAAcC,GAAyB;AAC9D,SAAS,OAAOD,CAAI,KAAKH,IAAc,OAAOI,CAAK;AACrD;AAGO,SAASC,EAAOC,GAA0B;AAC/C,SAAO,OAAOA,KAAUN,CAAU;AACpC;AAEO,SAASO,EAAQD,GAA0B;AAChD,SAAO,OAAOA,IAASL,CAAU;AACnC;AAuBA,MAAMO,IAAS,IAAI,eAAe,CAAC;AAW5B,SAASC,EAAWC,IAAkCF,GAAQG,KAAOD,KAAA,gBAAAA,EAAU,WAAU,GAAa;AAC3G,QAAME,IAAMF,KAAYF,GAClBK,IAAQ,KAAK,IAAIF,GAAMC,EAAI,MAAM,GACjCE,wBAAY,IAAA;AAClB,WAASC,IAAI,GAAGA,IAAIF,GAAOE,OAAW,IAAIH,EAAIG,CAAC,GAAaA,CAAC;AAC7D,QAAMC,IAAK,CAACD,MAAqCA,KAAK,KAAKA,IAAIF,IAASD,EAAIG,CAAC,IAAiB,QACxFE,IAAU,CAACX,MAAyCQ,EAAM,IAAIR,CAAM;AAE1E,SAAO;AAAA,IACL,MAAMO;AAAA,IACN,SAAAI;AAAA,IACA,IAAAD;AAAA,IACA,UAAUE,GAAQ;AAChB,YAAMC,IAAkB,CAAA;AACxB,iBAAWb,KAAUY,GAAQ;AAC3B,cAAMH,IAAIE,EAAQX,CAAM;AACxB,QAAIS,MAAM,UAAWI,EAAM,KAAKJ,CAAC;AAAA,MACnC;AACA,aAAOI;AAAA,IACT;AAAA,IACA,WAAWC,GAAS;AAClB,YAAMD,IAAoB,CAAA;AAC1B,iBAAWJ,KAAKK,GAAS;AACvB,cAAMd,IAASU,EAAGD,CAAC;AACnB,QAAIT,MAAW,UAAWa,EAAM,KAAKb,CAAM;AAAA,MAC7C;AACA,aAAOa;AAAA,IACT;AAAA,EAAA;AAEJ;"}

package/dist/core/scheduler.d.ts

@@ -0,0 +1,42 @@
+/**
+ * loaders.gl's `RequestScheduler`, issuing a **batch** where it issues a request, with one slot:
+ * DuckDB-WASM is one worker behind one port, so a second statement queues behind the first rather
+ * than overlapping it, and fossil reads a run of consecutive tiles as one statement only when it is
+ * handed them in one call (`/docs/design/graph`, *one batch in flight*).
+ *
+ * Priorities are asked again each time a slot frees, the debounce settles or `prune` runs. A negative
+ * priority is a request nobody wants any more: queued, it resolves `null` without ever being issued;
+ * in flight, its batch is aborted only once no request in it is wanted — a batch that still answers
+ * someone finishes, and answers everyone in it.
+ */
+/** A request's answer, its batch's failure, or `null` when it was never issued or was aborted. */
+export type Outcome<R> = {
+    readonly value: R;
+} | {
+    readonly error: unknown;
+} | null;
+export interface SchedulerOptions<T, R> {
+    /** One call for a batch: an answer per handle, in the order given. */
+    run: (handles: readonly T[], signal: AbortSignal) => Promise<readonly R[]>;
+    /** Batches running at once. */
+    maxRequests?: number;
+    /** Quiet time, in milliseconds, before the queue is issued — a pan settles before it asks. */
+    debounceTime?: number;
+}
+export declare class RequestScheduler<T, R> {
+    #private;
+    constructor({ debounceTime, maxRequests, run }: SchedulerOptions<T, R>);
+    schedule(handle: T, priority: (handle: T) => number): Promise<Outcome<R>>;
+    /** How many requests are queued, and how many batches are running. */
+    get size(): {
+        queued: number;
+        active: number;
+    };
+    /** The caller no longer wants `handle`'s answer: it resolves `null` now, wherever it is. */
+    cancel(handle: T): void;
+    /** Drops queued requests nobody wants, and aborts a batch in which nobody wants anything. */
+    prune(): void;
+    /** Every queued request resolves `null`, and every running batch is aborted. */
+    clear(): void;
+}
+//# sourceMappingURL=scheduler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../../src/core/scheduler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,kGAAkG;AAClG,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI;IAAE,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CAAC;AAepF,MAAM,WAAW,gBAAgB,CAAC,CAAC,EAAE,CAAC;IACpC,sEAAsE;IACtE,GAAG,EAAE,CAAC,OAAO,EAAE,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;IAC3E,+BAA+B;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,8FAA8F;IAC9F,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,qBAAa,gBAAgB,CAAC,CAAC,EAAE,CAAC;;gBAQpB,EAAE,YAAgB,EAAE,WAAe,EAAE,GAAG,EAAE,EAAE,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC;IAM9E,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAOzE,sEAAsE;IACtE,IAAI,IAAI,IAAI;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAE7C;IAED,4FAA4F;IAC5F,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI;IAgBvB,6FAA6F;IAC7F,KAAK,IAAI,IAAI;IAYb,gFAAgF;IAChF,KAAK,IAAI,IAAI;CA4Cd"}

package/dist/core/scheduler.js

@@ -0,0 +1,77 @@
+var v = (i) => {
+  throw TypeError(i);
+};
+var y = (i, t, e) => t.has(i) || v("Cannot " + e);
+var s = (i, t, e) => (y(i, t, "read from private field"), e ? e.call(i) : t.get(i)), a = (i, t, e) => t.has(i) ? v("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(i) : t.set(i, e), n = (i, t, e, r) => (y(i, t, "write to private field"), r ? r.call(i, e) : t.set(i, e), e), p = (i, t, e) => (y(i, t, "access private method"), e);
+var g, w, m, l, o, h, u, q, b, z;
+class x {
+  constructor({ debounceTime: t = 0, maxRequests: e = 1, run: r }) {
+    a(this, u);
+    a(this, g);
+    a(this, w);
+    a(this, m);
+    a(this, l, []);
+    a(this, o, /* @__PURE__ */ new Set());
+    a(this, h, null);
+    n(this, g, r), n(this, w, e), n(this, m, t);
+  }
+  schedule(t, e) {
+    return new Promise((r) => {
+      s(this, l).push({ handle: t, priority: e, resolve: r, settled: !1, dropped: !1 }), p(this, u, q).call(this);
+    });
+  }
+  /** How many requests are queued, and how many batches are running. */
+  get size() {
+    return { queued: s(this, l).length, active: s(this, o).size };
+  }
+  /** The caller no longer wants `handle`'s answer: it resolves `null` now, wherever it is. */
+  cancel(t) {
+    n(this, l, s(this, l).filter((e) => e.handle !== t ? !0 : (f(e, null), !1)));
+    for (const e of s(this, o))
+      for (const r of e.requests)
+        r.handle === t && (r.dropped = !0, f(r, null));
+    this.prune();
+  }
+  /** Drops queued requests nobody wants, and aborts a batch in which nobody wants anything. */
+  prune() {
+    n(this, l, s(this, l).filter((t) => t.priority(t.handle) >= 0 ? !0 : (f(t, null), !1)));
+    for (const t of s(this, o))
+      t.requests.some((r) => !r.dropped && r.priority(r.handle) >= 0) || t.controller.abort();
+  }
+  /** Every queued request resolves `null`, and every running batch is aborted. */
+  clear() {
+    s(this, h) !== null && clearTimeout(s(this, h)), n(this, h, null);
+    for (const t of s(this, l)) f(t, null);
+    n(this, l, []);
+    for (const t of s(this, o)) t.controller.abort();
+  }
+}
+g = new WeakMap(), w = new WeakMap(), m = new WeakMap(), l = new WeakMap(), o = new WeakMap(), h = new WeakMap(), u = new WeakSet(), q = function() {
+  s(this, h) !== null && clearTimeout(s(this, h)), n(this, h, setTimeout(() => {
+    n(this, h, null), p(this, u, b).call(this);
+  }, s(this, m)));
+}, b = function() {
+  if (this.prune(), s(this, o).size >= s(this, w) || s(this, l).length === 0) return;
+  const t = s(this, l).map((e) => ({ request: e, priority: e.priority(e.handle) }));
+  t.sort((e, r) => e.priority - r.priority), n(this, l, []), p(this, u, z).call(this, { requests: t.map(({ request: e }) => e), controller: new AbortController() });
+}, z = async function(t) {
+  s(this, o).add(t);
+  const { controller: e, requests: r } = t;
+  try {
+    const c = await s(this, g).call(this, r.map((d) => d.handle), e.signal);
+    if (c.length !== r.length)
+      throw new Error(`a batch of ${r.length} was answered with ${c.length}`);
+    r.forEach((d, T) => f(d, e.signal.aborted ? null : { value: c[T] }));
+  } catch (c) {
+    for (const d of r) f(d, e.signal.aborted ? null : { error: c });
+  } finally {
+    s(this, o).delete(t), s(this, l).length > 0 && p(this, u, b).call(this);
+  }
+};
+function f(i, t) {
+  i.settled || (i.settled = !0, i.resolve(t));
+}
+export {
+  x as RequestScheduler
+};
+//# sourceMappingURL=scheduler.js.map

package/dist/core/scheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.js","sources":["../../src/core/scheduler.ts"],"sourcesContent":["/**\n * loaders.gl's `RequestScheduler`, issuing a **batch** where it issues a request, with one slot:\n * DuckDB-WASM is one worker behind one port, so a second statement queues behind the first rather\n * than overlapping it, and fossil reads a run of consecutive tiles as one statement only when it is\n * handed them in one call (`/docs/design/graph`, *one batch in flight*).\n *\n * Priorities are asked again each time a slot frees, the debounce settles or `prune` runs. A negative\n * priority is a request nobody wants any more: queued, it resolves `null` without ever being issued;\n * in flight, its batch is aborted only once no request in it is wanted — a batch that still answers\n * someone finishes, and answers everyone in it.\n */\n\n/** A request's answer, its batch's failure, or `null` when it was never issued or was aborted. */\nexport type Outcome<R> = { readonly value: R } | { readonly error: unknown } | null;\n\ninterface Request<T, R> {\n  readonly handle: T;\n  readonly priority: (handle: T) => number;\n  readonly resolve: (outcome: Outcome<R>) => void;\n  settled: boolean;\n  dropped: boolean;\n}\n\ninterface Flight<T, R> {\n  readonly requests: readonly Request<T, R>[];\n  readonly controller: AbortController;\n}\n\nexport interface SchedulerOptions<T, R> {\n  /** One call for a batch: an answer per handle, in the order given. */\n  run: (handles: readonly T[], signal: AbortSignal) => Promise<readonly R[]>;\n  /** Batches running at once. */\n  maxRequests?: number;\n  /** Quiet time, in milliseconds, before the queue is issued — a pan settles before it asks. */\n  debounceTime?: number;\n}\n\nexport class RequestScheduler<T, R> {\n  readonly #run: SchedulerOptions<T, R>[\"run\"];\n  readonly #max: number;\n  readonly #debounce: number;\n  #queue: Request<T, R>[] = [];\n  #flights = new Set<Flight<T, R>>();\n  #timer: ReturnType<typeof setTimeout> | null = null;\n\n  constructor({ debounceTime = 0, maxRequests = 1, run }: SchedulerOptions<T, R>) {\n    this.#run = run;\n    this.#max = maxRequests;\n    this.#debounce = debounceTime;\n  }\n\n  schedule(handle: T, priority: (handle: T) => number): Promise<Outcome<R>> {\n    return new Promise((resolve) => {\n      this.#queue.push({ handle, priority, resolve, settled: false, dropped: false });\n      this.#wake();\n    });\n  }\n\n  /** How many requests are queued, and how many batches are running. */\n  get size(): { queued: number; active: number } {\n    return { queued: this.#queue.length, active: this.#flights.size };\n  }\n\n  /** The caller no longer wants `handle`'s answer: it resolves `null` now, wherever it is. */\n  cancel(handle: T): void {\n    this.#queue = this.#queue.filter((request) => {\n      if (request.handle !== handle) return true;\n      settle(request, null);\n      return false;\n    });\n    for (const flight of this.#flights) {\n      for (const request of flight.requests) {\n        if (request.handle !== handle) continue;\n        request.dropped = true;\n        settle(request, null);\n      }\n    }\n    this.prune();\n  }\n\n  /** Drops queued requests nobody wants, and aborts a batch in which nobody wants anything. */\n  prune(): void {\n    this.#queue = this.#queue.filter((request) => {\n      if (request.priority(request.handle) >= 0) return true;\n      settle(request, null);\n      return false;\n    });\n    for (const flight of this.#flights) {\n      const wanted = flight.requests.some((r) => !r.dropped && r.priority(r.handle) >= 0);\n      if (!wanted) flight.controller.abort();\n    }\n  }\n\n  /** Every queued request resolves `null`, and every running batch is aborted. */\n  clear(): void {\n    if (this.#timer !== null) clearTimeout(this.#timer);\n    this.#timer = null;\n    for (const request of this.#queue) settle(request, null);\n    this.#queue = [];\n    for (const flight of this.#flights) flight.controller.abort();\n  }\n\n  #wake(): void {\n    if (this.#timer !== null) clearTimeout(this.#timer);\n    this.#timer = setTimeout(() => {\n      this.#timer = null;\n      this.#issue();\n    }, this.#debounce);\n  }\n\n  #issue(): void {\n    this.prune();\n    if (this.#flights.size >= this.#max || this.#queue.length === 0) return;\n    const ranked = this.#queue.map((request) => ({ request, priority: request.priority(request.handle) }));\n    ranked.sort((a, b) => a.priority - b.priority);\n    this.#queue = [];\n    void this.#fly({ requests: ranked.map(({ request }) => request), controller: new AbortController() });\n  }\n\n  async #fly(flight: Flight<T, R>): Promise<void> {\n    this.#flights.add(flight);\n    const { controller, requests } = flight;\n    try {\n      const answers = await this.#run(\n        requests.map((request) => request.handle),\n        controller.signal,\n      );\n      if (answers.length !== requests.length) {\n        throw new Error(`a batch of ${requests.length} was answered with ${answers.length}`);\n      }\n      requests.forEach((request, i) => settle(request, controller.signal.aborted ? null : { value: answers[i] as R }));\n    } catch (error) {\n      for (const request of requests) settle(request, controller.signal.aborted ? null : { error });\n    } finally {\n      this.#flights.delete(flight);\n      if (this.#queue.length > 0) this.#issue();\n    }\n  }\n}\n\nfunction settle<T, R>(request: Request<T, R>, outcome: Outcome<R>): void {\n  if (request.settled) return;\n  request.settled = true;\n  request.resolve(outcome);\n}\n"],"names":["_run","_max","_debounce","_queue","_flights","_timer","_RequestScheduler_instances","wake_fn","issue_fn","fly_fn","RequestScheduler","debounceTime","maxRequests","run","__privateAdd","__privateSet","handle","priority","resolve","__privateGet","__privateMethod","request","settle","flight","ranked","a","b","controller","requests","answers","i","error","outcome"],"mappings":"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"}

package/dist/core/state.d.ts

@@ -0,0 +1,132 @@
+import { Corpus, Gap, TileAddress, TileMatrixSet } from '@fossil-lang/corpus';
+import { Selection as Crossfilter } from '@kanzo-tech/mosaic';
+import { LookPatch } from '../render/graph-looks';
+import { Sim } from '../render/graph-sim';
+import { Binding, Channels } from './channels';
+import { VertexId } from './resident';
+import { TileContent } from './tile';
+import { Viewport } from './tile-matrix';
+import { Motion, Selection, SelectionSource, Tool } from './types';
+export interface GraphOptions extends Channels {
+    /**
+     * The corpus the host opened with fossil's `open`, or the promise of it. A promise is what makes
+     * *opening* a state the graph can report; `null` is no corpus at all.
+     */
+    corpus: Corpus | PromiseLike<Corpus> | null;
+    /** The vertex type drawn. The first type with a position when absent. */
+    type?: string;
+    /** Which column the size ramp is spent on — Plot's `r`. */
+    r?: string;
+    /** Which column a label and the hover card show — Plot's `title`. */
+    title?: string;
+    /**
+     * What the categorical channel's values are called, keyed by value. For a column the manifest's
+     * `channels:` declares, the ordinals rank themselves and this only names them; for one it does not,
+     * the keys' order is also the rank, so a colour never moves because a tile arrived.
+     */
+    categories?: Readonly<Record<string, string>>;
+    /** The page's crossfilter: its clauses filter what is read, and the reader's pick is published into it. */
+    filterBy?: Crossfilter;
+    /** The most marks drawn at once; a coarser zoom is chosen above it. */
+    limit?: number;
+    /** Form: a patch over this package's own look. Memoise it — its identity is what repaints. */
+    look?: LookPatch;
+    /** The force coefficients, as a patch over this package's own. */
+    sim?: Partial<Sim>;
+    /** A live layout. Off: a corpus's positions are the index every read is asked against. */
+    simulate?: boolean;
+    /** Required: unhandled, a browser with no WebGL context shows an empty box. */
+    onFailure: (message: string) => void;
+    onSelect?: (selection: Selection | null) => void;
+    onFocus?: (vertex: VertexId | null) => void;
+}
+/**
+ * Where the graph is in its life. `none` is no corpus; `opening` is a corpus promised and not yet
+ * open; `reading` is a tile in view not yet read or not yet drawn; `idle` is everything in view
+ * drawn; `failed` is a corpus that would not open, a type it cannot draw, or a canvas that could not
+ * start a renderer.
+ */
+export type GraphStatus = "none" | "opening" | "reading" | "idle" | "failed";
+/** What is on the canvas, as the renderer composed it. */
+export interface Drawn {
+    /** Points drawn — vertices and cells. */
+    readonly marks: number;
+    /** Vertices those marks stand for: a cell counts its members. */
+    readonly represented: number;
+    /** What each category rank is: the declared or named values first, then any other seen, in rank order. */
+    readonly domain: readonly unknown[];
+    /** Per rank, the vertices drawn marks stand for. */
+    readonly tally: readonly number[];
+}
+/** What a host and the parts read, through `useGraphState`. */
+export interface GraphState {
+    readonly status: GraphStatus;
+    /** Vertices of the drawn type, from the manifest — it does not shrink with a filter. */
+    readonly total: number | undefined;
+    /** The zoom drawn, coarsest `0`; the payload is the last. */
+    readonly z: number | null;
+    /** Whether a tile in view is still being read. */
+    readonly pending: boolean;
+    /** What is on the canvas, or `null` before the first composition. */
+    readonly drawn: Drawn | null;
+    /** The categorical domain before anything is drawn: the manifest's ordinals, or the host's names. */
+    readonly domain: readonly unknown[];
+    readonly selection: Selection | null;
+    readonly focus: VertexId | null;
+    readonly hovered: VertexId | null;
+    readonly pinned: readonly VertexId[];
+    readonly tool: Tool;
+    readonly motion: Motion;
+    /** How far through settling a live layout is, `0`–`1`. */
+    readonly progress: number;
+    /** Relations the corpus declined to answer, with fossil's reason. */
+    readonly declined: readonly Gap[];
+    /** The options as given, with the corpus once it is open. */
+    readonly options: GraphOptions;
+    readonly corpus: Corpus | null;
+}
+/** One tile the picture is made of: where it is, and what it holds. */
+export interface TileView {
+    readonly address: TileAddress;
+    readonly kind: "rows" | "cells";
+    readonly content: TileContent;
+}
+/** The state, plus what only the renderer reads. */
+export interface GraphSnapshot extends GraphState {
+    readonly matrix: TileMatrixSet | null;
+    /** The drawn type's position in `corpus.types.vertices` — the type half of a `VertexId`. */
+    readonly typeIndex: number;
+    readonly binding: Binding;
+    /** The payload column a cell's `mode` is the majority of, or `null` where the tree names none. */
+    readonly modeColumn: string | null;
+    /** Tiles drawn now; the same array until the set changes. */
+    readonly visible: readonly TileView[];
+    /** Every tile holding content — where a far end is looked up. */
+    readonly cached: readonly TileView[];
+}
+/**
+ * **The graph's state, outside React** — TanStack Query's `QueryObserver` shape: `subscribe`,
+ * `getSnapshot`, `setOptions`, `destroy`. The snapshot is a new object only when something a reader
+ * can see changed, and the same object between notifications.
+ */
+export interface GraphStore {
+    subscribe(listener: () => void): () => void;
+    getSnapshot(): GraphSnapshot;
+    getOptions(): GraphOptions;
+    setOptions(options: GraphOptions): void;
+    destroy(): void;
+    /** The camera, from the renderer: the rectangle in view. */
+    setViewport(viewport: Viewport): void;
+    select(vertices: readonly VertexId[] | null, source?: SelectionSource, label?: string): void;
+    focus(vertex: VertexId | null): void;
+    hover(vertex: VertexId | null): void;
+    pin(vertices: readonly VertexId[]): void;
+    setTool(tool: Tool): void;
+    report(motion: Motion): void;
+    reportProgress(value: number): void;
+    /** Whether the canvas has a renderer: without one nothing in view will ever be drawn. */
+    setRenderable(renderable: boolean): void;
+    /** The renderer drew `visible`; `drawn` is what it composed, or `null` when the set was unchanged. */
+    reportDrawn(visible: readonly TileView[], drawn: Drawn | null): void;
+}
+//# sourceMappingURL=state.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/core/state.ts"],"names":[],"mappings":"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"}

package/dist/core/store.d.ts

@@ -0,0 +1,6 @@
+import { GraphOptions, GraphStore } from './state';
+export type { Drawn, GraphOptions, GraphSnapshot, GraphState, GraphStatus, GraphStore, TileView } from './state';
+/** Twenty thousand marks: what a canvas draws at once before a coarser zoom is chosen. */
+export declare const DEFAULT_LIMIT = 20000;
+export declare function createGraph(initial: GraphOptions): GraphStore;
+//# sourceMappingURL=store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/core/store.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,YAAY,EAA8B,UAAU,EAAY,MAAM,SAAS,CAAC;AAK9F,YAAY,EAAE,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEjH,0FAA0F;AAC1F,eAAO,MAAM,aAAa,QAAS,CAAC;AAwBpC,wBAAgB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,UAAU,CA6T7D"}

package/dist/core/store.js

@@ -0,0 +1,235 @@
+import { PAYLOAD_ADDRESS as te, PAYLOAD_COORDINATES as ne } from "@fossil-lang/corpus";
+import { domainOf as re } from "./categories.js";
+import { bindingOf as Y, projectionOf as oe } from "./channels.js";
+import { graphClient as le, publish as ie, filterFor as se } from "./filter.js";
+import { denseOf as ce } from "./resident.js";
+import { Tileset2D as fe } from "./tileset.js";
+const R = 2e4, q = Y({}), H = te[0];
+function de(i) {
+  var m;
+  let n = 0;
+  for (const s of i.edges) n += s.src.byteLength + s.dst.byteLength + (((m = s.weight) == null ? void 0 : m.byteLength) ?? 0);
+  return n + i.rows.numRows * 8 * 4;
+}
+const ue = (i, n) => JSON.stringify(i, (m, s) => typeof s == "bigint" ? `${s}n` : s) === JSON.stringify(n, (m, s) => typeof s == "bigint" ? `${s}n` : s), ae = (i) => typeof (i == null ? void 0 : i.then) == "function";
+function Q(i, n) {
+  return i.length !== n.length ? n : n.every((m, s) => {
+    var o;
+    return m.content === ((o = i[s]) == null ? void 0 : o.content);
+  }) ? i : n;
+}
+function be(i) {
+  let n = i;
+  const m = /* @__PURE__ */ new Set(), s = le();
+  let o = null, b = null, M = !1, C = !1, u = null, T = 0, G = null, O = null, g = q, F, z = null, E = [], S = null, h = null, B = !1, J = -1;
+  const D = (e) => {
+    n.onFailure(e instanceof Error ? e.message : String(e));
+  }, a = new fe({
+    debounceTime: 60,
+    load: async (e, t) => {
+      if (!o || !O) throw new Error("the graph has no scan to read with");
+      const r = (d) => {
+        var w;
+        return ((w = u == null ? void 0 : u.tileMatrices[d.z]) == null ? void 0 : w.kind) === "cells";
+      }, l = await O.read(e, { signal: t }), y = await o.edges({ from: e, direction: "src", signal: t }), p = e.filter((d) => !r(d)), I = p.length > 0 ? await o.edges({ from: p, direction: "dst", signal: t }) : [], N = new Map(p.map((d, w) => [d, I[w]]));
+      return e.map((d, w) => {
+        const v = y[w], L = N.get(d), Z = [...(v == null ? void 0 : v.batches) ?? [], ...(L == null ? void 0 : L.batches) ?? []], K = [...(v == null ? void 0 : v.declined) ?? [], ...(L == null ? void 0 : L.declined) ?? []], x = r(d) ? K.filter((ee) => ee.direction !== "dst") : K, U = { rows: l[w], edges: Z, declined: x };
+        return { ...U, byteLength: de(U) };
+      });
+    },
+    onTileLoad: (e) => {
+      var t;
+      for (const r of ((t = e.content) == null ? void 0 : t.declined) ?? [])
+        E.some((l) => l.edgeType === r.edgeType && l.direction === r.direction) || (E = [...E, r]);
+      a.refresh(), f();
+    },
+    onTileError: (e) => {
+      a.refresh(), D(e), f();
+    }
+  });
+  let c = {
+    status: "none",
+    matrix: null,
+    typeIndex: 0,
+    modeColumn: null,
+    binding: q,
+    domain: [],
+    z: null,
+    visible: [],
+    cached: [],
+    pending: !1,
+    total: void 0,
+    declined: [],
+    selection: null,
+    focus: null,
+    hovered: null,
+    pinned: [],
+    tool: null,
+    motion: "settled",
+    progress: 1,
+    drawn: null,
+    options: n,
+    corpus: null
+  };
+  const V = (e) => {
+    var t;
+    return {
+      address: e.address,
+      kind: ((t = u == null ? void 0 : u.tileMatrices[e.address.z]) == null ? void 0 : t.kind) ?? "rows",
+      content: e.content
+    };
+  };
+  let P = { key: [], value: [] };
+  function W() {
+    const e = [o, T, g.category, n.categories];
+    return e.some((t, r) => t !== P.key[r]) && (P = { key: e, value: re(o, T, g, n.categories) }), P.value;
+  }
+  function X(e, t) {
+    return M || C ? "failed" : b ? "opening" : o ? e || S !== t || c.drawn === null ? "reading" : "idle" : "none";
+  }
+  function f(e = {}) {
+    var y;
+    J = a.frame;
+    const t = a.tiles.filter((p) => p.content !== null), r = Q(c.visible, t.filter((p) => p.isVisible).map(V)), l = a.selectedTiles.some((p) => p.isLoading);
+    c = {
+      ...c,
+      matrix: u,
+      typeIndex: T,
+      modeColumn: G,
+      binding: g,
+      domain: W(),
+      z: a.z,
+      visible: r,
+      cached: Q(c.cached, t.map(V)),
+      pending: l,
+      total: u ? Number(((y = u.tileMatrices[u.tileMatrices.length - 1]) == null ? void 0 : y.count) ?? 0) : void 0,
+      declined: E,
+      options: n,
+      corpus: o,
+      ...e
+    }, c = { ...c, status: X(l, c.visible) };
+    for (const p of m) p();
+  }
+  function _() {
+    if (!(!o || !u)) {
+      try {
+        const e = [H, ...ne];
+        O = o.scan({ type: u.type, filter: F, select: oe(g, e) }), a.setPlan(O.plan());
+      } catch (e) {
+        O = null, a.setPlan([]), D(e);
+      }
+      a.reloadAll(), z && a.update(z, n.limit ?? R), f();
+    }
+  }
+  function A() {
+    var l, y, p, I, N;
+    M = !1, u = null, O = null, E = [], S = null, a.finalize();
+    const e = { selection: null, focus: null, hovered: null, pinned: [], drawn: null };
+    if (!o) return f(e);
+    const t = o.types.vertices, r = n.type ?? ((l = t.find((d) => d.geometry)) == null ? void 0 : l.type) ?? ((y = t[0]) == null ? void 0 : y.type);
+    T = Math.max(0, t.findIndex((d) => d.type === r));
+    try {
+      if (r === void 0) throw new Error("the corpus has no vertex type to draw");
+      u = o.tileMatrix(r);
+      const d = ((p = o.addressing.vertexType(r).cells) == null ? void 0 : p.modeChannel) ?? null;
+      G = ((N = (I = t[T]) == null ? void 0 : I.channels.find((w) => w.name === d)) == null ? void 0 : N.column) ?? null, a.setMatrix(u);
+    } catch (d) {
+      M = !0, D(d);
+    }
+    c = { ...c, ...e }, _();
+  }
+  function $(e) {
+    if (o = null, b = ae(e) ? e : null, !b)
+      return o = e, A();
+    const t = b;
+    A(), t.then(
+      (r) => {
+        b === t && (b = null, o = r, A());
+      },
+      (r) => {
+        b === t && (b = null, M = !0, D(r), f());
+      }
+    );
+  }
+  function k() {
+    h == null || h(), h = null;
+    const e = n.filterBy, t = () => {
+      let r;
+      try {
+        r = e ? se(e, s) : void 0;
+      } catch (l) {
+        D(l);
+        return;
+      }
+      ue(r, F) || (F = r, _());
+    };
+    e && (e.addEventListener("value", t), h = () => e.removeEventListener("value", t)), t();
+  }
+  const j = {
+    /**
+     * The first subscriber starts listening to the crossfilter and the last one stops it and lets the
+     * tiles go — `QueryObserver`'s `onSubscribe`/`onUnsubscribe`, which is what survives StrictMode
+     * mounting everything twice.
+     */
+    subscribe(e) {
+      return m.add(e), B || (B = !0, k()), () => {
+        m.delete(e), m.size === 0 && j.destroy();
+      };
+    },
+    getSnapshot: () => c,
+    getOptions: () => n,
+    setOptions(e) {
+      const t = n;
+      n = e;
+      const r = Y(e), l = r.category !== g.category || r.size !== g.size || r.title !== g.title;
+      if (g = r, e.corpus !== t.corpus || e.type !== t.type) {
+        e.corpus !== t.corpus ? $(e.corpus) : A(), B && e.filterBy !== t.filterBy && k();
+        return;
+      }
+      if (B && e.filterBy !== t.filterBy && k(), l) return _();
+      e.limit !== t.limit && z && a.update(z, e.limit ?? R), f();
+    },
+    destroy() {
+      B = !1, h == null || h(), h = null, a.finalize(), m.clear();
+    },
+    setViewport(e) {
+      z = e, a.update(e, n.limit ?? R) !== J && f();
+    },
+    select(e, t = "node", r = "") {
+      var y;
+      const l = e && e.length > 0 ? { vertices: [...e], source: t, label: r } : null;
+      f({ selection: l }), (y = n.onSelect) == null || y.call(n, l), n.filterBy && ie(n.filterBy, s, H, l ? l.vertices.map(ce) : null);
+    },
+    focus(e) {
+      var t;
+      e !== c.focus && (f({ focus: e }), (t = n.onFocus) == null || t.call(n, e));
+    },
+    hover(e) {
+      e !== c.hovered && f({ hovered: e });
+    },
+    pin(e) {
+      f({ pinned: [...e] });
+    },
+    setTool(e) {
+      e !== c.tool && f({ tool: e });
+    },
+    report(e) {
+      e !== c.motion && f({ motion: e });
+    },
+    reportProgress(e) {
+      e !== c.progress && f({ progress: e });
+    },
+    setRenderable(e) {
+      C !== !e && (C = !e, f());
+    },
+    reportDrawn(e, t) {
+      S === e && t === null || (S = e, f(t ? { drawn: t } : {}));
+    }
+  };
+  return g = Y(i), $(i.corpus), j;
+}
+export {
+  R as DEFAULT_LIMIT,
+  be as createGraph
+};
+//# sourceMappingURL=store.js.map

package/dist/core/store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","sources":["../../src/core/store.ts"],"sourcesContent":["import {\n  PAYLOAD_ADDRESS,\n  PAYLOAD_COORDINATES,\n  type Batch,\n  type Corpus,\n  type Filter,\n  type Gap,\n  type Scan,\n  type TileAddress,\n  type TileMatrixSet,\n} from \"@fossil-lang/corpus\";\nimport type { MosaicClient } from \"@kanzo-tech/mosaic\";\nimport { domainOf } from \"./categories\";\nimport { bindingOf, projectionOf, type Binding } from \"./channels\";\nimport { filterFor, graphClient, publish } from \"./filter\";\nimport { denseOf } from \"./resident\";\nimport type { GraphOptions, GraphSnapshot, GraphStatus, GraphStore, TileView } from \"./state\";\nimport type { TileContent } from \"./tile\";\nimport type { Viewport } from \"./tile-matrix\";\nimport { Tileset2D } from \"./tileset\";\n\nexport type { Drawn, GraphOptions, GraphSnapshot, GraphState, GraphStatus, GraphStore, TileView } from \"./state\";\n\n/** Twenty thousand marks: what a canvas draws at once before a coarser zoom is chosen. */\nexport const DEFAULT_LIMIT = 20_000;\n\nconst NO_BINDING: Binding = bindingOf({});\nconst KEY = PAYLOAD_ADDRESS[0] as string;\n\nfunction bytesOf(content: Omit<TileContent, \"byteLength\">): number {\n  let bytes = 0;\n  for (const edge of content.edges) bytes += edge.src.byteLength + edge.dst.byteLength + (edge.weight?.byteLength ?? 0);\n  return bytes + content.rows.numRows * 8 * 4;\n}\n\nconst sameFilter = (a: Filter | undefined, b: Filter | undefined) =>\n  JSON.stringify(a, (_, v: unknown) => (typeof v === \"bigint\" ? `${v}n` : v)) ===\n  JSON.stringify(b, (_, v: unknown) => (typeof v === \"bigint\" ? `${v}n` : v));\n\nconst isPromise = (value: unknown): value is PromiseLike<Corpus> =>\n  typeof (value as PromiseLike<Corpus> | null)?.then === \"function\";\n\n/** The same array while the set of tiles in it is the same, so a reader can compare by identity. */\nfunction keep(previous: readonly TileView[], next: TileView[]): readonly TileView[] {\n  if (previous.length !== next.length) return next;\n  return next.every((view, i) => view.content === previous[i]?.content) ? previous : next;\n}\n\nexport function createGraph(initial: GraphOptions): GraphStore {\n  let options = initial;\n  const listeners = new Set<() => void>();\n  const self: MosaicClient = graphClient();\n\n  let corpus: Corpus | null = null;\n  let opening: PromiseLike<Corpus> | null = null;\n  let failed = false;\n  let unrenderable = false;\n  let matrix: TileMatrixSet | null = null;\n  let typeIndex = 0;\n  let modeColumn: string | null = null;\n  let scan: Scan | null = null;\n  let binding = NO_BINDING;\n  let filter: Filter | undefined;\n  let viewport: Viewport | null = null;\n  let declined: Gap[] = [];\n  let composed: readonly TileView[] | null = null;\n  let unlisten: (() => void) | null = null;\n  let active = false;\n  let lastFrame = -1;\n\n  const fail = (error: unknown) => {\n    options.onFailure(error instanceof Error ? error.message : String(error));\n  };\n\n  const tileset = new Tileset2D({\n    debounceTime: 60,\n    load: async (addresses, signal) => {\n      if (!corpus || !scan) throw new Error(\"the graph has no scan to read with\");\n      const isCells = (address: TileAddress) => matrix?.tileMatrices[address.z]?.kind === \"cells\";\n      const rows = await scan.read(addresses, { signal });\n      const src = await corpus.edges({ from: addresses, direction: \"src\", signal });\n      const payload = addresses.filter((address) => !isCells(address));\n      const dst = payload.length > 0 ? await corpus.edges({ from: payload, direction: \"dst\", signal }) : [];\n      const dstOf = new Map(payload.map((address, i) => [address, dst[i]]));\n      return addresses.map((address, i) => {\n        const out = src[i];\n        const back = dstOf.get(address);\n        const edges = [...(out?.batches ?? []), ...(back?.batches ?? [])];\n        const gaps = [...(out?.declined ?? []), ...(back?.declined ?? [])];\n        const declined = isCells(address) ? gaps.filter((gap) => gap.direction !== \"dst\") : gaps;\n        const content = { rows: rows[i] as Batch, edges, declined };\n        return { ...content, byteLength: bytesOf(content) };\n      });\n    },\n    onTileLoad: (tile) => {\n      for (const gap of tile.content?.declined ?? []) {\n        if (!declined.some((d) => d.edgeType === gap.edgeType && d.direction === gap.direction)) {\n          declined = [...declined, gap];\n        }\n      }\n      tileset.refresh();\n      notify();\n    },\n    onTileError: (error) => {\n      tileset.refresh();\n      fail(error);\n      notify();\n    },\n  });\n\n  let snapshot: GraphSnapshot = {\n    status: \"none\",\n    matrix: null,\n    typeIndex: 0,\n    modeColumn: null,\n    binding: NO_BINDING,\n    domain: [],\n    z: null,\n    visible: [],\n    cached: [],\n    pending: false,\n    total: undefined,\n    declined: [],\n    selection: null,\n    focus: null,\n    hovered: null,\n    pinned: [],\n    tool: null,\n    motion: \"settled\",\n    progress: 1,\n    drawn: null,\n    options,\n    corpus: null,\n  };\n\n  const viewOf = (tile: { address: TileAddress; content: TileContent | null }): TileView => ({\n    address: tile.address,\n    kind: matrix?.tileMatrices[tile.address.z]?.kind ?? \"rows\",\n    content: tile.content as TileContent,\n  });\n\n  let domain: { key: unknown[]; value: readonly unknown[] } = { key: [], value: [] };\n  function domainNow(): readonly unknown[] {\n    const key = [corpus, typeIndex, binding.category, options.categories];\n    if (key.some((part, i) => part !== domain.key[i])) domain = { key, value: domainOf(corpus, typeIndex, binding, options.categories) };\n    return domain.value;\n  }\n\n  function statusOf(pending: boolean, visible: readonly TileView[]): GraphStatus {\n    if (failed || unrenderable) return \"failed\";\n    if (opening) return \"opening\";\n    if (!corpus) return \"none\";\n    return pending || composed !== visible || snapshot.drawn === null ? \"reading\" : \"idle\";\n  }\n\n  function notify(patch: Partial<GraphSnapshot> = {}): void {\n    lastFrame = tileset.frame;\n    const tiles = tileset.tiles.filter((tile) => tile.content !== null);\n    const visible = keep(snapshot.visible, tiles.filter((tile) => tile.isVisible).map(viewOf));\n    const pending = tileset.selectedTiles.some((tile) => tile.isLoading);\n    snapshot = {\n      ...snapshot,\n      matrix,\n      typeIndex,\n      modeColumn,\n      binding,\n      domain: domainNow(),\n      z: tileset.z,\n      visible,\n      cached: keep(snapshot.cached, tiles.map(viewOf)),\n      pending,\n      total: matrix ? Number(matrix.tileMatrices[matrix.tileMatrices.length - 1]?.count ?? 0) : undefined,\n      declined,\n      options,\n      corpus,\n      ...patch,\n    };\n    snapshot = { ...snapshot, status: statusOf(pending, snapshot.visible) };\n    for (const listener of listeners) listener();\n  }\n\n  /** A binding or a filter is a new scan, planned once and never per camera move. */\n  function rescan(): void {\n    if (!corpus || !matrix) return;\n    try {\n      const fixed = [KEY, ...PAYLOAD_COORDINATES];\n      scan = corpus.scan({ type: matrix.type, filter, select: projectionOf(binding, fixed) });\n      tileset.setPlan(scan.plan());\n    } catch (error) {\n      scan = null;\n      tileset.setPlan([]);\n      fail(error);\n    }\n    tileset.reloadAll();\n    if (viewport) tileset.update(viewport, options.limit ?? DEFAULT_LIMIT);\n    notify();\n  }\n\n  function reopen(): void {\n    failed = false;\n    matrix = null;\n    scan = null;\n    declined = [];\n    composed = null;\n    tileset.finalize();\n    const cleared = { selection: null, focus: null, hovered: null, pinned: [], drawn: null };\n    if (!corpus) return notify(cleared);\n    const types = corpus.types.vertices;\n    const type = options.type ?? types.find((t) => t.geometry)?.type ?? types[0]?.type;\n    typeIndex = Math.max(0, types.findIndex((t) => t.type === type));\n    try {\n      if (type === undefined) throw new Error(\"the corpus has no vertex type to draw\");\n      matrix = corpus.tileMatrix(type);\n      const mode = corpus.addressing.vertexType(type).cells?.modeChannel ?? null;\n      modeColumn = types[typeIndex]?.channels.find((channel) => channel.name === mode)?.column ?? null;\n      tileset.setMatrix(matrix);\n    } catch (error) {\n      failed = true;\n      fail(error);\n    }\n    snapshot = { ...snapshot, ...cleared };\n    rescan();\n  }\n\n  /** A promise is adopted when it settles, and only if it is still the corpus the host means. */\n  function adopt(given: GraphOptions[\"corpus\"]): void {\n    corpus = null;\n    opening = isPromise(given) ? given : null;\n    if (!opening) {\n      corpus = given as Corpus | null;\n      return reopen();\n    }\n    const promised = opening;\n    reopen();\n    promised.then(\n      (opened) => {\n        if (opening !== promised) return;\n        opening = null;\n        corpus = opened;\n        reopen();\n      },\n      (error: unknown) => {\n        if (opening !== promised) return;\n        opening = null;\n        failed = true;\n        fail(error);\n        notify();\n      },\n    );\n  }\n\n  function listen(): void {\n    unlisten?.();\n    unlisten = null;\n    const crossfilter = options.filterBy;\n    const refilter = () => {\n      let next: Filter | undefined;\n      try {\n        next = crossfilter ? filterFor(crossfilter, self) : undefined;\n      } catch (error) {\n        fail(error);\n        return;\n      }\n      if (sameFilter(next, filter)) return;\n      filter = next;\n      rescan();\n    };\n    if (crossfilter) {\n      crossfilter.addEventListener(\"value\", refilter);\n      unlisten = () => crossfilter.removeEventListener(\"value\", refilter);\n    }\n    refilter();\n  }\n\n  const store: GraphStore = {\n    /**\n     * The first subscriber starts listening to the crossfilter and the last one stops it and lets the\n     * tiles go — `QueryObserver`'s `onSubscribe`/`onUnsubscribe`, which is what survives StrictMode\n     * mounting everything twice.\n     */\n    subscribe(listener) {\n      listeners.add(listener);\n      if (!active) {\n        active = true;\n        listen();\n      }\n      return () => {\n        listeners.delete(listener);\n        if (listeners.size === 0) store.destroy();\n      };\n    },\n    getSnapshot: () => snapshot,\n    getOptions: () => options,\n    setOptions(next) {\n      const previous = options;\n      options = next;\n      const nextBinding = bindingOf(next);\n      const rebound =\n        nextBinding.category !== binding.category ||\n        nextBinding.size !== binding.size ||\n        nextBinding.title !== binding.title;\n      binding = nextBinding;\n      if (next.corpus !== previous.corpus || next.type !== previous.type) {\n        if (next.corpus !== previous.corpus) adopt(next.corpus);\n        else reopen();\n        if (active && next.filterBy !== previous.filterBy) listen();\n        return;\n      }\n      if (active && next.filterBy !== previous.filterBy) listen();\n      if (rebound) return rescan();\n      if (next.limit !== previous.limit && viewport) tileset.update(viewport, next.limit ?? DEFAULT_LIMIT);\n      notify();\n    },\n    destroy() {\n      active = false;\n      unlisten?.();\n      unlisten = null;\n      tileset.finalize();\n      listeners.clear();\n    },\n    setViewport(next) {\n      viewport = next;\n      if (tileset.update(next, options.limit ?? DEFAULT_LIMIT) !== lastFrame) notify();\n    },\n    select(vertices, source = \"node\", label = \"\") {\n      const selection = vertices && vertices.length > 0 ? { vertices: [...vertices], source, label } : null;\n      notify({ selection });\n      options.onSelect?.(selection);\n      if (options.filterBy) publish(options.filterBy, self, KEY, selection ? selection.vertices.map(denseOf) : null);\n    },\n    focus(vertex) {\n      if (vertex === snapshot.focus) return;\n      notify({ focus: vertex });\n      options.onFocus?.(vertex);\n    },\n    hover(vertex) {\n      if (vertex !== snapshot.hovered) notify({ hovered: vertex });\n    },\n    pin(vertices) {\n      notify({ pinned: [...vertices] });\n    },\n    setTool(tool) {\n      if (tool !== snapshot.tool) notify({ tool });\n    },\n    report(motion) {\n      if (motion !== snapshot.motion) notify({ motion });\n    },\n    reportProgress(value) {\n      if (value !== snapshot.progress) notify({ progress: value });\n    },\n    setRenderable(renderable) {\n      if (unrenderable === !renderable) return;\n      unrenderable = !renderable;\n      notify();\n    },\n    reportDrawn(visible, drawn) {\n      if (composed === visible && drawn === null) return;\n      composed = visible;\n      notify(drawn ? { drawn } : {});\n    },\n  };\n\n  binding = bindingOf(initial);\n  adopt(initial.corpus);\n  return store;\n}\n"],"names":["DEFAULT_LIMIT","NO_BINDING","bindingOf","KEY","PAYLOAD_ADDRESS","bytesOf","content","bytes","edge","_a","sameFilter","a","b","_","v","isPromise","value","keep","previous","next","view","i","createGraph","initial","options","listeners","self","graphClient","corpus","opening","failed","unrenderable","matrix","typeIndex","modeColumn","scan","binding","filter","viewport","declined","composed","unlisten","active","lastFrame","fail","error","tileset","Tileset2D","addresses","signal","isCells","address","rows","src","payload","dst","dstOf","out","back","edges","gaps","gap","tile","d","notify","snapshot","viewOf","domain","domainNow","key","part","domainOf","statusOf","pending","visible","patch","tiles","listener","rescan","fixed","PAYLOAD_COORDINATES","projectionOf","reopen","cleared","types","type","t","_b","mode","_c","_e","_d","channel","adopt","given","promised","opened","listen","crossfilter","refilter","filterFor","store","nextBinding","rebound","vertices","source","label","selection","publish","denseOf","vertex","tool","motion","renderable","drawn"],"mappings":"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"}