@pibbl/core 0.0.1

package/dist/lib/events/hit-test.d.ts

@@ -0,0 +1,13 @@
+import type { PibblEventRoot } from '../types.js';
+import { type PibblHitTestInput, type PibblHitTestOutput } from './paint-entry.js';
+import type { PibblEventTargetRegistration } from './registrations.js';
+export interface PibblCoordinatePoint {
+    readonly x: number;
+    readonly y: number;
+}
+/** Resolves one paint entry in reverse global paint order without allocating. */
+export declare function resolveCoordinateHit(eventRoot: PibblEventRoot, input: PibblHitTestInput, output: PibblHitTestOutput): PibblHitTestOutput;
+/** Compatibility wrapper for coordinate event dispatch. */
+export declare function resolveCoordinateTarget(eventRoot: PibblEventRoot, point: PibblCoordinatePoint): PibblEventTargetRegistration | undefined;
+/** Borrows the root scratch result for immediate coordinate dispatch. */
+export declare function resolveCoordinateOutput(eventRoot: PibblEventRoot, point: PibblCoordinatePoint): PibblHitTestOutput;

package/dist/lib/events/hit-test.js

@@ -0,0 +1,135 @@
+import { isHit } from "../util/is-hit.js";
+import {
+  PibblHitDisposition,
+  PibblPaintEntryKind,
+  hitTestScratchFactory
+} from "./paint-entry.js";
+function resolveCoordinateHit(eventRoot, input, output) {
+  const instance = eventRoot.rootInstance;
+  const canvas = eventRoot.canvas;
+  reset(output);
+  if (!instance || !canvas || !instance.surface.snapshot) return output;
+  return resolveInstanceHit(
+    eventRoot,
+    instance,
+    canvas,
+    input.rootX,
+    input.rootY,
+    new DOMMatrix(),
+    output
+  );
+}
+function resolveCoordinateTarget(eventRoot, point) {
+  const output = resolveCoordinateOutput(eventRoot, point);
+  return output.disposition === PibblHitDisposition.Target ? output.target ?? void 0 : void 0;
+}
+function resolveCoordinateOutput(eventRoot, point) {
+  let input = eventRoot.coordinateHitInput;
+  let output = eventRoot.coordinateHitOutput;
+  if (!input || !output) {
+    const scratch = hitTestScratchFactory.create();
+    input = eventRoot.coordinateHitInput = scratch.input;
+    output = eventRoot.coordinateHitOutput = scratch.output;
+  }
+  input.rootX = point.x;
+  input.rootY = point.y;
+  resolveCoordinateHit(eventRoot, input, output);
+  return output;
+}
+function resolveInstanceHit(eventRoot, instance, canvas, rootX, rootY, transform, output) {
+  const entries = Array.from(instance.paintEntries);
+  for (let index = entries.length - 1; index >= 0; index--) {
+    const entry = entries[index];
+    reset(output);
+    switch (entry.paintKind) {
+      case PibblPaintEntryKind.Path:
+        resolvePathHit(eventRoot, canvas, entry, rootX, rootY, transform, output);
+        break;
+      case PibblPaintEntryKind.NestedInstance:
+      case PibblPaintEntryKind.Resolver: {
+        if (entry.instance.mainTeardowns.closed) continue;
+        const childTransform = multiplyTransforms(transform, entry.transform);
+        const boundaryClippingStack = composeClippingStack(
+          entry.clippingStack,
+          transform
+        );
+        if (!isHit({
+          canvas,
+          path: entry.bounds,
+          transform: childTransform,
+          x: rootX,
+          y: rootY,
+          fill: true,
+          lineInteractionWidth: 0,
+          currentClippingStack: boundaryClippingStack
+        })) break;
+        try {
+          if (entry.paintKind === PibblPaintEntryKind.NestedInstance) {
+            resolveInstanceHit(
+              eventRoot,
+              entry.instance,
+              canvas,
+              rootX,
+              rootY,
+              childTransform,
+              output
+            );
+          } else if (entry.resolveLocal) {
+            const local = childTransform.inverse().transformPoint(
+              new DOMPoint(rootX, rootY)
+            );
+            entry.resolveLocal(local.x, local.y, output);
+          }
+        } finally {
+        }
+        break;
+      }
+    }
+    if (output.disposition !== PibblHitDisposition.Miss) return output;
+  }
+  return output;
+}
+function resolvePathHit(eventRoot, canvas, entry, rootX, rootY, transform, output) {
+  const target = entry.target;
+  if (!isLiveTarget(eventRoot, target)) return;
+  if (isHit({
+    canvas,
+    path: entry.path,
+    transform: multiplyTransforms(transform, entry.transform),
+    x: rootX,
+    y: rootY,
+    fill: entry.fill,
+    lineInteractionWidth: entry.lineInteractionWidth,
+    currentClippingStack: composeClippingStack(entry.clippingStack, transform)
+  })) {
+    output.disposition = PibblHitDisposition.Target;
+    output.target = target;
+  }
+}
+function reset(output) {
+  output.disposition = PibblHitDisposition.Miss;
+  output.target = null;
+  delete output.winner;
+  delete output.winnerState;
+}
+function isLiveTarget(eventRoot, target) {
+  return target.live && !target.owner.mainTeardowns.closed && target.owner.eventRoot === eventRoot && eventRoot.targets.has(target);
+}
+function composeClippingStack(clippingStack, transform) {
+  if (clippingStack.length === 0 || transform.isIdentity) return clippingStack;
+  return clippingStack.map((entry) => ({
+    ...entry,
+    transform: multiplyTransforms(transform, entry.transform)
+  }));
+}
+function multiplyTransforms(parent, child) {
+  if (parent.isIdentity) return child;
+  if (child.isIdentity) return parent;
+  return parent.multiply(child);
+}
+export {
+  resolveCoordinateHit,
+  resolveCoordinateOutput,
+  resolveCoordinateTarget
+};
+//# sourceMappingURL=hit-test.js.map

