@pibbl/core 0.0.2 → 0.0.3-alpha.90.1

package/dist/features/viz/lib/volume-series.js

@@ -0,0 +1,117 @@
+import { jsx } from "@pibbl/core/jsx-runtime";
+import { useNumericPosition } from "./series-position.js";
+import {
+  Group,
+  Path,
+  resolveSignalValue
+} from "@pibbl/core";
+import { withHooksForbidden } from "@pibbl/core/internal";
+import { useContinuousScale } from "./use-continuous-scale.js";
+import { pointAccessor, pointData, finiteCoordinate } from "./point-data.js";
+import { financialMarkWidth, volumeGeometry } from "./financial-geometry.js";
+import { opacity, width } from "./paint.js";
+function VolumeSeries({
+  data: input,
+  time: timeInput,
+  volume: volumeInput,
+  xScale,
+  yScale,
+  defined,
+  style: styleInput,
+  inspection,
+  pointerEvents,
+  ...events
+}) {
+  const xs = useNumericPosition(xScale), ys = useContinuousScale(yScale).get();
+  const data = pointData(resolveSignalValue(input), "VolumeSeries");
+  const time = pointAccessor(timeInput), volume = pointAccessor(volumeInput);
+  const rows = [];
+  for (let i = 0; i < data.length; i++) {
+    const datum = data[i];
+    if (defined && !defined(datum, i, data)) continue;
+    const t = time(datum, i, data), v = volume(datum, i, data);
+    if (!finiteCoordinate(t) || !finiteCoordinate(v)) continue;
+    if (v < 0)
+      throw new RangeError(
+        `VolumeSeries: negative volume at source index ${i}.`
+      );
+    rows.push({
+      datum,
+      sourceIndex: i,
+      time: t,
+      volume: v,
+      x: xs.map(t),
+      y: ys.map(v)
+    });
+  }
+  const positions = rows.map((row) => row.x), baselineY = ys.map(0), defaultWidth = financialMarkWidth(positions);
+  const specified = typeof styleInput === "function" ? styleInput : resolveSignalValue(styleInput);
+  const marks = inspection ? [] : void 0;
+  const batches = [];
+  for (const row of rows) {
+    const style = typeof specified === "function" ? withHooksForbidden(
+      "VolumeSeries style callback",
+      () => specified(row.datum, row.sourceIndex, data)
+    ) : specified ?? {};
+    const markWidth = style.width === void 0 ? defaultWidth : financialMarkWidth([], { width: style.width });
+    const b = volumeGeometry({
+      centerX: row.x,
+      valueY: row.y,
+      baselineY,
+      width: markWidth
+    });
+    const fill = style.fill ?? "#087f8c", stroke = style.stroke, strokeWidth = width(style.strokeWidth ?? 1, "VolumeSeries"), alpha = opacity(style.opacity ?? 1, "VolumeSeries");
+    marks?.push(
+      Object.freeze({
+        datum: row.datum,
+        sourceIndex: row.sourceIndex,
+        time: row.time,
+        volume: row.volume,
+        baseline: 0,
+        anchorLocal: Object.freeze({ x: row.x, y: row.y }),
+        boundsLocal: b,
+        fill: !!fill && alpha > 0,
+        strokeWidthLocal: stroke && alpha > 0 ? strokeWidth : 0
+      })
+    );
+    if (b.height === 0 || alpha === 0) continue;
+    let batch = batches.at(-1);
+    const half = stroke ? strokeWidth / 2 : 0, minX = b.x - half, maxX = b.x + b.width + half;
+    if (!batch || minX < batch.maxX && maxX > batch.minX || batch.fill !== fill || batch.stroke !== stroke || batch.strokeWidth !== strokeWidth || batch.opacity !== alpha || batch.cursor !== style.cursor) {
+      batch = {
+        path: new Path2D(),
+        fill,
+        stroke,
+        strokeWidth,
+        opacity: alpha,
+        cursor: style.cursor,
+        minX,
+        maxX
+      };
+      batches.push(batch);
+    }
+    batch.minX = Math.min(batch.minX, minX);
+    batch.maxX = Math.max(batch.maxX, maxX);
+    batch.path.rect(b.x, b.y, b.width, b.height);
+  }
+  inspection?.capture({ marks, xScale: xs, yScale: ys });
+  return /* @__PURE__ */ jsx(Group, { ...events, children: batches.map((batch, index) => /* @__PURE__ */ jsx(
+    Path,
+    {
+      pointerEvents,
+      style: {
+        d: batch.path,
+        fill: batch.fill,
+        stroke: batch.stroke,
+        strokeWidth: batch.strokeWidth,
+        opacity: batch.opacity,
+        cursor: batch.cursor
+      }
+    },
+    index
+  )) });
+}
+export {
+  VolumeSeries
+};
+//# sourceMappingURL=volume-series.js.map

