rn-gamekit 0.1.0

package/lib/module/react/bindAppLifecycle.js

@@ -0,0 +1,58 @@
+"use strict";
+
+/** Minimal AppState-like source used to keep this seam platform-neutral. */
+
+/** Session operations the lifecycle binding may drive. */
+
+/**
+ * Pause a running session when the app becomes inactive or backgrounded and
+ * resume it on foreground only when this binding performed that pause.
+ *
+ * Platform-neutral: the React adapter supplies React Native's `AppState`.
+ * The initial `currentState` is synchronized at bind time, so an app that
+ * mounts while already backgrounded never leaves a session running
+ * invisibly. Manual pauses that precede backgrounding are never claimed, and
+ * a session that another actor resumed (or disposed) meanwhile is not
+ * resumed again. Cleanup clears the binding flag so a late foreground event
+ * cannot restart an unmounted game.
+ */
+export function bindAppLifecycle(source, session) {
+  let pausedByLifecycle = false;
+  const pauseForBackground = () => {
+    if (session.getStatus() === 'running') {
+      session.pause();
+      pausedByLifecycle = true;
+    }
+  };
+
+  // Synchronize the initial app state before any change event arrives.
+  if (source.currentState === 'inactive' || source.currentState === 'background') {
+    pauseForBackground();
+  }
+  const subscription = source.addEventListener('change', next => {
+    if (next === 'active') {
+      if (pausedByLifecycle) {
+        pausedByLifecycle = false;
+        // Resume only if the session is still paused; a different actor may
+        // have resumed or disposed it while the app was backgrounded.
+        if (session.getStatus() === 'paused') {
+          session.resume();
+        }
+      }
+      return;
+    }
+    if (next === 'inactive' || next === 'background') {
+      pauseForBackground();
+    }
+  });
+  let cleanedUp = false;
+  return () => {
+    if (cleanedUp) {
+      return;
+    }
+    cleanedUp = true;
+    subscription.remove();
+    pausedByLifecycle = false;
+  };
+}
+//# sourceMappingURL=bindAppLifecycle.js.map

package/lib/module/react/bindAppLifecycle.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["bindAppLifecycle","source","session","pausedByLifecycle","pauseForBackground","getStatus","pause","currentState","subscription","addEventListener","next","resume","cleanedUp","remove"],"sourceRoot":"../../../src","sources":["react/bindAppLifecycle.ts"],"mappings":";;AAEA;;AAUA;;AAUA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASA,gBAAgBA,CAC9BC,MAA0B,EAC1BC,OAA4B,EAChB;EACZ,IAAIC,iBAAiB,GAAG,KAAK;EAE7B,MAAMC,kBAAkB,GAAGA,CAAA,KAAM;IAC/B,IAAIF,OAAO,CAACG,SAAS,CAAC,CAAC,KAAK,SAAS,EAAE;MACrCH,OAAO,CAACI,KAAK,CAAC,CAAC;MACfH,iBAAiB,GAAG,IAAI;IAC1B;EACF,CAAC;;EAED;EACA,IAAIF,MAAM,CAACM,YAAY,KAAK,UAAU,IAAIN,MAAM,CAACM,YAAY,KAAK,YAAY,EAAE;IAC9EH,kBAAkB,CAAC,CAAC;EACtB;EAEA,MAAMI,YAAY,GAAGP,MAAM,CAACQ,gBAAgB,CAAC,QAAQ,EAAGC,IAAI,IAAK;IAC/D,IAAIA,IAAI,KAAK,QAAQ,EAAE;MACrB,IAAIP,iBAAiB,EAAE;QACrBA,iBAAiB,GAAG,KAAK;QACzB;QACA;QACA,IAAID,OAAO,CAACG,SAAS,CAAC,CAAC,KAAK,QAAQ,EAAE;UACpCH,OAAO,CAACS,MAAM,CAAC,CAAC;QAClB;MACF;MACA;IACF;IACA,IAAID,IAAI,KAAK,UAAU,IAAIA,IAAI,KAAK,YAAY,EAAE;MAChDN,kBAAkB,CAAC,CAAC;IACtB;EACF,CAAC,CAAC;EAEF,IAAIQ,SAAS,GAAG,KAAK;EACrB,OAAO,MAAM;IACX,IAAIA,SAAS,EAAE;MACb;IACF;IACAA,SAAS,GAAG,IAAI;IAChBJ,YAAY,CAACK,MAAM,CAAC,CAAC;IACrBV,iBAAiB,GAAG,KAAK;EAC3B,CAAC;AACH","ignoreList":[]}

