@pibbl/core 0.0.1 → 0.0.3-alpha.109.1

package/dist/features/viz/lib/log-scale-component.d.ts

@@ -0,0 +1,7 @@
+import type { LogScaleProps } from "./types.js";
+/**
+ * Provides a named positive logarithmic mapping to descendant marks and axes.
+ * @param props - Identity, positive domain, range, and optional tick base. See {@link LogScaleProps}.
+ * @returns Descendant content within the logarithmic scale scope.
+ */
+export declare function LogScale(props: LogScaleProps): import("@pibbl/core").PibblNode;

package/dist/features/viz/lib/log-scale-component.js

@@ -0,0 +1,19 @@
+import { resolveSignalValue, useLayoutBox } from "@pibbl/core";
+import { resolveLogScale } from "./log-scale.js";
+import { useScaleProvider } from "./scale-provider.js";
+function LogScale(props) {
+  const { width, height } = useLayoutBox();
+  useScaleProvider(props.id, "log", () => resolveLogScale(
+    resolveSignalValue(props.domain),
+    resolveSignalValue(props.range),
+    resolveSignalValue(props.reverse ?? false),
+    width,
+    height,
+    resolveSignalValue(props.base ?? 10)
+  ), [props.domain, props.range, props.reverse, props.base, width, height]);
+  return props.children;
+}
+export {
+  LogScale
+};
+//# sourceMappingURL=log-scale-component.js.map

package/dist/features/viz/lib/log-scale-component.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/viz/lib/log-scale-component.ts"],
+  "sourcesContent": ["import { resolveSignalValue, useLayoutBox } from \"@pibbl/core\";\nimport type { LogScaleProps } from \"./types.js\";\nimport { resolveLogScale } from \"./log-scale.js\";\nimport { useScaleProvider } from \"./scale-provider.js\";\n/**\n * Provides a named positive logarithmic mapping to descendant marks and axes.\n * @param props - Identity, positive domain, range, and optional tick base. See {@link LogScaleProps}.\n * @returns Descendant content within the logarithmic scale scope.\n */\nexport function LogScale(props: LogScaleProps) {\n  const { width, height } = useLayoutBox();\n  useScaleProvider(props.id, \"log\", () => resolveLogScale(\n    resolveSignalValue(props.domain), resolveSignalValue(props.range),\n    resolveSignalValue(props.reverse ?? false), width, height, resolveSignalValue(props.base ?? 10),\n  ), [props.domain, props.range, props.reverse, props.base, width, height]);\n  return props.children;\n}\n"],
+  "mappings": "AAAA,SAAS,oBAAoB,oBAAoB;AAEjD,SAAS,uBAAuB;AAChC,SAAS,wBAAwB;AAM1B,SAAS,SAAS,OAAsB;AAC7C,QAAM,EAAE,OAAO,OAAO,IAAI,aAAa;AACvC,mBAAiB,MAAM,IAAI,OAAO,MAAM;AAAA,IACtC,mBAAmB,MAAM,MAAM;AAAA,IAAG,mBAAmB,MAAM,KAAK;AAAA,IAChE,mBAAmB,MAAM,WAAW,KAAK;AAAA,IAAG;AAAA,IAAO;AAAA,IAAQ,mBAAmB,MAAM,QAAQ,EAAE;AAAA,EAChG,GAAG,CAAC,MAAM,QAAQ,MAAM,OAAO,MAAM,SAAS,MAAM,MAAM,OAAO,MAAM,CAAC;AACxE,SAAO,MAAM;AACf;",
+  "names": []
+}

package/dist/features/viz/lib/log-scale.d.ts

@@ -0,0 +1,2 @@
+import type { LinearDomain, ResolvedLogScale, ScaleRange } from "./types.js";
+export declare function resolveLogScale(domainInput: LinearDomain, range: ScaleRange, reverse: boolean, width: number, height: number, base: number): ResolvedLogScale;

package/dist/features/viz/lib/log-scale.js

@@ -0,0 +1,53 @@
+import { resolveLinearScale } from "./linear-scale.js";
+function positive(value, field) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0)
+    throw new RangeError(`LogScale ${field} must be finite and positive.`);
+  return value;
+}
+function resolveLogScale(domainInput, range, reverse, width, height, base) {
+  if (typeof base !== "number" || !Number.isFinite(base) || base <= 1)
+    throw new RangeError("LogScale base must be finite and greater than one.");
+  if (!Array.isArray(domainInput) || domainInput.length !== 2)
+    throw new RangeError("LogScale domain requires two positive endpoints.");
+  const domain = Object.freeze([positive(domainInput[0], "domain"), positive(domainInput[1], "domain")]);
+  const logarithm = (value) => Math.log(positive(value, "map input"));
+  const mapping = resolveLinearScale([logarithm(domain[0]), logarithm(domain[1])], range, reverse, width, height);
+  return Object.freeze({
+    ...mapping,
+    type: "log",
+    domain,
+    base,
+    map(value) {
+      return mapping.map(logarithm(value));
+    },
+    invert(pixel) {
+      if (pixel === mapping.range[0] && mapping.range[0] !== mapping.range[1]) return domain[0];
+      if (pixel === mapping.range[1] && mapping.range[0] !== mapping.range[1]) return domain[1];
+      return positive(Math.exp(mapping.invert(pixel)), "inverted output");
+    },
+    ticks(count = 5) {
+      if (!Number.isInteger(count) || count < 2 || count > 100)
+        throw new RangeError("LogScale ticks count must be an integer from 2 to 100.");
+      if (count === 2) return Object.freeze([...domain]);
+      const lo = Math.min(...domain), hi = Math.max(...domain);
+      const first = Math.floor(Math.log(lo) / Math.log(base)) + 1;
+      const last = Math.ceil(Math.log(hi) / Math.log(base)) - 1;
+      if (!Number.isSafeInteger(first) || !Number.isSafeInteger(last))
+        throw new RangeError("LogScale tick exponents exceed numeric precision; choose a larger base.");
+      const stride = Math.max(1, Math.ceil((last - first + 1) / (count - 2)));
+      const ticks = [lo];
+      for (let i = 0; i < count - 2; i++) {
+        const exponent = first + i * stride;
+        if (exponent > last) break;
+        const value = base ** exponent;
+        if (Number.isFinite(value) && value > ticks[ticks.length - 1] && value < hi) ticks.push(value);
+      }
+      ticks.push(hi);
+      return Object.freeze(domain[0] > domain[1] ? ticks.reverse() : ticks);
+    }
+  });
+}
+export {
+  resolveLogScale
+};
+//# sourceMappingURL=log-scale.js.map