package/dist/lib/events/hit-test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/events/hit-test.ts"],
+  "sourcesContent": ["import type { PibblClippingStackEntry, PibblEventRoot, PibblInstance } from '../types.js';\nimport { isHit } from '../util/is-hit.js';\nimport {\n  PibblHitDisposition,\n  PibblPaintEntryKind,\n  hitTestScratchFactory,\n  type PibblHitTestInput,\n  type PibblHitTestOutput,\n  type PibblPathPaintEntry,\n} from './paint-entry.js';\nimport type { PibblEventTargetRegistration } from './registrations.js';\n\nexport interface PibblCoordinatePoint {\n  readonly x: number;\n  readonly y: number;\n}\n\n/** Resolves one paint entry in reverse global paint order without allocating. */\nexport function resolveCoordinateHit(\n  eventRoot: PibblEventRoot,\n  input: PibblHitTestInput,\n  output: PibblHitTestOutput,\n): PibblHitTestOutput {\n  const instance = eventRoot.rootInstance;\n  const canvas = eventRoot.canvas;\n  reset(output);\n  if (!instance || !canvas || !instance.surface.snapshot) return output;\n  return resolveInstanceHit(\n    eventRoot,\n    instance,\n    canvas,\n    input.rootX,\n    input.rootY,\n    new DOMMatrix(),\n    output,\n  );\n}\n\n/** Compatibility wrapper for coordinate event dispatch. */\nexport function resolveCoordinateTarget(\n  eventRoot: PibblEventRoot,\n  point: PibblCoordinatePoint,\n): PibblEventTargetRegistration | undefined {\n  const output = resolveCoordinateOutput(eventRoot, point);\n  return output.disposition === PibblHitDisposition.Target ?\n    output.target ?? undefined :\n    undefined;\n}\n\n/** Borrows the root scratch result for immediate coordinate dispatch. */\nexport function resolveCoordinateOutput(\n  eventRoot: PibblEventRoot,\n  point: PibblCoordinatePoint,\n): PibblHitTestOutput {\n  let input = eventRoot.coordinateHitInput;\n  let output = eventRoot.coordinateHitOutput;\n  if (!input || !output) {\n    const scratch = hitTestScratchFactory.create();\n    input = eventRoot.coordinateHitInput = scratch.input;\n    output = eventRoot.coordinateHitOutput = scratch.output;\n  }\n  input.rootX = point.x;\n  input.rootY = point.y;\n  resolveCoordinateHit(eventRoot, input, output);\n  return output;\n}\n\nfunction resolveInstanceHit(\n  eventRoot: PibblEventRoot,\n  instance: PibblInstance,\n  canvas: HTMLCanvasElement,\n  rootX: number,\n  rootY: number,\n  transform: DOMMatrix,\n  output: PibblHitTestOutput,\n): PibblHitTestOutput {\n  const entries = Array.from(instance.paintEntries);\n  for (let index = entries.length - 1; index >= 0; index--) {\n    const entry = entries[index]!;\n    reset(output);\n    switch (entry.paintKind) {\n      case PibblPaintEntryKind.Path:\n        resolvePathHit(eventRoot, canvas, entry, rootX, rootY, transform, output);\n        break;\n      case PibblPaintEntryKind.NestedInstance:\n      case PibblPaintEntryKind.Resolver: {\n        if (entry.instance.mainTeardowns.closed) continue;\n        const childTransform = multiplyTransforms(transform, entry.transform);\n        const boundaryClippingStack = composeClippingStack(\n          entry.clippingStack,\n          transform,\n        );\n        if (!isHit({\n          canvas,\n          path: entry.bounds,\n          transform: childTransform,\n          x: rootX,\n          y: rootY,\n          fill: true,\n          lineInteractionWidth: 0,\n          currentClippingStack: boundaryClippingStack,\n        })) break;\n        try {\n          if (entry.paintKind === PibblPaintEntryKind.NestedInstance) {\n            resolveInstanceHit(\n              eventRoot,\n              entry.instance,\n              canvas,\n              rootX,\n              rootY,\n              childTransform,\n              output,\n            );\n          } else if (entry.resolveLocal) {\n            const local = childTransform.inverse().transformPoint(\n              new DOMPoint(rootX, rootY),\n            );\n            entry.resolveLocal(local.x, local.y, output);\n          }\n        } finally {\n          // Child clipping and local coordinates are stack-local to this call.\n        }\n        break;\n      }\n    }\n    if (output.disposition !== PibblHitDisposition.Miss) return output;\n  }\n  return output;\n}\n\nfunction resolvePathHit(\n  eventRoot: PibblEventRoot,\n  canvas: HTMLCanvasElement,\n  entry: PibblPathPaintEntry,\n  rootX: number,\n  rootY: number,\n  transform: DOMMatrix,\n  output: PibblHitTestOutput,\n): void {\n  const target = entry.target;\n  if (!isLiveTarget(eventRoot, target)) return;\n  if (isHit({\n    canvas,\n    path: entry.path,\n    transform: multiplyTransforms(transform, entry.transform),\n    x: rootX,\n    y: rootY,\n    fill: entry.fill,\n    lineInteractionWidth: entry.lineInteractionWidth,\n    currentClippingStack: composeClippingStack(entry.clippingStack, transform),\n  })) {\n    output.disposition = PibblHitDisposition.Target;\n    output.target = target;\n  }\n}\n\nfunction reset(output: PibblHitTestOutput): void {\n  output.disposition = PibblHitDisposition.Miss;\n  output.target = null;\n  delete output.winner;\n  delete output.winnerState;\n}\n\nfunction isLiveTarget(\n  eventRoot: PibblEventRoot,\n  target: PibblEventTargetRegistration,\n): boolean {\n  return target.live &&\n    !target.owner.mainTeardowns.closed &&\n    target.owner.eventRoot === eventRoot &&\n    eventRoot.targets.has(target);\n}\n\nfunction composeClippingStack(\n  clippingStack: readonly PibblClippingStackEntry[],\n  transform: DOMMatrix,\n): readonly PibblClippingStackEntry[] {\n  if (clippingStack.length === 0 || transform.isIdentity) return clippingStack;\n  return clippingStack.map(entry => ({\n    ...entry,\n    transform: multiplyTransforms(transform, entry.transform),\n  }));\n}\n\nfunction multiplyTransforms(parent: DOMMatrix, child: DOMMatrix): DOMMatrix {\n  if (parent.isIdentity) return child;\n  if (child.isIdentity) return parent;\n  return parent.multiply(child);\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/lib/events/native-listener-hub.d.ts

@@ -0,0 +1,10 @@
+import type { PibblEventDefinition } from './event-definitions.js';
+import type { PibblEventType } from './types.js';
+import type { Teardowns } from '../teardowns.js';
+export interface NativeListenerHub {
+    acquire(type: PibblEventType): () => void;
+    count(type: PibblEventType): number;
+    dispose(): void;
+}
+export type NativeEventDispatch = (definition: PibblEventDefinition, event: Event) => void;
+export declare function createNativeListenerHub(canvas: HTMLCanvasElement, dispatch: NativeEventDispatch, teardowns: Teardowns): NativeListenerHub;

package/dist/lib/events/native-listener-hub.js

@@ -0,0 +1,72 @@
+import { getPibblEventDefinition } from "./event-definitions.js";
+function createNativeListenerHub(canvas, dispatch, teardowns) {
+  const records = /* @__PURE__ */ new Map();
+  let disposed = false;
+  const hub = {
+    acquire(type) {
+      if (disposed) {
+        return () => void 0;
+      }
+      let record = records.get(type);
+      if (!record) {
+        const definition = getPibblEventDefinition(type);
+        if (!definition) {
+          throw new Error(`Unknown Pibbl event type: ${type}`);
+        }
+        const listener = (event) => dispatch(definition, event);
+        const options = listenerOptions(definition);
+        record = { count: 0, listener, options };
+        canvas.addEventListener(type, listener, options);
+        records.set(type, record);
+      }
+      record.count++;
+      let released = false;
+      return () => {
+        if (released) return;
+        released = true;
+        if (disposed) return;
+        const current = records.get(type);
+        if (current !== record) return;
+        current.count--;
+        if (current.count === 0) {
+          records.delete(type);
+          canvas.removeEventListener(
+            type,
+            current.listener,
+            captureFrom(current.options)
+          );
+        }
+      };
+    },
+    count(type) {
+      return records.get(type)?.count ?? 0;
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      for (const [type, record] of records) {
+        canvas.removeEventListener(
+          type,
+          record.listener,
+          captureFrom(record.options)
+        );
+      }
+      records.clear();
+    }
+  };
+  teardowns.add(hub.dispose);
+  return hub;
+}
+function listenerOptions(definition) {
+  if (definition.cancelable && (definition.family === "touch" || definition.family === "wheel")) {
+    return { passive: false };
+  }
+  return false;
+}
+function captureFrom(options) {
+  return typeof options === "boolean" ? options : options.capture ?? false;
+}
+export {
+  createNativeListenerHub
+};
+//# sourceMappingURL=native-listener-hub.js.map

package/dist/lib/events/native-listener-hub.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/events/native-listener-hub.ts"],
+  "sourcesContent": ["import { getPibblEventDefinition } from './event-definitions.js';\nimport type { PibblEventDefinition } from './event-definitions.js';\nimport type { PibblEventType } from './types.js';\nimport type { Teardowns } from '../teardowns.js';\n\ninterface NativeListenerRecord {\n  count: number;\n  listener: EventListener;\n  options: AddEventListenerOptions | boolean;\n}\n\nexport interface NativeListenerHub {\n  acquire(type: PibblEventType): () => void;\n  count(type: PibblEventType): number;\n  dispose(): void;\n}\n\nexport type NativeEventDispatch = (\n  definition: PibblEventDefinition,\n  event: Event,\n) => void;\n\nexport function createNativeListenerHub(\n  canvas: HTMLCanvasElement,\n  dispatch: NativeEventDispatch,\n  teardowns: Teardowns,\n): NativeListenerHub {\n  const records = new Map<PibblEventType, NativeListenerRecord>();\n  let disposed = false;\n\n  const hub: NativeListenerHub = {\n    acquire(type) {\n      if (disposed) {\n        return () => undefined;\n      }\n\n      let record = records.get(type);\n      if (!record) {\n        const definition = getPibblEventDefinition(type);\n        if (!definition) {\n          throw new Error(`Unknown Pibbl event type: ${type}`);\n        }\n        const listener: EventListener = event => dispatch(definition, event);\n        const options = listenerOptions(definition);\n        record = { count: 0, listener, options };\n        canvas.addEventListener(type, listener, options);\n        records.set(type, record);\n      }\n      record.count++;\n\n      let released = false;\n      return () => {\n        if (released) return;\n        released = true;\n        if (disposed) return;\n\n        const current = records.get(type);\n        if (current !== record) return;\n        current.count--;\n        if (current.count === 0) {\n          records.delete(type);\n          canvas.removeEventListener(\n            type,\n            current.listener,\n            captureFrom(current.options),\n          );\n        }\n      };\n    },\n\n    count(type) {\n      return records.get(type)?.count ?? 0;\n    },\n\n    dispose() {\n      if (disposed) return;\n      disposed = true;\n      for (const [type, record] of records) {\n        canvas.removeEventListener(\n          type,\n          record.listener,\n          captureFrom(record.options),\n        );\n      }\n      records.clear();\n    },\n  };\n\n  teardowns.add(hub.dispose);\n  return hub;\n}\n\nfunction listenerOptions(\n  definition: PibblEventDefinition,\n): AddEventListenerOptions | boolean {\n  if (\n    definition.cancelable &&\n    (definition.family === 'touch' || definition.family === 'wheel')\n  ) {\n    return { passive: false };\n  }\n  return false;\n}\n\nfunction captureFrom(options: AddEventListenerOptions | boolean): boolean {\n  return typeof options === 'boolean' ? options : options.capture ?? false;\n}\n"],
+  "mappings": "AAAA,SAAS,+BAA+B;AAsBjC,SAAS,wBACd,QACA,UACA,WACmB;AACnB,QAAM,UAAU,oBAAI,IAA0C;AAC9D,MAAI,WAAW;AAEf,QAAM,MAAyB;AAAA,IAC7B,QAAQ,MAAM;AACZ,UAAI,UAAU;AACZ,eAAO,MAAM;AAAA,MACf;AAEA,UAAI,SAAS,QAAQ,IAAI,IAAI;AAC7B,UAAI,CAAC,QAAQ;AACX,cAAM,aAAa,wBAAwB,IAAI;AAC/C,YAAI,CAAC,YAAY;AACf,gBAAM,IAAI,MAAM,6BAA6B,IAAI,EAAE;AAAA,QACrD;AACA,cAAM,WAA0B,WAAS,SAAS,YAAY,KAAK;AACnE,cAAM,UAAU,gBAAgB,UAAU;AAC1C,iBAAS,EAAE,OAAO,GAAG,UAAU,QAAQ;AACvC,eAAO,iBAAiB,MAAM,UAAU,OAAO;AAC/C,gBAAQ,IAAI,MAAM,MAAM;AAAA,MAC1B;AACA,aAAO;AAEP,UAAI,WAAW;AACf,aAAO,MAAM;AACX,YAAI,SAAU;AACd,mBAAW;AACX,YAAI,SAAU;AAEd,cAAM,UAAU,QAAQ,IAAI,IAAI;AAChC,YAAI,YAAY,OAAQ;AACxB,gBAAQ;AACR,YAAI,QAAQ,UAAU,GAAG;AACvB,kBAAQ,OAAO,IAAI;AACnB,iBAAO;AAAA,YACL;AAAA,YACA,QAAQ;AAAA,YACR,YAAY,QAAQ,OAAO;AAAA,UAC7B;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,IAEA,MAAM,MAAM;AACV,aAAO,QAAQ,IAAI,IAAI,GAAG,SAAS;AAAA,IACrC;AAAA,IAEA,UAAU;AACR,UAAI,SAAU;AACd,iBAAW;AACX,iBAAW,CAAC,MAAM,MAAM,KAAK,SAAS;AACpC,eAAO;AAAA,UACL;AAAA,UACA,OAAO;AAAA,UACP,YAAY,OAAO,OAAO;AAAA,QAC5B;AAAA,MACF;AACA,cAAQ,MAAM;AAAA,IAChB;AAAA,EACF;AAEA,YAAU,IAAI,IAAI,OAAO;AACzB,SAAO;AACT;AAEA,SAAS,gBACP,YACmC;AACnC,MACE,WAAW,eACV,WAAW,WAAW,WAAW,WAAW,WAAW,UACxD;AACA,WAAO,EAAE,SAAS,MAAM;AAAA,EAC1B;AACA,SAAO;AACT;AAEA,SAAS,YAAY,SAAqD;AACxE,SAAO,OAAO,YAAY,YAAY,UAAU,QAAQ,WAAW;AACrE;",
+  "names": []
+}