package/lib/module/react/bindGameSession.js

@@ -0,0 +1,37 @@
+"use strict";
+
+/**
+ * Bind a live session to an imperative presentation sink.
+ *
+ * This platform-neutral lifecycle seam keeps the React adapter testable
+ * without loading React Native or Skia in the headless test runner. The sink
+ * receives commit frames only (simulation frequency), never per-display
+ * frames, and a stale write can never replace a newer commit: revisions are
+ * strictly increasing per session, and the initial envelope is presented
+ * through the same guard.
+ */
+export function bindGameSession(game, present) {
+  let lastRevision = -1;
+  const presentIfNewer = frame => {
+    if (frame.revision <= lastRevision) {
+      return;
+    }
+    lastRevision = frame.revision;
+    present(frame);
+  };
+  presentIfNewer(game.getRenderFrame());
+  const subscription = game.addCommitListener(presentIfNewer);
+  game.start();
+  let cleanedUp = false;
+  return () => {
+    if (cleanedUp) {
+      return;
+    }
+    cleanedUp = true;
+    subscription.remove();
+    if (game.status !== 'disposed') {
+      game.pause();
+    }
+  };
+}
+//# sourceMappingURL=bindGameSession.js.map

package/lib/module/react/bindGameSession.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["bindGameSession","game","present","lastRevision","presentIfNewer","frame","revision","getRenderFrame","subscription","addCommitListener","start","cleanedUp","remove","status","pause"],"sourceRoot":"../../../src","sources":["react/bindGameSession.ts"],"mappings":";;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASA,eAAeA,CAC7BC,IAAkC,EAClCC,OAA8C,EAClC;EACZ,IAAIC,YAAY,GAAG,CAAC,CAAC;EACrB,MAAMC,cAAc,GAAIC,KAA2B,IAAK;IACtD,IAAIA,KAAK,CAACC,QAAQ,IAAIH,YAAY,EAAE;MAClC;IACF;IACAA,YAAY,GAAGE,KAAK,CAACC,QAAQ;IAC7BJ,OAAO,CAACG,KAAK,CAAC;EAChB,CAAC;EACDD,cAAc,CAACH,IAAI,CAACM,cAAc,CAAC,CAAC,CAAC;EACrC,MAAMC,YAAY,GAAGP,IAAI,CAACQ,iBAAiB,CAACL,cAAc,CAAC;EAC3DH,IAAI,CAACS,KAAK,CAAC,CAAC;EACZ,IAAIC,SAAS,GAAG,KAAK;EAErB,OAAO,MAAM;IACX,IAAIA,SAAS,EAAE;MACb;IACF;IACAA,SAAS,GAAG,IAAI;IAChBH,YAAY,CAACI,MAAM,CAAC,CAAC;IACrB,IAAIX,IAAI,CAACY,MAAM,KAAK,UAAU,EAAE;MAC9BZ,IAAI,CAACa,KAAK,CAAC,CAAC;IACd;EACF,CAAC;AACH","ignoreList":[]}

package/lib/module/react/gestureLifecycle.js

