@kanzo-tech/graph 0.25.0 → 0.27.0

package/dist/render/camera.js.map

@@ -1 +1 @@
-{"version":3,"file":"camera.js","sources":["../../src/render/camera.ts"],"sourcesContent":["import type { Graph } from \"@cosmos.gl/graph\";\n\nexport const FIT_DURATION = 420;\nconst FIT_PADDING = 0.18;\n/** How often a running layout re-frames the camera, and how long each re-frame glides. */\nconst FOLLOW_EVERY = 900;\nconst FOLLOW_DURATION = 700;\n\nexport interface Camera {\n  /** A corpus was placed: frame these corners now, and again whenever the canvas changes size. */\n  frame(corners: readonly number[]): void;\n  /** The reader asked for the whole graph: frame it, and keep it framed through a resize. */\n  fit(): void;\n  /** A layout started moving the points: the corners are history, and the camera follows. */\n  run(): void;\n  tick(): void;\n  settle(): void;\n  destroy(): void;\n}\n\n/**\n * **Who holds the camera, and when it gives it back.** The camera frames the corpus once it is\n * placed and keeps it framed — through cosmos.gl's device coming up and every resize of the canvas,\n * since a host's split panel settles its width after mount and a frame taken at the old size opens\n * zoomed into a corner — and while a layout runs it follows the moving points and frames them when\n * they settle: Cosmograph's fit-on-settle, kept up. All of it stops the moment the reader zooms or\n * pans, and comes back with Fit or the next run.\n */\nexport function createCamera(graph: Graph, host: HTMLElement): { camera: Camera; taken: (userDriven: boolean) => void } {\n  let corners: readonly number[] | null = null;\n  let framing = false;\n  let following = false;\n  let followed = 0;\n  let pending = 0;\n\n  const fitNow = (duration: number) => {\n    if (corners) graph.fitViewByPointPositions([...corners], duration, FIT_PADDING);\n    else graph.fitView(duration, FIT_PADDING);\n  };\n  const reframe = () => {\n    pending = 0;\n    if (framing && !following) fitNow(0);\n  };\n  // After cosmos.gl's own observer has resized the canvas, so the frame is taken at the new size.\n  const resizes =\n    typeof ResizeObserver === \"undefined\"\n      ? null\n      : new ResizeObserver(() => {\n          if (!pending) pending = requestAnimationFrame(reframe);\n        });\n  resizes?.observe(host);\n  void graph.ready.then(reframe, () => {});\n\n  const camera: Camera = {\n    frame(next) {\n      corners = next;\n      framing = true;\n      fitNow(0);\n    },\n    fit() {\n      framing = true;\n      fitNow(FIT_DURATION);\n    },\n    run() {\n      corners = null;\n      following = true;\n      followed = performance.now();\n    },\n    tick() {\n      const now = performance.now();\n      if (!following || now - followed < FOLLOW_EVERY) return;\n      followed = now;\n      graph.fitView(FOLLOW_DURATION, FIT_PADDING);\n    },\n    settle() {\n      if (following) graph.fitView(FIT_DURATION, FIT_PADDING);\n      following = false;\n    },\n    destroy() {\n      resizes?.disconnect();\n      if (pending) cancelAnimationFrame(pending);\n    },\n  };\n  const taken = (userDriven: boolean) => {\n    if (!userDriven) return;\n    framing = false;\n    following = false;\n  };\n  return { camera, taken };\n}\n"],"names":["FIT_DURATION","createCamera","graph","host","corners","framing","following","followed","pending","fitNow","duration","reframe","resizes","next","now","userDriven"],"mappings":"AAEO,MAAMA,IAAe;AA0BrB,SAASC,EAAaC,GAAcC,GAA6E;AACtH,MAAIC,IAAoC,MACpCC,IAAU,IACVC,IAAY,IACZC,IAAW,GACXC,IAAU;AAEd,QAAMC,IAAS,CAACC,MAAqB;AACnC,IAAIN,MAAe,wBAAwB,CAAC,GAAGA,CAAO,GAAGM,GAAU,IAAW,IACzER,EAAM,QAAQQ,GAAU,IAAW;AAAA,EAC1C,GACMC,IAAU,MAAM;AACpB,IAAAH,IAAU,GACNH,KAAW,CAACC,KAAWG,EAAO,CAAC;AAAA,EACrC,GAEMG,IACJ,OAAO,iBAAmB,MACtB,OACA,IAAI,eAAe,MAAM;AACvB,IAAKJ,MAASA,IAAU,sBAAsBG,CAAO;AAAA,EACvD,CAAC;AACP,SAAAC,KAAA,QAAAA,EAAS,QAAQT,IACZD,EAAM,MAAM,KAAKS,GAAS,MAAM;AAAA,EAAC,CAAC,GAqChC,EAAE,QAnCc;AAAA,IACrB,MAAME,GAAM;AACV,MAAAT,IAAUS,GACVR,IAAU,IACVI,EAAO,CAAC;AAAA,IACV;AAAA,IACA,MAAM;AACJ,MAAAJ,IAAU,IACVI,EAAO,GAAY;AAAA,IACrB;AAAA,IACA,MAAM;AACJ,MAAAL,IAAU,MACVE,IAAY,IACZC,IAAW,YAAY,IAAA;AAAA,IACzB;AAAA,IACA,OAAO;AACL,YAAMO,IAAM,YAAY,IAAA;AACxB,MAAI,CAACR,KAAaQ,IAAMP,IAAW,QACnCA,IAAWO,GACXZ,EAAM,QAAQ,KAAiB,IAAW;AAAA,IAC5C;AAAA,IACA,SAAS;AACP,MAAII,KAAWJ,EAAM,QAAQ,KAAc,IAAW,GACtDI,IAAY;AAAA,IACd;AAAA,IACA,UAAU;AACR,MAAAM,KAAA,QAAAA,EAAS,cACLJ,0BAA8BA,CAAO;AAAA,IAC3C;AAAA,EAAA,GAOe,OALH,CAACO,MAAwB;AACrC,IAAKA,MACLV,IAAU,IACVC,IAAY;AAAA,EACd,EACiB;AACnB;"}
+{"version":3,"file":"camera.js","sources":["../../src/render/camera.ts"],"sourcesContent":["import type { Graph } from \"@cosmos.gl/graph\";\nimport { GraphError } from \"../core/error\";\n\nexport const FIT_DURATION = 420;\nconst FIT_PADDING = 0.18;\n/** How often a running layout re-frames the camera, and how long each re-frame glides. */\nconst FOLLOW_EVERY = 900;\nconst FOLLOW_DURATION = 700;\n\nexport interface Camera {\n  /** A corpus was placed: frame these corners now, and again whenever the canvas changes size. */\n  frame(corners: readonly number[]): void;\n  /** The reader asked for the whole graph: frame it, and keep it framed through a resize. */\n  fit(): void;\n  /** A layout started moving the points: the corners are history, and the camera follows. */\n  run(): void;\n  /** cosmos.gl's device came up: the frame is taken again, at the canvas's size. */\n  ready(): void;\n  /** cosmos.gl was handed positions and rendered them: from now on a fit may read them back. */\n  drawn(): void;\n  tick(): void;\n  settle(): void;\n  destroy(): void;\n}\n\n/**\n * **Who holds the camera, and when it gives it back.** The camera frames the corpus once it is\n * placed and keeps it framed — through cosmos.gl's device coming up and every resize of the canvas,\n * since a host's split panel settles its width after mount and a frame taken at the old size opens\n * zoomed into a corner — and while a layout runs it follows the moving points and frames them when\n * they settle: Cosmograph's fit-on-settle, kept up. All of it stops the moment the reader zooms or\n * pans, and comes back with Fit or the next run.\n *\n * **A fit without corners reads the points back from the GPU** (`fitView` → `getPointPositions` →\n * `readPixels` of cosmos.gl's position framebuffer), so it waits until there is one to read: the\n * device is up and a render has uploaded positions. If the read throws anyway, cosmos.gl holds no\n * positions: that is `graph/no-positions`, reported once through `fail`, and the camera reads no more\n * — rather than the same exception on every tick of a layout over a blank canvas.\n */\nexport function createCamera(\n  graph: Graph,\n  host: HTMLElement,\n  fail: (error: GraphError) => void,\n): { camera: Camera; taken: (userDriven: boolean) => void } {\n  let corners: readonly number[] | null = null;\n  let framing = false;\n  let following = false;\n  let followed = 0;\n  let pending = 0;\n  let drawn = false;\n  let broken = false;\n  let gone = false;\n\n  const fitPoints = (duration: number) => {\n    if (!drawn || broken || !graph.isReady) return;\n    try {\n      graph.fitView(duration, FIT_PADDING);\n    } catch (error) {\n      broken = true;\n      following = false;\n      fail(new GraphError(\"graph/no-positions\", \"cosmos.gl holds no positions on the GPU to draw or frame.\", {}, { cause: error }));\n    }\n  };\n  const fitNow = (duration: number) => {\n    if (corners) graph.fitViewByPointPositions([...corners], duration, FIT_PADDING);\n    else fitPoints(duration);\n  };\n  const reframe = () => {\n    pending = 0;\n    if (framing && !following) fitNow(0);\n  };\n  const later = () => {\n    if (!pending && !gone) pending = requestAnimationFrame(reframe);\n  };\n  // After cosmos.gl's own observer has resized the canvas, so the frame is taken at the new size.\n  const resizes = typeof ResizeObserver === \"undefined\" ? null : new ResizeObserver(later);\n  resizes?.observe(host);\n\n  const camera: Camera = {\n    frame(next) {\n      corners = next;\n      framing = true;\n      fitNow(0);\n    },\n    fit() {\n      framing = true;\n      fitNow(FIT_DURATION);\n    },\n    run() {\n      corners = null;\n      following = true;\n      followed = performance.now();\n    },\n    // A frame later: the commands cosmos.gl queued for its device run in the same turn as this.\n    ready: later,\n    drawn() {\n      drawn = true;\n    },\n    tick() {\n      const now = performance.now();\n      if (!following || now - followed < FOLLOW_EVERY) return;\n      followed = now;\n      fitPoints(FOLLOW_DURATION);\n    },\n    settle() {\n      if (following) fitPoints(FIT_DURATION);\n      following = false;\n    },\n    destroy() {\n      gone = true;\n      resizes?.disconnect();\n      if (pending) cancelAnimationFrame(pending);\n    },\n  };\n  const taken = (userDriven: boolean) => {\n    if (!userDriven) return;\n    framing = false;\n    following = false;\n  };\n  return { camera, taken };\n}\n"],"names":["FIT_DURATION","FIT_PADDING","FOLLOW_EVERY","FOLLOW_DURATION","createCamera","graph","host","fail","corners","framing","following","followed","pending","drawn","broken","gone","fitPoints","duration","error","GraphError","fitNow","reframe","later","resizes","next","now","userDriven"],"mappings":";AAGO,MAAMA,IAAe,KACtBC,IAAc,MAEdC,IAAe,KACfC,IAAkB;AAgCjB,SAASC,EACdC,GACAC,GACAC,GAC0D;AAC1D,MAAIC,IAAoC,MACpCC,IAAU,IACVC,IAAY,IACZC,IAAW,GACXC,IAAU,GACVC,IAAQ,IACRC,IAAS,IACTC,IAAO;AAEX,QAAMC,IAAY,CAACC,MAAqB;AACtC,QAAI,GAACJ,KAASC,KAAU,CAACT,EAAM;AAC/B,UAAI;AACF,QAAAA,EAAM,QAAQY,GAAUhB,CAAW;AAAA,MACrC,SAASiB,GAAO;AACd,QAAAJ,IAAS,IACTJ,IAAY,IACZH,EAAK,IAAIY,EAAW,sBAAsB,6DAA6D,CAAA,GAAI,EAAE,OAAOD,EAAA,CAAO,CAAC;AAAA,MAC9H;AAAA,EACF,GACME,IAAS,CAACH,MAAqB;AACnC,IAAIT,MAAe,wBAAwB,CAAC,GAAGA,CAAO,GAAGS,GAAUhB,CAAW,MAC/DgB,CAAQ;AAAA,EACzB,GACMI,IAAU,MAAM;AACpB,IAAAT,IAAU,GACNH,KAAW,CAACC,KAAWU,EAAO,CAAC;AAAA,EACrC,GACME,IAAQ,MAAM;AAClB,IAAI,CAACV,KAAW,CAACG,MAAMH,IAAU,sBAAsBS,CAAO;AAAA,EAChE,GAEME,IAAU,OAAO,iBAAmB,MAAc,OAAO,IAAI,eAAeD,CAAK;AACvF,SAAAC,KAAA,QAAAA,EAAS,QAAQjB,IA2CV,EAAE,QAzCc;AAAA,IACrB,MAAMkB,GAAM;AACV,MAAAhB,IAAUgB,GACVf,IAAU,IACVW,EAAO,CAAC;AAAA,IACV;AAAA,IACA,MAAM;AACJ,MAAAX,IAAU,IACVW,EAAOpB,CAAY;AAAA,IACrB;AAAA,IACA,MAAM;AACJ,MAAAQ,IAAU,MACVE,IAAY,IACZC,IAAW,YAAY,IAAA;AAAA,IACzB;AAAA;AAAA,IAEA,OAAOW;AAAA,IACP,QAAQ;AACN,MAAAT,IAAQ;AAAA,IACV;AAAA,IACA,OAAO;AACL,YAAMY,IAAM,YAAY,IAAA;AACxB,MAAI,CAACf,KAAae,IAAMd,IAAWT,MACnCS,IAAWc,GACXT,EAAUb,CAAe;AAAA,IAC3B;AAAA,IACA,SAAS;AACP,MAAIO,OAAqBV,CAAY,GACrCU,IAAY;AAAA,IACd;AAAA,IACA,UAAU;AACR,MAAAK,IAAO,IACPQ,KAAA,QAAAA,EAAS,cACLX,0BAA8BA,CAAO;AAAA,IAC3C;AAAA,EAAA,GAOe,OALH,CAACc,MAAwB;AACrC,IAAKA,MACLjB,IAAU,IACVC,IAAY;AAAA,EACd,EACiB;AACnB;"}

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