package/dist/features/viz/lib/log-scale.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/viz/lib/log-scale.ts"],
+  "sourcesContent": ["import type { LinearDomain, ResolvedLogScale, ScaleRange } from \"./types.js\";\nimport { resolveLinearScale } from \"./linear-scale.js\";\nfunction positive(value: number, field: string): number {\n  if (typeof value !== \"number\" || !Number.isFinite(value) || value <= 0)\n    throw new RangeError(`LogScale ${field} must be finite and positive.`);\n  return value;\n}\nexport function resolveLogScale(domainInput: LinearDomain, range: ScaleRange, reverse: boolean, width: number, height: number, base: number): ResolvedLogScale {\n  if (typeof base !== \"number\" || !Number.isFinite(base) || base <= 1)\n    throw new RangeError(\"LogScale base must be finite and greater than one.\");\n  if (!Array.isArray(domainInput) || domainInput.length !== 2)\n    throw new RangeError(\"LogScale domain requires two positive endpoints.\");\n  const domain = Object.freeze([positive(domainInput[0], \"domain\"), positive(domainInput[1], \"domain\")] as const);\n  const logarithm = (value: number) => Math.log(positive(value, \"map input\"));\n  const mapping = resolveLinearScale([logarithm(domain[0]), logarithm(domain[1])], range, reverse, width, height);\n  return Object.freeze({\n    ...mapping, type: \"log\", domain, base,\n    map(value: number) { return mapping.map(logarithm(value)); },\n    invert(pixel: number) {\n      if (pixel === mapping.range[0] && mapping.range[0] !== mapping.range[1]) return domain[0];\n      if (pixel === mapping.range[1] && mapping.range[0] !== mapping.range[1]) return domain[1];\n      return positive(Math.exp(mapping.invert(pixel)), \"inverted output\");\n    },\n    ticks(count = 5) {\n      if (!Number.isInteger(count) || count < 2 || count > 100)\n        throw new RangeError(\"LogScale ticks count must be an integer from 2 to 100.\");\n      if (count === 2) return Object.freeze([...domain]);\n      const lo = Math.min(...domain), hi = Math.max(...domain);\n      const first = Math.floor(Math.log(lo) / Math.log(base)) + 1;\n      const last = Math.ceil(Math.log(hi) / Math.log(base)) - 1;\n      if (!Number.isSafeInteger(first) || !Number.isSafeInteger(last))\n        throw new RangeError(\"LogScale tick exponents exceed numeric precision; choose a larger base.\");\n      const stride = Math.max(1, Math.ceil((last - first + 1) / (count - 2)));\n      const ticks: number[] = [lo];\n      for (let i = 0; i < count - 2; i++) {\n        const exponent = first + i * stride;\n        if (exponent > last) break;\n        const value = base ** exponent;\n        if (Number.isFinite(value) && value > ticks[ticks.length - 1] && value < hi) ticks.push(value);\n      }\n      ticks.push(hi);\n      return Object.freeze(domain[0] > domain[1] ? ticks.reverse() : ticks);\n    },\n  });\n}\n"],
+  "mappings": "AACA,SAAS,0BAA0B;AACnC,SAAS,SAAS,OAAe,OAAuB;AACtD,MAAI,OAAO,UAAU,YAAY,CAAC,OAAO,SAAS,KAAK,KAAK,SAAS;AACnE,UAAM,IAAI,WAAW,YAAY,KAAK,+BAA+B;AACvE,SAAO;AACT;AACO,SAAS,gBAAgB,aAA2B,OAAmB,SAAkB,OAAe,QAAgB,MAAgC;AAC7J,MAAI,OAAO,SAAS,YAAY,CAAC,OAAO,SAAS,IAAI,KAAK,QAAQ;AAChE,UAAM,IAAI,WAAW,oDAAoD;AAC3E,MAAI,CAAC,MAAM,QAAQ,WAAW,KAAK,YAAY,WAAW;AACxD,UAAM,IAAI,WAAW,kDAAkD;AACzE,QAAM,SAAS,OAAO,OAAO,CAAC,SAAS,YAAY,CAAC,GAAG,QAAQ,GAAG,SAAS,YAAY,CAAC,GAAG,QAAQ,CAAC,CAAU;AAC9G,QAAM,YAAY,CAAC,UAAkB,KAAK,IAAI,SAAS,OAAO,WAAW,CAAC;AAC1E,QAAM,UAAU,mBAAmB,CAAC,UAAU,OAAO,CAAC,CAAC,GAAG,UAAU,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,SAAS,OAAO,MAAM;AAC9G,SAAO,OAAO,OAAO;AAAA,IACnB,GAAG;AAAA,IAAS,MAAM;AAAA,IAAO;AAAA,IAAQ;AAAA,IACjC,IAAI,OAAe;AAAE,aAAO,QAAQ,IAAI,UAAU,KAAK,CAAC;AAAA,IAAG;AAAA,IAC3D,OAAO,OAAe;AACpB,UAAI,UAAU,QAAQ,MAAM,CAAC,KAAK,QAAQ,MAAM,CAAC,MAAM,QAAQ,MAAM,CAAC,EAAG,QAAO,OAAO,CAAC;AACxF,UAAI,UAAU,QAAQ,MAAM,CAAC,KAAK,QAAQ,MAAM,CAAC,MAAM,QAAQ,MAAM,CAAC,EAAG,QAAO,OAAO,CAAC;AACxF,aAAO,SAAS,KAAK,IAAI,QAAQ,OAAO,KAAK,CAAC,GAAG,iBAAiB;AAAA,IACpE;AAAA,IACA,MAAM,QAAQ,GAAG;AACf,UAAI,CAAC,OAAO,UAAU,KAAK,KAAK,QAAQ,KAAK,QAAQ;AACnD,cAAM,IAAI,WAAW,wDAAwD;AAC/E,UAAI,UAAU,EAAG,QAAO,OAAO,OAAO,CAAC,GAAG,MAAM,CAAC;AACjD,YAAM,KAAK,KAAK,IAAI,GAAG,MAAM,GAAG,KAAK,KAAK,IAAI,GAAG,MAAM;AACvD,YAAM,QAAQ,KAAK,MAAM,KAAK,IAAI,EAAE,IAAI,KAAK,IAAI,IAAI,CAAC,IAAI;AAC1D,YAAM,OAAO,KAAK,KAAK,KAAK,IAAI,EAAE,IAAI,KAAK,IAAI,IAAI,CAAC,IAAI;AACxD,UAAI,CAAC,OAAO,cAAc,KAAK,KAAK,CAAC,OAAO,cAAc,IAAI;AAC5D,cAAM,IAAI,WAAW,yEAAyE;AAChG,YAAM,SAAS,KAAK,IAAI,GAAG,KAAK,MAAM,OAAO,QAAQ,MAAM,QAAQ,EAAE,CAAC;AACtE,YAAM,QAAkB,CAAC,EAAE;AAC3B,eAAS,IAAI,GAAG,IAAI,QAAQ,GAAG,KAAK;AAClC,cAAM,WAAW,QAAQ,IAAI;AAC7B,YAAI,WAAW,KAAM;AACrB,cAAM,QAAQ,QAAQ;AACtB,YAAI,OAAO,SAAS,KAAK,KAAK,QAAQ,MAAM,MAAM,SAAS,CAAC,KAAK,QAAQ,GAAI,OAAM,KAAK,KAAK;AAAA,MAC/F;AACA,YAAM,KAAK,EAAE;AACb,aAAO,OAAO,OAAO,OAAO,CAAC,IAAI,OAAO,CAAC,IAAI,MAAM,QAAQ,IAAI,KAAK;AAAA,IACtE;AAAA,EACF,CAAC;AACH;",
+  "names": []
+}

package/dist/features/viz/lib/monotone-curve.d.ts

@@ -0,0 +1,11 @@
+import { type SeriesCurve } from "./curve-definition.js";
+/**
+ * Returns the immutable monotone-X cubic Hermite definition.
+ *
+ * It uses weighted harmonic interior slopes and limited one-sided endpoint slopes, preserving every observation,
+ * flat segment, and local extremum without sorting data. Each run must have strictly ascending
+ * or strictly descending x coordinates.
+ *
+ * @returns The named {@link SeriesCurve} definition.
+ */
+export declare function monotoneX(): SeriesCurve;

package/dist/features/viz/lib/monotone-curve.js

@@ -0,0 +1,63 @@
+import {
+  createSeriesCurve
+} from "./curve-definition.js";
+function endpointSlope(h0, h1, first, second) {
+  let slope = ((2 * h0 + h1) * first - h0 * second) / (h0 + h1);
+  if (Math.sign(slope) !== Math.sign(first)) return 0;
+  if (Math.sign(first) !== Math.sign(second) && Math.abs(slope) > Math.abs(3 * first))
+    slope = 3 * first;
+  return slope;
+}
+function monotoneSegments(points) {
+  if (points.length < 2) return [];
+  const direction = points[1][0] > points[0][0] ? 1 : -1;
+  const x = points.map((point) => direction * point[0]);
+  const h = [];
+  const delta = [];
+  for (let i = 0; i < points.length - 1; i++) {
+    const width = x[i + 1] - x[i];
+    if (!Number.isFinite(width) || width <= 0)
+      throw new RangeError(
+        "monotoneX requires strictly ascending or descending finite x coordinates."
+      );
+    h.push(width);
+    delta.push((points[i + 1][1] - points[i][1]) / width);
+  }
+  const slopes = new Array(points.length);
+  if (points.length === 2) slopes[0] = slopes[1] = delta[0];
+  else {
+    slopes[0] = endpointSlope(h[0], h[1], delta[0], delta[1]);
+    slopes[points.length - 1] = endpointSlope(
+      h.at(-1),
+      h.at(-2),
+      delta.at(-1),
+      delta.at(-2)
+    );
+    for (let i = 1; i < points.length - 1; i++) {
+      const previous = delta[i - 1], next = delta[i];
+      slopes[i] = previous === 0 || next === 0 || Math.sign(previous) !== Math.sign(next) ? 0 : 3 * (h[i - 1] + h[i]) / ((2 * h[i] + h[i - 1]) / previous + (h[i] + 2 * h[i - 1]) / next);
+    }
+  }
+  return points.slice(1).map((end, index) => {
+    const start = points[index], width = h[index];
+    const control1 = [
+      start[0] + (end[0] - start[0]) / 3,
+      start[1] + slopes[index] * width / 3
+    ];
+    const control2 = [
+      end[0] - (end[0] - start[0]) / 3,
+      end[1] - slopes[index + 1] * width / 3
+    ];
+    if (!Number.isFinite(control1[0]) || !Number.isFinite(control1[1]) || !Number.isFinite(control2[0]) || !Number.isFinite(control2[1]) || !Number.isFinite(end[0]) || !Number.isFinite(end[1]))
+      throw new RangeError("monotoneX generated non-finite cubic controls.");
+    return Object.freeze({ end, control1, control2 });
+  });
+}
+const monotone = /* @__PURE__ */ createSeriesCurve(monotoneSegments);
+function monotoneX() {
+  return monotone;
+}
+export {
+  monotoneX
+};
+//# sourceMappingURL=monotone-curve.js.map

