@pibbl/core 0.0.2 → 0.0.3-alpha.90.1

package/dist/features/viz/inspection/queries.js

@@ -0,0 +1,192 @@
+function finite(value, name) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    throw new RangeError(`${name} must be finite.`);
+}
+function limit(value, name) {
+  if (value === void 0) return;
+  finite(value, name);
+  if (value < 0) throw new RangeError(`${name} must be nonnegative.`);
+}
+function point(value, name) {
+  finite(value.x, `${name}.x`);
+  finite(value.y, `${name}.y`);
+}
+function candidate(rendered, observation) {
+  return Object.freeze({
+    ...observation,
+    anchorInsideClips: () => rendered.anchorInsideClips(observation.anchorLocal)
+  });
+}
+function accepts(rendered, observation, filter) {
+  return filter === void 0 || filter(candidate(rendered, observation));
+}
+function anchored(rendered, observation) {
+  return { ...observation, ...rendered.anchorAtDomain(observation) };
+}
+function firstSourceObservation(first, _next) {
+  return first;
+}
+function lastSourceObservation(_first, next) {
+  return next;
+}
+function anchorInsideClips(candidate2) {
+  return candidate2.anchorInsideClips();
+}
+function nearestRecordedX(rendered, options) {
+  rendered.assertLive();
+  const query = options.domainX;
+  if (query === void 0) return void 0;
+  finite(query, "nearestRecordedX domainX");
+  limit(options.maxDomainDelta, "nearestRecordedX maxDomainDelta");
+  let best;
+  let delta = Infinity;
+  for (const observation of rendered.observations) {
+    if (!accepts(rendered, observation, options.filter)) continue;
+    const next = Math.abs(observation.domainX - query);
+    finite(next, "nearestRecordedX domain delta");
+    if (next < delta && (options.maxDomainDelta === void 0 || next <= options.maxDomainDelta)) {
+      delta = next;
+      best = Object.freeze({
+        ...anchored(rendered, observation),
+        domainDelta: next
+      });
+    }
+  }
+  return best;
+}
+function nearestRecordedPoint(rendered, options) {
+  rendered.assertLive();
+  const query = options.rootPoint;
+  if (query === void 0) return void 0;
+  point(query, "nearestRecordedPoint rootPoint");
+  limit(options.maxRootDistance, "nearestRecordedPoint maxRootDistance");
+  let best;
+  let distance = Infinity;
+  for (const observation of rendered.observations) {
+    if (!accepts(rendered, observation, options.filter)) continue;
+    const next = Math.hypot(
+      observation.anchorRoot.x - query.x,
+      observation.anchorRoot.y - query.y
+    );
+    finite(next, "nearestRecordedPoint root distance");
+    if (next < distance && (options.maxRootDistance === void 0 || next <= options.maxRootDistance)) {
+      distance = next;
+      best = Object.freeze({
+        ...anchored(rendered, observation),
+        rootDistance: next
+      });
+    }
+  }
+  return best;
+}
+function resolvedRows(rendered, filter, resolver) {
+  let validatedRun;
+  let validatedX = -Infinity;
+  for (const observation of rendered.observations) {
+    finite(observation.domainX, "sampleRecordedX observation.domainX");
+    finite(observation.domainY, "sampleRecordedX observation.domainY");
+    if (validatedRun === observation.run && observation.domainX < validatedX)
+      throw new RangeError(
+        "sampleRecordedX requires nondecreasing domainX within each rendered run."
+      );
+    validatedRun = observation.run;
+    validatedX = observation.domainX;
+  }
+  const runs = [];
+  let current = [];
+  let previousRun;
+  const finish = () => {
+    if (current.length) runs.push(current);
+    current = [];
+    previousRun = void 0;
+  };
+  for (const observation of rendered.observations) {
+    if (previousRun !== void 0 && observation.run !== previousRun) finish();
+    previousRun = observation.run;
+    if (!accepts(rendered, observation, filter)) {
+      finish();
+      continue;
+    }
+    current.push(observation);
+  }
+  finish();
+  return runs.map((run) => {
+    const resolved = [];
+    for (let start = 0; start < run.length; ) {
+      let end = start + 1;
+      while (end < run.length && run[end].domainX === run[start].domainX)
+        end++;
+      let selected = run[start];
+      for (let duplicate = start + 1; duplicate < end; duplicate++) {
+        const next = run[duplicate];
+        if (resolver === void 0)
+          throw new RangeError(
+            "sampleRecordedX duplicate domainX requires resolveDuplicate."
+          );
+        const resolved2 = resolver(selected, next);
+        if (resolved2 !== selected && resolved2 !== next)
+          throw new TypeError(
+            "sampleRecordedX resolveDuplicate must return its first or next observation."
+          );
+        selected = resolved2;
+      }
+      resolved.push(selected);
+      start = end;
+    }
+    return resolved;
+  });
+}
+function sampleRecordedX(rendered, options) {
+  rendered.assertLive();
+  const query = options.domainX;
+  if (query === void 0) return void 0;
+  finite(query, "sampleRecordedX domainX");
+  limit(options.maxDomainGap, "sampleRecordedX maxDomainGap");
+  if (typeof options.interpolation !== "function")
+    throw new TypeError("sampleRecordedX interpolation must be a function.");
+  if (options.resolveDuplicate !== void 0 && typeof options.resolveDuplicate !== "function")
+    throw new TypeError("sampleRecordedX resolveDuplicate must be a function.");
+  for (const run of resolvedRows(
+    rendered,
+    options.filter,
+    options.resolveDuplicate
+  )) {
+    for (let index = 0; index < run.length; index++) {
+      const before = run[index];
+      if (before.domainX === query)
+        return Object.freeze({ ...anchored(rendered, before), kind: "exact" });
+      const after = run[index + 1];
+      if (!after || query <= before.domainX || query >= after.domainX) continue;
+      const gap = after.domainX - before.domainX;
+      finite(gap, "sampleRecordedX domain gap");
+      if (options.maxDomainGap !== void 0 && gap > options.maxDomainGap)
+        return void 0;
+      const fraction = (query - before.domainX) / gap;
+      const domainY = options.interpolation(
+        before.domainY,
+        after.domainY,
+        fraction
+      );
+      finite(domainY, "sampleRecordedX interpolation result");
+      return Object.freeze({
+        kind: "interpolated",
+        domainX: query,
+        domainY,
+        ...rendered.anchorAtDomain({ domainX: query, domainY }),
+        before,
+        after,
+        fraction
+      });
+    }
+  }
+  return void 0;
+}
+export {
+  anchorInsideClips,
+  firstSourceObservation,
+  lastSourceObservation,
+  nearestRecordedPoint,
+  nearestRecordedX,
+  sampleRecordedX
+};
+//# sourceMappingURL=queries.js.map