@@ -17,7 +17,7 @@ export interface Sim {
     linkSpring: number;
     linkDistance: number;
     friction: number;
-    /** Pull toward the node's group position on the cluster ring. Zero lets the links decide alone. */
+    /** Pull toward the centre of the vertex's cluster, when a column is bound to `cluster`. Zero lets the links decide alone. */
     cluster: number;
 }
 /**

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;;;;;;;;;;;;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"}
+{"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,6HAA6H;IAC7H,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. 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;"}
+{"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 centre of the vertex's cluster, when a column is bound to `cluster`. 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/motion.d.ts

@@ -0,0 +1,33 @@
+import { Geometry } from '../core/load';
+import { GraphOptions } from '../core/state';
+/**
+ * **What the renderer decides from the data**, apart from cosmos.gl so it can be read and tested
+ * without a GPU: how long a layout cools, when it hides links, whether it runs, and what a filter
+ * or a pick leaves in full colour.
+ */
+/**
+ * How long a layout cools, in frames: cosmos.gl's alpha reaches its floor after exactly this many.
+ * Measured on the gate in `/docs/graph/layout`: the shape is done in one to three seconds at every
+ * size, so a layout that runs on is spending frames, not reaching a better picture — 600 settles
+ * 200,000 vertices in about ten seconds at sixty frames, and past that 240 does the same at half the
+ * frame rate.
+ */
+export declare const decayFor: (size: number) => number;
+/**
+ * Past this many links a running layout does not draw them: drawing them is the cost, not the
+ * forces — at 800,000 links a layout ticked 14 times a second with them and 51 without (the gate).
+ * They come back when it settles.
+ */
+export declare const LINKS_WHILE_RUNNING = 250000;
+/** Whether a layout should run: as `simulate` says, else exactly when the positions are not the data's. */
+export declare const simulating: (options: GraphOptions, geometry: Geometry | null) => boolean;
+/**
+ * **What is in full colour**, and everything else is greyed out: the vertices the page's filter keeps
+ * and — when the reader picked some — that they picked; and the links whose two ends are both. cosmos.gl
+ * greys links apart from points, so the links are said out loud.
+ */
+export declare function highlighted(geometry: Geometry, mask: Uint8Array | null, selection: readonly number[] | null): {
+    highlightedPointIndices: number[] | undefined;
+    highlightedLinkIndices: number[] | undefined;
+};
+//# sourceMappingURL=motion.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"motion.d.ts","sourceRoot":"","sources":["../../src/render/motion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAElD;;;;GAIG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GAAI,MAAM,MAAM,KAAG,MAAsC,CAAC;AAC/E;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,SAAU,CAAC;AAE3C,2GAA2G;AAC3G,eAAO,MAAM,UAAU,GAAI,SAAS,YAAY,EAAE,UAAU,QAAQ,GAAG,IAAI,KAAG,OAClB,CAAC;AAE7D;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,UAAU,GAAG,IAAI,EACvB,SAAS,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,GAClC;IAAE,uBAAuB,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IAAC,sBAAsB,EAAE,MAAM,EAAE,GAAG,SAAS,CAAA;CAAE,CAWjG"}

