@pibbl/core 0.0.1

package/dist/lib/events/pointer-capture.js

@@ -0,0 +1,339 @@
+const captureStates = /* @__PURE__ */ new WeakMap();
+function getPointerCaptureStateCounts(eventRoot) {
+  const state = captureStates.get(eventRoot);
+  let activated = 0;
+  let provisional = 0;
+  for (const capture of state?.activeCaptures.values() ?? []) {
+    if (capture.activated) activated++;
+    else provisional++;
+  }
+  return {
+    activated,
+    nativeListenerRequests: state?.nativeReleases?.length ?? 0,
+    pendingLoss: state?.pendingLossOwners.size ?? 0,
+    provisional,
+    releaseTransactions: state?.releaseTransactions.size ?? 0
+  };
+}
+function setLogicalPointerCapture(target, pointerId) {
+  if (!isLiveNode(target)) return;
+  const eventRoot = target.owner.eventRoot;
+  const canvas = eventRoot.canvas;
+  if (!canvas) return;
+  const state = getCaptureState(eventRoot);
+  ensureNativeOwnership(eventRoot, state);
+  const previousTarget = eventRoot.pointerCaptures.get(pointerId);
+  const previousCapture = state.activeCaptures.get(pointerId);
+  const previousTransfer = state.pendingTransfers.get(pointerId);
+  const previousPendingOwner = state.pendingLossOwners.get(pointerId);
+  const activeOwner = previousTransfer ? previousTransfer.from : previousCapture?.activated ? previousCapture.owner : void 0;
+  const hadActiveOverride = previousTransfer !== void 0 || activeOwner !== void 0;
+  const nextTransfer = hadActiveOverride && activeOwner !== target ? { from: activeOwner } : void 0;
+  const nextCapture = nextTransfer ? activeOwner ? previousCapture : { owner: target, activated: false } : { owner: target, activated: activeOwner === target };
+  state.pendingLossOwners.delete(pointerId);
+  eventRoot.pointerCaptures.set(pointerId, target);
+  state.activeCaptures.set(pointerId, nextCapture);
+  if (nextTransfer) state.pendingTransfers.set(pointerId, nextTransfer);
+  else state.pendingTransfers.delete(pointerId);
+  try {
+    canvas.setPointerCapture(pointerId);
+  } catch (error) {
+    const operationStillPending = eventRoot.pointerCaptures.get(pointerId) === target && state.activeCaptures.get(pointerId) === nextCapture && (nextTransfer ? state.pendingTransfers.get(pointerId) === nextTransfer : !state.pendingTransfers.has(pointerId));
+    if (operationStillPending) {
+      if (previousTarget) {
+        eventRoot.pointerCaptures.set(pointerId, previousTarget);
+      } else {
+        eventRoot.pointerCaptures.delete(pointerId);
+      }
+      if (previousCapture) {
+        state.activeCaptures.set(pointerId, previousCapture);
+      } else {
+        state.activeCaptures.delete(pointerId);
+      }
+      if (previousTransfer) {
+        state.pendingTransfers.set(pointerId, previousTransfer);
+      } else {
+        state.pendingTransfers.delete(pointerId);
+      }
+      if (previousPendingOwner) {
+        state.pendingLossOwners.set(pointerId, previousPendingOwner);
+      }
+    }
+    releaseUnusedNativeOwnership(eventRoot, state);
+    throw error;
+  }
+}
+function hasLogicalPointerCapture(target, pointerId) {
+  const eventRoot = target.owner.eventRoot;
+  return eventRoot.pointerCaptures.get(pointerId) === target && eventRoot.canvas?.hasPointerCapture(pointerId) === true;
+}
+function releaseLogicalPointerCapture(target, pointerId) {
+  const eventRoot = target.owner.eventRoot;
+  if (eventRoot.pointerCaptures.get(pointerId) !== target) return;
+  const canvas = eventRoot.canvas;
+  if (!canvas) return;
+  const state = getCaptureState(eventRoot);
+  ensureNativeOwnership(eventRoot, state);
+  const capture = state.activeCaptures.get(pointerId);
+  const transfer = state.pendingTransfers.get(pointerId);
+  const previousPendingOwner = state.pendingLossOwners.get(pointerId);
+  const lossOwner = transfer ? transfer.from : capture?.activated ? capture.owner : target;
+  const transaction = {
+    owner: lossOwner,
+    requestedBy: target,
+    wasActivated: transfer !== void 0 || capture?.activated === true,
+    gotObserved: false,
+    lossObserved: false
+  };
+  state.releaseTransactions.set(pointerId, transaction);
+  eventRoot.pointerCaptures.delete(pointerId);
+  state.activeCaptures.delete(pointerId);
+  state.pendingTransfers.delete(pointerId);
+  if (lossOwner && isLiveNode(lossOwner)) {
+    state.pendingLossOwners.set(pointerId, lossOwner);
+  }
+  try {
+    canvas.releasePointerCapture(pointerId);
+  } catch (error) {
+    if (state.releaseTransactions.get(pointerId) === transaction) {
+      state.releaseTransactions.delete(pointerId);
+    }
+    if (!transaction.lossObserved && isLiveNode(target)) {
+      if (lossOwner && state.pendingLossOwners.get(pointerId) === lossOwner) {
+        if (previousPendingOwner) {
+          state.pendingLossOwners.set(pointerId, previousPendingOwner);
+        } else {
+          state.pendingLossOwners.delete(pointerId);
+        }
+      }
+      if (!eventRoot.pointerCaptures.has(pointerId)) {
+        eventRoot.pointerCaptures.set(pointerId, target);
+        if (capture) state.activeCaptures.set(pointerId, capture);
+        if (transfer) state.pendingTransfers.set(pointerId, transfer);
+      }
+    }
+    releaseUnusedNativeOwnership(eventRoot, state);
+    throw error;
+  }
+  if (state.releaseTransactions.get(pointerId) === transaction) {
+    state.releaseTransactions.delete(pointerId);
+  }
+  if (!transaction.wasActivated && !transaction.gotObserved && !transaction.lossObserved && lossOwner && state.pendingLossOwners.get(pointerId) === lossOwner && !canvas.hasPointerCapture(pointerId)) {
+    state.pendingLossOwners.delete(pointerId);
+  }
+  releaseUnusedNativeOwnership(eventRoot, state);
+}
+function clearPointerCapturesForTarget(target) {
+  const eventRoot = target.owner.eventRoot;
+  const state = captureStates.get(eventRoot);
+  if (!state) return;
+  const pointerIds = /* @__PURE__ */ new Set([
+    ...eventRoot.pointerCaptures.keys(),
+    ...state.activeCaptures.keys(),
+    ...state.pendingTransfers.keys(),
+    ...state.pendingLossOwners.keys(),
+    ...state.releaseTransactions.keys()
+  ]);
+  for (const pointerId of pointerIds) {
+    const pending = eventRoot.pointerCaptures.get(pointerId);
+    const capture = state.activeCaptures.get(pointerId);
+    const transfer = state.pendingTransfers.get(pointerId);
+    const transaction = state.releaseTransactions.get(pointerId);
+    let releaseNative = false;
+    if (pending === target) {
+      eventRoot.pointerCaptures.delete(pointerId);
+      releaseNative = true;
+      if (transfer?.from && transfer.from !== target && isLiveNode(transfer.from)) {
+        state.activeCaptures.set(pointerId, {
+          owner: transfer.from,
+          activated: true
+        });
+        state.pendingTransfers.set(pointerId, { from: transfer.from });
+        state.pendingLossOwners.set(pointerId, transfer.from);
+      } else {
+        state.activeCaptures.delete(pointerId);
+        state.pendingTransfers.delete(pointerId);
+      }
+    } else if (capture?.owner === target) {
+      if (transfer && pending && isLiveNode(pending)) {
+        state.activeCaptures.set(pointerId, {
+          owner: pending,
+          activated: false
+        });
+        state.pendingTransfers.set(pointerId, { from: void 0 });
+      } else {
+        state.activeCaptures.delete(pointerId);
+        state.pendingTransfers.delete(pointerId);
+      }
+    }
+    if (state.pendingLossOwners.get(pointerId) === target) {
+      state.pendingLossOwners.delete(pointerId);
+    }
+    if (transaction?.owner === target || transaction?.requestedBy === target) {
+      state.releaseTransactions.delete(pointerId);
+    }
+    if (releaseNative) releaseNativeCapture(eventRoot.canvas, pointerId);
+  }
+  releaseUnusedNativeOwnership(eventRoot, state);
+}
+function getLogicalPointerCapture(eventRoot, pointerId) {
+  const target = eventRoot.pointerCaptures.get(pointerId);
+  if (!target || isLiveNode(target)) return target;
+  clearPointerCapturesForTarget(target);
+  return void 0;
+}
+function activateLogicalPointerCapture(eventRoot, pointerId) {
+  const state = captureStates.get(eventRoot);
+  const transfer = state?.pendingTransfers.get(pointerId);
+  if (transfer?.from) return void 0;
+  const target = getLogicalPointerCapture(eventRoot, pointerId);
+  const capture = state?.activeCaptures.get(pointerId);
+  if (target && capture?.owner === target) {
+    if (capture.activated) return void 0;
+    capture.activated = true;
+    state?.pendingTransfers.delete(pointerId);
+    return target;
+  }
+  const transaction = state?.releaseTransactions.get(pointerId);
+  if (transaction && !transaction.wasActivated && transaction.owner && state?.pendingLossOwners.get(pointerId) === transaction.owner && isLiveNode(transaction.owner)) {
+    transaction.gotObserved = true;
+    return transaction.owner;
+  }
+  return void 0;
+}
+function cancelLogicalPointerCapture(eventRoot, pointerId) {
+  const pendingTarget = eventRoot.pointerCaptures.get(pointerId);
+  if (!pendingTarget) return;
+  eventRoot.pointerCaptures.delete(pointerId);
+  const state = getCaptureState(eventRoot);
+  const transfer = state.pendingTransfers.get(pointerId);
+  const capture = state.activeCaptures.get(pointerId);
+  const target = transfer ? transfer.from : capture?.activated ? capture.owner : pendingTarget;
+  state.activeCaptures.delete(pointerId);
+  state.pendingTransfers.delete(pointerId);
+  if (target && isLiveNode(target)) {
+    state.pendingLossOwners.set(pointerId, target);
+  }
+  releaseUnusedNativeOwnership(eventRoot, state);
+}
+function consumeLogicalPointerCaptureLoss(eventRoot, pointerId) {
+  const state = captureStates.get(eventRoot);
+  const transaction = state?.releaseTransactions.get(pointerId);
+  if (transaction) transaction.lossObserved = true;
+  const transfer = state?.pendingTransfers.get(pointerId);
+  const capture = state?.activeCaptures.get(pointerId);
+  const target = transfer ? transfer.from : capture?.activated ? capture.owner : state?.pendingLossOwners.get(pointerId) ?? eventRoot.pointerCaptures.get(pointerId);
+  eventRoot.pointerCaptures.delete(pointerId);
+  state?.activeCaptures.delete(pointerId);
+  state?.pendingTransfers.delete(pointerId);
+  state?.pendingLossOwners.delete(pointerId);
+  if (state) releaseUnusedNativeOwnership(eventRoot, state);
+  return target && isLiveNode(target) ? target : void 0;
+}
+function processPendingLogicalPointerCapture(eventRoot, pointerId, dispatchLost, dispatchGot) {
+  const state = captureStates.get(eventRoot);
+  if (!state?.pendingTransfers.has(pointerId) || state.processingTransfers.has(pointerId)) {
+    return;
+  }
+  state.processingTransfers.add(pointerId);
+  try {
+    const transfer = state.pendingTransfers.get(pointerId);
+    const previous = transfer?.from;
+    const pending = livePendingOwner(eventRoot, pointerId);
+    if (previous && previous !== pending) {
+      state.pendingLossOwners.delete(pointerId);
+      if (pending) {
+        state.activeCaptures.set(pointerId, {
+          owner: pending,
+          activated: false
+        });
+        state.pendingTransfers.set(pointerId, { from: void 0 });
+      } else {
+        state.activeCaptures.delete(pointerId);
+        state.pendingTransfers.delete(pointerId);
+      }
+      if (isLiveNode(previous)) dispatchLost(previous);
+    }
+    const currentTransfer = state.pendingTransfers.get(pointerId);
+    if (!currentTransfer) return;
+    const next = livePendingOwner(eventRoot, pointerId);
+    state.pendingTransfers.delete(pointerId);
+    state.pendingLossOwners.delete(pointerId);
+    if (!next) {
+      state.activeCaptures.delete(pointerId);
+      return;
+    }
+    state.activeCaptures.set(pointerId, { owner: next, activated: true });
+    if (next !== currentTransfer.from) dispatchGot(next);
+  } finally {
+    state.processingTransfers.delete(pointerId);
+    releaseUnusedNativeOwnership(eventRoot, state);
+  }
+}
+function getCaptureState(eventRoot) {
+  let state = captureStates.get(eventRoot);
+  if (!state) {
+    state = {
+      activeCaptures: /* @__PURE__ */ new Map(),
+      pendingTransfers: /* @__PURE__ */ new Map(),
+      processingTransfers: /* @__PURE__ */ new Set(),
+      pendingLossOwners: /* @__PURE__ */ new Map(),
+      releaseTransactions: /* @__PURE__ */ new Map(),
+      nativeReleases: void 0
+    };
+    captureStates.set(eventRoot, state);
+  }
+  return state;
+}
+function ensureNativeOwnership(eventRoot, state) {
+  if (state.nativeReleases) return;
+  const hub = eventRoot.nativeListeners;
+  if (!hub) return;
+  state.nativeReleases = Object.freeze([
+    hub.acquire("pointercancel"),
+    hub.acquire("gotpointercapture"),
+    hub.acquire("lostpointercapture")
+  ]);
+}
+function releaseUnusedNativeOwnership(eventRoot, state) {
+  if (eventRoot.pointerCaptures.size > 0 || state.pendingLossOwners.size > 0 || state.releaseTransactions.size > 0 || state.pendingTransfers.size > 0 || state.processingTransfers.size > 0) {
+    return;
+  }
+  const releases = state.nativeReleases;
+  state.nativeReleases = void 0;
+  if (releases) {
+    for (const release of releases) release();
+  }
+  captureStates.delete(eventRoot);
+}
+function livePendingOwner(eventRoot, pointerId) {
+  const target = eventRoot.pointerCaptures.get(pointerId);
+  if (!target || isLiveNode(target)) return target;
+  eventRoot.pointerCaptures.delete(pointerId);
+  return void 0;
+}
+function releaseNativeCapture(canvas, pointerId) {
+  if (!canvas) return;
+  try {
+    if (canvas.hasPointerCapture(pointerId)) {
+      canvas.releasePointerCapture(pointerId);
+    }
+  } catch {
+  }
+}
+function isLiveNode(target) {
+  return target.live && !target.owner.mainTeardowns.closed;
+}
+export {
+  activateLogicalPointerCapture,
+  cancelLogicalPointerCapture,
+  clearPointerCapturesForTarget,
+  consumeLogicalPointerCaptureLoss,
+  getLogicalPointerCapture,
+  getPointerCaptureStateCounts,
+  hasLogicalPointerCapture,
+  processPendingLogicalPointerCapture,
+  releaseLogicalPointerCapture,
+  setLogicalPointerCapture
+};
+//# sourceMappingURL=pointer-capture.js.map

