@pibbl/core 0.0.1

package/dist/lib/filter/filter-surface-pool.d.ts

@@ -0,0 +1,38 @@
+import type { RenderTargetSnapshot } from '../render-target.js';
+import type { FilterWindows } from './filter-region.js';
+export interface FilterSurface {
+    readonly canvas: OffscreenCanvas;
+    readonly context: OffscreenCanvasRenderingContext2D;
+    readonly target: RenderTargetSnapshot;
+}
+export interface FilterSurfacePairLease {
+    readonly source: FilterSurface;
+    readonly result: FilterSurface;
+    release(): void;
+}
+export interface FilterSurfacePoolSnapshot {
+    readonly surfaceSlots: number;
+    readonly createdSurfaceSlots: number;
+    readonly activePairs: number;
+    readonly peakActivePairs: number;
+    readonly pairCheckouts: number;
+    readonly pairReturns: number;
+    readonly resized: number;
+    readonly releasedSurfaceSlots: number;
+}
+export declare class FilterSurfacePool {
+    private slots;
+    private activePairs;
+    private peakActivePairs;
+    private pairCheckouts;
+    private pairReturns;
+    private createdSurfaceSlots;
+    private resized;
+    private releasedSurfaceSlots;
+    private surfaceSlots;
+    private disposed;
+    checkoutPair(windows: FilterWindows): FilterSurfacePairLease;
+    snapshot(): FilterSurfacePoolSnapshot;
+    dispose(): void;
+    private setupSlot;
+}

package/dist/lib/filter/filter-surface-pool.js

