@kanzo-tech/graph 0.14.0 → 0.15.1

package/dist/render/graph-model.js.map

@@ -1 +1 @@
-{"version":3,"file":"graph-model.js","sources":["../../src/render/graph-model.ts"],"sourcesContent":["import type { GraphConfig } from \"@cosmos.gl/graph\";\nimport { CHART_SLOTS, categoricalCapacity, categoricalColor } from \"@kanzo-tech/ui\";\nimport { isColour, type Channels } from \"../core/channels\";\nimport type { Composition } from \"./compose\";\nimport { resolveToken, toHex, type Rgba } from \"./css-color\";\nimport { SHAPE_INDEX, SHAPE_ORDER, SHAPE_OTHER, type Look, type Shape } from \"./graph-looks\";\nimport type { Sim } from \"./graph-sim\";\n\n/**\n * The categorical scale the bindings imply — what colour and what shape a category rank wears.\n *\n * One answer for the GPU buffers, the hover card and the legend, because three answers is how a\n * legend ends up disagreeing with the canvas it explains. Values are CSS strings: the DOM resolves\n * them itself, and the buffer path resolves them once on its way to the GPU.\n *\n * `capacity` is where Other begins, and it is the document's number rather than the token\n * vocabulary's: a set derived from a client's brand names 6 to 8 real categories, not always 8.\n */\nexport function scaleOf(channels: Channels, capacity = CHART_SLOTS) {\n  const constant = isColour(channels.fill) ? channels.fill : undefined;\n  const shaped = channels.symbol !== undefined;\n  return {\n    color: (ordinal: number): string => {\n      if (constant) return constant;\n      return ordinal >= capacity ? \"var(--muted-foreground)\" : categoricalColor(ordinal, undefined, capacity);\n    },\n    shape: (ordinal: number): Shape => (shaped ? (SHAPE_ORDER[ordinal] ?? SHAPE_OTHER) : \"circle\"),\n  };\n}\n\nexport interface Paint {\n  colors: Float32Array;\n  sizes: Float32Array;\n  shapes: Float32Array;\n  linkColors: Float32Array;\n  linkWidths: Float32Array;\n}\n\n/**\n * Every per-point and per-link attribute, from one composition and the live theme — what a look or a\n * theme change re-uploads, and all it re-uploads.\n *\n * `host` is the element the tokens are read against, so `var(--primary)` resolves for the tree the\n * canvas sits in. The ramp is `√value` over **this composition** — the biggest node here is what a\n * reader is looking at. A far end past `marks` is drawn at radius zero and alpha zero: it is in the\n * buffers only so an edge has somewhere to end.\n */\nexport function paint(composition: Composition, look: Look, host: Element, channels: Channels = {}): Paint {\n  const scale = scaleOf(channels, categoricalCapacity(host));\n  const rgba = new Map<number, Rgba>();\n  const colourOf = (ordinal: number): Rgba => {\n    let resolved = rgba.get(ordinal);\n    if (!resolved) rgba.set(ordinal, (resolved = resolveToken(host, scale.color(ordinal))));\n    return resolved;\n  };\n  const n = composition.positions.length / 2;\n  const colors = new Float32Array(n * 4);\n  const sizes = new Float32Array(n);\n  const shapes = new Float32Array(n);\n  const ramp = composition.sizes;\n  let lo = 0;\n  let span = 1;\n  if (ramp && composition.marks > 0) {\n    let min = Number.POSITIVE_INFINITY;\n    let max = 0;\n    for (let i = 0; i < composition.marks; i++) {\n      const value = ramp[i] as number;\n      if (value < min) min = value;\n      if (value > max) max = value;\n    }\n    lo = Math.sqrt(Number.isFinite(min) ? min : 0);\n    span = Math.sqrt(max) - lo || 1;\n  }\n  for (let i = 0; i < composition.marks; i++) {\n    const ordinal = composition.categories[i] ?? 0;\n    colors.set(colourOf(ordinal), i * 4);\n    const t = ramp ? (Math.sqrt(ramp[i] as number) - lo) / span : 0;\n    sizes[i] = look.size[0] + t * (look.size[1] - look.size[0]);\n    shapes[i] = SHAPE_INDEX[scale.shape(ordinal)] as number;\n  }\n\n  const count = composition.links.length / 2;\n  const linkColors = new Float32Array(count * 4);\n  const linkWidths = new Float32Array(count);\n  const neutral = channels.stroke ? resolveToken(host, channels.stroke) : null;\n  for (let e = 0; e < count; e++) {\n    const src = composition.links[e * 2] ?? 0;\n    // Link alpha stays 1: `linkOpacity` and the distance fade multiply into it, and a second\n    // opacity here would compound with both.\n    linkColors.set(\n      neutral ? [neutral[0], neutral[1], neutral[2], 1] : [colors[src * 4] ?? 0.7, colors[src * 4 + 1] ?? 0.7, colors[src * 4 + 2] ?? 0.7, 1],\n      e * 4,\n    );\n    const weight = composition.weights?.[e] ?? 1;\n    linkWidths[e] = look.link.width * (1 + Math.log2(Math.max(1, weight)) / 2);\n  }\n  return { colors, sizes, shapes, linkColors, linkWidths };\n}\n\n/** The simulation coefficients, in cosmos.gl's spelling. Shared by construction and every change. */\nexport function forces(sim: Sim): GraphConfig {\n  return {\n    simulationGravity: sim.gravity,\n    simulationRepulsion: sim.repulsion,\n    simulationLinkSpring: sim.linkSpring,\n    simulationLinkDistance: sim.linkDistance,\n    simulationFriction: sim.friction,\n    simulationCluster: sim.cluster,\n  };\n}\n\n/**\n * Everything the picture needs that is *one number for the whole canvas* — cosmos.gl's uniforms, read\n * fresh on every draw, so a look change costs a `setConfigPartial` and no upload at all.\n */\nexport function appearance(look: Look, host: Element): GraphConfig {\n  return {\n    backgroundColor: toHex(resolveToken(host, \"var(--background)\")),\n    scalePointsOnZoom: false,\n    renderLinks: look.link.render,\n    linkOpacity: look.link.opacity,\n    linkDefaultWidth: look.link.width,\n    linkBlending: look.link.blend,\n    curvedLinks: look.link.curve > 0,\n    curvedLinkControlPointDistance: look.link.curve,\n    linkVisibilityDistanceRange: look.link.fade,\n    linkVisibilityMinTransparency: 0.12,\n    renderHoveredPointRing: true,\n    hoveredPointRingColor: toHex(resolveToken(host, \"var(--primary)\")),\n    focusedPointRingColor: toHex(resolveToken(host, \"var(--primary)\")),\n    pointGreyoutOpacity: 0.1,\n    linkGreyoutOpacity: 0.025,\n  };\n}\n"],"names":["scaleOf","channels","capacity","CHART_SLOTS","constant","isColour","shaped","ordinal","categoricalColor","SHAPE_ORDER","SHAPE_OTHER","paint","composition","look","host","scale","categoricalCapacity","rgba","colourOf","resolved","resolveToken","n","colors","sizes","shapes","ramp","lo","span","min","max","i","value","t","SHAPE_INDEX","count","linkColors","linkWidths","neutral","e","src","weight","_a","forces","sim","appearance","toHex"],"mappings":"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"}
+{"version":3,"file":"graph-model.js","sources":["../../src/render/graph-model.ts"],"sourcesContent":["import type { GraphConfig } from \"@cosmos.gl/graph\";\nimport { CHART_SLOTS, categoricalCapacity, categoricalColor } from \"@kanzo-tech/ui\";\nimport { isColour, type Channels } from \"../core/channels\";\nimport type { Encoding, Geometry } from \"../core/load\";\nimport { resolveToken, toHex, type Rgba } from \"./css-color\";\nimport { SHAPE_INDEX, SHAPE_ORDER, SHAPE_OTHER, type Look, type Shape } from \"./graph-looks\";\nimport type { Sim } from \"./graph-sim\";\n\n/**\n * The categorical scale the bindings imply — what colour and what shape a category rank wears.\n *\n * One answer for the GPU buffers, the hover card and the legend, because three answers is how a\n * legend ends up disagreeing with the canvas it explains. Values are CSS strings: the DOM resolves\n * them itself, and the buffer path resolves them once on its way to the GPU.\n *\n * `capacity` is where Other begins, and it is the document's number rather than the token\n * vocabulary's: a set derived from a client's brand names 6 to 8 real categories, not always 8.\n */\nexport function scaleOf(channels: Channels, capacity = CHART_SLOTS) {\n  const constant = isColour(channels.fill) ? channels.fill : undefined;\n  const shaped = channels.symbol !== undefined;\n  return {\n    color: (ordinal: number): string => {\n      if (constant) return constant;\n      return ordinal >= capacity ? \"var(--muted-foreground)\" : categoricalColor(ordinal, undefined, capacity);\n    },\n    shape: (ordinal: number): Shape => (shaped ? (SHAPE_ORDER[ordinal] ?? SHAPE_OTHER) : \"circle\"),\n  };\n}\n\nexport interface Paint {\n  colors: Float32Array;\n  sizes: Float32Array;\n  shapes: Float32Array;\n  linkColors: Float32Array;\n}\n\n/**\n * Every per-point and per-link attribute, from the loaded graph and the live theme — what a binding,\n * a look or a theme change re-uploads, and all it re-uploads.\n *\n * `host` is the element the tokens are read against, so `var(--primary)` resolves for the tree the\n * canvas sits in. The ramp is `√value` over the whole graph, and a vertex with no value takes the\n * smallest radius.\n */\nexport function paint(geometry: Geometry, encoding: Encoding, look: Look, host: Element, channels: Channels = {}): Paint {\n  const scale = scaleOf(channels, categoricalCapacity(host));\n  const rgba = new Map<number, Rgba>();\n  const colourOf = (ordinal: number): Rgba => {\n    let resolved = rgba.get(ordinal);\n    if (!resolved) rgba.set(ordinal, (resolved = resolveToken(host, scale.color(ordinal))));\n    return resolved;\n  };\n  const n = geometry.size;\n  const colors = new Float32Array(n * 4);\n  const sizes = new Float32Array(n);\n  const shapes = new Float32Array(n);\n  const ramp = encoding.sizes;\n  let lo = 0;\n  let span = 1;\n  if (ramp) {\n    let min = Number.POSITIVE_INFINITY;\n    let max = 0;\n    for (let i = 0; i < n; i++) {\n      const value = ramp[i] as number;\n      if (value < min) min = value;\n      if (value > max) max = value;\n    }\n    lo = Math.sqrt(Number.isFinite(min) ? min : 0);\n    span = Math.sqrt(max) - lo || 1;\n  }\n  for (let i = 0; i < n; i++) {\n    const ordinal = encoding.ranks[i] ?? 0;\n    colors.set(colourOf(ordinal), i * 4);\n    const value = ramp ? (ramp[i] as number) : Number.NaN;\n    const t = Number.isNaN(value) ? 0 : (Math.sqrt(value) - lo) / span;\n    sizes[i] = look.size[0] + t * (look.size[1] - look.size[0]);\n    shapes[i] = SHAPE_INDEX[scale.shape(ordinal)] as number;\n  }\n\n  const count = geometry.links.length / 2;\n  const linkColors = new Float32Array(count * 4);\n  const neutral = channels.stroke ? resolveToken(host, channels.stroke) : null;\n  for (let e = 0; e < count; e++) {\n    const src = geometry.links[e * 2] ?? 0;\n    // Link alpha stays 1: `linkOpacity` and the distance fade multiply into it, and a second\n    // opacity here would compound with both.\n    linkColors[e * 4] = neutral ? neutral[0] : (colors[src * 4] ?? 0.7);\n    linkColors[e * 4 + 1] = neutral ? neutral[1] : (colors[src * 4 + 1] ?? 0.7);\n    linkColors[e * 4 + 2] = neutral ? neutral[2] : (colors[src * 4 + 2] ?? 0.7);\n    linkColors[e * 4 + 3] = 1;\n  }\n  return { colors, sizes, shapes, linkColors };\n}\n\n/** The simulation coefficients, in cosmos.gl's spelling. Shared by construction and every change. */\nexport function forces(sim: Sim): GraphConfig {\n  return {\n    simulationGravity: sim.gravity,\n    simulationRepulsion: sim.repulsion,\n    simulationLinkSpring: sim.linkSpring,\n    simulationLinkDistance: sim.linkDistance,\n    simulationFriction: sim.friction,\n    simulationCluster: sim.cluster,\n  };\n}\n\n/**\n * Everything the picture needs that is *one number for the whole canvas* — cosmos.gl's uniforms, read\n * fresh on every draw, so a look change costs a `setConfigPartial` and no upload at all.\n */\nexport function appearance(look: Look, host: Element): GraphConfig {\n  return {\n    backgroundColor: toHex(resolveToken(host, \"var(--background)\")),\n    scalePointsOnZoom: false,\n    renderLinks: look.link.render,\n    linkOpacity: look.link.opacity,\n    linkDefaultWidth: look.link.width,\n    linkBlending: look.link.blend,\n    curvedLinks: look.link.curve > 0,\n    curvedLinkControlPointDistance: look.link.curve,\n    linkVisibilityDistanceRange: look.link.fade,\n    linkVisibilityMinTransparency: 0.12,\n    renderHoveredPointRing: true,\n    hoveredPointRingColor: toHex(resolveToken(host, \"var(--primary)\")),\n    focusedPointRingColor: toHex(resolveToken(host, \"var(--primary)\")),\n    pointGreyoutOpacity: 0.1,\n    linkGreyoutOpacity: 0.025,\n  };\n}\n"],"names":["scaleOf","channels","capacity","CHART_SLOTS","constant","isColour","shaped","ordinal","categoricalColor","SHAPE_ORDER","SHAPE_OTHER","paint","geometry","encoding","look","host","scale","categoricalCapacity","rgba","colourOf","resolved","resolveToken","n","colors","sizes","shapes","ramp","lo","span","min","max","i","value","t","SHAPE_INDEX","count","linkColors","neutral","e","src","forces","sim","appearance","toHex"],"mappings":"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"}

