@pibbl/core 0.0.1

package/dist/lib/events/registrations.js

@@ -0,0 +1,397 @@
+import { PIBBL_EVENT_DEFINITIONS } from "./event-definitions.js";
+import { GLOBAL_STATE } from "../global-state.js";
+import { resolvePath } from "../geometry/resolve-path.js";
+import { getCurrentWorldTransform } from "../render-target.js";
+import { PibblPaintEntryKind } from "./paint-entry.js";
+import {
+  clearPointerCapturesForTarget,
+  hasLogicalPointerCapture,
+  releaseLogicalPointerCapture,
+  setLogicalPointerCapture
+} from "./pointer-capture.js";
+const nativeReleases = /* @__PURE__ */ new WeakMap();
+function createTarget(owner, component, slot) {
+  const target = {};
+  const publicTarget = createPublicTarget(() => target);
+  Object.assign(target, {
+    kind: "target",
+    owner,
+    component,
+    slot,
+    publicTarget,
+    paintEntry: void 0,
+    handlers: {},
+    handlerTypesLow: 0,
+    handlerTypesHigh: 0,
+    requiredNativeTypesLow: 0,
+    requiredNativeTypesHigh: 0,
+    ownedNativeTypesLow: 0,
+    ownedNativeTypesHigh: 0,
+    cursor: void 0,
+    keyboardFocusable: void 0,
+    keyboardNavigationBounds: void 0,
+    keyboardNavigationPoints: void 0,
+    live: false
+  });
+  return target;
+}
+function updateTarget(target, handlers, options, participatesInPaint = false, preserveKeyboardNavigationGeometry = false) {
+  updateTargetRegistration(
+    target,
+    handlers,
+    { ...options, path: resolvePath(options.path) },
+    participatesInPaint,
+    preserveKeyboardNavigationGeometry
+  );
+  if (target.live) target.owner.regions.add(target);
+}
+function updateCursorTarget(target, {
+  path,
+  fill = false,
+  lineInteractionWidth = 0,
+  cursor
+}) {
+  updateTargetRegistration(
+    target,
+    {},
+    {
+      path: resolvePath(path),
+      fill,
+      lineInteractionWidth,
+      cursor
+    }
+  );
+  if (target.live) target.owner.regions.add(target);
+}
+function updateTargetRegistration(target, handlers, options, participatesInPaint = false, preserveKeyboardNavigationGeometry = false) {
+  if (target.live) {
+    if (target.paintEntry) target.owner.paintEntries.delete(target.paintEntry);
+    target.owner.eventRoot.targets.delete(target);
+  }
+  refreshHandlers(target, handlers, Boolean(options.cursor));
+  const paintEntry = target.paintEntry ?? {
+    paintKind: PibblPaintEntryKind.Path
+  };
+  paintEntry.target = target;
+  paintEntry.path = options.path;
+  paintEntry.fill = options.fill ?? false;
+  paintEntry.lineInteractionWidth = options.lineInteractionWidth ?? 0;
+  if (GLOBAL_STATE.renderContext) {
+    paintEntry.transform = getCurrentWorldTransform();
+    paintEntry.clippingStack = Array.from(GLOBAL_STATE.clippingStack);
+  } else {
+    paintEntry.transform ??= new DOMMatrix();
+    paintEntry.clippingStack ??= [];
+  }
+  target.cursor = options.cursor;
+  target.keyboardFocusable = options.keyboardFocusable;
+  if (!preserveKeyboardNavigationGeometry) {
+    target.keyboardNavigationBounds = options.keyboardNavigationBounds;
+    target.keyboardNavigationPoints = void 0;
+  }
+  if (!participatesInPaint && target.handlerTypesLow === 0 && target.handlerTypesHigh === 0 && !target.cursor && target.keyboardFocusable !== true) {
+    if (target.live) {
+      target.owner.eventRoot.focusPolicy?.removeTarget(target);
+      target.owner.eventRoot.onNodeRelease?.(target);
+    }
+    target.owner.regions.delete(target);
+    target.paintEntry = void 0;
+    target.live = false;
+    clearPointerCapturesForTarget(target);
+    releaseNativeOwnership(target);
+    return;
+  }
+  target.live = true;
+  target.paintEntry = paintEntry;
+  target.owner.paintEntries.add(paintEntry);
+  target.owner.eventRoot.targets.add(target);
+  updateNativeOwnership(target);
+  target.owner.eventRoot.focusPolicy?.observeTarget(target);
+  target.owner.eventRoot.onTargetUpdate?.(target);
+}
+function releaseTarget(target) {
+  if (target.live) {
+    if (target.paintEntry) target.owner.paintEntries.delete(target.paintEntry);
+    target.owner.eventRoot.targets.delete(target);
+    target.owner.eventRoot.focusPolicy?.removeTarget(target);
+    target.owner.eventRoot.onNodeRelease?.(target);
+  }
+  target.owner.regions.delete(target);
+  target.paintEntry = void 0;
+  target.live = false;
+  clearPointerCapturesForTarget(target);
+  releaseNativeOwnership(target);
+}
+function createListener(owner, component, slot) {
+  const listener = {};
+  const publicTarget = createPublicTarget(() => listener);
+  Object.assign(listener, {
+    kind: "listener",
+    owner,
+    component,
+    slot,
+    publicTarget,
+    handlers: {},
+    handlerTypesLow: 0,
+    handlerTypesHigh: 0,
+    requiredNativeTypesLow: 0,
+    requiredNativeTypesHigh: 0,
+    ownedNativeTypesLow: 0,
+    ownedNativeTypesHigh: 0,
+    live: false
+  });
+  return listener;
+}
+function updateListener(listener, handlers) {
+  let registrations = listener.owner.eventRoot.listenersByComponent.get(
+    listener.component.id
+  );
+  if (listener.live) {
+    registrations?.delete(listener);
+  }
+  refreshHandlers(listener, handlers, false);
+  if (listener.handlerTypesLow === 0 && listener.handlerTypesHigh === 0) {
+    if (registrations?.size === 0) {
+      listener.owner.eventRoot.listenersByComponent.delete(
+        listener.component.id
+      );
+    }
+    if (listener.live) listener.owner.eventRoot.onNodeRelease?.(listener);
+    listener.live = false;
+    clearPointerCapturesForTarget(listener);
+    releaseNativeOwnership(listener);
+    return;
+  }
+  if (!registrations) {
+    registrations = /* @__PURE__ */ new Set();
+    listener.owner.eventRoot.listenersByComponent.set(
+      listener.component.id,
+      registrations
+    );
+  }
+  registrations.add(listener);
+  listener.live = true;
+  updateNativeOwnership(listener);
+}
+function releaseListener(listener) {
+  if (listener.live) {
+    const registrations = listener.owner.eventRoot.listenersByComponent.get(
+      listener.component.id
+    );
+    registrations?.delete(listener);
+    if (registrations?.size === 0) {
+      listener.owner.eventRoot.listenersByComponent.delete(
+        listener.component.id
+      );
+    }
+    listener.owner.eventRoot.onNodeRelease?.(listener);
+  }
+  listener.live = false;
+  clearPointerCapturesForTarget(listener);
+  releaseNativeOwnership(listener);
+}
+function normalizeHandlers(handlers) {
+  const state = createHandlerState();
+  refreshHandlers(state, handlers, false);
+  return state.handlers;
+}
+const eventPropMetadata = /* @__PURE__ */ Object.create(null);
+const eventIndexByType = /* @__PURE__ */ Object.create(null);
+if (PIBBL_EVENT_DEFINITIONS.length > 64) {
+  throw new Error("Pibbl event masks support at most 64 logical event types.");
+}
+for (let index = 0; index < PIBBL_EVENT_DEFINITIONS.length; index++) {
+  eventIndexByType[PIBBL_EVENT_DEFINITIONS[index].type] = index;
+}
+for (let index = 0; index < PIBBL_EVENT_DEFINITIONS.length; index++) {
+  const definition = PIBBL_EVENT_DEFINITIONS[index];
+  const handlerTypesLow = index < 32 ? 1 << index : 0;
+  const handlerTypesHigh = index < 32 ? 0 : 1 << index - 32;
+  const nativeTypes = expandNativeTypesForMetadata(
+    /* @__PURE__ */ new Set([definition.type]),
+    false
+  );
+  let requiredNativeTypesLow = 0;
+  let requiredNativeTypesHigh = 0;
+  for (const type of nativeTypes) {
+    const nativeIndex = eventIndexByType[type];
+    if (nativeIndex < 32) {
+      requiredNativeTypesLow |= 1 << nativeIndex;
+    } else {
+      requiredNativeTypesHigh |= 1 << nativeIndex - 32;
+    }
+  }
+  const bubble = Object.freeze({
+    normalizedKey: definition.type,
+    handlerTypesLow,
+    handlerTypesHigh,
+    requiredNativeTypesLow,
+    requiredNativeTypesHigh
+  });
+  const capture = Object.freeze({
+    ...bubble,
+    normalizedKey: `${definition.type}Capture`
+  });
+  eventPropMetadata[definition.prop] = bubble;
+  eventPropMetadata[definition.captureProp] = capture;
+}
+const cursorNativeTypes = expandNativeTypesForMetadata(/* @__PURE__ */ new Set(), true);
+let cursorNativeTypesLow = 0;
+let cursorNativeTypesHigh = 0;
+for (const type of cursorNativeTypes) {
+  const index = eventIndexByType[type];
+  if (index < 32) {
+    cursorNativeTypesLow |= 1 << index;
+  } else {
+    cursorNativeTypesHigh |= 1 << index - 32;
+  }
+}
+function createHandlerState() {
+  return {
+    handlers: {},
+    handlerTypesLow: 0,
+    handlerTypesHigh: 0,
+    requiredNativeTypesLow: 0,
+    requiredNativeTypesHigh: 0
+  };
+}
+function refreshHandlers(state, handlers, hasCursor) {
+  const normalized = {};
+  let handlerTypesLow = 0;
+  let handlerTypesHigh = 0;
+  let requiredNativeTypesLow = hasCursor ? cursorNativeTypesLow : 0;
+  let requiredNativeTypesHigh = hasCursor ? cursorNativeTypesHigh : 0;
+  for (const prop in handlers) {
+    const metadata = eventPropMetadata[prop];
+    if (!metadata) continue;
+    const handler = handlers[prop];
+    if (handler) {
+      normalized[metadata.normalizedKey] = handler;
+      handlerTypesLow |= metadata.handlerTypesLow;
+      handlerTypesHigh |= metadata.handlerTypesHigh;
+      requiredNativeTypesLow |= metadata.requiredNativeTypesLow;
+      requiredNativeTypesHigh |= metadata.requiredNativeTypesHigh;
+    }
+  }
+  state.handlers = normalized;
+  state.handlerTypesLow = handlerTypesLow;
+  state.handlerTypesHigh = handlerTypesHigh;
+  state.requiredNativeTypesLow = requiredNativeTypesLow;
+  state.requiredNativeTypesHigh = requiredNativeTypesHigh;
+}
+function expandNativeTypesForMetadata(types, hasCursor) {
+  const nativeTypes = new Set(types);
+  const hasPointerBoundary = types.has("pointerover") || types.has("pointerenter") || types.has("pointerout") || types.has("pointerleave");
+  if (hasPointerBoundary || types.has("pointermove")) {
+    nativeTypes.delete("pointerenter");
+    nativeTypes.delete("pointerleave");
+    nativeTypes.add("pointermove");
+    nativeTypes.add("pointerout");
+    if (hasPointerBoundary) nativeTypes.add("pointerover");
+  }
+  if (hasCursor || types.has("mouseover") || types.has("mouseenter") || types.has("mousemove") || types.has("mouseout") || types.has("mouseleave")) {
+    nativeTypes.delete("mouseover");
+    nativeTypes.delete("mouseenter");
+    nativeTypes.delete("mouseleave");
+    nativeTypes.add("mousemove");
+    nativeTypes.add("mouseout");
+  }
+  if (types.has("click") || types.has("dblclick") || types.has("auxclick")) {
+    nativeTypes.add("mousedown");
+    nativeTypes.add("mouseup");
+  }
+  if (types.has("dblclick")) nativeTypes.add("click");
+  if (types.has("touchstart") || types.has("touchmove") || types.has("touchend") || types.has("touchcancel")) {
+    nativeTypes.add("touchstart");
+    nativeTypes.add("touchend");
+    nativeTypes.add("touchcancel");
+  }
+  const hasDragBoundary = types.has("dragenter") || types.has("dragleave");
+  if (hasDragBoundary) nativeTypes.add("dragenter");
+  if (hasDragBoundary || types.has("dragover")) {
+    nativeTypes.add("dragover");
+    nativeTypes.add("dragleave");
+    nativeTypes.add("drop");
+    nativeTypes.add("dragend");
+  }
+  return nativeTypes;
+}
+function updateNativeOwnership(registration) {
+  const previousLow = registration.ownedNativeTypesLow;
+  const previousHigh = registration.ownedNativeTypesHigh;
+  const nextLow = registration.requiredNativeTypesLow;
+  const nextHigh = registration.requiredNativeTypesHigh;
+  if (previousLow === nextLow && previousHigh === nextHigh) return;
+  let releases = nativeReleases.get(registration);
+  if (!releases) {
+    releases = /* @__PURE__ */ new Map();
+    nativeReleases.set(registration, releases);
+  }
+  forEachChangedType(
+    previousLow & ~nextLow,
+    previousHigh & ~nextHigh,
+    (type) => {
+      releases.get(type)?.();
+      releases.delete(type);
+    }
+  );
+  const hub = registration.owner.eventRoot.nativeListeners;
+  if (hub) {
+    forEachChangedType(
+      nextLow & ~previousLow,
+      nextHigh & ~previousHigh,
+      (type) => {
+        if (!releases.has(type)) releases.set(type, hub.acquire(type));
+      }
+    );
+  }
+  registration.ownedNativeTypesLow = nextLow;
+  registration.ownedNativeTypesHigh = nextHigh;
+}
+function releaseNativeOwnership(registration) {
+  registration.ownedNativeTypesLow = 0;
+  registration.ownedNativeTypesHigh = 0;
+  const releases = nativeReleases.get(registration);
+  if (!releases) return;
+  nativeReleases.delete(registration);
+  for (const release of releases.values()) {
+    release();
+  }
+  releases.clear();
+}
+function forEachChangedType(low, high, visit) {
+  while (low !== 0) {
+    const bit = low & -low;
+    visit(PIBBL_EVENT_DEFINITIONS[31 - Math.clz32(bit)].type);
+    low &= low - 1;
+  }
+  while (high !== 0) {
+    const bit = high & -high;
+    visit(PIBBL_EVENT_DEFINITIONS[32 + 31 - Math.clz32(bit)].type);
+    high &= high - 1;
+  }
+}
+function createPublicTarget(getRegistration) {
+  return {
+    setPointerCapture(pointerId) {
+      setLogicalPointerCapture(getRegistration(), pointerId);
+    },
+    hasPointerCapture(pointerId) {
+      return hasLogicalPointerCapture(getRegistration(), pointerId);
+    },
+    releasePointerCapture(pointerId) {
+      releaseLogicalPointerCapture(getRegistration(), pointerId);
+    }
+  };
+}
+export {
+  createListener,
+  createTarget,
+  normalizeHandlers,
+  releaseListener,
+  releaseTarget,
+  updateCursorTarget,
+  updateListener,
+  updateTarget
+};
+//# sourceMappingURL=registrations.js.map