package/dist/lib/events/paint-entry.d.ts

@@ -0,0 +1,66 @@
+import type { PibblNestedResolverInput } from "../backend/types.js";
+import type { PibblClippingStackEntry, PibblInstance } from '../types.js';
+import type { PibblEventTargetRegistration } from './registrations.js';
+import type { PibblResolverInputWinner } from './resolver-input.js';
+export declare const enum PibblHitDisposition {
+    Miss = 0,
+    Block = 1,
+    Target = 2
+}
+export interface PibblHitTestInput {
+    rootX: number;
+    rootY: number;
+}
+/**
+ * The result of evaluating one paint entry's logical hit test.
+ *
+ * @see {@link PibblEventTargetRegistration}
+ * @see {@link PibblNestedResolverInput}
+ */
+export interface PibblHitTestOutput {
+    /**
+     * Whether the hit test selects a target, blocks lower paint, or passes through. See
+     * {@link PibblHitDisposition}.
+     */
+    disposition: PibblHitDisposition;
+    /**
+     * The selected logical target or target configuration. See {@link PibblEventTargetRegistration}.
+     */
+    target: PibblEventTargetRegistration | null;
+    /** @internal Resolver identity for winner-only external input delivery. */
+    winner?: PibblResolverInputWinner;
+    /** @internal Resolver-owned immutable state from this exact lookup. */
+    winnerState?: unknown;
+}
+export declare const enum PibblPaintEntryKind {
+    Path = 0,
+    NestedInstance = 1,
+    Resolver = 2
+}
+export interface PibblPathPaintEntry {
+    readonly paintKind: PibblPaintEntryKind.Path;
+    target: PibblEventTargetRegistration;
+    path: Path2D;
+    fill: boolean;
+    lineInteractionWidth: number;
+    transform: DOMMatrix;
+    clippingStack: readonly PibblClippingStackEntry[];
+}
+export interface PibblNestedPaintEntry {
+    readonly paintKind: PibblPaintEntryKind.NestedInstance | PibblPaintEntryKind.Resolver;
+    instance: PibblInstance;
+    bounds: Path2D;
+    transform: DOMMatrix;
+    clippingStack: readonly PibblClippingStackEntry[];
+    resolveLocal: ((localX: number, localY: number, output: PibblHitTestOutput) => void) | undefined;
+}
+export type PibblPaintEntry = PibblPathPaintEntry | PibblNestedPaintEntry;
+export interface PibblHitTestScratch {
+    readonly input: PibblHitTestInput;
+    readonly output: PibblHitTestOutput;
+}
+export declare function createHitTestOutput(): PibblHitTestOutput;
+/** @internal Mutable only to make root-owned scratch allocation observable. */
+export declare const hitTestScratchFactory: {
+    create(): PibblHitTestScratch;
+};

