@pibbl/core 0.0.3-alpha.85.1 → 0.0.3-alpha.90.1

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/filter-executor.d.ts

@@ -1,6 +1,12 @@
-import type { TexturePaint } from '../lib/textures/texture-protocol.js';
-import type { FilterWindows, PixelBounds } from '../lib/filter/filter-region.js';
-import type { PibblFilterBoundaryExecutor, PreparedPibblFilter } from '../lib/style/filter-types.js';
+import type { TexturePaint } from "../lib/textures/texture-protocol.js";
+import type { Canvas } from "../lib/types.js";
+import type { FilterWindows, PixelBounds } from "../lib/filter/filter-region.js";
+import type { PibblFilterBoundaryExecutor, PreparedPibblFilter } from "../lib/style/filter-types.js";
+/** Backing-pixel projection of the already-painted current render target. */
+export interface FilterBackdrop {
+    readonly canvas: Canvas;
+    readonly transform: DOMMatrix;
+}
 /** An operation-owned pass. The shared executor knows nothing about its inputs. */
 export interface CustomPreparedFilter extends PreparedPibblFilter {
     readonly reverseInfluence: (output: Readonly<PixelBounds>, density: number) => PixelBounds;
@@ -16,6 +22,7 @@ export interface CustomPreparedFilter extends PreparedPibblFilter {
         }>;
     }>;
     readonly fuseWithPrevious?: (previous: CustomPreparedFilter) => CustomPreparedFilter | undefined;
-    readonly process?: (source: OffscreenCanvas, windows: FilterWindows) => ImageBitmap;
+    readonly needsBackdrop?: boolean;
+    readonly process?: (source: OffscreenCanvas, windows: FilterWindows, backdrop?: FilterBackdrop) => ImageBitmap;
 }
 export declare const filterBoundaryExecutor: PibblFilterBoundaryExecutor;

package/dist/filters/filter-executor.js

@@ -1,8 +1,11 @@
 import { GLOBAL_STATE } from "../lib/global-state.js";
 import { getOptionalService } from "../lib/optional-services.js";
+import { getCurrentPaintTransform } from "../lib/render-target.js";
 import { enterPrimitivePresentation } from "../lib/primitive-presentation.js";
 import { renderFilterBoundary } from "../lib/filter/render-filter-boundary.js";
-import { compileNativeFilters } from "./native-operations.js";
+import {
+  compileNativeFilters
+} from "./native-operations.js";
 import { assertNativeCanvasFilter } from "./native-canvas-filter.js";
 const SCRATCH = /* @__PURE__ */ Symbol("pibbl.filter-pass-scratch");
 class PassScratch {
@@ -24,11 +27,17 @@ class PassScratch {
     if (success || !this.committed) this.dispose();
   }
   target(index, width, height) {
-    const canvas = this.surfaces[index] ??= new OffscreenCanvas(width, height);
+    const canvas = this.surfaces[index] ??= new OffscreenCanvas(
+      width,
+      height
+    );
     if (canvas.width !== width) canvas.width = width;
     if (canvas.height !== height) canvas.height = height;
     const context = canvas.getContext("2d");
-    if (!context) throw new Error("Filter passes require an OffscreenCanvas 2D scratch target.");
+    if (!context)
+      throw new Error(
+        "Filter passes require an OffscreenCanvas 2D scratch target."
+      );
     context.reset();
     return context;
   }
@@ -60,58 +69,104 @@ const filterBoundaryExecutor = {
       }
       return;
     }