package/dist/features/viz/inspection/queries.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/viz/inspection/queries.ts"],
+  "sourcesContent": ["import type {\n  NearestRecordedPointHit,\n  NearestRecordedXHit,\n  NumericDomainInterpolation,\n  NumericDuplicateResolver,\n  InspectionCandidate,\n  NumericRenderedFilter,\n  NumericRenderedObservation,\n  NumericRenderedSeries,\n  RecordedXSample,\n  RenderedSeriesPoint,\n} from \"./query-types.js\";\n\nfunction finite(value: unknown, name: string): asserts value is number {\n  if (typeof value !== \"number\" || !Number.isFinite(value))\n    throw new RangeError(`${name} must be finite.`);\n}\n\nfunction limit(value: number | undefined, name: string): void {\n  if (value === undefined) return;\n  finite(value, name);\n  if (value < 0) throw new RangeError(`${name} must be nonnegative.`);\n}\n\nfunction point(value: Readonly<RenderedSeriesPoint>, name: string): void {\n  finite(value.x, `${name}.x`);\n  finite(value.y, `${name}.y`);\n}\n\nfunction candidate<D>(\n  rendered: NumericRenderedSeries<D>,\n  observation: NumericRenderedObservation<D>,\n): InspectionCandidate<D> {\n  return Object.freeze({\n    ...observation,\n    anchorInsideClips: () =>\n      rendered.anchorInsideClips(observation.anchorLocal),\n  });\n}\n\nfunction accepts<D>(\n  rendered: NumericRenderedSeries<D>,\n  observation: NumericRenderedObservation<D>,\n  filter: NumericRenderedFilter<D> | undefined,\n): boolean {\n  return filter === undefined || filter(candidate(rendered, observation));\n}\n\nfunction anchored<D>(\n  rendered: NumericRenderedSeries<D>,\n  observation: NumericRenderedObservation<D>,\n): NumericRenderedObservation<D> {\n  return { ...observation, ...rendered.anchorAtDomain(observation) };\n}\n\n/**\n * Retains the first source observation at a duplicate domain coordinate.\n *\n * @param first - First selected observation at this domain coordinate.\n * @param _next - Later observation at the same domain coordinate.\n * @returns The earliest source observation.\n * @see {@link NumericDuplicateResolver}\n */\nexport function firstSourceObservation<D>(\n  first: NumericRenderedObservation<D>,\n  _next: NumericRenderedObservation<D>,\n): NumericRenderedObservation<D> {\n  return first;\n}\n\n/**\n * Replaces a source observation with the next one at a duplicate domain coordinate.\n *\n * @param _first - Earlier selected observation at this domain coordinate.\n * @param next - Later observation at the same domain coordinate.\n * @returns The latest source observation.\n * @see {@link NumericDuplicateResolver}\n */\nexport function lastSourceObservation<D>(\n  _first: NumericRenderedObservation<D>,\n  next: NumericRenderedObservation<D>,\n): NumericRenderedObservation<D> {\n  return next;\n}\n\n/**\n * Returns whether a filter candidate's anchor lies inside the committed clip stack.\n *\n * Pass this function as a query filter when visibility at the anchor is required.\n * Queries otherwise examine all eligible rendered observations.\n *\n * @param candidate - Candidate whose committed local anchor should be clip-tested.\n * @returns Whether the candidate anchor lies within every committed clip.\n * @see {@link NumericRenderedFilter}\n */\nexport function anchorInsideClips<D>(\n  candidate: InspectionCandidate<D>,\n): boolean {\n  return candidate.anchorInsideClips();\n}\n\n/** Options for {@link nearestRecordedX}. */\nexport interface NearestRecordedXOptions<D> {\n  /** Numeric horizontal domain value to inspect, or undefined for no request. */\n  readonly domainX: number | undefined;\n  /** Maximum accepted absolute horizontal-domain delta. */\n  readonly maxDomainDelta?: number;\n  /** Further restricts committed observations for this request. */\n  readonly filter?: NumericRenderedFilter<D>;\n}\n\n/**\n * Finds the recorded observation nearest to a numeric horizontal domain value in O(n) time.\n *\n * Ties retain source order. Distance is measured in domain units, while both\n * returned anchors retain their explicitly named local and root-logical units.\n *\n * @param rendered - Committed rendered-series generation to inspect synchronously.\n * @param options - Domain position, optional limit, and observation filter.\n * @returns The selected recorded observation, or undefined when none qualifies.\n * @see {@link NearestRecordedXOptions}\n */\nexport function nearestRecordedX<D>(\n  rendered: NumericRenderedSeries<D>,\n  options: NearestRecordedXOptions<D>,\n): NearestRecordedXHit<D> | undefined {\n  rendered.assertLive();\n  const query = options.domainX;\n  if (query === undefined) return undefined;\n  finite(query, \"nearestRecordedX domainX\");\n  limit(options.maxDomainDelta, \"nearestRecordedX maxDomainDelta\");\n  let best: NearestRecordedXHit<D> | undefined;\n  let delta = Infinity;\n  for (const observation of rendered.observations) {\n    if (!accepts(rendered, observation, options.filter)) continue;\n    const next = Math.abs(observation.domainX - query);\n    finite(next, \"nearestRecordedX domain delta\");\n    if (\n      next < delta &&\n      (options.maxDomainDelta === undefined || next <= options.maxDomainDelta)\n    ) {\n      delta = next;\n      best = Object.freeze({\n        ...anchored(rendered, observation),\n        domainDelta: next,\n      });\n    }\n  }\n  return best;\n}\n\n/** Options for {@link nearestRecordedPoint}. */\nexport interface NearestRecordedPointOptions<D> {\n  /** Root-logical point to inspect, or undefined for no request. */\n  readonly rootPoint: Readonly<RenderedSeriesPoint> | undefined;\n  /** Maximum accepted Euclidean root-logical distance. */\n  readonly maxRootDistance?: number;\n  /** Further restricts committed observations for this request. */\n  readonly filter?: NumericRenderedFilter<D>;\n}\n\n/**\n * Finds the recorded observation nearest to a root-logical point in O(n) time.\n *\n * Ties retain source order. This query measures distance in root-logical units\n * so it remains meaningful under nonuniform series transforms.\n *\n * @param rendered - Committed rendered-series generation to inspect synchronously.\n * @param options - Root position, optional limit, and observation filter.\n * @returns The selected recorded observation, or undefined when none qualifies.\n * @see {@link NearestRecordedPointOptions}\n */\nexport function nearestRecordedPoint<D>(\n  rendered: NumericRenderedSeries<D>,\n  options: NearestRecordedPointOptions<D>,\n): NearestRecordedPointHit<D> | undefined {\n  rendered.assertLive();\n  const query = options.rootPoint;\n  if (query === undefined) return undefined;\n  point(query, \"nearestRecordedPoint rootPoint\");\n  limit(options.maxRootDistance, \"nearestRecordedPoint maxRootDistance\");\n  let best: NearestRecordedPointHit<D> | undefined;\n  let distance = Infinity;\n  for (const observation of rendered.observations) {\n    if (!accepts(rendered, observation, options.filter)) continue;\n    const next = Math.hypot(\n      observation.anchorRoot.x - query.x,\n      observation.anchorRoot.y - query.y,\n    );\n    finite(next, \"nearestRecordedPoint root distance\");\n    if (\n      next < distance &&\n      (options.maxRootDistance === undefined || next <= options.maxRootDistance)\n    ) {\n      distance = next;\n      best = Object.freeze({\n        ...anchored(rendered, observation),\n        rootDistance: next,\n      });\n    }\n  }\n  return best;\n}\n\n/** Options for {@link sampleRecordedX}. */\nexport interface SampleRecordedXOptions<D> {\n  /** Numeric horizontal domain value to sample, or undefined for no request. */\n  readonly domainX: number | undefined;\n  /** Computes the estimated numeric domain value between two recorded values. */\n  readonly interpolation: NumericDomainInterpolation;\n  /** Explicitly chooses one observation from each duplicate-domain group. */\n  readonly resolveDuplicate?: NumericDuplicateResolver<D>;\n  /** Maximum domain interval that may be interpolated across. */\n  readonly maxDomainGap?: number;\n  /** Further restricts committed observations for this request. */\n  readonly filter?: NumericRenderedFilter<D>;\n}\n\nfunction resolvedRows<D>(\n  rendered: NumericRenderedSeries<D>,\n  filter: NumericRenderedFilter<D> | undefined,\n  resolver: NumericDuplicateResolver<D> | undefined,\n): readonly (readonly NumericRenderedObservation<D>[])[] {\n  let validatedRun: number | undefined;\n  let validatedX = -Infinity;\n  for (const observation of rendered.observations) {\n    finite(observation.domainX, \"sampleRecordedX observation.domainX\");\n    finite(observation.domainY, \"sampleRecordedX observation.domainY\");\n    if (validatedRun === observation.run && observation.domainX < validatedX)\n      throw new RangeError(\n        \"sampleRecordedX requires nondecreasing domainX within each rendered run.\",\n      );\n    validatedRun = observation.run;\n    validatedX = observation.domainX;\n  }\n  const runs: NumericRenderedObservation<D>[][] = [];\n  let current: NumericRenderedObservation<D>[] = [];\n  let previousRun: number | undefined;\n  const finish = () => {\n    if (current.length) runs.push(current);\n    current = [];\n    previousRun = undefined;\n  };\n  for (const observation of rendered.observations) {\n    if (previousRun !== undefined && observation.run !== previousRun) finish();\n    previousRun = observation.run;\n    if (!accepts(rendered, observation, filter)) {\n      finish();\n      continue;\n    }\n    current.push(observation);\n  }\n  finish();\n  return runs.map((run) => {\n    const resolved: NumericRenderedObservation<D>[] = [];\n    for (let start = 0; start < run.length;) {\n      let end = start + 1;\n      while (end < run.length && run[end]!.domainX === run[start]!.domainX)\n        end++;\n      let selected = run[start]!;\n      for (let duplicate = start + 1; duplicate < end; duplicate++) {\n        const next = run[duplicate]!;\n        if (resolver === undefined)\n          throw new RangeError(\n            \"sampleRecordedX duplicate domainX requires resolveDuplicate.\",\n          );\n        const resolved = resolver(selected, next);\n        if (resolved !== selected && resolved !== next)\n          throw new TypeError(\n            \"sampleRecordedX resolveDuplicate must return its first or next observation.\",\n          );\n        selected = resolved;\n      }\n      resolved.push(selected);\n      start = end;\n    }\n    return resolved;\n  });\n}\n\n/**\n * Returns an exact recorded observation or a caller-defined interpolation between records.\n *\n * It never bridges separate rendered runs, filtered observations, or an interval larger\n * than `maxDomainGap`. Duplicate x values reject by default and require an explicit\n * `resolveDuplicate` function. Estimated results retain their two source observations and\n * map explicit local/root anchors through the committed generation. This is O(n) in captured\n * observations and the result is borrowed until the rendered generation is replaced or disposed.\n *\n * @param rendered - Committed rendered-series generation to inspect synchronously.\n * @param options - Domain position, interpolation, duplicate policy, and filter.\n * @returns An exact record, an explicitly interpolated estimate, or undefined.\n * @see {@link SampleRecordedXOptions}\n */\nexport function sampleRecordedX<D>(\n  rendered: NumericRenderedSeries<D>,\n  options: SampleRecordedXOptions<D>,\n): RecordedXSample<D> | undefined {\n  rendered.assertLive();\n  const query = options.domainX;\n  if (query === undefined) return undefined;\n  finite(query, \"sampleRecordedX domainX\");\n  limit(options.maxDomainGap, \"sampleRecordedX maxDomainGap\");\n  if (typeof options.interpolation !== \"function\")\n    throw new TypeError(\"sampleRecordedX interpolation must be a function.\");\n  if (\n    options.resolveDuplicate !== undefined &&\n    typeof options.resolveDuplicate !== \"function\"\n  )\n    throw new TypeError(\"sampleRecordedX resolveDuplicate must be a function.\");\n  for (const run of resolvedRows(\n    rendered,\n    options.filter,\n    options.resolveDuplicate,\n  )) {\n    for (let index = 0; index < run.length; index++) {\n      const before = run[index]!;\n      if (before.domainX === query)\n        return Object.freeze({ ...anchored(rendered, before), kind: \"exact\" });\n      const after = run[index + 1];\n      if (!after || query <= before.domainX || query >= after.domainX) continue;\n      const gap = after.domainX - before.domainX;\n      finite(gap, \"sampleRecordedX domain gap\");\n      if (options.maxDomainGap !== undefined && gap > options.maxDomainGap)\n        return undefined;\n      const fraction = (query - before.domainX) / gap;\n      const domainY = options.interpolation(\n        before.domainY,\n        after.domainY,\n        fraction,\n      );\n      finite(domainY, \"sampleRecordedX interpolation result\");\n      return Object.freeze({\n        kind: \"interpolated\",\n        domainX: query,\n        domainY,\n        ...rendered.anchorAtDomain({ domainX: query, domainY }),\n        before,\n        after,\n        fraction,\n      });\n    }\n  }\n  return undefined;\n}\n"],
+  "mappings": "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",
+  "names": ["candidate", "resolved"]
+}