package/dist/features/viz/lib/volume-series.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/viz/lib/volume-series.tsx"],
+  "sourcesContent": ["import { useNumericPosition } from \"./series-position.js\";\nimport {\n  Group,\n  Path,\n  resolveSignalValue,\n  type FillStyle,\n  type StrokeStyle,\n  type SignalValue,\n  type PibblEventHandlers,\n  type PibblEventParticipationOptions,\n  type PibblNode,\n} from \"@pibbl/core\";\nimport { withHooksForbidden } from \"@pibbl/core/internal\";\nimport type { LineAccessor, ScaleId } from \"./types.js\";\nimport type {\n  VolumeInspectionRef,\n  CapturedVolumeMark,\n} from \"../inspection/volume.js\";\nimport { useContinuousScale } from \"./use-continuous-scale.js\";\nimport { pointAccessor, pointData, finiteCoordinate } from \"./point-data.js\";\nimport { financialMarkWidth, volumeGeometry } from \"./financial-geometry.js\";\nimport { opacity, width } from \"./paint.js\";\n\n/** Local column presentation; color meaning is supplied by the application.\n * @see {@link VolumeSeries}\n */\nexport interface VolumeSeriesStyle {\n  /** Positive column width in local logical units; default 70% spacing capped at 12. */\n  readonly width?: number;\n  /** Interior paint; defaults to teal. */\n  readonly fill?: FillStyle;\n  /** Optional column outline paint. */\n  readonly stroke?: StrokeStyle;\n  /** Nonnegative outline width in local units; default 1. */\n  readonly strokeWidth?: number;\n  /** Paint opacity from zero through one; default 1. */\n  readonly opacity?: number;\n  /** Cursor when the series owns coordinate targeting. */\n  readonly cursor?: string;\n}\n/** Time-aligned volume columns with an independent numeric y-scale.\n * @see {@link VolumeSeries}\n */\nexport interface VolumeSeriesProps<D>\n  extends PibblEventHandlers, PibblEventParticipationOptions {\n  /** Original records or a signal of records; never sorted or mutated. */\n  readonly data: SignalValue<readonly D[]>;\n  /** UTC-millisecond property or callback; missing/nonfinite values skip the row. */\n  readonly time: LineAccessor<D>;\n  /** Nonnegative volume property or callback; missing/nonfinite values skip the row. */\n  readonly volume: LineAccessor<D>;\n  /** Selects source records before evaluating accessors.\n   * @param datum - Original record.\n   * @param index - Original source index.\n   * @param data - Complete source array.\n   * @returns Whether the row participates.\n   */\n  readonly defined?: (datum: D, index: number, data: readonly D[]) => boolean;\n  /** Numeric time scale identity. */\n  readonly xScale: ScaleId;\n  /** Independent numeric volume scale identity; the baseline is zero. */\n  readonly yScale: ScaleId;\n  /** Constant presentation or a hook-free per-record resolver.\n   * @param datum - Original record.\n   * @param index - Original source index.\n   * @param data - Complete source array.\n   * @returns Column presentation.\n   */\n  readonly style?:\n    | SignalValue<VolumeSeriesStyle>\n    | ((datum: D, index: number, data: readonly D[]) => VolumeSeriesStyle);\n  /** Optional committed capture; importing the renderer does not import inspection queries. */\n  readonly inspection?: VolumeInspectionRef<D>;\n}\n/**\n * Paints source-ordered time-aligned volume columns, batching adjacent equal styles.\n * Zero volume is recorded but has no painted coverage. Finite negative volume rejects.\n * @param props - Original records, numeric scales, accessors and optional capture.\n * @returns Ordinary Pibbl paint/event composition.\n * @see {@link VolumeSeriesProps}\n */\nexport function VolumeSeries<D>({\n  data: input,\n  time: timeInput,\n  volume: volumeInput,\n  xScale,\n  yScale,\n  defined,\n  style: styleInput,\n  inspection,\n  pointerEvents,\n  ...events\n}: VolumeSeriesProps<D>): PibblNode {\n  const xs = useNumericPosition(xScale),\n    ys = useContinuousScale(yScale).get();\n  const data = pointData(resolveSignalValue(input), \"VolumeSeries\");\n  const time = pointAccessor(timeInput),\n    volume = pointAccessor(volumeInput);\n  const rows: {\n    datum: D;\n    sourceIndex: number;\n    time: number;\n    volume: number;\n    x: number;\n    y: number;\n  }[] = [];\n  for (let i = 0; i < data.length; i++) {\n    const datum = data[i];\n    if (defined && !defined(datum, i, data)) continue;\n    const t = time(datum, i, data),\n      v = volume(datum, i, data);\n    if (!finiteCoordinate(t) || !finiteCoordinate(v)) continue;\n    if (v < 0)\n      throw new RangeError(\n        `VolumeSeries: negative volume at source index ${i}.`,\n      );\n    rows.push({\n      datum,\n      sourceIndex: i,\n      time: t,\n      volume: v,\n      x: xs.map(t),\n      y: ys.map(v),\n    });\n  }\n  const positions = rows.map((row) => row.x),\n    baselineY = ys.map(0),\n    defaultWidth = financialMarkWidth(positions);\n  const specified =\n    typeof styleInput === \"function\"\n      ? styleInput\n      : resolveSignalValue(styleInput);\n  const marks: CapturedVolumeMark<D>[] | undefined = inspection\n    ? []\n    : undefined;\n  const batches: {\n    path: Path2D;\n    fill: FillStyle;\n    stroke: StrokeStyle | undefined;\n    strokeWidth: number;\n    opacity: number;\n    cursor: string | undefined;\n    minX: number;\n    maxX: number;\n  }[] = [];\n  for (const row of rows) {\n    const style =\n      typeof specified === \"function\"\n        ? withHooksForbidden(\"VolumeSeries style callback\", () =>\n            specified(row.datum, row.sourceIndex, data),\n          )\n        : (specified ?? {});\n    const markWidth =\n      style.width === undefined\n        ? defaultWidth\n        : financialMarkWidth([], { width: style.width });\n    const b = volumeGeometry({\n      centerX: row.x,\n      valueY: row.y,\n      baselineY,\n      width: markWidth,\n    });\n    const fill = style.fill ?? \"#087f8c\",\n      stroke = style.stroke,\n      strokeWidth = width(style.strokeWidth ?? 1, \"VolumeSeries\"),\n      alpha = opacity(style.opacity ?? 1, \"VolumeSeries\");\n    marks?.push(\n      Object.freeze({\n        datum: row.datum,\n        sourceIndex: row.sourceIndex,\n        time: row.time,\n        volume: row.volume,\n        baseline: 0,\n        anchorLocal: Object.freeze({ x: row.x, y: row.y }),\n        boundsLocal: b,\n        fill: !!fill && alpha > 0,\n        strokeWidthLocal: stroke && alpha > 0 ? strokeWidth : 0,\n      }),\n    );\n    if (b.height === 0 || alpha === 0) continue;\n    let batch = batches.at(-1);\n    const half = stroke ? strokeWidth / 2 : 0,\n      minX = b.x - half,\n      maxX = b.x + b.width + half;\n    if (\n      !batch ||\n      (minX < batch.maxX && maxX > batch.minX) ||\n      batch.fill !== fill ||\n      batch.stroke !== stroke ||\n      batch.strokeWidth !== strokeWidth ||\n      batch.opacity !== alpha ||\n      batch.cursor !== style.cursor\n    ) {\n      batch = {\n        path: new Path2D(),\n        fill,\n        stroke,\n        strokeWidth,\n        opacity: alpha,\n        cursor: style.cursor,\n        minX,\n        maxX,\n      };\n      batches.push(batch);\n    }\n    batch.minX = Math.min(batch.minX, minX);\n    batch.maxX = Math.max(batch.maxX, maxX);\n    batch.path.rect(b.x, b.y, b.width, b.height);\n  }\n  inspection?.capture({ marks: marks!, xScale: xs, yScale: ys });\n  return (\n    <Group {...events}>\n      {batches.map((batch, index) => (\n        <Path\n          key={index}\n          pointerEvents={pointerEvents}\n          style={{\n            d: batch.path,\n            fill: batch.fill,\n            stroke: batch.stroke,\n            strokeWidth: batch.strokeWidth,\n            opacity: batch.opacity,\n            cursor: batch.cursor,\n          }}\n        />\n      ))}\n    </Group>\n  );\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/features/viz/lib/weighted-point-series.d.ts

@@ -0,0 +1,71 @@
+import type { FillStyle, PibblEventHandlers, PibblEventParticipationOptions, SignalValue, StrokeStyle } from "@pibbl/core";
+import type { SignalStyle } from "@pibbl/core/internal";
+import type { LineAccessor, ScaleId, SeriesAccessor } from "./types.js";
+/**
+ * A data property or callback extracting a nonnegative research weight.
+ *
+ * @see {@link WeightedPointSeriesProps}
+ */
+export type WeightAccessor<D> = LineAccessor<D>;
+/** Shared presentation for {@link WeightedPointSeries}. */
+export interface WeightedPointSeriesStyle {
+    /** Paint used for point interiors. Defaults to `#087f8c`. */
+    readonly fill?: FillStyle;
+    /** Paint used for point outlines. Defaults to no outline. */
+    readonly stroke?: StrokeStyle;
+    /** Outline width in local coordinate units. Defaults to 1. */
+    readonly strokeWidth?: number;
+    /** Opacity in the inclusive range [0, 1]. Defaults to 1. */
+    readonly opacity?: number;
+    /** Pointer cursor while the series owns a target. */
+    readonly cursor?: string;
+}
+/**
+ * Authored inputs for {@link WeightedPointSeries}.
+ *
+ * Weights are supplied data, not calculated precision, sample size, or evidence.
+ * The zero baseline and squared-radius interpolation make displayed area linear in
+ * the supplied weight.
+ */
+export interface WeightedPointSeriesProps<D> extends PibblEventHandlers, PibblEventParticipationOptions {
+    /** Readonly data or a signal containing it. */
+    readonly data: SignalValue<readonly D[]>;
+    /** Horizontal coordinate property or synchronous accessor. */
+    readonly x: SeriesAccessor<D>;
+    /** Vertical coordinate property or synchronous accessor. */
+    readonly y: SeriesAccessor<D>;
+    /** Nonnegative supplied weight property or synchronous accessor. */
+    readonly weight: WeightAccessor<D>;
+    /** Scale used to map x coordinates. */
+    readonly xScale: ScaleId;
+    /** Scale used to map y coordinates. */
+    readonly yScale: ScaleId;
+    /** Supplied inclusive weight extent. The lower bound must be zero. */
+    readonly weightDomain: readonly [0, number];
+    /** Radius extent `[0, maximumRadius]`; defaults to `[0, 6]`. */
+    readonly radiusRange?: readonly [0, number];
+    /**
+     * Excludes a datum before coordinate and weight accessors run.
+     * @param datum - Candidate source datum.
+     * @param index - Zero-based source index.
+     * @param data - Complete source data array.
+     * @returns Whether this datum contributes a mark.
+     */
+    readonly defined?: (datum: D, index: number, data: readonly D[]) => boolean;
+    /** Shared presentation. Whole-object and shallow field signals are supported. */
+    readonly style?: SignalValue<SignalStyle<WeightedPointSeriesStyle>>;
+}
+/**
+ * Draws batched circles whose visible area is proportional to supplied weights.
+ *
+ * Nullish weights and zero weights omit their marks. Finite positive weights must
+ * fall inside `weightDomain`; the component never clamps or infers weights.
+ * `data` and shared style signals schedule ordinary Pibbl updates. The component
+ * owns no retained resources and returns one ordinary Pibbl pointer target.
+ *
+ * @param props - Supplied observations, coordinate and weight accessors, scales, and paint.
+ * See {@link WeightedPointSeriesProps}.
+ * @returns One batched Pibbl Path whose mark area is proportional to each supplied weight.
+ * @see {@link WeightedPointSeriesProps}
+ */
+export declare function WeightedPointSeries<D>({ data: input, x: xInput, y: yInput, weight: weightInput, xScale: xId, yScale: yId, weightDomain, radiusRange, defined, style: styleInput, ...events }: WeightedPointSeriesProps<D>): import("../../../jsx-runtime.js").JSX.Element;

package/dist/features/viz/lib/weighted-point-series.js

@@ -0,0 +1,169 @@
+import { jsx } from "@pibbl/core/jsx-runtime";
+import { resolveTexturePaint } from "@pibbl/core/internal";
+import { Path, resolveSignalValue, useCanvasContext } from "@pibbl/core";
+import { validateTexturePaint, withHooksForbidden } from "@pibbl/core/internal";
+import { pointAccessor, pointData } from "./point-data.js";
+import { appendPointTarget, pointPath } from "./point-geometry.js";
+import { opacity, width } from "./paint.js";
+import {
+  mapSeriesPosition,
+  seriesAccessor,
+  useSeriesPosition
+} from "./series-position.js";
+const fields = ["fill", "stroke", "strokeWidth", "opacity", "cursor"];
+function paint(value, name) {
+  if (value === void 0 || typeof value === "string" || value instanceof CanvasGradient || value instanceof CanvasPattern)
+    return value;
+  try {
+    validateTexturePaint(value);
+    return value;
+  } catch {
+  }
+  throw new TypeError(`WeightedPointSeries: invalid ${name}.`);
+}
+function styleObject(input) {
+  if (input === null || typeof input !== "object" || Array.isArray(input))
+    throw new TypeError("WeightedPointSeries: style must be an object.");
+  const result = {};
+  for (const key of Object.keys(input)) {
+    if (!fields.includes(key))
+      throw new TypeError(
+        `WeightedPointSeries: unsupported style field ${key}.`
+      );
+    result[key] = resolveSignalValue(input[key]);
+  }
+  return result;
+}
+function normalized(style) {
+  if (style.cursor !== void 0 && typeof style.cursor !== "string")
+    throw new TypeError("WeightedPointSeries: cursor must be a string.");
+  return {
+    fill: paint(style.fill ?? "#087f8c", "fill"),
+    stroke: paint(style.stroke, "stroke"),
+    strokeWidth: width(
+      style.strokeWidth ?? 1,
+      "WeightedPointSeries strokeWidth"
+    ),
+    opacity: opacity(style.opacity ?? 1, "WeightedPointSeries opacity"),
+    cursor: style.cursor
+  };
+}
+function range(value) {
+  const actual = value ?? [0, 6];
+  if (!Array.isArray(actual) || actual.length !== 2 || actual[0] !== 0 || !Number.isFinite(actual[1]) || actual[1] < 0)
+    throw new RangeError(
+      "WeightedPointSeries: radiusRange must be [0, a finite nonnegative maximum]."
+    );
+  return actual;
+}
+function domain(value) {
+  if (!Array.isArray(value) || value.length !== 2 || value[0] !== 0 || !Number.isFinite(value[1]) || value[1] <= 0)
+    throw new RangeError(
+      "WeightedPointSeries: weightDomain must be [0, a finite positive maximum]."
+    );
+  return value;
+}
+function WeightedPointSeries({
+  data: input,
+  x: xInput,
+  y: yInput,
+  weight: weightInput,
+  xScale: xId,
+  yScale: yId,
+  weightDomain,
+  radiusRange,
+  defined,
+  style: styleInput,
+  ...events
+}) {
+  const xs = useSeriesPosition(xId);
+  const ys = useSeriesPosition(yId);
+  const data = pointData(resolveSignalValue(input), "WeightedPointSeries");
+  const x = seriesAccessor(xInput);
+  const y = seriesAccessor(yInput);
+  const weight = pointAccessor(weightInput);
+  const [, maximumWeight] = domain(weightDomain);
+  const [, maximumRadius] = range(radiusRange);
+  const style = normalized(styleObject(resolveSignalValue(styleInput) ?? {}));
+  const ctx = useCanvasContext();
+  const target = new Path2D();
+  const marks = [];
+  for (let i = 0; i < data.length; i++) {
+    const datum = data[i];
+    const values = withHooksForbidden(
+      "WeightedPointSeries: accessors cannot call hooks.",
+      () => {
+        if (defined && !defined(datum, i, data)) return void 0;
+        return {
+          x: x(datum, i, data),
+          y: y(datum, i, data),
+          weight: weight(datum, i, data)
+        };
+      }
+    );
+    if (!values) continue;
+    const mappedX = mapSeriesPosition(xs, values.x);
+    const mappedY = mapSeriesPosition(ys, values.y);
+    if (mappedX === void 0 || mappedY === void 0) continue;
+    const supplied = values.weight;
+    if (supplied == null) continue;
+    if (typeof supplied !== "number" || !Number.isFinite(supplied))
+      throw new TypeError(
+        "WeightedPointSeries: weight must be a finite number."
+      );
+    if (supplied < 0)
+      throw new RangeError("WeightedPointSeries: weight must be nonnegative.");
+    if (supplied > maximumWeight)
+      throw new RangeError("WeightedPointSeries: weight exceeds weightDomain.");
+    if (supplied === 0 || maximumRadius === 0) continue;
+    const radius = maximumRadius * Math.sqrt(supplied / maximumWeight);
+    marks.push({ x: mappedX, y: mappedY, radius });
+  }
+  for (const { x: x2, y: y2, radius } of marks) {
+    appendPointTarget(
+      target,
+      x2,
+      y2,
+      radius,
+      !!style.fill,
+      style.stroke ? style.strokeWidth : 0
+    );
+    const path = pointPath(x2, y2, radius);
+    ctx.save();
+    try {
+      ctx.globalAlpha *= style.opacity;
+      if (style.fill) {
+        ctx.fillStyle = resolveTexturePaint(style.fill, ctx, {
+          x: x2 - radius,
+          y: y2 - radius,
+          width: radius * 2,
+          height: radius * 2
+        });
+        ctx.fill(path);
+      }
+      if (style.stroke && style.strokeWidth > 0) {
+        ctx.strokeStyle = resolveTexturePaint(style.stroke, ctx, {
+          x: x2 - radius,
+          y: y2 - radius,
+          width: radius * 2,
+          height: radius * 2
+        });
+        ctx.lineWidth = style.strokeWidth;
+        ctx.stroke(path);
+      }
+    } finally {
+      ctx.restore();
+    }
+  }
+  return /* @__PURE__ */ jsx(
+    Path,
+    {
+      ...events,
+      style: { d: target, fill: "transparent", cursor: style.cursor }
+    }
+  );
+}
+export {
+  WeightedPointSeries
+};
+//# sourceMappingURL=weighted-point-series.js.map

package/dist/features/viz/lib/weighted-point-series.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/viz/lib/weighted-point-series.tsx"],
+  "sourcesContent": ["import { resolveTexturePaint } from \"@pibbl/core/internal\";\nimport { Path, resolveSignalValue, useCanvasContext } from \"@pibbl/core\";\nimport type {\n  FillStyle,\n  PibblEventHandlers,\n  PibblEventParticipationOptions,\n  SignalValue,\n  StrokeStyle,\n} from \"@pibbl/core\";\nimport type { SignalStyle } from \"@pibbl/core/internal\";\nimport { validateTexturePaint, withHooksForbidden } from \"@pibbl/core/internal\";\nimport type { LineAccessor, ScaleId, SeriesAccessor } from \"./types.js\";\nimport { pointAccessor, pointData } from \"./point-data.js\";\nimport { appendPointTarget, pointPath } from \"./point-geometry.js\";\nimport { opacity, width } from \"./paint.js\";\nimport {\n  mapSeriesPosition,\n  seriesAccessor,\n  useSeriesPosition,\n} from \"./series-position.js\";\n\nconst fields = [\"fill\", \"stroke\", \"strokeWidth\", \"opacity\", \"cursor\"];\n\n/**\n * A data property or callback extracting a nonnegative research weight.\n *\n * @see {@link WeightedPointSeriesProps}\n */\nexport type WeightAccessor<D> = LineAccessor<D>;\n\n/** Shared presentation for {@link WeightedPointSeries}. */\nexport interface WeightedPointSeriesStyle {\n  /** Paint used for point interiors. Defaults to `#087f8c`. */\n  readonly fill?: FillStyle;\n  /** Paint used for point outlines. Defaults to no outline. */\n  readonly stroke?: StrokeStyle;\n  /** Outline width in local coordinate units. Defaults to 1. */\n  readonly strokeWidth?: number;\n  /** Opacity in the inclusive range [0, 1]. Defaults to 1. */\n  readonly opacity?: number;\n  /** Pointer cursor while the series owns a target. */\n  readonly cursor?: string;\n}\n\n/**\n * Authored inputs for {@link WeightedPointSeries}.\n *\n * Weights are supplied data, not calculated precision, sample size, or evidence.\n * The zero baseline and squared-radius interpolation make displayed area linear in\n * the supplied weight.\n */\nexport interface WeightedPointSeriesProps<D>\n  extends PibblEventHandlers, PibblEventParticipationOptions {\n  /** Readonly data or a signal containing it. */\n  readonly data: SignalValue<readonly D[]>;\n  /** Horizontal coordinate property or synchronous accessor. */\n  readonly x: SeriesAccessor<D>;\n  /** Vertical coordinate property or synchronous accessor. */\n  readonly y: SeriesAccessor<D>;\n  /** Nonnegative supplied weight property or synchronous accessor. */\n  readonly weight: WeightAccessor<D>;\n  /** Scale used to map x coordinates. */\n  readonly xScale: ScaleId;\n  /** Scale used to map y coordinates. */\n  readonly yScale: ScaleId;\n  /** Supplied inclusive weight extent. The lower bound must be zero. */\n  readonly weightDomain: readonly [0, number];\n  /** Radius extent `[0, maximumRadius]`; defaults to `[0, 6]`. */\n  readonly radiusRange?: readonly [0, number];\n  /**\n   * Excludes a datum before coordinate and weight accessors run.\n   * @param datum - Candidate source datum.\n   * @param index - Zero-based source index.\n   * @param data - Complete source data array.\n   * @returns Whether this datum contributes a mark.\n   */\n  readonly defined?: (datum: D, index: number, data: readonly D[]) => boolean;\n  /** Shared presentation. Whole-object and shallow field signals are supported. */\n  readonly style?: SignalValue<SignalStyle<WeightedPointSeriesStyle>>;\n}\n\nfunction paint(\n  value: unknown,\n  name: string,\n): FillStyle | StrokeStyle | undefined {\n  if (\n    value === undefined ||\n    typeof value === \"string\" ||\n    value instanceof CanvasGradient ||\n    value instanceof CanvasPattern\n  )\n    return value;\n  try {\n    validateTexturePaint(value as never);\n    return value as FillStyle | StrokeStyle;\n  } catch {\n    // Normalize all unsupported public paint values to the series error.\n  }\n  throw new TypeError(`WeightedPointSeries: invalid ${name}.`);\n}\n\nfunction styleObject(input: unknown): WeightedPointSeriesStyle {\n  if (input === null || typeof input !== \"object\" || Array.isArray(input))\n    throw new TypeError(\"WeightedPointSeries: style must be an object.\");\n  const result: Record<string, unknown> = {};\n  for (const key of Object.keys(input)) {\n    if (!fields.includes(key))\n      throw new TypeError(\n        `WeightedPointSeries: unsupported style field ${key}.`,\n      );\n    result[key] = resolveSignalValue((input as Record<string, unknown>)[key]);\n  }\n  return result as WeightedPointSeriesStyle;\n}\n\nfunction normalized(style: WeightedPointSeriesStyle) {\n  if (style.cursor !== undefined && typeof style.cursor !== \"string\")\n    throw new TypeError(\"WeightedPointSeries: cursor must be a string.\");\n  return {\n    fill: paint(style.fill ?? \"#087f8c\", \"fill\"),\n    stroke: paint(style.stroke, \"stroke\"),\n    strokeWidth: width(\n      style.strokeWidth ?? 1,\n      \"WeightedPointSeries strokeWidth\",\n    ),\n    opacity: opacity(style.opacity ?? 1, \"WeightedPointSeries opacity\"),\n    cursor: style.cursor,\n  };\n}\n\nfunction range(\n  value: readonly [number, number] | undefined,\n): readonly [number, number] {\n  const actual: readonly [number, number] = value ?? [0, 6];\n  if (\n    !Array.isArray(actual) ||\n    actual.length !== 2 ||\n    actual[0] !== 0 ||\n    !Number.isFinite(actual[1]) ||\n    actual[1] < 0\n  )\n    throw new RangeError(\n      \"WeightedPointSeries: radiusRange must be [0, a finite nonnegative maximum].\",\n    );\n  return actual;\n}\n\nfunction domain(value: readonly [0, number]): readonly [number, number] {\n  if (\n    !Array.isArray(value) ||\n    value.length !== 2 ||\n    value[0] !== 0 ||\n    !Number.isFinite(value[1]) ||\n    value[1] <= 0\n  )\n    throw new RangeError(\n      \"WeightedPointSeries: weightDomain must be [0, a finite positive maximum].\",\n    );\n  return value;\n}\n\n/**\n * Draws batched circles whose visible area is proportional to supplied weights.\n *\n * Nullish weights and zero weights omit their marks. Finite positive weights must\n * fall inside `weightDomain`; the component never clamps or infers weights.\n * `data` and shared style signals schedule ordinary Pibbl updates. The component\n * owns no retained resources and returns one ordinary Pibbl pointer target.\n *\n * @param props - Supplied observations, coordinate and weight accessors, scales, and paint.\n * See {@link WeightedPointSeriesProps}.\n * @returns One batched Pibbl Path whose mark area is proportional to each supplied weight.\n * @see {@link WeightedPointSeriesProps}\n */\nexport function WeightedPointSeries<D>({\n  data: input,\n  x: xInput,\n  y: yInput,\n  weight: weightInput,\n  xScale: xId,\n  yScale: yId,\n  weightDomain,\n  radiusRange,\n  defined,\n  style: styleInput,\n  ...events\n}: WeightedPointSeriesProps<D>) {\n  const xs = useSeriesPosition(xId);\n  const ys = useSeriesPosition(yId);\n  const data = pointData(resolveSignalValue(input), \"WeightedPointSeries\");\n  const x = seriesAccessor(xInput);\n  const y = seriesAccessor(yInput);\n  const weight = pointAccessor(weightInput);\n  const [, maximumWeight] = domain(weightDomain);\n  const [, maximumRadius] = range(radiusRange);\n  const style = normalized(styleObject(resolveSignalValue(styleInput) ?? {}));\n  const ctx = useCanvasContext();\n  const target = new Path2D();\n  const marks: {\n    readonly x: number;\n    readonly y: number;\n    readonly radius: number;\n  }[] = [];\n  for (let i = 0; i < data.length; i++) {\n    const datum = data[i];\n    const values = withHooksForbidden(\n      \"WeightedPointSeries: accessors cannot call hooks.\",\n      () => {\n        if (defined && !defined(datum, i, data)) return undefined;\n        return {\n          x: x(datum, i, data),\n          y: y(datum, i, data),\n          weight: weight(datum, i, data),\n        };\n      },\n    );\n    if (!values) continue;\n    const mappedX = mapSeriesPosition(xs, values.x);\n    const mappedY = mapSeriesPosition(ys, values.y);\n    if (mappedX === undefined || mappedY === undefined) continue;\n    const supplied = values.weight;\n    if (supplied == null) continue;\n    if (typeof supplied !== \"number\" || !Number.isFinite(supplied))\n      throw new TypeError(\n        \"WeightedPointSeries: weight must be a finite number.\",\n      );\n    if (supplied < 0)\n      throw new RangeError(\"WeightedPointSeries: weight must be nonnegative.\");\n    if (supplied > maximumWeight)\n      throw new RangeError(\"WeightedPointSeries: weight exceeds weightDomain.\");\n    if (supplied === 0 || maximumRadius === 0) continue;\n    const radius = maximumRadius * Math.sqrt(supplied / maximumWeight);\n    marks.push({ x: mappedX, y: mappedY, radius });\n  }\n  for (const { x, y, radius } of marks) {\n    appendPointTarget(\n      target,\n      x,\n      y,\n      radius,\n      !!style.fill,\n      style.stroke ? style.strokeWidth : 0,\n    );\n    const path = pointPath(x, y, radius);\n    ctx.save();\n    try {\n      ctx.globalAlpha *= style.opacity;\n      if (style.fill) {\n        ctx.fillStyle = resolveTexturePaint(style.fill, ctx, {\n          x: x - radius,\n          y: y - radius,\n          width: radius * 2,\n          height: radius * 2,\n        });\n        ctx.fill(path);\n      }\n      if (style.stroke && style.strokeWidth > 0) {\n        ctx.strokeStyle = resolveTexturePaint(style.stroke, ctx, {\n          x: x - radius,\n          y: y - radius,\n          width: radius * 2,\n          height: radius * 2,\n        });\n        ctx.lineWidth = style.strokeWidth;\n        ctx.stroke(path);\n      }\n    } finally {\n      ctx.restore();\n    }\n  }\n  return (\n    <Path\n      {...events}\n      style={{ d: target, fill: \"transparent\", cursor: style.cursor }}\n    />\n  );\n}\n"],
+  "mappings": "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",
+  "names": ["x", "y"]
+}