@@ -0,0 +1,252 @@
+import { GLOBAL_STATE } from "../global-state.js";
+import { layoutDiagnostic } from "../style/diagnostics.js";
+import { resetNativeCanvasFilter } from "../../filters/native-canvas-filter.js";
+const MAX_UNSIGNED_LONG = 4294967295;
+class FilterSurfacePool {
+  slots = [];
+  activePairs = 0;
+  peakActivePairs = 0;
+  pairCheckouts = 0;
+  pairReturns = 0;
+  createdSurfaceSlots = 0;
+  resized = 0;
+  releasedSurfaceSlots = 0;
+  surfaceSlots = 0;
+  disposed = false;
+  checkoutPair(windows) {
+    if (this.disposed) {
+      throw new Error("Cannot check out filter surfaces from a disposed pool.");
+    }
+    validateWindow(windows.source, "source");
+    validateWindow(windows.output, "result");
+    const depth = this.activePairs;
+    const sourceIndex = 2 * depth;
+    const resultIndex = sourceIndex + 1;
+    const sourceSlot = this.slots[sourceIndex];
+    const resultSlot = this.slots[resultIndex];
+    this.activePairs = depth + 1;
+    let source;
+    let result;
+    try {
+      source = this.setupSlot(sourceIndex, sourceSlot, windows.source, "source");
+      result = this.setupSlot(resultIndex, resultSlot, windows.output, "result");
+    } catch (error) {
+      this.activePairs = depth;
+      throw error;
+    }
+    this.pairCheckouts += 1;
+    this.peakActivePairs = Math.max(this.peakActivePairs, this.activePairs);
+    let released = false;
+    return {
+      source,
+      result,
+      release: () => {
+        if (released) return;
+        if (this.disposed) {
+          released = true;
+          return;
+        }
+        if (this.activePairs !== depth + 1) {
+          throw new Error(
+            "Filter surface pairs must be released in strict LIFO order."
+          );
+        }
+        released = true;
+        this.activePairs = depth;
+        this.pairReturns += 1;
+        scrubIdleSurface(source);
+        scrubIdleSurface(result);
+      }
+    };
+  }
+  snapshot() {
+    return {
+      surfaceSlots: this.surfaceSlots,
+      createdSurfaceSlots: this.createdSurfaceSlots,
+      activePairs: this.activePairs,
+      peakActivePairs: this.peakActivePairs,
+      pairCheckouts: this.pairCheckouts,
+      pairReturns: this.pairReturns,
+      resized: this.resized,
+      releasedSurfaceSlots: this.releasedSurfaceSlots
+    };
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.pairReturns += this.activePairs;
+    this.activePairs = 0;
+    this.releasedSurfaceSlots += this.surfaceSlots;
+    this.surfaceSlots = 0;
+    this.slots = [];
+  }
+  setupSlot(index, existing, window, role) {
+    if (!existing) {
+      const created = createSlot(window, role);
+      this.slots[index] = created;
+      this.createdSurfaceSlots += 1;
+      this.surfaceSlots += 1;
+      return created;
+    }
+    const { canvas, context } = existing;
+    const dimensionsChanged = canvas.width !== window.backingWidth || canvas.height !== window.backingHeight;
+    if (dimensionsChanged) {
+      try {
+        if (canvas.width !== window.backingWidth) {
+          canvas.width = window.backingWidth;
+        }
+        if (canvas.height !== window.backingHeight) {
+          canvas.height = window.backingHeight;
+        }
+      } catch (error) {
+        throw surfaceError(role, window, "could not resize its OffscreenCanvas", error);
+      }
+      installDefaults(context);
+      context.save();
+      this.resized += 1;
+    } else {
+      context.restore();
+      context.save();
+      context.setTransform(1, 0, 0, 1, 0, 0);
+      context.clearRect(0, 0, canvas.width, canvas.height);
+      context.beginPath();
+      installDefaultState(context);
+    }
+    existing.target = targetFor(window);
+    return existing;
+  }
+}
+function createSlot(window, role) {
+  if (typeof OffscreenCanvas === "undefined") {
+    throw surfaceError(role, window, "requires browser OffscreenCanvas support");
+  }
+  let canvas;
+  try {
+    canvas = new OffscreenCanvas(window.backingWidth, window.backingHeight);
+  } catch (error) {
+    throw surfaceError(role, window, "could not allocate its OffscreenCanvas", error);
+  }
+  let context;
+  try {
+    context = canvas.getContext("2d");
+  } catch (error) {
+    throw surfaceError(
+      role,
+      window,
+      "could not acquire its OffscreenCanvas 2D context",
+      error
+    );
+  }
+  if (!context) {
+    throw surfaceError(role, window, "could not acquire its OffscreenCanvas 2D context");
+  }
+  installDefaults(context);
+  context.save();
+  return { canvas, context, target: targetFor(window) };
+}
+function installDefaults(context) {
+  context.setTransform(1, 0, 0, 1, 0, 0);
+  context.beginPath();
+  installDefaultState(context);
+}
+function installDefaultState(context) {
+  context.direction = "inherit";
+  context.fillStyle = "#000000";
+  resetIfSupported(context);
+  context.font = "10px sans-serif";
+  setIfPresent(context, "fontKerning", "auto");
+  setIfPresent(context, "fontStretch", "normal");
+  setIfPresent(context, "fontVariantCaps", "normal");
+  context.globalAlpha = 1;
+  context.globalCompositeOperation = "source-over";
+  context.imageSmoothingEnabled = true;
+  context.imageSmoothingQuality = "low";
+  setIfPresent(context, "letterSpacing", "0px");
+  context.lineCap = "butt";
+  context.setLineDash([]);
+  context.lineDashOffset = 0;
+  context.lineJoin = "miter";
+  context.lineWidth = 1;
+  context.miterLimit = 10;
+  context.shadowBlur = 0;
+  context.shadowColor = "rgba(0, 0, 0, 0)";
+  context.shadowOffsetX = 0;
+  context.shadowOffsetY = 0;
+  context.strokeStyle = "#000000";
+  context.textAlign = "start";
+  context.textBaseline = "alphabetic";
+  setIfPresent(context, "textRendering", "auto");
+  setIfPresent(context, "wordSpacing", "0px");
+}
+function scrubIdleSurface(surface) {
+  const { context } = surface;
+  try {
+    context.fillStyle = "#000000";
+  } catch {
+  }
+  try {
+    context.strokeStyle = "#000000";
+  } catch {
+  }
+  resetIfSupported(context);
+}
+function resetIfSupported(context) {
+  try {
+    resetNativeCanvasFilter(context, "filter surface");
+  } catch {
+  }
+}
+function setIfPresent(context, property, value) {
+  if (property in context) {
+    context[property] = value;
+  }
+}
+function targetFor(window) {
+  return {
+    logicalBounds: window.logicalBounds,
+    backingWidth: window.backingWidth,
+    backingHeight: window.backingHeight,
+    renderTransform: window.renderTransform,
+    inverseRenderTransform: window.inverseRenderTransform
+  };
+}
+function validateWindow(window, role) {
+  const { backingWidth: width, backingHeight: height } = window;
+  if (!Number.isSafeInteger(width) || !Number.isSafeInteger(height) || width <= 0 || height <= 0 || width > MAX_UNSIGNED_LONG || height > MAX_UNSIGNED_LONG) {
+    throw surfaceError(
+      role,
+      window,
+      `backing dimensions must be positive unsigned-long integers no greater than ${MAX_UNSIGNED_LONG}`
+    );
+  }
+  if (!Number.isSafeInteger(width * height)) {
+    throw surfaceError(
+      role,
+      window,
+      "backing area must remain a finite safe integer"
+    );
+  }
+}
+function surfaceError(role, window, reason, cause) {
+  const type = GLOBAL_STATE.componentRefs?.element.type;
+  const component = typeof type === "function" && type.name ? type.name : "filter boundary";
+  const diagnostic = layoutDiagnostic({
+    component,
+    property: `filter.${role}Surface`,
+    value: {
+      logicalBounds: window.logicalBounds,
+      backingWidth: window.backingWidth,
+      backingHeight: window.backingHeight
+    },
+    algorithm: "filter-capture",
+    reason
+  });
+  if (cause !== void 0) {
+    diagnostic.cause = cause;
+  }
+  return diagnostic;
+}
+export {
+  FilterSurfacePool
+};
+//# sourceMappingURL=filter-surface-pool.js.map