package/dist/lib/events/pointer-capture.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/events/pointer-capture.ts"],
+  "sourcesContent": ["import type { PibblEventRoot } from '../types.js';\nimport type { PibblEventNode } from './registrations.js';\n\ninterface PibblPointerCaptureState {\n  readonly activeCaptures: Map<number, PibblPointerCaptureRecord>;\n  readonly pendingTransfers: Map<number, PibblPointerCaptureTransfer>;\n  readonly processingTransfers: Set<number>;\n  readonly pendingLossOwners: Map<number, PibblEventNode>;\n  readonly releaseTransactions: Map<number, PibblPointerReleaseTransaction>;\n  nativeReleases: readonly (() => void)[] | undefined;\n}\n\ninterface PibblPointerCaptureRecord {\n  readonly owner: PibblEventNode;\n  activated: boolean;\n}\n\ninterface PibblPointerCaptureTransfer {\n  readonly from: PibblEventNode | undefined;\n}\n\ninterface PibblPointerReleaseTransaction {\n  readonly owner: PibblEventNode | undefined;\n  readonly requestedBy: PibblEventNode;\n  readonly wasActivated: boolean;\n  gotObserved: boolean;\n  lossObserved: boolean;\n}\n\nconst captureStates = new WeakMap<PibblEventRoot, PibblPointerCaptureState>();\n\n/** @internal Structural ownership evidence for lifecycle tests. */\nexport function getPointerCaptureStateCounts(eventRoot: PibblEventRoot): {\n  readonly activated: number;\n  readonly nativeListenerRequests: number;\n  readonly pendingLoss: number;\n  readonly provisional: number;\n  readonly releaseTransactions: number;\n} {\n  const state = captureStates.get(eventRoot);\n  let activated = 0;\n  let provisional = 0;\n  for (const capture of state?.activeCaptures.values() ?? []) {\n    if (capture.activated) activated++;\n    else provisional++;\n  }\n  return {\n    activated,\n    nativeListenerRequests: state?.nativeReleases?.length ?? 0,\n    pendingLoss: state?.pendingLossOwners.size ?? 0,\n    provisional,\n    releaseTransactions: state?.releaseTransactions.size ?? 0,\n  };\n}\n\nexport function setLogicalPointerCapture(\n  target: PibblEventNode,\n  pointerId: number,\n): void {\n  if (!isLiveNode(target)) return;\n  const eventRoot = target.owner.eventRoot;\n  const canvas = eventRoot.canvas;\n  if (!canvas) return;\n\n  const state = getCaptureState(eventRoot);\n  ensureNativeOwnership(eventRoot, state);\n  const previousTarget = eventRoot.pointerCaptures.get(pointerId);\n  const previousCapture = state.activeCaptures.get(pointerId);\n  const previousTransfer = state.pendingTransfers.get(pointerId);\n  const previousPendingOwner = state.pendingLossOwners.get(pointerId);\n  const activeOwner = previousTransfer ? previousTransfer.from :\n    previousCapture?.activated ? previousCapture.owner : undefined;\n  const hadActiveOverride = previousTransfer !== undefined ||\n    activeOwner !== undefined;\n  const nextTransfer = hadActiveOverride && activeOwner !== target ?\n    { from: activeOwner } : undefined;\n  const nextCapture: PibblPointerCaptureRecord = nextTransfer ?\n    activeOwner ? previousCapture! : { owner: target, activated: false } :\n    { owner: target, activated: activeOwner === target };\n  state.pendingLossOwners.delete(pointerId);\n  eventRoot.pointerCaptures.set(pointerId, target);\n  state.activeCaptures.set(pointerId, nextCapture);\n  if (nextTransfer) state.pendingTransfers.set(pointerId, nextTransfer);\n  else state.pendingTransfers.delete(pointerId);\n  try {\n    canvas.setPointerCapture(pointerId);\n  } catch (error) {\n    const operationStillPending =\n      eventRoot.pointerCaptures.get(pointerId) === target &&\n      state.activeCaptures.get(pointerId) === nextCapture &&\n      (nextTransfer ? state.pendingTransfers.get(pointerId) === nextTransfer :\n        !state.pendingTransfers.has(pointerId));\n    if (operationStillPending) {\n      if (previousTarget) {\n        eventRoot.pointerCaptures.set(pointerId, previousTarget);\n      } else {\n        eventRoot.pointerCaptures.delete(pointerId);\n      }\n      if (previousCapture) {\n        state.activeCaptures.set(pointerId, previousCapture);\n      } else {\n        state.activeCaptures.delete(pointerId);\n      }\n      if (previousTransfer) {\n        state.pendingTransfers.set(pointerId, previousTransfer);\n      } else {\n        state.pendingTransfers.delete(pointerId);\n      }\n      if (previousPendingOwner) {\n        state.pendingLossOwners.set(pointerId, previousPendingOwner);\n      }\n    }\n    releaseUnusedNativeOwnership(eventRoot, state);\n    throw error;\n  }\n}\n\nexport function hasLogicalPointerCapture(\n  target: PibblEventNode,\n  pointerId: number,\n): boolean {\n  const eventRoot = target.owner.eventRoot;\n  return eventRoot.pointerCaptures.get(pointerId) === target &&\n    eventRoot.canvas?.hasPointerCapture(pointerId) === true;\n}\n\nexport function releaseLogicalPointerCapture(\n  target: PibblEventNode,\n  pointerId: number,\n): void {\n  const eventRoot = target.owner.eventRoot;\n  if (eventRoot.pointerCaptures.get(pointerId) !== target) return;\n  const canvas = eventRoot.canvas;\n  if (!canvas) return;\n\n  const state = getCaptureState(eventRoot);\n  ensureNativeOwnership(eventRoot, state);\n  const capture = state.activeCaptures.get(pointerId);\n  const transfer = state.pendingTransfers.get(pointerId);\n  const previousPendingOwner = state.pendingLossOwners.get(pointerId);\n  const lossOwner = transfer ? transfer.from :\n    capture?.activated ? capture.owner : target;\n  const transaction: PibblPointerReleaseTransaction = {\n    owner: lossOwner,\n    requestedBy: target,\n    wasActivated: transfer !== undefined || capture?.activated === true,\n    gotObserved: false,\n    lossObserved: false,\n  };\n  state.releaseTransactions.set(pointerId, transaction);\n  eventRoot.pointerCaptures.delete(pointerId);\n  state.activeCaptures.delete(pointerId);\n  state.pendingTransfers.delete(pointerId);\n  if (lossOwner && isLiveNode(lossOwner)) {\n    state.pendingLossOwners.set(pointerId, lossOwner);\n  }\n  try {\n    canvas.releasePointerCapture(pointerId);\n  } catch (error) {\n    if (state.releaseTransactions.get(pointerId) === transaction) {\n      state.releaseTransactions.delete(pointerId);\n    }\n    if (!transaction.lossObserved && isLiveNode(target)) {\n      if (lossOwner && state.pendingLossOwners.get(pointerId) === lossOwner) {\n        if (previousPendingOwner) {\n          state.pendingLossOwners.set(pointerId, previousPendingOwner);\n        } else {\n          state.pendingLossOwners.delete(pointerId);\n        }\n      }\n      if (!eventRoot.pointerCaptures.has(pointerId)) {\n        eventRoot.pointerCaptures.set(pointerId, target);\n        if (capture) state.activeCaptures.set(pointerId, capture);\n        if (transfer) state.pendingTransfers.set(pointerId, transfer);\n      }\n    }\n    releaseUnusedNativeOwnership(eventRoot, state);\n    throw error;\n  }\n  if (state.releaseTransactions.get(pointerId) === transaction) {\n    state.releaseTransactions.delete(pointerId);\n  }\n  if (\n    !transaction.wasActivated &&\n    !transaction.gotObserved &&\n    !transaction.lossObserved &&\n    lossOwner && state.pendingLossOwners.get(pointerId) === lossOwner &&\n    !canvas.hasPointerCapture(pointerId)\n  ) {\n    state.pendingLossOwners.delete(pointerId);\n  }\n  releaseUnusedNativeOwnership(eventRoot, state);\n}\n\nexport function clearPointerCapturesForTarget(target: PibblEventNode): void {\n  const eventRoot = target.owner.eventRoot;\n  const state = captureStates.get(eventRoot);\n  if (!state) return;\n  const pointerIds = new Set([\n    ...eventRoot.pointerCaptures.keys(),\n    ...state.activeCaptures.keys(),\n    ...state.pendingTransfers.keys(),\n    ...state.pendingLossOwners.keys(),\n    ...state.releaseTransactions.keys(),\n  ]);\n  for (const pointerId of pointerIds) {\n    const pending = eventRoot.pointerCaptures.get(pointerId);\n    const capture = state.activeCaptures.get(pointerId);\n    const transfer = state.pendingTransfers.get(pointerId);\n    const transaction = state.releaseTransactions.get(pointerId);\n    let releaseNative = false;\n\n    if (pending === target) {\n      eventRoot.pointerCaptures.delete(pointerId);\n      releaseNative = true;\n      if (transfer?.from && transfer.from !== target && isLiveNode(transfer.from)) {\n        state.activeCaptures.set(pointerId, {\n          owner: transfer.from,\n          activated: true,\n        });\n        state.pendingTransfers.set(pointerId, { from: transfer.from });\n        state.pendingLossOwners.set(pointerId, transfer.from);\n      } else {\n        state.activeCaptures.delete(pointerId);\n        state.pendingTransfers.delete(pointerId);\n      }\n    } else if (capture?.owner === target) {\n      if (transfer && pending && isLiveNode(pending)) {\n        state.activeCaptures.set(pointerId, {\n          owner: pending,\n          activated: false,\n        });\n        state.pendingTransfers.set(pointerId, { from: undefined });\n      } else {\n        state.activeCaptures.delete(pointerId);\n        state.pendingTransfers.delete(pointerId);\n      }\n    }\n\n    if (state.pendingLossOwners.get(pointerId) === target) {\n      state.pendingLossOwners.delete(pointerId);\n    }\n    if (\n      transaction?.owner === target ||\n      transaction?.requestedBy === target\n    ) {\n      state.releaseTransactions.delete(pointerId);\n    }\n    if (releaseNative) releaseNativeCapture(eventRoot.canvas, pointerId);\n  }\n  releaseUnusedNativeOwnership(eventRoot, state);\n}\n\nexport function getLogicalPointerCapture(\n  eventRoot: PibblEventRoot,\n  pointerId: number,\n): PibblEventNode | undefined {\n  const target = eventRoot.pointerCaptures.get(pointerId);\n  if (!target || isLiveNode(target)) return target;\n  clearPointerCapturesForTarget(target);\n  return undefined;\n}\n\n/** Records native activation before exposing the logical got callback. */\nexport function activateLogicalPointerCapture(\n  eventRoot: PibblEventRoot,\n  pointerId: number,\n): PibblEventNode | undefined {\n  const state = captureStates.get(eventRoot);\n  const transfer = state?.pendingTransfers.get(pointerId);\n  if (transfer?.from) return undefined;\n  const target = getLogicalPointerCapture(eventRoot, pointerId);\n  const capture = state?.activeCaptures.get(pointerId);\n  if (target && capture?.owner === target) {\n    if (capture.activated) return undefined;\n    capture.activated = true;\n    state?.pendingTransfers.delete(pointerId);\n    return target;\n  }\n\n  const transaction = state?.releaseTransactions.get(pointerId);\n  if (\n    transaction &&\n    !transaction.wasActivated &&\n    transaction.owner &&\n    state?.pendingLossOwners.get(pointerId) === transaction.owner &&\n    isLiveNode(transaction.owner)\n  ) {\n    transaction.gotObserved = true;\n    return transaction.owner;\n  }\n  return undefined;\n}\n\n/** Clears active routing while retaining the owner for native loss delivery. */\nexport function cancelLogicalPointerCapture(\n  eventRoot: PibblEventRoot,\n  pointerId: number,\n): void {\n  const pendingTarget = eventRoot.pointerCaptures.get(pointerId);\n  if (!pendingTarget) return;\n  eventRoot.pointerCaptures.delete(pointerId);\n  const state = getCaptureState(eventRoot);\n  const transfer = state.pendingTransfers.get(pointerId);\n  const capture = state.activeCaptures.get(pointerId);\n  const target = transfer ? transfer.from :\n    capture?.activated ? capture.owner : pendingTarget;\n  state.activeCaptures.delete(pointerId);\n  state.pendingTransfers.delete(pointerId);\n  if (target && isLiveNode(target)) {\n    state.pendingLossOwners.set(pointerId, target);\n  }\n  releaseUnusedNativeOwnership(eventRoot, state);\n}\n\n/** Removes native-loss state before exposing the logical loss callback. */\nexport function consumeLogicalPointerCaptureLoss(\n  eventRoot: PibblEventRoot,\n  pointerId: number,\n): PibblEventNode | undefined {\n  const state = captureStates.get(eventRoot);\n  const transaction = state?.releaseTransactions.get(pointerId);\n  if (transaction) transaction.lossObserved = true;\n  const transfer = state?.pendingTransfers.get(pointerId);\n  const capture = state?.activeCaptures.get(pointerId);\n  const target = transfer ? transfer.from :\n    capture?.activated ? capture.owner :\n    state?.pendingLossOwners.get(pointerId) ??\n    eventRoot.pointerCaptures.get(pointerId);\n  eventRoot.pointerCaptures.delete(pointerId);\n  state?.activeCaptures.delete(pointerId);\n  state?.pendingTransfers.delete(pointerId);\n  state?.pendingLossOwners.delete(pointerId);\n  if (state) releaseUnusedNativeOwnership(eventRoot, state);\n  return target && isLiveNode(target) ? target : undefined;\n}\n\n/** Processes one pending logical owner change before a non-capture PointerEvent. */\nexport function processPendingLogicalPointerCapture(\n  eventRoot: PibblEventRoot,\n  pointerId: number,\n  dispatchLost: (target: PibblEventNode) => void,\n  dispatchGot: (target: PibblEventNode) => void,\n): void {\n  const state = captureStates.get(eventRoot);\n  if (\n    !state?.pendingTransfers.has(pointerId) ||\n    state.processingTransfers.has(pointerId)\n  ) {\n    return;\n  }\n\n  state.processingTransfers.add(pointerId);\n  try {\n    const transfer = state.pendingTransfers.get(pointerId);\n    const previous = transfer?.from;\n    const pending = livePendingOwner(eventRoot, pointerId);\n    if (previous && previous !== pending) {\n      state.pendingLossOwners.delete(pointerId);\n      if (pending) {\n        state.activeCaptures.set(pointerId, {\n          owner: pending,\n          activated: false,\n        });\n        state.pendingTransfers.set(pointerId, { from: undefined });\n      } else {\n        state.activeCaptures.delete(pointerId);\n        state.pendingTransfers.delete(pointerId);\n      }\n      if (isLiveNode(previous)) dispatchLost(previous);\n    }\n\n    const currentTransfer = state.pendingTransfers.get(pointerId);\n    if (!currentTransfer) return;\n    const next = livePendingOwner(eventRoot, pointerId);\n    state.pendingTransfers.delete(pointerId);\n    state.pendingLossOwners.delete(pointerId);\n    if (!next) {\n      state.activeCaptures.delete(pointerId);\n      return;\n    }\n\n    state.activeCaptures.set(pointerId, { owner: next, activated: true });\n    if (next !== currentTransfer.from) dispatchGot(next);\n  } finally {\n    state.processingTransfers.delete(pointerId);\n    releaseUnusedNativeOwnership(eventRoot, state);\n  }\n}\n\nfunction getCaptureState(eventRoot: PibblEventRoot): PibblPointerCaptureState {\n  let state = captureStates.get(eventRoot);\n  if (!state) {\n    state = {\n      activeCaptures: new Map(),\n      pendingTransfers: new Map(),\n      processingTransfers: new Set(),\n      pendingLossOwners: new Map(),\n      releaseTransactions: new Map(),\n      nativeReleases: undefined,\n    };\n    captureStates.set(eventRoot, state);\n  }\n  return state;\n}\n\nfunction ensureNativeOwnership(\n  eventRoot: PibblEventRoot,\n  state: PibblPointerCaptureState,\n): void {\n  if (state.nativeReleases) return;\n  const hub = eventRoot.nativeListeners;\n  if (!hub) return;\n  state.nativeReleases = Object.freeze([\n    hub.acquire('pointercancel'),\n    hub.acquire('gotpointercapture'),\n    hub.acquire('lostpointercapture'),\n  ]);\n}\n\nfunction releaseUnusedNativeOwnership(\n  eventRoot: PibblEventRoot,\n  state: PibblPointerCaptureState,\n): void {\n  if (\n    eventRoot.pointerCaptures.size > 0 ||\n    state.pendingLossOwners.size > 0 ||\n    state.releaseTransactions.size > 0\n    || state.pendingTransfers.size > 0\n    || state.processingTransfers.size > 0\n  ) {\n    return;\n  }\n  const releases = state.nativeReleases;\n  state.nativeReleases = undefined;\n  if (releases) {\n    for (const release of releases) release();\n  }\n  captureStates.delete(eventRoot);\n}\n\nfunction livePendingOwner(\n  eventRoot: PibblEventRoot,\n  pointerId: number,\n): PibblEventNode | undefined {\n  const target = eventRoot.pointerCaptures.get(pointerId);\n  if (!target || isLiveNode(target)) return target;\n  eventRoot.pointerCaptures.delete(pointerId);\n  return undefined;\n}\n\nfunction releaseNativeCapture(\n  canvas: HTMLCanvasElement | undefined,\n  pointerId: number,\n): void {\n  if (!canvas) return;\n  try {\n    if (canvas.hasPointerCapture(pointerId)) {\n      canvas.releasePointerCapture(pointerId);\n    }\n  } catch {\n    // Native pointer lifetime may already have ended; logical teardown still\n    // must synchronously remove the dead owner.\n  }\n}\n\nfunction isLiveNode(target: PibblEventNode): boolean {\n  return target.live && !target.owner.mainTeardowns.closed;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/lib/events/propagation.d.ts

@@ -0,0 +1,7 @@
+import { type CreatePibblEventInput } from './event-facade.js';
+import type { PibblEventNode } from './registrations.js';
+import type { PibblEventMap, PibblEventType } from './types.js';
+export interface DispatchEventPathInput<K extends PibblEventType> extends Omit<CreatePibblEventInput<K>, 'path'> {
+    readonly target: PibblEventNode;
+}
+export declare function dispatchEventPath<K extends PibblEventType>(input: DispatchEventPathInput<K>): PibblEventMap[K];

package/dist/lib/events/propagation.js

@@ -0,0 +1,56 @@
+import { getPibblEventDefinition } from "./event-definitions.js";
+import {
+  createPibblEvent,
+  isPibblImmediatePropagationStopped,
+  isPibblPropagationStopped,
+  setPibblEventInvocation
+} from "./event-facade.js";
+import { buildEventPath } from "./event-path.js";
+function dispatchEventPath(input) {
+  const definition = getPibblEventDefinition(input.type);
+  if (!definition) {
+    throw new Error(`Unsupported Pibbl event type: ${input.type}`);
+  }
+  const path = buildEventPath(input.target);
+  const event = createPibblEvent({ ...input, path });
+  const targetIndex = path.length - 1;
+  for (let index = 0; index < targetIndex; index++) {
+    if (isPibblPropagationStopped(event)) break;
+    invoke(path[index], input.type, true, 1, event);
+  }
+  if (!isPibblPropagationStopped(event) && input.target.live) {
+    invoke(input.target, input.type, true, 2, event);
+    if (!isPibblImmediatePropagationStopped(event)) {
+      invoke(input.target, input.type, false, 2, event);
+    }
+  }
+  if (definition.bubbles && !isPibblPropagationStopped(event)) {
+    for (let index = targetIndex - 1; index >= 0; index--) {
+      if (isPibblPropagationStopped(event)) break;
+      invoke(path[index], input.type, false, 3, event);
+    }
+  }
+  return event;
+}
+function invoke(node, type, capture, phase, event) {
+  if (!node.live) return;
+  const key = capture ? `${type}Capture` : type;
+  const handler = node.handlers[key];
+  if (!handler) return;
+  setPibblEventInvocation(event, node.publicTarget, phase);
+  try {
+    handler(event);
+  } catch (error) {
+    reportDispatchError(error);
+  }
+}
+function reportDispatchError(error) {
+  try {
+    globalThis.reportError(error);
+  } catch {
+  }
+}
+export {
+  dispatchEventPath
+};
+//# sourceMappingURL=propagation.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/events/propagation.ts"],
+  "sourcesContent": ["import { getPibblEventDefinition } from './event-definitions.js';\nimport {\n  createPibblEvent,\n  isPibblImmediatePropagationStopped,\n  isPibblPropagationStopped,\n  setPibblEventInvocation,\n  type CreatePibblEventInput,\n} from './event-facade.js';\nimport { buildEventPath } from './event-path.js';\nimport type {\n  PibblEventNode,\n  PibblNormalizedHandlers,\n} from './registrations.js';\nimport type {\n  PibblEvent,\n  PibblEventMap,\n  PibblEventPhase,\n  PibblEventType,\n} from './types.js';\n\nexport interface DispatchEventPathInput<K extends PibblEventType>\n  extends Omit<CreatePibblEventInput<K>, 'path'> {\n  readonly target: PibblEventNode;\n}\n\ntype PibblNormalizedCaptureKey = `${PibblEventType}Capture`;\n\nexport function dispatchEventPath<K extends PibblEventType>(\n  input: DispatchEventPathInput<K>,\n): PibblEventMap[K] {\n  const definition = getPibblEventDefinition(input.type);\n  if (!definition) {\n    throw new Error(`Unsupported Pibbl event type: ${input.type}`);\n  }\n  const path = buildEventPath(input.target);\n  const event = createPibblEvent({ ...input, path });\n  const targetIndex = path.length - 1;\n\n  for (let index = 0; index < targetIndex; index++) {\n    if (isPibblPropagationStopped(event)) break;\n    invoke(path[index], input.type, true, 1, event);\n  }\n\n  if (!isPibblPropagationStopped(event) && input.target.live) {\n    invoke(input.target, input.type, true, 2, event);\n    if (!isPibblImmediatePropagationStopped(event)) {\n      invoke(input.target, input.type, false, 2, event);\n    }\n  }\n\n  if (definition.bubbles && !isPibblPropagationStopped(event)) {\n    for (let index = targetIndex - 1; index >= 0; index--) {\n      if (isPibblPropagationStopped(event)) break;\n      invoke(path[index], input.type, false, 3, event);\n    }\n  }\n\n  return event;\n}\n\nfunction invoke(\n  node: PibblEventNode,\n  type: PibblEventType,\n  capture: boolean,\n  phase: PibblEventPhase,\n  event: PibblEvent,\n): void {\n  if (!node.live) return;\n  const key = capture ? `${type}Capture` as PibblNormalizedCaptureKey : type;\n  const handler = node.handlers[key as keyof PibblNormalizedHandlers];\n  if (!handler) return;\n  setPibblEventInvocation(event, node.publicTarget, phase);\n  try {\n    (handler as (event: PibblEvent) => void)(event);\n  } catch (error) {\n    reportDispatchError(error);\n  }\n}\n\nfunction reportDispatchError(error: unknown): void {\n  try {\n    globalThis.reportError(error);\n  } catch {\n    // Reporting cannot suppress unrelated handlers in this logical dispatch.\n  }\n}\n"],
+  "mappings": "AAAA,SAAS,+BAA+B;AACxC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAEK;AACP,SAAS,sBAAsB;AAmBxB,SAAS,kBACd,OACkB;AAClB,QAAM,aAAa,wBAAwB,MAAM,IAAI;AACrD,MAAI,CAAC,YAAY;AACf,UAAM,IAAI,MAAM,iCAAiC,MAAM,IAAI,EAAE;AAAA,EAC/D;AACA,QAAM,OAAO,eAAe,MAAM,MAAM;AACxC,QAAM,QAAQ,iBAAiB,EAAE,GAAG,OAAO,KAAK,CAAC;AACjD,QAAM,cAAc,KAAK,SAAS;AAElC,WAAS,QAAQ,GAAG,QAAQ,aAAa,SAAS;AAChD,QAAI,0BAA0B,KAAK,EAAG;AACtC,WAAO,KAAK,KAAK,GAAG,MAAM,MAAM,MAAM,GAAG,KAAK;AAAA,EAChD;AAEA,MAAI,CAAC,0BAA0B,KAAK,KAAK,MAAM,OAAO,MAAM;AAC1D,WAAO,MAAM,QAAQ,MAAM,MAAM,MAAM,GAAG,KAAK;AAC/C,QAAI,CAAC,mCAAmC,KAAK,GAAG;AAC9C,aAAO,MAAM,QAAQ,MAAM,MAAM,OAAO,GAAG,KAAK;AAAA,IAClD;AAAA,EACF;AAEA,MAAI,WAAW,WAAW,CAAC,0BAA0B,KAAK,GAAG;AAC3D,aAAS,QAAQ,cAAc,GAAG,SAAS,GAAG,SAAS;AACrD,UAAI,0BAA0B,KAAK,EAAG;AACtC,aAAO,KAAK,KAAK,GAAG,MAAM,MAAM,OAAO,GAAG,KAAK;AAAA,IACjD;AAAA,EACF;AAEA,SAAO;AACT;AAEA,SAAS,OACP,MACA,MACA,SACA,OACA,OACM;AACN,MAAI,CAAC,KAAK,KAAM;AAChB,QAAM,MAAM,UAAU,GAAG,IAAI,YAAyC;AACtE,QAAM,UAAU,KAAK,SAAS,GAAoC;AAClE,MAAI,CAAC,QAAS;AACd,0BAAwB,OAAO,KAAK,cAAc,KAAK;AACvD,MAAI;AACF,IAAC,QAAwC,KAAK;AAAA,EAChD,SAAS,OAAO;AACd,wBAAoB,KAAK;AAAA,EAC3B;AACF;AAEA,SAAS,oBAAoB,OAAsB;AACjD,MAAI;AACF,eAAW,YAAY,KAAK;AAAA,EAC9B,QAAQ;AAAA,EAER;AACF;",
+  "names": []
+}