package/dist/lib/events/registrations.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/events/registrations.ts"],
+  "sourcesContent": ["import type { PibblHitTestOutput } from './paint-entry.js';\nimport type { isBackendEventTargetLive, useBackendEventTarget } from '../../internal.js';\nimport { PIBBL_EVENT_DEFINITIONS } from \"./event-definitions.js\";\nimport type {\n  PibblEventHandler,\n  PibblEventHandlers,\n  PibblEventTarget,\n  PibblEventTargetOptions,\n  PibblEventType,\n} from \"./types.js\";\nimport { GLOBAL_STATE } from \"../global-state.js\";\nimport { resolvePath } from '../geometry/resolve-path.js';\nimport type { PathGeometry } from '../geometry/path-geometry.js';\nimport type { LayoutBox } from \"../layout/types.js\";\nimport { getCurrentWorldTransform } from \"../render-target.js\";\nimport type {\n  PibblComponentRefs,\n  PibblInstance,\n} from \"../types.js\";\nimport { PibblPaintEntryKind, type PibblPathPaintEntry } from \"./paint-entry.js\";\nimport {\n  clearPointerCapturesForTarget,\n  hasLogicalPointerCapture,\n  releaseLogicalPointerCapture,\n  setLogicalPointerCapture,\n} from \"./pointer-capture.js\";\n\ntype PibblNormalizedCaptureKey = `${PibblEventType}Capture`;\n\nexport type PibblNormalizedHandlers = Partial<\n  {\n    [K in PibblEventType]: PibblEventHandler<K>;\n  } & {\n    [K in PibblEventType as `${K}Capture`]: PibblEventHandler<K>;\n  }\n>;\n\n/**\n * Mount-owned event target registration and cleanup state.\n *\n * @see {@link PibblEventTarget}\n * @see {@link LayoutBox}\n * @see {@link PibblHitTestOutput}\n * @see {@link useBackendEventTarget}\n * @see {@link isBackendEventTargetLive}\n */\nexport interface PibblEventTargetRegistration {\n  /** Selects the kind of geometry, material, or result. See {@link PibblEventTargetRegistration}. */\n  readonly kind: \"target\";\n  /** Mount or runtime resource owning this registration. See {@link PibblInstance}. */\n  readonly owner: PibblInstance;\n  /**\n   * Component identity or diagnostic name associated with this value. See {@link PibblComponentRefs}\n   * .\n   */\n  readonly component: PibblComponentRefs<any>;\n  /** Mount-local hook or registration slot. See {@link PibblEventTargetRegistration}. */\n  readonly slot: number;\n  /** Logical target exposed to application event handlers. See {@link PibblEventTarget}. */\n  readonly publicTarget: PibblEventTarget;\n  /** Paint-ledger entry associated with this registration. See {@link PibblPathPaintEntry}. */\n  paintEntry: PibblPathPaintEntry | undefined;\n  /** Event handlers dispatched for this logical target. See {@link PibblNormalizedHandlers}. */\n  handlers: PibblNormalizedHandlers;\n  /** Logical event types currently present in `handlers`, split across two 32-bit words. */\n  handlerTypesLow: number;\n  /**\n   * High event-mask bits identifying registered handler types. See\n   * {@link PibblEventTargetRegistration}.\n   */\n  handlerTypesHigh: number;\n  /** Native event dependency signature derived from the current handlers and cursor. */\n  requiredNativeTypesLow: number;\n  /**\n   * High event-mask bits identifying required native listeners. See\n   * {@link PibblEventTargetRegistration}.\n   */\n  requiredNativeTypesHigh: number;\n  /** Last native signature reconciled with `nativeReleases`. */\n  ownedNativeTypesLow: number;\n  /**\n   * High event-mask bits identifying native listeners owned by this registration. See\n   * {@link PibblEventTargetRegistration}.\n   */\n  ownedNativeTypesHigh: number;\n  /**\n   * Cursor shown while this target owns pointer presentation. See\n   * {@link PibblEventTargetRegistration}.\n   */\n  cursor: string | undefined;\n  /** Whether the target may receive keyboard focus. See {@link PibblEventTargetRegistration}. */\n  keyboardFocusable: boolean | undefined;\n  /** Logical rectangle used for directional keyboard navigation. See {@link LayoutBox}. */\n  keyboardNavigationBounds: Readonly<LayoutBox> | undefined;\n  /** @internal Backend-projected points retained until root-space resolution. */\n  keyboardNavigationPoints:\n    | readonly Readonly<{\n        /**\n         * Horizontal coordinate or displacement in the containing coordinate system. See\n         * {@link PibblEventTargetRegistration}.\n         */\n        x: number;\n        /**\n         * Vertical coordinate or displacement in the containing coordinate system. See\n         * {@link PibblEventTargetRegistration}.\n         */\n        y: number;\n      }>[]\n    | undefined;\n  /**\n   * Whether this registration is currently attached to a live owner. See\n   * {@link PibblEventTargetRegistration}.\n   */\n  live: boolean;\n}\n\nexport interface PibblEventListenerRegistration {\n  readonly kind: \"listener\";\n  readonly owner: PibblInstance;\n  readonly component: PibblComponentRefs<any>;\n  readonly slot: number;\n  readonly publicTarget: PibblEventTarget;\n  handlers: PibblNormalizedHandlers;\n  /** Logical event types currently present in `handlers`, split across two 32-bit words. */\n  handlerTypesLow: number;\n  handlerTypesHigh: number;\n  /** Native event dependency signature derived from the current handlers. */\n  requiredNativeTypesLow: number;\n  requiredNativeTypesHigh: number;\n  /** Last native signature reconciled with `nativeReleases`. */\n  ownedNativeTypesLow: number;\n  ownedNativeTypesHigh: number;\n  live: boolean;\n}\n\nexport type PibblEventNode =\n  PibblEventTargetRegistration | PibblEventListenerRegistration;\n\n// Masks make membership/diff checks cheap; this map retains the exact release\n// closure returned by the shared hub for each bit that was actually acquired.\nconst nativeReleases = new WeakMap<\n  PibblEventTargetRegistration | PibblEventListenerRegistration,\n  Map<PibblEventType, () => void>\n>();\n\nexport function createTarget(\n  owner: PibblInstance,\n  component: PibblComponentRefs<any>,\n  slot: number,\n): PibblEventTargetRegistration {\n  const target = {} as PibblEventTargetRegistration;\n  const publicTarget = createPublicTarget(() => target);\n  Object.assign(target, {\n    kind: \"target\" as const,\n    owner,\n    component,\n    slot,\n    publicTarget,\n    paintEntry: undefined,\n    handlers: {},\n    handlerTypesLow: 0,\n    handlerTypesHigh: 0,\n    requiredNativeTypesLow: 0,\n    requiredNativeTypesHigh: 0,\n    ownedNativeTypesLow: 0,\n    ownedNativeTypesHigh: 0,\n    cursor: undefined,\n    keyboardFocusable: undefined,\n    keyboardNavigationBounds: undefined,\n    keyboardNavigationPoints: undefined,\n    live: false,\n  });\n  return target;\n}\n\nexport function updateTarget(\n  target: PibblEventTargetRegistration,\n  handlers: PibblEventHandlers,\n  options: PibblEventTargetOptions,\n  participatesInPaint = false,\n  preserveKeyboardNavigationGeometry = false,\n): void {\n  updateTargetRegistration(\n    target,\n    handlers,\n    { ...options, path: resolvePath(options.path) },\n    participatesInPaint,\n    preserveKeyboardNavigationGeometry,\n  );\n  if (target.live) target.owner.regions.add(target);\n}\n\nexport function updateCursorTarget(\n  target: PibblEventTargetRegistration,\n  {\n    path,\n    fill = false,\n    lineInteractionWidth = 0,\n    cursor,\n  }: {\n    path: Path2D | PathGeometry;\n    fill?: boolean;\n    lineInteractionWidth?: number;\n    cursor?: string;\n  },\n): void {\n  updateTargetRegistration(\n    target,\n    {},\n    {\n      path: resolvePath(path),\n      fill,\n      lineInteractionWidth,\n      cursor,\n    },\n  );\n  if (target.live) target.owner.regions.add(target);\n}\n\nfunction updateTargetRegistration(\n  target: PibblEventTargetRegistration,\n  handlers: PibblEventHandlers,\n  options: Omit<PibblEventTargetOptions, 'path'> & { readonly path: Path2D },\n  participatesInPaint = false,\n  preserveKeyboardNavigationGeometry = false,\n): void {\n  if (target.live) {\n    // Remove while the previous handler map is still current so ownership\n    // diagnostics and mutation observers attribute the release correctly.\n    if (target.paintEntry) target.owner.paintEntries.delete(target.paintEntry);\n    target.owner.eventRoot.targets.delete(target);\n  }\n\n  refreshHandlers(target, handlers, Boolean(options.cursor));\n  const paintEntry =\n    target.paintEntry ??\n    ({\n      paintKind: PibblPaintEntryKind.Path,\n    } as PibblPathPaintEntry);\n  paintEntry.target = target;\n  paintEntry.path = options.path;\n  paintEntry.fill = options.fill ?? false;\n  paintEntry.lineInteractionWidth = options.lineInteractionWidth ?? 0;\n  if (GLOBAL_STATE.renderContext) {\n    paintEntry.transform = getCurrentWorldTransform();\n    paintEntry.clippingStack = Array.from(GLOBAL_STATE.clippingStack);\n  } else {\n    paintEntry.transform ??= new DOMMatrix();\n    paintEntry.clippingStack ??= [];\n  }\n  target.cursor = options.cursor;\n  target.keyboardFocusable = options.keyboardFocusable;\n  if (!preserveKeyboardNavigationGeometry) {\n    target.keyboardNavigationBounds = options.keyboardNavigationBounds;\n    target.keyboardNavigationPoints = undefined;\n  }\n\n  if (\n    !participatesInPaint &&\n    target.handlerTypesLow === 0 &&\n    target.handlerTypesHigh === 0 &&\n    !target.cursor &&\n    target.keyboardFocusable !== true\n  ) {\n    if (target.live) {\n      target.owner.eventRoot.focusPolicy?.removeTarget(target);\n      target.owner.eventRoot.onNodeRelease?.(target);\n    }\n    target.owner.regions.delete(target);\n    target.paintEntry = undefined;\n    target.live = false;\n    clearPointerCapturesForTarget(target);\n    releaseNativeOwnership(target);\n    return;\n  }\n\n  target.live = true;\n  target.paintEntry = paintEntry;\n  target.owner.paintEntries.add(paintEntry);\n  target.owner.eventRoot.targets.add(target);\n  updateNativeOwnership(target);\n  target.owner.eventRoot.focusPolicy?.observeTarget(target);\n  target.owner.eventRoot.onTargetUpdate?.(target);\n}\n\nexport function releaseTarget(target: PibblEventTargetRegistration): void {\n  if (target.live) {\n    if (target.paintEntry) target.owner.paintEntries.delete(target.paintEntry);\n    target.owner.eventRoot.targets.delete(target);\n    target.owner.eventRoot.focusPolicy?.removeTarget(target);\n    target.owner.eventRoot.onNodeRelease?.(target);\n  }\n  target.owner.regions.delete(target);\n  target.paintEntry = undefined;\n  target.live = false;\n  clearPointerCapturesForTarget(target);\n  releaseNativeOwnership(target);\n}\n\nexport function createListener(\n  owner: PibblInstance,\n  component: PibblComponentRefs<any>,\n  slot: number,\n): PibblEventListenerRegistration {\n  const listener = {} as PibblEventListenerRegistration;\n  const publicTarget = createPublicTarget(() => listener);\n  Object.assign(listener, {\n    kind: \"listener\",\n    owner,\n    component,\n    slot,\n    publicTarget,\n    handlers: {},\n    handlerTypesLow: 0,\n    handlerTypesHigh: 0,\n    requiredNativeTypesLow: 0,\n    requiredNativeTypesHigh: 0,\n    ownedNativeTypesLow: 0,\n    ownedNativeTypesHigh: 0,\n    live: false,\n  });\n  return listener;\n}\n\nexport function updateListener(\n  listener: PibblEventListenerRegistration,\n  handlers: PibblEventHandlers,\n): void {\n  let registrations = listener.owner.eventRoot.listenersByComponent.get(\n    listener.component.id,\n  );\n  if (listener.live) {\n    // Keep the registration stable while refreshing its current source-order\n    // position and preserving the previous handler map for release observers.\n    registrations?.delete(listener);\n  }\n  refreshHandlers(listener, handlers, false);\n\n  if (listener.handlerTypesLow === 0 && listener.handlerTypesHigh === 0) {\n    if (registrations?.size === 0) {\n      listener.owner.eventRoot.listenersByComponent.delete(\n        listener.component.id,\n      );\n    }\n    if (listener.live) listener.owner.eventRoot.onNodeRelease?.(listener);\n    listener.live = false;\n    clearPointerCapturesForTarget(listener);\n    releaseNativeOwnership(listener);\n    return;\n  }\n\n  if (!registrations) {\n    registrations = new Set();\n    listener.owner.eventRoot.listenersByComponent.set(\n      listener.component.id,\n      registrations,\n    );\n  }\n  registrations.add(listener);\n  listener.live = true;\n  updateNativeOwnership(listener);\n}\n\nexport function releaseListener(listener: PibblEventListenerRegistration): void {\n  if (listener.live) {\n    const registrations = listener.owner.eventRoot.listenersByComponent.get(\n      listener.component.id,\n    );\n    registrations?.delete(listener);\n    if (registrations?.size === 0) {\n      listener.owner.eventRoot.listenersByComponent.delete(\n        listener.component.id,\n      );\n    }\n    listener.owner.eventRoot.onNodeRelease?.(listener);\n  }\n  listener.live = false;\n  clearPointerCapturesForTarget(listener);\n  releaseNativeOwnership(listener);\n}\n\nexport function normalizeHandlers(\n  handlers: PibblEventHandlers,\n): PibblNormalizedHandlers {\n  const state = createHandlerState();\n  refreshHandlers(state, handlers, false);\n  return state.handlers;\n}\n\ninterface PibblHandlerState {\n  handlers: PibblNormalizedHandlers;\n  handlerTypesLow: number;\n  handlerTypesHigh: number;\n  requiredNativeTypesLow: number;\n  requiredNativeTypesHigh: number;\n}\n\ninterface PibblEventPropMetadata {\n  readonly normalizedKey: PibblEventType | PibblNormalizedCaptureKey;\n  readonly handlerTypesLow: number;\n  readonly handlerTypesHigh: number;\n  readonly requiredNativeTypesLow: number;\n  readonly requiredNativeTypesHigh: number;\n}\n\n/**\n * Hot-path property lookup built once from the closed event vocabulary.\n *\n * Each definition owns one bit position. JavaScript bitwise operators use\n * signed 32-bit integers, but sign is irrelevant here: the words are opaque\n * bit sets compared and combined only with bitwise operations.\n */\nconst eventPropMetadata = Object.create(null) as Record<\n  string,\n  PibblEventPropMetadata | undefined\n>;\nconst eventIndexByType = Object.create(null) as Record<\n  string,\n  number | undefined\n>;\n\nif (PIBBL_EVENT_DEFINITIONS.length > 64) {\n  throw new Error(\"Pibbl event masks support at most 64 logical event types.\");\n}\n\nfor (let index = 0; index < PIBBL_EVENT_DEFINITIONS.length; index++) {\n  eventIndexByType[PIBBL_EVENT_DEFINITIONS[index]!.type] = index;\n}\n\nfor (let index = 0; index < PIBBL_EVENT_DEFINITIONS.length; index++) {\n  const definition = PIBBL_EVENT_DEFINITIONS[index]!;\n  const handlerTypesLow = index < 32 ? 1 << index : 0;\n  const handlerTypesHigh = index < 32 ? 0 : 1 << (index - 32);\n  // Expand logical-to-native prerequisites once. The render path only ORs\n  // these precomputed words and never allocates dependency Sets.\n  const nativeTypes = expandNativeTypesForMetadata(\n    new Set([definition.type]),\n    false,\n  );\n  let requiredNativeTypesLow = 0;\n  let requiredNativeTypesHigh = 0;\n  for (const type of nativeTypes) {\n    const nativeIndex = eventIndexByType[type]!;\n    if (nativeIndex < 32) {\n      requiredNativeTypesLow |= 1 << nativeIndex;\n    } else {\n      requiredNativeTypesHigh |= 1 << (nativeIndex - 32);\n    }\n  }\n  const bubble: PibblEventPropMetadata = Object.freeze({\n    normalizedKey: definition.type,\n    handlerTypesLow,\n    handlerTypesHigh,\n    requiredNativeTypesLow,\n    requiredNativeTypesHigh,\n  });\n  const capture: PibblEventPropMetadata = Object.freeze({\n    ...bubble,\n    normalizedKey: `${definition.type}Capture` as PibblNormalizedCaptureKey,\n  });\n  eventPropMetadata[definition.prop] = bubble;\n  eventPropMetadata[definition.captureProp] = capture;\n}\n\n// Cursor tracking has native movement/exit requirements even without a\n// logical callback, so it receives the same precomputed representation.\nconst cursorNativeTypes = expandNativeTypesForMetadata(new Set(), true);\nlet cursorNativeTypesLow = 0;\nlet cursorNativeTypesHigh = 0;\nfor (const type of cursorNativeTypes) {\n  const index = eventIndexByType[type]!;\n  if (index < 32) {\n    cursorNativeTypesLow |= 1 << index;\n  } else {\n    cursorNativeTypesHigh |= 1 << (index - 32);\n  }\n}\n\nfunction createHandlerState(): PibblHandlerState {\n  return {\n    handlers: {},\n    handlerTypesLow: 0,\n    handlerTypesHigh: 0,\n    requiredNativeTypesLow: 0,\n    requiredNativeTypesHigh: 0,\n  };\n}\n\nfunction refreshHandlers(\n  state: PibblHandlerState,\n  handlers: PibblEventHandlers,\n  hasCursor: boolean,\n): void {\n  const normalized: PibblNormalizedHandlers = {};\n  let handlerTypesLow = 0;\n  let handlerTypesHigh = 0;\n  let requiredNativeTypesLow = hasCursor ? cursorNativeTypesLow : 0;\n  let requiredNativeTypesHigh = hasCursor ? cursorNativeTypesHigh : 0;\n  // Iterate supplied props rather than probing every supported bubble and\n  // capture name. Keep the normalized object fresh so dispatch always sees\n  // the newest closures even when the type signature is unchanged.\n  for (const prop in handlers) {\n    const metadata = eventPropMetadata[prop];\n    if (!metadata) continue;\n    const handler = handlers[prop as keyof PibblEventHandlers];\n    if (handler) {\n      (normalized as Record<string, unknown>)[metadata.normalizedKey] = handler;\n      handlerTypesLow |= metadata.handlerTypesLow;\n      handlerTypesHigh |= metadata.handlerTypesHigh;\n      requiredNativeTypesLow |= metadata.requiredNativeTypesLow;\n      requiredNativeTypesHigh |= metadata.requiredNativeTypesHigh;\n    }\n  }\n  state.handlers = normalized;\n  state.handlerTypesLow = handlerTypesLow;\n  state.handlerTypesHigh = handlerTypesHigh;\n  state.requiredNativeTypesLow = requiredNativeTypesLow;\n  state.requiredNativeTypesHigh = requiredNativeTypesHigh;\n}\n\n/**\n * Cold module-initialization helper. Do not call this from registration or\n * render code: its Sets deliberately trade startup simplicity for precomputed\n * allocation-free metadata in the hot path.\n */\nfunction expandNativeTypesForMetadata(\n  types: ReadonlySet<PibblEventType>,\n  hasCursor: boolean,\n): ReadonlySet<PibblEventType> {\n  const nativeTypes = new Set(types);\n  const hasPointerBoundary =\n    types.has(\"pointerover\") ||\n    types.has(\"pointerenter\") ||\n    types.has(\"pointerout\") ||\n    types.has(\"pointerleave\");\n  if (hasPointerBoundary || types.has(\"pointermove\")) {\n    nativeTypes.delete(\"pointerenter\");\n    nativeTypes.delete(\"pointerleave\");\n    nativeTypes.add(\"pointermove\");\n    nativeTypes.add(\"pointerout\");\n    if (hasPointerBoundary) nativeTypes.add(\"pointerover\");\n  }\n  if (\n    hasCursor ||\n    types.has(\"mouseover\") ||\n    types.has(\"mouseenter\") ||\n    types.has(\"mousemove\") ||\n    types.has(\"mouseout\") ||\n    types.has(\"mouseleave\")\n  ) {\n    nativeTypes.delete(\"mouseover\");\n    nativeTypes.delete(\"mouseenter\");\n    nativeTypes.delete(\"mouseleave\");\n    nativeTypes.add(\"mousemove\");\n    nativeTypes.add(\"mouseout\");\n  }\n  if (types.has(\"click\") || types.has(\"dblclick\") || types.has(\"auxclick\")) {\n    nativeTypes.add(\"mousedown\");\n    nativeTypes.add(\"mouseup\");\n  }\n  if (types.has(\"dblclick\")) nativeTypes.add(\"click\");\n  if (\n    types.has(\"touchstart\") ||\n    types.has(\"touchmove\") ||\n    types.has(\"touchend\") ||\n    types.has(\"touchcancel\")\n  ) {\n    nativeTypes.add(\"touchstart\");\n    nativeTypes.add(\"touchend\");\n    nativeTypes.add(\"touchcancel\");\n  }\n  const hasDragBoundary = types.has(\"dragenter\") || types.has(\"dragleave\");\n  if (hasDragBoundary) nativeTypes.add(\"dragenter\");\n  if (hasDragBoundary || types.has(\"dragover\")) {\n    nativeTypes.add(\"dragover\");\n    nativeTypes.add(\"dragleave\");\n    nativeTypes.add(\"drop\");\n    nativeTypes.add(\"dragend\");\n  }\n  return nativeTypes;\n}\n\nfunction updateNativeOwnership(\n  registration: PibblEventTargetRegistration | PibblEventListenerRegistration,\n): void {\n  const previousLow = registration.ownedNativeTypesLow;\n  const previousHigh = registration.ownedNativeTypesHigh;\n  const nextLow = registration.requiredNativeTypesLow;\n  const nextHigh = registration.requiredNativeTypesHigh;\n  // Callback values may change every render while their native requirements\n  // remain identical. Two integer comparisons make that common case a no-op.\n  if (previousLow === nextLow && previousHigh === nextHigh) return;\n\n  let releases = nativeReleases.get(registration);\n  if (!releases) {\n    releases = new Map();\n    nativeReleases.set(registration, releases);\n  }\n\n  // A & ~B is the set difference A \u2212 B. Release all removals before\n  // acquiring additions so hub reference counts always describe this target's\n  // current requirement transition.\n  forEachChangedType(\n    previousLow & ~nextLow,\n    previousHigh & ~nextHigh,\n    (type) => {\n      releases.get(type)?.();\n      releases.delete(type);\n    },\n  );\n\n  const hub = registration.owner.eventRoot.nativeListeners;\n  if (hub) {\n    // B & ~A is B \u2212 A: only newly required native types are acquired.\n    forEachChangedType(\n      nextLow & ~previousLow,\n      nextHigh & ~previousHigh,\n      (type) => {\n        if (!releases.has(type)) releases.set(type, hub.acquire(type));\n      },\n    );\n  }\n  registration.ownedNativeTypesLow = nextLow;\n  registration.ownedNativeTypesHigh = nextHigh;\n}\n\nfunction releaseNativeOwnership(\n  registration: PibblEventTargetRegistration | PibblEventListenerRegistration,\n): void {\n  // Zero first so a stable hook slot revived after release cannot mistake its\n  // old signature for live ownership and skip reacquisition.\n  registration.ownedNativeTypesLow = 0;\n  registration.ownedNativeTypesHigh = 0;\n  const releases = nativeReleases.get(registration);\n  if (!releases) return;\n  nativeReleases.delete(registration);\n  for (const release of releases.values()) {\n    release();\n  }\n  releases.clear();\n}\n\nfunction forEachChangedType(\n  low: number,\n  high: number,\n  visit: (type: PibblEventType) => void,\n): void {\n  // `word & -word` isolates the least-significant set bit. `word & (word - 1)`\n  // clears it, so this loop is O(number of changed types), not O(52 events).\n  // Math.clz32 converts the isolated bit to its definition index; the high\n  // word starts at definition 32.\n  while (low !== 0) {\n    const bit = low & -low;\n    visit(PIBBL_EVENT_DEFINITIONS[31 - Math.clz32(bit)]!.type);\n    low &= low - 1;\n  }\n  while (high !== 0) {\n    const bit = high & -high;\n    visit(PIBBL_EVENT_DEFINITIONS[32 + 31 - Math.clz32(bit)]!.type);\n    high &= high - 1;\n  }\n}\n\nfunction createPublicTarget(\n  getRegistration: () => PibblEventNode,\n): PibblEventTarget {\n  return {\n    setPointerCapture(pointerId) {\n      setLogicalPointerCapture(getRegistration(), pointerId);\n    },\n    hasPointerCapture(pointerId) {\n      return hasLogicalPointerCapture(getRegistration(), pointerId);\n    },\n    releasePointerCapture(pointerId) {\n      releaseLogicalPointerCapture(getRegistration(), pointerId);\n    },\n  };\n}\n"],
+  "mappings": "AAEA,SAAS,+BAA+B;AAQxC,SAAS,oBAAoB;AAC7B,SAAS,mBAAmB;AAG5B,SAAS,gCAAgC;AAKzC,SAAS,2BAAqD;AAC9D;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAmHP,MAAM,iBAAiB,oBAAI,QAGzB;AAEK,SAAS,aACd,OACA,WACA,MAC8B;AAC9B,QAAM,SAAS,CAAC;AAChB,QAAM,eAAe,mBAAmB,MAAM,MAAM;AACpD,SAAO,OAAO,QAAQ;AAAA,IACpB,MAAM;AAAA,IACN;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,YAAY;AAAA,IACZ,UAAU,CAAC;AAAA,IACX,iBAAiB;AAAA,IACjB,kBAAkB;AAAA,IAClB,wBAAwB;AAAA,IACxB,yBAAyB;AAAA,IACzB,qBAAqB;AAAA,IACrB,sBAAsB;AAAA,IACtB,QAAQ;AAAA,IACR,mBAAmB;AAAA,IACnB,0BAA0B;AAAA,IAC1B,0BAA0B;AAAA,IAC1B,MAAM;AAAA,EACR,CAAC;AACD,SAAO;AACT;AAEO,SAAS,aACd,QACA,UACA,SACA,sBAAsB,OACtB,qCAAqC,OAC/B;AACN;AAAA,IACE;AAAA,IACA;AAAA,IACA,EAAE,GAAG,SAAS,MAAM,YAAY,QAAQ,IAAI,EAAE;AAAA,IAC9C;AAAA,IACA;AAAA,EACF;AACA,MAAI,OAAO,KAAM,QAAO,MAAM,QAAQ,IAAI,MAAM;AAClD;AAEO,SAAS,mBACd,QACA;AAAA,EACE;AAAA,EACA,OAAO;AAAA,EACP,uBAAuB;AAAA,EACvB;AACF,GAMM;AACN;AAAA,IACE;AAAA,IACA,CAAC;AAAA,IACD;AAAA,MACE,MAAM,YAAY,IAAI;AAAA,MACtB;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AACA,MAAI,OAAO,KAAM,QAAO,MAAM,QAAQ,IAAI,MAAM;AAClD;AAEA,SAAS,yBACP,QACA,UACA,SACA,sBAAsB,OACtB,qCAAqC,OAC/B;AACN,MAAI,OAAO,MAAM;AAGf,QAAI,OAAO,WAAY,QAAO,MAAM,aAAa,OAAO,OAAO,UAAU;AACzE,WAAO,MAAM,UAAU,QAAQ,OAAO,MAAM;AAAA,EAC9C;AAEA,kBAAgB,QAAQ,UAAU,QAAQ,QAAQ,MAAM,CAAC;AACzD,QAAM,aACJ,OAAO,cACN;AAAA,IACC,WAAW,oBAAoB;AAAA,EACjC;AACF,aAAW,SAAS;AACpB,aAAW,OAAO,QAAQ;AAC1B,aAAW,OAAO,QAAQ,QAAQ;AAClC,aAAW,uBAAuB,QAAQ,wBAAwB;AAClE,MAAI,aAAa,eAAe;AAC9B,eAAW,YAAY,yBAAyB;AAChD,eAAW,gBAAgB,MAAM,KAAK,aAAa,aAAa;AAAA,EAClE,OAAO;AACL,eAAW,cAAc,IAAI,UAAU;AACvC,eAAW,kBAAkB,CAAC;AAAA,EAChC;AACA,SAAO,SAAS,QAAQ;AACxB,SAAO,oBAAoB,QAAQ;AACnC,MAAI,CAAC,oCAAoC;AACvC,WAAO,2BAA2B,QAAQ;AAC1C,WAAO,2BAA2B;AAAA,EACpC;AAEA,MACE,CAAC,uBACD,OAAO,oBAAoB,KAC3B,OAAO,qBAAqB,KAC5B,CAAC,OAAO,UACR,OAAO,sBAAsB,MAC7B;AACA,QAAI,OAAO,MAAM;AACf,aAAO,MAAM,UAAU,aAAa,aAAa,MAAM;AACvD,aAAO,MAAM,UAAU,gBAAgB,MAAM;AAAA,IAC/C;AACA,WAAO,MAAM,QAAQ,OAAO,MAAM;AAClC,WAAO,aAAa;AACpB,WAAO,OAAO;AACd,kCAA8B,MAAM;AACpC,2BAAuB,MAAM;AAC7B;AAAA,EACF;AAEA,SAAO,OAAO;AACd,SAAO,aAAa;AACpB,SAAO,MAAM,aAAa,IAAI,UAAU;AACxC,SAAO,MAAM,UAAU,QAAQ,IAAI,MAAM;AACzC,wBAAsB,MAAM;AAC5B,SAAO,MAAM,UAAU,aAAa,cAAc,MAAM;AACxD,SAAO,MAAM,UAAU,iBAAiB,MAAM;AAChD;AAEO,SAAS,cAAc,QAA4C;AACxE,MAAI,OAAO,MAAM;AACf,QAAI,OAAO,WAAY,QAAO,MAAM,aAAa,OAAO,OAAO,UAAU;AACzE,WAAO,MAAM,UAAU,QAAQ,OAAO,MAAM;AAC5C,WAAO,MAAM,UAAU,aAAa,aAAa,MAAM;AACvD,WAAO,MAAM,UAAU,gBAAgB,MAAM;AAAA,EAC/C;AACA,SAAO,MAAM,QAAQ,OAAO,MAAM;AAClC,SAAO,aAAa;AACpB,SAAO,OAAO;AACd,gCAA8B,MAAM;AACpC,yBAAuB,MAAM;AAC/B;AAEO,SAAS,eACd,OACA,WACA,MACgC;AAChC,QAAM,WAAW,CAAC;AAClB,QAAM,eAAe,mBAAmB,MAAM,QAAQ;AACtD,SAAO,OAAO,UAAU;AAAA,IACtB,MAAM;AAAA,IACN;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,UAAU,CAAC;AAAA,IACX,iBAAiB;AAAA,IACjB,kBAAkB;AAAA,IAClB,wBAAwB;AAAA,IACxB,yBAAyB;AAAA,IACzB,qBAAqB;AAAA,IACrB,sBAAsB;AAAA,IACtB,MAAM;AAAA,EACR,CAAC;AACD,SAAO;AACT;AAEO,SAAS,eACd,UACA,UACM;AACN,MAAI,gBAAgB,SAAS,MAAM,UAAU,qBAAqB;AAAA,IAChE,SAAS,UAAU;AAAA,EACrB;AACA,MAAI,SAAS,MAAM;AAGjB,mBAAe,OAAO,QAAQ;AAAA,EAChC;AACA,kBAAgB,UAAU,UAAU,KAAK;AAEzC,MAAI,SAAS,oBAAoB,KAAK,SAAS,qBAAqB,GAAG;AACrE,QAAI,eAAe,SAAS,GAAG;AAC7B,eAAS,MAAM,UAAU,qBAAqB;AAAA,QAC5C,SAAS,UAAU;AAAA,MACrB;AAAA,IACF;AACA,QAAI,SAAS,KAAM,UAAS,MAAM,UAAU,gBAAgB,QAAQ;AACpE,aAAS,OAAO;AAChB,kCAA8B,QAAQ;AACtC,2BAAuB,QAAQ;AAC/B;AAAA,EACF;AAEA,MAAI,CAAC,eAAe;AAClB,oBAAgB,oBAAI,IAAI;AACxB,aAAS,MAAM,UAAU,qBAAqB;AAAA,MAC5C,SAAS,UAAU;AAAA,MACnB;AAAA,IACF;AAAA,EACF;AACA,gBAAc,IAAI,QAAQ;AAC1B,WAAS,OAAO;AAChB,wBAAsB,QAAQ;AAChC;AAEO,SAAS,gBAAgB,UAAgD;AAC9E,MAAI,SAAS,MAAM;AACjB,UAAM,gBAAgB,SAAS,MAAM,UAAU,qBAAqB;AAAA,MAClE,SAAS,UAAU;AAAA,IACrB;AACA,mBAAe,OAAO,QAAQ;AAC9B,QAAI,eAAe,SAAS,GAAG;AAC7B,eAAS,MAAM,UAAU,qBAAqB;AAAA,QAC5C,SAAS,UAAU;AAAA,MACrB;AAAA,IACF;AACA,aAAS,MAAM,UAAU,gBAAgB,QAAQ;AAAA,EACnD;AACA,WAAS,OAAO;AAChB,gCAA8B,QAAQ;AACtC,yBAAuB,QAAQ;AACjC;AAEO,SAAS,kBACd,UACyB;AACzB,QAAM,QAAQ,mBAAmB;AACjC,kBAAgB,OAAO,UAAU,KAAK;AACtC,SAAO,MAAM;AACf;AAyBA,MAAM,oBAAoB,uBAAO,OAAO,IAAI;AAI5C,MAAM,mBAAmB,uBAAO,OAAO,IAAI;AAK3C,IAAI,wBAAwB,SAAS,IAAI;AACvC,QAAM,IAAI,MAAM,2DAA2D;AAC7E;AAEA,SAAS,QAAQ,GAAG,QAAQ,wBAAwB,QAAQ,SAAS;AACnE,mBAAiB,wBAAwB,KAAK,EAAG,IAAI,IAAI;AAC3D;AAEA,SAAS,QAAQ,GAAG,QAAQ,wBAAwB,QAAQ,SAAS;AACnE,QAAM,aAAa,wBAAwB,KAAK;AAChD,QAAM,kBAAkB,QAAQ,KAAK,KAAK,QAAQ;AAClD,QAAM,mBAAmB,QAAQ,KAAK,IAAI,KAAM,QAAQ;AAGxD,QAAM,cAAc;AAAA,IAClB,oBAAI,IAAI,CAAC,WAAW,IAAI,CAAC;AAAA,IACzB;AAAA,EACF;AACA,MAAI,yBAAyB;AAC7B,MAAI,0BAA0B;AAC9B,aAAW,QAAQ,aAAa;AAC9B,UAAM,cAAc,iBAAiB,IAAI;AACzC,QAAI,cAAc,IAAI;AACpB,gCAA0B,KAAK;AAAA,IACjC,OAAO;AACL,iCAA2B,KAAM,cAAc;AAAA,IACjD;AAAA,EACF;AACA,QAAM,SAAiC,OAAO,OAAO;AAAA,IACnD,eAAe,WAAW;AAAA,IAC1B;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AACD,QAAM,UAAkC,OAAO,OAAO;AAAA,IACpD,GAAG;AAAA,IACH,eAAe,GAAG,WAAW,IAAI;AAAA,EACnC,CAAC;AACD,oBAAkB,WAAW,IAAI,IAAI;AACrC,oBAAkB,WAAW,WAAW,IAAI;AAC9C;AAIA,MAAM,oBAAoB,6BAA6B,oBAAI,IAAI,GAAG,IAAI;AACtE,IAAI,uBAAuB;AAC3B,IAAI,wBAAwB;AAC5B,WAAW,QAAQ,mBAAmB;AACpC,QAAM,QAAQ,iBAAiB,IAAI;AACnC,MAAI,QAAQ,IAAI;AACd,4BAAwB,KAAK;AAAA,EAC/B,OAAO;AACL,6BAAyB,KAAM,QAAQ;AAAA,EACzC;AACF;AAEA,SAAS,qBAAwC;AAC/C,SAAO;AAAA,IACL,UAAU,CAAC;AAAA,IACX,iBAAiB;AAAA,IACjB,kBAAkB;AAAA,IAClB,wBAAwB;AAAA,IACxB,yBAAyB;AAAA,EAC3B;AACF;AAEA,SAAS,gBACP,OACA,UACA,WACM;AACN,QAAM,aAAsC,CAAC;AAC7C,MAAI,kBAAkB;AACtB,MAAI,mBAAmB;AACvB,MAAI,yBAAyB,YAAY,uBAAuB;AAChE,MAAI,0BAA0B,YAAY,wBAAwB;AAIlE,aAAW,QAAQ,UAAU;AAC3B,UAAM,WAAW,kBAAkB,IAAI;AACvC,QAAI,CAAC,SAAU;AACf,UAAM,UAAU,SAAS,IAAgC;AACzD,QAAI,SAAS;AACX,MAAC,WAAuC,SAAS,aAAa,IAAI;AAClE,yBAAmB,SAAS;AAC5B,0BAAoB,SAAS;AAC7B,gCAA0B,SAAS;AACnC,iCAA2B,SAAS;AAAA,IACtC;AAAA,EACF;AACA,QAAM,WAAW;AACjB,QAAM,kBAAkB;AACxB,QAAM,mBAAmB;AACzB,QAAM,yBAAyB;AAC/B,QAAM,0BAA0B;AAClC;AAOA,SAAS,6BACP,OACA,WAC6B;AAC7B,QAAM,cAAc,IAAI,IAAI,KAAK;AACjC,QAAM,qBACJ,MAAM,IAAI,aAAa,KACvB,MAAM,IAAI,cAAc,KACxB,MAAM,IAAI,YAAY,KACtB,MAAM,IAAI,cAAc;AAC1B,MAAI,sBAAsB,MAAM,IAAI,aAAa,GAAG;AAClD,gBAAY,OAAO,cAAc;AACjC,gBAAY,OAAO,cAAc;AACjC,gBAAY,IAAI,aAAa;AAC7B,gBAAY,IAAI,YAAY;AAC5B,QAAI,mBAAoB,aAAY,IAAI,aAAa;AAAA,EACvD;AACA,MACE,aACA,MAAM,IAAI,WAAW,KACrB,MAAM,IAAI,YAAY,KACtB,MAAM,IAAI,WAAW,KACrB,MAAM,IAAI,UAAU,KACpB,MAAM,IAAI,YAAY,GACtB;AACA,gBAAY,OAAO,WAAW;AAC9B,gBAAY,OAAO,YAAY;AAC/B,gBAAY,OAAO,YAAY;AAC/B,gBAAY,IAAI,WAAW;AAC3B,gBAAY,IAAI,UAAU;AAAA,EAC5B;AACA,MAAI,MAAM,IAAI,OAAO,KAAK,MAAM,IAAI,UAAU,KAAK,MAAM,IAAI,UAAU,GAAG;AACxE,gBAAY,IAAI,WAAW;AAC3B,gBAAY,IAAI,SAAS;AAAA,EAC3B;AACA,MAAI,MAAM,IAAI,UAAU,EAAG,aAAY,IAAI,OAAO;AAClD,MACE,MAAM,IAAI,YAAY,KACtB,MAAM,IAAI,WAAW,KACrB,MAAM,IAAI,UAAU,KACpB,MAAM,IAAI,aAAa,GACvB;AACA,gBAAY,IAAI,YAAY;AAC5B,gBAAY,IAAI,UAAU;AAC1B,gBAAY,IAAI,aAAa;AAAA,EAC/B;AACA,QAAM,kBAAkB,MAAM,IAAI,WAAW,KAAK,MAAM,IAAI,WAAW;AACvE,MAAI,gBAAiB,aAAY,IAAI,WAAW;AAChD,MAAI,mBAAmB,MAAM,IAAI,UAAU,GAAG;AAC5C,gBAAY,IAAI,UAAU;AAC1B,gBAAY,IAAI,WAAW;AAC3B,gBAAY,IAAI,MAAM;AACtB,gBAAY,IAAI,SAAS;AAAA,EAC3B;AACA,SAAO;AACT;AAEA,SAAS,sBACP,cACM;AACN,QAAM,cAAc,aAAa;AACjC,QAAM,eAAe,aAAa;AAClC,QAAM,UAAU,aAAa;AAC7B,QAAM,WAAW,aAAa;AAG9B,MAAI,gBAAgB,WAAW,iBAAiB,SAAU;AAE1D,MAAI,WAAW,eAAe,IAAI,YAAY;AAC9C,MAAI,CAAC,UAAU;AACb,eAAW,oBAAI,IAAI;AACnB,mBAAe,IAAI,cAAc,QAAQ;AAAA,EAC3C;AAKA;AAAA,IACE,cAAc,CAAC;AAAA,IACf,eAAe,CAAC;AAAA,IAChB,CAAC,SAAS;AACR,eAAS,IAAI,IAAI,IAAI;AACrB,eAAS,OAAO,IAAI;AAAA,IACtB;AAAA,EACF;AAEA,QAAM,MAAM,aAAa,MAAM,UAAU;AACzC,MAAI,KAAK;AAEP;AAAA,MACE,UAAU,CAAC;AAAA,MACX,WAAW,CAAC;AAAA,MACZ,CAAC,SAAS;AACR,YAAI,CAAC,SAAS,IAAI,IAAI,EAAG,UAAS,IAAI,MAAM,IAAI,QAAQ,IAAI,CAAC;AAAA,MAC/D;AAAA,IACF;AAAA,EACF;AACA,eAAa,sBAAsB;AACnC,eAAa,uBAAuB;AACtC;AAEA,SAAS,uBACP,cACM;AAGN,eAAa,sBAAsB;AACnC,eAAa,uBAAuB;AACpC,QAAM,WAAW,eAAe,IAAI,YAAY;AAChD,MAAI,CAAC,SAAU;AACf,iBAAe,OAAO,YAAY;AAClC,aAAW,WAAW,SAAS,OAAO,GAAG;AACvC,YAAQ;AAAA,EACV;AACA,WAAS,MAAM;AACjB;AAEA,SAAS,mBACP,KACA,MACA,OACM;AAKN,SAAO,QAAQ,GAAG;AAChB,UAAM,MAAM,MAAM,CAAC;AACnB,UAAM,wBAAwB,KAAK,KAAK,MAAM,GAAG,CAAC,EAAG,IAAI;AACzD,WAAO,MAAM;AAAA,EACf;AACA,SAAO,SAAS,GAAG;AACjB,UAAM,MAAM,OAAO,CAAC;AACpB,UAAM,wBAAwB,KAAK,KAAK,KAAK,MAAM,GAAG,CAAC,EAAG,IAAI;AAC9D,YAAQ,OAAO;AAAA,EACjB;AACF;AAEA,SAAS,mBACP,iBACkB;AAClB,SAAO;AAAA,IACL,kBAAkB,WAAW;AAC3B,+BAAyB,gBAAgB,GAAG,SAAS;AAAA,IACvD;AAAA,IACA,kBAAkB,WAAW;AAC3B,aAAO,yBAAyB,gBAAgB,GAAG,SAAS;AAAA,IAC9D;AAAA,IACA,sBAAsB,WAAW;AAC/B,mCAA6B,gBAAgB,GAAG,SAAS;AAAA,IAC3D;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/lib/events/resolver-input.d.ts