package/dist/lib/events/paint-entry.js

@@ -0,0 +1,30 @@
+var PibblHitDisposition = /* @__PURE__ */ ((PibblHitDisposition2) => {
+  PibblHitDisposition2[PibblHitDisposition2["Miss"] = 0] = "Miss";
+  PibblHitDisposition2[PibblHitDisposition2["Block"] = 1] = "Block";
+  PibblHitDisposition2[PibblHitDisposition2["Target"] = 2] = "Target";
+  return PibblHitDisposition2;
+})(PibblHitDisposition || {});
+var PibblPaintEntryKind = /* @__PURE__ */ ((PibblPaintEntryKind2) => {
+  PibblPaintEntryKind2[PibblPaintEntryKind2["Path"] = 0] = "Path";
+  PibblPaintEntryKind2[PibblPaintEntryKind2["NestedInstance"] = 1] = "NestedInstance";
+  PibblPaintEntryKind2[PibblPaintEntryKind2["Resolver"] = 2] = "Resolver";
+  return PibblPaintEntryKind2;
+})(PibblPaintEntryKind || {});
+function createHitTestOutput() {
+  return { disposition: 0 /* Miss */, target: null };
+}
+const hitTestScratchFactory = {
+  create() {
+    return {
+      input: { rootX: 0, rootY: 0 },
+      output: createHitTestOutput()
+    };
+  }
+};
+export {
+  PibblHitDisposition,
+  PibblPaintEntryKind,
+  createHitTestOutput,
+  hitTestScratchFactory
+};
+//# sourceMappingURL=paint-entry.js.map

