@xenosystem/blocks 0.22.0 → 0.23.1

package/dist/edit/index.js

@@ -1,9 +1,31 @@
 import {
-  CollapseGlyph,
+  DEFAULT_CURVE_ZOOM,
+  DEFAULT_GRAPH_ZOOM,
+  XenoCurveScale,
+  XenoGraphScale,
+  XenoNodeIndex,
+  boxesIntersect,
+  distanceToEdge,
+  edgeBounds,
+  edgeKey,
+  edgePath,
+  findPort,
+  fitToBounds,
+  fitValueRange,
+  graphBounds,
+  nodeBounds,
+  portHasRoom,
+  portRefId,
+  visibleEdges,
+  wheelZoomFactor,
+  zoomAboutCursor,
+  zoomTimeAboutCursor,
+  zoomValueAboutCursor
+} from "../chunk-76V25B3E.js";
+import {
   CopyIcon,
   DiamondIcon,
   EntryIcon,
-  ExpandGlyph,
   EyedropperIcon,
   ICONS,
   KindGlyph,
@@ -13,7 +35,6 @@ import {
   NextIcon,
   PrevIcon,
   RedoIcon,
-  RefreshGlyph,
   ResetIcon,
   StopwatchIcon,
   SwapIcon,
@@ -23,7 +44,12 @@ import {
   VisibilityIcon,
   XIcon,
   XIcon2
-} from "../chunk-6ZIWULSK.js";
+} from "../chunk-YZ6J6A67.js";
+import {
+  CollapseGlyph,
+  ExpandGlyph,
+  RefreshGlyph
+} from "../chunk-YSMDUREC.js";
 import "../chunk-2KG3PWR4.js";
 
 // src/edit/layers/panel.ts
@@ -6586,180 +6612,6 @@ import {
 // src/edit/curve/controller.ts
 import { createThrottle as createThrottle5, DEFAULT_TIMEBASE } from "@xenosystem/time-core";
 
-// src/edit/curve/scale.ts
-var DEFAULT_CURVE_ZOOM = { min: 5e-4, max: 64 };
-var XenoCurveScale = class _XenoCurveScale {
-  pxPerTick;
-  scrollTick;
-  minValue;
-  maxValue;
-  widthPx;
-  heightPx;
-  gutterPx;
-  rulerPx;
-  constructor(state, geometry) {
-    this.widthPx = Math.max(1, finiteOr(geometry.widthPx, 1));
-    this.heightPx = Math.max(1, finiteOr(geometry.heightPx, 1));
-    this.gutterPx = Math.max(0, Math.min(finiteOr(geometry.gutterPx, 0), this.widthPx - 1));
-    this.rulerPx = Math.max(0, Math.min(finiteOr(geometry.rulerPx, 0), this.heightPx - 1));
-    this.pxPerTick = Math.max(Number.MIN_VALUE, finiteOr(state.pxPerTick, 1));
-    this.scrollTick = finiteOr(state.scrollTick, 0);
-    const min = finiteOr(state.minValue, 0);
-    const max = finiteOr(state.maxValue, 1);
-    if (max - min < 1e-12) {
-      const centre = (max + min) / 2;
-      this.minValue = centre - 0.5;
-      this.maxValue = centre + 0.5;
-    } else {
-      this.minValue = min;
-      this.maxValue = max;
-    }
-  }
-  /** Width of the plot area. Always ≥ 1. */
-  get plotPx() {
-    return Math.max(1, this.widthPx - this.gutterPx);
-  }
-  /** Height of the plot area. Always ≥ 1. */
-  get plotHeightPx() {
-    return Math.max(1, this.heightPx - this.rulerPx);
-  }
-  /** Ticks visible. */
-  get spanTicks() {
-    return this.plotPx / this.pxPerTick;
-  }
-  /** Tick at the right edge. */
-  get endTick() {
-    return this.scrollTick + this.spanTicks;
-  }
-  /** Value units per pixel. */
-  get valuePerPx() {
-    return (this.maxValue - this.minValue) / this.plotHeightPx;
-  }
-  /** Container-relative x → tick. */
-  xToTick(x) {
-    return this.scrollTick + (finiteOr(x, 0) - this.gutterPx) / this.pxPerTick;
-  }
-  /** Tick → container-relative x. */
-  tickToX(tick) {
-    return this.gutterPx + (finiteOr(tick, 0) - this.scrollTick) * this.pxPerTick;
-  }
-  /**
-   * Container-relative y → value.
-   *
-   * **Inverted.** Screen y grows downward, value grows upward. Every sign error in a graph editor
-   * lives on this one line.
-   */
-  yToValue(y) {
-    const local = finiteOr(y, 0) - this.rulerPx;
-    return this.maxValue - local / this.plotHeightPx * (this.maxValue - this.minValue);
-  }
-  /** Value → container-relative y. */
-  valueToY(value) {
-    const fraction = (this.maxValue - finiteOr(value, 0)) / (this.maxValue - this.minValue);
-    return this.rulerPx + fraction * this.plotHeightPx;
-  }
-  /**
-   * A tick DURATION → a pixel width.
-   *
-   * Separate from {@link tickToX}, because rounding is not associative: mixing
-   * `durationToPx(b - a)` with `tickToX(b) - tickToX(a)` puts a curve's handle a pixel off its key
-   * at some zoom levels and not others.
-   */
-  durationToPx(ticks) {
-    return finiteOr(ticks, 0) * this.pxPerTick;
-  }
-  /** A value DELTA → a pixel height. Sign-preserving and NOT inverted. */
-  valueDeltaToPx(delta) {
-    return finiteOr(delta, 0) / (this.maxValue - this.minValue) * this.plotHeightPx;
-  }
-  /** A pixel distance → a tick distance. For screen-space thresholds. */
-  pxToTicks(px) {
-    return finiteOr(px, 0) / this.pxPerTick;
-  }
-  /** A pixel distance → a value distance. For screen-space thresholds. */
-  pxToValue(px) {
-    return finiteOr(px, 0) * this.valuePerPx;
-  }
-  /** Is this point inside the plot area? */
-  isInPlot(x, y) {
-    return x >= this.gutterPx && x <= this.widthPx && y >= this.rulerPx && y <= this.heightPx;
-  }
-  /** A copy with new state. */
-  with(state) {
-    return new _XenoCurveScale(
-      {
-        pxPerTick: state.pxPerTick ?? this.pxPerTick,
-        scrollTick: state.scrollTick ?? this.scrollTick,
-        minValue: state.minValue ?? this.minValue,
-        maxValue: state.maxValue ?? this.maxValue
-      },
-      {
-        widthPx: this.widthPx,
-        heightPx: this.heightPx,
-        gutterPx: this.gutterPx,
-        rulerPx: this.rulerPx
-      }
-    );
-  }
-  /** A copy with new geometry. */
-  resized(geometry) {
-    return new _XenoCurveScale(
-      {
-        pxPerTick: this.pxPerTick,
-        scrollTick: this.scrollTick,
-        minValue: this.minValue,
-        maxValue: this.maxValue
-      },
-      {
-        widthPx: geometry.widthPx ?? this.widthPx,
-        heightPx: geometry.heightPx ?? this.heightPx,
-        gutterPx: geometry.gutterPx ?? this.gutterPx,
-        rulerPx: geometry.rulerPx ?? this.rulerPx
-      }
-    );
-  }
-};
-function finiteOr(value, fallback) {
-  return Number.isFinite(value) ? value : fallback;
-}
-function zoomTimeAboutCursor(scale, x, factor, bounds = DEFAULT_CURVE_ZOOM) {
-  const anchorTick = scale.xToTick(x);
-  const requested = scale.pxPerTick * (Number.isFinite(factor) && factor > 0 ? factor : 1);
-  const pxPerTick = Math.min(bounds.max, Math.max(bounds.min, requested));
-  return {
-    pxPerTick,
-    scrollTick: anchorTick - (x - scale.gutterPx) / pxPerTick,
-    minValue: scale.minValue,
-    maxValue: scale.maxValue
-  };
-}
-function zoomValueAboutCursor(scale, y, factor) {
-  const anchorValue = scale.yToValue(y);
-  const safeFactor = Number.isFinite(factor) && factor > 0 ? factor : 1;
-  const span = (scale.maxValue - scale.minValue) / safeFactor;
-  const fraction = (scale.maxValue - anchorValue) / (scale.maxValue - scale.minValue);
-  const maxValue = anchorValue + span * fraction;
-  return {
-    pxPerTick: scale.pxPerTick,
-    scrollTick: scale.scrollTick,
-    minValue: maxValue - span,
-    maxValue
-  };
-}
-function wheelZoomFactor(deltaY, sensitivity = 0.01) {
-  const raw = Number.isFinite(deltaY) ? deltaY : 0;
-  const clamped = Math.max(-10, Math.min(10, raw));
-  return Math.pow(2, -clamped * sensitivity * 10);
-}
-function fitValueRange(extent, marginFraction = 0.1) {
-  if (!extent || !Number.isFinite(extent.min) || !Number.isFinite(extent.max)) {
-    return { minValue: 0, maxValue: 1 };
-  }
-  const span = extent.max - extent.min;
-  const margin = Math.max(span * marginFraction, 0.5);
-  return { minValue: extent.min - margin, maxValue: extent.max + margin };
-}
-
 // src/edit/curve/bezier.ts
 function cubic(t, p1, p2) {
   const mt = 1 - t;
@@ -10933,243 +10785,6 @@ import {
 // src/edit/nodegraph/throttle.ts
 import { createThrottle as createThrottle6 } from "@xenosystem/tree-core";
 
-// src/edit/nodegraph/scale.ts
-var DEFAULT_GRAPH_ZOOM = { min: 0.05, max: 4 };
-var XenoGraphScale = class _XenoGraphScale {
-  zoom;
-  x;
-  y;
-  widthPx;
-  heightPx;
-  constructor(state, geometry) {
-    this.widthPx = Math.max(1, finiteOr2(geometry.widthPx, 1));
-    this.heightPx = Math.max(1, finiteOr2(geometry.heightPx, 1));
-    this.zoom = Math.max(Number.MIN_VALUE, finiteOr2(state.zoom, 1));
-    this.x = finiteOr2(state.x, 0);
-    this.y = finiteOr2(state.y, 0);
-  }
-  /** Graph-space width of the viewport. */
-  get graphWidth() {
-    return this.widthPx / this.zoom;
-  }
-  /** Graph-space height of the viewport. */
-  get graphHeight() {
-    return this.heightPx / this.zoom;
-  }
-  /** The visible rectangle in graph space. */
-  get viewport() {
-    return { x: this.x, y: this.y, width: this.graphWidth, height: this.graphHeight };
-  }
-  /** Container-relative screen point → graph point. */
-  screenToGraph(px, py) {
-    return { x: this.x + finiteOr2(px, 0) / this.zoom, y: this.y + finiteOr2(py, 0) / this.zoom };
-  }
-  /** Graph point → container-relative screen point. */
-  graphToScreen(gx, gy) {
-    return { x: (finiteOr2(gx, 0) - this.x) * this.zoom, y: (finiteOr2(gy, 0) - this.y) * this.zoom };
-  }
-  /** A graph-space distance → pixels. */
-  toPx(distance) {
-    return finiteOr2(distance, 0) * this.zoom;
-  }
-  /** A pixel distance → graph space. Used for screen-space hit thresholds. */
-  toGraph(px) {
-    return finiteOr2(px, 0) / this.zoom;
-  }
-  /** A copy with new state. */
-  with(state) {
-    return new _XenoGraphScale(
-      { zoom: state.zoom ?? this.zoom, x: state.x ?? this.x, y: state.y ?? this.y },
-      { widthPx: this.widthPx, heightPx: this.heightPx }
-    );
-  }
-  /** A copy with new geometry. */
-  resized(geometry) {
-    return new _XenoGraphScale(
-      { zoom: this.zoom, x: this.x, y: this.y },
-      { widthPx: geometry.widthPx ?? this.widthPx, heightPx: geometry.heightPx ?? this.heightPx }
-    );
-  }
-};
-function finiteOr2(value, fallback) {
-  return Number.isFinite(value) ? value : fallback;
-}
-function zoomAboutCursor(scale, px, py, factor, bounds = DEFAULT_GRAPH_ZOOM) {
-  const anchor = scale.screenToGraph(px, py);
-  const requested = scale.zoom * (Number.isFinite(factor) && factor > 0 ? factor : 1);
-  const zoom = Math.min(bounds.max, Math.max(bounds.min, requested));
-  return { zoom, x: anchor.x - px / zoom, y: anchor.y - py / zoom };
-}
-function fitToBounds(bounds, widthPx, heightPx, zoomBounds = DEFAULT_GRAPH_ZOOM, paddingPx = 40) {
-  if (!bounds || bounds.width <= 0 || bounds.height <= 0) return { zoom: 1, x: 0, y: 0 };
-  const usableW = Math.max(1, widthPx - paddingPx * 2);
-  const usableH = Math.max(1, heightPx - paddingPx * 2);
-  const zoom = Math.min(
-    zoomBounds.max,
-    Math.max(zoomBounds.min, Math.min(usableW / bounds.width, usableH / bounds.height))
-  );
-  const x = bounds.x + bounds.width / 2 - widthPx / zoom / 2;
-  const y = bounds.y + bounds.height / 2 - heightPx / zoom / 2;
-  return { zoom, x, y };
-}
-function graphBounds(nodes) {
-  if (nodes.length === 0) return null;
-  let minX = Number.POSITIVE_INFINITY;
-  let minY = Number.POSITIVE_INFINITY;
-  let maxX = Number.NEGATIVE_INFINITY;
-  let maxY = Number.NEGATIVE_INFINITY;
-  for (const node of nodes) {
-    if (!Number.isFinite(node.x) || !Number.isFinite(node.y)) continue;
-    minX = Math.min(minX, node.x);
-    minY = Math.min(minY, node.y);
-    maxX = Math.max(maxX, node.x + Math.max(1, node.width));
-    maxY = Math.max(maxY, node.y + Math.max(1, node.height));
-  }
-  if (!Number.isFinite(minX)) return null;
-  return { x: minX, y: minY, width: Math.max(1, maxX - minX), height: Math.max(1, maxY - minY) };
-}
-
-// src/edit/nodegraph/types.ts
-function portRefId(ref) {
-  return `${ref.nodeId}${ref.portId}`;
-}
-function edgeKey(edge) {
-  return `${edge.fromNodeId}${edge.fromPortId}${edge.toNodeId}${edge.toPortId}`;
-}
-function findPort(node, portId) {
-  return node.inputs.find((p) => p.id === portId) ?? node.outputs.find((p) => p.id === portId) ?? null;
-}
-function portHasRoom(port, existingCount) {
-  if (port.multiple !== void 0) return port.multiple || existingCount === 0;
-  return port.direction === "out" ? true : existingCount === 0;
-}
-function nodeBounds(node) {
-  return { x: node.x, y: node.y, width: Math.max(1, node.width), height: Math.max(1, node.height) };
-}
-function boxesIntersect(a, b) {
-  return a.x < b.x + b.width && b.x < a.x + a.width && a.y < b.y + b.height && b.y < a.y + a.height;
-}
-
-// src/edit/nodegraph/spatial.ts
-var XenoNodeIndex = class {
-  cellSize;
-  cells = /* @__PURE__ */ new Map();
-  all;
-  constructor(nodes) {
-    this.all = nodes;
-    this.cellSize = chooseCellSize(nodes);
-    for (const node of nodes) {
-      const x0 = Math.floor(node.x / this.cellSize);
-      const y0 = Math.floor(node.y / this.cellSize);
-      const x1 = Math.floor((node.x + Math.max(1, node.width)) / this.cellSize);
-      const y1 = Math.floor((node.y + Math.max(1, node.height)) / this.cellSize);
-      for (let cx = x0; cx <= x1; cx += 1) {
-        for (let cy = y0; cy <= y1; cy += 1) {
-          const key = `${cx},${cy}`;
-          const bucket = this.cells.get(key);
-          if (bucket) bucket.push(node);
-          else this.cells.set(key, [node]);
-        }
-      }
-    }
-  }
-  /** Bucket size, for tests. */
-  get bucketSize() {
-    return this.cellSize;
-  }
-  /**
-   * Nodes intersecting a box.
-   *
-   * @param box - The query rectangle in graph space.
-   * @returns Matching nodes, each at most once.
-   */
-  query(box) {
-    const x0 = Math.floor(box.x / this.cellSize);
-    const y0 = Math.floor(box.y / this.cellSize);
-    const x1 = Math.floor((box.x + box.width) / this.cellSize);
-    const y1 = Math.floor((box.y + box.height) / this.cellSize);
-    const seen = /* @__PURE__ */ new Set();
-    const out = [];
-    for (let cx = x0; cx <= x1; cx += 1) {
-      for (let cy = y0; cy <= y1; cy += 1) {
-        for (const node of this.cells.get(`${cx},${cy}`) ?? []) {
-          if (seen.has(node.id)) continue;
-          seen.add(node.id);
-          if (boxesIntersect(node, { ...box, width: Math.max(0, box.width), height: Math.max(0, box.height) })) {
-            out.push(node);
-          }
-        }
-      }
-    }
-    return out;
-  }
-  /** The topmost node containing a point, or `null`. */
-  hit(x, y) {
-    const candidates = this.query({ x, y, width: 1e-3, height: 1e-3 });
-    if (candidates.length === 0) return null;
-    let best = null;
-    for (const node of candidates) {
-      if (x >= node.x && x <= node.x + node.width && y >= node.y && y <= node.y + node.height) {
-        if (!best || this.all.indexOf(node) > this.all.indexOf(best)) best = node;
-      }
-    }
-    return best;
-  }
-};
-function chooseCellSize(nodes) {
-  if (nodes.length === 0) return 256;
-  const sizes = [];
-  for (const node of nodes) {
-    const size = Math.max(node.width || 1, node.height || 1);
-    if (Number.isFinite(size) && size > 0) sizes.push(size);
-  }
-  if (sizes.length === 0) return 256;
-  sizes.sort((a, b) => a - b);
-  const median = sizes[Math.floor(sizes.length / 2)];
-  return Math.max(32, Math.min(4096, median * 2));
-}
-function edgeBounds(from, to, slack = 64) {
-  const x = Math.min(from.x, to.x) - slack;
-  const y = Math.min(from.y, to.y) - slack;
-  return {
-    x,
-    y,
-    width: Math.abs(to.x - from.x) + slack * 2,
-    height: Math.abs(to.y - from.y) + slack * 2
-  };
-}
-function visibleEdges(edges, portPosition, viewport) {
-  const out = [];
-  for (const edge of edges) {
-    const from = portPosition(edge.fromNodeId, edge.fromPortId);
-    const to = portPosition(edge.toNodeId, edge.toPortId);
-    if (!from || !to) continue;
-    if (!boxesIntersect(edgeBounds(from, to), viewport)) continue;
-    out.push({ edge, from, to });
-  }
-  return out;
-}
-function edgePath(from, to) {
-  const dx = Math.abs(to.x - from.x);
-  const reach = Math.max(40, Math.min(dx * 0.6, 240));
-  return `M${from.x},${from.y} C${from.x + reach},${from.y} ${to.x - reach},${to.y} ${to.x},${to.y}`;
-}
-function distanceToEdge(point, from, to, samples = 16) {
-  const dx = Math.abs(to.x - from.x);
-  const reach = Math.max(40, Math.min(dx * 0.6, 240));
-  const c1 = { x: from.x + reach, y: from.y };
-  const c2 = { x: to.x - reach, y: to.y };
-  let best = Number.POSITIVE_INFINITY;
-  for (let i = 0; i <= samples; i += 1) {
-    const t = i / samples;
-    const mt = 1 - t;
-    const x = mt * mt * mt * from.x + 3 * mt * mt * t * c1.x + 3 * mt * t * t * c2.x + t * t * t * to.x;
-    const y = mt * mt * mt * from.y + 3 * mt * mt * t * c1.y + 3 * mt * t * t * c2.y + t * t * t * to.y;
-    best = Math.min(best, Math.hypot(x - point.x, y - point.y));
-  }
-  return best;
-}
-
 // src/edit/nodegraph/connect.ts
 function canConnect(graph, from, to, rules = {}) {
   if (from.nodeId === to.nodeId) {

package/dist/icons/index.js

@@ -1,8 +1,10 @@
 import {
   ICONS,
-  ICON_UNITS,
+  ICON_UNITS
+} from "../chunk-YZ6J6A67.js";
+import {
   Svg
-} from "../chunk-6ZIWULSK.js";
+} from "../chunk-YSMDUREC.js";
 import "../chunk-2KG3PWR4.js";
 export {
   ICONS,

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * `@xenosystem/blocks` — rung 3 of the FRONT ladder — BLOCKS (`XENO FRONT-END HIERARCHY.md`).
  * Families are subpaths: `@xenosystem/blocks/auth`, `/edit`, `/data`, `/time`, `/ops`, `/trust`,
- * `/agent`. This root re-exports nothing on purpose: import the family you mount, so a product
+ * `/agent`, `/docs`, `/corpus`. This root re-exports nothing on purpose: import the family you mount, so a product
  * carries only it. Naming rule: `XENO PACKAGE NAMING - STANDARD.md`.
  */
 declare const BLOCKS_VERSION = "0.8.1";

package/dist/ops/index.js

@@ -7,10 +7,12 @@ import {
   terminalThemeVar
 } from "../chunk-WE6A2DTY.js";
 import {
-  ICONS,
+  ICONS
+} from "../chunk-YZ6J6A67.js";
+import {
   PlusGlyph,
   XGlyph
-} from "../chunk-6ZIWULSK.js";
+} from "../chunk-YSMDUREC.js";
 import "../chunk-2KG3PWR4.js";
 
 // src/ops/console/panel.ts

package/dist/scale-XiQwxiFA.d.ts

@@ -0,0 +1,130 @@
+/**
+ * `XenoGraphScale` — the only thing in this package that converts between pixels and graph space.
+ *
+ * Same discipline as the timeline and curve scales, **copied with attribution rather than shared**:
+ * a graph is 2D with a *uniform* zoom (a node must not shear), where the timeline is 1D and the
+ * curve has two independent axes. One type covering all three would be three things wearing one
+ * name.
+ *
+ * Kept verbatim because it is right in all three: state is `(zoom, x, y)` rather than a pair of
+ * corners, every dimension is clamped at the single construction site so a collapsed container
+ * cannot poison it with a sticky NaN, and zoom-to-cursor derives its offset from the **clamped**
+ * zoom.
+ *
+ * @module
+ */
+/** The visible window. */
+interface XenoGraphScaleState {
+    /** Uniform zoom. A node must not shear, so there is one scalar and not two. */
+    zoom: number;
+    /** Graph-space coordinate at the viewport's top-left. */
+    x: number;
+    y: number;
+}
+/** Container geometry. */
+interface XenoGraphScaleGeometry {
+    widthPx: number;
+    heightPx: number;
+}
+/** Zoom limits. */
+interface XenoGraphZoom {
+    min: number;
+    max: number;
+}
+/** Default zoom range: 5% to 400%, the band every surveyed editor lands in. */
+declare const DEFAULT_GRAPH_ZOOM: XenoGraphZoom;
+/** An immutable graph→view mapping. */
+declare class XenoGraphScale {
+    readonly zoom: number;
+    readonly x: number;
+    readonly y: number;
+    readonly widthPx: number;
+    readonly heightPx: number;
+    constructor(state: XenoGraphScaleState, geometry: XenoGraphScaleGeometry);
+    /** Graph-space width of the viewport. */
+    get graphWidth(): number;
+    /** Graph-space height of the viewport. */
+    get graphHeight(): number;
+    /** The visible rectangle in graph space. */
+    get viewport(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Container-relative screen point → graph point. */
+    screenToGraph(px: number, py: number): {
+        x: number;
+        y: number;
+    };
+    /** Graph point → container-relative screen point. */
+    graphToScreen(gx: number, gy: number): {
+        x: number;
+        y: number;
+    };
+    /** A graph-space distance → pixels. */
+    toPx(distance: number): number;
+    /** A pixel distance → graph space. Used for screen-space hit thresholds. */
+    toGraph(px: number): number;
+    /** A copy with new state. */
+    with(state: Partial<XenoGraphScaleState>): XenoGraphScale;
+    /** A copy with new geometry. */
+    resized(geometry: Partial<XenoGraphScaleGeometry>): XenoGraphScale;
+}
+/**
+ * Zoom about a cursor, keeping the graph point under the pointer fixed.
+ *
+ * ```
+ * anchor = screenToGraph(px, py)        // BEFORE
+ * zoom'  = clamp(zoom * factor)         // clamp FIRST
+ * x'     = anchor.x - px / zoom'
+ * ```
+ *
+ * 🔴 The offset is derived from the **clamped** zoom. Using the requested one moves the graph under
+ * a stationary cursor at both ends of the range — exactly when the user is zoomed in on the thing
+ * they care about.
+ *
+ * @param scale - Current scale.
+ * @param px - Container-relative pointer x.
+ * @param py - Container-relative pointer y.
+ * @param factor - Requested multiplier.
+ * @param bounds - Zoom limits.
+ * @returns New state.
+ */
+declare function zoomAboutCursor(scale: XenoGraphScale, px: number, py: number, factor: number, bounds?: XenoGraphZoom): XenoGraphScaleState;
+
+/**
+ * The scale that frames a graph-space rectangle.
+ *
+ * @param bounds - The rectangle to frame.
+ * @param widthPx - Viewport width.
+ * @param heightPx - Viewport height.
+ * @param bounds_ - Zoom limits.
+ * @param paddingPx - Screen-space padding.
+ * @returns The state that shows it.
+ *
+ * @example
+ * ```ts
+ * controller.fitTo(graphBounds(graph.nodes))
+ * ```
+ */
+declare function fitToBounds(bounds: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | null, widthPx: number, heightPx: number, zoomBounds?: XenoGraphZoom, paddingPx?: number): XenoGraphScaleState;
+/** The bounding box of a set of nodes, or `null` when there are none. */
+declare function graphBounds(nodes: readonly {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}[]): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | null;
+
+export { DEFAULT_GRAPH_ZOOM as D, type XenoGraphScaleState as X, type XenoGraphZoom as a, XenoGraphScale as b, type XenoGraphScaleGeometry as c, fitToBounds as f, graphBounds as g, zoomAboutCursor as z };

package/dist/time/index.js

@@ -13,7 +13,8 @@ import {
   StopIcon,
   TRANSPORT_ICONS,
   TRANSPORT_RUNTIME_UNITS
-} from "../chunk-6ZIWULSK.js";
+} from "../chunk-YZ6J6A67.js";
+import "../chunk-YSMDUREC.js";
 import {
   __reExport
 } from "../chunk-2KG3PWR4.js";