@@ -0,0 +1,25 @@
+import type { PibblEventRoot } from "../types.js";
+import type { PibblHitTestOutput } from "./paint-entry.js";
+export type PibblResolverInputType = "pointerdown" | "pointermove" | "pointerup" | "pointercancel" | "wheel" | "contextmenu" | "click";
+export interface PibblResolverInputWinner {
+    readonly eventRoot: PibblEventRoot;
+    deliver(type: PibblResolverInputType, point: Readonly<{
+        x: number;
+        y: number;
+    }>, originalEvent: PointerEvent | WheelEvent | MouseEvent, state: unknown): void;
+    /** @internal Keeps native terminal pointer delivery alive while captured. */
+    onPointerCaptureChange?(): void;
+}
+export declare function dispatchResolvedInput(output: PibblHitTestOutput, type: PibblResolverInputType, point: Readonly<{
+    x: number;
+    y: number;
+}>, originalEvent: PointerEvent | WheelEvent | MouseEvent): void;
+export declare function getResolverPointerCapture(eventRoot: PibblEventRoot, pointerId: number): PibblResolverInputWinner | undefined;
+export declare function hasResolverPointerCapture(winner: PibblResolverInputWinner): boolean;
+export declare function dispatchCapturedResolverInput(winner: PibblResolverInputWinner, type: "pointermove" | "pointerup" | "pointercancel", point: Readonly<{
+    x: number;
+    y: number;
+}>, originalEvent: PointerEvent): void;
+export declare function setResolverPointerCapture(winner: PibblResolverInputWinner, pointerId: number): void;
+export declare function releaseResolverPointerCapture(winner: PibblResolverInputWinner, pointerId: number): void;
+export declare function releaseResolverInputWinner(winner: PibblResolverInputWinner): void;