package/dist/features/viz/inspection/query-types.d.ts

@@ -0,0 +1,177 @@
+/**
+ * A point in a named logical coordinate system.
+ *
+ * @see {@link NumericRenderedObservation}
+ */
+export interface RenderedSeriesPoint {
+    /** Horizontal logical coordinate. */
+    readonly x: number;
+    /** Vertical logical coordinate. */
+    readonly y: number;
+}
+/**
+ * One numeric observation evaluated for a committed rendered-series generation.
+ *
+ * `anchorLocal` belongs to the series' local logical coordinate system and
+ * `anchorRoot` belongs to the root-logical coordinate system used by Pibbl
+ * events. `run` separates observations that the rendered mark does not join.
+ *
+ * @see {@link NumericRenderedSeries}
+ */
+export interface NumericRenderedObservation<D> {
+    /** Caller-owned original record. */
+    readonly datum: D;
+    /** Original zero-based index in the caller's source array. */
+    readonly sourceIndex: number;
+    /** Evaluated horizontal value in the series' numeric domain. */
+    readonly domainX: number;
+    /** Evaluated vertical value in the series' numeric domain. */
+    readonly domainY: number;
+    /** The observation anchor in series-local logical coordinates. */
+    readonly anchorLocal: Readonly<RenderedSeriesPoint>;
+    /** The observation anchor in root-logical coordinates. */
+    readonly anchorRoot: Readonly<RenderedSeriesPoint>;
+    /** Identifier of the contiguous rendered run containing this observation. */
+    readonly run: number;
+}
+/**
+ * The two logical anchors of a numeric domain position.
+ *
+ * @see {@link NumericRenderedSeries}
+ */
+export interface NumericRenderedAnchors {
+    /** Anchor in the series-local logical coordinate system. */
+    readonly anchorLocal: Readonly<RenderedSeriesPoint>;
+    /** Anchor in the root-logical coordinate system. */
+    readonly anchorRoot: Readonly<RenderedSeriesPoint>;
+}
+/**
+ * A committed numeric rendering available for synchronous inspection.
+ *
+ * Instances are supplied by the matching inspection ref; applications do not
+ * create them. They are valid only for the synchronous inspection context that
+ * supplied them. `assertLive` throws after that context, after a replacement
+ * generation, or after disposal.
+ *
+ * @see {@link NumericRenderedObservation}
+ */
+export interface NumericRenderedSeries<D> {
+    /** Evaluated observations in source order for this committed generation. */
+    readonly observations: readonly NumericRenderedObservation<D>[];
+    /** Asserts that this generation can still be inspected synchronously. */
+    assertLive(): void;
+    /**
+     * Converts a root-logical point to a numeric horizontal domain value, or
+     * reports that the committed transform cannot invert that point.
+     * @param point - Root-logical position to invert.
+     * @returns The numeric horizontal domain value, or undefined when unavailable.
+     */
+    domainXAtRoot(point: Readonly<RenderedSeriesPoint>): number | undefined;
+    /**
+     * Maps numeric domain values to the committed local and root-logical anchors.
+     * @param point - Numeric domain values to map.
+     * @param point.domainX - Horizontal numeric domain value.
+     * @param point.domainY - Vertical numeric domain value.
+     * @returns Both committed logical anchors for the requested domain point.
+     */
+    anchorAtDomain(point: Readonly<{
+        /** Horizontal numeric domain value. */
+        domainX: number;
+        /** Vertical numeric domain value. */
+        domainY: number;
+    }>): NumericRenderedAnchors;
+    /**
+     * Returns whether a local point lies within the committed clip stack.
+     * @param pointLocal - Series-local logical position to test.
+     * @returns Whether every committed clip contains the point.
+     */
+    anchorInsideClips(pointLocal: Readonly<RenderedSeriesPoint>): boolean;
+}
+/**
+ * An observation that can be explicitly filtered by committed clipping.
+ *
+ * @see {@link NumericRenderedFilter}
+ */
+export interface InspectionCandidate<D> extends NumericRenderedObservation<D> {
+    /** @returns Whether this observation's anchor lies within the committed clips. */
+    anchorInsideClips(): boolean;
+}
+/**
+ * Selects observations eligible for one inspection request.
+ *
+ * @param observation - Candidate containing the original observation and optional clip test.
+ * @returns Whether the candidate participates in this request.
+ * @see {@link InspectionCandidate}
+ */
+export type NumericRenderedFilter<D> = (observation: InspectionCandidate<D>) => boolean;
+/**
+ * A recorded observation selected by a numeric inspection query.
+ *
+ * @see {@link NumericRenderedObservation}
+ */
+export interface RecordedNumericHit<D> extends NumericRenderedObservation<D> {
+}
+/**
+ * A recorded observation selected by horizontal-domain proximity.
+ *
+ * @see {@link NearestRecordedXHit}
+ */
+export interface NearestRecordedXHit<D> extends RecordedNumericHit<D> {
+    /** Absolute difference from the requested horizontal domain value. */
+    readonly domainDelta: number;
+}
+/**
+ * A recorded observation selected by root-logical geometric proximity.
+ *
+ * @see {@link NearestRecordedPointHit}
+ */
+export interface NearestRecordedPointHit<D> extends RecordedNumericHit<D> {
+    /** Euclidean distance from the requested root-logical point. */
+    readonly rootDistance: number;
+}
+/**
+ * Chooses one source observation when several observations in one rendered run
+ * have the same horizontal domain value.
+ *
+ * @param first - Observation selected so far at this domain value.
+ * @param next - Later source observation at the same domain value.
+ * @returns Either `first` or `next`.
+ * @see {@link NumericRenderedObservation}
+ */
+export type NumericDuplicateResolver<D> = (first: NumericRenderedObservation<D>, next: NumericRenderedObservation<D>) => NumericRenderedObservation<D>;
+/**
+ * Computes a numeric vertical sample between two recorded domain values.
+ *
+ * @param beforeDomainY - Numeric vertical value before the sample.
+ * @param afterDomainY - Numeric vertical value after the sample.
+ * @param fraction - Distance from before to after, from zero through one.
+ * @returns The estimated numeric vertical domain value.
+ * @see {@link RecordedXSample}
+ */
+export type NumericDomainInterpolation = (beforeDomainY: number, afterDomainY: number, fraction: number) => number;
+/**
+ * An exact recorded sample or an explicit estimate between recorded observations.
+ *
+ * @see {@link NumericDomainInterpolation}
+ */
+export type RecordedXSample<D> = (RecordedNumericHit<D> & {
+    /** Identifies a value selected directly from one recorded observation. */
+    readonly kind: "exact";
+}) | Readonly<{
+    /** Identifies a value computed between two recorded observations. */
+    kind: "interpolated";
+    /** Requested horizontal numeric domain value. */
+    domainX: number;
+    /** Numeric domain value returned by the caller's interpolation function. */
+    domainY: number;
+    /** Interpolated anchor in committed series-local logical coordinates. */
+    anchorLocal: Readonly<RenderedSeriesPoint>;
+    /** Interpolated anchor in committed root-logical coordinates. */
+    anchorRoot: Readonly<RenderedSeriesPoint>;
+    /** Observation immediately before the sampled position in its rendered run. */
+    before: NumericRenderedObservation<D>;
+    /** Observation immediately after the sampled position in its rendered run. */
+    after: NumericRenderedObservation<D>;
+    /** Fraction of the interval from `before` through `after`. */
+    fraction: number;
+}>;