@@ -0,0 +1,68 @@
+"use strict";
+
+/** RN-side mirror of whether the trailing-flush sampler should be mounted. */
+
+/**
+ * Manual-gesture terminal lifecycle (F3).
+ *
+ * The RNGH 3 manual recognizer is activated explicitly on touch-down and
+ * must be returned to its terminal state explicitly: it stays active across
+ * separate touches and screen lifecycles otherwise. This pure decision
+ * drives the deactivation call in `GamePointerInput`; the recognizer-state
+ * operations themselves stay on the UI runtime.
+ */
+
+/** A single-pointer binding begins only with the first native touch. */
+export function canBeginPrimaryPointer(nativeTouchCount) {
+  'worklet';
+
+  return nativeTouchCount === 1;
+}
+
+/** After an up edge, deactivate once RNGH reports that no touches remain. */
+export function deactivateAfterUp(remainingTouches) {
+  'worklet';
+
+  return remainingTouches === 0;
+}
+
+/** Unexpected finalization while a pointer is still active must neutralize ownership. */
+export function cancelOnActiveFinalize(activePointerId) {
+  'worklet';
+
+  return activePointerId !== undefined;
+}
+
+/**
+ * Sampler mirror for the F2 trailing flush (F2 lifecycle).
+ *
+ * The trailing-flush frame callback must stay active exactly while the
+ * coalescer owns a pointer. Returns `true` when a begin crossed (pointer
+ * owned), `false` when a terminal edge crossed (pointer released), and
+ * `undefined` for empty batches (secondary touches — never toggle the
+ * sampler) and flushed moves (the pointer stays owned).
+ */
+export function samplerMirrorFromBatch(batch) {
+  'worklet';
+
+  if (batch.length === 0) {
+    return undefined;
+  }
+  const kind = batch[batch.length - 1]?.kind;
+  if (kind === 'begin') {
+    return true;
+  }
+  if (kind === 'end' || kind === 'cancel') {
+    return false;
+  }
+  return undefined;
+}
+
+/**
+ * Apply a UI-originated sampler update only when it belongs to the current
+ * binding generation.
+ */
+export function reduceSamplerMirrorState(currentGeneration, previous, next) {
+  return next.generation === currentGeneration ? next : previous;
+}
+//# sourceMappingURL=gestureLifecycle.js.map

package/lib/module/react/gestureLifecycle.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["canBeginPrimaryPointer","nativeTouchCount","deactivateAfterUp","remainingTouches","cancelOnActiveFinalize","activePointerId","undefined","samplerMirrorFromBatch","batch","length","kind","reduceSamplerMirrorState","currentGeneration","previous","next","generation"],"sourceRoot":"../../../src","sources":["react/gestureLifecycle.ts"],"mappings":";;AAEA;;AAMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,OAAO,SAASA,sBAAsBA,CAACC,gBAAwB,EAAW;EACxE,SAAS;;EACT,OAAOA,gBAAgB,KAAK,CAAC;AAC/B;;AAEA;AACA,OAAO,SAASC,iBAAiBA,CAACC,gBAAwB,EAAW;EACnE,SAAS;;EACT,OAAOA,gBAAgB,KAAK,CAAC;AAC/B;;AAEA;AACA,OAAO,SAASC,sBAAsBA,CAACC,eAAmC,EAAW;EACnF,SAAS;;EACT,OAAOA,eAAe,KAAKC,SAAS;AACtC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,sBAAsBA,CACpCC,KAAuC,EAClB;EACrB,SAAS;;EACT,IAAIA,KAAK,CAACC,MAAM,KAAK,CAAC,EAAE;IACtB,OAAOH,SAAS;EAClB;EACA,MAAMI,IAAI,GAAGF,KAAK,CAACA,KAAK,CAACC,MAAM,GAAG,CAAC,CAAC,EAAEC,IAAI;EAC1C,IAAIA,IAAI,KAAK,OAAO,EAAE;IACpB,OAAO,IAAI;EACb;EACA,IAAIA,IAAI,KAAK,KAAK,IAAIA,IAAI,KAAK,QAAQ,EAAE;IACvC,OAAO,KAAK;EACd;EACA,OAAOJ,SAAS;AAClB;;AAEA;AACA;AACA;AACA;AACA,OAAO,SAASK,wBAAwBA,CACtCC,iBAAyB,EACzBC,QAA4B,EAC5BC,IAAwB,EACJ;EACpB,OAAOA,IAAI,CAACC,UAAU,KAAKH,iBAAiB,GAAGE,IAAI,GAAGD,QAAQ;AAChE","ignoreList":[]}