package/dist/lib/events/resolver-input.js

@@ -0,0 +1,62 @@
+const pointerCaptures = /* @__PURE__ */ new WeakMap();
+function dispatchResolvedInput(output, type, point, originalEvent) {
+  output.winner?.deliver(type, point, originalEvent, output.winnerState);
+}
+function getResolverPointerCapture(eventRoot, pointerId) {
+  return pointerCaptures.get(eventRoot)?.get(pointerId);
+}
+function hasResolverPointerCapture(winner) {
+  return Array.from(pointerCaptures.get(winner.eventRoot)?.values() ?? []).some(
+    (owner) => owner === winner
+  );
+}
+function dispatchCapturedResolverInput(winner, type, point, originalEvent) {
+  try {
+    winner.deliver(type, point, originalEvent, void 0);
+  } finally {
+    if (type === "pointerup" || type === "pointercancel") {
+      releaseResolverPointerCapture(winner, originalEvent.pointerId);
+    }
+  }
+}
+function setResolverPointerCapture(winner, pointerId) {
+  let captures = pointerCaptures.get(winner.eventRoot);
+  if (!captures) {
+    captures = /* @__PURE__ */ new Map();
+    pointerCaptures.set(winner.eventRoot, captures);
+  }
+  captures.set(pointerId, winner);
+  winner.onPointerCaptureChange?.();
+  try {
+    winner.eventRoot.canvas?.setPointerCapture(pointerId);
+  } catch {
+  }
+}
+function releaseResolverPointerCapture(winner, pointerId) {
+  const captures = pointerCaptures.get(winner.eventRoot);
+  if (captures?.get(pointerId) !== winner) return;
+  captures.delete(pointerId);
+  if (captures.size === 0) pointerCaptures.delete(winner.eventRoot);
+  winner.onPointerCaptureChange?.();
+  try {
+    winner.eventRoot.canvas?.releasePointerCapture(pointerId);
+  } catch {
+  }
+}
+function releaseResolverInputWinner(winner) {
+  const captures = pointerCaptures.get(winner.eventRoot);
+  if (!captures) return;
+  for (const [pointerId, owner] of captures) {
+    if (owner === winner) releaseResolverPointerCapture(winner, pointerId);
+  }
+}
+export {
+  dispatchCapturedResolverInput,
+  dispatchResolvedInput,
+  getResolverPointerCapture,
+  hasResolverPointerCapture,
+  releaseResolverInputWinner,
+  releaseResolverPointerCapture,
+  setResolverPointerCapture
+};
+//# sourceMappingURL=resolver-input.js.map