package/dist/features/viz/inspection/volume.d.ts

@@ -0,0 +1,104 @@
+import { type NumericPositionScale } from "../lib/series-position.js";
+import type { LayoutBox } from "@pibbl/core";
+import type { VolumeSeriesProps } from "../lib/volume-series.js";
+import type { ResolvedContinuousScale } from "../lib/types.js";
+import type { RenderedSeriesPoint, NumericRenderedSeries } from "./query-types.js";
+/** One original volume record and the values/geometry evaluated during paint.
+ * @see {@link useVolumeInspection}
+ */
+export interface VolumeObservation<D> {
+    /** Caller-owned original record. */ readonly datum: D;
+    /** Original index including skipped rows. */ readonly sourceIndex: number;
+    /** Evaluated UTC milliseconds. */ readonly time: number;
+    /** Evaluated nonnegative volume. */ readonly volume: number;
+    /** Zero-volume baseline. */ readonly baseline: 0;
+    /** Volume endpoint in series-local logical coordinates. */ readonly anchorLocal: Readonly<RenderedSeriesPoint>;
+    /** Volume endpoint in root-logical coordinates. */ readonly anchorRoot: Readonly<RenderedSeriesPoint>;
+    /** Column bounds in series-local logical coordinates. */ readonly boundsLocal: Readonly<LayoutBox>;
+}
+/** A nearest-time candidate with an explicit optional clip predicate.
+ * @see {@link useVolumeInspection}
+ */
+export interface VolumeInspectionCandidate<D> extends VolumeObservation<D> {
+    /** @returns Whether the endpoint lies inside every committed clip. */ anchorInsideClips(): boolean;
+}
+/** A recorded volume selected by timestamp proximity.
+ * @see {@link useVolumeInspection}
+ */
+export interface NearestVolumeHit<D> extends VolumeObservation<D> {
+    /** Absolute UTC-millisecond distance from the requested time. */ readonly timeDelta: number;
+}
+/** A recorded volume whose painted column covers the query point.
+ * @see {@link useVolumeInspection}
+ */
+export interface PaintedVolumeHit<D> extends VolumeObservation<D> {
+}
+/** @internal Immutable local renderer capture, without queries or transformed allocation.
+ * @see {@link useVolumeInspection}
+ */
+export interface CapturedVolumeMark<D> extends Omit<VolumeObservation<D>, "anchorRoot"> {
+    /** Whether the rectangle paints its interior. */ readonly fill: boolean;
+    /** Outline width when painted, zero otherwise. */ readonly strokeWidthLocal: number;
+}
+/** Borrowed committed volume values; expires after a new root generation or disposal.
+ * @see {@link useVolumeInspection}
+ */
+export interface VolumeRenderedSeries<D> {
+    /** Original observations and evaluated values in source order. */ readonly observations: readonly VolumeObservation<D>[];
+    /** Throws when borrowed values are stale or disposed. */ assertLive(): void;
+    /** Inverts a root-logical point to UTC milliseconds.
+     * @param pointRoot - Root-logical Canvas position.
+     * @returns Timestamp or undefined for unavailable inversion.
+     */ timeAtRoot(pointRoot: Readonly<RenderedSeriesPoint>): number | undefined;
+    /** Tests a local point against the committed clip stack.
+     * @param pointLocal - Series-local position.
+     * @returns Whether every clip includes it.
+     */ anchorInsideClips(pointLocal: Readonly<RenderedSeriesPoint>): boolean;
+    /** @internal Committed paint flags. */ readonly marks: readonly CapturedVolumeMark<D>[];
+    /** @internal Shared numeric query view. */ readonly numeric: NumericRenderedSeries<D>;
+    /** @internal Converts root coordinates to local coordinates.
+     * @param point - Root-logical position.
+     * @returns Local position or undefined for a singular transform.
+     */ localAtRoot(point: Readonly<RenderedSeriesPoint>): Readonly<RenderedSeriesPoint> | undefined;
+}
+/** Mount-owned optional volume capture.
+ * @see {@link useVolumeInspection}
+ */
+export interface VolumeInspectionRef<D> {
+    /** @returns Borrowed committed values, or undefined before paint/after disposal. */ rendered(): VolumeRenderedSeries<D> | undefined;
+    /** @internal Records local values without executing a query.
+     * @param input - Immutable local marks and committed time mapping.
+     */ capture(input: {
+        /** Captured local paint marks. */ marks: readonly CapturedVolumeMark<D>[];
+        /** Committed horizontal mapping. */ xScale: NumericPositionScale;
+        /** Committed volume mapping. */ yScale: ResolvedContinuousScale;
+    }): void;
+}
+/**
+ * Creates a stable optional volume receiver without reading data or subscribing.
+ * @param _inputs - Data/accessors used only for original datum inference.
+ * @returns Ref to pass to exactly one VolumeSeries inspection prop.
+ * @see {@link VolumeInspectionRef}
+ */
+export declare function useVolumeInspection<D>(_inputs: Pick<VolumeSeriesProps<D>, "data" | "time" | "volume">): VolumeInspectionRef<D>;
+/**
+ * Selects a recorded volume by timestamp; equal distances choose first source index.
+ * @param rendered - Borrowed committed volume values.
+ * @param options - UTC-millisecond request and optional pure candidate filter.
+ * @returns Captured original volume and time delta, or undefined when no candidate survives.
+ * @see {@link NearestVolumeHit}
+ */
+export declare function nearestRecordedVolumeX<D>(rendered: VolumeRenderedSeries<D>, options: {
+    time: number;
+    filter?: (observation: VolumeInspectionCandidate<D>) => boolean;
+}): NearestVolumeHit<D> | undefined;
+/**
+ * Finds the last-painted volume column covering a root-logical point.
+ * @param rendered - Borrowed committed volume values and paint geometry.
+ * @param options - Root-logical point; respects clips, zero height and source paint order.
+ * @returns Captured original volume, or undefined for gaps/singular transforms.
+ * @see {@link PaintedVolumeHit}
+ */
+export declare function paintedVolumeAt<D>(rendered: VolumeRenderedSeries<D>, options: {
+    rootPoint: Readonly<RenderedSeriesPoint>;
+}): PaintedVolumeHit<D> | undefined;