package/dist/filters/backdrop-contrast-gpu.d.ts

@@ -0,0 +1,5 @@
+import { ReflectionGpu, type ReflectionGpuCallbacks } from "./reflection-gpu.js";
+/** Shares the existing private GPU resource/context-loss implementation. */
+export declare class BackdropContrastGpu extends ReflectionGpu {
+    constructor(callbacks?: Readonly<ReflectionGpuCallbacks>);
+}

package/dist/filters/backdrop-contrast-gpu.js

@@ -0,0 +1,33 @@
+import {
+  ReflectionGpu
+} from "./reflection-gpu.js";
+const fragment = `#version 300 es
+precision highp float;
+uniform sampler2D scene, map, lightMap;
+in vec2 uv;
+out vec4 outputColor;
+vec3 linearRgb(vec3 c) {
+  return mix(c/12.92,pow((c+.055)/1.055,vec3(2.4)),step(vec3(.04045),c));
+}
+void main() {
+  float coverage=texture(scene,uv).a;
+  vec4 backdrop=texture(map,uv);
+  // A transparent current target is evaluated over white; DOM pixels are unavailable.
+  vec3 background=mix(vec3(1),backdrop.rgb,backdrop.a);
+  float luminance=dot(linearRgb(background),vec3(.2126,.7152,.0722));
+  // Equal black/white contrast occurs at sqrt(.05*1.05)-.05.
+  int choice=luminance<.179128784747792?0:1;
+  vec4 color=texelFetch(lightMap,ivec2(choice,0),0);
+  float alpha=coverage*color.a;
+  outputColor=vec4(color.rgb*alpha,alpha);
+}
+`;
+class BackdropContrastGpu extends ReflectionGpu {
+  constructor(callbacks = {}) {
+    super(callbacks, fragment);
+  }
+}
+export {
+  BackdropContrastGpu
+};
+//# sourceMappingURL=backdrop-contrast-gpu.js.map

