diff --git a/.gitignore b/.gitignore
index 580051f..331b206 100644
--- a/.gitignore
+++ b/.gitignore
@@ -204,3 +204,4 @@ dist
 .astro
 
 /blog
+/tmp_docs
diff --git a/docs/package.json b/docs/package.json
index f55c457..7e0593f 100644
--- a/docs/package.json
+++ b/docs/package.json
@@ -12,6 +12,7 @@
     "@astrojs/mdx": "^4.3.0",
     "@cereb/pan": "workspace:^",
     "@cereb/pinch": "workspace:^",
+    "@cereb/tap": "workspace:^",
     "@tailwindcss/vite": "^4.1.17",
     "astro": "^5.16.4",
     "astro-embed": "^0.9.2",
diff --git a/docs/src/components/examples/space-adventure.astro b/docs/src/components/examples/space-adventure.astro
index d665116..ae42f37 100644
--- a/docs/src/components/examples/space-adventure.astro
+++ b/docs/src/components/examples/space-adventure.astro
@@ -12,7 +12,7 @@ import "./space-adventure.css";
     <strong id="space-zoom-mode" class="_zoom-mode">Zoom Mode</strong>
     <div class="_tip">
       <strong class="_tip-title">Tip.</strong>
-      Pinch or change slider to zoom.<br />
+      Pinch, double tap, or change slider to zoom.<br />
       In Desktop, use 'z' + '+/-' or 'wheel' to zoom.
     </div>
   </div>
@@ -42,8 +42,9 @@ import "./space-adventure.css";
 
 <script>
 import { wheel, keydown, keyheld, type KeyboardSignal, type WheelSignal, domEvent, type KeyboardValue, type Signal } from "cereb";
-import { zoom as createZoom, extend, when, spy, type ZoomInput, type ZoomOptions } from "cereb/operators";
+import { zoom as createZoom, extend, when, spy, filter, type ZoomInput, type ZoomOptions } from "cereb/operators";
 import { pinch } from "@cereb/pinch";