package/dist/render/motion.js

@@ -0,0 +1,19 @@
+const e = (n) => n > 2e5 ? 240 : 600, u = 25e4, c = (n, l) => n.simulate ?? (l !== null && !l.bound);
+function f(n, l, s) {
+  if (l === null && s === null) return { highlightedPointIndices: void 0, highlightedLinkIndices: void 0 };
+  const t = new Uint8Array(n.size);
+  if (s === null) t.set(l);
+  else for (const i of s) i < n.size && (l === null || l[i]) && (t[i] = 1);
+  const d = [];
+  for (let i = 0; i < n.size; i++) t[i] && d.push(i);
+  const o = [], { links: h } = n;
+  for (let i = 0; i < h.length / 2; i++) t[h[2 * i]] && t[h[2 * i + 1]] && o.push(i);
+  return { highlightedPointIndices: d, highlightedLinkIndices: o };
+}
+export {
+  u as LINKS_WHILE_RUNNING,
+  e as decayFor,
+  f as highlighted,
+  c as simulating
+};
+//# sourceMappingURL=motion.js.map

package/dist/render/motion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"motion.js","sources":["../../src/render/motion.ts"],"sourcesContent":["import type { Geometry } from \"../core/load\";\nimport type { GraphOptions } from \"../core/state\";\n\n/**\n * **What the renderer decides from the data**, apart from cosmos.gl so it can be read and tested\n * without a GPU: how long a layout cools, when it hides links, whether it runs, and what a filter\n * or a pick leaves in full colour.\n */\n\n/**\n * How long a layout cools, in frames: cosmos.gl's alpha reaches its floor after exactly this many.\n * Measured on the gate in `/docs/graph/layout`: the shape is done in one to three seconds at every\n * size, so a layout that runs on is spending frames, not reaching a better picture — 600 settles\n * 200,000 vertices in about ten seconds at sixty frames, and past that 240 does the same at half the\n * frame rate.\n */\nexport const decayFor = (size: number): number => (size > 200_000 ? 240 : 600);\n/**\n * Past this many links a running layout does not draw them: drawing them is the cost, not the\n * forces — at 800,000 links a layout ticked 14 times a second with them and 51 without (the gate).\n * They come back when it settles.\n */\nexport const LINKS_WHILE_RUNNING = 250_000;\n\n/** Whether a layout should run: as `simulate` says, else exactly when the positions are not the data's. */\nexport const simulating = (options: GraphOptions, geometry: Geometry | null): boolean =>\n  options.simulate ?? (geometry !== null && !geometry.bound);\n\n/**\n * **What is in full colour**, and everything else is greyed out: the vertices the page's filter keeps\n * and — when the reader picked some — that they picked; and the links whose two ends are both. cosmos.gl\n * greys links apart from points, so the links are said out loud.\n */\nexport function highlighted(\n  geometry: Geometry,\n  mask: Uint8Array | null,\n  selection: readonly number[] | null,\n): { highlightedPointIndices: number[] | undefined; highlightedLinkIndices: number[] | undefined } {\n  if (mask === null && selection === null) return { highlightedPointIndices: undefined, highlightedLinkIndices: undefined };\n  const on = new Uint8Array(geometry.size);\n  if (selection === null) on.set(mask as Uint8Array);\n  else for (const id of selection) if (id < geometry.size && (mask === null || mask[id])) on[id] = 1;\n  const points: number[] = [];\n  for (let id = 0; id < geometry.size; id++) if (on[id]) points.push(id);\n  const linkIds: number[] = [];\n  const { links } = geometry;\n  for (let e = 0; e < links.length / 2; e++) if (on[links[2 * e] as number] && on[links[2 * e + 1] as number]) linkIds.push(e);\n  return { highlightedPointIndices: points, highlightedLinkIndices: linkIds };\n}\n"],"names":["decayFor","size","LINKS_WHILE_RUNNING","simulating","options","geometry","highlighted","mask","selection","on","id","points","linkIds","links","e"],"mappings":"AAgBO,MAAMA,IAAW,CAACC,MAA0BA,IAAO,MAAU,MAAM,KAM7DC,IAAsB,MAGtBC,IAAa,CAACC,GAAuBC,MAChDD,EAAQ,aAAaC,MAAa,QAAQ,CAACA,EAAS;AAO/C,SAASC,EACdD,GACAE,GACAC,GACiG;AACjG,MAAID,MAAS,QAAQC,MAAc,aAAa,EAAE,yBAAyB,QAAW,wBAAwB,OAAA;AAC9G,QAAMC,IAAK,IAAI,WAAWJ,EAAS,IAAI;AACvC,MAAIG,MAAc,KAAM,CAAAC,EAAG,IAAIF,CAAkB;AAAA,MAC5C,YAAWG,KAAMF,EAAW,CAAIE,IAAKL,EAAS,SAASE,MAAS,QAAQA,EAAKG,CAAE,OAAID,EAAGC,CAAE,IAAI;AACjG,QAAMC,IAAmB,CAAA;AACzB,WAASD,IAAK,GAAGA,IAAKL,EAAS,MAAMK,IAAM,CAAID,EAAGC,CAAE,KAAGC,EAAO,KAAKD,CAAE;AACrE,QAAME,IAAoB,CAAA,GACpB,EAAE,OAAAC,MAAUR;AAClB,WAASS,IAAI,GAAGA,IAAID,EAAM,SAAS,GAAGC,IAAK,CAAIL,EAAGI,EAAM,IAAIC,CAAC,CAAW,KAAKL,EAAGI,EAAM,IAAIC,IAAI,CAAC,CAAW,KAAGF,EAAQ,KAAKE,CAAC;AAC3H,SAAO,EAAE,yBAAyBH,GAAQ,wBAAwBC,EAAA;AACpE;"}