package/dist/lib/events/registrations.d.ts

@@ -0,0 +1,120 @@
+import type { PibblHitTestOutput } from "./paint-entry.js";
+import type { isBackendEventTargetLive, useBackendEventTarget } from "../../internal.js";
+import type { PibblEventHandler, PibblEventHandlers, PibblEventTarget, PibblEventTargetOptions, PibblEventType } from "./types.js";
+import type { PathGeometry } from '../geometry/path-geometry.js';
+import type { LayoutBox } from "../layout/types.js";
+import type { PibblComponentRefs, PibblInstance } from "../types.js";
+import { type PibblPathPaintEntry } from "./paint-entry.js";
+export type PibblNormalizedHandlers = Partial<{
+    [K in PibblEventType]: PibblEventHandler<K>;
+} & {
+    [K in PibblEventType as `${K}Capture`]: PibblEventHandler<K>;
+}>;
+/**
+ * Mount-owned event target registration and cleanup state.
+ *
+ * @see {@link PibblEventTarget}
+ * @see {@link LayoutBox}
+ * @see {@link PibblHitTestOutput}
+ * @see {@link useBackendEventTarget}
+ * @see {@link isBackendEventTargetLive}
+ */
+export interface PibblEventTargetRegistration {
+    /** Selects the kind of geometry, material, or result. See {@link PibblEventTargetRegistration}. */
+    readonly kind: "target";
+    /** Mount or runtime resource owning this registration. See {@link PibblInstance}. */
+    readonly owner: PibblInstance;
+    /**
+     * Component identity or diagnostic name associated with this value. See {@link PibblComponentRefs}
+     * .
+     */
+    readonly component: PibblComponentRefs<any>;
+    /** Mount-local hook or registration slot. See {@link PibblEventTargetRegistration}. */
+    readonly slot: number;
+    /** Logical target exposed to application event handlers. See {@link PibblEventTarget}. */
+    readonly publicTarget: PibblEventTarget;
+    /** Paint-ledger entry associated with this registration. See {@link PibblPathPaintEntry}. */
+    paintEntry: PibblPathPaintEntry | undefined;
+    /** Event handlers dispatched for this logical target. See {@link PibblNormalizedHandlers}. */
+    handlers: PibblNormalizedHandlers;
+    /** Logical event types currently present in `handlers`, split across two 32-bit words. */
+    handlerTypesLow: number;
+    /**
+     * High event-mask bits identifying registered handler types. See
+     * {@link PibblEventTargetRegistration}.
+     */
+    handlerTypesHigh: number;
+    /** Native event dependency signature derived from the current handlers and cursor. */
+    requiredNativeTypesLow: number;
+    /**
+     * High event-mask bits identifying required native listeners. See
+     * {@link PibblEventTargetRegistration}.
+     */
+    requiredNativeTypesHigh: number;
+    /** Last native signature reconciled with `nativeReleases`. */
+    ownedNativeTypesLow: number;
+    /**
+     * High event-mask bits identifying native listeners owned by this registration. See
+     * {@link PibblEventTargetRegistration}.
+     */
+    ownedNativeTypesHigh: number;
+    /**
+     * Cursor shown while this target owns pointer presentation. See
+     * {@link PibblEventTargetRegistration}.
+     */
+    cursor: string | undefined;
+    /** Whether the target may receive keyboard focus. See {@link PibblEventTargetRegistration}. */
+    keyboardFocusable: boolean | undefined;
+    /** Logical rectangle used for directional keyboard navigation. See {@link LayoutBox}. */
+    keyboardNavigationBounds: Readonly<LayoutBox> | undefined;
+    /** @internal Backend-projected points retained until root-space resolution. */
+    keyboardNavigationPoints: readonly Readonly<{
+        /**
+         * Horizontal coordinate or displacement in the containing coordinate system. See
+         * {@link PibblEventTargetRegistration}.
+         */
+        x: number;
+        /**
+         * Vertical coordinate or displacement in the containing coordinate system. See
+         * {@link PibblEventTargetRegistration}.
+         */
+        y: number;
+    }>[] | undefined;
+    /**
+     * Whether this registration is currently attached to a live owner. See
+     * {@link PibblEventTargetRegistration}.
+     */
+    live: boolean;
+}
+export interface PibblEventListenerRegistration {
+    readonly kind: "listener";
+    readonly owner: PibblInstance;
+    readonly component: PibblComponentRefs<any>;
+    readonly slot: number;
+    readonly publicTarget: PibblEventTarget;
+    handlers: PibblNormalizedHandlers;
+    /** Logical event types currently present in `handlers`, split across two 32-bit words. */
+    handlerTypesLow: number;
+    handlerTypesHigh: number;
+    /** Native event dependency signature derived from the current handlers. */
+    requiredNativeTypesLow: number;
+    requiredNativeTypesHigh: number;
+    /** Last native signature reconciled with `nativeReleases`. */
+    ownedNativeTypesLow: number;
+    ownedNativeTypesHigh: number;
+    live: boolean;
+}
+export type PibblEventNode = PibblEventTargetRegistration | PibblEventListenerRegistration;
+export declare function createTarget(owner: PibblInstance, component: PibblComponentRefs<any>, slot: number): PibblEventTargetRegistration;
+export declare function updateTarget(target: PibblEventTargetRegistration, handlers: PibblEventHandlers, options: PibblEventTargetOptions, participatesInPaint?: boolean, preserveKeyboardNavigationGeometry?: boolean): void;
+export declare function updateCursorTarget(target: PibblEventTargetRegistration, { path, fill, lineInteractionWidth, cursor, }: {
+    path: Path2D | PathGeometry;
+    fill?: boolean;
+    lineInteractionWidth?: number;
+    cursor?: string;
+}): void;
+export declare function releaseTarget(target: PibblEventTargetRegistration): void;
+export declare function createListener(owner: PibblInstance, component: PibblComponentRefs<any>, slot: number): PibblEventListenerRegistration;
+export declare function updateListener(listener: PibblEventListenerRegistration, handlers: PibblEventHandlers): void;
+export declare function releaseListener(listener: PibblEventListenerRegistration): void;
+export declare function normalizeHandlers(handlers: PibblEventHandlers): PibblNormalizedHandlers;