-    if (operations.every((operation) => "css" in operation)) {
-      renderFilterBoundary({ component: input.component, filters: operations, presentation: input.presentation }, input.renderSubtree);
+    if (operations.every(
+      (operation) => "css" in operation
+    )) {
+      renderFilterBoundary(
+        {
+          component: input.component,
+          filters: operations,
+          presentation: input.presentation
+        },
+        input.renderSubtree
+      );
       return;
     }
-    const bounds = operations.map((operation) => "css" in operation ? operation : {
-      executor: filterBoundaryExecutor,
-      css: () => "none",
-      reverseInfluence: operation.reverseInfluence
-    });
-    renderFilterBoundary({
-      component: input.component,
-      filters: bounds,
-      presentation: input.presentation,
-      process(source, result, windows) {
-        const instance = GLOBAL_STATE.currentPibblInstance;
-        if (!instance) throw new Error("Filter processing requires an active Pibbl instance.");
-        const scratch = getOptionalService(instance, SCRATCH, () => new PassScratch(instance));
-        scratch.used = true;
-        let current = source, pass = 0;
-        let native = [];
-        const target = () => scratch.target(pass++ % 2, source.width, source.height);
-        const applyNative = () => {
-          if (!native.length) return;
-          const context = target();
-          assertNativeCanvasFilter(context, compileNativeFilters(native, windows.density), input.component, () => {
-            for (const operation of native) if (operation.onRejected) {
-              assertNativeCanvasFilter(context, operation.css(windows.density), input.component, operation.onRejected);
-            }
-          });
-          context.drawImage(current, 0, 0);
-          current = context.canvas;
-          native = [];
-        };
-        for (const operation of operations) {
-          if ("css" in operation) {
-            native.push(operation);
-            continue;
-          }
-          applyNative();
-          const bitmap = operation.process(current, windows);
-          try {
+    const parent = operations.some(
+      (operation) => "needsBackdrop" in operation && operation.needsBackdrop
+    ) ? GLOBAL_STATE.renderContext : void 0;
+    const parentTarget = parent ? GLOBAL_STATE.renderTarget : void 0;
+    const paint = parent ? getCurrentPaintTransform() : void 0;
+    const boundaryPaint = paint && input.presentation?.transform ? paint.multiply(input.presentation.transform) : paint;
+    const bounds = operations.map(
+      (operation) => "css" in operation ? operation : {
+        executor: filterBoundaryExecutor,
+        css: () => "none",
+        reverseInfluence: operation.reverseInfluence
+      }
+    );
+    renderFilterBoundary(
+      {
+        component: input.component,
+        filters: bounds,
+        presentation: input.presentation,
+        process(source, result, windows) {
+          const instance = GLOBAL_STATE.currentPibblInstance;
+          if (!instance)
+            throw new Error(
+              "Filter processing requires an active Pibbl instance."
+            );
+          const scratch = getOptionalService(
+            instance,
+            SCRATCH,
+            () => new PassScratch(instance)
+          );
+          scratch.used = true;
+          let current = source, pass = 0;
+          let native = [];
+          const target = () => scratch.target(pass++ % 2, source.width, source.height);
+          const applyNative = () => {
+            if (!native.length) return;
             const context = target();
-            context.drawImage(bitmap, 0, 0);
+            assertNativeCanvasFilter(
+              context,
+              compileNativeFilters(native, windows.density),
+              input.component,
+              () => {
+                for (const operation of native)
+                  if (operation.onRejected) {
+                    assertNativeCanvasFilter(
+                      context,
+                      operation.css(windows.density),
+                      input.component,
+                      operation.onRejected
+                    );
+                  }
+              }
+            );
+            context.drawImage(current, 0, 0);
             current = context.canvas;
-          } finally {
-            bitmap.close();
+            native = [];
+          };
+          for (const operation of operations) {
+            if ("css" in operation) {
+              native.push(operation);
+              continue;
+            }
+            applyNative();
+            const backdrop = parent && parentTarget && boundaryPaint ? {
+              canvas: parent.canvas,
+              transform: windows.source.renderTransform.multiply(boundaryPaint.inverse()).multiply(parentTarget.inverseRenderTransform)
+            } : void 0;
+            const bitmap = operation.process(current, windows, backdrop);
+            try {
+              const context = target();
+              context.drawImage(bitmap, 0, 0);
+              current = context.canvas;
+            } finally {
+              bitmap.close();
+            }
           }
+          applyNative();
+          result.drawImage(
+            current,
+            windows.sourceToOutputX,
+            windows.sourceToOutputY
+          );
         }
-        applyNative();
-        result.drawImage(current, windows.sourceToOutputX, windows.sourceToOutputY);
-      }
-    }, input.renderSubtree);
+      },
+      input.renderSubtree
+    );
   }
 };
 export {

package/dist/filters/filter-executor.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/filters/filter-executor.ts"],
-  "sourcesContent": ["import type { TexturePaint } from '../lib/textures/texture-protocol.js';\nimport { GLOBAL_STATE } from '../lib/global-state.js';\nimport { getOptionalService } from '../lib/optional-services.js';\nimport { enterPrimitivePresentation } from '../lib/primitive-presentation.js';\nimport { renderFilterBoundary } from '../lib/filter/render-filter-boundary.js';\nimport type { FilterWindows, PixelBounds } from '../lib/filter/filter-region.js';\nimport type { PibblFilterBoundaryExecutor, PreparedPibblFilter } from '../lib/style/filter-types.js';\nimport type { PibblInstance } from '../lib/types.js';\nimport { compileNativeFilters, type NativePreparedFilter } from './native-operations.js';\nimport { assertNativeCanvasFilter } from './native-canvas-filter.js';\n\n/** An operation-owned pass. The shared executor knows nothing about its inputs. */\nexport interface CustomPreparedFilter extends PreparedPibblFilter {\n  readonly reverseInfluence: (output: Readonly<PixelBounds>, density: number) => PixelBounds;\n  /** Private fusion capability; no concrete GPU implementation enters this module. */\n  readonly textureWarp?: Readonly<{ map: TexturePaint; strength: number; region: Readonly<{x:number;y:number;width:number;height:number}> }>;\n  readonly fuseWithPrevious?: (previous: CustomPreparedFilter) => CustomPreparedFilter | undefined;\n  readonly process?: (source: OffscreenCanvas, windows: FilterWindows) => ImageBitmap;\n}\ntype Operation = NativePreparedFilter | CustomPreparedFilter;\nconst SCRATCH = Symbol('pibbl.filter-pass-scratch');\nclass PassScratch {\n  private readonly surfaces: OffscreenCanvas[] = [];\n  used = false;\n  private committed = false;\n  constructor(private readonly instance: PibblInstance) {}\n  beginRender(): void { this.used = false; }\n  endRender(success: boolean): void {\n    if (success && this.used) { this.committed = true; return; }\n    if (success || !this.committed) this.dispose();\n  }\n  target(index: number, width: number, height: number): OffscreenCanvasRenderingContext2D {\n    const canvas = this.surfaces[index] ??= new OffscreenCanvas(width, height);\n    if (canvas.width !== width) canvas.width = width;\n    if (canvas.height !== height) canvas.height = height;\n    const context = canvas.getContext('2d');\n    if (!context) throw new Error('Filter passes require an OffscreenCanvas 2D scratch target.');\n    context.reset();\n    return context;\n  }\n  dispose(): void {\n    for (const canvas of this.surfaces) { canvas.width = 0; canvas.height = 0; }\n    this.surfaces.length = 0;\n    this.instance.optionalServices.delete(SCRATCH);\n  }\n}\n\nexport const filterBoundaryExecutor: PibblFilterBoundaryExecutor = {\n  render(input) {\n    const operations: Operation[] = [];\n    for (const operation of input.filters as readonly Operation[]) {\n      if (!('css' in operation) && !operation.process) continue;\n      const previous = operations.at(-1);\n      const fused = previous && !('css' in previous) && !('css' in operation)\n        ? operation.fuseWithPrevious?.(previous) : undefined;\n      if (fused) operations[operations.length - 1] = fused;\n      else operations.push(operation);\n    }\n    if (!operations.length) {\n      const release = enterPrimitivePresentation(input.presentation);\n      try { input.renderSubtree(); } finally { release(); }\n      return;\n    }\n    if (operations.every((operation): operation is NativePreparedFilter => 'css' in operation)) {\n      renderFilterBoundary({ component: input.component, filters: operations, presentation: input.presentation }, input.renderSubtree);\n      return;\n    }\n    const bounds = operations.map(operation => 'css' in operation ? operation : {\n      executor: filterBoundaryExecutor, css: () => 'none', reverseInfluence: operation.reverseInfluence,\n    });\n    renderFilterBoundary({\n      component: input.component, filters: bounds, presentation: input.presentation,\n      process(source, result, windows) {\n        const instance = GLOBAL_STATE.currentPibblInstance;\n        if (!instance) throw new Error('Filter processing requires an active Pibbl instance.');\n        const scratch = getOptionalService(instance, SCRATCH, () => new PassScratch(instance));\n        scratch.used = true;\n        let current = source, pass = 0;\n        let native: NativePreparedFilter[] = [];\n        const target = () => scratch.target(pass++ % 2, source.width, source.height);\n        const applyNative = () => {\n          if (!native.length) return;\n          const context = target();\n          assertNativeCanvasFilter(context, compileNativeFilters(native, windows.density), input.component, () => {\n            for (const operation of native) if (operation.onRejected) {\n              assertNativeCanvasFilter(context, operation.css(windows.density), input.component, operation.onRejected);\n            }\n          });\n          context.drawImage(current, 0, 0);\n          current = context.canvas;\n          native = [];\n        };\n        for (const operation of operations) {\n          if ('css' in operation) { native.push(operation); continue; }\n          applyNative();\n          const bitmap = operation.process!(current, windows);\n          try {\n            const context = target(); context.drawImage(bitmap, 0, 0); current = context.canvas;\n          } finally { bitmap.close(); }\n        }\n        applyNative();\n        result.drawImage(current, windows.sourceToOutputX, windows.sourceToOutputY);\n      },\n    }, input.renderSubtree);\n  },\n};\n"],
-  "mappings": "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",
+  "sourcesContent": ["import type { TexturePaint } from \"../lib/textures/texture-protocol.js\";\nimport { GLOBAL_STATE } from \"../lib/global-state.js\";\nimport { getOptionalService } from \"../lib/optional-services.js\";\nimport { getCurrentPaintTransform } from \"../lib/render-target.js\";\nimport type { Canvas } from \"../lib/types.js\";\nimport { enterPrimitivePresentation } from \"../lib/primitive-presentation.js\";\nimport { renderFilterBoundary } from \"../lib/filter/render-filter-boundary.js\";\nimport type {\n  FilterWindows,\n  PixelBounds,\n} from \"../lib/filter/filter-region.js\";\nimport type {\n  PibblFilterBoundaryExecutor,\n  PreparedPibblFilter,\n} from \"../lib/style/filter-types.js\";\nimport type { PibblInstance } from \"../lib/types.js\";\nimport {\n  compileNativeFilters,\n  type NativePreparedFilter,\n} from \"./native-operations.js\";\nimport { assertNativeCanvasFilter } from \"./native-canvas-filter.js\";\n\n/** Backing-pixel projection of the already-painted current render target. */\nexport interface FilterBackdrop {\n  readonly canvas: Canvas;\n  readonly transform: DOMMatrix;\n}\n\n/** An operation-owned pass. The shared executor knows nothing about its inputs. */\nexport interface CustomPreparedFilter extends PreparedPibblFilter {\n  readonly reverseInfluence: (\n    output: Readonly<PixelBounds>,\n    density: number,\n  ) => PixelBounds;\n  /** Private fusion capability; no concrete GPU implementation enters this module. */\n  readonly textureWarp?: Readonly<{\n    map: TexturePaint;\n    strength: number;\n    region: Readonly<{ x: number; y: number; width: number; height: number }>;\n  }>;\n  readonly fuseWithPrevious?: (\n    previous: CustomPreparedFilter,\n  ) => CustomPreparedFilter | undefined;\n  readonly needsBackdrop?: boolean;\n  readonly process?: (\n    source: OffscreenCanvas,\n    windows: FilterWindows,\n    backdrop?: FilterBackdrop,\n  ) => ImageBitmap;\n}\ntype Operation = NativePreparedFilter | CustomPreparedFilter;\nconst SCRATCH = Symbol(\"pibbl.filter-pass-scratch\");\nclass PassScratch {\n  private readonly surfaces: OffscreenCanvas[] = [];\n  used = false;\n  private committed = false;\n  constructor(private readonly instance: PibblInstance) {}\n  beginRender(): void {\n    this.used = false;\n  }\n  endRender(success: boolean): void {\n    if (success && this.used) {\n      this.committed = true;\n      return;\n    }\n    if (success || !this.committed) this.dispose();\n  }\n  target(\n    index: number,\n    width: number,\n    height: number,\n  ): OffscreenCanvasRenderingContext2D {\n    const canvas = (this.surfaces[index] ??= new OffscreenCanvas(\n      width,\n      height,\n    ));\n    if (canvas.width !== width) canvas.width = width;\n    if (canvas.height !== height) canvas.height = height;\n    const context = canvas.getContext(\"2d\");\n    if (!context)\n      throw new Error(\n        \"Filter passes require an OffscreenCanvas 2D scratch target.\",\n      );\n    context.reset();\n    return context;\n  }\n  dispose(): void {\n    for (const canvas of this.surfaces) {\n      canvas.width = 0;\n      canvas.height = 0;\n    }\n    this.surfaces.length = 0;\n    this.instance.optionalServices.delete(SCRATCH);\n  }\n}\n\nexport const filterBoundaryExecutor: PibblFilterBoundaryExecutor = {\n  render(input) {\n    const operations: Operation[] = [];\n    for (const operation of input.filters as readonly Operation[]) {\n      if (!(\"css\" in operation) && !operation.process) continue;\n      const previous = operations.at(-1);\n      const fused =\n        previous && !(\"css\" in previous) && !(\"css\" in operation)\n          ? operation.fuseWithPrevious?.(previous)\n          : undefined;\n      if (fused) operations[operations.length - 1] = fused;\n      else operations.push(operation);\n    }\n    if (!operations.length) {\n      const release = enterPrimitivePresentation(input.presentation);\n      try {\n        input.renderSubtree();\n      } finally {\n        release();\n      }\n      return;\n    }\n    if (\n      operations.every(\n        (operation): operation is NativePreparedFilter => \"css\" in operation,\n      )\n    ) {\n      renderFilterBoundary(\n        {\n          component: input.component,\n          filters: operations,\n          presentation: input.presentation,\n        },\n        input.renderSubtree,\n      );\n      return;\n    }\n    // Snapshot the parent projection before capture switches the current render target.\n    const parent = operations.some(\n      (operation) => \"needsBackdrop\" in operation && operation.needsBackdrop,\n    )\n      ? GLOBAL_STATE.renderContext\n      : undefined;\n    const parentTarget = parent ? GLOBAL_STATE.renderTarget : undefined;\n    const paint = parent ? getCurrentPaintTransform() : undefined;\n    const boundaryPaint =\n      paint && input.presentation?.transform\n        ? paint.multiply(input.presentation.transform)\n        : paint;\n    const bounds = operations.map((operation) =>\n      \"css\" in operation\n        ? operation\n        : {\n            executor: filterBoundaryExecutor,\n            css: () => \"none\",\n            reverseInfluence: operation.reverseInfluence,\n          },\n    );\n    renderFilterBoundary(\n      {\n        component: input.component,\n        filters: bounds,\n        presentation: input.presentation,\n        process(source, result, windows) {\n          const instance = GLOBAL_STATE.currentPibblInstance;\n          if (!instance)\n            throw new Error(\n              \"Filter processing requires an active Pibbl instance.\",\n            );\n          const scratch = getOptionalService(\n            instance,\n            SCRATCH,\n            () => new PassScratch(instance),\n          );\n          scratch.used = true;\n          let current = source,\n            pass = 0;\n          let native: NativePreparedFilter[] = [];\n          const target = () =>\n            scratch.target(pass++ % 2, source.width, source.height);\n          const applyNative = () => {\n            if (!native.length) return;\n            const context = target();\n            assertNativeCanvasFilter(\n              context,\n              compileNativeFilters(native, windows.density),\n              input.component,\n              () => {\n                for (const operation of native)\n                  if (operation.onRejected) {\n                    assertNativeCanvasFilter(\n                      context,\n                      operation.css(windows.density),\n                      input.component,\n                      operation.onRejected,\n                    );\n                  }\n              },\n            );\n            context.drawImage(current, 0, 0);\n            current = context.canvas;\n            native = [];\n          };\n          for (const operation of operations) {\n            if (\"css\" in operation) {\n              native.push(operation);\n              continue;\n            }\n            applyNative();\n            const backdrop =\n              parent && parentTarget && boundaryPaint\n                ? {\n                    canvas: parent.canvas,\n                    transform: windows.source.renderTransform\n                      .multiply(boundaryPaint.inverse())\n                      .multiply(parentTarget.inverseRenderTransform),\n                  }\n                : undefined;\n            const bitmap = operation.process!(current, windows, backdrop);\n            try {\n              const context = target();\n              context.drawImage(bitmap, 0, 0);\n              current = context.canvas;\n            } finally {\n              bitmap.close();\n            }\n          }\n          applyNative();\n          result.drawImage(\n            current,\n            windows.sourceToOutputX,\n            windows.sourceToOutputY,\n          );\n        },\n      },\n      input.renderSubtree,\n    );\n  },\n};\n"],
+  "mappings": "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",
   "names": []
 }

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

@@ -0,0 +1,31 @@
+import type { PibblInstance } from "../lib/types.js";
+import type { FilterWindows } from "../lib/filter/filter-region.js";
+import type { FilterBackdrop } from "./filter-executor.js";
+import { BackdropContrastGpu } from "./backdrop-contrast-gpu.js";
+declare class BackdropContrastService {
+    private readonly instance;
+    readonly gpu: BackdropContrastGpu;
+    private readonly backdrop;
+    private readonly palette;
+    private revision;
+    private paletteRevision;
+    private colors;
+    private committed;
+    private disposed;
+    used: boolean;
+    constructor(instance: PibblInstance);
+    beginRender(): void;
+    endRender(success: boolean): void;
+    apply(source: OffscreenCanvas, windows: FilterWindows, input: FilterBackdrop, colors: Readonly<{
+        light: string;
+        dark: string;
+    }>): ImageBitmap;
+    dispose(): void;
+}
+/** @internal Read-only ownership evidence; never creates resources. */
+export declare function peekBackdropContrastService(instance: PibblInstance): BackdropContrastService | undefined;
+export declare function processBackdropContrast(source: OffscreenCanvas, windows: FilterWindows, backdrop: FilterBackdrop, colors: Readonly<{
+    light: string;
+    dark: string;
+}>): ImageBitmap;
+export {};

package/dist/filters/render-backdrop-contrast-boundary.js

@@ -0,0 +1,116 @@
+import { GLOBAL_STATE } from "../lib/global-state.js";
+import { getOptionalService } from "../lib/optional-services.js";
+import { update } from "../lib/update.js";
+import { BackdropContrastGpu } from "./backdrop-contrast-gpu.js";
+const SERVICE = /* @__PURE__ */ Symbol("pibbl.backdrop-contrast");
+class BackdropContrastService {
+  constructor(instance) {
+    this.instance = instance;
+    this.gpu = new BackdropContrastGpu({
+      onContextRestored: () => {
+        if (!this.disposed && !instance.mainTeardowns.closed)
+          update(instance.canvas, void 0, true);
+      }
+    });
+  }
+  instance;
+  gpu;
+  backdrop = new OffscreenCanvas(1, 1);
+  palette = new OffscreenCanvas(2, 1);
+  revision = 0;
+  paletteRevision = 0;
+  colors = "";
+  committed = false;
+  disposed = false;
+  used = false;
+  beginRender() {
+    this.used = false;
+  }
+  endRender(success) {
+    if (success && this.used) {
+      this.committed = true;
+      return;
+    }
+    if (success || !this.committed) this.dispose();
+  }
+  apply(source, windows, input, colors) {
+    this.used = true;
+    if (this.backdrop.width !== source.width)
+      this.backdrop.width = source.width;
+    if (this.backdrop.height !== source.height)
+      this.backdrop.height = source.height;
+    const context = this.backdrop.getContext("2d");
+    if (!context)
+      throw new Error("backdropContrast requires OffscreenCanvas 2D.");
+    context.reset();
+    context.setTransform(input.transform);
+    context.drawImage(input.canvas, 0, 0);
+    const colorKey = JSON.stringify([colors.light, colors.dark]);
+    if (this.colors !== colorKey) {
+      const palette = this.palette.getContext("2d");
+      if (!palette)
+        throw new Error("backdropContrast colors require OffscreenCanvas 2D.");
+      palette.reset();
+      palette.fillStyle = colors.light;
+      palette.fillRect(0, 0, 1, 1);
+      palette.fillStyle = colors.dark;
+      palette.fillRect(1, 0, 1, 1);
+      this.colors = colorKey;
+      this.paletteRevision++;
+    }
+    const raster = (canvas, revision) => ({
+      source: canvas,
+      width: canvas.width,
+      height: canvas.height,
+      resource: canvas,
+      revision,
+      placement: { mode: "stretch" }
+    });
+    const region = windows.source.logicalBounds;
+    return this.gpu.apply(
+      source,
+      raster(this.backdrop, ++this.revision),
+      { raster: raster(this.palette, this.paletteRevision) },
+      { opacity: 1, threshold: 0, softness: 1, direction: [0, 1] },
+      {
+        originX: region.x,
+        originY: region.y,
+        density: windows.density,
+        region
+      }
+    );
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.gpu.dispose();
+    this.backdrop.width = this.backdrop.height = this.palette.width = this.palette.height = 0;
+    this.instance.optionalServices.delete(SERVICE);
+  }
+}
+function peekBackdropContrastService(instance) {
+  return instance.optionalServices.get(SERVICE);
+}
+function processBackdropContrast(source, windows, backdrop, colors) {
+  const instance = GLOBAL_STATE.currentPibblInstance;
+  if (!instance)
+    throw new Error("backdropContrast requires an active Pibbl instance.");
+  const service = getOptionalService(
+    instance,
+    SERVICE,
+    () => new BackdropContrastService(instance)
+  );
+  try {
+    return service.apply(source, windows, backdrop, colors);
+  } catch (error) {
+    throw new Error(
+      `backdropContrast processing failed: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error }
+    );
+  }
+}
+export {
+  peekBackdropContrastService,
+  processBackdropContrast
+};
+//# sourceMappingURL=render-backdrop-contrast-boundary.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/filters/render-backdrop-contrast-boundary.ts"],
+  "sourcesContent": ["import { GLOBAL_STATE } from \"../lib/global-state.js\";\nimport { getOptionalService } from \"../lib/optional-services.js\";\nimport { update } from \"../lib/update.js\";\nimport type { PibblInstance } from \"../lib/types.js\";\nimport type { FilterWindows } from \"../lib/filter/filter-region.js\";\nimport type { FilterBackdrop } from \"./filter-executor.js\";\nimport type { BorrowedTextureRaster } from \"../lib/textures/texture-protocol.js\";\nimport { BackdropContrastGpu } from \"./backdrop-contrast-gpu.js\";\n\nconst SERVICE = Symbol(\"pibbl.backdrop-contrast\");\nclass BackdropContrastService {\n  readonly gpu: BackdropContrastGpu;\n  private readonly backdrop = new OffscreenCanvas(1, 1);\n  private readonly palette = new OffscreenCanvas(2, 1);\n  private revision = 0;\n  private paletteRevision = 0;\n  private colors = \"\";\n  private committed = false;\n  private disposed = false;\n  used = false;\n  constructor(private readonly instance: PibblInstance) {\n    this.gpu = new BackdropContrastGpu({\n      onContextRestored: () => {\n        if (!this.disposed && !instance.mainTeardowns.closed)\n          update(instance.canvas, undefined, true);\n      },\n    });\n  }\n  beginRender(): void {\n    this.used = false;\n  }\n  endRender(success: boolean): void {\n    if (success && this.used) {\n      this.committed = true;\n      return;\n    }\n    if (success || !this.committed) this.dispose();\n  }\n  apply(\n    source: OffscreenCanvas,\n    windows: FilterWindows,\n    input: FilterBackdrop,\n    colors: Readonly<{ light: string; dark: string }>,\n  ): ImageBitmap {\n    this.used = true;\n    if (this.backdrop.width !== source.width)\n      this.backdrop.width = source.width;\n    if (this.backdrop.height !== source.height)\n      this.backdrop.height = source.height;\n    const context = this.backdrop.getContext(\"2d\");\n    if (!context)\n      throw new Error(\"backdropContrast requires OffscreenCanvas 2D.\");\n    context.reset();\n    context.setTransform(input.transform);\n    context.drawImage(input.canvas, 0, 0);\n    const colorKey = JSON.stringify([colors.light, colors.dark]);\n    if (this.colors !== colorKey) {\n      const palette = this.palette.getContext(\"2d\");\n      if (!palette)\n        throw new Error(\"backdropContrast colors require OffscreenCanvas 2D.\");\n      palette.reset();\n      palette.fillStyle = colors.light;\n      palette.fillRect(0, 0, 1, 1);\n      palette.fillStyle = colors.dark;\n      palette.fillRect(1, 0, 1, 1);\n      this.colors = colorKey;\n      this.paletteRevision++;\n    }\n    const raster = (\n      canvas: OffscreenCanvas,\n      revision: number,\n    ): BorrowedTextureRaster => ({\n      source: canvas,\n      width: canvas.width,\n      height: canvas.height,\n      resource: canvas,\n      revision,\n      placement: { mode: \"stretch\" },\n    });\n    const region = windows.source.logicalBounds;\n    return this.gpu.apply(\n      source,\n      raster(this.backdrop, ++this.revision),\n      { raster: raster(this.palette, this.paletteRevision) },\n      { opacity: 1, threshold: 0, softness: 1, direction: [0, 1] },\n      {\n        originX: region.x,\n        originY: region.y,\n        density: windows.density,\n        region,\n      },\n    );\n  }\n  dispose(): void {\n    if (this.disposed) return;\n    this.disposed = true;\n    this.gpu.dispose();\n    this.backdrop.width =\n      this.backdrop.height =\n      this.palette.width =\n      this.palette.height =\n        0;\n    this.instance.optionalServices.delete(SERVICE);\n  }\n}\n/** @internal Read-only ownership evidence; never creates resources. */\nexport function peekBackdropContrastService(\n  instance: PibblInstance,\n): BackdropContrastService | undefined {\n  return instance.optionalServices.get(SERVICE) as\n    BackdropContrastService | undefined;\n}\nexport function processBackdropContrast(\n  source: OffscreenCanvas,\n  windows: FilterWindows,\n  backdrop: FilterBackdrop,\n  colors: Readonly<{ light: string; dark: string }>,\n): ImageBitmap {\n  const instance = GLOBAL_STATE.currentPibblInstance;\n  if (!instance)\n    throw new Error(\"backdropContrast requires an active Pibbl instance.\");\n  const service = getOptionalService(\n    instance,\n    SERVICE,\n    () => new BackdropContrastService(instance),\n  );\n  try {\n    return service.apply(source, windows, backdrop, colors);\n  } catch (error) {\n    throw new Error(\n      `backdropContrast processing failed: ${error instanceof Error ? error.message : String(error)}`,\n      { cause: error },\n    );\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/filters.d.ts

@@ -1,7 +1,9 @@
-export { blur, brightness, contrast, dropShadow, grayscale, hueRotate, invert, opacity, saturate, sepia, } from './filters/native.js';
-export { displacement } from './filters/displacement.js';
-export type { PibblFilter, PibblBlurFilterOptions, PibblBrightnessFilterOptions, PibblContrastFilterOptions, PibblDropShadowFilterOptions, PibblGrayscaleFilterOptions, PibblHueRotateFilterOptions, PibblInvertFilterOptions, PibblOpacityFilterOptions, PibblSaturateFilterOptions, PibblSepiaFilterOptions, PibblDisplacementFilterOptions, } from './lib/style/filter-types.js';
-export { reflectedLight } from './filters/reflected-light.js';
-export type { PibblReflectedLightFilterOptions, PibblReflectedLightSource } from './lib/style/filter-types.js';
-export { emboss } from './filters/emboss.js';
-export type { PibblEmbossFilterOptions } from './filters/emboss.js';
+export { blur, brightness, contrast, dropShadow, grayscale, hueRotate, invert, opacity, saturate, sepia, } from "./filters/native.js";
+export { displacement } from "./filters/displacement.js";
+export type { PibblFilter, PibblBlurFilterOptions, PibblBrightnessFilterOptions, PibblContrastFilterOptions, PibblDropShadowFilterOptions, PibblGrayscaleFilterOptions, PibblHueRotateFilterOptions, PibblInvertFilterOptions, PibblOpacityFilterOptions, PibblSaturateFilterOptions, PibblSepiaFilterOptions, PibblDisplacementFilterOptions, } from "./lib/style/filter-types.js";
+export { reflectedLight } from "./filters/reflected-light.js";
+export type { PibblReflectedLightFilterOptions, PibblReflectedLightSource, } from "./lib/style/filter-types.js";
+export { emboss } from "./filters/emboss.js";
+export type { PibblEmbossFilterOptions } from "./filters/emboss.js";
+export { backdropContrast } from "./filters/backdrop-contrast.js";
+export type { PibblBackdropContrastFilterOptions } from "./filters/backdrop-contrast.js";

package/dist/filters.js

@@ -13,7 +13,9 @@ import {
 import { displacement } from "./filters/displacement.js";
 import { reflectedLight } from "./filters/reflected-light.js";
 import { emboss } from "./filters/emboss.js";
+import { backdropContrast } from "./filters/backdrop-contrast.js";
 export {
+  backdropContrast,
   blur,
   brightness,
   contrast,