package/dist/render/placement.d.ts

@@ -12,11 +12,9 @@ export interface Placement {
     readonly dx: number;
     readonly dy: number;
 }
-/** No extent — no row has a position — so nothing moves and nothing is drawn. */
-export declare const UNPLACED: Placement;
 export declare function placementOf(extent: Extent, box: number): Placement;
-/** The loaded positions in the square, with `NaN` where the page's filter hides a vertex — cosmos.gl draws no such point. */
-export declare function placed(geometry: Geometry, at: Placement, mask: Uint8Array | null): Float32Array;
+/** Bound positions in the square. A vertex with no value stays `NaN`, which cosmos.gl does not draw. */
+export declare function placed(positions: Float32Array, at: Placement): Float32Array;
 /** The extent's corners in the square, for a camera that frames it. */
 export declare function cornersOf(extent: Extent, at: Placement): number[];
 export {};

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

@@ -1 +1 @@
-{"version":3,"file":"placement.d.ts","sourceRoot":"","sources":["../../src/render/placement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE7C,KAAK,MAAM,GAAG,WAAW,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC;AAE9C;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB;AAED,iFAAiF;AACjF,eAAO,MAAM,QAAQ,EAAE,SAA2C,CAAC;AAEnE,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,CAKlE;AAED,6HAA6H;AAC7H,wBAAgB,MAAM,CAAC,QAAQ,EAAE,QAAQ,EAAE,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,UAAU,GAAG,IAAI,GAAG,YAAY,CAS/F;AAED,uEAAuE;AACvE,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,SAAS,GAAG,MAAM,EAAE,CAEjE"}
+{"version":3,"file":"placement.d.ts","sourceRoot":"","sources":["../../src/render/placement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE7C,KAAK,MAAM,GAAG,WAAW,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC;AAE9C;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,CAKlE;AAED,wGAAwG;AACxG,wBAAgB,MAAM,CAAC,SAAS,EAAE,YAAY,EAAE,EAAE,EAAE,SAAS,GAAG,YAAY,CAO3E;AAED,uEAAuE;AACvE,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,SAAS,GAAG,MAAM,EAAE,CAEjE"}

package/dist/render/placement.js

@@ -1,23 +1,19 @@
-const u = { side: 0, k: 1, dx: 0, dy: 0 };
-function l(d, o) {
-  const s = Math.max(d.w, d.h, 2), n = s > o ? o / s : 1, c = s * n;
-  return { side: c, k: n, dx: (c - d.w * n) / 2 - d.x * n, dy: (c - d.h * n) / 2 - d.y * n };
+function l(r, c) {
+  const y = Math.max(r.w, r.h, 2), d = y > c ? c / y : 1, k = y * d;
+  return { side: k, k: d, dx: (k - r.w * d) / 2 - r.x * d, dy: (k - r.h * d) / 2 - r.y * d };
 }
-function y(d, o, s) {
-  const { positions: n } = d, c = new Float32Array(n.length);
-  for (let r = 0; r < d.size; r++) {
-    const i = s !== null && !s[r];
-    c[r * 2] = i ? Number.NaN : n[r * 2] * o.k + o.dx, c[r * 2 + 1] = i ? Number.NaN : n[r * 2 + 1] * o.k + o.dy;
-  }
-  return c;
+function u(r, c) {
+  const y = new Float32Array(r.length);
+  for (let d = 0; d < r.length; d += 2)
+    y[d] = r[d] * c.k + c.dx, y[d + 1] = r[d + 1] * c.k + c.dy;
+  return y;
 }
-function k(d, o) {
-  return [d.x * o.k + o.dx, d.y * o.k + o.dy, (d.x + d.w) * o.k + o.dx, (d.y + d.h) * o.k + o.dy];
+function f(r, c) {
+  return [r.x * c.k + c.dx, r.y * c.k + c.dy, (r.x + r.w) * c.k + c.dx, (r.y + r.h) * c.k + c.dy];
 }
 export {
-  u as UNPLACED,
-  k as cornersOf,
-  y as placed,
+  f as cornersOf,
+  u as placed,
   l as placementOf
 };
 //# sourceMappingURL=placement.js.map

package/dist/render/placement.js.map

@@ -1 +1 @@
-{"version":3,"file":"placement.js","sources":["../../src/render/placement.ts"],"sourcesContent":["import type { Geometry } from \"../core/load\";\n\ntype Extent = NonNullable<Geometry[\"extent\"]>;\n\n/**\n * **Where the corpus's extent sits in cosmos.gl's square** — centred, at its own scale, and scaled\n * down only past the box the device can simulate in. Drawing alone is translation-invariant, but the\n * layout is not: gravity pulls toward the square's centre and many-body bins points on a grid over\n * `[0, side]²`, so an extent left where it was contracts toward a corner and falls off the grid.\n */\nexport interface Placement {\n  readonly side: number;\n  readonly k: number;\n  readonly dx: number;\n  readonly dy: number;\n}\n\n/** No extent — no row has a position — so nothing moves and nothing is drawn. */\nexport const UNPLACED: Placement = { side: 0, k: 1, dx: 0, dy: 0 };\n\nexport function placementOf(extent: Extent, box: number): Placement {\n  const longest = Math.max(extent.w, extent.h, 2);\n  const k = longest > box ? box / longest : 1;\n  const side = longest * k;\n  return { side, k, dx: (side - extent.w * k) / 2 - extent.x * k, dy: (side - extent.h * k) / 2 - extent.y * k };\n}\n\n/** The loaded positions in the square, with `NaN` where the page's filter hides a vertex — cosmos.gl draws no such point. */\nexport function placed(geometry: Geometry, at: Placement, mask: Uint8Array | null): Float32Array {\n  const { positions } = geometry;\n  const out = new Float32Array(positions.length);\n  for (let id = 0; id < geometry.size; id++) {\n    const hidden = mask !== null && !mask[id];\n    out[id * 2] = hidden ? Number.NaN : (positions[id * 2] as number) * at.k + at.dx;\n    out[id * 2 + 1] = hidden ? Number.NaN : (positions[id * 2 + 1] as number) * at.k + at.dy;\n  }\n  return out;\n}\n\n/** The extent's corners in the square, for a camera that frames it. */\nexport function cornersOf(extent: Extent, at: Placement): number[] {\n  return [extent.x * at.k + at.dx, extent.y * at.k + at.dy, (extent.x + extent.w) * at.k + at.dx, (extent.y + extent.h) * at.k + at.dy];\n}\n"],"names":["UNPLACED","placementOf","extent","box","longest","k","side","placed","geometry","at","mask","positions","out","id","hidden","cornersOf"],"mappings":"AAkBO,MAAMA,IAAsB,EAAE,MAAM,GAAG,GAAG,GAAG,IAAI,GAAG,IAAI,EAAA;AAExD,SAASC,EAAYC,GAAgBC,GAAwB;AAClE,QAAMC,IAAU,KAAK,IAAIF,EAAO,GAAGA,EAAO,GAAG,CAAC,GACxCG,IAAID,IAAUD,IAAMA,IAAMC,IAAU,GACpCE,IAAOF,IAAUC;AACvB,SAAO,EAAE,MAAAC,GAAM,GAAAD,GAAG,KAAKC,IAAOJ,EAAO,IAAIG,KAAK,IAAIH,EAAO,IAAIG,GAAG,KAAKC,IAAOJ,EAAO,IAAIG,KAAK,IAAIH,EAAO,IAAIG,EAAA;AAC7G;AAGO,SAASE,EAAOC,GAAoBC,GAAeC,GAAuC;AAC/F,QAAM,EAAE,WAAAC,MAAcH,GAChBI,IAAM,IAAI,aAAaD,EAAU,MAAM;AAC7C,WAASE,IAAK,GAAGA,IAAKL,EAAS,MAAMK,KAAM;AACzC,UAAMC,IAASJ,MAAS,QAAQ,CAACA,EAAKG,CAAE;AACxC,IAAAD,EAAIC,IAAK,CAAC,IAAIC,IAAS,OAAO,MAAOH,EAAUE,IAAK,CAAC,IAAeJ,EAAG,IAAIA,EAAG,IAC9EG,EAAIC,IAAK,IAAI,CAAC,IAAIC,IAAS,OAAO,MAAOH,EAAUE,IAAK,IAAI,CAAC,IAAeJ,EAAG,IAAIA,EAAG;AAAA,EACxF;AACA,SAAOG;AACT;AAGO,SAASG,EAAUb,GAAgBO,GAAyB;AACjE,SAAO,CAACP,EAAO,IAAIO,EAAG,IAAIA,EAAG,IAAIP,EAAO,IAAIO,EAAG,IAAIA,EAAG,KAAKP,EAAO,IAAIA,EAAO,KAAKO,EAAG,IAAIA,EAAG,KAAKP,EAAO,IAAIA,EAAO,KAAKO,EAAG,IAAIA,EAAG,EAAE;AACtI;"}
+{"version":3,"file":"placement.js","sources":["../../src/render/placement.ts"],"sourcesContent":["import type { Geometry } from \"../core/load\";\n\ntype Extent = NonNullable<Geometry[\"extent\"]>;\n\n/**\n * **Where the corpus's extent sits in cosmos.gl's square** — centred, at its own scale, and scaled\n * down only past the box the device can simulate in. Drawing alone is translation-invariant, but the\n * layout is not: gravity pulls toward the square's centre and many-body bins points on a grid over\n * `[0, side]²`, so an extent left where it was contracts toward a corner and falls off the grid.\n */\nexport interface Placement {\n  readonly side: number;\n  readonly k: number;\n  readonly dx: number;\n  readonly dy: number;\n}\n\nexport function placementOf(extent: Extent, box: number): Placement {\n  const longest = Math.max(extent.w, extent.h, 2);\n  const k = longest > box ? box / longest : 1;\n  const side = longest * k;\n  return { side, k, dx: (side - extent.w * k) / 2 - extent.x * k, dy: (side - extent.h * k) / 2 - extent.y * k };\n}\n\n/** Bound positions in the square. A vertex with no value stays `NaN`, which cosmos.gl does not draw. */\nexport function placed(positions: Float32Array, at: Placement): Float32Array {\n  const out = new Float32Array(positions.length);\n  for (let i = 0; i < positions.length; i += 2) {\n    out[i] = (positions[i] as number) * at.k + at.dx;\n    out[i + 1] = (positions[i + 1] as number) * at.k + at.dy;\n  }\n  return out;\n}\n\n/** The extent's corners in the square, for a camera that frames it. */\nexport function cornersOf(extent: Extent, at: Placement): number[] {\n  return [extent.x * at.k + at.dx, extent.y * at.k + at.dy, (extent.x + extent.w) * at.k + at.dx, (extent.y + extent.h) * at.k + at.dy];\n}\n"],"names":["placementOf","extent","box","longest","k","side","placed","positions","at","out","i","cornersOf"],"mappings":"AAiBO,SAASA,EAAYC,GAAgBC,GAAwB;AAClE,QAAMC,IAAU,KAAK,IAAIF,EAAO,GAAGA,EAAO,GAAG,CAAC,GACxCG,IAAID,IAAUD,IAAMA,IAAMC,IAAU,GACpCE,IAAOF,IAAUC;AACvB,SAAO,EAAE,MAAAC,GAAM,GAAAD,GAAG,KAAKC,IAAOJ,EAAO,IAAIG,KAAK,IAAIH,EAAO,IAAIG,GAAG,KAAKC,IAAOJ,EAAO,IAAIG,KAAK,IAAIH,EAAO,IAAIG,EAAA;AAC7G;AAGO,SAASE,EAAOC,GAAyBC,GAA6B;AAC3E,QAAMC,IAAM,IAAI,aAAaF,EAAU,MAAM;AAC7C,WAASG,IAAI,GAAGA,IAAIH,EAAU,QAAQG,KAAK;AACzC,IAAAD,EAAIC,CAAC,IAAKH,EAAUG,CAAC,IAAeF,EAAG,IAAIA,EAAG,IAC9CC,EAAIC,IAAI,CAAC,IAAKH,EAAUG,IAAI,CAAC,IAAeF,EAAG,IAAIA,EAAG;AAExD,SAAOC;AACT;AAGO,SAASE,EAAUV,GAAgBO,GAAyB;AACjE,SAAO,CAACP,EAAO,IAAIO,EAAG,IAAIA,EAAG,IAAIP,EAAO,IAAIO,EAAG,IAAIA,EAAG,KAAKP,EAAO,IAAIA,EAAO,KAAKO,EAAG,IAAIA,EAAG,KAAKP,EAAO,IAAIA,EAAO,KAAKO,EAAG,IAAIA,EAAG,EAAE;AACtI;"}

package/dist/render/renderer.d.ts

@@ -23,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 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 new graph uploads positions and links, once per corpus and per position binding;
+ * - a binding, a look or a theme change uploads colours, sizes, shapes and clusters and nothing else;
+ * - a filter, a selection, a focus or a pin sets config and uploads nothing, and never calls
+ *   `render()`: a vertex the page's filter does not keep is greyed out, Cosmograph's way, so the
+ *   points never move because a chart was brushed;
  * - 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.
+ * The layout runs on its own when `x` and `y` are unbound, and from the current positions.
  * Every callback reads the store's latest options, so a host's inline `onFailure` never rebuilds it.
  * A failure to draw at all marks the store `failed` through `unrenderable`, never `onFailure` alone.
  */

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;AAGzC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,aAAa,EAAY,MAAM,eAAe,CAAC;AAQ7D,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;AAaD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,GAAE,cAAmB,GAAG,QAAQ,GAAG,IAAI,CA+TpH"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/render/renderer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAGzC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,aAAa,EAAoB,MAAM,eAAe,CAAC;AASrE,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;AAcD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,GAAE,cAAmB,GAAG,QAAQ,GAAG,IAAI,CAoVpH"}

package/dist/render/renderer.js

@@ -1,169 +1,181 @@
-import { Graph as nn } from "@cosmos.gl/graph";
-import { GraphError as E } from "../core/error.js";
-import { resolveLook as M } from "./graph-looks.js";
-import { forces as z, appearance as W, paint as tn } from "./graph-model.js";
-import { resolveSim as j } from "./graph-sim.js";
-import { createCamera as on, FIT_DURATION as en } from "./camera.js";
-import { placed as rn, UNPLACED as V, placementOf as an, cornersOf as ln } from "./placement.js";
-import { webglBox as sn, releaseContext as un } from "./webgl.js";
-const T = 0.35, cn = 1200, Y = 20, J = 1e4;
-function kn(l, e, i = {}) {
-  let O = !1;
-  const S = (n) => {
-    O || e.unrenderable(n);
-  }, I = sn();
-  if (I === null)
-    return S(new E("graph/no-webgl", "This browser offers no WebGL context to draw with.")), null;
-  let k = j(e.getOptions().sim), c = e.getOptions().simulate ?? !1, x = null, C = null, b = 0, A = -1;
-  const F = (n) => {
-    const t = Math.round(n * Y);
-    t !== A && (A = t, e.reportProgress(t / Y));
+import { Graph as an } from "@cosmos.gl/graph";
+import { GraphError as L } from "../core/error.js";
+import { resolveLook as Y } from "./graph-looks.js";
+import { forces as z, appearance as J, paint as ln } from "./graph-model.js";
+import { resolveSim as Q } from "./graph-sim.js";
+import { createCamera as sn, FIT_DURATION as un } from "./camera.js";
+import { simulating as F, highlighted as cn, decayFor as fn, LINKS_WHILE_RUNNING as pn } from "./motion.js";
+import { placementOf as dn, cornersOf as mn, placed as gn } from "./placement.js";
+import { webglBox as hn, releaseContext as Sn } from "./webgl.js";
+const T = 0.35, Pn = 1200, X = 20, $ = 1e4;
+function xn(f, i, e = {}) {
+  let C = !1;
+  const h = (n) => {
+    C || i.unrenderable(n);
+  }, N = hn();
+  if (N === null)
+    return h(new L("graph/no-webgl", "This browser offers no WebGL context to draw with.")), null;
+  let b = Q(i.getOptions().sim), p = !1, E = !1, O = null, x = null, w = 0, A = -1;
+  const _ = (n) => {
+    const o = Math.round(n * X);
+    o !== A && (A = o, i.reportProgress(o / X));
   };
-  let w = M(e.getOptions().look), B = e.getOptions().look;
-  const r = { positions: !0, paint: !0, state: !0, pinned: !0 };
-  let h = 0, G = null, P = null, D = null, s = e.getSnapshot(), f = e.getOptions();
-  const N = () => {
+  let S = Y(i.getOptions().look), B = i.getOptions().look;
+  const a = { positions: !0, paint: !0, state: !0, pinned: !0 };
+  let P = 0, d = null, s = i.getSnapshot(), m = i.getOptions();
+  const G = () => {
     var n;
-    return ((n = e.getSnapshot().geometry) == null ? void 0 : n.size) ?? 0;
+    return ((n = i.getSnapshot().geometry) == null ? void 0 : n.size) ?? 0;
   };
-  let o;
+  let t;
   try {
-    o = new nn(l, {
-      // No `spaceSize` here: the box is the corpus's extent, set when the graph has loaded.
-      // `rescalePositions: false` because the placement below is ours, and the corpus's own scale.
+    t = new an(f, {
+      // No `spaceSize` here: it is the geometry's, set when the graph has loaded.
+      // `rescalePositions: false` because the placement below is ours.
       rescalePositions: !1,
+      fitViewOnInit: !1,
       transitionDuration: 0,
-      enableSimulation: c,
-      ...z(k),
-      // Frames to convergence: alpha reaches its floor after exactly this many rendered frames.
-      simulationDecay: 400,
+      enableSimulation: p,
+      ...z(b),
       randomSeed: "kanzo-discovery",
       pixelRatio: window.devicePixelRatio || 1,
       enableDrag: !0,
       hoveredPointCursor: "pointer",
       attribution: "",
-      onSimulationStart: () => e.report("running"),
+      onSimulationStart: () => i.report("running"),
       onSimulationEnd: () => {
         var n;
-        e.report("settled"), F(1), p.settle(), (n = i.onFrame) == null || n.call(i);
+        I("settled"), _(1), u.settle(), (n = e.onFrame) == null || n.call(e);
       },
-      onSimulationPause: () => e.report("paused"),
-      onSimulationUnpause: () => e.report("running"),
-      onSimulationTick: (n, t, a) => {
-        var u, m;
-        F(o.progress), p.tick(), t !== void 0 && a && ((u = i.onHover) == null || u.call(i, a)), (m = i.onFrame) == null || m.call(i);
+      onSimulationPause: () => I("paused"),
+      onSimulationUnpause: () => I("running"),
+      onSimulationTick: (n, o, r) => {
+        var c, l;
+        _(t.progress), u.tick(), o !== void 0 && r && ((c = e.onHover) == null || c.call(e, r)), (l = e.onFrame) == null || l.call(e);
       },
-      onZoomStart: (n, t) => K(t),
+      onZoomStart: (n, o) => v(o),
       onZoom: () => {
         var n;
-        return (n = i.onFrame) == null ? void 0 : n.call(i);
+        return (n = e.onFrame) == null ? void 0 : n.call(e);
       },
-      onPointMouseOver: (n, t) => {
-        var a;
-        x = n, (a = i.onHover) == null || a.call(i, t), e.hover(n);
+      onPointMouseOver: (n, o) => {
+        var r;
+        O = n, (r = e.onHover) == null || r.call(e, o), i.hover(n);
       },
       onPointMouseOut: () => {
         var n;
-        x = null, (n = i.onHover) == null || n.call(i, null), e.hover(null);
+        O = null, (n = e.onHover) == null || n.call(e, null), i.hover(null);
       },
       onDragStart: () => {
-        C = x;
+        x = O;
       },
       onDrag: (n) => {
-        var t, a;
-        (t = i.onHover) == null || t.call(i, o.screenToSpacePosition([n.x, n.y])), (a = i.onFrame) == null || a.call(i);
+        var o, r;
+        (o = e.onHover) == null || o.call(e, t.screenToSpacePosition([n.x, n.y])), (r = e.onFrame) == null || r.call(e);
       },
       // d3-force's drag-to-fix, and only while a layout can move the point back: cosmos.gl moves a
       // dragged point with the simulation off too, and a pin nothing pulls against means nothing.
       onDragEnd: () => {
-        const n = C;
-        C = null;
-        const { motion: t, pinned: a } = e.getSnapshot();
-        n !== null && t !== "settled" && !a.includes(n) && e.pin([...a, n]);
+        const n = x;
+        x = null;
+        const { motion: o, pinned: r } = i.getSnapshot();
+        n !== null && o !== "settled" && !r.includes(n) && i.pin([...r, n]);
       },
-      onPointClick: (n) => _(n),
-      onBackgroundClick: () => H()
+      onPointClick: (n) => Z(n),
+      onBackgroundClick: () => q()
     });
   } catch (n) {
-    return S(new E("graph/no-webgl", "The renderer failed to start.", {}, { cause: n })), null;
+    return h(new L("graph/no-webgl", "The renderer failed to start.", {}, { cause: n })), null;
   }
-  const { camera: p, taken: K } = on(o, l), L = () => {
-    h || (h = requestAnimationFrame(() => {
-      h = 0, Q();
+  const { camera: u, taken: v } = sn(t, f, h), D = () => {
+    P || (P = requestAnimationFrame(() => {
+      P = 0, nn();
     }));
   };
-  function Q() {
-    var q;
-    const n = e.getSnapshot(), { geometry: t, encoding: a } = n, u = e.getOptions();
-    let m = !1;
-    if (r.positions && t && (r.positions = !1, o.setPointPositions(rn(t, X(t), n.mask), !0), t.links !== D && (D = t.links, o.setLinks(D), r.paint = r.state = r.pinned = !0), m = !0), r.paint && t && a) {
-      r.paint = !1;
-      const g = tn(t, a, w, l, u);
-      o.setPointColors(g.colors), o.setPointSizes(g.sizes), o.setPointShapes(g.shapes), o.setLinkColors(g.linkColors), o.setConfigPartial(W(w, l)), m = !0;
+  function nn() {
+    var j, K;
+    const n = i.getSnapshot(), { geometry: o, encoding: r } = n, c = i.getOptions(), l = a.positions && r ? o : null;
+    l && (a.positions = !1, t.setPointPositions(on(l), !0), l.links !== d && (d = l.links, t.setLinks(d), a.paint = a.state = a.pinned = !0));
+    const V = a.paint && o && r;
+    if (V) {
+      a.paint = !1;
+      const y = ln(o, r, S, f, c);
+      t.setPointColors(y.colors), t.setPointSizes(y.sizes), t.setPointShapes(y.shapes), t.setLinkColors(y.linkColors), t.setPointClusters(r.clusters ?? []), t.setConfigPartial({ ...J(S, f), renderLinks: H() });
     }
-    r.state && t && (r.state = !1, o.setConfigPartial({
-      highlightedPointIndices: n.selection ? n.selection.vertices.filter((g) => g < 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)), m && o.render(), t && a && !r.paint && e.reportDrawn(n), (q = i.onFrame) == null || q.call(i);
+    a.state && o && (a.state = !1, t.setConfigPartial({
+      ...cn(o, n.mask, ((j = n.selection) == null ? void 0 : j.vertices) ?? null),
+      focusedPointIndex: n.focus === null || n.focus >= o.size ? void 0 : n.focus
+    })), a.pinned && o && (a.pinned = !1, t.setPinnedPoints(n.pinned.length > 0 ? [...n.pinned] : null)), (V || l) && t.render(), l && tn(l, F(c, l)), o && r && !a.paint && i.reportDrawn(n), (K = e.onFrame) == null || K.call(e);
   }
-  function X(n) {
-    return n === G ? P ?? V : n.extent ? (G = n, P = an(n.extent, I), o.setConfigPartial({ spaceSize: P.side }), p.frame(ln(n.extent, P)), P) : V;
+  function on(n) {
+    const o = n.bound && n.extent ? dn(n.extent, N) : null;
+    return t.setConfigPartial({ spaceSize: (o == null ? void 0 : o.side) ?? n.space, simulationDecay: fn(n.size) }), !o || !n.extent ? n.positions : (u.frame(mn(n.extent, o)), gn(n.positions, o));
   }
-  function $(n) {
-    const t = j(n), a = Object.keys(t).some((u) => t[u] !== k[u]);
-    k = t, c && (o.setConfigPartial(z(t)), a && e.getSnapshot().motion !== "paused" && o.start(T));
+  function tn(n, o) {
+    if (u.drawn(), o) return k(1);
+    p && t.pause(), n.bound || u.fit();
   }
-  function y(n) {
-    c || (c = !0, o.setConfigPartial({ enableSimulation: !0, ...z(k) })), p.run(), o.start(n);
+  const H = () => S.link.render && !(E && ((d == null ? void 0 : d.length) ?? 0) / 2 > pn), U = () => t.setConfigPartial({ renderLinks: H() });
+  function I(n) {
+    E = n === "running", U(), i.report(n);
   }
-  function d() {
-    clearTimeout(b), b = 0;
+  function en(n) {
+    const o = Q(n), r = Object.keys(o).some((c) => o[c] !== b[c]);
+    b = o, p && (t.setConfigPartial(z(o)), r && i.getSnapshot().motion !== "paused" && t.start(T));
   }
-  function _(n) {
-    const t = o.getNeighboringPointIndices(n) ?? [];
-    e.select([n, ...t], "node", "Node"), e.focus(n);
+  function k(n) {
+    p || (p = !0, t.setConfigPartial({ enableSimulation: !0, ...z(b) })), u.run(), E = !0, t.start(n), U();
   }
-  function H() {
-    e.select(null), e.focus(null);
+  function g() {
+    clearTimeout(w), w = 0;
   }
-  o.setConfigPartial(W(w, l)), o.render();
-  const U = (n) => {
-    n.preventDefault(), S(new E("graph/context-lost", "The browser took back the WebGL context; reload to get one."));
-  }, Z = (n, t) => S(new E("graph/no-webgl", "No GPU device came up to draw with.", n, { cause: t })), R = setTimeout(() => Z({ after: J }), J);
-  o.ready.then(
+  function Z(n) {
+    const o = t.getNeighboringPointIndices(n) ?? [];
+    i.select([n, ...o], "node", "Node"), i.focus(n);
+  }
+  function q() {
+    i.select(null), i.focus(null);
+  }
+  t.setConfigPartial(J(S, f)), t.render();
+  const M = (n) => {
+    n.preventDefault(), h(new L("graph/context-lost", "The browser took back the WebGL context; reload to get one."));
+  }, W = (n, o) => h(new L("graph/no-webgl", "No GPU device came up to draw with.", n, { cause: o })), R = setTimeout(() => W({ after: $ }), $);
+  t.ready.then(
     () => {
       var n;
-      clearTimeout(R), O || (n = l.querySelector("canvas")) == null || n.addEventListener("webglcontextlost", U);
+      clearTimeout(R), C || (n = f.querySelector("canvas")) == null || n.addEventListener("webglcontextlost", M), u.ready();
     },
     (n) => {
-      clearTimeout(R), Z({}, n);
+      clearTimeout(R), W({}, n);
     }
-  ), e.report(c && o.isSimulationRunning ? "running" : "settled"), L();
-  const v = e.subscribe(() => {
-    const n = e.getSnapshot(), t = e.getOptions();
-    (n.geometry !== s.geometry || n.mask !== s.mask) && (r.positions = !0), n.encoding !== s.encoding && (r.paint = !0), t.look !== B && (B = t.look, w = M(t.look), r.paint = !0), (t.fill !== f.fill || t.symbol !== f.symbol || t.stroke !== f.stroke) && (r.paint = !0), (n.selection !== s.selection || n.focus !== s.focus) && (r.state = !0), n.pinned !== s.pinned && (r.pinned = !0), t.sim !== f.sim && $(t.sim), (t.simulate ?? !1) !== (f.simulate ?? !1) && (d(), t.simulate ? y(T) : o.pause()), s = n, f = t, (r.positions || r.paint || r.state || r.pinned) && L();
+  ), i.report(p && t.isSimulationRunning ? "running" : "settled"), D();
+  const rn = i.subscribe(() => {
+    const n = i.getSnapshot(), o = i.getOptions();
+    n.geometry !== s.geometry && (a.positions = !0), n.encoding !== s.encoding && (a.paint = !0), o.look !== B && (B = o.look, S = Y(o.look), a.paint = !0), (o.fill !== m.fill || o.symbol !== m.symbol || o.stroke !== m.stroke) && (a.paint = !0), (n.selection !== s.selection || n.focus !== s.focus || n.mask !== s.mask) && (a.state = !0), n.pinned !== s.pinned && (a.pinned = !0), o.sim !== m.sim && en(o.sim);
+    const r = F(o, n.geometry);
+    n.geometry === s.geometry && r !== F(m, s.geometry) && (g(), r ? k(T) : t.pause()), s = n, m = o, (a.positions || a.paint || a.state || a.pinned) && D();
   });
   return {
-    graph: o,
+    graph: t,
     repaint() {
-      r.paint = !0, L();
+      a.paint = !0, D();
     },
     hit(n) {
-      const t = "rect" in n ? o.findPointsInRect(n.rect) : o.findPointsInPolygon(n.polygon);
-      return Array.from(t);
+      const o = "rect" in n ? t.findPointsInRect(n.rect) : t.findPointsInPolygon(n.polygon);
+      return Array.from(o);
     },
     zoomBy(n) {
-      o.setZoomLevel(o.getZoomLevel() * n, 220);
+      t.setZoomLevel(t.getZoomLevel() * n, 220);
     },
-    fit: () => p.fit(),
+    fit: () => u.fit(),
     pause() {
-      d(), o.pause();
+      g(), t.pause();
     },
     resume() {
-      d(), e.getSnapshot().motion === "settled" || !c ? y(T) : o.unpause();
+      g(), i.getSnapshot().motion === "settled" || !p ? k(T) : t.unpause();
     },
     restart() {
-      d(), e.pin([]), y(1);
+      g(), i.pin([]), k(1);
     },
     /**
      * d3's release: unfix, then reheat, so the released points visibly flow back. A running layout
@@ -171,28 +183,28 @@ function kn(l, e, i = {}) {
      * bounded burst and is paused again, because the reader paused it.
      */
     unpin() {
-      const { motion: n, pinned: t } = e.getSnapshot();
-      t.length !== 0 && (d(), e.pin([]), y(T), n === "paused" && (b = window.setTimeout(() => {
-        b = 0, o.pause();
-      }, cn)));
+      const { motion: n, pinned: o } = i.getSnapshot();
+      o.length !== 0 && (g(), i.pin([]), k(T), n === "paused" && (w = window.setTimeout(() => {
+        w = 0, t.pause();
+      }, Pn)));
     },
     reveal(n) {
-      n >= N() || (_(n), o.zoomToPointByIndex(n, 500, 5, !0));
+      n >= G() || (Z(n), t.zoomToPointByIndex(n, 500, 5, !0));
     },
     frameSelection() {
-      var t;
-      const n = (((t = e.getSnapshot().selection) == null ? void 0 : t.vertices) ?? []).filter((a) => a < N());
-      n.length > 0 && o.fitViewByPointIndices(n, en, 0.25);
+      var o;
+      const n = (((o = i.getSnapshot().selection) == null ? void 0 : o.vertices) ?? []).filter((r) => r < G());
+      n.length > 0 && t.fitViewByPointIndices(n, un, 0.25);
     },
-    clear: H,
+    clear: q,
     destroy() {
-      v(), d(), h && cancelAnimationFrame(h), clearTimeout(R), p.destroy(), O = !0;
-      const n = l.querySelector("canvas");
-      n == null || n.removeEventListener("webglcontextlost", U), o.destroy(), un(n);
+      rn(), g(), P && cancelAnimationFrame(P), clearTimeout(R), u.destroy(), C = !0;
+      const n = f.querySelector("canvas");
+      n == null || n.removeEventListener("webglcontextlost", M), t.destroy(), Sn(n);
     }
   };
 }
 export {
-  kn as createRenderer
+  xn as createRenderer
 };
 //# sourceMappingURL=renderer.js.map