package/dist/filters/backdrop-contrast-gpu.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/filters/backdrop-contrast-gpu.ts"],
+  "sourcesContent": ["import {\n  ReflectionGpu,\n  type ReflectionGpuCallbacks,\n} from \"./reflection-gpu.js\";\n\nconst fragment = `#version 300 es\nprecision highp float;\nuniform sampler2D scene, map, lightMap;\nin vec2 uv;\nout vec4 outputColor;\nvec3 linearRgb(vec3 c) {\n  return mix(c/12.92,pow((c+.055)/1.055,vec3(2.4)),step(vec3(.04045),c));\n}\nvoid main() {\n  float coverage=texture(scene,uv).a;\n  vec4 backdrop=texture(map,uv);\n  // A transparent current target is evaluated over white; DOM pixels are unavailable.\n  vec3 background=mix(vec3(1),backdrop.rgb,backdrop.a);\n  float luminance=dot(linearRgb(background),vec3(.2126,.7152,.0722));\n  // Equal black/white contrast occurs at sqrt(.05*1.05)-.05.\n  int choice=luminance<.179128784747792?0:1;\n  vec4 color=texelFetch(lightMap,ivec2(choice,0),0);\n  float alpha=coverage*color.a;\n  outputColor=vec4(color.rgb*alpha,alpha);\n}\n`;\n/** Shares the existing private GPU resource/context-loss implementation. */\nexport class BackdropContrastGpu extends ReflectionGpu {\n  constructor(callbacks: Readonly<ReflectionGpuCallbacks> = {}) {\n    super(callbacks, fragment);\n  }\n}\n"],
+  "mappings": "AAAA;AAAA,EACE;AAAA,OAEK;AAEP,MAAM,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAsBV,MAAM,4BAA4B,cAAc;AAAA,EACrD,YAAY,YAA8C,CAAC,GAAG;AAC5D,UAAM,WAAW,QAAQ;AAAA,EAC3B;AACF;",
+  "names": []
+}