package/lib/module/react/instrumentation.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=instrumentation.js.map

package/lib/module/react/instrumentation.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["react/instrumentation.ts"],"mappings":"","ignoreList":[]}

package/lib/module/react/pointerBinding.js

@@ -0,0 +1,196 @@
+"use strict";
+
+import { containsSurfacePoint, surfaceToWorld } from "../viewport2d/index.js";
+
+/**
+ * A coalesced pointer event stamped with the binding epoch it was scheduled
+ * under (F6). Packets scheduled before a layout revision or binding
+ * replacement carry the old epoch and are rejected on the RN runtime, so a
+ * stale begin cannot reacquire input with old coordinates and a stale
+ * terminal edge cannot release a newer capture that reused the pointer id.
+ */
+
+/** Monotonic generation source for factory-created bindings (F3). */
+let nextFactoryGeneration = 1;
+
+/** The identity a pointer binding is scoped to. */
+
+/** A binding plus the identity it was created for. */
+
+/**
+ * Reuse the previous binding when the identity is unchanged, otherwise dispose
+ * it and create a fresh binding. Returns whether a new binding was created.
+ */
+export function createPointerBinding(identity, getViewport, previous) {
+  if (previous !== undefined && previous.identity.input === identity.input && previous.identity.action === identity.action && previous.identity.viewport === identity.viewport) {
+    return {
+      entry: previous,
+      created: false
+    };
+  }
+  if (previous !== undefined) {
+    previous.binding.dispose();
+  }
+  return {
+    entry: {
+      binding: new PointerBinding(identity.action, identity.input, getViewport, nextFactoryGeneration++),
+      identity
+    },
+    created: true
+  };
+}
+
+/**
+ * Platform-neutral pointer binding seam.
+ *
+ * It converts gesture positions from surface coordinates into logical world
+ * coordinates through the current resolved viewport, rejects begins that
+ * start in `fit` letterbox space, and forwards semantic events into the
+ * session input buffer. The high-level `handleTouches*` methods mirror the
+ * adapter's touch dispatch (including forwarding the final up position) so
+ * the full adapter behavior is testable without mounting native gesture
+ * views. Ownership and neutralization live in the input buffer.
+ */
+export class PointerBinding {
+  #action;
+  #input;
+  #getViewport;
+  #generation;
+  #disposed = false;
+  constructor(action, input, getViewport, generation) {
+    this.#action = action;
+    this.#input = input;
+    this.#getViewport = getViewport;
+    this.#generation = generation;
+  }
+
+  /**
+   * The monotonic adapter-owned generation this binding belongs to (F3).
+   * Generations never reset to zero, so a replacement binding and the
+   * worklet closures that stamp its packets agree by construction — no
+   * post-commit synchronization is needed.
+   */
+  get generation() {
+    return this.#generation;
+  }
+
+  /**
+   * Dispatch a coalesced packet stamped with its scheduling generation.
+   *
+   * Returns `false` (and forwards nothing) when the binding is disposed or
+   * the packet belongs to a different generation; the active gesture's
+   * packets keep flowing under the current generation with the latest
+   * viewport. Layout-epoch rejection happens on the adapter side (the epoch
+   * is adapter-owned and never resets, so it cannot desynchronize).
+   */
+  dispatch(packet) {
+    if (this.#disposed || packet.generation !== this.#generation) {
+      return false;
+    }
+    switch (packet.kind) {
+      case 'begin':
+        this.handleTouchesDown(packet.pointerId, packet.x, packet.y);
+        break;
+      case 'move':
+        this.handleTouchesMove(packet.pointerId, packet.x, packet.y);
+        break;
+      case 'end':
+        this.handleTouchesUp(packet.pointerId, packet.x, packet.y);
+        break;
+      case 'cancel':
+        this.handleTouchesCancelled();
+        break;
+    }
+    return true;
+  }
+
+  /**
+   * Begin a pointer at a surface point.
+   *
+   * Returns `false` when the layout is invalid or the point starts in
+   * letterbox space; the gesture must be rejected and never becomes the owner.
+   */
+  begin(pointerId, surfacePoint) {
+    if (this.#disposed) {
+      return false;
+    }
+    const viewport = this.#getViewport();
+    if (viewport === undefined) {
+      return false;
+    }
+    if (!containsSurfacePoint(viewport, surfacePoint)) {
+      return false;
+    }
+    this.#input.begin(this.#action, pointerId, surfaceToWorld(viewport, surfacePoint));
+    return true;
+  }
+
+  /** Move a pointer. Conversion remains unbounded outside content bounds. */
+  move(pointerId, surfacePoint) {
+    if (this.#disposed) {
+      return;
+    }
+    const viewport = this.#getViewport();
+    if (viewport === undefined) {
+      return;
+    }
+    this.#input.move(this.#action, pointerId, surfaceToWorld(viewport, surfacePoint));
+  }
+
+  /** End a pointer. The owning pointer is released by the input buffer. */
+  end(pointerId) {
+    if (this.#disposed) {
+      return;
+    }
+    this.#input.end(this.#action, pointerId);
+  }
+
+  /** Cancel the active pointer (gesture cancellation, layout change, unmount). */
+  cancel() {
+    if (this.#disposed) {
+      return;
+    }
+    this.#input.cancel(this.#action);
+  }
+
+  /** Handle a touch-down gesture event with a surface position. */
+  handleTouchesDown(pointerId, x, y) {
+    return this.begin(pointerId, {
+      x,
+      y
+    });
+  }
+
+  /** Handle a touch-move gesture event with a surface position. */
+  handleTouchesMove(pointerId, x, y) {
+    this.move(pointerId, {
+      x,
+      y
+    });
+  }
+
+  /**
+   * Handle a touch-up gesture event with its final surface position.
+   *
+   * The final position is forwarded before ownership ends so the documented
+   * release frame contains the actual point where the pointer lifted.
+   */
+  handleTouchesUp(pointerId, x, y) {
+    this.move(pointerId, {
+      x,
+      y
+    });
+    this.end(pointerId);
+  }
+
+  /** Handle a platform touch cancellation. */
+  handleTouchesCancelled() {
+    this.cancel();
+  }
+
+  /** Stop forwarding events. Safe to call repeatedly. */
+  dispose() {
+    this.#disposed = true;
+  }
+}
+//# sourceMappingURL=pointerBinding.js.map