package/dist/render/graph-sim.d.ts

@@ -25,9 +25,8 @@ export interface Sim {
  *
  * Chosen against a corpus of that size, and they are a starting point rather than a law: a graph
  * two orders of magnitude larger wants less repulsion and more friction, and the measurements in
- * `/docs/graph/benchmarks` say a live simulation is finished by around 200,000 points regardless. What a
- * corpus of a given size wants is computed rather than chosen — see `adaptive` — and a host that
- * knows its corpus should start its users at that answer through the tenant policy.
+ * `/docs/graph/benchmarks` say a live simulation is finished by around 200,000 points regardless. A
+ * host that knows its corpus starts its users elsewhere through the tenant policy.
  *
  * The values are strings for the reason `lookFrom`'s are: a contributed preference is a string in
  * all three kinds, so an unrecognised namespace rides through a write untouched. A key that is

package/dist/render/graph-sim.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph-sim.d.ts","sourceRoot":"","sources":["../../src/render/graph-sim.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,iEAAiE;AACjE,MAAM,WAAW,GAAG;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,mGAAmG;IACnG,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,MAAM,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAM,GAAG,GAAG,CAatF;AAED;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,EAAE,GAAe,CAAC;AAE1C;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG,CAGpD"}
+{"version":3,"file":"graph-sim.d.ts","sourceRoot":"","sources":["../../src/render/graph-sim.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,iEAAiE;AACjE,MAAM,WAAW,GAAG;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,mGAAmG;IACnG,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,MAAM,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAM,GAAG,GAAG,CAatF;AAED;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,EAAE,GAAe,CAAC;AAE1C;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG,CAGpD"}

package/dist/render/graph-sim.js.map

@@ -1 +1 @@
-{"version":3,"file":"graph-sim.js","sources":["../../src/render/graph-sim.ts"],"sourcesContent":["/**\n * The force coefficients, and the one function that builds them from the axes a person chose.\n *\n * `graph-looks.ts`'s sibling, and deliberately its twin: a type the renderer consumes, one builder\n * that reads declared string values, and a default that is the builder called with nothing. What was\n * here before is what was there before — an interface, a `DEFAULT_SIM` table beside it, and a dock\n * that held six of them in React state and drew six sliders by hand.\n *\n * **A coefficient is not appearance, and it is still a preference.** `section.ts` says why it shares\n * the manifest: `tokens` are the colours a document may move, `prefs` are what the person on the\n * screen decides, and somebody tuning a layout until it settles is deciding.\n */\n\n/** Force coefficients, handed straight to the GPU simulation. */\nexport interface Sim {\n  gravity: number;\n  repulsion: number;\n  linkSpring: number;\n  linkDistance: number;\n  friction: number;\n  /** Pull toward the node's group position on the cluster ring. Zero lets the links decide alone. */\n  cluster: number;\n}\n\n/**\n * Coefficients that settle a few-hundred-node graph into something readable.\n *\n * Chosen against a corpus of that size, and they are a starting point rather than a law: a graph\n * two orders of magnitude larger wants less repulsion and more friction, and the measurements in\n * `/docs/graph/benchmarks` say a live simulation is finished by around 200,000 points regardless. What a\n * corpus of a given size wants is computed rather than chosen — see `adaptive` — and a host that\n * knows its corpus should start its users at that answer through the tenant policy.\n *\n * The values are strings for the reason `lookFrom`'s are: a contributed preference is a string in\n * all three kinds, so an unrecognised namespace rides through a write untouched. A key that is\n * missing, or that carries a value the section never offered, takes the default below — which is\n * what a graph simulated before any of this existed.\n */\nexport function simFrom(values: Readonly<Record<string, string | undefined>> = {}): Sim {\n  const num = (key: string, fallback: number) => {\n    const value = Number.parseFloat(values[key] ?? \"\");\n    return Number.isFinite(value) ? value : fallback;\n  };\n  return {\n    gravity: num(\"gravity\", 0.14),\n    repulsion: num(\"repulsion\", 1.1),\n    linkSpring: num(\"link-spring\", 0.6),\n    linkDistance: num(\"link-distance\", 18),\n    friction: num(\"friction\", 0.86),\n    cluster: num(\"cluster\", 0.1),\n  };\n}\n\n/**\n * What a canvas simulates with when nobody has chosen anything.\n *\n * **Not on the barrel, and it used to be** — for the reason its twin was: it is `simFrom()`, a\n * second public name for a value already available on request, exported only because `sim` took a\n * whole `Sim` and a host changing `gravity` had to supply the other five.\n */\nexport const DEFAULT_SIM: Sim = simFrom();\n\n/**\n * The coefficients a caller wants different, over the ones this package chose.\n *\n * Flat, so a spread is the whole merge. `undefined` returns the shared constant rather than a copy:\n * the renderer re-heats when the forces change, so a fresh object\n * per render would put energy back into a settled layout on every render.\n */\nexport function resolveSim(patch?: Partial<Sim>): Sim {\n  if (!patch) return DEFAULT_SIM;\n  return { ...DEFAULT_SIM, ...patch };\n}\n"],"names":["simFrom","values","num","key","fallback","value","DEFAULT_SIM","resolveSim","patch"],"mappings":"AAsCO,SAASA,EAAQC,IAAuD,IAAS;AACtF,QAAMC,IAAM,CAACC,GAAaC,MAAqB;AAC7C,UAAMC,IAAQ,OAAO,WAAWJ,EAAOE,CAAG,KAAK,EAAE;AACjD,WAAO,OAAO,SAASE,CAAK,IAAIA,IAAQD;AAAA,EAC1C;AACA,SAAO;AAAA,IACL,SAASF,EAAI,WAAW,IAAI;AAAA,IAC5B,WAAWA,EAAI,aAAa,GAAG;AAAA,IAC/B,YAAYA,EAAI,eAAe,GAAG;AAAA,IAClC,cAAcA,EAAI,iBAAiB,EAAE;AAAA,IACrC,UAAUA,EAAI,YAAY,IAAI;AAAA,IAC9B,SAASA,EAAI,WAAW,GAAG;AAAA,EAAA;AAE/B;AASO,MAAMI,IAAmBN,EAAA;AASzB,SAASO,EAAWC,GAA2B;AACpD,SAAKA,IACE,EAAE,GAAGF,GAAa,GAAGE,EAAA,IADTF;AAErB;"}
+{"version":3,"file":"graph-sim.js","sources":["../../src/render/graph-sim.ts"],"sourcesContent":["/**\n * The force coefficients, and the one function that builds them from the axes a person chose.\n *\n * `graph-looks.ts`'s sibling, and deliberately its twin: a type the renderer consumes, one builder\n * that reads declared string values, and a default that is the builder called with nothing. What was\n * here before is what was there before — an interface, a `DEFAULT_SIM` table beside it, and a dock\n * that held six of them in React state and drew six sliders by hand.\n *\n * **A coefficient is not appearance, and it is still a preference.** `section.ts` says why it shares\n * the manifest: `tokens` are the colours a document may move, `prefs` are what the person on the\n * screen decides, and somebody tuning a layout until it settles is deciding.\n */\n\n/** Force coefficients, handed straight to the GPU simulation. */\nexport interface Sim {\n  gravity: number;\n  repulsion: number;\n  linkSpring: number;\n  linkDistance: number;\n  friction: number;\n  /** Pull toward the node's group position on the cluster ring. Zero lets the links decide alone. */\n  cluster: number;\n}\n\n/**\n * Coefficients that settle a few-hundred-node graph into something readable.\n *\n * Chosen against a corpus of that size, and they are a starting point rather than a law: a graph\n * two orders of magnitude larger wants less repulsion and more friction, and the measurements in\n * `/docs/graph/benchmarks` say a live simulation is finished by around 200,000 points regardless. A\n * host that knows its corpus starts its users elsewhere through the tenant policy.\n *\n * The values are strings for the reason `lookFrom`'s are: a contributed preference is a string in\n * all three kinds, so an unrecognised namespace rides through a write untouched. A key that is\n * missing, or that carries a value the section never offered, takes the default below — which is\n * what a graph simulated before any of this existed.\n */\nexport function simFrom(values: Readonly<Record<string, string | undefined>> = {}): Sim {\n  const num = (key: string, fallback: number) => {\n    const value = Number.parseFloat(values[key] ?? \"\");\n    return Number.isFinite(value) ? value : fallback;\n  };\n  return {\n    gravity: num(\"gravity\", 0.14),\n    repulsion: num(\"repulsion\", 1.1),\n    linkSpring: num(\"link-spring\", 0.6),\n    linkDistance: num(\"link-distance\", 18),\n    friction: num(\"friction\", 0.86),\n    cluster: num(\"cluster\", 0.1),\n  };\n}\n\n/**\n * What a canvas simulates with when nobody has chosen anything.\n *\n * **Not on the barrel, and it used to be** — for the reason its twin was: it is `simFrom()`, a\n * second public name for a value already available on request, exported only because `sim` took a\n * whole `Sim` and a host changing `gravity` had to supply the other five.\n */\nexport const DEFAULT_SIM: Sim = simFrom();\n\n/**\n * The coefficients a caller wants different, over the ones this package chose.\n *\n * Flat, so a spread is the whole merge. `undefined` returns the shared constant rather than a copy:\n * the renderer re-heats when the forces change, so a fresh object\n * per render would put energy back into a settled layout on every render.\n */\nexport function resolveSim(patch?: Partial<Sim>): Sim {\n  if (!patch) return DEFAULT_SIM;\n  return { ...DEFAULT_SIM, ...patch };\n}\n"],"names":["simFrom","values","num","key","fallback","value","DEFAULT_SIM","resolveSim","patch"],"mappings":"AAqCO,SAASA,EAAQC,IAAuD,IAAS;AACtF,QAAMC,IAAM,CAACC,GAAaC,MAAqB;AAC7C,UAAMC,IAAQ,OAAO,WAAWJ,EAAOE,CAAG,KAAK,EAAE;AACjD,WAAO,OAAO,SAASE,CAAK,IAAIA,IAAQD;AAAA,EAC1C;AACA,SAAO;AAAA,IACL,SAASF,EAAI,WAAW,IAAI;AAAA,IAC5B,WAAWA,EAAI,aAAa,GAAG;AAAA,IAC/B,YAAYA,EAAI,eAAe,GAAG;AAAA,IAClC,cAAcA,EAAI,iBAAiB,EAAE;AAAA,IACrC,UAAUA,EAAI,YAAY,IAAI;AAAA,IAC9B,SAASA,EAAI,WAAW,GAAG;AAAA,EAAA;AAE/B;AASO,MAAMI,IAAmBN,EAAA;AASzB,SAASO,EAAWC,GAA2B;AACpD,SAAKA,IACE,EAAE,GAAGF,GAAa,GAAGE,EAAA,IADTF;AAErB;"}

package/dist/render/renderer.d.ts

@@ -1,20 +1,14 @@
 import { Graph } from '@cosmos.gl/graph';
-import { Resident } from '../core/resident';
 import { GraphStore } from '../core/store';
 import { GraphCommands } from '../core/types';
-import { Composition } from './compose';
 export interface RendererEvents {
     /** After every frame and every camera move — where the overlays repaint. */
     onFrame?: () => void;
-    /** A new composition was uploaded. */
-    onComposed?: (composition: Composition) => void;
     /** Where the hovered point is in space, as cosmos.gl reports it: no GPU readback per hover. */
     onHover?: (position: [number, number] | null) => void;
 }
 export interface Renderer extends GraphCommands {
     readonly graph: Graph;
-    resident(): Resident;
-    composition(): Composition | null;
     /** The theme moved under the canvas: colours are resolved again, nothing else. */
     repaint(): void;
     /** The drawn points inside a screen rectangle or polygon, once the device is ready. */
@@ -29,15 +23,16 @@ export interface Renderer extends GraphCommands {
  * **cosmos.gl's lifetime, and the frame that renders once.** Built once per element; it subscribes to
  * the store and discharges what changed in one `requestAnimationFrame`:
  *
- * - a change of visible tiles recomposes, and dirties positions, links and the per-point arrays;
- * - a look or a theme change dirties colours, sizes and shapes and nothing else;
+ * - a new graph uploads positions and links, once per corpus; a filter uploads positions alone;
+ * - a binding, a look or a theme change uploads colours, sizes and shapes and nothing else;
  * - a selection, a focus or a pin sets config and uploads nothing, and never calls `render()`:
  *   `render()` walks every point and link in JS, and `setConfigPartial` asks for its own frame;
- * - a snapshot that changed none of those schedules nothing.
+ * - the camera reaches nothing: cosmos.gl moves it, and the overlays follow.
  *
+ * A vertex's id is its index here, so nothing is resolved between the store and the buffers.
  * `transitionDuration` is 0: the default animates every upload for 800 ms and keeps the loop awake.
- * The live layout is off unless `simulate` or the toolbar asks, and runs from the current positions;
- * a drag needs none, since cosmos.gl moves the dragged point itself. Every callback reads the store's latest options, so a host's inline `onFailure` never rebuilds it.
+ * The live layout is off unless `simulate` or the toolbar asks, and runs from the current positions.
+ * Every callback reads the store's latest options, so a host's inline `onFailure` never rebuilds it.
  */
 export declare function createRenderer(host: HTMLDivElement, store: GraphStore, events?: RendererEvents): Renderer | null;
 //# sourceMappingURL=renderer.d.ts.map

package/dist/render/renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/render/renderer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEzC,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,kBAAkB,CAAC;AAE3D,OAAO,KAAK,EAAiB,UAAU,EAAE,MAAM,eAAe,CAAC;AAE/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAkB,KAAK,WAAW,EAAE,MAAM,WAAW,CAAC;AAM7D,MAAM,WAAW,cAAc;IAC7B,4EAA4E;IAC5E,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,sCAAsC;IACtC,UAAU,CAAC,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,IAAI,CAAC;IAChD,+FAA+F;IAC/F,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,KAAK,IAAI,CAAC;CACvD;AAED,MAAM,WAAW,QAAS,SAAQ,aAAa;IAC7C,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,IAAI,QAAQ,CAAC;IACrB,WAAW,IAAI,WAAW,GAAG,IAAI,CAAC;IAClC,kFAAkF;IAClF,OAAO,IAAI,IAAI,CAAC;IAChB,uFAAuF;IACvF,GAAG,CAAC,KAAK,EAAE;QAAE,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;KAAE,GAAG;QAAE,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAA;KAAE,GAAG,MAAM,EAAE,CAAC;IACvG,OAAO,IAAI,IAAI,CAAC;CACjB;AAUD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,GAAE,cAAmB,GAAG,QAAQ,GAAG,IAAI,CAiVpH"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/render/renderer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEzC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,aAAa,EAAY,MAAM,eAAe,CAAC;AAM7D,MAAM,WAAW,cAAc;IAC7B,4EAA4E;IAC5E,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,+FAA+F;IAC/F,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,KAAK,IAAI,CAAC;CACvD;AAED,MAAM,WAAW,QAAS,SAAQ,aAAa;IAC7C,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,kFAAkF;IAClF,OAAO,IAAI,IAAI,CAAC;IAChB,uFAAuF;IACvF,GAAG,CAAC,KAAK,EAAE;QAAE,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;KAAE,GAAG;QAAE,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAA;KAAE,GAAG,MAAM,EAAE,CAAC;IACvG,OAAO,IAAI,IAAI,CAAC;CACjB;AAqBD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,GAAE,cAAmB,GAAG,QAAQ,GAAG,IAAI,CA8QpH"}

package/dist/render/renderer.js

@@ -1,43 +1,41 @@
-import { Graph as v } from "@cosmos.gl/graph";
-import { denseOf as ii } from "../core/resident.js";
-import { tileOfDense as ni } from "../core/tile-matrix.js";
-import { createComposer as ti } from "./compose.js";
-import { resolveLook as _ } from "./graph-looks.js";
-import { forces as R, appearance as U, paint as ei } from "./graph-model.js";
-import { resolveSim as Z } from "./graph-sim.js";
-import { hasWebGL as oi, releaseContext as ri } from "./webgl.js";
-const S = 420, y = 0.18, O = 0.35, j = 20, C = (c) => [c.x, c.y, c.x + c.w, c.y + c.h];
-function gi(c, e, o = {}) {
-  const M = (i) => e.getOptions().onFailure(i);
-  if (!oi())
-    return M("This canvas renders on the GPU, and this browser offers no WebGL context."), null;
-  let b = Z(e.getOptions().sim), g = e.getOptions().simulate ?? !1, T = null, k = null, F = -1;
-  const B = (i) => {
-    const n = Math.round(i * j);
-    n !== F && (F = n, e.reportProgress(n / j));
-  }, Y = ti();
-  let d = null, w = _(e.getOptions().look), E = e.getOptions().look;
-  const s = { compose: !0, paint: !0, state: !0, pinned: !0 };
-  let P = 0, I = !1, A = null, x = null, f = e.getSnapshot(), h = e.getOptions();
-  const m = () => (d == null ? void 0 : d.resident) ?? ai, z = () => {
-    const { height: i, width: n } = c.getBoundingClientRect();
-    if (!t.isReady || n === 0 || i === 0) return null;
-    const [a, l] = t.screenToSpacePosition([0, 0]), [u, p] = t.screenToSpacePosition([n, i]), r = { xMin: Math.min(a, u), yMin: Math.min(l, p), xMax: Math.max(a, u), yMax: Math.max(l, p) };
-    return { view: r, perPixel: (r.xMax - r.xMin) / n };
-  }, G = () => {
-    const i = z();
-    i && e.setViewport(i.view);
+import { Graph as j } from "@cosmos.gl/graph";
+import { resolveLook as B } from "./graph-looks.js";
+import { forces as x, appearance as H, paint as $ } from "./graph-model.js";
+import { resolveSim as M } from "./graph-sim.js";
+import { hasWebGL as J, releaseContext as K } from "./webgl.js";
+const C = 420, z = 0.18, S = 0.35, V = 20, _ = (s) => [s.x, s.y, s.x + s.w, s.y + s.h];
+function Q(s, i) {
+  if (!i) return s.positions;
+  const e = s.positions.slice();
+  for (let l = 0; l < s.size; l++)
+    i[l] || (e[l * 2] = e[l * 2 + 1] = Number.NaN);
+  return e;
+}
+function on(s, i, e = {}) {
+  const l = (n) => i.getOptions().onFailure(n);
+  if (!J())
+    return l("This canvas renders on the GPU, and this browser offers no WebGL context."), null;
+  let h = M(i.getOptions().sim), f = i.getOptions().simulate ?? !1, k = null, y = null, D = -1;
+  const F = (n) => {
+    const t = Math.round(n * V);
+    t !== D && (D = t, i.reportProgress(t / V));
+  };
+  let P = B(i.getOptions().look), I = i.getOptions().look;
+  const r = { positions: !0, paint: !0, state: !0, pinned: !0 };
+  let g = 0, L = !1, T = null, b = null, u = i.getSnapshot(), p = i.getOptions();
+  const E = () => {
+    var n;
+    return ((n = i.getSnapshot().geometry) == null ? void 0 : n.size) ?? 0;
   };
-  let t;
+  let o;
   try {
-    t = new v(c, {
-      // No `spaceSize` here: the box is the corpus's extent, set when the matrix arrives.
-      // `rescalePositions: false` because the corpus's coordinates are the camera's — a rescale
-      // between them means the cull and the viewport describe different places.
+    o = new j(s, {
+      // No `spaceSize` here: the box is the corpus's extent, set when the graph has loaded.
+      // `rescalePositions: false` because the corpus's coordinates are the camera's.
       rescalePositions: !1,
       transitionDuration: 0,
-      enableSimulation: g,
-      ...R(b),
+      enableSimulation: f,
+      ...x(h),
       // Frames to convergence: alpha reaches its floor after exactly this many rendered frames.
       simulationDecay: 400,
       randomSeed: "kanzo-discovery",
@@ -45,188 +43,137 @@ function gi(c, e, o = {}) {
       enableDrag: !0,
       hoveredPointCursor: "pointer",
       attribution: "",
-      onSimulationStart: () => e.report("running"),
+      onSimulationStart: () => i.report("running"),
       onSimulationEnd: () => {
-        var i;
-        e.report("settled"), B(1), (i = o.onFrame) == null || i.call(o);
+        var n;
+        i.report("settled"), F(1), (n = e.onFrame) == null || n.call(e);
       },
-      onSimulationPause: () => e.report("paused"),
-      onSimulationUnpause: () => e.report("running"),
-      onSimulationTick: (i, n, a) => {
-        var l, u;
-        B(t.progress), n !== void 0 && a && ((l = o.onHover) == null || l.call(o, a)), (u = o.onFrame) == null || u.call(o);
+      onSimulationPause: () => i.report("paused"),
+      onSimulationUnpause: () => i.report("running"),
+      onSimulationTick: (n, t, a) => {
+        var c, d;
+        F(o.progress), t !== void 0 && a && ((c = e.onHover) == null || c.call(e, a)), (d = e.onFrame) == null || d.call(e);
       },
       onZoom: () => {
-        var i;
-        G(), (i = o.onFrame) == null || i.call(o);
+        var n;
+        return (n = e.onFrame) == null ? void 0 : n.call(e);
       },
-      onPointMouseOver: (i, n) => {
+      onPointMouseOver: (n, t) => {
         var a;
-        T = i, (a = o.onHover) == null || a.call(o, n), e.hover(m().at(i) ?? null);
+        k = n, (a = e.onHover) == null || a.call(e, t), i.hover(n);
       },
       onPointMouseOut: () => {
-        var i;
-        T = null, (i = o.onHover) == null || i.call(o, null), e.hover(null);
+        var n;
+        k = null, (n = e.onHover) == null || n.call(e, null), i.hover(null);
       },
       onDragStart: () => {
-        k = T;
+        y = k;
       },
-      onDrag: (i) => {
-        var n, a;
-        (n = o.onHover) == null || n.call(o, t.screenToSpacePosition([i.x, i.y])), (a = o.onFrame) == null || a.call(o);
+      onDrag: (n) => {
+        var t, a;
+        (t = e.onHover) == null || t.call(e, o.screenToSpacePosition([n.x, n.y])), (a = e.onFrame) == null || a.call(e);
       },
       onDragEnd: () => {
-        const i = k === null ? void 0 : m().at(k);
-        k = null, i !== void 0 && e.pin([...e.getSnapshot().pinned, i]);
-      },
-      onPointClick: (i) => {
-        const n = m().at(i);
-        n !== void 0 && H(n, i);
+        const n = y;
+        y = null, n !== null && i.pin([...i.getSnapshot().pinned, n]);
       },
-      onBackgroundClick: () => W()
+      onPointClick: (n) => R(n),
+      onBackgroundClick: () => A()
     });
-  } catch (i) {
-    return M(`The renderer failed to start. (${String(i)})`), null;
+  } catch (n) {
+    return l(`The renderer failed to start. (${String(n)})`), null;
   }
-  const D = () => {
-    P || (P = requestAnimationFrame(() => {
-      P = 0, $();
+  const w = () => {
+    g || (g = requestAnimationFrame(() => {
+      g = 0, q();
     }));
   };
-  function $() {
-    var l, u, p;
-    const i = e.getSnapshot(), n = e.getOptions();
-    let a = !1;
-    if (s.compose && i.matrix) {
-      s.compose = !1;
-      const r = Y({
-        matrix: i.matrix,
-        typeIndex: i.typeIndex,
-        binding: i.binding,
-        modeColumn: i.modeColumn,
-        domain: i.domain,
-        visible: i.visible,
-        cached: i.cached,
-        perPixel: ((l = z()) == null ? void 0 : l.perPixel) ?? 0
-      });
-      if (r && (d = r, t.setPointPositions(r.positions, !0), t.setLinks(r.links), s.paint = !0, s.state = !0, s.pinned = !0, a = !0, (u = o.onComposed) == null || u.call(o, r), x !== null && r.resident.indexOf(x) !== void 0)) {
-        const X = x;
-        x = null, queueMicrotask(() => q(X));
-      }
-      const Q = r && { marks: r.marks, represented: r.represented, domain: r.domain, tally: r.tally };
-      e.reportDrawn(i.visible, Q);
-    }
-    if (s.paint && d) {
-      s.paint = !1;
-      const r = ei(d, w, c, n);
-      t.setPointColors(r.colors), t.setPointSizes(r.sizes), t.setPointShapes(r.shapes), t.setLinkColors(r.linkColors), t.setLinkWidths(r.linkWidths), t.setConfigPartial(U(w, c)), a = !0;
-    }
-    if (s.state && d) {
-      s.state = !1;
-      const r = d.resident;
-      t.setConfigPartial({
-        highlightedPointIndices: i.selection ? r.indicesOf(i.selection.vertices) : void 0,
-        focusedPointIndex: i.focus === null ? void 0 : r.indexOf(i.focus)
-      });
+  function q() {
+    var N;
+    const n = i.getSnapshot(), { geometry: t, encoding: a } = n, c = i.getOptions();
+    let d = !1;
+    if (r.positions && t && (r.positions = !1, U(t), o.setPointPositions(Q(t, n.mask), !0), t.links !== b && (b = t.links, o.setLinks(b), r.paint = r.state = r.pinned = !0), d = !0), r.paint && t && a) {
+      r.paint = !1;
+      const m = $(t, a, P, s, c);
+      o.setPointColors(m.colors), o.setPointSizes(m.sizes), o.setPointShapes(m.shapes), o.setLinkColors(m.linkColors), o.setConfigPartial(H(P, s)), d = !0;
     }
-    if (s.pinned && d) {
-      s.pinned = !1;
-      const r = d.resident.indicesOf(i.pinned);
-      t.setPinnedPoints(r.length > 0 ? r : null);
-    }
-    a && t.render(), (p = o.onFrame) == null || p.call(o);
+    r.state && t && (r.state = !1, o.setConfigPartial({
+      highlightedPointIndices: n.selection ? n.selection.vertices.filter((m) => m < t.size) : void 0,
+      focusedPointIndex: n.focus === null || n.focus >= t.size ? void 0 : n.focus
+    })), r.pinned && t && (r.pinned = !1, o.setPinnedPoints(n.pinned.length > 0 ? [...n.pinned] : null)), d && o.render(), t && a && !r.paint && i.reportDrawn(n), (N = e.onFrame) == null || N.call(e);
   }
-  const V = (i) => {
-    var a;
-    const n = (a = i.matrix) == null ? void 0 : a.extent;
-    !n || i.matrix === A || (A = i.matrix, t.setConfigPartial({ spaceSize: Math.max(n.w, n.h) }), t.fitViewByPointPositions(C(n), 0, y), t.ready.then(() => {
-      I || G();
-    }));
-  }, J = e.subscribe(() => {
-    const i = e.getSnapshot(), n = e.getOptions();
-    V(i), (i.visible !== f.visible || i.binding !== f.binding || i.domain !== f.domain) && (s.compose = !0), n.look !== E && (E = n.look, w = _(n.look), s.paint = !0), (n.fill !== h.fill || n.symbol !== h.symbol || n.stroke !== h.stroke) && (s.paint = !0), (i.selection !== f.selection || i.focus !== f.focus) && (s.state = !0), i.pinned !== f.pinned && (s.pinned = !0), n.sim !== h.sim && K(n.sim), (n.simulate ?? !1) !== (h.simulate ?? !1) && (n.simulate ? L(O) : t.pause()), f = i, h = n, (s.compose || s.paint || s.state || s.pinned) && D();
-  });
-  function K(i) {
-    const n = Z(i), a = Object.keys(n).some((l) => n[l] !== b[l]);
-    b = n, g && (t.setConfigPartial(R(n)), a && e.getSnapshot().motion !== "paused" && t.start(O));
+  function U(n) {
+    n === T || !n.extent || (T = n, o.setConfigPartial({ spaceSize: Math.max(n.extent.w, n.extent.h) }), o.fitViewByPointPositions(_(n.extent), 0, z));
   }
-  function L(i) {
-    g || (g = !0, t.setConfigPartial({ enableSimulation: !0, ...R(b) })), t.start(i);
+  const W = i.subscribe(() => {
+    const n = i.getSnapshot(), t = i.getOptions();
+    (n.geometry !== u.geometry || n.mask !== u.mask) && (r.positions = !0), n.encoding !== u.encoding && (r.paint = !0), t.look !== I && (I = t.look, P = B(t.look), r.paint = !0), (t.fill !== p.fill || t.symbol !== p.symbol || t.stroke !== p.stroke) && (r.paint = !0), (n.selection !== u.selection || n.focus !== u.focus) && (r.state = !0), n.pinned !== u.pinned && (r.pinned = !0), t.sim !== p.sim && Z(t.sim), (t.simulate ?? !1) !== (p.simulate ?? !1) && (t.simulate ? O(S) : o.pause()), u = n, p = t, (r.positions || r.paint || r.state || r.pinned) && w();
+  });
+  function Z(n) {
+    const t = M(n), a = Object.keys(t).some((c) => t[c] !== h[c]);
+    h = t, f && (o.setConfigPartial(x(t)), a && i.getSnapshot().motion !== "paused" && o.start(S));
   }
-  function H(i, n) {
-    const l = m().verticesAt(t.getNeighboringPointIndices(n));
-    e.select([i, ...l], "node", "Node"), e.focus(i);
+  function O(n) {
+    f || (f = !0, o.setConfigPartial({ enableSimulation: !0, ...x(h) })), o.start(n);
   }
-  function W() {
-    e.select(null), e.focus(null);
+  function R(n) {
+    const t = o.getNeighboringPointIndices(n) ?? [];
+    i.select([n, ...t], "node", "Node"), i.focus(n);
   }
-  function q(i) {
-    var p, r;
-    const n = m().indexOf(i);
-    if (n !== void 0) {
-      H(i, n), t.zoomToPointByIndex(n, 500, 5, !0);
-      return;
-    }
-    const a = e.getSnapshot().matrix, l = a ? ni(a, ii(i)) : null, u = l && ((r = (p = a == null ? void 0 : a.tileMatrices[l.z]) == null ? void 0 : p.tiles[l.tile]) == null ? void 0 : r.bbox);
-    u && (x = i, t.fitViewByPointPositions(C(u), S, y));
+  function A() {
+    i.select(null), i.focus(null);
   }
-  t.setConfigPartial(U(w, c)), t.render();
-  const N = (i) => {
-    i.preventDefault(), M("The graph's WebGL context was lost. A browser keeps a limited number of them and drops the oldest; reload the page to get one back.");
+  o.setConfigPartial(H(P, s)), o.render();
+  const G = (n) => {
+    n.preventDefault(), l("The graph's WebGL context was lost. A browser keeps a limited number of them and drops the oldest; reload the page to get one back.");
   };
-  return t.ready.then(() => {
-    var i;
-    I || (i = c.querySelector("canvas")) == null || i.addEventListener("webglcontextlost", N);
-  }), e.report(g && t.isSimulationRunning ? "running" : "settled"), V(f), D(), {
-    graph: t,
-    resident: m,
-    composition: () => d,
+  return o.ready.then(() => {
+    var n;
+    L || (n = s.querySelector("canvas")) == null || n.addEventListener("webglcontextlost", G);
+  }), i.report(f && o.isSimulationRunning ? "running" : "settled"), w(), {
+    graph: o,
     repaint() {
-      s.paint = !0, D();
+      r.paint = !0, w();
     },
-    hit(i) {
-      const n = "rect" in i ? t.findPointsInRect(i.rect) : t.findPointsInPolygon(i.polygon);
-      return Array.from(n);
+    hit(n) {
+      const t = "rect" in n ? o.findPointsInRect(n.rect) : o.findPointsInPolygon(n.polygon);
+      return Array.from(t);
     },
-    zoomBy(i) {
-      t.setZoomLevel(t.getZoomLevel() * i, 220);
+    zoomBy(n) {
+      o.setZoomLevel(o.getZoomLevel() * n, 220);
     },
     fit() {
-      var n;
-      const i = (n = e.getSnapshot().matrix) == null ? void 0 : n.extent;
-      i ? t.fitViewByPointPositions(C(i), S, y) : t.fitView(S, y);
+      var t;
+      const n = (t = i.getSnapshot().geometry) == null ? void 0 : t.extent;
+      n ? o.fitViewByPointPositions(_(n), C, z) : o.fitView(C, z);
     },
-    pause: () => t.pause(),
+    pause: () => o.pause(),
     resume() {
-      e.getSnapshot().motion === "settled" || !g ? L(O) : t.unpause();
+      i.getSnapshot().motion === "settled" || !f ? O(S) : o.unpause();
     },
     restart() {
-      e.pin([]), L(1);
+      i.pin([]), O(1);
     },
     unpin() {
-      e.getSnapshot().pinned.length !== 0 && (e.pin([]), e.getSnapshot().motion === "running" && t.start(O));
+      i.getSnapshot().pinned.length !== 0 && (i.pin([]), i.getSnapshot().motion === "running" && o.start(S));
     },
-    reveal: q,
-    frameBox(i, { duration: n = S, padding: a = y } = {}) {
-      t.fitViewByPointPositions(C(i), n, a);
+    reveal(n) {
+      n >= E() || (R(n), o.zoomToPointByIndex(n, 500, 5, !0));
     },
     frameSelection() {
-      var n;
-      const i = m().indicesOf(((n = e.getSnapshot().selection) == null ? void 0 : n.vertices) ?? []);
-      i.length > 0 && t.fitViewByPointIndices(i, S, 0.25);
+      var t;
+      const n = (((t = i.getSnapshot().selection) == null ? void 0 : t.vertices) ?? []).filter((a) => a < E());
+      n.length > 0 && o.fitViewByPointIndices(n, C, 0.25);
     },
-    clear: W,
+    clear: A,
     destroy() {
-      J(), P && cancelAnimationFrame(P), I = !0;
-      const i = c.querySelector("canvas");
-      i == null || i.removeEventListener("webglcontextlost", N), t.destroy(), ri(i);
+      W(), g && cancelAnimationFrame(g), L = !0;
+      const n = s.querySelector("canvas");
+      n == null || n.removeEventListener("webglcontextlost", G), o.destroy(), K(n);
     }
   };
 }
-const ai = { size: 0, indexOf: () => {
-}, at: () => {
-}, indicesOf: () => [], verticesAt: () => [] };
 export {
-  gi as createRenderer
+  on as createRenderer
 };
 //# sourceMappingURL=renderer.js.map