package/dist/filters/backdrop-contrast.d.ts

@@ -0,0 +1,21 @@
+import type { SignalValue } from "../lib/signals/types.js";
+import { type PibblFilter } from "../lib/style/filter-types.js";
+/** Two foreground colors selected per backdrop pixel. See {@link backdropContrast}. */
+export interface PibblBackdropContrastFilterOptions {
+    /** Color drawn over dark backdrop pixels; defaults to white. See {@link SignalValue}. */
+    readonly light?: SignalValue<string>;
+    /** Color drawn over light backdrop pixels; defaults to black. See {@link SignalValue}. */
+    readonly dark?: SignalValue<string>;
+}
+/**
+ * Recolors a receiving primitive and its descendants per pixel, using their combined alpha
+ * as a mask. Chooses light below relative backdrop luminance 0.179129 and dark otherwise.
+ * Samples already-painted content in the current Canvas target; transparent backdrop is
+ * evaluated over white. Isolated/cached layers see their own local backdrop, not outer paint.
+ * Requires OffscreenCanvas and WebGL2; performs no scene pixel readback. Geometry is unchanged.
+ *
+ * @param options - Optional signal-capable foreground colors; white and black by default.
+ * See {@link PibblBackdropContrastFilterOptions}.
+ * @returns An immutable descriptor for style.filter. See {@link PibblFilter}.
+ */
+export declare function backdropContrast(options?: PibblBackdropContrastFilterOptions): PibblFilter;