package/lib/module/react/pointerBinding.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["containsSurfacePoint","surfaceToWorld","nextFactoryGeneration","createPointerBinding","identity","getViewport","previous","undefined","input","action","viewport","entry","created","binding","dispose","PointerBinding","generation","disposed","constructor","dispatch","packet","kind","handleTouchesDown","pointerId","x","y","handleTouchesMove","handleTouchesUp","handleTouchesCancelled","begin","surfacePoint","move","end","cancel"],"sourceRoot":"../../../src","sources":["react/pointerBinding.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/react/pointerCoalescer.js

@@ -0,0 +1,224 @@
+"use strict";
+
+/**
+ * Pointer coalescer (T7).
+ *
+ * Pure, worklet-safe state machine that throttles move forwarding from the
+ * UI runtime: at most one move crosses runtimes per configured interval
+ * (default: one fixed step), always carrying the latest dirty position.
+ * Edges are never throttled or dropped:
+ *
+ * - `down` forwards the begin immediately (latency-critical) and establishes
+ *   the single active pointer; a secondary pointer is ignored.
+ * - `move` updates the latest dirty position and forwards it at most once
+ *   per interval.
+ * - `flush` forwards the latest deferred move even if native touch movement
+ *   has paused.
+ * - `up` forwards the final position in the terminal edge and releases the
+ *   active pointer.
+ * - `cancel` neutralizes exactly once.
+ * - `reset` drops all queued state (layout revision, unmount).
+ *
+ * The coalescer is not the authoritative owner: ownership, edge sampling,
+ * and containment re-validation stay on the JS side (input buffer).
+ * Time is injected so ordering and frequency are testable without a device.
+ */
+
+/** Explicit coalescer state stored in one UI-runtime SharedValue. */
+
+/** One native touch input consumed by the pure coalescer reducer. */
+
+/** Immutable state plus the ordered events produced by one coalescer input. */
+
+/** Create fresh state for a UI-runtime coalescer. */
+export function createPointerCoalescerState(maxMoveIntervalMs) {
+  'worklet';
+
+  return {
+    maxMoveIntervalMs,
+    active: undefined
+  };
+}
+
+/**
+ * Advance pointer coalescing without relying on mutable worklet closures.
+ *
+ * RNGH registers each touch callback as a separate worklet. Closure-captured
+ * objects may therefore be serialized into independent copies; callers must
+ * keep the returned state in one SharedValue and pass it into every handler.
+ */
+export function reducePointerCoalescer(state, input) {
+  'worklet';
+
+  if (input.kind === 'reset') {
+    return {
+      state: createPointerCoalescerState(state.maxMoveIntervalMs),
+      events: []
+    };
+  }
+  if (input.kind === 'down') {
+    if (state.active !== undefined) {
+      return {
+        state,
+        events: []
+      };
+    }
+    return {
+      state: {
+        ...state,
+        active: {
+          pointerId: input.pointerId,
+          lastForwardMs: input.nowMs,
+          pendingMove: undefined
+        }
+      },
+      events: [{
+        kind: 'begin',
+        pointerId: input.pointerId,
+        x: input.x,
+        y: input.y
+      }]
+    };
+  }
+  if (input.kind === 'cancel') {
+    if (state.active === undefined) {
+      return {
+        state,
+        events: []
+      };
+    }
+    return {
+      state: {
+        ...state,
+        active: undefined
+      },
+      events: [{
+        kind: 'cancel'
+      }]
+    };
+  }
+  const active = state.active;
+  if (input.kind === 'flush') {
+    if (active === undefined || active.pendingMove === undefined) {
+      return {
+        state,
+        events: []
+      };
+    }
+    if (input.nowMs - active.lastForwardMs < state.maxMoveIntervalMs) {
+      return {
+        state,
+        events: []
+      };
+    }
+    return {
+      state: {
+        ...state,
+        active: {
+          ...active,
+          lastForwardMs: input.nowMs,
+          pendingMove: undefined
+        }
+      },
+      events: [{
+        kind: 'move',
+        pointerId: active.pointerId,
+        x: active.pendingMove.x,
+        y: active.pendingMove.y
+      }]
+    };
+  }
+  if (active === undefined || active.pointerId !== input.pointerId) {
+    return {
+      state,
+      events: []
+    };
+  }
+  if (input.kind === 'up') {
+    return {
+      state: {
+        ...state,
+        active: undefined
+      },
+      // The terminal event carries the newest point, subsuming a deferred move.
+      events: [{
+        kind: 'end',
+        pointerId: input.pointerId,
+        x: input.x,
+        y: input.y
+      }]
+    };
+  }
+  const shouldForward = input.nowMs - active.lastForwardMs >= state.maxMoveIntervalMs;
+  const nextActive = {
+    pointerId: input.pointerId,
+    lastForwardMs: shouldForward ? input.nowMs : active.lastForwardMs,
+    pendingMove: shouldForward ? undefined : {
+      x: input.x,
+      y: input.y
+    }
+  };
+  return {
+    state: {
+      ...state,
+      active: nextActive
+    },
+    events: shouldForward ? [{
+      kind: 'move',
+      pointerId: input.pointerId,
+      x: input.x,
+      y: input.y
+    }] : []
+  };
+}
+
+/**
+ * Stateful RN-runtime adapter retained for pure tests and non-worklet callers.
+ * UI gesture handlers use `reducePointerCoalescer` with a SharedValue instead.
+ */
+export function createPointerCoalescer(maxMoveIntervalMs) {
+  let state = createPointerCoalescerState(maxMoveIntervalMs);
+  const dispatch = input => {
+    const transition = reducePointerCoalescer(state, input);
+    state = transition.state;
+    return transition.events;
+  };
+  const coalescer = {
+    down: (pointerId, x, y, nowMs) => dispatch({
+      kind: 'down',
+      pointerId,
+      x,
+      y,
+      nowMs
+    }),
+    move: (pointerId, x, y, nowMs) => dispatch({
+      kind: 'move',
+      pointerId,
+      x,
+      y,
+      nowMs
+    }),
+    flush: nowMs => dispatch({
+      kind: 'flush',
+      nowMs
+    }),
+    up: (pointerId, x, y, nowMs) => dispatch({
+      kind: 'up',
+      pointerId,
+      x,
+      y,
+      nowMs
+    }),
+    cancel: nowMs => dispatch({
+      kind: 'cancel',
+      nowMs
+    }),
+    reset: () => {
+      dispatch({
+        kind: 'reset'
+      });
+    }
+  };
+  return Object.freeze(coalescer);
+}
+//# sourceMappingURL=pointerCoalescer.js.map

package/lib/module/react/pointerCoalescer.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createPointerCoalescerState","maxMoveIntervalMs","active","undefined","reducePointerCoalescer","state","input","kind","events","pointerId","lastForwardMs","nowMs","pendingMove","x","y","shouldForward","nextActive","createPointerCoalescer","dispatch","transition","coalescer","down","move","flush","up","cancel","reset","Object","freeze"],"sourceRoot":"../../../src","sources":["react/pointerCoalescer.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/react/pointerContainment.js

@@ -0,0 +1,27 @@
+"use strict";
+
+/**
+ * UI-side containment mirror (T7).
+ *
+ * The exact same viewport formula the JS binding uses to reject begins in
+ * `fit` letterbox space, workletized so the Manual gesture can fail before
+ * activation. JS re-validates on receipt; this mirror only prevents an
+ * obviously invalid begin from activating the gesture at all.
+ */
+
+/** Whether a surface point may begin a gesture in the interactive content. */
+export function isBeginAllowed(viewport, x, y) {
+  'worklet';
+
+  if (viewport === undefined) {
+    return false;
+  }
+  const {
+    x: boundsX,
+    y: boundsY,
+    width,
+    height
+  } = viewport.contentBounds;
+  return x >= boundsX && y >= boundsY && x <= boundsX + width && y <= boundsY + height;
+}
+//# sourceMappingURL=pointerContainment.js.map

package/lib/module/react/pointerContainment.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["isBeginAllowed","viewport","x","y","undefined","boundsX","boundsY","width","height","contentBounds"],"sourceRoot":"../../../src","sources":["react/pointerContainment.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGA;AACA,OAAO,SAASA,cAAcA,CAC5BC,QAAwC,EACxCC,CAAS,EACTC,CAAS,EACA;EACT,SAAS;;EACT,IAAIF,QAAQ,KAAKG,SAAS,EAAE;IAC1B,OAAO,KAAK;EACd;EACA,MAAM;IAAEF,CAAC,EAAEG,OAAO;IAAEF,CAAC,EAAEG,OAAO;IAAEC,KAAK;IAAEC;EAAO,CAAC,GAAGP,QAAQ,CAACQ,aAAa;EACxE,OAAOP,CAAC,IAAIG,OAAO,IAAIF,CAAC,IAAIG,OAAO,IAAIJ,CAAC,IAAIG,OAAO,GAAGE,KAAK,IAAIJ,CAAC,IAAIG,OAAO,GAAGE,MAAM;AACtF","ignoreList":[]}