package/dist/features/viz/inspection/volume.js

@@ -0,0 +1,95 @@
+import {
+  invertNumericPosition
+} from "../lib/series-position.js";
+import { useRenderedRef } from "./owned-ref.js";
+import { nearestRecordedX } from "./queries.js";
+function useVolumeInspection(_inputs) {
+  return useRenderedRef("volumeInspection", (candidate, geometry) => {
+    const observations = Object.freeze(
+      candidate.marks.map(
+        (mark) => Object.freeze({
+          datum: mark.datum,
+          sourceIndex: mark.sourceIndex,
+          time: mark.time,
+          volume: mark.volume,
+          baseline: mark.baseline,
+          anchorLocal: mark.anchorLocal,
+          anchorRoot: geometry.rootAtLocal(mark.anchorLocal),
+          boundsLocal: mark.boundsLocal
+        })
+      )
+    );
+    const numeric = Object.freeze({
+      observations: Object.freeze(
+        observations.map(
+          (row) => Object.freeze({
+            ...row,
+            domainX: row.time,
+            domainY: row.volume,
+            run: 0
+          })
+        )
+      ),
+      assertLive: geometry.assertLive,
+      domainXAtRoot(point) {
+        const local = geometry.localAtRoot(point);
+        return local ? invertNumericPosition(candidate.xScale, local.x) : void 0;
+      },
+      anchorInsideClips: geometry.anchorInsideClips,
+      anchorAtDomain(point) {
+        geometry.assertLive();
+        const anchorLocal = Object.freeze({
+          x: candidate.xScale.map(point.domainX),
+          y: candidate.yScale.map(point.domainY)
+        });
+        return Object.freeze({
+          anchorLocal,
+          anchorRoot: geometry.rootAtLocal(anchorLocal)
+        });
+      }
+    });
+    return Object.freeze({
+      observations,
+      marks: Object.freeze(candidate.marks.slice()),
+      numeric,
+      assertLive: geometry.assertLive,
+      localAtRoot: geometry.localAtRoot,
+      anchorInsideClips: geometry.anchorInsideClips,
+      timeAtRoot: numeric.domainXAtRoot
+    });
+  });
+}
+function nearestRecordedVolumeX(rendered, options) {
+  const hit = nearestRecordedX(rendered.numeric, {
+    domainX: options.time,
+    filter: options.filter ? (candidate) => options.filter(
+      candidate
+    ) : void 0
+  });
+  if (!hit) return void 0;
+  const row = rendered.observations.find(
+    (row2) => row2.sourceIndex === hit.sourceIndex
+  );
+  return Object.freeze({ ...row, timeDelta: hit.domainDelta });
+}
+function paintedVolumeAt(rendered, options) {
+  rendered.assertLive();
+  if (!Number.isFinite(options.rootPoint.x) || !Number.isFinite(options.rootPoint.y))
+    throw new RangeError("paintedVolumeAt rootPoint must be finite.");
+  const p = rendered.localAtRoot(options.rootPoint);
+  if (!p || !rendered.anchorInsideClips(p)) return void 0;
+  for (let i = rendered.marks.length - 1; i >= 0; i--) {
+    const mark = rendered.marks[i], b = mark.boundsLocal, h = mark.strokeWidthLocal / 2;
+    if (b.height === 0) continue;
+    const inside = p.x >= b.x && p.x <= b.x + b.width && p.y >= b.y && p.y <= b.y + b.height;
+    const outline = h > 0 && p.x >= b.x - h && p.x <= b.x + b.width + h && p.y >= b.y - h && p.y <= b.y + b.height + h && !(p.x > b.x + h && p.x < b.x + b.width - h && p.y > b.y + h && p.y < b.y + b.height - h);
+    if (mark.fill && inside || outline) return rendered.observations[i];
+  }
+  return void 0;
+}
+export {
+  nearestRecordedVolumeX,
+  paintedVolumeAt,
+  useVolumeInspection
+};
+//# sourceMappingURL=volume.js.map