package/dist/filters/backdrop-contrast.js

@@ -0,0 +1,61 @@
+import { isSignal } from "../lib/signals/graph.js";
+import { layoutDiagnostic } from "../lib/style/diagnostics.js";
+import {
+  PIBBL_FILTER_EXECUTOR
+} from "../lib/style/filter-types.js";
+import { concreteColor } from "./native-color.js";
+import {
+  filterBoundaryExecutor
+} from "./filter-executor.js";
+import { processBackdropContrast } from "./render-backdrop-contrast-boundary.js";
+const definitions = /* @__PURE__ */ new WeakMap();
+const executor = {
+  prepare(value, property, context) {
+    const options = definitions.get(value);
+    if (!options)
+      throw new Error(
+        "A backdropContrast filter was created by an incompatible Pibbl runtime."
+      );
+    const color = (key, fallback) => {
+      const input = options[key];
+      const value2 = input === void 0 ? fallback : isSignal(input) ? input.get() : input;
+      const result = concreteColor(value2, `${property}.${key}`, context);
+      if (typeof CSS === "undefined" || !CSS.supports("color", result))
+        throw layoutDiagnostic({
+          component: context.component,
+          property: `${property}.${key}`,
+          value: value2,
+          algorithm: context.algorithm,
+          constraints: context.constraints,
+          reason: "must be a supported concrete CSS color"
+        });
+      return result;
+    };
+    const light = color("light", "white"), dark = color("dark", "black");
+    return Object.freeze({
+      executor: filterBoundaryExecutor,
+      needsBackdrop: true,
+      reverseInfluence: (output) => ({ ...output }),
+      process: (source, windows, backdrop) => {
+        if (!backdrop)
+          throw new Error(
+            "backdropContrast requires the current Canvas backdrop."
+          );
+        return processBackdropContrast(source, windows, backdrop, {
+          light,
+          dark
+        });
+      }
+    });
+  },
+  render: filterBoundaryExecutor.render
+};
+function backdropContrast(options = {}) {
+  const value = Object.freeze({ [PIBBL_FILTER_EXECUTOR]: executor });
+  definitions.set(value, Object.freeze({ ...options }));
+  return value;
+}
+export {
+  backdropContrast
+};
+//# sourceMappingURL=backdrop-contrast.js.map