package/dist/lib/events/paint-entry.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/events/paint-entry.ts"],
+  "sourcesContent": ["import type { PibblNestedResolverInput } from '../backend/types.js';\nimport type { PibblClippingStackEntry, PibblInstance } from '../types.js';\nimport type { PibblEventTargetRegistration } from './registrations.js';\nimport type { PibblResolverInputWinner } from './resolver-input.js';\n\nexport const enum PibblHitDisposition {\n  Miss = 0,\n  Block = 1,\n  Target = 2,\n}\n\nexport interface PibblHitTestInput {\n  rootX: number;\n  rootY: number;\n}\n\n/**\n * The result of evaluating one paint entry's logical hit test.\n *\n * @see {@link PibblEventTargetRegistration}\n * @see {@link PibblNestedResolverInput}\n */\nexport interface PibblHitTestOutput {\n  /**\n   * Whether the hit test selects a target, blocks lower paint, or passes through. See\n   * {@link PibblHitDisposition}.\n   */\n  disposition: PibblHitDisposition;\n  /**\n   * The selected logical target or target configuration. See {@link PibblEventTargetRegistration}.\n   */\n  target: PibblEventTargetRegistration | null;\n  /** @internal Resolver identity for winner-only external input delivery. */\n  winner?: PibblResolverInputWinner;\n  /** @internal Resolver-owned immutable state from this exact lookup. */\n  winnerState?: unknown;\n}\n\nexport const enum PibblPaintEntryKind {\n  Path = 0,\n  NestedInstance = 1,\n  Resolver = 2,\n}\n\nexport interface PibblPathPaintEntry {\n  readonly paintKind: PibblPaintEntryKind.Path;\n  target: PibblEventTargetRegistration;\n  path: Path2D;\n  fill: boolean;\n  lineInteractionWidth: number;\n  transform: DOMMatrix;\n  clippingStack: readonly PibblClippingStackEntry[];\n}\n\nexport interface PibblNestedPaintEntry {\n  readonly paintKind:\n    | PibblPaintEntryKind.NestedInstance\n    | PibblPaintEntryKind.Resolver;\n  instance: PibblInstance;\n  bounds: Path2D;\n  transform: DOMMatrix;\n  clippingStack: readonly PibblClippingStackEntry[];\n  resolveLocal:\n    | ((localX: number, localY: number, output: PibblHitTestOutput) => void)\n    | undefined;\n}\n\nexport type PibblPaintEntry = PibblPathPaintEntry | PibblNestedPaintEntry;\n\nexport interface PibblHitTestScratch {\n  readonly input: PibblHitTestInput;\n  readonly output: PibblHitTestOutput;\n}\n\nexport function createHitTestOutput(): PibblHitTestOutput {\n  return { disposition: PibblHitDisposition.Miss, target: null };\n}\n\n/** @internal Mutable only to make root-owned scratch allocation observable. */\nexport const hitTestScratchFactory = {\n  create(): PibblHitTestScratch {\n    return {\n      input: { rootX: 0, rootY: 0 },\n      output: createHitTestOutput(),\n    };\n  },\n};\n"],
+  "mappings": "AAKO,IAAW,sBAAX,kBAAWA,yBAAX;AACL,EAAAA,0CAAA,UAAO,KAAP;AACA,EAAAA,0CAAA,WAAQ,KAAR;AACA,EAAAA,0CAAA,YAAS,KAAT;AAHgB,SAAAA;AAAA,GAAA;AAiCX,IAAW,sBAAX,kBAAWC,yBAAX;AACL,EAAAA,0CAAA,UAAO,KAAP;AACA,EAAAA,0CAAA,oBAAiB,KAAjB;AACA,EAAAA,0CAAA,cAAW,KAAX;AAHgB,SAAAA;AAAA,GAAA;AAoCX,SAAS,sBAA0C;AACxD,SAAO,EAAE,aAAa,cAA0B,QAAQ,KAAK;AAC/D;AAGO,MAAM,wBAAwB;AAAA,EACnC,SAA8B;AAC5B,WAAO;AAAA,MACL,OAAO,EAAE,OAAO,GAAG,OAAO,EAAE;AAAA,MAC5B,QAAQ,oBAAoB;AAAA,IAC9B;AAAA,EACF;AACF;",
+  "names": ["PibblHitDisposition", "PibblPaintEntryKind"]
+}