package/dist/features/viz/lib/monotone-curve.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/viz/lib/monotone-curve.ts"],
+  "sourcesContent": ["import {\n  createSeriesCurve,\n  type SeriesCurve,\n  type SeriesCurvePoint,\n} from \"./curve-definition.js\";\n\nfunction endpointSlope(\n  h0: number,\n  h1: number,\n  first: number,\n  second: number,\n): number {\n  let slope = ((2 * h0 + h1) * first - h0 * second) / (h0 + h1);\n  if (Math.sign(slope) !== Math.sign(first)) return 0;\n  if (\n    Math.sign(first) !== Math.sign(second) &&\n    Math.abs(slope) > Math.abs(3 * first)\n  )\n    slope = 3 * first;\n  return slope;\n}\n\nfunction monotoneSegments(points: readonly SeriesCurvePoint[]) {\n  if (points.length < 2) return [];\n  const direction = points[1][0] > points[0][0] ? 1 : -1;\n  const x = points.map((point) => direction * point[0]);\n  const h: number[] = [];\n  const delta: number[] = [];\n  for (let i = 0; i < points.length - 1; i++) {\n    const width = x[i + 1] - x[i];\n    if (!Number.isFinite(width) || width <= 0)\n      throw new RangeError(\n        \"monotoneX requires strictly ascending or descending finite x coordinates.\",\n      );\n    h.push(width);\n    delta.push((points[i + 1][1] - points[i][1]) / width);\n  }\n  const slopes = new Array<number>(points.length);\n  if (points.length === 2) slopes[0] = slopes[1] = delta[0];\n  else {\n    slopes[0] = endpointSlope(h[0], h[1], delta[0], delta[1]);\n    slopes[points.length - 1] = endpointSlope(\n      h.at(-1)!,\n      h.at(-2)!,\n      delta.at(-1)!,\n      delta.at(-2)!,\n    );\n    for (let i = 1; i < points.length - 1; i++) {\n      const previous = delta[i - 1],\n        next = delta[i];\n      slopes[i] =\n        previous === 0 || next === 0 || Math.sign(previous) !== Math.sign(next)\n          ? 0\n          : (3 * (h[i - 1] + h[i])) /\n            ((2 * h[i] + h[i - 1]) / previous + (h[i] + 2 * h[i - 1]) / next);\n    }\n  }\n  return points.slice(1).map((end, index) => {\n    const start = points[index],\n      width = h[index];\n    const control1: SeriesCurvePoint = [\n      start[0] + (end[0] - start[0]) / 3,\n      start[1] + (slopes[index] * width) / 3,\n    ];\n    const control2: SeriesCurvePoint = [\n      end[0] - (end[0] - start[0]) / 3,\n      end[1] - (slopes[index + 1] * width) / 3,\n    ];\n    if ((!Number.isFinite(control1[0]) || !Number.isFinite(control1[1]) || !Number.isFinite(control2[0]) || !Number.isFinite(control2[1]) || !Number.isFinite(end[0]) || !Number.isFinite(end[1])))\n      throw new RangeError(\"monotoneX generated non-finite cubic controls.\");\n    return Object.freeze({ end, control1, control2 });\n  });\n}\n\nconst monotone = /* @__PURE__ */ createSeriesCurve(monotoneSegments);\n\n/**\n * Returns the immutable monotone-X cubic Hermite definition.\n *\n * It uses weighted harmonic interior slopes and limited one-sided endpoint slopes, preserving every observation,\n * flat segment, and local extremum without sorting data. Each run must have strictly ascending\n * or strictly descending x coordinates.\n *\n * @returns The named {@link SeriesCurve} definition.\n */\nexport function monotoneX(): SeriesCurve {\n  return monotone;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/features/viz/lib/nearest.d.ts

@@ -1,10 +1,10 @@
-import type { ResolvedLinearScale } from "./types.js";
+import type { ResolvedContinuousScale } from "./types.js";
 import type { PointAccessor } from "./point-types.js";
 /**
  * Coordinate accessors, resolved scales, and candidate filtering for a nearest-point search.
  *
  * @see {@link PointAccessor}
- * @see {@link ResolvedLinearScale}
+ * @see {@link ResolvedContinuousScale}
  * @see {@link nearestPoint}
  */
 export interface NearestPointOptions<D> {
@@ -12,10 +12,10 @@ export interface NearestPointOptions<D> {
     readonly x: PointAccessor<D>;
     /** Property key or callback extracting the vertical domain coordinate. See {@link PointAccessor}. */
     readonly y: PointAccessor<D>;
-    /** The scale used to map horizontal data coordinates. See {@link ResolvedLinearScale}. */
-    readonly xScale: ResolvedLinearScale;
-    /** The scale used to map vertical data coordinates. See {@link ResolvedLinearScale}. */
-    readonly yScale: ResolvedLinearScale;
+    /** The scale used to map horizontal data coordinates. See {@link ResolvedContinuousScale}. */
+    readonly xScale: ResolvedContinuousScale;
+    /** The scale used to map vertical data coordinates. See {@link ResolvedContinuousScale}. */
+    readonly yScale: ResolvedContinuousScale;
     /**
      * Returns whether a datum contributes drawable or queryable coordinates. See
      * {@link NearestPointOptions}.
@@ -57,12 +57,12 @@ export interface NearestPoint<D> {
  *
  * @param values - Candidate domain values.
  * @param rangeValue - Pointer coordinate in the scale's range.
- * @param scale - Scale mapping candidates into range coordinates. See {@link ResolvedLinearScale}.
+ * @param scale - Scale mapping candidates into range coordinates. See {@link ResolvedContinuousScale}.
  * @returns The nearest domain value, or undefined when no candidate can be selected.
  *
- * @see {@link ResolvedLinearScale}
+ * @see {@link ResolvedContinuousScale}
  */
-export declare function nearestDomainValue(values: readonly number[], rangeValue: number, scale: ResolvedLinearScale): number | undefined;
+export declare function nearestDomainValue(values: readonly number[], rangeValue: number, scale: ResolvedContinuousScale): number | undefined;
 /**
  * Finds the nearest defined datum in scaled coordinates, subject to an optional maximum distance.
  *

package/dist/features/viz/lib/nearest.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/features/viz/lib/nearest.ts"],
-  "sourcesContent": ["import type { ResolvedLinearScale } from \"./types.js\";\nimport type { PointAccessor } from \"./point-types.js\";\nimport { finiteCoordinate, pointAccessor, pointData } from \"./point-data.js\";\n/**\n * Coordinate accessors, resolved scales, and candidate filtering for a nearest-point search.\n *\n * @see {@link PointAccessor}\n * @see {@link ResolvedLinearScale}\n * @see {@link nearestPoint}\n */\nexport interface NearestPointOptions<D> {\n  /** Property key or callback extracting the horizontal domain coordinate. See {@link PointAccessor}. */\n  readonly x: PointAccessor<D>;\n  /** Property key or callback extracting the vertical domain coordinate. See {@link PointAccessor}. */\n  readonly y: PointAccessor<D>;\n  /** The scale used to map horizontal data coordinates. See {@link ResolvedLinearScale}. */\n  readonly xScale: ResolvedLinearScale;\n  /** The scale used to map vertical data coordinates. See {@link ResolvedLinearScale}. */\n  readonly yScale: ResolvedLinearScale;\n  /**\n   * Returns whether a datum contributes drawable or queryable coordinates. See\n   * {@link NearestPointOptions}.\n   * @param datum - Datum to test.\n   * @param index - Zero-based index in the source data.\n   * @param data - Complete source data array.\n   * @returns Whether this datum should participate in the series or query.\n   */\n  readonly defined?: (datum: D, index: number, data: readonly D[]) => boolean;\n  /** Maximum distance accepted by the query. See {@link NearestPointOptions}. */\n  readonly maxDistance?: number;\n}\n/**\n * The selected datum, source index, mapped coordinates, and distance from the query point.\n *\n * @see {@link nearestPoint}\n */\nexport interface NearestPoint<D> {\n  /** The original data item selected by this result. See {@link NearestPoint}. */\n  readonly datum: D;\n  /** Index of the selected datum in its source data. See {@link NearestPoint}. */\n  readonly index: number;\n  /**\n   * Horizontal coordinate or displacement in the containing coordinate system. See\n   * {@link NearestPoint}.\n   */\n  readonly x: number;\n  /**\n   * Vertical coordinate or displacement in the containing coordinate system. See\n   * {@link NearestPoint}.\n   */\n  readonly y: number;\n  /** Distance measured in this query or guide's coordinate system. See {@link NearestPoint}. */\n  readonly distance: number;\n}\nfunction finite(value: unknown, name: string): asserts value is number {\n  if (!finiteCoordinate(value)) throw new RangeError(`${name} must be finite.`);\n}\n/**\n * Finds the domain value nearest to a logical range coordinate; returns undefined for no\n * candidate.\n *\n * @param values - Candidate domain values.\n * @param rangeValue - Pointer coordinate in the scale's range.\n * @param scale - Scale mapping candidates into range coordinates. See {@link ResolvedLinearScale}.\n * @returns The nearest domain value, or undefined when no candidate can be selected.\n *\n * @see {@link ResolvedLinearScale}\n */\nexport function nearestDomainValue(\n  values: readonly number[],\n  rangeValue: number,\n  scale: ResolvedLinearScale,\n): number | undefined {\n  pointData(values, \"nearestDomainValue\");\n  finite(rangeValue, \"nearestDomainValue rangeValue\");\n  let best: number | undefined,\n    distance = Infinity;\n  for (const value of values) {\n    if (!finiteCoordinate(value)) continue;\n    const next = Math.abs(scale.map(value) - rangeValue);\n    finite(next, \"nearestDomainValue distance\");\n    if (next < distance) {\n      best = value;\n      distance = next;\n    }\n  }\n  return best;\n}\n/**\n * Finds the nearest defined datum in scaled coordinates, subject to an optional maximum distance.\n *\n * @param data - Candidate data records.\n * @param point - Query point in plotted range coordinates.\n * @param options - Accessors, scales, eligibility, and distance settings. See\n * {@link NearestPointOptions} .\n * @returns The nearest matching point, or undefined when no candidate qualifies. See\n * {@link NearestPoint} .\n *\n * @see {@link NearestPointOptions}\n * @see {@link NearestPoint}\n */\nexport function nearestPoint<D>(\n  data: readonly D[],\n  point: Readonly<{ x: number; y: number }>,\n  options: NearestPointOptions<D>,\n): NearestPoint<D> | undefined {\n  pointData(data, \"nearestPoint\");\n  finite(point.x, \"nearestPoint x\");\n  finite(point.y, \"nearestPoint y\");\n  const max = options.maxDistance;\n  if (max !== undefined) {\n    finite(max, \"nearestPoint maxDistance\");\n    if (max < 0)\n      throw new RangeError(\"nearestPoint maxDistance must be nonnegative.\");\n  }\n  const x = pointAccessor(options.x),\n    y = pointAccessor(options.y);\n  let best: NearestPoint<D> | undefined,\n    distance = Infinity;\n  for (let i = 0; i < data.length; i++) {\n    const datum = data[i];\n    if (options.defined && !options.defined(datum, i, data)) continue;\n    const xv = x(datum, i, data),\n      yv = y(datum, i, data);\n    if (!finiteCoordinate(xv) || !finiteCoordinate(yv)) continue;\n    const px = options.xScale.map(xv),\n      py = options.yScale.map(yv);\n    const next = Math.hypot(px - point.x, py - point.y);\n    finite(next, \"nearestPoint distance\");\n    if (next < distance && (max === undefined || next <= max)) {\n      distance = next;\n      best = { datum, index: i, x: px, y: py, distance: next };\n    }\n  }\n  return best;\n}\n"],
+  "sourcesContent": ["import type { ResolvedContinuousScale } from \"./types.js\";\nimport type { PointAccessor } from \"./point-types.js\";\nimport { finiteCoordinate, pointAccessor, pointData } from \"./point-data.js\";\n/**\n * Coordinate accessors, resolved scales, and candidate filtering for a nearest-point search.\n *\n * @see {@link PointAccessor}\n * @see {@link ResolvedContinuousScale}\n * @see {@link nearestPoint}\n */\nexport interface NearestPointOptions<D> {\n  /** Property key or callback extracting the horizontal domain coordinate. See {@link PointAccessor}. */\n  readonly x: PointAccessor<D>;\n  /** Property key or callback extracting the vertical domain coordinate. See {@link PointAccessor}. */\n  readonly y: PointAccessor<D>;\n  /** The scale used to map horizontal data coordinates. See {@link ResolvedContinuousScale}. */\n  readonly xScale: ResolvedContinuousScale;\n  /** The scale used to map vertical data coordinates. See {@link ResolvedContinuousScale}. */\n  readonly yScale: ResolvedContinuousScale;\n  /**\n   * Returns whether a datum contributes drawable or queryable coordinates. See\n   * {@link NearestPointOptions}.\n   * @param datum - Datum to test.\n   * @param index - Zero-based index in the source data.\n   * @param data - Complete source data array.\n   * @returns Whether this datum should participate in the series or query.\n   */\n  readonly defined?: (datum: D, index: number, data: readonly D[]) => boolean;\n  /** Maximum distance accepted by the query. See {@link NearestPointOptions}. */\n  readonly maxDistance?: number;\n}\n/**\n * The selected datum, source index, mapped coordinates, and distance from the query point.\n *\n * @see {@link nearestPoint}\n */\nexport interface NearestPoint<D> {\n  /** The original data item selected by this result. See {@link NearestPoint}. */\n  readonly datum: D;\n  /** Index of the selected datum in its source data. See {@link NearestPoint}. */\n  readonly index: number;\n  /**\n   * Horizontal coordinate or displacement in the containing coordinate system. See\n   * {@link NearestPoint}.\n   */\n  readonly x: number;\n  /**\n   * Vertical coordinate or displacement in the containing coordinate system. See\n   * {@link NearestPoint}.\n   */\n  readonly y: number;\n  /** Distance measured in this query or guide's coordinate system. See {@link NearestPoint}. */\n  readonly distance: number;\n}\nfunction finite(value: unknown, name: string): asserts value is number {\n  if (!finiteCoordinate(value)) throw new RangeError(`${name} must be finite.`);\n}\n/**\n * Finds the domain value nearest to a logical range coordinate; returns undefined for no\n * candidate.\n *\n * @param values - Candidate domain values.\n * @param rangeValue - Pointer coordinate in the scale's range.\n * @param scale - Scale mapping candidates into range coordinates. See {@link ResolvedContinuousScale}.\n * @returns The nearest domain value, or undefined when no candidate can be selected.\n *\n * @see {@link ResolvedContinuousScale}\n */\nexport function nearestDomainValue(\n  values: readonly number[],\n  rangeValue: number,\n  scale: ResolvedContinuousScale,\n): number | undefined {\n  pointData(values, \"nearestDomainValue\");\n  finite(rangeValue, \"nearestDomainValue rangeValue\");\n  let best: number | undefined,\n    distance = Infinity;\n  for (const value of values) {\n    if (!finiteCoordinate(value)) continue;\n    const next = Math.abs(scale.map(value) - rangeValue);\n    finite(next, \"nearestDomainValue distance\");\n    if (next < distance) {\n      best = value;\n      distance = next;\n    }\n  }\n  return best;\n}\n/**\n * Finds the nearest defined datum in scaled coordinates, subject to an optional maximum distance.\n *\n * @param data - Candidate data records.\n * @param point - Query point in plotted range coordinates.\n * @param options - Accessors, scales, eligibility, and distance settings. See\n * {@link NearestPointOptions} .\n * @returns The nearest matching point, or undefined when no candidate qualifies. See\n * {@link NearestPoint} .\n *\n * @see {@link NearestPointOptions}\n * @see {@link NearestPoint}\n */\nexport function nearestPoint<D>(\n  data: readonly D[],\n  point: Readonly<{ x: number; y: number }>,\n  options: NearestPointOptions<D>,\n): NearestPoint<D> | undefined {\n  pointData(data, \"nearestPoint\");\n  finite(point.x, \"nearestPoint x\");\n  finite(point.y, \"nearestPoint y\");\n  const max = options.maxDistance;\n  if (max !== undefined) {\n    finite(max, \"nearestPoint maxDistance\");\n    if (max < 0)\n      throw new RangeError(\"nearestPoint maxDistance must be nonnegative.\");\n  }\n  const x = pointAccessor(options.x),\n    y = pointAccessor(options.y);\n  let best: NearestPoint<D> | undefined,\n    distance = Infinity;\n  for (let i = 0; i < data.length; i++) {\n    const datum = data[i];\n    if (options.defined && !options.defined(datum, i, data)) continue;\n    const xv = x(datum, i, data),\n      yv = y(datum, i, data);\n    if (!finiteCoordinate(xv) || !finiteCoordinate(yv)) continue;\n    const px = options.xScale.map(xv),\n      py = options.yScale.map(yv);\n    const next = Math.hypot(px - point.x, py - point.y);\n    finite(next, \"nearestPoint distance\");\n    if (next < distance && (max === undefined || next <= max)) {\n      distance = next;\n      best = { datum, index: i, x: px, y: py, distance: next };\n    }\n  }\n  return best;\n}\n"],
   "mappings": "AAEA,SAAS,kBAAkB,eAAe,iBAAiB;AAoD3D,SAAS,OAAO,OAAgB,MAAuC;AACrE,MAAI,CAAC,iBAAiB,KAAK,EAAG,OAAM,IAAI,WAAW,GAAG,IAAI,kBAAkB;AAC9E;AAYO,SAAS,mBACd,QACA,YACA,OACoB;AACpB,YAAU,QAAQ,oBAAoB;AACtC,SAAO,YAAY,+BAA+B;AAClD,MAAI,MACF,WAAW;AACb,aAAW,SAAS,QAAQ;AAC1B,QAAI,CAAC,iBAAiB,KAAK,EAAG;AAC9B,UAAM,OAAO,KAAK,IAAI,MAAM,IAAI,KAAK,IAAI,UAAU;AACnD,WAAO,MAAM,6BAA6B;AAC1C,QAAI,OAAO,UAAU;AACnB,aAAO;AACP,iBAAW;AAAA,IACb;AAAA,EACF;AACA,SAAO;AACT;AAcO,SAAS,aACd,MACA,OACA,SAC6B;AAC7B,YAAU,MAAM,cAAc;AAC9B,SAAO,MAAM,GAAG,gBAAgB;AAChC,SAAO,MAAM,GAAG,gBAAgB;AAChC,QAAM,MAAM,QAAQ;AACpB,MAAI,QAAQ,QAAW;AACrB,WAAO,KAAK,0BAA0B;AACtC,QAAI,MAAM;AACR,YAAM,IAAI,WAAW,+CAA+C;AAAA,EACxE;AACA,QAAM,IAAI,cAAc,QAAQ,CAAC,GAC/B,IAAI,cAAc,QAAQ,CAAC;AAC7B,MAAI,MACF,WAAW;AACb,WAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,UAAM,QAAQ,KAAK,CAAC;AACpB,QAAI,QAAQ,WAAW,CAAC,QAAQ,QAAQ,OAAO,GAAG,IAAI,EAAG;AACzD,UAAM,KAAK,EAAE,OAAO,GAAG,IAAI,GACzB,KAAK,EAAE,OAAO,GAAG,IAAI;AACvB,QAAI,CAAC,iBAAiB,EAAE,KAAK,CAAC,iBAAiB,EAAE,EAAG;AACpD,UAAM,KAAK,QAAQ,OAAO,IAAI,EAAE,GAC9B,KAAK,QAAQ,OAAO,IAAI,EAAE;AAC5B,UAAM,OAAO,KAAK,MAAM,KAAK,MAAM,GAAG,KAAK,MAAM,CAAC;AAClD,WAAO,MAAM,uBAAuB;AACpC,QAAI,OAAO,aAAa,QAAQ,UAAa,QAAQ,MAAM;AACzD,iBAAW;AACX,aAAO,EAAE,OAAO,OAAO,GAAG,GAAG,IAAI,GAAG,IAAI,UAAU,KAAK;AAAA,IACzD;AAAA,EACF;AACA,SAAO;AACT;",
   "names": []
 }

package/dist/features/viz/lib/numeric-range-interpolation.d.ts

@@ -0,0 +1,15 @@
+import type { NumericDomain } from "./types.js";
+/**
+ * Linearly interpolates both endpoints of a finite numeric range.
+ *
+ * The returned pair is frozen. It preserves ascending, descending, and flat
+ * endpoint order for progress within zero through one. Progress outside that
+ * interval deliberately extrapolates, matching Pibbl's numeric tween behavior.
+ *
+ * @param from - Starting finite endpoint pair.
+ * @param to - Ending finite endpoint pair.
+ * @param progress - Finite interpolation progress supplied by an animation definition.
+ * @returns A frozen finite endpoint pair.
+ * @see {@link NumericDomain}
+ */
+export declare function interpolateNumericRange(from: NumericDomain, to: NumericDomain, progress: number): NumericDomain;

package/dist/features/viz/lib/numeric-range-interpolation.js

@@ -0,0 +1,36 @@
+function endpoint(value, name) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    throw new RangeError(`Numeric range ${name} must be finite.`);
+  return value;
+}
+function range(value, name) {
+  if (!Array.isArray(value) || value.length !== 2)
+    throw new TypeError(`Numeric range ${name} requires two endpoints.`);
+  return [endpoint(value[0], `${name}[0]`), endpoint(value[1], `${name}[1]`)];
+}
+function interpolateEndpoint(from, to, progress) {
+  if (progress === 0 || from === to) return from;
+  if (progress === 1) return to;
+  const difference = to - from;
+  const direct = from + difference * progress;
+  if (Number.isFinite(direct)) return direct;
+  const scale = Math.max(Math.abs(from), Math.abs(to));
+  const scaled = (from / scale + (to / scale - from / scale) * progress) * scale;
+  if (!Number.isFinite(scaled))
+    throw new RangeError("Numeric range interpolation must produce finite endpoints.");
+  return scaled;
+}
+function interpolateNumericRange(from, to, progress) {
+  const start = range(from, "from");
+  const end = range(to, "to");
+  if (typeof progress !== "number" || !Number.isFinite(progress))
+    throw new RangeError("Numeric range interpolation progress must be finite.");
+  return Object.freeze([
+    interpolateEndpoint(start[0], end[0], progress),
+    interpolateEndpoint(start[1], end[1], progress)
+  ]);
+}
+export {
+  interpolateNumericRange
+};
+//# sourceMappingURL=numeric-range-interpolation.js.map

package/dist/features/viz/lib/numeric-range-interpolation.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/viz/lib/numeric-range-interpolation.ts"],
+  "sourcesContent": ["import type { NumericDomain } from \"./types.js\";\n\nfunction endpoint(value: unknown, name: string): number {\n  if (typeof value !== \"number\" || !Number.isFinite(value))\n    throw new RangeError(`Numeric range ${name} must be finite.`);\n  return value;\n}\n\nfunction range(value: NumericDomain, name: string): readonly [number, number] {\n  if (!Array.isArray(value) || value.length !== 2)\n    throw new TypeError(`Numeric range ${name} requires two endpoints.`);\n  return [endpoint(value[0], `${name}[0]`), endpoint(value[1], `${name}[1]`)];\n}\n\nfunction interpolateEndpoint(from: number, to: number, progress: number): number {\n  if (progress === 0 || from === to) return from;\n  if (progress === 1) return to;\n  const difference = to - from;\n  const direct = from + difference * progress;\n  if (Number.isFinite(direct)) return direct;\n\n  // Scaling avoids overflow in the subtraction for opposite, very large endpoints.\n  const scale = Math.max(Math.abs(from), Math.abs(to));\n  const scaled =\n    (from / scale + (to / scale - from / scale) * progress) * scale;\n  if (!Number.isFinite(scaled))\n    throw new RangeError(\"Numeric range interpolation must produce finite endpoints.\");\n  return scaled;\n}\n\n/**\n * Linearly interpolates both endpoints of a finite numeric range.\n *\n * The returned pair is frozen. It preserves ascending, descending, and flat\n * endpoint order for progress within zero through one. Progress outside that\n * interval deliberately extrapolates, matching Pibbl's numeric tween behavior.\n *\n * @param from - Starting finite endpoint pair.\n * @param to - Ending finite endpoint pair.\n * @param progress - Finite interpolation progress supplied by an animation definition.\n * @returns A frozen finite endpoint pair.\n * @see {@link NumericDomain}\n */\nexport function interpolateNumericRange(\n  from: NumericDomain,\n  to: NumericDomain,\n  progress: number,\n): NumericDomain {\n  const start = range(from, \"from\");\n  const end = range(to, \"to\");\n  if (typeof progress !== \"number\" || !Number.isFinite(progress))\n    throw new RangeError(\"Numeric range interpolation progress must be finite.\");\n  return Object.freeze([\n    interpolateEndpoint(start[0], end[0], progress),\n    interpolateEndpoint(start[1], end[1], progress),\n  ]);\n}\n"],
+  "mappings": "AAEA,SAAS,SAAS,OAAgB,MAAsB;AACtD,MAAI,OAAO,UAAU,YAAY,CAAC,OAAO,SAAS,KAAK;AACrD,UAAM,IAAI,WAAW,iBAAiB,IAAI,kBAAkB;AAC9D,SAAO;AACT;AAEA,SAAS,MAAM,OAAsB,MAAyC;AAC5E,MAAI,CAAC,MAAM,QAAQ,KAAK,KAAK,MAAM,WAAW;AAC5C,UAAM,IAAI,UAAU,iBAAiB,IAAI,0BAA0B;AACrE,SAAO,CAAC,SAAS,MAAM,CAAC,GAAG,GAAG,IAAI,KAAK,GAAG,SAAS,MAAM,CAAC,GAAG,GAAG,IAAI,KAAK,CAAC;AAC5E;AAEA,SAAS,oBAAoB,MAAc,IAAY,UAA0B;AAC/E,MAAI,aAAa,KAAK,SAAS,GAAI,QAAO;AAC1C,MAAI,aAAa,EAAG,QAAO;AAC3B,QAAM,aAAa,KAAK;AACxB,QAAM,SAAS,OAAO,aAAa;AACnC,MAAI,OAAO,SAAS,MAAM,EAAG,QAAO;AAGpC,QAAM,QAAQ,KAAK,IAAI,KAAK,IAAI,IAAI,GAAG,KAAK,IAAI,EAAE,CAAC;AACnD,QAAM,UACH,OAAO,SAAS,KAAK,QAAQ,OAAO,SAAS,YAAY;AAC5D,MAAI,CAAC,OAAO,SAAS,MAAM;AACzB,UAAM,IAAI,WAAW,4DAA4D;AACnF,SAAO;AACT;AAeO,SAAS,wBACd,MACA,IACA,UACe;AACf,QAAM,QAAQ,MAAM,MAAM,MAAM;AAChC,QAAM,MAAM,MAAM,IAAI,IAAI;AAC1B,MAAI,OAAO,aAAa,YAAY,CAAC,OAAO,SAAS,QAAQ;AAC3D,UAAM,IAAI,WAAW,sDAAsD;AAC7E,SAAO,OAAO,OAAO;AAAA,IACnB,oBAAoB,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,QAAQ;AAAA,IAC9C,oBAAoB,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,QAAQ;AAAA,EAChD,CAAC;AACH;",
+  "names": []
+}

package/dist/features/viz/lib/numeric-ticks.d.ts

@@ -0,0 +1,38 @@
+import type { NumericDomain } from "./types.js";
+/** Readable linear tick density. See {@link linearTicks}. */
+export interface LinearTickOptions {
+    /** Target number of intervals, from 2 to 100; defaults to 5. */
+    readonly count?: number;
+}
+/**
+ * Generates bounded ticks at readable 1, 2, or 5 × powers-of-ten intervals.
+ * Endpoints are included only when aligned. Does not change scale geometry.
+ * @param domain - Distinct finite endpoints, ascending or descending.
+ * @param options - Target density; defaults to five intervals.
+ * @returns Frozen ticks in domain order. See {@link niceLinearDomain}.
+ */
+export declare function linearTicks(domain: NumericDomain, options?: LinearTickOptions): readonly number[];
+/**
+ * Expands a linear domain to readable tick boundaries, preserving direction.
+ * @param domain - Distinct finite numeric endpoints; never mutated.
+ * @param options - Target density; defaults to five intervals.
+ * @returns Frozen expanded endpoints. See {@link linearTicks}.
+ */
+export declare function niceLinearDomain(domain: NumericDomain, options?: LinearTickOptions): NumericDomain;
+/** Number formatting with explicit locale and literal unit affixes. See {@link formatNumber}. */
+export interface NumberFormatOptions extends Intl.NumberFormatOptions {
+    /** Locale for formatting; defaults to en-US. */
+    readonly locale?: string;
+    /** Literal prefix; defaults to empty. */
+    readonly prefix?: string;
+    /** Literal suffix, including any desired space; defaults to empty. */
+    readonly suffix?: string;
+}
+/**
+ * Formats a finite number with Intl precision, currency, percent, or unit options.
+ * Rounded negative zero is displayed as positive zero.
+ * @param value - Finite numeric value.
+ * @param options - Intl options plus locale and literal affixes; default maximum fraction digits is 3.
+ * @returns Formatted text. Invalid Intl options retain native errors. See {@link NumberFormatOptions}.
+ */
+export declare function formatNumber(value: number, options?: NumberFormatOptions): string;

package/dist/features/viz/lib/numeric-ticks.js

@@ -0,0 +1,54 @@
+function parameters(domain, options) {
+  const count = options.count ?? 5;
+  if (!Number.isInteger(count) || count < 2 || count > 100)
+    throw new RangeError("Linear tick count must be an integer from 2 to 100.");
+  if (!Array.isArray(domain) || domain.length !== 2 || !domain.every(Number.isFinite))
+    throw new RangeError("Linear tick domain requires two finite endpoints.");
+  const lo = Math.min(...domain), hi = Math.max(...domain);
+  const span = hi - lo;
+  if (!Number.isFinite(span) || span === 0)
+    throw new RangeError("Linear tick domain must have a finite nonzero span.");
+  const raw = span / count;
+  const power = 10 ** Math.floor(Math.log10(raw));
+  const error = raw / power;
+  let step = power * (error >= Math.sqrt(50) ? 10 : error >= Math.sqrt(10) ? 5 : error >= Math.sqrt(2) ? 2 : 1);
+  if (!Number.isFinite(step) || step === 0 || !Number.isSafeInteger(Math.floor(lo / step)) || !Number.isSafeInteger(Math.ceil(hi / step)))
+    throw new RangeError("Linear tick spacing exceeds numeric precision.");
+  if (Math.floor(hi / step) - Math.ceil(lo / step) + 1 > 100) {
+    const magnitude = 10 ** Math.floor(Math.log10(step));
+    const factor = step / magnitude;
+    step = magnitude * (factor < 1.5 ? 2 : factor < 3 ? 5 : 10);
+  }
+  return { lo, hi, step };
+}
+function clean(value) {
+  return Number(value.toPrecision(15)) || 0;
+}
+function linearTicks(domain, options = {}) {
+  const { lo, hi, step } = parameters(domain, options);
+  const start = Math.ceil(lo / step), end = Math.floor(hi / step);
+  const values = Array.from({ length: Math.max(0, end - start + 1) }, (_, i) => clean((start + i) * step)).filter((v) => v >= lo && v <= hi);
+  return Object.freeze(domain[0] > domain[1] ? values.reverse() : values);
+}
+function niceLinearDomain(domain, options = {}) {
+  const { lo, hi, step } = parameters(domain, options);
+  const a = clean(Math.floor(lo / step) * step), b = clean(Math.ceil(hi / step) * step);
+  if (!Number.isFinite(a) || !Number.isFinite(b)) throw new RangeError("Nice linear domain exceeds finite numeric bounds.");
+  return Object.freeze(domain[0] > domain[1] ? [b, a] : [a, b]);
+}
+function formatNumber(value, options = {}) {
+  if (!Number.isFinite(value)) throw new RangeError("formatNumber value must be finite.");
+  const { locale = "en-US", prefix = "", suffix = "", ...intl } = options;
+  const formatter = new Intl.NumberFormat(locale, intl);
+  const parts = formatter.formatToParts(value);
+  const zeroDigit = Array.from(formatter.formatToParts(0).find((p) => p.type === "integer").value).at(-1);
+  const digits = parts.filter((p) => p.type === "integer" || p.type === "fraction");
+  const zero = digits.length > 0 && digits.every((p) => Array.from(p.value).every((digit) => digit === zeroDigit));
+  return prefix + formatter.format(zero ? 0 : value) + suffix;
+}
+export {
+  formatNumber,
+  linearTicks,
+  niceLinearDomain
+};
+//# sourceMappingURL=numeric-ticks.js.map

package/dist/features/viz/lib/numeric-ticks.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/viz/lib/numeric-ticks.ts"],
+  "sourcesContent": ["import type { NumericDomain } from \"./types.js\";\n\n/** Readable linear tick density. See {@link linearTicks}. */\nexport interface LinearTickOptions {\n  /** Target number of intervals, from 2 to 100; defaults to 5. */\n  readonly count?: number;\n}\nfunction parameters(domain: NumericDomain, options: LinearTickOptions) {\n  const count = options.count ?? 5;\n  if (!Number.isInteger(count) || count < 2 || count > 100)\n    throw new RangeError(\"Linear tick count must be an integer from 2 to 100.\");\n  if (!Array.isArray(domain) || domain.length !== 2 || !domain.every(Number.isFinite))\n    throw new RangeError(\"Linear tick domain requires two finite endpoints.\");\n  const lo = Math.min(...domain), hi = Math.max(...domain);\n  const span = hi - lo;\n  if (!Number.isFinite(span) || span === 0)\n    throw new RangeError(\"Linear tick domain must have a finite nonzero span.\");\n  const raw = span / count;\n  const power = 10 ** Math.floor(Math.log10(raw));\n  const error = raw / power;\n  let step = power * (error >= Math.sqrt(50) ? 10 : error >= Math.sqrt(10) ? 5 : error >= Math.sqrt(2) ? 2 : 1);\n  if (!Number.isFinite(step) || step === 0 || !Number.isSafeInteger(Math.floor(lo / step)) || !Number.isSafeInteger(Math.ceil(hi / step)))\n    throw new RangeError(\"Linear tick spacing exceeds numeric precision.\");\n  if (Math.floor(hi / step) - Math.ceil(lo / step) + 1 > 100) {\n    const magnitude = 10 ** Math.floor(Math.log10(step));\n    const factor = step / magnitude;\n    step = magnitude * (factor < 1.5 ? 2 : factor < 3 ? 5 : 10);\n  }\n  return { lo, hi, step };\n}\nfunction clean(value: number) { return Number(value.toPrecision(15)) || 0; }\n/**\n * Generates bounded ticks at readable 1, 2, or 5 \u00D7 powers-of-ten intervals.\n * Endpoints are included only when aligned. Does not change scale geometry.\n * @param domain - Distinct finite endpoints, ascending or descending.\n * @param options - Target density; defaults to five intervals.\n * @returns Frozen ticks in domain order. See {@link niceLinearDomain}.\n */\nexport function linearTicks(domain: NumericDomain, options: LinearTickOptions = {}): readonly number[] {\n  const { lo, hi, step } = parameters(domain, options);\n  const start = Math.ceil(lo / step), end = Math.floor(hi / step);\n  const values = Array.from({ length: Math.max(0, end - start + 1) }, (_, i) => clean((start + i) * step)).filter(v => v >= lo && v <= hi);\n  return Object.freeze(domain[0] > domain[1] ? values.reverse() : values);\n}\n/**\n * Expands a linear domain to readable tick boundaries, preserving direction.\n * @param domain - Distinct finite numeric endpoints; never mutated.\n * @param options - Target density; defaults to five intervals.\n * @returns Frozen expanded endpoints. See {@link linearTicks}.\n */\nexport function niceLinearDomain(domain: NumericDomain, options: LinearTickOptions = {}): NumericDomain {\n  const { lo, hi, step } = parameters(domain, options);\n  const a = clean(Math.floor(lo / step) * step), b = clean(Math.ceil(hi / step) * step);\n  if (!Number.isFinite(a) || !Number.isFinite(b)) throw new RangeError(\"Nice linear domain exceeds finite numeric bounds.\");\n  return Object.freeze(domain[0] > domain[1] ? [b, a] : [a, b]);\n}\n/** Number formatting with explicit locale and literal unit affixes. See {@link formatNumber}. */\nexport interface NumberFormatOptions extends Intl.NumberFormatOptions {\n  /** Locale for formatting; defaults to en-US. */\n  readonly locale?: string;\n  /** Literal prefix; defaults to empty. */\n  readonly prefix?: string;\n  /** Literal suffix, including any desired space; defaults to empty. */\n  readonly suffix?: string;\n}\n/**\n * Formats a finite number with Intl precision, currency, percent, or unit options.\n * Rounded negative zero is displayed as positive zero.\n * @param value - Finite numeric value.\n * @param options - Intl options plus locale and literal affixes; default maximum fraction digits is 3.\n * @returns Formatted text. Invalid Intl options retain native errors. See {@link NumberFormatOptions}.\n */\nexport function formatNumber(value: number, options: NumberFormatOptions = {}): string {\n  if (!Number.isFinite(value)) throw new RangeError(\"formatNumber value must be finite.\");\n  const { locale = \"en-US\", prefix = \"\", suffix = \"\", ...intl } = options;\n  const formatter = new Intl.NumberFormat(locale, intl);\n  const parts = formatter.formatToParts(value);\n  const zeroDigit = Array.from(formatter.formatToParts(0).find(p => p.type === \"integer\")!.value).at(-1)!;\n  const digits = parts.filter(p => p.type === \"integer\" || p.type === \"fraction\");\n  const zero = digits.length > 0 && digits.every(p => Array.from(p.value).every(digit => digit === zeroDigit));\n  return prefix + formatter.format(zero ? 0 : value) + suffix;\n}\n"],
+  "mappings": "AAOA,SAAS,WAAW,QAAuB,SAA4B;AACrE,QAAM,QAAQ,QAAQ,SAAS;AAC/B,MAAI,CAAC,OAAO,UAAU,KAAK,KAAK,QAAQ,KAAK,QAAQ;AACnD,UAAM,IAAI,WAAW,qDAAqD;AAC5E,MAAI,CAAC,MAAM,QAAQ,MAAM,KAAK,OAAO,WAAW,KAAK,CAAC,OAAO,MAAM,OAAO,QAAQ;AAChF,UAAM,IAAI,WAAW,mDAAmD;AAC1E,QAAM,KAAK,KAAK,IAAI,GAAG,MAAM,GAAG,KAAK,KAAK,IAAI,GAAG,MAAM;AACvD,QAAM,OAAO,KAAK;AAClB,MAAI,CAAC,OAAO,SAAS,IAAI,KAAK,SAAS;AACrC,UAAM,IAAI,WAAW,qDAAqD;AAC5E,QAAM,MAAM,OAAO;AACnB,QAAM,QAAQ,MAAM,KAAK,MAAM,KAAK,MAAM,GAAG,CAAC;AAC9C,QAAM,QAAQ,MAAM;AACpB,MAAI,OAAO,SAAS,SAAS,KAAK,KAAK,EAAE,IAAI,KAAK,SAAS,KAAK,KAAK,EAAE,IAAI,IAAI,SAAS,KAAK,KAAK,CAAC,IAAI,IAAI;AAC3G,MAAI,CAAC,OAAO,SAAS,IAAI,KAAK,SAAS,KAAK,CAAC,OAAO,cAAc,KAAK,MAAM,KAAK,IAAI,CAAC,KAAK,CAAC,OAAO,cAAc,KAAK,KAAK,KAAK,IAAI,CAAC;AACpI,UAAM,IAAI,WAAW,gDAAgD;AACvE,MAAI,KAAK,MAAM,KAAK,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,IAAI,IAAI,KAAK;AAC1D,UAAM,YAAY,MAAM,KAAK,MAAM,KAAK,MAAM,IAAI,CAAC;AACnD,UAAM,SAAS,OAAO;AACtB,WAAO,aAAa,SAAS,MAAM,IAAI,SAAS,IAAI,IAAI;AAAA,EAC1D;AACA,SAAO,EAAE,IAAI,IAAI,KAAK;AACxB;AACA,SAAS,MAAM,OAAe;AAAE,SAAO,OAAO,MAAM,YAAY,EAAE,CAAC,KAAK;AAAG;AAQpE,SAAS,YAAY,QAAuB,UAA6B,CAAC,GAAsB;AACrG,QAAM,EAAE,IAAI,IAAI,KAAK,IAAI,WAAW,QAAQ,OAAO;AACnD,QAAM,QAAQ,KAAK,KAAK,KAAK,IAAI,GAAG,MAAM,KAAK,MAAM,KAAK,IAAI;AAC9D,QAAM,SAAS,MAAM,KAAK,EAAE,QAAQ,KAAK,IAAI,GAAG,MAAM,QAAQ,CAAC,EAAE,GAAG,CAAC,GAAG,MAAM,OAAO,QAAQ,KAAK,IAAI,CAAC,EAAE,OAAO,OAAK,KAAK,MAAM,KAAK,EAAE;AACvI,SAAO,OAAO,OAAO,OAAO,CAAC,IAAI,OAAO,CAAC,IAAI,OAAO,QAAQ,IAAI,MAAM;AACxE;AAOO,SAAS,iBAAiB,QAAuB,UAA6B,CAAC,GAAkB;AACtG,QAAM,EAAE,IAAI,IAAI,KAAK,IAAI,WAAW,QAAQ,OAAO;AACnD,QAAM,IAAI,MAAM,KAAK,MAAM,KAAK,IAAI,IAAI,IAAI,GAAG,IAAI,MAAM,KAAK,KAAK,KAAK,IAAI,IAAI,IAAI;AACpF,MAAI,CAAC,OAAO,SAAS,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,EAAG,OAAM,IAAI,WAAW,mDAAmD;AACxH,SAAO,OAAO,OAAO,OAAO,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAC9D;AAiBO,SAAS,aAAa,OAAe,UAA+B,CAAC,GAAW;AACrF,MAAI,CAAC,OAAO,SAAS,KAAK,EAAG,OAAM,IAAI,WAAW,oCAAoC;AACtF,QAAM,EAAE,SAAS,SAAS,SAAS,IAAI,SAAS,IAAI,GAAG,KAAK,IAAI;AAChE,QAAM,YAAY,IAAI,KAAK,aAAa,QAAQ,IAAI;AACpD,QAAM,QAAQ,UAAU,cAAc,KAAK;AAC3C,QAAM,YAAY,MAAM,KAAK,UAAU,cAAc,CAAC,EAAE,KAAK,OAAK,EAAE,SAAS,SAAS,EAAG,KAAK,EAAE,GAAG,EAAE;AACrG,QAAM,SAAS,MAAM,OAAO,OAAK,EAAE,SAAS,aAAa,EAAE,SAAS,UAAU;AAC9E,QAAM,OAAO,OAAO,SAAS,KAAK,OAAO,MAAM,OAAK,MAAM,KAAK,EAAE,KAAK,EAAE,MAAM,WAAS,UAAU,SAAS,CAAC;AAC3G,SAAO,SAAS,UAAU,OAAO,OAAO,IAAI,KAAK,IAAI;AACvD;",
+  "names": []
+}