package/dist/filters/backdrop-contrast.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/filters/backdrop-contrast.ts"],
+  "sourcesContent": ["import { isSignal } from \"../lib/signals/graph.js\";\nimport type { SignalValue } from \"../lib/signals/types.js\";\nimport { layoutDiagnostic } from \"../lib/style/diagnostics.js\";\nimport {\n  PIBBL_FILTER_EXECUTOR,\n  type PibblFilter,\n  type PibblFilterExecutor,\n} from \"../lib/style/filter-types.js\";\nimport { concreteColor } from \"./native-color.js\";\nimport {\n  filterBoundaryExecutor,\n  type CustomPreparedFilter,\n} from \"./filter-executor.js\";\nimport { processBackdropContrast } from \"./render-backdrop-contrast-boundary.js\";\n\n/** Two foreground colors selected per backdrop pixel. See {@link backdropContrast}. */\nexport interface PibblBackdropContrastFilterOptions {\n  /** Color drawn over dark backdrop pixels; defaults to white. See {@link SignalValue}. */\n  readonly light?: SignalValue<string>;\n  /** Color drawn over light backdrop pixels; defaults to black. See {@link SignalValue}. */\n  readonly dark?: SignalValue<string>;\n}\nconst definitions = new WeakMap<\n  PibblFilter,\n  Readonly<PibblBackdropContrastFilterOptions>\n>();\nconst executor: PibblFilterExecutor = {\n  prepare(value, property, context) {\n    const options = definitions.get(value);\n    if (!options)\n      throw new Error(\n        \"A backdropContrast filter was created by an incompatible Pibbl runtime.\",\n      );\n    const color = (key: \"light\" | \"dark\", fallback: string) => {\n      const input = options[key];\n      const value =\n        input === undefined ? fallback : isSignal(input) ? input.get() : input;\n      const result = concreteColor(value, `${property}.${key}`, context);\n      if (typeof CSS === \"undefined\" || !CSS.supports(\"color\", result))\n        throw layoutDiagnostic({\n          component: context.component,\n          property: `${property}.${key}`,\n          value,\n          algorithm: context.algorithm,\n          constraints: context.constraints,\n          reason: \"must be a supported concrete CSS color\",\n        });\n      return result;\n    };\n    const light = color(\"light\", \"white\"),\n      dark = color(\"dark\", \"black\");\n    return Object.freeze({\n      executor: filterBoundaryExecutor,\n      needsBackdrop: true,\n      reverseInfluence: (output) => ({ ...output }),\n      process: (source, windows, backdrop) => {\n        if (!backdrop)\n          throw new Error(\n            \"backdropContrast requires the current Canvas backdrop.\",\n          );\n        return processBackdropContrast(source, windows, backdrop, {\n          light,\n          dark,\n        });\n      },\n    } satisfies CustomPreparedFilter);\n  },\n  render: filterBoundaryExecutor.render,\n};\n/**\n * Recolors a receiving primitive and its descendants per pixel, using their combined alpha\n * as a mask. Chooses light below relative backdrop luminance 0.179129 and dark otherwise.\n * Samples already-painted content in the current Canvas target; transparent backdrop is\n * evaluated over white. Isolated/cached layers see their own local backdrop, not outer paint.\n * Requires OffscreenCanvas and WebGL2; performs no scene pixel readback. Geometry is unchanged.\n *\n * @param options - Optional signal-capable foreground colors; white and black by default.\n * See {@link PibblBackdropContrastFilterOptions}.\n * @returns An immutable descriptor for style.filter. See {@link PibblFilter}.\n */\nexport function backdropContrast(\n  options: PibblBackdropContrastFilterOptions = {},\n): PibblFilter {\n  const value = Object.freeze({ [PIBBL_FILTER_EXECUTOR]: executor });\n  definitions.set(value, Object.freeze({ ...options }));\n  return value;\n}\n"],
+  "mappings": "AAAA,SAAS,gBAAgB;AAEzB,SAAS,wBAAwB;AACjC;AAAA,EACE;AAAA,OAGK;AACP,SAAS,qBAAqB;AAC9B;AAAA,EACE;AAAA,OAEK;AACP,SAAS,+BAA+B;AASxC,MAAM,cAAc,oBAAI,QAGtB;AACF,MAAM,WAAgC;AAAA,EACpC,QAAQ,OAAO,UAAU,SAAS;AAChC,UAAM,UAAU,YAAY,IAAI,KAAK;AACrC,QAAI,CAAC;AACH,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AACF,UAAM,QAAQ,CAAC,KAAuB,aAAqB;AACzD,YAAM,QAAQ,QAAQ,GAAG;AACzB,YAAMA,SACJ,UAAU,SAAY,WAAW,SAAS,KAAK,IAAI,MAAM,IAAI,IAAI;AACnE,YAAM,SAAS,cAAcA,QAAO,GAAG,QAAQ,IAAI,GAAG,IAAI,OAAO;AACjE,UAAI,OAAO,QAAQ,eAAe,CAAC,IAAI,SAAS,SAAS,MAAM;AAC7D,cAAM,iBAAiB;AAAA,UACrB,WAAW,QAAQ;AAAA,UACnB,UAAU,GAAG,QAAQ,IAAI,GAAG;AAAA,UAC5B,OAAAA;AAAA,UACA,WAAW,QAAQ;AAAA,UACnB,aAAa,QAAQ;AAAA,UACrB,QAAQ;AAAA,QACV,CAAC;AACH,aAAO;AAAA,IACT;AACA,UAAM,QAAQ,MAAM,SAAS,OAAO,GAClC,OAAO,MAAM,QAAQ,OAAO;AAC9B,WAAO,OAAO,OAAO;AAAA,MACnB,UAAU;AAAA,MACV,eAAe;AAAA,MACf,kBAAkB,CAAC,YAAY,EAAE,GAAG,OAAO;AAAA,MAC3C,SAAS,CAAC,QAAQ,SAAS,aAAa;AACtC,YAAI,CAAC;AACH,gBAAM,IAAI;AAAA,YACR;AAAA,UACF;AACF,eAAO,wBAAwB,QAAQ,SAAS,UAAU;AAAA,UACxD;AAAA,UACA;AAAA,QACF,CAAC;AAAA,MACH;AAAA,IACF,CAAgC;AAAA,EAClC;AAAA,EACA,QAAQ,uBAAuB;AACjC;AAYO,SAAS,iBACd,UAA8C,CAAC,GAClC;AACb,QAAM,QAAQ,OAAO,OAAO,EAAE,CAAC,qBAAqB,GAAG,SAAS,CAAC;AACjE,cAAY,IAAI,OAAO,OAAO,OAAO,EAAE,GAAG,QAAQ,CAAC,CAAC;AACpD,SAAO;AACT;",
+  "names": ["value"]
+}