package/dist/features/viz/inspection/volume.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/viz/inspection/volume.ts"],
+  "sourcesContent": ["import {\n  invertNumericPosition,\n  type NumericPositionScale,\n} from \"../lib/series-position.js\";\nimport type { LayoutBox } from \"@pibbl/core\";\nimport type { VolumeSeriesProps } from \"../lib/volume-series.js\";\nimport type { ResolvedContinuousScale } from \"../lib/types.js\";\nimport type {\n  RenderedSeriesPoint,\n  NumericRenderedSeries,\n} from \"./query-types.js\";\nimport { useRenderedRef } from \"./owned-ref.js\";\nimport { nearestRecordedX } from \"./queries.js\";\n\n/** One original volume record and the values/geometry evaluated during paint.\n * @see {@link useVolumeInspection}\n */\nexport interface VolumeObservation<D> {\n  /** Caller-owned original record. */ readonly datum: D;\n  /** Original index including skipped rows. */ readonly sourceIndex: number;\n  /** Evaluated UTC milliseconds. */ readonly time: number;\n  /** Evaluated nonnegative volume. */ readonly volume: number;\n  /** Zero-volume baseline. */ readonly baseline: 0;\n  /** Volume endpoint in series-local logical coordinates. */ readonly anchorLocal: Readonly<RenderedSeriesPoint>;\n  /** Volume endpoint in root-logical coordinates. */ readonly anchorRoot: Readonly<RenderedSeriesPoint>;\n  /** Column bounds in series-local logical coordinates. */ readonly boundsLocal: Readonly<LayoutBox>;\n}\n/** A nearest-time candidate with an explicit optional clip predicate.\n * @see {@link useVolumeInspection}\n */\nexport interface VolumeInspectionCandidate<D> extends VolumeObservation<D> {\n  /** @returns Whether the endpoint lies inside every committed clip. */ anchorInsideClips(): boolean;\n}\n/** A recorded volume selected by timestamp proximity.\n * @see {@link useVolumeInspection}\n */\nexport interface NearestVolumeHit<D> extends VolumeObservation<D> {\n  /** Absolute UTC-millisecond distance from the requested time. */ readonly timeDelta: number;\n}\n/** A recorded volume whose painted column covers the query point.\n * @see {@link useVolumeInspection}\n */\nexport interface PaintedVolumeHit<D> extends VolumeObservation<D> {}\n/** @internal Immutable local renderer capture, without queries or transformed allocation.\n * @see {@link useVolumeInspection}\n */\nexport interface CapturedVolumeMark<D> extends Omit<\n  VolumeObservation<D>,\n  \"anchorRoot\"\n> {\n  /** Whether the rectangle paints its interior. */ readonly fill: boolean;\n  /** Outline width when painted, zero otherwise. */ readonly strokeWidthLocal: number;\n}\n/** Borrowed committed volume values; expires after a new root generation or disposal.\n * @see {@link useVolumeInspection}\n */\nexport interface VolumeRenderedSeries<D> {\n  /** Original observations and evaluated values in source order. */ readonly observations: readonly VolumeObservation<D>[];\n  /** Throws when borrowed values are stale or disposed. */ assertLive(): void;\n  /** Inverts a root-logical point to UTC milliseconds.\n   * @param pointRoot - Root-logical Canvas position.\n   * @returns Timestamp or undefined for unavailable inversion.\n   */ timeAtRoot(pointRoot: Readonly<RenderedSeriesPoint>): number | undefined;\n  /** Tests a local point against the committed clip stack.\n   * @param pointLocal - Series-local position.\n   * @returns Whether every clip includes it.\n   */ anchorInsideClips(pointLocal: Readonly<RenderedSeriesPoint>): boolean;\n  /** @internal Committed paint flags. */ readonly marks: readonly CapturedVolumeMark<D>[];\n  /** @internal Shared numeric query view. */ readonly numeric: NumericRenderedSeries<D>;\n  /** @internal Converts root coordinates to local coordinates.\n   * @param point - Root-logical position.\n   * @returns Local position or undefined for a singular transform.\n   */ localAtRoot(\n    point: Readonly<RenderedSeriesPoint>,\n  ): Readonly<RenderedSeriesPoint> | undefined;\n}\n/** Mount-owned optional volume capture.\n * @see {@link useVolumeInspection}\n */\nexport interface VolumeInspectionRef<D> {\n  /** @returns Borrowed committed values, or undefined before paint/after disposal. */ rendered():\n    VolumeRenderedSeries<D> | undefined;\n  /** @internal Records local values without executing a query.\n   * @param input - Immutable local marks and committed time mapping.\n   */ capture(input: {\n    /** Captured local paint marks. */ marks: readonly CapturedVolumeMark<D>[];\n    /** Committed horizontal mapping. */ xScale: NumericPositionScale;\n    /** Committed volume mapping. */ yScale: ResolvedContinuousScale;\n  }): void;\n}\n/**\n * Creates a stable optional volume receiver without reading data or subscribing.\n * @param _inputs - Data/accessors used only for original datum inference.\n * @returns Ref to pass to exactly one VolumeSeries inspection prop.\n * @see {@link VolumeInspectionRef}\n */\nexport function useVolumeInspection<D>(\n  _inputs: Pick<VolumeSeriesProps<D>, \"data\" | \"time\" | \"volume\">,\n): VolumeInspectionRef<D> {\n  return useRenderedRef<\n    {\n      marks: readonly CapturedVolumeMark<D>[];\n      xScale: NumericPositionScale;\n      yScale: ResolvedContinuousScale;\n    },\n    VolumeRenderedSeries<D>\n  >(\"volumeInspection\", (candidate, geometry) => {\n    const observations = Object.freeze(\n      candidate.marks.map((mark) =>\n        Object.freeze({\n          datum: mark.datum,\n          sourceIndex: mark.sourceIndex,\n          time: mark.time,\n          volume: mark.volume,\n          baseline: mark.baseline,\n          anchorLocal: mark.anchorLocal,\n          anchorRoot: geometry.rootAtLocal(mark.anchorLocal),\n          boundsLocal: mark.boundsLocal,\n        }),\n      ),\n    );\n    const numeric: NumericRenderedSeries<D> = Object.freeze({\n      observations: Object.freeze(\n        observations.map((row) =>\n          Object.freeze({\n            ...row,\n            domainX: row.time,\n            domainY: row.volume,\n            run: 0,\n          }),\n        ),\n      ),\n      assertLive: geometry.assertLive,\n      domainXAtRoot(point: Readonly<RenderedSeriesPoint>) {\n        const local = geometry.localAtRoot(point);\n        return local\n          ? invertNumericPosition(candidate.xScale, local.x)\n          : undefined;\n      },\n      anchorInsideClips: geometry.anchorInsideClips,\n      anchorAtDomain(point: Readonly<{ domainX: number; domainY: number }>) {\n        geometry.assertLive();\n        const anchorLocal = Object.freeze({\n          x: candidate.xScale.map(point.domainX),\n          y: candidate.yScale.map(point.domainY),\n        });\n        return Object.freeze({\n          anchorLocal,\n          anchorRoot: geometry.rootAtLocal(anchorLocal),\n        });\n      },\n    });\n    return Object.freeze({\n      observations,\n      marks: Object.freeze(candidate.marks.slice()),\n      numeric,\n      assertLive: geometry.assertLive,\n      localAtRoot: geometry.localAtRoot,\n      anchorInsideClips: geometry.anchorInsideClips,\n      timeAtRoot: numeric.domainXAtRoot,\n    });\n  });\n}\n/**\n * Selects a recorded volume by timestamp; equal distances choose first source index.\n * @param rendered - Borrowed committed volume values.\n * @param options - UTC-millisecond request and optional pure candidate filter.\n * @returns Captured original volume and time delta, or undefined when no candidate survives.\n * @see {@link NearestVolumeHit}\n */\nexport function nearestRecordedVolumeX<D>(\n  rendered: VolumeRenderedSeries<D>,\n  options: {\n    time: number;\n    filter?: (observation: VolumeInspectionCandidate<D>) => boolean;\n  },\n): NearestVolumeHit<D> | undefined {\n  const hit = nearestRecordedX(rendered.numeric, {\n    domainX: options.time,\n    filter: options.filter\n      ? (candidate) =>\n          options.filter!(\n            candidate as typeof candidate & VolumeInspectionCandidate<D>,\n          )\n      : undefined,\n  });\n  if (!hit) return undefined;\n  const row = rendered.observations.find(\n    (row) => row.sourceIndex === hit.sourceIndex,\n  )!;\n  return Object.freeze({ ...row, timeDelta: hit.domainDelta });\n}\n/**\n * Finds the last-painted volume column covering a root-logical point.\n * @param rendered - Borrowed committed volume values and paint geometry.\n * @param options - Root-logical point; respects clips, zero height and source paint order.\n * @returns Captured original volume, or undefined for gaps/singular transforms.\n * @see {@link PaintedVolumeHit}\n */\nexport function paintedVolumeAt<D>(\n  rendered: VolumeRenderedSeries<D>,\n  options: { rootPoint: Readonly<RenderedSeriesPoint> },\n): PaintedVolumeHit<D> | undefined {\n  rendered.assertLive();\n  if (\n    !Number.isFinite(options.rootPoint.x) ||\n    !Number.isFinite(options.rootPoint.y)\n  )\n    throw new RangeError(\"paintedVolumeAt rootPoint must be finite.\");\n  const p = rendered.localAtRoot(options.rootPoint);\n  if (!p || !rendered.anchorInsideClips(p)) return undefined;\n  for (let i = rendered.marks.length - 1; i >= 0; i--) {\n    const mark = rendered.marks[i],\n      b = mark.boundsLocal,\n      h = mark.strokeWidthLocal / 2;\n    if (b.height === 0) continue;\n    const inside =\n      p.x >= b.x && p.x <= b.x + b.width && p.y >= b.y && p.y <= b.y + b.height;\n    const outline =\n      h > 0 &&\n      p.x >= b.x - h &&\n      p.x <= b.x + b.width + h &&\n      p.y >= b.y - h &&\n      p.y <= b.y + b.height + h &&\n      !(\n        p.x > b.x + h &&\n        p.x < b.x + b.width - h &&\n        p.y > b.y + h &&\n        p.y < b.y + b.height - h\n      );\n    if ((mark.fill && inside) || outline) return rendered.observations[i];\n  }\n  return undefined;\n}\n"],
+  "mappings": "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",
+  "names": ["row"]
+}