package/dist/lib/events/resolver-input.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/events/resolver-input.ts"],
+  "sourcesContent": ["import type { PibblEventRoot } from \"../types.js\";\nimport type { PibblHitTestOutput } from \"./paint-entry.js\";\n\nexport type PibblResolverInputType =\n  | \"pointerdown\"\n  | \"pointermove\"\n  | \"pointerup\"\n  | \"pointercancel\"\n  | \"wheel\"\n  | \"contextmenu\"\n  | \"click\";\n\nexport interface PibblResolverInputWinner {\n  readonly eventRoot: PibblEventRoot;\n  deliver(\n    type: PibblResolverInputType,\n    point: Readonly<{ x: number; y: number }>,\n    originalEvent: PointerEvent | WheelEvent | MouseEvent,\n    state: unknown,\n  ): void;\n  /** @internal Keeps native terminal pointer delivery alive while captured. */\n  onPointerCaptureChange?(): void;\n}\n\nconst pointerCaptures = new WeakMap<\n  PibblEventRoot,\n  Map<number, PibblResolverInputWinner>\n>();\n\nexport function dispatchResolvedInput(\n  output: PibblHitTestOutput,\n  type: PibblResolverInputType,\n  point: Readonly<{ x: number; y: number }>,\n  originalEvent: PointerEvent | WheelEvent | MouseEvent,\n): void {\n  output.winner?.deliver(type, point, originalEvent, output.winnerState);\n}\n\nexport function getResolverPointerCapture(\n  eventRoot: PibblEventRoot,\n  pointerId: number,\n): PibblResolverInputWinner | undefined {\n  return pointerCaptures.get(eventRoot)?.get(pointerId);\n}\n\nexport function hasResolverPointerCapture(\n  winner: PibblResolverInputWinner,\n): boolean {\n  return Array.from(pointerCaptures.get(winner.eventRoot)?.values() ?? []).some(\n    (owner) => owner === winner,\n  );\n}\n\nexport function dispatchCapturedResolverInput(\n  winner: PibblResolverInputWinner,\n  type: \"pointermove\" | \"pointerup\" | \"pointercancel\",\n  point: Readonly<{ x: number; y: number }>,\n  originalEvent: PointerEvent,\n): void {\n  try {\n    winner.deliver(type, point, originalEvent, undefined);\n  } finally {\n    if (type === \"pointerup\" || type === \"pointercancel\") {\n      releaseResolverPointerCapture(winner, originalEvent.pointerId);\n    }\n  }\n}\n\nexport function setResolverPointerCapture(\n  winner: PibblResolverInputWinner,\n  pointerId: number,\n): void {\n  let captures = pointerCaptures.get(winner.eventRoot);\n  if (!captures) {\n    captures = new Map();\n    pointerCaptures.set(winner.eventRoot, captures);\n  }\n  captures.set(pointerId, winner);\n  winner.onPointerCaptureChange?.();\n  try {\n    winner.eventRoot.canvas?.setPointerCapture(pointerId);\n  } catch {\n    // Pibbl ownership is authoritative even when native capture is unavailable.\n  }\n}\n\nexport function releaseResolverPointerCapture(\n  winner: PibblResolverInputWinner,\n  pointerId: number,\n): void {\n  const captures = pointerCaptures.get(winner.eventRoot);\n  if (captures?.get(pointerId) !== winner) return;\n  captures.delete(pointerId);\n  if (captures.size === 0) pointerCaptures.delete(winner.eventRoot);\n  winner.onPointerCaptureChange?.();\n  try {\n    winner.eventRoot.canvas?.releasePointerCapture(pointerId);\n  } catch {\n    // Native capture is best-effort; Pibbl ownership has already been released.\n  }\n}\n\nexport function releaseResolverInputWinner(\n  winner: PibblResolverInputWinner,\n): void {\n  const captures = pointerCaptures.get(winner.eventRoot);\n  if (!captures) return;\n  for (const [pointerId, owner] of captures) {\n    if (owner === winner) releaseResolverPointerCapture(winner, pointerId);\n  }\n}\n"],
+  "mappings": "AAwBA,MAAM,kBAAkB,oBAAI,QAG1B;AAEK,SAAS,sBACd,QACA,MACA,OACA,eACM;AACN,SAAO,QAAQ,QAAQ,MAAM,OAAO,eAAe,OAAO,WAAW;AACvE;AAEO,SAAS,0BACd,WACA,WACsC;AACtC,SAAO,gBAAgB,IAAI,SAAS,GAAG,IAAI,SAAS;AACtD;AAEO,SAAS,0BACd,QACS;AACT,SAAO,MAAM,KAAK,gBAAgB,IAAI,OAAO,SAAS,GAAG,OAAO,KAAK,CAAC,CAAC,EAAE;AAAA,IACvE,CAAC,UAAU,UAAU;AAAA,EACvB;AACF;AAEO,SAAS,8BACd,QACA,MACA,OACA,eACM;AACN,MAAI;AACF,WAAO,QAAQ,MAAM,OAAO,eAAe,MAAS;AAAA,EACtD,UAAE;AACA,QAAI,SAAS,eAAe,SAAS,iBAAiB;AACpD,oCAA8B,QAAQ,cAAc,SAAS;AAAA,IAC/D;AAAA,EACF;AACF;AAEO,SAAS,0BACd,QACA,WACM;AACN,MAAI,WAAW,gBAAgB,IAAI,OAAO,SAAS;AACnD,MAAI,CAAC,UAAU;AACb,eAAW,oBAAI,IAAI;AACnB,oBAAgB,IAAI,OAAO,WAAW,QAAQ;AAAA,EAChD;AACA,WAAS,IAAI,WAAW,MAAM;AAC9B,SAAO,yBAAyB;AAChC,MAAI;AACF,WAAO,UAAU,QAAQ,kBAAkB,SAAS;AAAA,EACtD,QAAQ;AAAA,EAER;AACF;AAEO,SAAS,8BACd,QACA,WACM;AACN,QAAM,WAAW,gBAAgB,IAAI,OAAO,SAAS;AACrD,MAAI,UAAU,IAAI,SAAS,MAAM,OAAQ;AACzC,WAAS,OAAO,SAAS;AACzB,MAAI,SAAS,SAAS,EAAG,iBAAgB,OAAO,OAAO,SAAS;AAChE,SAAO,yBAAyB;AAChC,MAAI;AACF,WAAO,UAAU,QAAQ,sBAAsB,SAAS;AAAA,EAC1D,QAAQ;AAAA,EAER;AACF;AAEO,SAAS,2BACd,QACM;AACN,QAAM,WAAW,gBAAgB,IAAI,OAAO,SAAS;AACrD,MAAI,CAAC,SAAU;AACf,aAAW,CAAC,WAAW,KAAK,KAAK,UAAU;AACzC,QAAI,UAAU,OAAQ,+BAA8B,QAAQ,SAAS;AAAA,EACvE;AACF;",
+  "names": []
+}