@kanzo-tech/graph 0.1.0 → 0.3.0

package/dist/use-graph.js

@@ -1,101 +1,102 @@
 "use client";
-import { useMemo as P, useRef as s, useCallback as R } from "react";
-import { DEFAULT_LOOK as j } from "./graph-looks.js";
-import { isColour as q } from "./graph-model.js";
-import { residentOf as z } from "./resident.js";
-import { useQueryLoop as H } from "./use-query-loop.js";
-import { useRenderer as I } from "./use-renderer.js";
-import { useGraphLook as J } from "./use-graph-look.js";
-const S = z(null);
-function nr(C) {
+import { useMemo as l, useRef as c, useCallback as b } from "react";
+import { resolveLook as H } from "./graph-looks.js";
+import { isColour as I } from "./graph-model.js";
+import { residentOf as J } from "./resident.js";
+import { resolveSim as K } from "./graph-sim.js";
+import { useQueryLoop as U } from "./use-query-loop.js";
+import { useRenderer as V } from "./use-renderer.js";
+import { useGraphLook as W } from "./use-graph-look.js";
+const X = J(null);
+function cr(B) {
   const {
     clusters: D,
     debounce: E,
-    events: a,
+    events: p,
     fill: i,
-    limit: L,
-    look: b = j,
-    onFailure: p,
-    pinned: x,
-    r: B,
-    report: G,
+    limit: G,
+    look: d,
+    onFailure: k,
+    pinned: L,
+    r: x,
+    report: y,
     reportProgress: T,
-    schedule: y,
-    sim: F,
-    simulate: Z = !1,
-    source: w,
-    stroke: d,
-    symbol: l
-  } = C, A = q(i) ? l : i, K = P(() => ({ fill: i, stroke: d, symbol: l }), [i, d, l]), u = s(null), f = s(null), c = s(S), { explore: M, pending: N, refresh: m, resident: k, slice: v, sliced: Q, total: U } = H({
+    schedule: Z,
+    sim: v,
+    simulate: w = !1,
+    source: F,
+    stroke: h,
+    symbol: m
+  } = B, M = l(() => H(d), [d]), N = l(() => K(v), [v]), Q = I(i) ? m : i, S = l(() => ({ fill: i, stroke: h, symbol: m }), [i, h, m]), u = c(null), f = c(null), s = c(X), { pending: Y, refresh: a, resident: g, slice: P, sliced: j, total: q } = U({
     debounce: E,
-    fill: A,
+    fill: Q,
     graphRef: f,
     hostRef: u,
-    limit: L,
-    onError: p,
-    pinned: x,
-    r: B,
-    source: w
+    limit: G,
+    onError: k,
+    pinned: L,
+    r: x,
+    source: F
   });
-  c.current = k;
-  const g = R(() => f.current, []), Y = R(() => c.current, []), t = s(a);
-  t.current = a;
-  const h = s(m);
-  h.current = m;
-  const _ = P(
+  s.current = g;
+  const O = b(() => f.current, []), z = b(() => s.current, []), t = c(p);
+  t.current = p;
+  const R = c(a);
+  R.current = a;
+  const A = l(
     () => ({
       onBackgroundClick: () => {
-        var r, e;
-        return (e = (r = t.current) == null ? void 0 : r.onBackgroundClick) == null ? void 0 : e.call(r);
+        var r, o;
+        return (o = (r = t.current) == null ? void 0 : r.onBackgroundClick) == null ? void 0 : o.call(r);
       },
       onDragEnd: (r) => {
-        var o, n;
-        const e = c.current.at(r);
-        e !== void 0 && ((n = (o = t.current) == null ? void 0 : o.onDragEnd) == null || n.call(o, e));
+        var e, n;
+        const o = s.current.at(r);
+        o !== void 0 && ((n = (e = t.current) == null ? void 0 : e.onDragEnd) == null || n.call(e, o));
       },
-      onPointClick: (r, e) => {
-        var n, O;
-        const o = c.current.at(e);
-        o !== void 0 && ((O = (n = t.current) == null ? void 0 : n.onPointClick) == null || O.call(n, o, r, e));
+      onPointClick: (r, o) => {
+        var n, C;
+        const e = s.current.at(o);
+        e !== void 0 && ((C = (n = t.current) == null ? void 0 : n.onPointClick) == null || C.call(n, e, r, o));
       },
       onPointerOut: () => {
-        var r, e;
-        return (e = (r = t.current) == null ? void 0 : r.onPointerOut) == null ? void 0 : e.call(r);
+        var r, o;
+        return (o = (r = t.current) == null ? void 0 : r.onPointerOut) == null ? void 0 : o.call(r);
       },
       onPointerOver: (r) => {
-        var o, n;
-        const e = c.current.at(r);
-        e !== void 0 && ((n = (o = t.current) == null ? void 0 : o.onPointerOver) == null || n.call(o, e, r));
+        var e, n;
+        const o = s.current.at(r);
+        o !== void 0 && ((n = (e = t.current) == null ? void 0 : e.onPointerOver) == null || n.call(e, o, r));
       },
       onTick: () => {
-        var r, e;
-        return (e = (r = t.current) == null ? void 0 : r.onTick) == null ? void 0 : e.call(r);
+        var r, o;
+        return (o = (r = t.current) == null ? void 0 : r.onTick) == null ? void 0 : o.call(r);
       },
       // The camera moved, so the graph is re-asked. A host that forgot this line got a canvas that
       // drew its first answer and never asked again — which is what `refresh` being the host's
       // responsibility used to cost.
       onZoom: () => {
-        var r, e;
-        h.current(), (e = (r = t.current) == null ? void 0 : r.onZoom) == null || e.call(r);
+        var r, o;
+        R.current(), (o = (r = t.current) == null ? void 0 : r.onZoom) == null || o.call(r);
       }
     }),
     // Built once: every reference inside is a ref this hook owns, so there is nothing to depend on.
     // It used to close over a ref object a host could substitute, which is the prop this file deletes.
     []
   );
-  return I({
+  return V({
     clusters: D,
-    events: _,
+    events: A,
     graphRef: f,
     hostRef: u,
-    onFailure: p,
-    report: G,
+    onFailure: k,
+    report: y,
     reportProgress: T,
-    sim: F,
-    simulate: Z
-  }), J({ channels: K, getGraph: g, hostRef: u, look: b, schedule: y, slice: v }), { explore: M, getGraph: g, getResident: Y, hostRef: u, pending: N, refresh: m, resident: k, slice: v, sliced: Q, total: U };
+    sim: N,
+    simulate: w
+  }), W({ channels: S, getGraph: O, hostRef: u, look: M, schedule: Z, slice: P }), { getGraph: O, getResident: z, hostRef: u, pending: Y, refresh: a, resident: g, slice: P, sliced: j, total: q };
 }
 export {
-  nr as useGraph
+  cr as useGraph
 };
 //# sourceMappingURL=use-graph.js.map

package/dist/use-graph.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-graph.js","sources":["../src/use-graph.ts"],"sourcesContent":["\"use client\";\n\nimport type { Graph } from \"@cosmos.gl/graph\";\nimport { useCallback, useMemo, useRef, type RefObject } from \"react\";\nimport type { BoundedSource, Slice } from \"./bounded\";\nimport { DEFAULT_LOOK, type Look } from \"./graph-looks\";\nimport { isColour, type Channels } from \"./graph-model\";\nimport { residentOf, type Resident, type VertexId } from \"./resident\";\nimport type { Sim } from \"./graph-sim\";\nimport type { Motion } from \"./types\";\nimport { useQueryLoop } from \"./use-query-loop\";\nimport { useRenderer, type RendererOptions } from \"./use-renderer\";\nimport { useGraphLook } from \"./use-graph-look\";\n\n/**\n * Everything a graph is, above the element that draws it.\n *\n * **This is Ark's `useX(props) → api`, and the reason it exists is a host that could not adopt\n * `GraphCanvas`.** The component owned the renderer, the query loop and the look, and published them\n * through a context — which a legend or an inspector can read, because those are `children`. What\n * cannot read a context is anything that sits *above* the element: `useGraphOverlays` wants\n * `getGraph` and `getResident`, the `events` block wants the same accessors, and both are arguments\n * to a hook called in the component that renders the canvas rather than inside it. The workspace\n * needed them in thirty places and so kept its own copy of all three.\n *\n * The general answer to that circularity is Ark's, and it is a shape rather than a feature: the\n * factory builds the api where the host can hold it, the provider takes it and renders. What the\n * component version tried instead — `graphRef` and `residentRef` as props, given rather than\n * returned — solved one host's version of it and is deleted by this file.\n *\n * **The structure is copied and the substance is not.** An Ark api's value is its prop getters,\n * which distribute props across many parts. Here there are no parts: a canvas is one element. So\n * there is no `getRootProps()` — `hostRef` is what the provider needs and all it needs — and\n * inventing one for the resemblance would be cargo cult. `CONVENTIONS.md` is where that line is\n * drawn, not here.\n */\n\n/**\n * The gestures, in the terms the rest of this package speaks.\n *\n * cosmos.gl reports a **buffer index**, which names a slot in the answer currently uploaded. Every\n * host then wrote the same three lines — resolve the index through the resident map, return early if\n * it resolves to nothing, carry on with the identity — because an index is not something you can\n * keep. The factory already holds that map, so it does the resolving and a callback that would have\n * been handed a stale slot is simply not called.\n *\n * `onZoom` is the one with a duty attached: the camera moving is how a bounded graph is re-asked,\n * and the loop issues that `refresh` itself. What arrives here is the notification, for a host that\n * has overlays to reposition.\n */\nexport interface GraphEvents {\n  onBackgroundClick?: () => void;\n  onPointClick?: (vertex: VertexId, graph: Graph, index: number) => void;\n  onPointerOver?: (vertex: VertexId, index: number) => void;\n  onPointerOut?: () => void;\n  onDragEnd?: (vertex: VertexId) => void;\n  onTick?: () => void;\n  onZoom?: () => void;\n}\n\nexport interface UseGraphProps {\n  /** What to draw. `null` renders the frame and asks nothing — a host still resolving its data. */\n  source: BoundedSource | null;\n  /**\n   * Geometry only. Colour comes from the page's categorical scale, never from here.\n   *\n   * **One appearance input**, where there were two: a `Display` rode beside this with its own\n   * defaults, spelling the edge layer, the backdrop and two multipliers over numbers the look\n   * already computes. `lookFrom(values)` resolves the whole picture from the axes a person chose.\n   */\n  look?: Look;\n  sim?: Sim;\n  /**\n   * Off by default, and that is the correct default rather than a cautious one: a bounded source\n   * hands back the coordinates its next spatial query is expressed in, so a force moves the picture\n   * out from under its own index.\n   */\n  simulate?: boolean;\n  clusters?: (number | undefined)[];\n  /**\n   * Which column colours a point, **or a CSS colour every point wears** — Plot's channel name,\n   * Plot's meaning, and Plot's rule that a colour is a constant and anything else is a column.\n   *\n   * **A channel is what you want drawn, so it rides the question and not the source.** Baked into a\n   * source at construction — which is where this used to live — changing what a graph is coloured by\n   * meant building a second source, and *where the bytes are* and *what I want drawn* are not the\n   * same question. Changing it here re-asks over the same bytes, which is all it should ever have\n   * cost.\n   *\n   * As a *constant* it costs no query at all: `fill=\"var(--foreground)\"` is the monochrome picture,\n   * and it is a binding rather than a look, because a look may not rebind an encoding.\n   *\n   * Omitted, the source decides which column: it is the only thing that knows what its corpus\n   * carries.\n   */\n  fill?: string;\n  /**\n   * Which column a point's **shape** carries — Plot's `symbol`, and a peer of colour.\n   *\n   * Bound to the same column as `fill` this is redundant encoding, which is the point on a colourful\n   * document and the only encoding left on a monochrome one. It reads the categorical column the\n   * slice already carries, so it costs no query; a *different* column would need a second categorical\n   * array in the slice and in every source, and is not paid for.\n   *\n   * Binding it takes on an obligation — see `gradeComposition`: shape and size spent at once need a\n   * radius floor, which is a property of what you composed rather than of the form you picked.\n   */\n  symbol?: string;\n  /**\n   * Which column the size ramp is spent on — Plot's `r`.\n   *\n   * Omitted, every point is drawn at one radius, which is a legitimate picture: without a ramp a\n   * look's `form.size` range has only one end.\n   */\n  r?: string;\n  /**\n   * What tints a link. **Absent, each link takes the colour of the vertex it leaves**; a constant\n   * like `var(--muted-foreground)` makes links plain structure.\n   */\n  stroke?: string;\n  /** Vertices that stay drawn whatever the camera is over. */\n  pinned?: VertexId[];\n  limit?: number;\n  debounce?: number;\n  /**\n   * Required, and the only one.\n   *\n   * Its silence is a defect rather than a choice: unhandled, a browser with no WebGL context shows\n   * an empty box and says nothing, and what stands in its place is the host's decision.\n   */\n  onFailure: (message: string) => void;\n  events?: GraphEvents;\n  report?: (motion: Motion) => void;\n  reportProgress?: (value: number) => void;\n  /**\n   * Ask the overlays to reposition after a look has been uploaded.\n   *\n   * Optional, and only owed to `useGraphOverlays`: point sizes changed, so labels sit differently,\n   * and a look change does not tick — with a simulation off there is nothing to schedule a repaint\n   * off. A host drawing no labels passes nothing.\n   *\n   * It goes through the props rather than being read off the api because `useGraphOverlays` is\n   * declared *after* this hook — it needs `getGraph` and `getResident` from it. A host bridges the\n   * two with one ref, which is the smallest honest answer to a cycle that is genuinely mutual:\n   * overlays need the graph, and the graph's repaint owes the overlays a nudge.\n   */\n  schedule?: () => void;\n}\n\n/**\n * What a graph publishes — to its own chrome through the provider, and to its host directly.\n *\n * Getters rather than values for the two that change every answer: a legend, an inspector and a\n * hover card all read the graph and the resident map from inside callbacks, and publishing them as\n * values would re-render every consumer on every camera move to hand back a reference they only\n * dereference when something is clicked. `slice` and `resident` ARE values, because a legend counts\n * what is drawn and has to re-render when that changes.\n *\n * **There is no `graphRef` here, and that is deliberate.** `getGraph()` answers every read of it,\n * and a ref object as well would be two ways to express one thing — with the second one writable,\n * which nothing outside `useRenderer` may be.\n */\nexport interface GraphApi {\n  /**\n   * Where the canvas is drawn. `GraphRootProvider` attaches it; a host that renders its own surface\n   * attaches it itself, and nothing works until something does.\n   */\n  hostRef: RefObject<HTMLDivElement | null>;\n  getGraph: () => Graph | null;\n  getResident: () => Resident;\n  /** The answer currently drawn, or `null` before the first one. */\n  slice: Slice | null;\n  /** Who is drawn and where, rebuilt with every answer — never build a second one. */\n  resident: Resident;\n  /** How many vertices there are, when the source knows. */\n  total: number | undefined;\n  /** Whether a question is outstanding. */\n  pending: boolean;\n  /** Whether this graph is asked in pieces at all, or fitted under the limit and taken whole. */\n  sliced: boolean;\n  /** Ask again about wherever the camera is now. Wired to the camera already. */\n  refresh: () => void;\n  /** Ask a topological question instead of a spatial one, when the source supports one. */\n  explore: (seeds: VertexId[], depth: number) => void;\n}\n\n/** The empty answer, built once — a ref has to hold something before the first slice arrives. */\nconst NOBODY = residentOf(null);\n\nexport function useGraph(props: UseGraphProps): GraphApi {\n  const {\n    clusters,\n    debounce,\n    events,\n    fill,\n    limit,\n    look = DEFAULT_LOOK,\n    onFailure,\n    pinned,\n    r,\n    report,\n    reportProgress,\n    schedule,\n    sim,\n    simulate = false,\n    source,\n    stroke,\n    symbol,\n  } = props;\n\n  /**\n   * The two destinations one vocabulary splits into — and the one column they share.\n   *\n   * A slice carries **one** categorical array, so the query has one column to fetch and the question\n   * is which binding names it: `fill` when it is a column, and `symbol` when `fill` is a constant.\n   * That is not a fallback, it is the monochrome picture stated exactly — identity has moved to\n   * shape, so the column identity lives in is the one `symbol` names.\n   *\n   * Getting this wrong is not a silent failure, which is the one good thing about it: with `fill` a\n   * constant and nothing put in its place, the source fell back to its own default column and DuckDB\n   * answered `Referenced column \"community\" not found`. The browser said so on the first Ink render.\n   *\n   * `stroke` never reaches a query at all — a link's tint is a decision about drawing.\n   */\n  const asked = isColour(fill) ? symbol : fill;\n  const channels = useMemo<Channels>(() => ({ fill, stroke, symbol }), [fill, stroke, symbol]);\n\n  const hostRef = useRef<HTMLDivElement>(null);\n  const graphRef = useRef<Graph | null>(null);\n  const residentRef = useRef<Resident>(NOBODY);\n\n  const { explore, pending, refresh, resident, slice, sliced, total } = useQueryLoop({\n    debounce,\n    fill: asked,\n    graphRef,\n    hostRef,\n    limit,\n    onError: onFailure,\n    pinned,\n    r,\n    source,\n  });\n\n  /**\n   * The resident map, readable from a callback that was created once.\n   *\n   * Written on every render rather than through an effect: a click handler registered with cosmos.gl\n   * at construction reads this on the next gesture, and an effect would leave one frame where the map\n   * describes buffers that are no longer on screen.\n   */\n  residentRef.current = resident;\n\n  const getGraph = useCallback(() => graphRef.current, []);\n  const getResident = useCallback(() => residentRef.current, []);\n\n  /**\n   * The host's handlers, read through a ref.\n   *\n   * cosmos.gl takes its callbacks once, at construction, so a fresh `events` object per render would\n   * either be ignored or force a rebuild of the WebGL context. The ref is what lets a host pass an\n   * inline object without either.\n   */\n  const live = useRef(events);\n  live.current = events;\n\n  const refreshRef = useRef(refresh);\n  refreshRef.current = refresh;\n\n  const wired = useMemo<RendererOptions[\"events\"]>(\n    () => ({\n      onBackgroundClick: () => live.current?.onBackgroundClick?.(),\n      onDragEnd: (index) => {\n        const vertex = residentRef.current.at(index);\n        if (vertex !== undefined) live.current?.onDragEnd?.(vertex);\n      },\n      onPointClick: (graph, index) => {\n        const vertex = residentRef.current.at(index);\n        if (vertex !== undefined) live.current?.onPointClick?.(vertex, graph, index);\n      },\n      onPointerOut: () => live.current?.onPointerOut?.(),\n      onPointerOver: (index) => {\n        const vertex = residentRef.current.at(index);\n        if (vertex !== undefined) live.current?.onPointerOver?.(vertex, index);\n      },\n      onTick: () => live.current?.onTick?.(),\n      // The camera moved, so the graph is re-asked. A host that forgot this line got a canvas that\n      // drew its first answer and never asked again — which is what `refresh` being the host's\n      // responsibility used to cost.\n      onZoom: () => {\n        refreshRef.current();\n        live.current?.onZoom?.();\n      },\n    }),\n    // Built once: every reference inside is a ref this hook owns, so there is nothing to depend on.\n    // It used to close over a ref object a host could substitute, which is the prop this file deletes.\n    [],\n  );\n\n  /**\n   * The renderer, built into an element this hook does not render.\n   *\n   * That is sound and not a gamble: React attaches refs during the commit phase, before any effect\n   * runs, so by the time this effect fires `hostRef.current` is whatever the provider mounted —\n   * including when the provider is a child component, since child refs are attached in the same\n   * commit. A host that calls `useGraph` and renders no surface at all gets a hook that returns\n   * early, forever, which is the honest outcome for a graph with nowhere to go.\n   */\n  useRenderer({\n    clusters,\n    events: wired,\n    graphRef,\n    hostRef,\n    onFailure,\n    report,\n    reportProgress,\n    sim,\n    simulate,\n  });\n\n  useGraphLook({ channels, getGraph, hostRef, look, schedule, slice });\n\n  return { explore, getGraph, getResident, hostRef, pending, refresh, resident, slice, sliced, total };\n}\n"],"names":[],"mappings":";;;;;;;;AA2LA;AAEO;AACL;AAAM;AACJ;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACW;AACX;AACA;AACA;AAwBiF;AACjF;AACM;AACN;AACA;AACA;AACS;AACT;AACA;AACA;AAUF;AAEA;AAWA;AAEA;AACA;AAEA;AAAc;AACL;;AACoB;AAAA;AAAA;;AAEvB;AACA;AAAoD;AACtD;;AAEE;AACA;AAAsE;AACxE;;AACoB;AAAA;AAAA;;AAElB;AACA;AAAgE;AAClE;;AACc;AAAA;AAAA;AAAA;AAAA;AAAA;;AAKZ;AACA;AACF;AAAA;AAAA;AAAA;AAIF;AAYF;AAAY;AACV;AACQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AAMJ;;;;"}
+{"version":3,"file":"use-graph.js","sources":["../src/use-graph.ts"],"sourcesContent":["\"use client\";\n\nimport type { Graph } from \"@cosmos.gl/graph\";\nimport { useCallback, useMemo, useRef, type RefObject } from \"react\";\nimport type { BoundedSource, Slice } from \"./bounded\";\nimport { resolveLook, type LookPatch } from \"./graph-looks\";\nimport { isColour, type Channels } from \"./graph-model\";\nimport { residentOf, type Resident, type VertexId } from \"./resident\";\nimport { resolveSim, type Sim } from \"./graph-sim\";\nimport type { Motion } from \"./types\";\nimport { useQueryLoop } from \"./use-query-loop\";\nimport { useRenderer, type RendererOptions } from \"./use-renderer\";\nimport { useGraphLook } from \"./use-graph-look\";\n\n/**\n * Everything a graph is, above the element that draws it.\n *\n * **This is Ark's `useX(props) → api`, and the reason it exists is a host that could not adopt\n * `GraphCanvas`.** The component owned the renderer, the query loop and the look, and published them\n * through a context — which a legend or an inspector can read, because those are `children`. What\n * cannot read a context is anything that sits *above* the element: `useGraphOverlays` wants the api\n * itself, the `events` block wants the accessors on it, and both are arguments to a hook called in\n * the component that renders the canvas rather than inside it. The workspace needed them in thirty\n * places and so kept its own copy of all three.\n *\n * The general answer to that circularity is Ark's, and it is a shape rather than a feature: the\n * factory builds the api where the host can hold it, the provider takes it and renders. What the\n * component version tried instead — `graphRef` and `residentRef` as props, given rather than\n * returned — solved one host's version of it and is deleted by this file.\n *\n * **The structure is copied and the substance is not.** An Ark api's value is its prop getters,\n * which distribute props across many parts. Here there are no parts: a canvas is one element. So\n * there is no `getRootProps()` — `hostRef` is what the provider needs and all it needs — and\n * inventing one for the resemblance would be cargo cult. `CONVENTIONS.md` is where that line is\n * drawn, not here.\n */\n\n/**\n * The gestures, in the terms the rest of this package speaks.\n *\n * cosmos.gl reports a **buffer index**, which names a slot in the answer currently uploaded. Every\n * host then wrote the same three lines — resolve the index through the resident map, return early if\n * it resolves to nothing, carry on with the identity — because an index is not something you can\n * keep. The factory already holds that map, so it does the resolving and a callback that would have\n * been handed a stale slot is simply not called.\n *\n * `onZoom` is the one with a duty attached: the camera moving is how a bounded graph is re-asked,\n * and the loop issues that `refresh` itself. What arrives here is the notification, for a host that\n * has overlays to reposition.\n */\nexport interface GraphEvents {\n  onBackgroundClick?: () => void;\n  onPointClick?: (vertex: VertexId, graph: Graph, index: number) => void;\n  onPointerOver?: (vertex: VertexId, index: number) => void;\n  onPointerOut?: () => void;\n  onDragEnd?: (vertex: VertexId) => void;\n  onTick?: () => void;\n  onZoom?: () => void;\n}\n\nexport interface UseGraphProps {\n  /** What to draw. `null` renders the frame and asks nothing — a host still resolving its data. */\n  source: BoundedSource | null;\n  /**\n   * Geometry only. Colour comes from the page's categorical scale, never from here.\n   *\n   * **One appearance input**, where there were two: a `Display` rode beside this with its own\n   * defaults, spelling the edge layer, the backdrop and two multipliers over numbers the look\n   * already computes. `lookFrom(values)` resolves the whole picture from the axes a person chose.\n   *\n   * **A patch, not a whole `Look` — which is what `DEFAULT_LOOK` was for.** This took the complete\n   * object, so a host that wanted the vignette on wrote `{ ...DEFAULT_LOOK, vignette: true }` and\n   * the package exported the default to make that expressible. That spread is a *copy*: the host\n   * now holds every number this package chose, and stops tracking any of them the moment one moves\n   * here. Passing `{ vignette: true }` says what the host decided and leaves the rest ours. `link`\n   * merges one level down, so `{ link: { render: false } }` keeps the measured opacity and width.\n   *\n   * Memoise it, or pass a literal only when it does not change: the reference is what the buffers\n   * are rebuilt on. Omitted entirely, it costs nothing — the shared default is returned by identity.\n   */\n  look?: LookPatch;\n  /**\n   * The force coefficients, as a patch over this package's own — `look`'s twin in every respect,\n   * including why `DEFAULT_SIM` is no longer exported to spread from.\n   */\n  sim?: Partial<Sim>;\n  /**\n   * Off by default, and that is the correct default rather than a cautious one: a bounded source\n   * hands back the coordinates its next spatial query is expressed in, so a force moves the picture\n   * out from under its own index.\n   */\n  simulate?: boolean;\n  clusters?: (number | undefined)[];\n  /**\n   * Which column colours a point, **or a CSS colour every point wears** — Plot's channel name,\n   * Plot's meaning, and Plot's rule that a colour is a constant and anything else is a column.\n   *\n   * **A channel is what you want drawn, so it rides the question and not the source.** Baked into a\n   * source at construction — which is where this used to live — changing what a graph is coloured by\n   * meant building a second source, and *where the bytes are* and *what I want drawn* are not the\n   * same question. Changing it here re-asks over the same bytes, which is all it should ever have\n   * cost.\n   *\n   * As a *constant* it costs no query at all: `fill=\"var(--foreground)\"` is the monochrome picture,\n   * and it is a binding rather than a look, because a look may not rebind an encoding.\n   *\n   * Omitted, the source decides which column: it is the only thing that knows what its corpus\n   * carries.\n   */\n  fill?: string;\n  /**\n   * Which column a point's **shape** carries — Plot's `symbol`, and a peer of colour.\n   *\n   * Bound to the same column as `fill` this is redundant encoding, which is the point on a colourful\n   * document and the only encoding left on a monochrome one. It reads the categorical column the\n   * slice already carries, so it costs no query; a *different* column would need a second categorical\n   * array in the slice and in every source, and is not paid for.\n   *\n   * Binding it takes on an obligation — see `gradeComposition`: shape and size spent at once need a\n   * radius floor, which is a property of what you composed rather than of the form you picked.\n   */\n  symbol?: string;\n  /**\n   * Which column the size ramp is spent on — Plot's `r`.\n   *\n   * Omitted, every point is drawn at one radius, which is a legitimate picture: without a ramp a\n   * look's `form.size` range has only one end.\n   */\n  r?: string;\n  /**\n   * What tints a link. **Absent, each link takes the colour of the vertex it leaves**; a constant\n   * like `var(--muted-foreground)` makes links plain structure.\n   */\n  stroke?: string;\n  /** Vertices that stay drawn whatever the camera is over. */\n  pinned?: VertexId[];\n  limit?: number;\n  debounce?: number;\n  /**\n   * Required, and the only one.\n   *\n   * Its silence is a defect rather than a choice: unhandled, a browser with no WebGL context shows\n   * an empty box and says nothing, and what stands in its place is the host's decision.\n   */\n  onFailure: (message: string) => void;\n  events?: GraphEvents;\n  report?: (motion: Motion) => void;\n  reportProgress?: (value: number) => void;\n  /**\n   * Ask the overlays to reposition after a look has been uploaded.\n   *\n   * Optional, and only owed to `useGraphOverlays`: point sizes changed, so labels sit differently,\n   * and a look change does not tick — with a simulation off there is nothing to schedule a repaint\n   * off. A host drawing no labels passes nothing.\n   *\n   * It goes through the props rather than being read off the api because `useGraphOverlays` is\n   * declared *after* this hook — it takes what this hook returns. A host bridges the two with one\n   * ref, which is the smallest honest answer to a cycle that is genuinely mutual: the overlays need\n   * the graph, and the graph's repaint owes the overlays a nudge.\n   */\n  schedule?: () => void;\n}\n\n/**\n * What a graph publishes — to its own chrome through the provider, and to its host directly.\n *\n * Getters rather than values for the two that change every answer: a legend, an inspector and a\n * hover card all read the graph and the resident map from inside callbacks, and publishing them as\n * values would re-render every consumer on every camera move to hand back a reference they only\n * dereference when something is clicked. `slice` and `resident` ARE values, because a legend counts\n * what is drawn and has to re-render when that changes.\n *\n * **There is no `graphRef` here, and that is deliberate.** `getGraph()` answers every read of it,\n * and a ref object as well would be two ways to express one thing — with the second one writable,\n * which nothing outside `useRenderer` may be.\n */\nexport interface GraphApi {\n  /**\n   * Where the canvas is drawn. `GraphRootProvider` attaches it; a host that renders its own surface\n   * attaches it itself, and nothing works until something does.\n   */\n  hostRef: RefObject<HTMLDivElement | null>;\n  /**\n   * The renderer and the current map, read from inside a callback that was created once.\n   *\n   * **These two nearly left with `GraphOverlayOptions`, and the census is why they stayed.** The\n   * reason they were on the api was that `useGraphOverlays` asked for them as a pair, so every host\n   * copied them out of this object into that hook's argument — which is a re-statement, and that\n   * hook takes the api now. What kept them is a different set of readers: `useGraphSelection` takes\n   * both (its `commit` is a policy only a product can write, so it cannot be folded into the api the\n   * way the overlays were), and a real consumer outside this repository reads `getGraph` and\n   * `getResident` off `useGraphContext()` to paint its own mask over the buffers. Both are reads\n   * from inside a callback registered once, which is exactly the case `slice` and `resident` cannot\n   * serve — a value would re-render every consumer on every camera move to hand back a reference\n   * they only dereference when something is clicked.\n   */\n  getGraph: () => Graph | null;\n  getResident: () => Resident;\n  /** The answer currently drawn, or `null` before the first one. */\n  slice: Slice | null;\n  /** Who is drawn and where, rebuilt with every answer — never build a second one. */\n  resident: Resident;\n  /** How many vertices there are, when the source knows. */\n  total: number | undefined;\n  /** Whether a question is outstanding. */\n  pending: boolean;\n  /** Whether this graph is asked in pieces at all, or fitted under the limit and taken whole. */\n  sliced: boolean;\n  /** Ask again about wherever the camera is now. Wired to the camera already. */\n  refresh: () => void;\n}\n\n/** The empty answer, built once — a ref has to hold something before the first slice arrives. */\nconst NOBODY = residentOf(null);\n\nexport function useGraph(props: UseGraphProps): GraphApi {\n  const {\n    clusters,\n    debounce,\n    events,\n    fill,\n    limit,\n    look: lookPatch,\n    onFailure,\n    pinned,\n    r,\n    report,\n    reportProgress,\n    schedule,\n    sim: simPatch,\n    simulate = false,\n    source,\n    stroke,\n    symbol,\n  } = props;\n\n  /**\n   * The patch, merged with what this package chose — once per change of the patch, not per render.\n   *\n   * The memo is the whole reason this is not inlined. Both resolved values are compared **by\n   * reference** downstream: the look's identity is what `useGraphLook` rebuilds the GPU buffers on,\n   * and the sim's is what `useRenderer` tests before putting energy back into a settled layout. A\n   * merge on every render would upload the same colours sixty times a second and re-heat a graph\n   * nobody had touched.\n   */\n  const look = useMemo(() => resolveLook(lookPatch), [lookPatch]);\n  const sim = useMemo(() => resolveSim(simPatch), [simPatch]);\n\n  /**\n   * The two destinations one vocabulary splits into — and the one column they share.\n   *\n   * A slice carries **one** categorical array, so the query has one column to fetch and the question\n   * is which binding names it: `fill` when it is a column, and `symbol` when `fill` is a constant.\n   * That is not a fallback, it is the monochrome picture stated exactly — identity has moved to\n   * shape, so the column identity lives in is the one `symbol` names.\n   *\n   * Getting this wrong is not a silent failure, which is the one good thing about it: with `fill` a\n   * constant and nothing put in its place, the source fell back to its own default column and DuckDB\n   * answered `Referenced column \"community\" not found`. The browser said so on the first Ink render.\n   *\n   * `stroke` never reaches a query at all — a link's tint is a decision about drawing.\n   */\n  const asked = isColour(fill) ? symbol : fill;\n  const channels = useMemo<Channels>(() => ({ fill, stroke, symbol }), [fill, stroke, symbol]);\n\n  const hostRef = useRef<HTMLDivElement>(null);\n  const graphRef = useRef<Graph | null>(null);\n  const residentRef = useRef<Resident>(NOBODY);\n\n  const { pending, refresh, resident, slice, sliced, total } = useQueryLoop({\n    debounce,\n    fill: asked,\n    graphRef,\n    hostRef,\n    limit,\n    onError: onFailure,\n    pinned,\n    r,\n    source,\n  });\n\n  /**\n   * The resident map, readable from a callback that was created once.\n   *\n   * Written on every render rather than through an effect: a click handler registered with cosmos.gl\n   * at construction reads this on the next gesture, and an effect would leave one frame where the map\n   * describes buffers that are no longer on screen.\n   */\n  residentRef.current = resident;\n\n  const getGraph = useCallback(() => graphRef.current, []);\n  const getResident = useCallback(() => residentRef.current, []);\n\n  /**\n   * The host's handlers, read through a ref.\n   *\n   * cosmos.gl takes its callbacks once, at construction, so a fresh `events` object per render would\n   * either be ignored or force a rebuild of the WebGL context. The ref is what lets a host pass an\n   * inline object without either.\n   */\n  const live = useRef(events);\n  live.current = events;\n\n  const refreshRef = useRef(refresh);\n  refreshRef.current = refresh;\n\n  const wired = useMemo<RendererOptions[\"events\"]>(\n    () => ({\n      onBackgroundClick: () => live.current?.onBackgroundClick?.(),\n      onDragEnd: (index) => {\n        const vertex = residentRef.current.at(index);\n        if (vertex !== undefined) live.current?.onDragEnd?.(vertex);\n      },\n      onPointClick: (graph, index) => {\n        const vertex = residentRef.current.at(index);\n        if (vertex !== undefined) live.current?.onPointClick?.(vertex, graph, index);\n      },\n      onPointerOut: () => live.current?.onPointerOut?.(),\n      onPointerOver: (index) => {\n        const vertex = residentRef.current.at(index);\n        if (vertex !== undefined) live.current?.onPointerOver?.(vertex, index);\n      },\n      onTick: () => live.current?.onTick?.(),\n      // The camera moved, so the graph is re-asked. A host that forgot this line got a canvas that\n      // drew its first answer and never asked again — which is what `refresh` being the host's\n      // responsibility used to cost.\n      onZoom: () => {\n        refreshRef.current();\n        live.current?.onZoom?.();\n      },\n    }),\n    // Built once: every reference inside is a ref this hook owns, so there is nothing to depend on.\n    // It used to close over a ref object a host could substitute, which is the prop this file deletes.\n    [],\n  );\n\n  /**\n   * The renderer, built into an element this hook does not render.\n   *\n   * That is sound and not a gamble: React attaches refs during the commit phase, before any effect\n   * runs, so by the time this effect fires `hostRef.current` is whatever the provider mounted —\n   * including when the provider is a child component, since child refs are attached in the same\n   * commit. A host that calls `useGraph` and renders no surface at all gets a hook that returns\n   * early, forever, which is the honest outcome for a graph with nowhere to go.\n   */\n  useRenderer({\n    clusters,\n    events: wired,\n    graphRef,\n    hostRef,\n    onFailure,\n    report,\n    reportProgress,\n    sim,\n    simulate,\n  });\n\n  useGraphLook({ channels, getGraph, hostRef, look, schedule, slice });\n\n  return { getGraph, getResident, hostRef, pending, refresh, resident, slice, sliced, total };\n}\n"],"names":[],"mappings":";;;;;;;;;AAqNA;AAEO;AACL;AAAM;AACJ;AACA;AACA;AACA;AACA;AACM;AACN;AACA;AACA;AACA;AACA;AACA;AACK;AACM;AACX;AACA;AACA;AAoCwE;AACxE;AACM;AACN;AACA;AACA;AACS;AACT;AACA;AACA;AAUF;AAEA;AAWA;AAEA;AACA;AAEA;AAAc;AACL;;AACoB;AAAA;AAAA;;AAEvB;AACA;AAAoD;AACtD;;AAEE;AACA;AAAsE;AACxE;;AACoB;AAAA;AAAA;;AAElB;AACA;AAAgE;AAClE;;AACc;AAAA;AAAA;AAAA;AAAA;AAAA;;AAKZ;AACA;AACF;AAAA;AAAA;AAAA;AAIF;AAYF;AAAY;AACV;AACQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AAMJ;;;;"}

package/dist/use-query-loop.d.ts

@@ -7,12 +7,18 @@ import { Resident, VertexId } from './resident';
  *
  * This is the half the engine rule requires of anything with an engine — the canvas stays presentational
  * and this owns the asking. It debounces, cancels what the camera has already superseded, and pushes
- * each answer's geometry into the renderer. A host that already holds its arrays wraps them in a
- * source and gets the same path; there is no second one.
+ * each answer's geometry into the renderer. There is one source and it is `openCorpus`; this loop is
+ * written against the contract rather than against it, which is what keeps a second one possible.
  *
  * **A graph that fits pays for nothing.** `total()` is asked first, and under the limit the source is
  * asked once for everything and never again — panning is then free exactly when it can be. Above it,
  * every camera move costs a query, which at 200,000 nodes is the trade that buys the ceiling away.
+ *
+ * **It is also where the question is finished.** A host's `limit` is optional and `minLinkPixels` is
+ * not a host's business at all, and both are **required** on the `SliceRequest` a source receives —
+ * resolved here, once, from `DEFAULT_LIMIT` and `DEFAULT_MIN_LINK_PIXELS`. They used to reach a
+ * source as an exported `BOUNDED_DEFAULTS` table it looked them up in, which made a request
+ * something a source had to *complete* rather than answer, in its own words, in two repositories.
  */
 export interface QueryLoopOptions {
     source: BoundedSource | null;
@@ -77,8 +83,6 @@ export interface QueryLoopState {
     sliced: boolean;
     /** Ask again. Wire it to the camera, and call it when the pinned set changes. */
     refresh: () => void;
-    /** Ask a topological question instead of a spatial one, when the source supports one. */
-    explore: (seeds: VertexId[], depth: number) => void;
 }
 export declare function useQueryLoop(options: QueryLoopOptions): QueryLoopState;
 //# sourceMappingURL=use-query-loop.d.ts.map

package/dist/use-query-loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-query-loop.d.ts","sourceRoot":"","sources":["../src/use-query-loop.ts"],"names":[],"mappings":"AAEA,OAAO,EAAqD,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAC1F,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAIL,KAAK,aAAa,EAElB,KAAK,KAAK,EAEX,MAAM,WAAW,CAAC;AACnB,OAAO,EAAc,KAAK,QAAQ,EAAE,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAGtE;;;;;;;;;;;GAWG;AAEH,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,aAAa,GAAG,IAAI,CAAC;IAC7B,2EAA2E;IAC3E,QAAQ,EAAE,SAAS,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC;IAClC,8EAA8E;IAC9E,OAAO,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;IACvC;;;;;OAKG;IACH,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC;IACpB;;;;;;;;;;OAUG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACrC;AAED,MAAM,WAAW,cAAc;IAC7B,kEAAkE;IAClE,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB;;;;;;;;OAQG;IACH,QAAQ,EAAE,QAAQ,CAAC;IACnB,yCAAyC;IACzC,OAAO,EAAE,OAAO,CAAC;IACjB,0DAA0D;IAC1D,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B;;;;;OAKG;IACH,MAAM,EAAE,OAAO,CAAC;IAChB,iFAAiF;IACjF,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,yFAAyF;IACzF,OAAO,EAAE,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACrD;AAwCD,wBAAgB,YAAY,CAAC,OAAO,EAAE,gBAAgB,GAAG,cAAc,CA6StE"}
+{"version":3,"file":"use-query-loop.d.ts","sourceRoot":"","sources":["../src/use-query-loop.ts"],"names":[],"mappings":"AAEA,OAAO,EAAqD,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAC1F,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAKL,KAAK,aAAa,EAClB,KAAK,KAAK,EAEX,MAAM,WAAW,CAAC;AACnB,OAAO,EAAc,KAAK,QAAQ,EAAE,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAGtE;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,aAAa,GAAG,IAAI,CAAC;IAC7B,2EAA2E;IAC3E,QAAQ,EAAE,SAAS,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC;IAClC,8EAA8E;IAC9E,OAAO,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;IACvC;;;;;OAKG;IACH,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC;IACpB;;;;;;;;;;OAUG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACrC;AAED,MAAM,WAAW,cAAc;IAC7B,kEAAkE;IAClE,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB;;;;;;;;OAQG;IACH,QAAQ,EAAE,QAAQ,CAAC;IACnB,yCAAyC;IACzC,OAAO,EAAE,OAAO,CAAC;IACjB,0DAA0D;IAC1D,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B;;;;;OAKG;IACH,MAAM,EAAE,OAAO,CAAC;IAChB,iFAAiF;IACjF,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAwCD,wBAAgB,YAAY,CAAC,OAAO,EAAE,gBAAgB,GAAG,cAAc,CA4StE"}

package/dist/use-query-loop.js

@@ -1,150 +1,147 @@
 "use client";
-import { useState as I, useRef as m, useCallback as b, useEffect as g, useMemo as L } from "react";
-import { BOUNDED_DEFAULTS as U, isSuperseded as z, shouldSlice as H } from "./bounded.js";
-import { residentOf as Q } from "./resident.js";
-import { whenReady as j } from "./when-ready.js";
-const q = {
+import { useState as y, useRef as d, useCallback as v, useEffect as N, useMemo as G } from "react";
+import { isAbort as U, DEFAULT_MIN_LINK_PIXELS as C, DEFAULT_LIMIT as z, shouldSlice as H } from "./bounded.js";
+import { residentOf as K } from "./resident.js";
+import { whenReady as Q } from "./when-ready.js";
+const X = {
   xMin: Number.NEGATIVE_INFINITY,
   yMin: Number.NEGATIVE_INFINITY,
   xMax: Number.POSITIVE_INFINITY,
   yMax: Number.POSITIVE_INFINITY
 };
-function J(w, N) {
-  const { height: l, width: s } = N.getBoundingClientRect(), [M, c] = w.screenToSpacePosition([0, 0]), [h, y] = w.screenToSpacePosition([s, l]), u = {
-    xMin: Math.min(M, h),
-    yMin: Math.min(c, y),
-    xMax: Math.max(M, h),
-    yMax: Math.max(c, y)
-  }, e = s > 0 ? (u.xMax - u.xMin) / s : 0;
-  return { view: u, perPixel: e };
+function j(T, p) {
+  const { height: f, width: i } = p.getBoundingClientRect(), [M, o] = T.screenToSpacePosition([0, 0]), [m, I] = T.screenToSpacePosition([i, f]), a = {
+    xMin: Math.min(M, m),
+    yMin: Math.min(o, I),
+    xMax: Math.max(M, m),
+    yMax: Math.max(o, I)
+  }, e = i > 0 ? (a.xMax - a.xMin) / i : 0;
+  return { view: a, perPixel: e };
 }
-function tt(w) {
+function tt(T) {
   const {
-    debounce: N = K,
-    fill: l,
-    graphRef: s,
+    debounce: p = q,
+    fill: f,
+    graphRef: i,
     hostRef: M,
-    limit: c = U.limit,
-    onError: h,
-    pinned: y,
-    r: u,
+    limit: o = z,
+    onError: m,
+    pinned: I,
+    r: a,
     source: e
-  } = w, [x, E] = I(null), [Y, V] = I(!1), [k, C] = I(void 0), [A, B] = I(!1), [F, R] = I(null), p = m(null), f = m(null), S = m(!1), T = m(y);
-  T.current = y;
-  const a = m(h);
-  a.current = h;
-  const d = b(
+  } = T, [u, g] = y(null), [R, L] = y(!1), [Y, _] = y(void 0), [O, B] = y(!1), [F, V] = y(null), h = d(null), x = d(null), w = d(!1), E = d(I);
+  E.current = I;
+  const l = d(m);
+  l.current = m;
+  const b = v(
     async (n) => {
-      var r, i;
+      var r, c;
       if (!e) return;
-      (r = p.current) == null || r.abort();
+      (r = h.current) == null || r.abort();
       const t = new AbortController();
-      p.current = t, V(!0);
+      h.current = t, L(!0);
       try {
-        const o = await n(e, t.signal);
+        const s = await n(e, t.signal);
         if (t.signal.aborted) return;
-        E(o);
-      } catch (o) {
-        if (t.signal.aborted || z(o)) return;
-        (i = a.current) == null || i.call(a, String(o));
+        g(s);
+      } catch (s) {
+        if (t.signal.aborted || U(s)) return;
+        (c = l.current) == null || c.call(l, String(s));
       } finally {
-        p.current === t && (p.current = null, V(!1));
+        h.current === t && (h.current = null, L(!1));
       }
     },
     [e]
-  ), _ = m(null), O = b(
+  ), k = d(null), A = v(
     async (n) => {
-      var o;
-      if (!n.extent || _.current === n) return;
-      _.current = n;
+      var s;
+      if (!n.extent || k.current === n) return;
+      k.current = n;
       let t;
       try {
         t = await n.extent();
-      } catch (v) {
-        (o = a.current) == null || o.call(a, String(v));
+      } catch (S) {
+        (s = l.current) == null || s.call(l, String(S));
         return;
       }
-      const r = s.current;
+      const r = i.current;
       if (!r) return;
-      const i = await r.ready.then(() => r);
-      i.setConfigPartial({ spaceSize: Math.max(t.xMax - t.xMin, t.yMax - t.yMin) }), i.fitViewByPointPositions([t.xMin, t.yMin, t.xMax, t.yMax], 0);
+      const c = await r.ready.then(() => r);
+      c.setConfigPartial({ spaceSize: Math.max(t.xMax - t.xMin, t.yMax - t.yMin) }), c.fitViewByPointPositions([t.xMin, t.yMin, t.xMax, t.yMax], 0);
     },
-    [s]
-  ), P = b(() => {
-    S.current && (f.current && clearTimeout(f.current), f.current = setTimeout(() => {
-      f.current = null;
-      const n = s.current, t = M.current;
+    [i]
+  ), P = v(() => {
+    w.current && (x.current && clearTimeout(x.current), x.current = setTimeout(() => {
+      x.current = null;
+      const n = i.current, t = M.current;
       if (!n || !t) return;
-      const { perPixel: r, view: i } = J(n, t);
-      d(
-        (o, v) => o.slice({ view: i, perPixel: r, pinned: T.current, fill: l, r: u, limit: c, signal: v })
-      );
-    }, N));
-  }, [d, N, l, s, M, c, u]), D = b(
-    (n, t) => {
-      var r;
-      if (!e || !("explore" in e)) {
-        (r = a.current) == null || r.call(a, "this source answers regions only");
-        return;
-      }
-      f.current && clearTimeout(f.current), d(
-        (i, o) => i.explore({
-          seeds: n,
-          depth: t,
-          pinned: T.current,
-          fill: l,
-          r: u,
-          limit: c,
-          signal: o
+      const { perPixel: r, view: c } = j(n, t);
+      b(
+        (s, S) => s.slice({
+          view: c,
+          perPixel: r,
+          pinned: E.current,
+          fill: f,
+          r: a,
+          limit: o,
+          minLinkPixels: C,
+          signal: S
         })
       );
-    },
-    [d, l, c, u, e]
-  );
-  g(() => {
+    }, p));
+  }, [b, p, f, i, M, o, a]);
+  N(() => {
     if (!e) {
-      E(null), C(void 0), R(null);
+      g(null), _(void 0), V(null);
       return;
     }
     let n = !0;
     return (async () => {
-      var i;
+      var c;
       let t;
       try {
-        t = await ((i = e.total) == null ? void 0 : i.call(e));
+        t = await ((c = e.total) == null ? void 0 : c.call(e));
       } catch {
       }
       if (!n) return;
-      C(t);
-      const r = H(t, c);
-      S.current = r, B(r), R(e);
+      _(t);
+      const r = H(t, o);
+      w.current = r, B(r), V(e);
     })(), () => {
       n = !1;
     };
-  }, [c, e]), g(() => {
-    !e || F !== e || (async () => (await O(e), S.current ? P() : await d(
-      (n, t) => n.slice({ view: q, pinned: T.current, fill: l, r: u, limit: c, signal: t })
+  }, [o, e]), N(() => {
+    !e || F !== e || (async () => (await A(e), w.current ? P() : await b(
+      (n, t) => n.slice({
+        view: X,
+        pinned: E.current,
+        fill: f,
+        r: a,
+        limit: o,
+        minLinkPixels: C,
+        signal: t
+      })
     )))();
-  }, [d, F, l, O, c, u, P, e]), g(() => {
+  }, [b, F, f, A, o, a, P, e]), N(() => {
     var n;
-    return (n = e == null ? void 0 : e.watch) == null ? void 0 : n.call(e, E);
-  }, [e]), g(
+    return (n = e == null ? void 0 : e.watch) == null ? void 0 : n.call(e, g);
+  }, [e]), N(
     () => () => {
       var n;
-      f.current && clearTimeout(f.current), (n = p.current) == null || n.abort();
+      x.current && clearTimeout(x.current), (n = h.current) == null || n.abort();
     },
     []
-  ), g(() => {
-    const n = s.current;
-    if (!(!n || !x))
-      return j(n, (t) => {
-        t.setPointPositions(x.positions), t.setLinks(x.links), t.render();
+  ), N(() => {
+    const n = i.current;
+    if (!(!n || !u))
+      return Q(n, (t) => {
+        t.setPointPositions(u.positions), t.setLinks(u.links), t.render();
       });
-  }, [s, x]);
-  const G = L(() => Q(x), [x]);
-  return { slice: x, resident: G, pending: Y, total: k, sliced: A, refresh: P, explore: D };
+  }, [i, u]);
+  const D = G(() => K(u), [u]);
+  return { slice: u, resident: D, pending: R, total: Y, sliced: O, refresh: P };
 }
-const K = 120;
+const q = 120;
 export {
   tt as useQueryLoop
 };