package/dist/lib/filter/filter-surface-pool.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/filter/filter-surface-pool.ts"],
+  "sourcesContent": ["import { GLOBAL_STATE } from '../global-state.js';\nimport type { RenderTargetSnapshot } from '../render-target.js';\nimport { layoutDiagnostic } from '../style/diagnostics.js';\nimport { resetNativeCanvasFilter } from '../../filters/native-canvas-filter.js';\nimport type { FilterPixelWindow, FilterWindows } from './filter-region.js';\n\nconst MAX_UNSIGNED_LONG = 0xffff_ffff;\n\nexport interface FilterSurface {\n  readonly canvas: OffscreenCanvas;\n  readonly context: OffscreenCanvasRenderingContext2D;\n  readonly target: RenderTargetSnapshot;\n}\n\nexport interface FilterSurfacePairLease {\n  readonly source: FilterSurface;\n  readonly result: FilterSurface;\n  release(): void;\n}\n\nexport interface FilterSurfacePoolSnapshot {\n  readonly surfaceSlots: number;\n  readonly createdSurfaceSlots: number;\n  readonly activePairs: number;\n  readonly peakActivePairs: number;\n  readonly pairCheckouts: number;\n  readonly pairReturns: number;\n  readonly resized: number;\n  readonly releasedSurfaceSlots: number;\n}\n\ninterface FilterSurfaceSlot extends FilterSurface {\n  target: RenderTargetSnapshot;\n}\n\nexport class FilterSurfacePool {\n  private slots: Array<FilterSurfaceSlot | undefined> = [];\n  private activePairs = 0;\n  private peakActivePairs = 0;\n  private pairCheckouts = 0;\n  private pairReturns = 0;\n  private createdSurfaceSlots = 0;\n  private resized = 0;\n  private releasedSurfaceSlots = 0;\n  private surfaceSlots = 0;\n  private disposed = false;\n\n  checkoutPair(windows: FilterWindows): FilterSurfacePairLease {\n    if (this.disposed) {\n      throw new Error('Cannot check out filter surfaces from a disposed pool.');\n    }\n    validateWindow(windows.source, 'source');\n    validateWindow(windows.output, 'result');\n\n    const depth = this.activePairs;\n    const sourceIndex = 2 * depth;\n    const resultIndex = sourceIndex + 1;\n    const sourceSlot = this.slots[sourceIndex];\n    const resultSlot = this.slots[resultIndex];\n    this.activePairs = depth + 1;\n\n    let source: FilterSurfaceSlot;\n    let result: FilterSurfaceSlot;\n    try {\n      source = this.setupSlot(sourceIndex, sourceSlot, windows.source, 'source');\n      result = this.setupSlot(resultIndex, resultSlot, windows.output, 'result');\n    } catch (error) {\n      this.activePairs = depth;\n      throw error;\n    }\n\n    this.pairCheckouts += 1;\n    this.peakActivePairs = Math.max(this.peakActivePairs, this.activePairs);\n    let released = false;\n    return {\n      source,\n      result,\n      release: () => {\n        if (released) return;\n        if (this.disposed) {\n          released = true;\n          return;\n        }\n        if (this.activePairs !== depth + 1) {\n          throw new Error(\n            'Filter surface pairs must be released in strict LIFO order.',\n          );\n        }\n        released = true;\n        this.activePairs = depth;\n        this.pairReturns += 1;\n        scrubIdleSurface(source);\n        scrubIdleSurface(result);\n      },\n    };\n  }\n\n  snapshot(): FilterSurfacePoolSnapshot {\n    return {\n      surfaceSlots: this.surfaceSlots,\n      createdSurfaceSlots: this.createdSurfaceSlots,\n      activePairs: this.activePairs,\n      peakActivePairs: this.peakActivePairs,\n      pairCheckouts: this.pairCheckouts,\n      pairReturns: this.pairReturns,\n      resized: this.resized,\n      releasedSurfaceSlots: this.releasedSurfaceSlots,\n    };\n  }\n\n  dispose(): void {\n    if (this.disposed) return;\n    this.disposed = true;\n    this.pairReturns += this.activePairs;\n    this.activePairs = 0;\n    this.releasedSurfaceSlots += this.surfaceSlots;\n    this.surfaceSlots = 0;\n    this.slots = [];\n  }\n\n  private setupSlot(\n    index: number,\n    existing: FilterSurfaceSlot | undefined,\n    window: FilterPixelWindow,\n    role: 'source' | 'result',\n  ): FilterSurfaceSlot {\n    if (!existing) {\n      const created = createSlot(window, role);\n      this.slots[index] = created;\n      this.createdSurfaceSlots += 1;\n      this.surfaceSlots += 1;\n      return created;\n    }\n\n    const { canvas, context } = existing;\n    const dimensionsChanged =\n      canvas.width !== window.backingWidth ||\n      canvas.height !== window.backingHeight;\n    if (dimensionsChanged) {\n      try {\n        if (canvas.width !== window.backingWidth) {\n          canvas.width = window.backingWidth;\n        }\n        if (canvas.height !== window.backingHeight) {\n          canvas.height = window.backingHeight;\n        }\n      } catch (error) {\n        throw surfaceError(role, window, 'could not resize its OffscreenCanvas', error);\n      }\n      installDefaults(context);\n      context.save();\n      this.resized += 1;\n    } else {\n      context.restore();\n      context.save();\n      context.setTransform(1, 0, 0, 1, 0, 0);\n      context.clearRect(0, 0, canvas.width, canvas.height);\n      context.beginPath();\n      installDefaultState(context);\n    }\n    existing.target = targetFor(window);\n    return existing;\n  }\n}\n\nfunction createSlot(\n  window: FilterPixelWindow,\n  role: 'source' | 'result',\n): FilterSurfaceSlot {\n  if (typeof OffscreenCanvas === 'undefined') {\n    throw surfaceError(role, window, 'requires browser OffscreenCanvas support');\n  }\n\n  let canvas: OffscreenCanvas;\n  try {\n    canvas = new OffscreenCanvas(window.backingWidth, window.backingHeight);\n  } catch (error) {\n    throw surfaceError(role, window, 'could not allocate its OffscreenCanvas', error);\n  }\n  let context: OffscreenCanvasRenderingContext2D | null;\n  try {\n    context = canvas.getContext('2d');\n  } catch (error) {\n    throw surfaceError(\n      role,\n      window,\n      'could not acquire its OffscreenCanvas 2D context',\n      error,\n    );\n  }\n  if (!context) {\n    throw surfaceError(role, window, 'could not acquire its OffscreenCanvas 2D context');\n  }\n  installDefaults(context);\n  context.save();\n  return { canvas, context, target: targetFor(window) };\n}\n\nfunction installDefaults(context: OffscreenCanvasRenderingContext2D): void {\n  context.setTransform(1, 0, 0, 1, 0, 0);\n  context.beginPath();\n  installDefaultState(context);\n}\n\nfunction installDefaultState(\n  context: OffscreenCanvasRenderingContext2D,\n): void {\n  context.direction = 'inherit';\n  context.fillStyle = '#000000';\n  resetIfSupported(context);\n  context.font = '10px sans-serif';\n  setIfPresent(context, 'fontKerning', 'auto');\n  setIfPresent(context, 'fontStretch', 'normal');\n  setIfPresent(context, 'fontVariantCaps', 'normal');\n  context.globalAlpha = 1;\n  context.globalCompositeOperation = 'source-over';\n  context.imageSmoothingEnabled = true;\n  context.imageSmoothingQuality = 'low';\n  setIfPresent(context, 'letterSpacing', '0px');\n  context.lineCap = 'butt';\n  context.setLineDash([]);\n  context.lineDashOffset = 0;\n  context.lineJoin = 'miter';\n  context.lineWidth = 1;\n  context.miterLimit = 10;\n  context.shadowBlur = 0;\n  context.shadowColor = 'rgba(0, 0, 0, 0)';\n  context.shadowOffsetX = 0;\n  context.shadowOffsetY = 0;\n  context.strokeStyle = '#000000';\n  context.textAlign = 'start';\n  context.textBaseline = 'alphabetic';\n  setIfPresent(context, 'textRendering', 'auto');\n  setIfPresent(context, 'wordSpacing', '0px');\n}\n\nfunction scrubIdleSurface(surface: FilterSurface): void {\n  const { context } = surface;\n  try {\n    context.fillStyle = '#000000';\n  } catch {\n    // A poisoned user-visible property must not mask an active render error.\n  }\n  try {\n    context.strokeStyle = '#000000';\n  } catch {\n    // CanvasGradient and CanvasPattern are the other reference-bearing state.\n  }\n  resetIfSupported(context);\n}\n\nfunction resetIfSupported(context: OffscreenCanvasRenderingContext2D): void {\n  try {\n    resetNativeCanvasFilter(context, 'filter surface');\n  } catch {\n    // Pool reset/release must not mask the boundary's component-aware error.\n  }\n}\n\nfunction setIfPresent(\n  context: OffscreenCanvasRenderingContext2D,\n  property: string,\n  value: string,\n): void {\n  if (property in context) {\n    (context as unknown as Record<string, unknown>)[property] = value;\n  }\n}\n\nfunction targetFor(window: FilterPixelWindow): RenderTargetSnapshot {\n  return {\n    logicalBounds: window.logicalBounds,\n    backingWidth: window.backingWidth,\n    backingHeight: window.backingHeight,\n    renderTransform: window.renderTransform,\n    inverseRenderTransform: window.inverseRenderTransform,\n  };\n}\n\nfunction validateWindow(\n  window: FilterPixelWindow,\n  role: 'source' | 'result',\n): void {\n  const { backingWidth: width, backingHeight: height } = window;\n  if (\n    !Number.isSafeInteger(width) ||\n    !Number.isSafeInteger(height) ||\n    width <= 0 ||\n    height <= 0 ||\n    width > MAX_UNSIGNED_LONG ||\n    height > MAX_UNSIGNED_LONG\n  ) {\n    throw surfaceError(\n      role,\n      window,\n      `backing dimensions must be positive unsigned-long integers no greater than ${MAX_UNSIGNED_LONG}`,\n    );\n  }\n  if (!Number.isSafeInteger(width * height)) {\n    throw surfaceError(\n      role,\n      window,\n      'backing area must remain a finite safe integer',\n    );\n  }\n}\n\nfunction surfaceError(\n  role: 'source' | 'result',\n  window: FilterPixelWindow,\n  reason: string,\n  cause?: unknown,\n): Error {\n  const type = GLOBAL_STATE.componentRefs?.element.type;\n  const component = typeof type === 'function' && type.name ?\n    type.name : 'filter boundary';\n  const diagnostic = layoutDiagnostic({\n    component,\n    property: `filter.${role}Surface`,\n    value: {\n      logicalBounds: window.logicalBounds,\n      backingWidth: window.backingWidth,\n      backingHeight: window.backingHeight,\n    },\n    algorithm: 'filter-capture',\n    reason,\n  });\n  if (cause !== undefined) {\n    diagnostic.cause = cause;\n  }\n  return diagnostic;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/lib/filter/render-filter-boundary.d.ts

@@ -0,0 +1,14 @@
+import type { NativePreparedFilter } from '../../filters/native-operations.js';
+import { FilterSurfacePool } from './filter-surface-pool.js';
+import { resolveFilterWindows } from './filter-region.js';
+import { type PrimitivePresentation } from '../primitive-presentation.js';
+import type { PibblInstance } from '../types.js';
+export interface RenderFilterBoundaryInput {
+    readonly component: string;
+    readonly filters: readonly NativePreparedFilter[];
+    readonly presentation?: Readonly<PrimitivePresentation>;
+    readonly process?: (source: OffscreenCanvas, result: OffscreenCanvasRenderingContext2D, windows: ReturnType<typeof resolveFilterWindows> extends infer T ? Exclude<T, 'discard'> : never) => void;
+}
+export declare function renderFilterBoundary(input: Readonly<RenderFilterBoundaryInput>, renderSubtree: () => void): void;
+/** @internal Read-only test/diagnostic access; it never allocates a pool. */
+export declare function peekNativeFilterPool(instance: PibblInstance): FilterSurfacePool | undefined;

package/dist/lib/filter/render-filter-boundary.js

@@ -0,0 +1,211 @@
+import { GLOBAL_STATE } from "../global-state.js";
+import {
+  getCurrentPaintTransform,
+  getCurrentWorldTransform,
+  withRenderTarget
+} from "../render-target.js";
+import { getOptionalService } from "../optional-services.js";
+import { compileNativeFilters } from "../../filters/native-operations.js";
+import { assertNativeCanvasFilter, resetNativeCanvasFilter } from "../../filters/native-canvas-filter.js";
+import { copyFilterSourceState } from "./canvas-state.js";
+import { FilterSurfacePool } from "./filter-surface-pool.js";
+import { resolveFilterWindows } from "./filter-region.js";
+import {
+  enterPrimitivePresentation
+} from "../primitive-presentation.js";
+import { layoutDiagnostic } from "../style/diagnostics.js";
+const FILTER_SURFACE_POOL = /* @__PURE__ */ Symbol("pibbl.native-filter-surface-pool");
+function renderFilterBoundary(input, renderSubtree) {
+  const parent = GLOBAL_STATE.renderContext;
+  const parentTarget = GLOBAL_STATE.renderTarget;
+  const instance = GLOBAL_STATE.currentPibblInstance;
+  if (!parent || !parentTarget || !instance) {
+    throw new Error("Filter rendering requires an active Pibbl render target.");
+  }
+  const parentPaintTransform = getCurrentPaintTransform();
+  const parentWorld = getCurrentWorldTransform();
+  const boundaryPaintTransform = input.presentation?.transform ? parentPaintTransform.multiply(input.presentation.transform) : parentPaintTransform;
+  const windows = resolveFilterWindows(
+    parentTarget,
+    boundaryPaintTransform,
+    { values: input.filters }
+  );
+  if (windows === "discard") {
+    renderDiscardedBoundary(input, parent, parentWorld, renderSubtree);
+    return;
+  }
+  const pool = getOptionalService(instance, FILTER_SURFACE_POOL, () => new NativeFilterService(instance));
+  pool.used = true;
+  const pair = pool.pool.checkoutPair(windows);
+  try {
+    const { source, result } = pair;
+    result.context.setTransform(1, 0, 0, 1, 0, 0);
+    if (!input.process) validateNativeFilter(input, result.context, windows.density);
+    copyFilterSourceState(parent, source.context);
+    source.context.setTransform(windows.source.renderTransform);
+    withRenderTarget(
+      source.context,
+      source.target,
+      parentWorld,
+      () => {
+        const releasePresentation2 = enterPrimitivePresentation(
+          input.presentation,
+          { deferPaint: true }
+        );
+        try {
+          renderSubtree();
+        } finally {
+          releasePresentation2();
+        }
+      }
+    );
+    if (input.process) input.process(source.canvas, result.context, windows);
+    else result.context.drawImage(source.canvas, windows.sourceToOutputX, windows.sourceToOutputY);
+    parent.save();
+    let releasePresentation;
+    try {
+      releasePresentation = enterPrimitivePresentation(input.presentation);
+      parent.drawImage(
+        result.canvas,
+        0,
+        0,
+        windows.output.backingWidth,
+        windows.output.backingHeight,
+        windows.output.logicalBounds.x,
+        windows.output.logicalBounds.y,
+        windows.output.logicalBounds.width,
+        windows.output.logicalBounds.height
+      );
+    } finally {
+      try {
+        releasePresentation?.();
+      } finally {
+        parent.restore();
+      }
+    }
+  } finally {
+    pair.release();
+  }
+}
+function peekNativeFilterPool(instance) {
+  return instance.optionalServices.get(FILTER_SURFACE_POOL)?.pool;
+}
+class NativeFilterService {
+  constructor(instance) {
+    this.instance = instance;
+  }
+  instance;
+  pool = new FilterSurfacePool();
+  used = false;
+  committed = false;
+  beginRender() {
+    this.used = false;
+  }
+  endRender(success) {
+    if (success && this.used) {
+      this.committed = true;
+      return;
+    }
+    if (!success && this.committed) return;
+    this.pool.dispose();
+    this.instance.optionalServices.delete(FILTER_SURFACE_POOL);
+  }
+  dispose() {
+    this.pool.dispose();
+  }
+}
+function renderDiscardedBoundary(input, parent, parentWorld, renderSubtree) {
+  if (typeof OffscreenCanvas === "undefined") {
+    throw filterCapabilityError(
+      input.component,
+      "requires browser OffscreenCanvas support for its discard target"
+    );
+  }
+  let canvas;
+  try {
+    canvas = new OffscreenCanvas(1, 1);
+  } catch (error) {
+    throw filterCapabilityError(
+      input.component,
+      "could not allocate its discard OffscreenCanvas",
+      error
+    );
+  }
+  let context;
+  try {
+    context = canvas.getContext("2d");
+  } catch (error) {
+    throw filterCapabilityError(
+      input.component,
+      "could not acquire its discard OffscreenCanvas 2D context",
+      error
+    );
+  }
+  if (!context) {
+    throw filterCapabilityError(
+      input.component,
+      "could not acquire its discard OffscreenCanvas 2D context"
+    );
+  }
+  context.setTransform(1, 0, 0, 1, 0, 0);
+  context.clearRect(0, 0, 1, 1);
+  context.beginPath();
+  if (!input.process) {
+    validateNativeFilter(input, context, 1);
+    resetNativeCanvasFilter(context, input.component);
+  }
+  copyFilterSourceState(parent, context);
+  const target = {
+    logicalBounds: Object.freeze({ x: 0, y: 0, width: 1, height: 1 }),
+    backingWidth: 1,
+    backingHeight: 1,
+    renderTransform: new DOMMatrix(),
+    inverseRenderTransform: new DOMMatrix()
+  };
+  withRenderTarget(context, target, parentWorld, () => {
+    const releasePresentation = enterPrimitivePresentation(
+      input.presentation,
+      { deferPaint: true }
+    );
+    try {
+      renderSubtree();
+    } finally {
+      releasePresentation();
+    }
+  });
+}
+function validateNativeFilter(input, context, density) {
+  const cssText = compileNativeFilters(input.filters, density);
+  assertNativeCanvasFilter(context, cssText, input.component, () => {
+    for (const filter of input.filters) {
+      if (!filter.onRejected) continue;
+      try {
+        assertNativeCanvasFilter(
+          context,
+          compileNativeFilters([filter], density),
+          input.component
+        );
+      } catch {
+        filter.onRejected();
+      }
+    }
+  });
+}
+function filterCapabilityError(component, reason, cause) {
+  const diagnostic = layoutDiagnostic({
+    component,
+    property: "filter",
+    value: void 0,
+    algorithm: "filter-rendering",
+    reason
+  });
+  if (cause !== void 0) {
+    diagnostic.cause = cause;
+  }
+  return diagnostic;
+}
+export {
+  peekNativeFilterPool,
+  renderFilterBoundary
+};
+//# sourceMappingURL=render-filter-boundary.js.map

package/dist/lib/filter/render-filter-boundary.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/filter/render-filter-boundary.ts"],
+  "sourcesContent": ["import { GLOBAL_STATE } from '../global-state.js';\nimport {\n  getCurrentPaintTransform,\n  getCurrentWorldTransform,\n  type RenderTargetSnapshot,\n  withRenderTarget,\n} from '../render-target.js';\nimport { getOptionalService } from '../optional-services.js';\nimport type { NativePreparedFilter } from '../../filters/native-operations.js';\nimport { compileNativeFilters } from '../../filters/native-operations.js';\nimport { assertNativeCanvasFilter, resetNativeCanvasFilter } from '../../filters/native-canvas-filter.js';\nimport { copyFilterSourceState } from './canvas-state.js';\nimport { FilterSurfacePool } from './filter-surface-pool.js';\nimport { resolveFilterWindows } from './filter-region.js';\nimport {\n  enterPrimitivePresentation,\n  type PrimitivePresentation,\n} from '../primitive-presentation.js';\nimport { layoutDiagnostic } from '../style/diagnostics.js';\nimport type { PibblInstance } from '../types.js';\n\nconst FILTER_SURFACE_POOL = Symbol('pibbl.native-filter-surface-pool');\n\nexport interface RenderFilterBoundaryInput {\n  readonly component: string;\n  readonly filters: readonly NativePreparedFilter[];\n  readonly presentation?: Readonly<PrimitivePresentation>;\n  readonly process?: (source: OffscreenCanvas, result: OffscreenCanvasRenderingContext2D, windows: ReturnType<typeof resolveFilterWindows> extends infer T ? Exclude<T, 'discard'> : never) => void;\n}\n\nexport function renderFilterBoundary(\n  input: Readonly<RenderFilterBoundaryInput>,\n  renderSubtree: () => void,\n): void {\n  const parent = GLOBAL_STATE.renderContext;\n  const parentTarget = GLOBAL_STATE.renderTarget;\n  const instance = GLOBAL_STATE.currentPibblInstance;\n  if (!parent || !parentTarget || !instance) {\n    throw new Error('Filter rendering requires an active Pibbl render target.');\n  }\n\n  const parentPaintTransform = getCurrentPaintTransform();\n  const parentWorld = getCurrentWorldTransform();\n  const boundaryPaintTransform = input.presentation?.transform ?\n    parentPaintTransform.multiply(input.presentation.transform) :\n    parentPaintTransform;\n  const windows = resolveFilterWindows(\n    parentTarget,\n    boundaryPaintTransform,\n    { values: input.filters },\n  );\n  if (windows === 'discard') {\n    renderDiscardedBoundary(input, parent, parentWorld, renderSubtree);\n    return;\n  }\n\n  const pool = getOptionalService(instance, FILTER_SURFACE_POOL, () => new NativeFilterService(instance));\n  pool.used = true;\n  const pair = pool.pool.checkoutPair(windows);\n  try {\n    const { source, result } = pair;\n    result.context.setTransform(1, 0, 0, 1, 0, 0);\n    if (!input.process) validateNativeFilter(input, result.context, windows.density);\n\n    copyFilterSourceState(parent, source.context);\n    source.context.setTransform(windows.source.renderTransform);\n    withRenderTarget(\n      source.context,\n      source.target,\n      parentWorld,\n      () => {\n        const releasePresentation = enterPrimitivePresentation(\n          input.presentation,\n          { deferPaint: true },\n        );\n        try {\n          renderSubtree();\n        } finally {\n          releasePresentation();\n        }\n      },\n    );\n\n    if (input.process) input.process(source.canvas, result.context, windows);\n    else result.context.drawImage(source.canvas, windows.sourceToOutputX, windows.sourceToOutputY);\n    parent.save();\n    let releasePresentation: (() => void) | undefined;\n    try {\n      releasePresentation = enterPrimitivePresentation(input.presentation);\n      parent.drawImage(\n        result.canvas,\n        0,\n        0,\n        windows.output.backingWidth,\n        windows.output.backingHeight,\n        windows.output.logicalBounds.x,\n        windows.output.logicalBounds.y,\n        windows.output.logicalBounds.width,\n        windows.output.logicalBounds.height,\n      );\n    } finally {\n      try {\n        releasePresentation?.();\n      } finally {\n        parent.restore();\n      }\n    }\n  } finally {\n    pair.release();\n  }\n}\n\n/** @internal Read-only test/diagnostic access; it never allocates a pool. */\nexport function peekNativeFilterPool(instance: PibblInstance): FilterSurfacePool | undefined {\n  return (instance.optionalServices.get(FILTER_SURFACE_POOL) as NativeFilterService | undefined)?.pool;\n}\n\nclass NativeFilterService {\n  readonly pool = new FilterSurfacePool();\n  used = false;\n  private committed = false;\n\n  constructor(private readonly instance: NonNullable<typeof GLOBAL_STATE.currentPibblInstance>) {}\n\n  beginRender(): void { this.used = false; }\n  endRender(success: boolean): void {\n    if (success && this.used) {\n      this.committed = true;\n      return;\n    }\n    if (!success && this.committed) return;\n    this.pool.dispose();\n    this.instance.optionalServices.delete(FILTER_SURFACE_POOL);\n  }\n  dispose(): void { this.pool.dispose(); }\n}\n\nfunction renderDiscardedBoundary(\n  input: Readonly<RenderFilterBoundaryInput>,\n  parent: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D,\n  parentWorld: DOMMatrix,\n  renderSubtree: () => void,\n): void {\n  if (typeof OffscreenCanvas === 'undefined') {\n    throw filterCapabilityError(\n      input.component,\n      'requires browser OffscreenCanvas support for its discard target',\n    );\n  }\n  let canvas: OffscreenCanvas;\n  try {\n    canvas = new OffscreenCanvas(1, 1);\n  } catch (error) {\n    throw filterCapabilityError(\n      input.component,\n      'could not allocate its discard OffscreenCanvas',\n      error,\n    );\n  }\n  let context: OffscreenCanvasRenderingContext2D | null;\n  try {\n    context = canvas.getContext('2d');\n  } catch (error) {\n    throw filterCapabilityError(\n      input.component,\n      'could not acquire its discard OffscreenCanvas 2D context',\n      error,\n    );\n  }\n  if (!context) {\n    throw filterCapabilityError(\n      input.component,\n      'could not acquire its discard OffscreenCanvas 2D context',\n    );\n  }\n  context.setTransform(1, 0, 0, 1, 0, 0);\n  context.clearRect(0, 0, 1, 1);\n  context.beginPath();\n  if (!input.process) {\n    validateNativeFilter(input, context, 1);\n    resetNativeCanvasFilter(context, input.component);\n  }\n  copyFilterSourceState(parent, context);\n  const target: RenderTargetSnapshot = {\n    logicalBounds: Object.freeze({ x: 0, y: 0, width: 1, height: 1 }),\n    backingWidth: 1,\n    backingHeight: 1,\n    renderTransform: new DOMMatrix(),\n    inverseRenderTransform: new DOMMatrix(),\n  };\n  withRenderTarget(context, target, parentWorld, () => {\n    const releasePresentation = enterPrimitivePresentation(\n      input.presentation,\n      { deferPaint: true },\n    );\n    try {\n      renderSubtree();\n    } finally {\n      releasePresentation();\n    }\n  });\n}\n\nfunction validateNativeFilter(\n  input: Readonly<RenderFilterBoundaryInput>,\n  context: OffscreenCanvasRenderingContext2D,\n  density: number,\n): void {\n  const cssText = compileNativeFilters(input.filters, density);\n  assertNativeCanvasFilter(context, cssText, input.component, () => {\n    for (const filter of input.filters) {\n      if (!filter.onRejected) continue;\n      try {\n        assertNativeCanvasFilter(\n          context,\n          compileNativeFilters([filter], density),\n          input.component,\n        );\n      } catch {\n        filter.onRejected();\n      }\n    }\n  });\n}\n\nfunction filterCapabilityError(\n  component: string,\n  reason: string,\n  cause?: unknown,\n): Error {\n  const diagnostic = layoutDiagnostic({\n    component,\n    property: 'filter',\n    value: undefined,\n    algorithm: 'filter-rendering',\n    reason,\n  });\n  if (cause !== undefined) {\n    diagnostic.cause = cause;\n  }\n  return diagnostic;\n}\n"],
+  "mappings": "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",
+  "names": ["releasePresentation"]
+}

package/dist/lib/focus/directional-navigation.d.ts

@@ -0,0 +1,12 @@
+import type { PibblNavigationCandidate } from "./types.js";
+export type PibblDirection = "left" | "right" | "up" | "down";
+export type DirectionalScore = readonly [
+    beamPenalty: 0 | 1,
+    forwardEdgeDistance: number,
+    perpendicularDistance: number,
+    sourceIndex: number
+];
+export declare function findDirectionalCandidate(current: PibblNavigationCandidate, candidates: readonly PibblNavigationCandidate[], direction: PibblDirection, eligible?: (candidate: PibblNavigationCandidate) => boolean): PibblNavigationCandidate | undefined;
+/** Resolves only within the candidate's nearest committed boundary. */
+export declare function findNearestDirectionalCandidate(current: PibblNavigationCandidate, direction: PibblDirection, eligible?: (candidate: PibblNavigationCandidate) => boolean): PibblNavigationCandidate | undefined;
+export declare function scoreDirectionalCandidate(current: PibblNavigationCandidate, candidate: PibblNavigationCandidate, direction: PibblDirection): DirectionalScore | undefined;