package/dist/filters/emboss-gpu.d.ts

@@ -0,0 +1,4 @@
+import { ReflectionGpu, type ReflectionGpuCallbacks } from "./reflection-gpu.js";
+export declare class EmbossGpu extends ReflectionGpu {
+    constructor(callbacks?: Readonly<ReflectionGpuCallbacks>);
+}

package/dist/filters/emboss-gpu.js

@@ -0,0 +1,39 @@
+import {
+  ReflectionGpu
+} from "./reflection-gpu.js";
+const fragment = `#version 300 es
+precision highp float;
+uniform sampler2D scene, map;
+uniform vec2 logicalOrigin, logicalSize, mapOrigin, tileSize, direction;
+uniform float rotation, opacity, depth;
+in vec2 uv;
+out vec4 outputColor;
+vec2 coordinates(vec2 logical) {
+  vec2 p=logical-mapOrigin;
+  float c=cos(rotation),s=sin(rotation);
+  return vec2(c*p.x+s*p.y,-s*p.x+c*p.y)/tileSize;
+}
+float height(vec2 p) {
+  vec4 field=texture(map,coordinates(p));
+  return dot(field.rgb,vec3(.2126,.7152,.0722))*field.a;
+}
+void main() {
+  vec4 base=texture(scene,uv);
+  vec2 p=logicalOrigin+uv*logicalSize;
+  vec2 gradient=.5*vec2(height(p+vec2(1,0))-height(p-vec2(1,0)),height(p+vec2(0,1))-height(p-vec2(0,1)));
+  vec3 normal=normalize(vec3(-depth*gradient,1.));
+  vec3 light=normalize(vec3(direction*.8,1.));
+  float shade=max(0.,dot(normal,light))/light.z;
+  // A flat map is exactly neutral. Multiply premultiplied color, preserve alpha.
+  outputColor=vec4(clamp(base.rgb*mix(1.,shade,opacity),vec3(0),vec3(base.a)),base.a);
+}
+`;
+class EmbossGpu extends ReflectionGpu {
+  constructor(callbacks = {}) {
+    super(callbacks, fragment);
+  }
+}
+export {
+  EmbossGpu
+};
+//# sourceMappingURL=emboss-gpu.js.map

package/dist/filters/emboss-gpu.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/filters/emboss-gpu.ts"],
+  "sourcesContent": ["import {\n  ReflectionGpu,\n  type ReflectionGpuCallbacks,\n} from \"./reflection-gpu.js\";\n\n// Reuses the existing GPU surface/cache ownership; this shader consumes scalar\n// height instead of the reflected-light operation's pre-encoded RG slopes.\nconst fragment = `#version 300 es\nprecision highp float;\nuniform sampler2D scene, map;\nuniform vec2 logicalOrigin, logicalSize, mapOrigin, tileSize, direction;\nuniform float rotation, opacity, depth;\nin vec2 uv;\nout vec4 outputColor;\nvec2 coordinates(vec2 logical) {\n  vec2 p=logical-mapOrigin;\n  float c=cos(rotation),s=sin(rotation);\n  return vec2(c*p.x+s*p.y,-s*p.x+c*p.y)/tileSize;\n}\nfloat height(vec2 p) {\n  vec4 field=texture(map,coordinates(p));\n  return dot(field.rgb,vec3(.2126,.7152,.0722))*field.a;\n}\nvoid main() {\n  vec4 base=texture(scene,uv);\n  vec2 p=logicalOrigin+uv*logicalSize;\n  vec2 gradient=.5*vec2(height(p+vec2(1,0))-height(p-vec2(1,0)),height(p+vec2(0,1))-height(p-vec2(0,1)));\n  vec3 normal=normalize(vec3(-depth*gradient,1.));\n  vec3 light=normalize(vec3(direction*.8,1.));\n  float shade=max(0.,dot(normal,light))/light.z;\n  // A flat map is exactly neutral. Multiply premultiplied color, preserve alpha.\n  outputColor=vec4(clamp(base.rgb*mix(1.,shade,opacity),vec3(0),vec3(base.a)),base.a);\n}\n`;\nexport class EmbossGpu extends ReflectionGpu {\n  constructor(callbacks: Readonly<ReflectionGpuCallbacks> = {}) {\n    super(callbacks, fragment);\n  }\n}\n"],
+  "mappings": "AAAA;AAAA,EACE;AAAA,OAEK;AAIP,MAAM,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA2BV,MAAM,kBAAkB,cAAc;AAAA,EAC3C,YAAY,YAA8C,CAAC,GAAG;AAC5D,UAAM,WAAW,QAAQ;AAAA,EAC3B;AACF;",
+  "names": []
+}