package/dist/lib/events/pointer-capture.d.ts

@@ -0,0 +1,23 @@
+import type { PibblEventRoot } from '../types.js';
+import type { PibblEventNode } from './registrations.js';
+/** @internal Structural ownership evidence for lifecycle tests. */
+export declare function getPointerCaptureStateCounts(eventRoot: PibblEventRoot): {
+    readonly activated: number;
+    readonly nativeListenerRequests: number;
+    readonly pendingLoss: number;
+    readonly provisional: number;
+    readonly releaseTransactions: number;
+};
+export declare function setLogicalPointerCapture(target: PibblEventNode, pointerId: number): void;
+export declare function hasLogicalPointerCapture(target: PibblEventNode, pointerId: number): boolean;
+export declare function releaseLogicalPointerCapture(target: PibblEventNode, pointerId: number): void;
+export declare function clearPointerCapturesForTarget(target: PibblEventNode): void;
+export declare function getLogicalPointerCapture(eventRoot: PibblEventRoot, pointerId: number): PibblEventNode | undefined;
+/** Records native activation before exposing the logical got callback. */
+export declare function activateLogicalPointerCapture(eventRoot: PibblEventRoot, pointerId: number): PibblEventNode | undefined;
+/** Clears active routing while retaining the owner for native loss delivery. */
+export declare function cancelLogicalPointerCapture(eventRoot: PibblEventRoot, pointerId: number): void;
+/** Removes native-loss state before exposing the logical loss callback. */
+export declare function consumeLogicalPointerCaptureLoss(eventRoot: PibblEventRoot, pointerId: number): PibblEventNode | undefined;
+/** Processes one pending logical owner change before a non-capture PointerEvent. */
+export declare function processPendingLogicalPointerCapture(eventRoot: PibblEventRoot, pointerId: number, dispatchLost: (target: PibblEventNode) => void, dispatchGot: (target: PibblEventNode) => void): void;