+import { tap, type TapSignal } from "@cereb/tap";
 
 interface Star {
   x: number;
@@ -819,6 +820,22 @@ function initSpacePinchZoom() {
     )
     .on(render);
 
+  // Double Tap Zoom
+  const DOUBLE_TAP_ZOOM_MULTIPLIER = 2.5;
+  tap(box, { chainIntervalThreshold: 300 })
+    .pipe(
+      filter((signal) => signal.value.tapCount === 2),
+      extend<TapSignal, ZoomInput>(() => {
+        const currentScale = zoomManager.getScale();
+        const isNearMax = currentScale >= MAX_SCALE * 0.9;
+        return {
+          ratio: isNearMax ? 1 : Math.min(currentScale * DOUBLE_TAP_ZOOM_MULTIPLIER, MAX_SCALE),
+        };
+      }),
+      zoom({ baseScale: 1.0 }),
+    )
+    .on(render);
+
   // 'z' + '+/-' (logarithmic zoom: multiply by 1.2 or 1/1.2)
   keydown(window, { code: ["Equal", "Minus"] })
     .pipe(
diff --git a/docs/src/config/sidebar.json b/docs/src/config/sidebar.json
index 99c9a7d..7e33a77 100644
--- a/docs/src/config/sidebar.json
+++ b/docs/src/config/sidebar.json
@@ -58,6 +58,10 @@
           "label": "pinch",
           "slug": "stream-api/pinch"
         },
+        {
+          "label": "tap",
+          "slug": "stream-api/tap"
+        },
         {
           "label": "singlePointer",
           "slug": "stream-api/single-pointer"
diff --git a/docs/src/content/stream-api/pan.mdx b/docs/src/content/stream-api/pan.mdx
index 3a96cff..6114396 100644
--- a/docs/src/content/stream-api/pan.mdx
+++ b/docs/src/content/stream-api/pan.mdx
@@ -109,3 +109,38 @@ singlePointer(element)
   .pipe(panRecognizer({ threshold: 10 }))
   .on((signal) => { /* ... */ });
 ```
+
+## Advanced: createPanRecognizer
+
+Low-level API for imperative usage or custom integrations.
+The recognizer accepts any signal that satisfies `PanSourceSignal` interface.
+
+```typescript
+import { createPanRecognizer, type PanSourceSignal } from "@cereb/pan";
+
+const recognizer = createPanRecognizer({ threshold: 10 });
+
+// Works with any source that provides the required properties
+function handlePointerEvent(signal: PanSourceSignal) {
+  const panEvent = recognizer.process(signal);
+  if (panEvent) {
+    console.log(panEvent.value.deltaX, panEvent.value.velocityX);
+  }
+}
+```
+
+### PanSourceSignal Interface
+
+```typescript
+interface PanSourceSignal {
+  value: {
+    phase: "start" | "move" | "end" | "cancel";
+    x: number;
+    y: number;
+    pageX: number;
+    pageY: number;
+  };
+  createdAt: number;
+  deviceId: string;
+}
+```
diff --git a/docs/src/content/stream-api/pinch.mdx b/docs/src/content/stream-api/pinch.mdx
index 0566bb4..ad7b83b 100644
--- a/docs/src/content/stream-api/pinch.mdx
+++ b/docs/src/content/stream-api/pinch.mdx
@@ -92,3 +92,43 @@ multiPointer(element, { maxPointers: 2 })
   )
   .on((signal) => { /* ... */ });
 ```
+
+## Advanced: createPinchRecognizer
+
+Low-level API for imperative usage or custom integrations.
+The recognizer accepts any signal that satisfies `PinchSourceSignal` interface.
+
+```typescript
+import { createPinchRecognizer, type PinchSourceSignal } from "@cereb/pinch";
+
+const recognizer = createPinchRecognizer({ threshold: 10 });
+
+// Works with any source that provides the required properties
+function handleMultiPointerEvent(signal: PinchSourceSignal) {
+  const pinchEvent = recognizer.process(signal);
+  if (pinchEvent) {
+    console.log(pinchEvent.value.distance, pinchEvent.value.velocity);
+  }
+}
+```
+
+### PinchSourceSignal Interface
+
+```typescript
+interface PinchSourcePointer {
+  id: string;
+  phase: "start" | "move" | "end" | "cancel";
+  x: number;
+  y: number;
+  pageX: number;
+  pageY: number;
+}
+
+interface PinchSourceSignal {
+  value: {
+    pointers: readonly PinchSourcePointer[];
+  };
+  createdAt: number;
+  deviceId: string;
+}
+```
diff --git a/docs/src/content/stream-api/tap.mdx b/docs/src/content/stream-api/tap.mdx
new file mode 100644
index 0000000..802347d
--- /dev/null
+++ b/docs/src/content/stream-api/tap.mdx
@@ -0,0 +1,176 @@
+# `tap`
+
+Tap gesture recognition with multi-tap support. Detects single, double, triple taps and beyond with configurable timing and distance thresholds.
+
+```bash
+npm install --save @cereb/tap
+```
+
+## Basic Usage
+
+```typescript
+import { tap } from "@cereb/tap";
+
+tap(element).on((signal) => {
+  const { tapCount, x, y } = signal.value;
+
+  if (tapCount === 1) {
+    console.log("Single tap");
+  } else if (tapCount === 2) {
+    console.log("Double tap - zoom in!");
+  }
+});
+```
+
+## Signature
+
+```typescript
+function tap(target: EventTarget, options?: TapOptions): Stream<TapSignal>
+```
+
+## Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `movementThreshold` | `number` | `10` | Max movement (px) allowed during tap |
+| `durationThreshold` | `number` | `500` | Max duration (ms) for a valid tap |
+| `chainMovementThreshold` | `number` | `movementThreshold` | Max distance between consecutive taps |
+| `chainIntervalThreshold` | `number` | `durationThreshold / 2` | Max interval (ms) between consecutive taps |
+
+### Multi-Tap Configuration
+
+```typescript
+// Fast double-tap detection
+tap(element, {
+  durationThreshold: 300,
+  chainIntervalThreshold: 250
+})
+
+// Strict tap positioning
+tap(element, {
+  movementThreshold: 5,
+  chainMovementThreshold: 20
+})
+```
+
+## Signal Value
+
+The `signal.value` contains:
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `phase` | `"start" \| "end" \| "cancel"` | Current gesture phase |
+| `x` | `number` | Tap X position (clientX) |
+| `y` | `number` | Tap Y position (clientY) |
+| `pageX` | `number` | Tap X position (pageX) |
+| `pageY` | `number` | Tap Y position (pageY) |
+| `tapCount` | `number` | Consecutive tap count (1, 2, 3, ...) |
+| `duration` | `number` | How long pointer was pressed (ms) |
+| `pointerType` | `"mouse" \| "touch" \| "pen" \| "unknown"` | Input device type |
+
+## Phase Lifecycle
+
+```
+pointer down → "start" → pointer up (within thresholds) → "end"
+                       → moved too far / held too long → "cancel"
+```
+
+- **start**: Pointer pressed down
+- **end**: Valid tap completed (tapCount incremented if chained)
+- **cancel**: Tap invalidated (moved too far or held too long)
+
+## Multi-Tap Chaining
+
+Taps are chained when:
+1. Time between taps is less than `chainIntervalThreshold`
+2. Distance between tap positions is less than `chainMovementThreshold`
+
+```
+tap → 200ms → tap → 200ms → tap = tapCount: 3 (triple tap)
+tap → 500ms → tap                = tapCount: 1 (chain reset)
+```
+
+## With Visual Feedback
+
+Use `tapRecognizer` for full lifecycle handling:
+
+```typescript
+import { singlePointer } from "cereb";
+import { tapRecognizer } from "@cereb/tap";
+
+singlePointer(element)
+  .pipe(tapRecognizer())
+  .on((signal) => {
+    const { phase } = signal.value;
+
+    if (phase === "start") {
+      element.classList.add("pressed");
+    } else {
+      element.classList.remove("pressed");
+    }
+  });
+```
+
+## Advanced: tapRecognizer
+
+Use as an operator with custom pointer sources:
+
+```typescript
+import { singlePointer } from "cereb";
+import { tapRecognizer } from "@cereb/tap";
+
+singlePointer(element)
+  .pipe(tapRecognizer({ durationThreshold: 300 }))
+  .on((signal) => { /* ... */ });
+```
+
+## Advanced: tapEndOnly
+
+Only emits successful taps (filters out start/cancel):
+
+```typescript
+import { singlePointer } from "cereb";
+import { tapEndOnly } from "@cereb/tap";
+
+singlePointer(element)
+  .pipe(tapEndOnly())
+  .on((signal) => {
+    console.log(`Tap ${signal.value.tapCount}!`);
+  });
+```
+
+## Advanced: createTapRecognizer
+
+Low-level API for imperative usage or custom integrations.
+The recognizer accepts any signal that satisfies `TapSourceSignal` interface.
+
+```typescript
+import { createTapRecognizer, type TapSourceSignal } from "@cereb/tap";
+
+const recognizer = createTapRecognizer({ durationThreshold: 300 });
+
+// Works with any source that provides the required properties
+function handlePointerEvent(signal: TapSourceSignal) {
+  const tapEvent = recognizer.process(signal);
+  if (tapEvent?.value.phase === "end") {
+    console.log(`Tap ${tapEvent.value.tapCount}!`);
+  }
+}
+```
+
+### TapSourceSignal Interface
+
+```typescript
+interface TapSourceSignal {
+  value: {
+    phase: "start" | "move" | "end" | "cancel";
+    x: number;
+    y: number;
+    pageX: number;
+    pageY: number;
+    pointerType: "touch" | "mouse" | "pen" | "unknown";
+  };
+  createdAt: number;
+  deviceId: string;
+}
+```
diff --git a/docs/src/layouts/docs-layout.astro b/docs/src/layouts/docs-layout.astro
index ecde65e..5fcfb64 100644
--- a/docs/src/layouts/docs-layout.astro
+++ b/docs/src/layouts/docs-layout.astro
@@ -94,7 +94,10 @@ const sidebar = getSidebar(currentPath);
 
   .container {
     display: flex;
+    position: relative;
     width: 100%;
+    max-width: 1200px !important;
+    margin: 0 auto;
     padding: var(--sl-header-height) var(--sl-nav-pad-x) 0 220px;
     box-sizing: border-box;
   }
diff --git a/docs/src/pages/stream-api/pan.astro b/docs/src/pages/stream-api/pan.astro
index 39163b7..1ebc687 100644
--- a/docs/src/pages/stream-api/pan.astro
+++ b/docs/src/pages/stream-api/pan.astro
@@ -10,6 +10,7 @@ const headings = [
   { depth: 2, slug: "phase-lifecycle", text: "Phase Lifecycle" },
   { depth: 2, slug: "operators", text: "Operators" },
   { depth: 2, slug: "advanced-panrecognizer", text: "Advanced: panRecognizer" },
+  { depth: 2, slug: "advanced-createpanrecognizer", text: "Advanced: createPanRecognizer" },
 ];
 ---
 
diff --git a/docs/src/pages/stream-api/pinch.astro b/docs/src/pages/stream-api/pinch.astro
index 9573714..4231ff0 100644
--- a/docs/src/pages/stream-api/pinch.astro
+++ b/docs/src/pages/stream-api/pinch.astro
@@ -10,6 +10,7 @@ const headings = [
   { depth: 2, slug: "phase-lifecycle", text: "Phase Lifecycle" },
   { depth: 2, slug: "with-zoom-operator", text: "With Zoom Operator" },
   { depth: 2, slug: "advanced-pinchrecognizer", text: "Advanced: pinchRecognizer" },
+  { depth: 2, slug: "advanced-createpinchrecognizer", text: "Advanced: createPinchRecognizer" },
 ];
 ---
 
diff --git a/docs/src/pages/stream-api/tap.astro b/docs/src/pages/stream-api/tap.astro
new file mode 100644
index 0000000..e4ef44a
--- /dev/null
+++ b/docs/src/pages/stream-api/tap.astro
@@ -0,0 +1,21 @@
+---
+import DocsLayout from "@/layouts/docs-layout.astro";
+import Content from "@/content/stream-api/tap.mdx";
+
+const headings = [
+  { depth: 2, slug: "basic-usage", text: "Basic Usage" },
+  { depth: 2, slug: "signature", text: "Signature" },
+  { depth: 2, slug: "options", text: "Options" },
+  { depth: 2, slug: "signal-value", text: "Signal Value" },
+  { depth: 2, slug: "phase-lifecycle", text: "Phase Lifecycle" },
+  { depth: 2, slug: "multi-tap-chaining", text: "Multi-Tap Chaining" },
+  { depth: 2, slug: "with-visual-feedback", text: "With Visual Feedback" },
+  { depth: 2, slug: "advanced-taprecognizer", text: "Advanced: tapRecognizer" },
+  { depth: 2, slug: "advanced-tapendonly", text: "Advanced: tapEndOnly" },
+  { depth: 2, slug: "advanced-createtaprecognizer", text: "Advanced: createTapRecognizer" },
+];
+---
+
+<DocsLayout title="tap" description="Tap gesture recognition with multi-tap support" headings={headings}>
+  <Content />
+</DocsLayout>
diff --git a/docs/src/styles/custom-design/layout.css b/docs/src/styles/custom-design/layout.css
index bb7737c..483d212 100644
--- a/docs/src/styles/custom-design/layout.css
+++ b/docs/src/styles/custom-design/layout.css
@@ -18,10 +18,6 @@ body {
   @apply py-16! xl:py-24!;
 }
 
-/* container */
-.container {
-  @apply mx-auto max-w-full! xl:max-w-[1740px]! px-4;
-}
 .content-panel .sl-container {
   @apply mx-auto xl:max-w-[1740px]! ;
 }
diff --git a/packages/pan/README.md b/packages/pan/README.md
index 6ec15f8..43aeb2c 100644
--- a/packages/pan/README.md
+++ b/packages/pan/README.md
@@ -81,18 +81,20 @@ singlePointer(element)
 ### `createPanRecognizer(options?)`
 
 Low-level API for imperative usage or custom integrations.
+Accepts any signal that satisfies `PanSourceSignal` interface.
 
 ```typescript
-import { createPanRecognizer } from "@cereb/pan";
+import { createPanRecognizer, type PanSourceSignal } from "@cereb/pan";
 
 const recognizer = createPanRecognizer({ threshold: 10 });
 
-singlePointerStream.on((signal) => {
+// Works with any source that provides the required properties
+function handlePointerEvent(signal: PanSourceSignal) {
   const panEvent = recognizer.process(signal);
   if (panEvent) {
     console.log(panEvent.value.deltaX, panEvent.value.velocityX);
   }
-});
+}
 ```
 
 ## PanValue
diff --git a/packages/pan/package.json b/packages/pan/package.json
index bbbdb08..a97f808 100644
--- a/packages/pan/package.json
+++ b/packages/pan/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@cereb/pan",
   "description": "Pan gesture recognition, designed to work seamlessly with reactive streams and other gesture interactions.",
-  "version": "0.11.3",
+  "version": "0.12.0",
   "license": "MIT",
   "author": "devphilip21 <philip21.dev@gmail.com>",
   "repository": {
diff --git a/packages/pan/src/index.ts b/packages/pan/src/index.ts
index cfc63a1..59afae6 100644
--- a/packages/pan/src/index.ts
+++ b/packages/pan/src/index.ts
@@ -1,4 +1,12 @@
 export { pan, panRecognizer } from "./pan.js";
 export type { PanSignal, PanValue } from "./pan-signal.js";
-export type { PanDirection, PanDirectionMode, PanOptions, PanPhase } from "./pan-types.js";
+export type {
+  PanDirection,
+  PanDirectionMode,
+  PanOptions,
+  PanPhase,
+  PanSourcePhase,
+  PanSourceSignal,
+  PanSourceValue,
+} from "./pan-types.js";
 export { createPanRecognizer, type PanRecognizer } from "./recognizer.js";
diff --git a/packages/pan/src/pan-types.ts b/packages/pan/src/pan-types.ts
index a2f8a1a..d3151e2 100644
--- a/packages/pan/src/pan-types.ts
+++ b/packages/pan/src/pan-types.ts
@@ -4,6 +4,33 @@ export type PanDirection = "up" | "down" | "left" | "right" | "none";
 
 export type PanDirectionMode = "horizontal" | "vertical" | "all";
 
+/**
+ * Pointer phase values that PanRecognizer can process.
+ */
+export type PanSourcePhase = "start" | "move" | "end" | "cancel";
+
+/**
+ * Value interface that PanRecognizer requires from input signals.
+ * Any signal whose value satisfies this interface can be processed.
+ */
+export interface PanSourceValue {
+  readonly phase: PanSourcePhase;
+  readonly x: number;
+  readonly y: number;
+  readonly pageX: number;
+  readonly pageY: number;
+}
+
+/**
+ * Minimal signal interface that PanRecognizer requires.
+ * Decoupled from SinglePointerSignal to allow any compatible source.
+ */
+export interface PanSourceSignal {
+  readonly value: PanSourceValue;
+  readonly createdAt: number;
+  readonly deviceId: string;
+}
+
 export interface PanOptions {
   /**
    * Minimum movement required before pan gesture is recognized.
diff --git a/packages/pan/src/pan.ts b/packages/pan/src/pan.ts
index 9f22522..c342ab4 100644
--- a/packages/pan/src/pan.ts
+++ b/packages/pan/src/pan.ts
@@ -1,22 +1,26 @@
-import type { Operator, SinglePointerSignal, Stream } from "cereb";
+import type { Operator, Signal, Stream } from "cereb";
 import { createStream, singlePointer } from "cereb";
 import type { PanSignal } from "./pan-signal.js";
-import type { PanOptions } from "./pan-types.js";
+import type { PanOptions, PanSourceValue } from "./pan-types.js";
 import { createPanRecognizer } from "./recognizer.js";
 
 /**
- * Operator that transforms SinglePointer events into PanEvent events.
+ * Operator that transforms pointer events into PanSignal events.
+ *
+ * Accepts any Signal whose value satisfies PanSourceValue interface.
  *
  * Use this when you need to compose with other operators or use a custom pointer source.
  *
  * @example
  * ```typescript
  * singlePointer(element)
- *   .pipe(singlePointerToPan({ threshold: 10 }), withVelocity())
- *   .on(pan => console.log(pan.deltaX, pan.velocityX));
+ *   .pipe(panRecognizer({ threshold: 10 }))
+ *   .on(pan => console.log(pan.value.deltaX, pan.value.velocityX));
  * ```
  */
-export function panRecognizer(options: PanOptions = {}): Operator<SinglePointerSignal, PanSignal> {
+export function panRecognizer<T extends Signal<string, PanSourceValue>>(
+  options: PanOptions = {},
+): Operator<T, PanSignal> {
   return (source) =>
     createStream((observer) => {
       const recognizer = createPanRecognizer(options);
diff --git a/packages/pan/src/recognizer.ts b/packages/pan/src/recognizer.ts
index 858bbc7..004f5d2 100644
--- a/packages/pan/src/recognizer.ts
+++ b/packages/pan/src/recognizer.ts
@@ -1,7 +1,6 @@
-import type { SinglePointerSignal } from "cereb";
 import { calculateDistance, getDirection } from "./geometry.js";
 import { createPanSignal, type PanSignal } from "./pan-signal.js";
-import type { PanDirectionMode, PanOptions, PanPhase } from "./pan-types.js";
+import type { PanDirectionMode, PanOptions, PanPhase, PanSourceSignal } from "./pan-types.js";
 import { createInitialPanState, type PanState, resetPanState } from "./state.js";
 
 const DEFAULT_THRESHOLD = 10;
@@ -27,11 +26,14 @@ function calculateVelocity(
 }
 
 /**
- * Stateful processor that transforms SinglePointer events into PanSignal.
+ * Stateful processor that transforms pointer events into PanSignal.
  * Can be used imperatively or integrated into custom pipelines.
+ *
+ * Accepts any signal that satisfies PanSourceSignal interface,
+ * allowing integration with various input sources beyond SinglePointer.
  */
 export interface PanRecognizer {
-  process(pointer: SinglePointerSignal): PanSignal | null;
+  process(signal: PanSourceSignal): PanSignal | null;
   readonly isActive: boolean;
   readonly thresholdMet: boolean;
   reset(): void;
@@ -55,18 +57,18 @@ function isThresholdMet(
 }
 
 /**
- * Creates a pan gesture recognizer that processes SinglePointer events.
+ * Creates a pan gesture recognizer that processes pointer events.
  *
  * The recognizer maintains internal state and can be used:
  * - Imperatively via process() method
- * - With any event source (not just Observable streams)
+ * - With any event source that satisfies PanSourceSignal interface
  * - In Web Workers or other non-DOM contexts
  *
  * @example
  * ```typescript
  * const recognizer = createPanRecognizer({ threshold: 10 });
  *
- * singlePointerStream.subscribe((signal) => {
+ * pointerStream.on((signal) => {
  *   const panEvent = recognizer.process(signal);
  *   if (panEvent) {
  *     console.log(panEvent.value.deltaX, panEvent.value.velocityX);
@@ -78,17 +80,14 @@ export function createPanRecognizer(options: PanOptions = {}): PanRecognizer {
   const { threshold = DEFAULT_THRESHOLD, direction = "all" } = options;
   const state: PanState = createInitialPanState();
 
-  function createPanSignalFromPointer(
-    pointerSignal: SinglePointerSignal,
-    phase: PanPhase,
-  ): PanSignal {
-    const deltaX = pointerSignal.value.x - state.startX;
-    const deltaY = pointerSignal.value.y - state.startY;
+  function createPanSignalFromSource(signal: PanSourceSignal, phase: PanPhase): PanSignal {
+    const deltaX = signal.value.x - state.startX;
+    const deltaY = signal.value.y - state.startY;
 
     const { velocityX, velocityY } = calculateVelocity(
-      pointerSignal.value.x,
-      pointerSignal.value.y,
-      pointerSignal.createdAt,
+      signal.value.x,
+      signal.value.y,
+      signal.createdAt,
       state.prevX,
       state.prevY,
       state.prevTimestamp,
@@ -102,14 +101,14 @@ export function createPanRecognizer(options: PanOptions = {}): PanRecognizer {
       direction: getDirection(deltaX, deltaY),
       velocityX,
       velocityY,
-      x: pointerSignal.value.x,
-      y: pointerSignal.value.y,
-      pageX: pointerSignal.value.pageX,
-      pageY: pointerSignal.value.pageY,
+      x: signal.value.x,
+      y: signal.value.y,
+      pageX: signal.value.pageX,
+      pageY: signal.value.pageY,
     });
   }
 
-  function handleStart(signal: SinglePointerSignal): null {
+  function handleStart(signal: PanSourceSignal): null {
     state.isActive = true;
     state.thresholdMet = false;
     state.startX = signal.value.x;
@@ -123,7 +122,7 @@ export function createPanRecognizer(options: PanOptions = {}): PanRecognizer {
     return null;
   }
 
-  function handleMove(signal: SinglePointerSignal): PanSignal | null {
+  function handleMove(signal: PanSourceSignal): PanSignal | null {
     if (!state.isActive) return null;
 
     const deltaX = signal.value.x - state.startX;
@@ -142,10 +141,10 @@ export function createPanRecognizer(options: PanOptions = {}): PanRecognizer {
     if (!state.thresholdMet) {
       if (isThresholdMet(deltaX, deltaY, threshold, direction)) {
         state.thresholdMet = true;
-        result = createPanSignalFromPointer(signal, "start");
+        result = createPanSignalFromSource(signal, "start");
       }
     } else {
-      result = createPanSignalFromPointer(signal, "move");
+      result = createPanSignalFromSource(signal, "move");
     }
 
     state.prevX = signal.value.x;
@@ -155,25 +154,25 @@ export function createPanRecognizer(options: PanOptions = {}): PanRecognizer {
     return result;
   }
 
-  function handleEnd(signal: SinglePointerSignal): PanSignal | null {
+  function handleEnd(signal: PanSourceSignal): PanSignal | null {
     if (!state.isActive) return null;
 
     let result: PanSignal | null = null;
 
     if (state.thresholdMet) {
-      result = createPanSignalFromPointer(signal, "end");
+      result = createPanSignalFromSource(signal, "end");
     }
 
     resetPanState(state);
     return result;
   }
 
-  function handleCancel(signal: SinglePointerSignal): PanSignal | null {
+  function handleCancel(signal: PanSourceSignal): PanSignal | null {
     if (!state.isActive) return null;
 
     let result: PanSignal | null = null;
     if (state.thresholdMet) {
-      result = createPanSignalFromPointer(signal, "cancel");
+      result = createPanSignalFromSource(signal, "cancel");
     }
 
     resetPanState(state);
@@ -181,7 +180,7 @@ export function createPanRecognizer(options: PanOptions = {}): PanRecognizer {
   }
 
   return {
-    process(signal: SinglePointerSignal): PanSignal | null {
+    process(signal: PanSourceSignal): PanSignal | null {
       switch (signal.value.phase) {
         case "start":
           return handleStart(signal);
diff --git a/packages/pinch/README.md b/packages/pinch/README.md
index 4e52868..bd018f3 100644
--- a/packages/pinch/README.md
+++ b/packages/pinch/README.md
@@ -82,18 +82,20 @@ multiPointer(element, { maxPointers: 2 })
 ### `createPinchRecognizer(options?)`
 
 Low-level API for imperative usage or custom integrations.
+Accepts any signal that satisfies `PinchSourceSignal` interface.
 
 ```typescript
-import { createPinchRecognizer } from "@cereb/pinch";
+import { createPinchRecognizer, type PinchSourceSignal } from "@cereb/pinch";
 
 const recognizer = createPinchRecognizer({ threshold: 10 });
 
-multiPointerStream.on((signal) => {
+// Works with any source that provides the required properties
+function handleMultiPointerEvent(signal: PinchSourceSignal) {
   const pinchEvent = recognizer.process(signal);
   if (pinchEvent) {
     console.log(pinchEvent.value.distance);
   }
-});
+}
 ```
 
 ## PinchValue
diff --git a/packages/pinch/package.json b/packages/pinch/package.json
index 903c7dd..4a44e7f 100644
--- a/packages/pinch/package.json
+++ b/packages/pinch/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@cereb/pinch",
   "description": "Pinch gesture recognition, designed to work seamlessly with reactive streams and other gesture interactions.",
-  "version": "0.11.3",
+  "version": "0.12.0",
   "license": "MIT",
   "author": "devphilip21 <philip21.dev@gmail.com>",
   "repository": {
diff --git a/packages/pinch/src/geometry.ts b/packages/pinch/src/geometry.ts
index f33d90f..276304d 100644
--- a/packages/pinch/src/geometry.ts
+++ b/packages/pinch/src/geometry.ts
@@ -1,4 +1,4 @@
-import type { PointerInfo } from "cereb";
+import type { PinchSourcePointer } from "./pinch-types.js";
 
 /**
  * Calculate Euclidean distance between two points.
@@ -12,14 +12,17 @@ export function calculateDistance(x1: number, y1: number, x2: number, y2: number
 /**
  * Calculate distance between two pointers.
  */
-export function getPointerDistance(p1: PointerInfo, p2: PointerInfo): number {
+export function getPointerDistance(p1: PinchSourcePointer, p2: PinchSourcePointer): number {
   return calculateDistance(p1.x, p1.y, p2.x, p2.y);
 }
 
 /**
  * Calculate center point between two pointers (client coordinates).
  */
-export function getCenter(p1: PointerInfo, p2: PointerInfo): { centerX: number; centerY: number } {
+export function getCenter(
+  p1: PinchSourcePointer,
+  p2: PinchSourcePointer,
+): { centerX: number; centerY: number } {
   return {
     centerX: (p1.x + p2.x) / 2,
     centerY: (p1.y + p2.y) / 2,
@@ -30,8 +33,8 @@ export function getCenter(p1: PointerInfo, p2: PointerInfo): { centerX: number;
  * Calculate center point between two pointers (page coordinates).
  */
 export function getPageCenter(
-  p1: PointerInfo,
-  p2: PointerInfo,
+  p1: PinchSourcePointer,
+  p2: PinchSourcePointer,
 ): { pageCenterX: number; pageCenterY: number } {
   return {
     pageCenterX: (p1.pageX + p2.pageX) / 2,
diff --git a/packages/pinch/src/index.ts b/packages/pinch/src/index.ts
index 40d0b7b..9bd4a54 100644
--- a/packages/pinch/src/index.ts
+++ b/packages/pinch/src/index.ts
@@ -1,4 +1,11 @@
 export { pinch, pinchRecognizer } from "./pinch.js";
 export type { PinchSignal, PinchValue } from "./pinch-signal.js";
-export type { PinchOptions, PinchPhase } from "./pinch-types.js";
+export type {
+  PinchOptions,
+  PinchPhase,
+  PinchSourcePhase,
+  PinchSourcePointer,
+  PinchSourceSignal,
+  PinchSourceValue,
+} from "./pinch-types.js";
 export { createPinchRecognizer, type PinchRecognizer } from "./recognizer.js";
diff --git a/packages/pinch/src/pinch-types.ts b/packages/pinch/src/pinch-types.ts
index 03bd4db..5f64eae 100644
--- a/packages/pinch/src/pinch-types.ts
+++ b/packages/pinch/src/pinch-types.ts
@@ -1,5 +1,41 @@
 export type PinchPhase = "unknown" | "start" | "change" | "end" | "cancel";
 
+/**
+ * Pointer phase values that PinchRecognizer can process.
+ */
+export type PinchSourcePhase = "start" | "move" | "end" | "cancel";
+
+/**
+ * Pointer info interface that PinchRecognizer requires.
+ * Represents a single pointer in a multi-pointer signal.
+ */
+export interface PinchSourcePointer {
+  readonly id: string;
+  readonly phase: PinchSourcePhase;
+  readonly x: number;
+  readonly y: number;
+  readonly pageX: number;
+  readonly pageY: number;
+}
+
+/**
+ * Value interface that PinchRecognizer requires from input signals.
+ * Any signal whose value satisfies this interface can be processed.
+ */
+export interface PinchSourceValue {
+  readonly pointers: readonly PinchSourcePointer[];
+}
+
+/**
+ * Minimal signal interface that PinchRecognizer requires.
+ * Decoupled from MultiPointerSignal to allow any compatible source.
+ */
+export interface PinchSourceSignal {
+  readonly value: PinchSourceValue;
+  readonly createdAt: number;
+  readonly deviceId: string;
+}
+
 export interface PinchOptions {
   /**
    * Minimum distance change (in pixels) required before pinch gesture is recognized.
diff --git a/packages/pinch/src/pinch.ts b/packages/pinch/src/pinch.ts
index 9c1f830..2e905f1 100644
--- a/packages/pinch/src/pinch.ts
+++ b/packages/pinch/src/pinch.ts
@@ -1,12 +1,14 @@
-import type { MultiPointerSignal, Operator, Stream } from "cereb";
+import type { Operator, Signal, Stream } from "cereb";
 import { createStream, multiPointer } from "cereb";
 import { multiPointerSession } from "cereb/operators";
 import type { PinchSignal } from "./pinch-signal.js";
-import type { PinchOptions } from "./pinch-types.js";
+import type { PinchOptions, PinchSourceValue } from "./pinch-types.js";
 import { createPinchRecognizer } from "./recognizer.js";
 
 /**
- * Operator that transforms MultiPointer signals into PinchSignal events.
+ * Operator that transforms multi-pointer signals into PinchSignal events.
+ *
+ * Accepts any Signal whose value satisfies PinchSourceValue interface.
  *
  * Use this when composing with other operators or using a custom pointer source.
  *
@@ -15,15 +17,15 @@ import { createPinchRecognizer } from "./recognizer.js";
  * multiPointer(element, { maxPointers: 2 })
  *   .pipe(
  *     multiPointerSession(2),
- *     pinchRecognizer({ threshold: { ratio: 0.05 } }),
+ *     pinchRecognizer({ threshold: 10 }),
  *     zoom({ minScale: 0.5, maxScale: 3.0 }),
  *   )
  *   .on(pinch => console.log(pinch.value.distance, pinch.value.scale));
  * ```
  */
-export function pinchRecognizer(
+export function pinchRecognizer<T extends Signal<string, PinchSourceValue>>(
   options: PinchOptions = {},
-): Operator<MultiPointerSignal, PinchSignal> {
+): Operator<T, PinchSignal> {
   return (source) =>
     createStream((observer) => {
       const recognizer = createPinchRecognizer(options);
diff --git a/packages/pinch/src/recognizer.ts b/packages/pinch/src/recognizer.ts
index 6258c23..2c382a2 100644
--- a/packages/pinch/src/recognizer.ts
+++ b/packages/pinch/src/recognizer.ts
@@ -1,18 +1,25 @@
-import type { MultiPointerSignal, PointerInfo } from "cereb";
 import { getCenter, getPageCenter, getPointerDistance } from "./geometry.js";
 import { createPinchSignal, type PinchSignal } from "./pinch-signal.js";
-import type { PinchOptions, PinchPhase } from "./pinch-types.js";
+import type {
+  PinchOptions,
+  PinchPhase,
+  PinchSourcePointer,
+  PinchSourceSignal,
+} from "./pinch-types.js";
 import { createInitialPinchState, type PinchState, resetPinchState } from "./state.js";
 
 const DEFAULT_THRESHOLD = 0;
 const MIN_INITIAL_DISTANCE = 1;
 
 /**
- * Stateful processor that transforms MultiPointer signals into PinchSignal.
+ * Stateful processor that transforms multi-pointer signals into PinchSignal.
  * Can be used imperatively or integrated into custom pipelines.
+ *
+ * Accepts any signal that satisfies PinchSourceSignal interface,
+ * allowing integration with various input sources beyond MultiPointer.
  */
 export interface PinchRecognizer {
-  process(signal: MultiPointerSignal): PinchSignal | null;
+  process(signal: PinchSourceSignal): PinchSignal | null;
   readonly isActive: boolean;
   readonly thresholdMet: boolean;
   reset(): void;
@@ -29,10 +36,10 @@ function isThresholdMet(
 }
 
 function findTrackedPointers(
-  pointers: readonly PointerInfo[],
+  pointers: readonly PinchSourcePointer[],
   id1: string,
   id2: string,
-): [PointerInfo, PointerInfo] | null {
+): [PinchSourcePointer, PinchSourcePointer] | null {
   const p1 = pointers.find((p) => p.id === id1);
   const p2 = pointers.find((p) => p.id === id2);
   if (!p1 || !p2) return null;
@@ -40,7 +47,7 @@ function findTrackedPointers(
 }
 
 function hasTrackedPointerEnded(
-  pointers: readonly PointerInfo[],
+  pointers: readonly PinchSourcePointer[],
   id1: string,
   id2: string,
 ): { ended: boolean; cancelled: boolean } {
@@ -71,18 +78,18 @@ function calculateVelocity(
 }
 
 /**
- * Creates a pinch gesture recognizer that processes MultiPointer signals.
+ * Creates a pinch gesture recognizer that processes multi-pointer signals.
  *
  * The recognizer maintains internal state and can be used:
  * - Imperatively via process() method
- * - With any event source (not just Observable streams)
+ * - With any event source that satisfies PinchSourceSignal interface
  * - In Web Workers or other non-DOM contexts
  *
  * @example
  * ```typescript
  * const recognizer = createPinchRecognizer({ threshold: 10 });
  *
- * multiPointerStream.subscribe((signal) => {
+ * multiPointerStream.on((signal) => {
  *   const pinchEvent = recognizer.process(signal);
  *   if (pinchEvent) {
  *     console.log(pinchEvent.value.distance, pinchEvent.value.velocity);
@@ -96,8 +103,8 @@ export function createPinchRecognizer(options: PinchOptions = {}): PinchRecogniz
   const state: PinchState = createInitialPinchState();
 
   function createPinchSignalFromPointers(
-    p1: PointerInfo,
-    p2: PointerInfo,
+    p1: PinchSourcePointer,
+    p2: PinchSourcePointer,
     phase: PinchPhase,
     timestamp: number,
   ): PinchSignal {
@@ -129,7 +136,11 @@ export function createPinchRecognizer(options: PinchOptions = {}): PinchRecogniz
     });
   }
 
-  function handleSessionStart(signal: MultiPointerSignal, p1: PointerInfo, p2: PointerInfo): null {
+  function handleSessionStart(
+    signal: PinchSourceSignal,
+    p1: PinchSourcePointer,
+    p2: PinchSourcePointer,
+  ): null {
     const distance = getPointerDistance(p1, p2);
     const initialDistance = Math.max(distance, MIN_INITIAL_DISTANCE);
 
@@ -147,9 +158,9 @@ export function createPinchRecognizer(options: PinchOptions = {}): PinchRecogniz
   }
 
   function handleMove(
-    signal: MultiPointerSignal,
-    p1: PointerInfo,
-    p2: PointerInfo,
+    signal: PinchSourceSignal,
+    p1: PinchSourcePointer,
+    p2: PinchSourcePointer,
   ): PinchSignal | null {
     if (!state.isActive) return null;
 
@@ -167,9 +178,9 @@ export function createPinchRecognizer(options: PinchOptions = {}): PinchRecogniz
   }
 
   function handleEnd(
-    signal: MultiPointerSignal,
-    p1: PointerInfo,
-    p2: PointerInfo,
+    signal: PinchSourceSignal,
+    p1: PinchSourcePointer,
+    p2: PinchSourcePointer,
     isCancelled: boolean,
   ): PinchSignal | null {
     if (!state.isActive) return null;
@@ -189,7 +200,7 @@ export function createPinchRecognizer(options: PinchOptions = {}): PinchRecogniz
   }
 
   return {
-    process(signal: MultiPointerSignal): PinchSignal | null {
+    process(signal: PinchSourceSignal): PinchSignal | null {
       const pointers = signal.value.pointers;
 
       const workingPointers = pointers.filter((p) => p.phase === "start" || p.phase === "move");
diff --git a/packages/tap/.npmignore b/packages/tap/.npmignore
new file mode 100644
index 0000000..ac245eb
--- /dev/null
+++ b/packages/tap/.npmignore
@@ -0,0 +1,2 @@
+# Source maps (not needed for consumers)
+**/*.map
diff --git a/packages/tap/LICENSE b/packages/tap/LICENSE
new file mode 100644
index 0000000..6a380ae
--- /dev/null
+++ b/packages/tap/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 devphilip21
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/packages/tap/README.md b/packages/tap/README.md
new file mode 100644
index 0000000..1c586d4
--- /dev/null
+++ b/packages/tap/README.md
@@ -0,0 +1,139 @@
+# [@cereb/tap](https://cereb.dev/stream-api/tap)
+
+Tap gesture recognition with multi-tap support. Works seamlessly with [cereb](https://www.npmjs.com/package/cereb) reactive streams.
+
+## Installation
+
+```bash
+npm install --save cereb @cereb/tap
+```
+
+## Quick Start
+
+```typescript
+import { tap } from "@cereb/tap";
+
+tap(element).on((signal) => {
+  const { tapCount, x, y } = signal.value;
+
+  if (tapCount === 2) {
+    console.log(`Double tap at (${x}, ${y})`);
+  }
+});
+```
+
+## With Visual Feedback
+
+Use the `tapRecognizer` operator to handle tap lifecycle for visual feedback:
+
+```typescript
+import { singlePointer } from "cereb";
+import { tapRecognizer } from "@cereb/tap";
+
+singlePointer(element)
+  .pipe(tapRecognizer({ durationThreshold: 300 }))
+  .on((signal) => {
+    const { phase } = signal.value;
+
+    if (phase === "start") {
+      element.classList.add("pressed");
+    } else {
+      element.classList.remove("pressed");
+    }
+  });
+```
+
+## Documentation
+
+For detailed documentation, examples, and guides, visit [cereb.dev/stream-api/tap](https://cereb.dev/stream-api/tap).
+
+## API
+
+### `tap(target, options?)`
+
+Creates a tap gesture stream from an element. Only emits successful tap events (phase === "end").
+
+```typescript
+import { tap } from "@cereb/tap";
+
+const stream = tap(element, { durationThreshold: 300, chainIntervalThreshold: 250 });
+```
+
+**Options:**
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `movementThreshold` | `number` | `10` | Max movement (px) allowed during tap |
+| `durationThreshold` | `number` | `500` | Max duration (ms) for a valid tap |
+| `chainMovementThreshold` | `number` | `movementThreshold` | Max distance between consecutive taps |
+| `chainIntervalThreshold` | `number` | `durationThreshold / 2` | Max interval (ms) between consecutive taps |
+
+### `tapRecognizer(options?)`
+
+Operator that transforms single-pointer signals into tap events with full lifecycle (start, end, cancel). Use this when you need visual feedback or composition with other operators.
+
+```typescript
+import { singlePointer } from "cereb";
+import { tapRecognizer } from "@cereb/tap";
+
+singlePointer(element)
+  .pipe(tapRecognizer({ movementThreshold: 15 }))
+  .on((signal) => {
+    // ...
+  });
+```
+
+### `tapEndOnly(options?)`
+
+Operator that only emits successful tap events (phase === "end"). Filters out start and cancel phases.
+
+```typescript
+import { singlePointer } from "cereb";
+import { tapEndOnly } from "@cereb/tap";
+
+singlePointer(element)
+  .pipe(tapEndOnly())
+  .on((signal) => {
+    console.log(`Tap count: ${signal.value.tapCount}`);
+  });
+```
+
+### `createTapRecognizer(options?)`
+
+Low-level API for imperative usage or custom integrations.
+Accepts any signal that satisfies `TapSourceSignal` interface.
+
+```typescript
+import { createTapRecognizer, type TapSourceSignal } from "@cereb/tap";
+
+const recognizer = createTapRecognizer({ durationThreshold: 300 });
+
+// Works with any source that provides the required properties
+function handlePointerEvent(signal: TapSourceSignal) {
+  const tapEvent = recognizer.process(signal);
+  if (tapEvent?.value.phase === "end") {
+    console.log(`Tap ${tapEvent.value.tapCount}!`);
+  }
+}
+```
+
+## TapValue
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `phase` | `"start" \| "end" \| "cancel"` | Current gesture phase |
+| `x` | `number` | Tap X position (client) |
+| `y` | `number` | Tap Y position (client) |
+| `pageX` | `number` | Tap X position (page) |
+| `pageY` | `number` | Tap Y position (page) |
+| `tapCount` | `number` | Consecutive tap count (1=single, 2=double, etc.) |
+| `duration` | `number` | How long the pointer was pressed (ms) |
+| `pointerType` | `"mouse" \| "touch" \| "pen" \| "unknown"` | Type of pointer |
+
+## Contributing
+
+Contributions are welcome! Please read our [Contributing Guide](https://github.com/devphilip21/cereb/blob/main/CONTRIBUTING.md).
+
+## License
+
+MIT
diff --git a/packages/tap/package.json b/packages/tap/package.json
new file mode 100644
index 0000000..84efb8a
--- /dev/null
+++ b/packages/tap/package.json
@@ -0,0 +1,61 @@
+{
+  "name": "@cereb/tap",
+  "description": "Tap gesture recognition with multi-tap support, designed for reactive streams.",
+  "version": "0.1.0",
+  "license": "MIT",
+  "author": "devphilip21 <philip21.dev@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/devphilip21/cereb.git",
+    "directory": "packages/tap"
+  },
+  "homepage": "https://cereb.dev/stream-api/tap",
+  "bugs": {
+    "url": "https://github.com/devphilip21/cereb/issues"
+  },
+  "keywords": [
+    "tap",
+    "click",
+    "gesture",
+    "touch",
+    "pointer",
+    "double-tap",
+    "cereb"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "builder build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "dependencies": {
+    "cereb": "workspace:^"
+  },
+  "peerDependencies": {
+    "cereb": "workspace:^"
+  },
+  "devDependencies": {
+    "@cereb/builder": "workspace:^",
+    "@vitest/coverage-v8": "*",
+    "jsdom": "*",
+    "vite": "*",
+    "vitest": "*"
+  }
+}
diff --git a/packages/tap/src/geometry.spec.ts b/packages/tap/src/geometry.spec.ts
new file mode 100644
index 0000000..b7dfb4e
--- /dev/null
+++ b/packages/tap/src/geometry.spec.ts
@@ -0,0 +1,28 @@
+import { describe, expect, it } from "vitest";
+import { calculateDistance } from "./geometry.js";
+
+describe("calculateDistance", () => {
+  it("should calculate horizontal distance", () => {
+    const distance = calculateDistance(0, 0, 100, 0);
+
+    expect(distance).toBe(100);
+  });
+
+  it("should calculate vertical distance", () => {
+    const distance = calculateDistance(0, 0, 0, 100);
+
+    expect(distance).toBe(100);
+  });
+
+  it("should calculate diagonal distance using Pythagorean theorem", () => {
+    const distance = calculateDistance(0, 0, 3, 4);
+
+    expect(distance).toBe(5);
+  });
+
+  it("should return zero for same points", () => {
+    const distance = calculateDistance(50, 50, 50, 50);
+
+    expect(distance).toBe(0);
+  });
+});
diff --git a/packages/tap/src/geometry.ts b/packages/tap/src/geometry.ts
new file mode 100644
index 0000000..cf9f7c6
--- /dev/null
+++ b/packages/tap/src/geometry.ts
@@ -0,0 +1,8 @@
+/**
+ * Calculate Euclidean distance between two points.
+ */
+export function calculateDistance(x1: number, y1: number, x2: number, y2: number): number {
+  const dx = x2 - x1;
+  const dy = y2 - y1;
+  return Math.sqrt(dx * dx + dy * dy);
+}
diff --git a/packages/tap/src/index.ts b/packages/tap/src/index.ts
new file mode 100644
index 0000000..5a76523
--- /dev/null
+++ b/packages/tap/src/index.ts
@@ -0,0 +1,11 @@
+export { createTapRecognizer, type TapRecognizer } from "./recognizer.js";
+export { tap, tapEndOnly, tapRecognizer } from "./tap.js";
+export type { TapSignal, TapValue } from "./tap-signal.js";
+export type {
+  TapOptions,
+  TapPhase,
+  TapSourcePhase,
+  TapSourcePointerType,
+  TapSourceSignal,
+  TapSourceValue,
+} from "./tap-types.js";
diff --git a/packages/tap/src/recognizer.spec.ts b/packages/tap/src/recognizer.spec.ts
new file mode 100644
index 0000000..79b7441
--- /dev/null
+++ b/packages/tap/src/recognizer.spec.ts
@@ -0,0 +1,196 @@
+import type { SinglePointerSignal } from "cereb";
+import { describe, expect, it } from "vitest";
+import { createTapRecognizer } from "./recognizer.js";
+
+function createMockPointerSignal(
+  phase: "start" | "move" | "end" | "cancel",
+  x: number,
+  y: number,
+  createdAt: number,
+): SinglePointerSignal {
+  return {
+    kind: "single-pointer",
+    value: {
+      phase,
+      x,
+      y,
+      pageX: x,
+      pageY: y,
+      pointerType: "mouse",
+      button: "primary",
+      pressure: 0.5,
+      id: "1",
+    },
+    deviceId: "test-device",
+    createdAt,
+  };
+}
+
+describe("createTapRecognizer", () => {
+  describe("single tap recognition", () => {
+    it("should emit start phase on pointer start", () => {
+      const recognizer = createTapRecognizer();
+
+      const result = recognizer.process(createMockPointerSignal("start", 100, 100, 0));
+
+      expect(result).not.toBeNull();
+      expect(result?.value.phase).toBe("start");
+      expect(result?.value.tapCount).toBe(1);
+      expect(result?.value.x).toBe(100);
+      expect(result?.value.y).toBe(100);
+    });
+
+    it("should emit end phase on pointer end within thresholds", () => {
+      const recognizer = createTapRecognizer();
+
+      recognizer.process(createMockPointerSignal("start", 100, 100, 0));
+      const result = recognizer.process(createMockPointerSignal("end", 100, 100, 100));
+
+      expect(result).not.toBeNull();
+      expect(result?.value.phase).toBe("end");
+      expect(result?.value.tapCount).toBe(1);
+      expect(result?.value.duration).toBe(100);
+    });
+
+    it("should not emit on move within threshold", () => {
+      const recognizer = createTapRecognizer({ movementThreshold: 10 });
+
+      recognizer.process(createMockPointerSignal("start", 100, 100, 0));
+      const result = recognizer.process(createMockPointerSignal("move", 105, 105, 50));
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("tap cancellation", () => {
+    it("should cancel on movement exceeding threshold", () => {
+      const recognizer = createTapRecognizer({ movementThreshold: 10 });
+
+      recognizer.process(createMockPointerSignal("start", 100, 100, 0));
+      const result = recognizer.process(createMockPointerSignal("move", 120, 100, 50));
+
+      expect(result).not.toBeNull();
+      expect(result?.value.phase).toBe("cancel");
+      expect(result?.value.tapCount).toBe(0);
+    });
+
+    it("should cancel on duration exceeding threshold", () => {
+      const recognizer = createTapRecognizer({ durationThreshold: 500 });
+
+      recognizer.process(createMockPointerSignal("start", 100, 100, 0));
+      const result = recognizer.process(createMockPointerSignal("move", 100, 100, 600));
+
+      expect(result).not.toBeNull();
+      expect(result?.value.phase).toBe("cancel");
+    });
+
+    it("should cancel on pointer cancel event", () => {
+      const recognizer = createTapRecognizer();
+
+      recognizer.process(createMockPointerSignal("start", 100, 100, 0));
+      const result = recognizer.process(createMockPointerSignal("cancel", 100, 100, 50));
+
+      expect(result).not.toBeNull();
+      expect(result?.value.phase).toBe("cancel");
+    });
+
+    it("should not emit end after cancellation", () => {
+      const recognizer = createTapRecognizer({ movementThreshold: 10 });
+
+      recognizer.process(createMockPointerSignal("start", 100, 100, 0));
+      recognizer.process(createMockPointerSignal("move", 120, 100, 50));
+      const result = recognizer.process(createMockPointerSignal("end", 120, 100, 100));
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("double tap detection", () => {
+    it("should increment tapCount for consecutive taps within interval", () => {
+      const recognizer = createTapRecognizer({
+        chainIntervalThreshold: 300,
+        chainMovementThreshold: 25,
+      });
+
+      recognizer.process(createMockPointerSignal("start", 100, 100, 0));
+      recognizer.process(createMockPointerSignal("end", 100, 100, 100));
+
+      const startResult = recognizer.process(createMockPointerSignal("start", 105, 105, 200));
+      const endResult = recognizer.process(createMockPointerSignal("end", 105, 105, 250));
+
+      expect(startResult?.value.tapCount).toBe(2);
+      expect(endResult?.value.tapCount).toBe(2);
+    });
+
+    it("should reset tapCount when interval exceeded", () => {
+      const recognizer = createTapRecognizer({ chainIntervalThreshold: 300 });
+
+      recognizer.process(createMockPointerSignal("start", 100, 100, 0));
+      recognizer.process(createMockPointerSignal("end", 100, 100, 100));
+
+      const startResult = recognizer.process(createMockPointerSignal("start", 100, 100, 500));
+
+      expect(startResult?.value.tapCount).toBe(1);
+    });
+
+    it("should reset tapCount when distance exceeded", () => {
+      const recognizer = createTapRecognizer({
+        chainIntervalThreshold: 300,
+        chainMovementThreshold: 25,
+      });
+
+      recognizer.process(createMockPointerSignal("start", 100, 100, 0));
+      recognizer.process(createMockPointerSignal("end", 100, 100, 100));
+
+      const startResult = recognizer.process(createMockPointerSignal("start", 150, 150, 200));
+
+      expect(startResult?.value.tapCount).toBe(1);
+    });
+  });
+
+  describe("triple tap and beyond", () => {
+    it("should support triple tap", () => {
+      const recognizer = createTapRecognizer({
+        chainIntervalThreshold: 300,
+        chainMovementThreshold: 25,
+      });
+
+      recognizer.process(createMockPointerSignal("start", 100, 100, 0));
+      recognizer.process(createMockPointerSignal("end", 100, 100, 50));
+
+      recognizer.process(createMockPointerSignal("start", 100, 100, 150));
+      recognizer.process(createMockPointerSignal("end", 100, 100, 200));
+
+      const thirdStart = recognizer.process(createMockPointerSignal("start", 100, 100, 300));
+      const thirdEnd = recognizer.process(createMockPointerSignal("end", 100, 100, 350));
+
+      expect(thirdStart?.value.tapCount).toBe(3);
+      expect(thirdEnd?.value.tapCount).toBe(3);
+    });
+  });
+
+  describe("reset and dispose", () => {
+    it("should reset state", () => {
+      const recognizer = createTapRecognizer();
+
+      recognizer.process(createMockPointerSignal("start", 100, 100, 0));
+      expect(recognizer.isActive).toBe(true);
+
+      recognizer.reset();
+      expect(recognizer.isActive).toBe(false);
+    });
+
+    it("should reset multi-tap tracking on reset", () => {
+      const recognizer = createTapRecognizer({ chainIntervalThreshold: 300 });
+
+      recognizer.process(createMockPointerSignal("start", 100, 100, 0));
+      recognizer.process(createMockPointerSignal("end", 100, 100, 50));
+
+      recognizer.reset();
+
+      const result = recognizer.process(createMockPointerSignal("start", 100, 100, 100));
+
+      expect(result?.value.tapCount).toBe(1);
+    });
+  });
+});
diff --git a/packages/tap/src/recognizer.ts b/packages/tap/src/recognizer.ts
new file mode 100644
index 0000000..74be811
--- /dev/null
+++ b/packages/tap/src/recognizer.ts
@@ -0,0 +1,210 @@
+import { calculateDistance } from "./geometry.js";
+import { createInitialTapState, resetCurrentTap, resetTapState, type TapState } from "./state.js";
+import { createTapSignal, type TapSignal } from "./tap-signal.js";
+import type { TapOptions, TapPhase, TapSourceSignal } from "./tap-types.js";
+
+const DEFAULT_MOVEMENT_THRESHOLD = 10;
+const DEFAULT_DURATION_THRESHOLD = 500;
+
+/**
+ * Stateful processor that transforms pointer events into TapSignal.
+ * Supports multi-tap detection (double-tap, triple-tap, etc.)
+ *
+ * Accepts any signal that satisfies TapSourceSignal interface,
+ * allowing integration with various input sources beyond SinglePointer.
+ */
+export interface TapRecognizer {
+  process(signal: TapSourceSignal): TapSignal | null;
+  readonly isActive: boolean;
+  reset(): void;
+  dispose(): void;
+}
+
+/**
+ * Creates a tap gesture recognizer that processes pointer events.
+ *
+ * The recognizer maintains internal state and can be used:
+ * - Imperatively via process() method
+ * - With any event source that satisfies TapSourceSignal interface
+ *
+ * @example
+ * ```typescript
+ * const recognizer = createTapRecognizer({ durationThreshold: 300 });
+ *
+ * pointerStream.on((signal) => {
+ *   const tapEvent = recognizer.process(signal);
+ *   if (tapEvent?.value.phase === "end") {
+ *     console.log(`Tap ${tapEvent.value.tapCount}!`);
+ *   }
+ * });
+ * ```
+ */
+export function createTapRecognizer(options: TapOptions = {}): TapRecognizer {
+  const {
+    movementThreshold = DEFAULT_MOVEMENT_THRESHOLD,
+    durationThreshold = DEFAULT_DURATION_THRESHOLD,
+  } = options;
+
+  const chainMovementThreshold = options.chainMovementThreshold ?? movementThreshold;
+  const chainIntervalThreshold = options.chainIntervalThreshold ?? durationThreshold / 2;
+
+  const state: TapState = createInitialTapState();
+
+  function createTapSignalFromState(
+    signal: TapSourceSignal,
+    phase: TapPhase,
+    tapCount: number,
+  ): TapSignal {
+    const duration = signal.createdAt - state.startTimestamp;
+
+    return createTapSignal({
+      phase,
+      x: state.startX,
+      y: state.startY,
+      pageX: state.startPageX,
+      pageY: state.startPageY,
+      tapCount,
+      duration: Math.max(0, duration),
+      pointerType: signal.value.pointerType,
+    });
+  }
+
+  function shouldIncrementTapCount(
+    currentX: number,
+    currentY: number,
+    currentTimestamp: number,
+  ): boolean {
+    if (state.lastTapEndTimestamp === 0) {
+      return false;
+    }
+
+    const timeSinceLastTap = currentTimestamp - state.lastTapEndTimestamp;
+    if (timeSinceLastTap > chainIntervalThreshold) {
+      return false;
+    }
+
+    const distance = calculateDistance(state.lastTapX, state.lastTapY, currentX, currentY);
+    if (distance > chainMovementThreshold) {
+      return false;
+    }
+
+    return true;
+  }
+
+  function handleStart(signal: TapSourceSignal): TapSignal {
+    const { x, y, pageX, pageY, pointerType } = signal.value;
+
+    const continuesMultiTap = shouldIncrementTapCount(x, y, signal.createdAt);
+
+    state.isActive = true;
+    state.startX = x;
+    state.startY = y;
+    state.startPageX = pageX;
+    state.startPageY = pageY;
+    state.startTimestamp = signal.createdAt;
+    state.deviceId = signal.deviceId;
+    state.pointerType = pointerType;
+    state.isCancelled = false;
+
+    if (continuesMultiTap) {
+      state.currentTapCount += 1;
+    } else {
+      state.currentTapCount = 1;
+    }
+
+    return createTapSignalFromState(signal, "start", state.currentTapCount);
+  }
+
+  function handleMove(signal: TapSourceSignal): TapSignal | null {
+    if (!state.isActive || state.isCancelled) return null;
+
+    const { x, y } = signal.value;
+
+    const movement = calculateDistance(state.startX, state.startY, x, y);
+    if (movement > movementThreshold) {
+      state.isCancelled = true;
+      state.lastTapEndTimestamp = 0;
+      state.currentTapCount = 0;
+      return createTapSignalFromState(signal, "cancel", 0);
+    }
+
+    const duration = signal.createdAt - state.startTimestamp;
+    if (duration > durationThreshold) {
+      state.isCancelled = true;
+      state.lastTapEndTimestamp = 0;
+      state.currentTapCount = 0;
+      return createTapSignalFromState(signal, "cancel", 0);
+    }
+
+    return null;
+  }
+
+  function handleEnd(signal: TapSourceSignal): TapSignal | null {
+    if (!state.isActive) return null;
+
+    if (state.isCancelled) {
+      resetCurrentTap(state);
+      return null;
+    }
+
+    const duration = signal.createdAt - state.startTimestamp;
+    if (duration > durationThreshold) {
+      state.lastTapEndTimestamp = 0;
+      state.currentTapCount = 0;
+      const result = createTapSignalFromState(signal, "cancel", 0);
+      resetCurrentTap(state);
+      return result;
+    }
+
+    const tapCount = state.currentTapCount;
+    state.lastTapEndTimestamp = signal.createdAt;
+    state.lastTapX = state.startX;
+    state.lastTapY = state.startY;
+
+    const result = createTapSignalFromState(signal, "end", tapCount);
+    resetCurrentTap(state);
+
+    return result;
+  }
+
+  function handleCancel(signal: TapSourceSignal): TapSignal | null {
+    if (!state.isActive) return null;
+
+    state.lastTapEndTimestamp = 0;
+    state.currentTapCount = 0;
+
+    const result = state.isCancelled ? null : createTapSignalFromState(signal, "cancel", 0);
+
+    resetCurrentTap(state);
+    return result;
+  }
+
+  return {
+    process(signal: TapSourceSignal): TapSignal | null {
+      switch (signal.value.phase) {
+        case "start":
+          return handleStart(signal);
+        case "move":
+          return handleMove(signal);
+        case "end":
+          return handleEnd(signal);
+        case "cancel":
+          return handleCancel(signal);
+        default:
+          return null;
+      }
+    },
+
+    get isActive(): boolean {
+      return state.isActive;
+    },
+
+    reset(): void {
+      resetTapState(state);
+    },
+
+    dispose(): void {
+      resetTapState(state);
+    },
+  };
+}
diff --git a/packages/tap/src/state.spec.ts b/packages/tap/src/state.spec.ts
new file mode 100644
index 0000000..74f7297
--- /dev/null
+++ b/packages/tap/src/state.spec.ts
@@ -0,0 +1,74 @@
+import { describe, expect, it } from "vitest";
+import { createInitialTapState, resetCurrentTap, resetTapState } from "./state.js";
+
+describe("createInitialTapState", () => {
+  it("should create state with initial values", () => {
+    const state = createInitialTapState();
+
+    expect(state.isActive).toBe(false);
+    expect(state.startX).toBe(0);
+    expect(state.startY).toBe(0);
+    expect(state.startPageX).toBe(0);
+    expect(state.startPageY).toBe(0);
+    expect(state.startTimestamp).toBe(0);
+    expect(state.deviceId).toBe("");
+    expect(state.pointerType).toBe("unknown");
+    expect(state.lastTapEndTimestamp).toBe(0);
+    expect(state.lastTapX).toBe(0);
+    expect(state.lastTapY).toBe(0);
+    expect(state.currentTapCount).toBe(0);
+    expect(state.isCancelled).toBe(false);
+  });
+});
+
+describe("resetCurrentTap", () => {
+  it("should reset current tap fields but preserve multi-tap tracking", () => {
+    const state = createInitialTapState();
+    state.isActive = true;
+    state.startX = 100;
+    state.startY = 200;
+    state.startTimestamp = 1000;
+    state.deviceId = "mouse-1";
+    state.isCancelled = true;
+    state.lastTapEndTimestamp = 500;
+    state.lastTapX = 50;
+    state.lastTapY = 60;
+    state.currentTapCount = 2;
+
+    resetCurrentTap(state);
+
+    expect(state.isActive).toBe(false);
+    expect(state.startX).toBe(0);
+    expect(state.startY).toBe(0);
+    expect(state.isCancelled).toBe(false);
+    expect(state.lastTapEndTimestamp).toBe(500);
+    expect(state.lastTapX).toBe(50);
+    expect(state.lastTapY).toBe(60);
+    expect(state.currentTapCount).toBe(2);
+  });
+});
+
+describe("resetTapState", () => {
+  it("should reset all fields to initial values", () => {
+    const state = createInitialTapState();
+    state.isActive = true;
+    state.startX = 100;
+    state.startY = 200;
+    state.startTimestamp = 1000;
+    state.deviceId = "mouse-1";
+    state.lastTapEndTimestamp = 500;
+    state.lastTapX = 50;
+    state.lastTapY = 60;
+    state.currentTapCount = 2;
+
+    resetTapState(state);
+
+    expect(state.isActive).toBe(false);
+    expect(state.startX).toBe(0);
+    expect(state.startY).toBe(0);
+    expect(state.lastTapEndTimestamp).toBe(0);
+    expect(state.lastTapX).toBe(0);
+    expect(state.lastTapY).toBe(0);
+    expect(state.currentTapCount).toBe(0);
+  });
+});
diff --git a/packages/tap/src/state.ts b/packages/tap/src/state.ts
new file mode 100644
index 0000000..93a63eb
--- /dev/null
+++ b/packages/tap/src/state.ts
@@ -0,0 +1,71 @@
+/**
+ * Internal state for tap gesture tracking.
+ * Tracks both current tap attempt and history for multi-tap detection.
+ */
+export interface TapState {
+  /** Whether a tap attempt is currently in progress */
+  isActive: boolean;
+
+  /** Start position X */
+  startX: number;
+  /** Start position Y */
+  startY: number;
+  /** Page coordinates at start */
+  startPageX: number;
+  startPageY: number;
+  /** Timestamp when tap started */
+  startTimestamp: number;
+  /** Device identifier */
+  deviceId: string;
+  /** Pointer type (touch, mouse, pen) */
+  pointerType: string;
+
+  /** Timestamp of last successful tap end */
+  lastTapEndTimestamp: number;
+  /** Position of last successful tap */
+  lastTapX: number;
+  lastTapY: number;
+  /** Current consecutive tap count */
+  currentTapCount: number;
+
+  /** Whether current tap attempt has been cancelled due to movement/duration */
+  isCancelled: boolean;
+}
+
+export function createInitialTapState(): TapState {
+  return {
+    isActive: false,
+    startX: 0,
+    startY: 0,
+    startPageX: 0,
+    startPageY: 0,
+    startTimestamp: 0,
+    deviceId: "",
+    pointerType: "unknown",
+    lastTapEndTimestamp: 0,
+    lastTapX: 0,
+    lastTapY: 0,
+    currentTapCount: 0,
+    isCancelled: false,
+  };
+}
+
+export function resetCurrentTap(state: TapState): void {
+  state.isActive = false;
+  state.startX = 0;
+  state.startY = 0;
+  state.startPageX = 0;
+  state.startPageY = 0;
+  state.startTimestamp = 0;
+  state.deviceId = "";
+  state.pointerType = "unknown";
+  state.isCancelled = false;
+}
+
+export function resetTapState(state: TapState): void {
+  resetCurrentTap(state);
+  state.lastTapEndTimestamp = 0;
+  state.lastTapX = 0;
+  state.lastTapY = 0;
+  state.currentTapCount = 0;
+}
diff --git a/packages/tap/src/tap-signal.ts b/packages/tap/src/tap-signal.ts
new file mode 100644
index 0000000..a90e487
--- /dev/null
+++ b/packages/tap/src/tap-signal.ts
@@ -0,0 +1,58 @@
+import type { Signal } from "cereb";
+import { createSignal } from "cereb";
+import type { TapPhase, TapSourcePointerType } from "./tap-types.js";
+
+/**
+ * Tap gesture value emitted during tap lifecycle (start, end, cancel).
+ * Contains position, timing, and consecutive tap count information.
+ */
+export interface TapValue {
+  phase: TapPhase;
+
+  /** Tap position X (client coordinates) */
+  x: number;
+  /** Tap position Y (client coordinates) */
+  y: number;
+
+  /** Tap position X (page coordinates) */
+  pageX: number;
+  /** Tap position Y (page coordinates) */
+  pageY: number;
+
+  /**
+   * Number of consecutive taps (1=single, 2=double, 3=triple, etc.)
+   * Increments if taps occur within multiTapInterval and multiTapDistance.
+   */
+  tapCount: number;
+
+  /** How long the pointer was pressed (ms) */
+  duration: number;
+
+  /** Type of pointer that performed the tap */
+  pointerType: TapSourcePointerType;
+}
+
+export interface TapSignal<T = {}> extends Signal<"tap", TapValue & T> {}
+
+export const TAP_SIGNAL_KIND = "tap" as const;
+
+export function createDefaultTapValue(): TapValue {
+  return {
+    phase: "end",
+    x: 0,
+    y: 0,
+    pageX: 0,
+    pageY: 0,
+    tapCount: 1,
+    duration: 0,
+    pointerType: "unknown",
+  };
+}
+
+export function createDefaultTapSignal(): TapSignal {
+  return createSignal(TAP_SIGNAL_KIND, createDefaultTapValue());
+}
+
+export function createTapSignal(value: TapValue): TapSignal {
+  return createSignal(TAP_SIGNAL_KIND, value);
+}
diff --git a/packages/tap/src/tap-types.ts b/packages/tap/src/tap-types.ts
new file mode 100644
index 0000000..9716a1e
--- /dev/null
+++ b/packages/tap/src/tap-types.ts
@@ -0,0 +1,49 @@
+export type TapPhase = "start" | "end" | "cancel";
+
+/**
+ * Pointer phase values that TapRecognizer can process.
+ * Maps to gesture lifecycle: press → drag → release/cancel.
+ */
+export type TapSourcePhase = "start" | "move" | "end" | "cancel";
+
+/**
+ * Pointer type indicating the input device.
+ */
+export type TapSourcePointerType = "touch" | "mouse" | "pen" | "unknown";
+
+/**
+ * Value interface that TapRecognizer requires from input signals.
+ * Any signal whose value satisfies this interface can be processed.
+ */
+export interface TapSourceValue {
+  readonly phase: TapSourcePhase;
+  readonly x: number;
+  readonly y: number;
+  readonly pageX: number;
+  readonly pageY: number;
+  readonly pointerType: TapSourcePointerType;
+}
+
+/**
+ * Minimal signal interface that TapRecognizer requires.
+ * Decoupled from SinglePointerSignal to allow any compatible source.
+ */
+export interface TapSourceSignal {
+  readonly value: TapSourceValue;
+  readonly createdAt: number;
+  readonly deviceId: string;
+}
+
+export interface TapOptions {
+  /** Max movement allowed during tap (default: 10px) */
+  movementThreshold?: number;
+
+  /** Max duration for a valid tap (default: 500ms) */
+  durationThreshold?: number;
+
+  /** Max distance between consecutive taps (default: movementThreshold) */
+  chainMovementThreshold?: number;
+
+  /** Max interval between consecutive taps (default: durationThreshold / 2) */
+  chainIntervalThreshold?: number;
+}
diff --git a/packages/tap/src/tap.ts b/packages/tap/src/tap.ts
new file mode 100644
index 0000000..b5cb640
--- /dev/null
+++ b/packages/tap/src/tap.ts
@@ -0,0 +1,118 @@
+import type { Operator, Signal, Stream } from "cereb";
+import { createStream, singlePointer } from "cereb";
+import { createTapRecognizer } from "./recognizer.js";
+import type { TapSignal } from "./tap-signal.js";
+import type { TapOptions, TapSourceValue } from "./tap-types.js";
+
+/**
+ * Operator that transforms pointer events into TapSignal events.
+ * Emits "start", "end", and "cancel" phases for full tap lifecycle visibility.
+ *
+ * Accepts any Signal whose value satisfies TapSourceValue interface.
+ *
+ * Use this when you need to:
+ * - Show visual feedback on tap start
+ * - Handle tap cancellation
+ * - Compose with other operators
+ *
+ * @example
+ * ```typescript
+ * singlePointer(element)
+ *   .pipe(tapRecognizer({ maxDuration: 300 }))
+ *   .on((signal) => {
+ *     if (signal.value.phase === "start") {
+ *       element.classList.add("pressed");
+ *     } else {
+ *       element.classList.remove("pressed");
+ *     }
+ *   });
+ * ```
+ */
+export function tapRecognizer<T extends Signal<string, TapSourceValue>>(
+  options: TapOptions = {},
+): Operator<T, TapSignal> {
+  return (source) =>
+    createStream((observer) => {
+      const recognizer = createTapRecognizer(options);
+
+      const unsub = source.on({
+        next(pointer) {
+          const event = recognizer.process(pointer);
+          if (event) {
+            observer.next(event);
+          }
+        },
+        error: observer.error?.bind(observer),
+        complete() {
+          observer.complete?.();
+        },
+      });
+
+      return () => {
+        recognizer.dispose();
+        unsub();
+      };
+    });
+}
+
+/**
+ * Operator that only emits successful tap events (phase === "end").
+ * Filters out "start" and "cancel" phases for simpler tap handling.
+ *
+ * Accepts any Signal whose value satisfies TapSourceValue interface.
+ *
+ * @example
+ * ```typescript
+ * singlePointer(element)
+ *   .pipe(tapEndOnly({ multiTapInterval: 300 }))
+ *   .on((signal) => {
+ *     if (signal.value.tapCount === 2) {
+ *       console.log("Double tap detected!");
+ *     }
+ *   });
+ * ```
+ */
+export function tapEndOnly<T extends Signal<string, TapSourceValue>>(
+  options: TapOptions = {},
+): Operator<T, TapSignal> {
+  return (source) =>
+    createStream((observer) => {
+      const recognizer = createTapRecognizer(options);
+
+      const unsub = source.on({
+        next(pointer) {
+          const event = recognizer.process(pointer);
+          if (event && event.value.phase === "end") {
+            observer.next(event);
+          }
+        },
+        error: observer.error?.bind(observer),
+        complete() {
+          observer.complete?.();
+        },
+      });
+
+      return () => {
+        recognizer.dispose();
+        unsub();
+      };
+    });
+}
+
+/**
+ * Creates a tap gesture stream from an element.
+ * Only emits successful tap events (phase === "end").
+ *
+ * This is a convenience function that combines singlePointer and tap recognition.
+ *
+ * @example
+ * ```typescript
+ * tap(button, { multiTapInterval: 300 })
+ *   .on((signal) => {
+ *     console.log(`Tap count: ${signal.value.tapCount}`);
+ *   });
+ * ```
+ */
+export function tap(target: EventTarget, options: TapOptions = {}): Stream<TapSignal> {
+  return singlePointer(target).pipe(tapEndOnly(options));
+}
diff --git a/packages/tap/tsconfig.json b/packages/tap/tsconfig.json
new file mode 100644
index 0000000..847ec1e
--- /dev/null
+++ b/packages/tap/tsconfig.json
@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022", "DOM"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "noEmit": false,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"],
+  "references": [{ "path": "../cereb" }]
+}
diff --git a/packages/tap/vite.config.ts b/packages/tap/vite.config.ts
new file mode 100644
index 0000000..98e0664
--- /dev/null
+++ b/packages/tap/vite.config.ts
@@ -0,0 +1,20 @@
+import { resolve } from "node:path";
+import type { UserConfig } from "vite";
+
+export default ({ dirname }: { dirname: string }): UserConfig => ({
+  build: {
+    lib: {
+      entry: {
+        index: resolve(dirname, "src/index.ts"),
+      },
+      formats: ["es", "cjs"],
+      fileName: (format, entryName) => {
+        const ext = format === "es" ? "js" : "cjs";
+        return `${entryName}.${ext}`;
+      },
+    },
+    rollupOptions: {
+      external: ["cereb"],
+    },
+  },
+});
diff --git a/packages/tap/vitest.config.ts b/packages/tap/vitest.config.ts
new file mode 100644
index 0000000..2227609
--- /dev/null
+++ b/packages/tap/vitest.config.ts
@@ -0,0 +1,15 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "jsdom",
+    include: ["src/**/*.spec.ts"],
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "html"],
+      include: ["src/**/*.ts"],
+      exclude: ["src/**/*.spec.ts"],
+    },
+  },
+});
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 50d8967..12442bb 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -66,6 +66,9 @@ importers:
       '@cereb/pinch':
         specifier: workspace:^
         version: link:../packages/pinch
+      '@cereb/tap':
+        specifier: workspace:^
+        version: link:../packages/tap
       '@tailwindcss/vite':
         specifier: ^4.1.17
         version: 4.1.18(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.30.2)(yaml@2.8.2))
@@ -188,6 +191,28 @@ importers:
         specifier: '*'
         version: 2.1.9(@types/node@24.10.4)(jsdom@25.0.1)(lightningcss@1.30.2)
 
+  packages/tap:
+    dependencies:
+      cereb:
+        specifier: workspace:^
+        version: link:../cereb
+    devDependencies:
+      '@cereb/builder':
+        specifier: workspace:^
+        version: link:../../internal/builder
+      '@vitest/coverage-v8':
+        specifier: '*'
+        version: 2.1.9(vitest@2.1.9(@types/node@24.10.4)(jsdom@25.0.1)(lightningcss@1.30.2))
+      jsdom:
+        specifier: '*'
+        version: 25.0.1
+      vite:
+        specifier: '*'
+        version: 7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.30.2)(yaml@2.8.2)
+      vitest:
+        specifier: '*'
+        version: 2.1.9(@types/node@24.10.4)(jsdom@25.0.1)(lightningcss@1.30.2)
+
 packages:
 
   '@ampproject/remapping@2.3.0':
diff --git a/pr.md b/pr.md
new file mode 100644
index 0000000..0cbebb3
--- /dev/null
+++ b/pr.md
@@ -0,0 +1,47 @@
+# feat(tap): add tap gesture recognition with multi-tap support
+
+## Summary
+- Add new `@cereb/tap` package for tap gesture recognition
+- Support multi-tap detection (single, double, triple taps, etc.)
+- Add double-tap zoom gesture to space adventure example
+
+## Features
+
+### Operators
+- `tapRecognizer()` - Full lifecycle operator emitting `start`, `end`, and `cancel` phases
+- `tapEndOnly()` - Simplified operator that only emits successful tap events
+- `tap()` - Convenience function that creates a tap stream from an element
+
+### Configuration Options
+| Option | Default | Description |
+|--------|---------|-------------|
+| `movementThreshold` | 10px | Max movement allowed during tap |
+| `durationThreshold` | 500ms | Max duration for a valid tap |
+| `chainMovementThreshold` | movementThreshold | Max distance between consecutive taps |
+| `chainIntervalThreshold` | durationThreshold / 2 | Max interval between consecutive taps |
+
+### TapSignal Value
+- `phase`: Tap lifecycle phase (`start`, `end`, `cancel`)
+- `x`, `y`: Client coordinates
+- `pageX`, `pageY`: Page coordinates
+- `tapCount`: Consecutive tap count (1=single, 2=double, etc.)
+- `duration`: How long the pointer was pressed (ms)
+- `pointerType`: Type of pointer (`mouse`, `touch`, `pen`)
+
+## Usage Example
+```typescript
+import { tap } from "@cereb/tap";
+
+tap(element, { chainIntervalThreshold: 300 })
+  .on((signal) => {
+    if (signal.value.tapCount === 2) {
+      console.log("Double tap detected!");
+    }
+  });
+```
+
+## Test Plan
+- [x] Unit tests for tap recognizer state machine
+- [x] Unit tests for geometry calculations
+- [x] Unit tests for tap recognition scenarios (single, double, triple taps)
+- [x] Integration with docs site (space adventure double-tap zoom)