package/dist/features/viz/lib/ohlc-bar-series.d.ts

@@ -0,0 +1,55 @@
+import { type PibblEventHandlers, type PibblEventParticipationOptions, type PibblNode, type SignalValue, type StrokeStyle } from "@pibbl/core";
+import type { OhlcBarInspectionRef } from "../inspection/ohlc-bar.js";
+import type { LineAccessor, ScaleId } from "./types.js";
+/** Shared stroke presentation for an OHLC bar.
+ * @see {@link OhlcBarSeries}
+ */
+export interface OhlcBarSeriesStyle {
+    /** Positive total width, or automatic 70% spacing capped at 12; singleton fallback 8. */ readonly bandwidth?: number | "auto";
+    /** Stem and tick stroke; defaults to dark teal. Empty string disables painting. */ readonly stroke?: StrokeStyle;
+    /** Nonnegative local stroke width; default 1. */ readonly strokeWidth?: number;
+    /** Paint opacity from zero through one; default 1. */ readonly opacity?: number;
+    /** Cursor while the series owns targeting. */ readonly cursor?: string;
+}
+/** Source-ordered OHLC records rendered as a high/low stem with open/close ticks.
+ * @see {@link OhlcBarSeries}
+ */
+export interface OhlcBarSeriesProps<D> extends PibblEventHandlers, PibblEventParticipationOptions {
+    /** Original records or signal; never sorted or mutated. */
+    readonly data: SignalValue<readonly D[]>;
+    /** UTC-millisecond property or callback. */
+    readonly time: LineAccessor<D>;
+    /** Opening price property or callback. */
+    readonly open: LineAccessor<D>;
+    /** High price property or callback. */
+    readonly high: LineAccessor<D>;
+    /** Low price property or callback. */
+    readonly low: LineAccessor<D>;
+    /** Closing price property or callback. */
+    readonly close: LineAccessor<D>;
+    /** Numeric, UTC, or trading-time horizontal mapping identity. */
+    readonly xScale: ScaleId;
+    /** Continuous price mapping identity. */
+    readonly yScale: ScaleId;
+    /** Tests original rows before accessor evaluation.
+     * @param datum - Original row.
+     * @param index - Source index including skipped rows.
+     * @param data - Complete source array.
+     * @returns Whether the bar participates.
+     */
+    readonly defined?: (datum: D, index: number, data: readonly D[]) => boolean;
+    /** Shared presentation or a hook-free original-row resolver.
+     * @param datum - Original row.
+     * @param index - Source index.
+     * @param data - Complete source array.
+     * @returns Plain OHLC-bar style.
+     */
+    readonly style?: SignalValue<OhlcBarSeriesStyle> | ((datum: D, index: number, data: readonly D[]) => OhlcBarSeriesStyle);
+    /** Optional committed capture; the renderer does not execute inspection queries. */ readonly inspection?: OhlcBarInspectionRef<D>;
+}
+/** Paints source-ordered OHLC bars with a high/low stem, left open tick, and right close tick.
+ * @param props - Original OHLC accessors, scales, styles, events, and optional capture.
+ * @returns Ordinary Pibbl composition; equal disjoint styles share paths.
+ * @see {@link OhlcBarSeriesProps}
+ */
+export declare function OhlcBarSeries<D>({ data: input, time: timeInput, open: openInput, high: highInput, low: lowInput, close: closeInput, xScale, yScale, defined, style: styleInput, inspection, pointerEvents, ...events }: OhlcBarSeriesProps<D>): PibblNode;