diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0b4bcd3..f0f6654 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.0-alpha.1 — 2026-09-06
+
+- Preserve continuous offset and progress across React renders and preserve consumer transforms with independent CSS translation.
+- Add velocity-aware bounded settling, deterministic gesture-start snapshots, and interruptible snap-back continuity.
+- Add optional `onDismissComplete` after mounted departure while keeping `onDismiss` as immediate semantic commitment.
+- Scope global blur handling to active pointer sessions and keep 1,000 idle instances free of global listeners, animation frames, and observers.
+- Reject empty or mixed-axis directions and invalid thresholds with precise errors.
+- Protect text-editing controls for mouse, touch, and pen, and add `data-drag-dismiss-ignore` for custom interaction surfaces.
+- Expand lifecycle, integration, troubleshooting, performance, and real-device documentation.
+
 ## 0.1.0-alpha.0
 
 - Initial drag-to-dismiss primitive with logical directions, intent arbitration, recent velocity, resistance, interruptible settling, reduced motion, SSR-safe packaging, and documentation.
diff --git a/README.md b/README.md
index 724edd4..d0dad0f 100644
--- a/README.md
+++ b/README.md
@@ -14,7 +14,8 @@ import '@nipe-solutions/react-drag-dismiss/core.css'
 
 ;<DragDismiss
   directions={['start', 'end']}
-  onDismiss={({ direction }) => removeItem(id, direction)}
+  onDismiss={({ direction }) => recordCommit(id, direction)}
+  onDismissComplete={() => removeItem(id)}
 >
   <Notification />
 </DragDismiss>
@@ -24,6 +25,8 @@ import '@nipe-solutions/react-drag-dismiss/core.css'
 
 The package detects intent and provides motion mechanics. Your application owns removal, unmounting, undo, focus, persistence, and side effects. Always provide an accessible semantic control for required dismissal actions.
 
+`onDismiss` fires once when release commits. Optional `onDismissComplete` fires once after a mounted departure reaches its visual target; it does not fire if the consumer unmounts first. Use `data-drag-dismiss-ignore` on custom controls that must never initiate a gesture. Inputs, textareas, selects, and contenteditable descendants are ignored automatically.
+
 Full documentation: [react-drag-dismiss.nipesolutions.com](https://react-drag-dismiss.nipesolutions.com)
 
 Part of [NIPE Open Source](https://opensource.nipesolutions.com).
@@ -38,7 +41,7 @@ npm run check
 npm run test:e2e
 ```
 
-See [CONTRIBUTING.md](CONTRIBUTING.md), [SECURITY.md](SECURITY.md), and [docs/REAL_DEVICE_QA.md](docs/REAL_DEVICE_QA.md).
+See [CONTRIBUTING.md](CONTRIBUTING.md), [SECURITY.md](SECURITY.md), [interaction architecture](docs/ARCHITECTURE.md), [performance notes](docs/PERFORMANCE.md), and [real-device QA](docs/REAL_DEVICE_QA.md).
 
 ## License
 
diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md
new file mode 100644
index 0000000..50500c2
--- /dev/null
+++ b/docs/ARCHITECTURE.md
@@ -0,0 +1,27 @@
+# Interaction architecture
+
+Drag Dismiss separates continuous interaction mechanics from semantic React state.
+
+## Pointer session snapshot
+
+Pointer down measures the element once and snapshots the axis, logical directions, physical signs, writing direction, threshold, size, and lifecycle callbacks. Prop changes and resizing during that gesture take effect on the next gesture. Pointer movement performs no layout or computed-style reads.
+
+## Continuous DOM state
+
+The interaction controller owns `translate`, `--drag-dismiss-offset`, and `--drag-dismiss-progress` through refs and direct DOM writes. React initializes these values when the node connects but does not render-own them afterward. React state owns only semantic attributes such as `data-state`.
+
+Progress is signed and threshold-relative: zero is origin, `1` or `-1` is the configured threshold, and travel beyond the threshold may exceed that range. Offset is a signed CSS pixel value.
+
+## Ownership and settling
+
+A session starts pending, claims only after dominant-axis intent, and otherwise abandons without preventing default behavior. A claimed cancellation begins an interruptible return. A new gesture starts from the currently rendered return offset. Committed departure is final and cannot be re-grabbed.
+
+Recent sampled velocity participates in both commitment and bounded settle duration. A pause expires stale velocity. The controller measures no geometry during animation frames and schedules no frame while idle.
+
+## Dismiss lifecycle
+
+`onDismiss` reports semantic commitment exactly once before departure. If the node remains mounted, `onDismissComplete` reports visual completion exactly once after the departure target is reached. Unmounting from `onDismiss` safely cancels motion and intentionally prevents completion. The package never manages presence or removes DOM.
+
+## Resource lifecycle
+
+Each idle instance owns only element-level React handlers. The window blur safeguard exists only while a pointer session is active and is removed when that session ends, abandons, or unmounts. There are no observers or idle animation frames.
diff --git a/docs/PERFORMANCE.md b/docs/PERFORMANCE.md
new file mode 100644
index 0000000..8dd5f82
--- /dev/null
+++ b/docs/PERFORMANCE.md
@@ -0,0 +1,9 @@
+# Performance notes
+
+The performance fixture mounts 1,000 independent `DragDismiss` instances and instruments resources owned by the package.
+
+While idle, the group creates no window blur listeners, animation frames, or observers. Each instance retains only its element-level React pointer handlers and refs. Starting one gesture attaches one session-scoped blur listener, measures that element once, and leaves the other 999 instances inactive. Ending, abandoning, disabling, or unmounting the active session removes that listener.
+
+Pointer movement writes `translate`, offset, progress, and semantic data attributes directly to the active element. It performs no React render per frame, computed-style lookup, or geometry measurement. Settle frames reuse the gesture-start size and configuration snapshot.
+
+These are qualitative resource invariants rather than timing claims. Render duration depends on React mode, consumer content, browser, and device, so the project does not advertise a synthetic rows-per-second benchmark.
diff --git a/docs/REAL_DEVICE_QA.md b/docs/REAL_DEVICE_QA.md
index 8dcf34c..23267fa 100644
--- a/docs/REAL_DEVICE_QA.md
+++ b/docs/REAL_DEVICE_QA.md
@@ -9,6 +9,16 @@ Record device, OS, browser version, date, and result for:
 - Desktop Chrome
 - Desktop Safari
 
-For each environment verify horizontal and vertical dismissal, slow threshold drag, fast flick, pause before release, reversal, cancel, unsupported direction, buttons and links, scrolling, RTL, reduced motion, browser-edge behavior, resize, and repeated gestures.
+For each environment verify:
+
+- slow horizontal drag, fast flick, pause before release, reversal, cancel, and wrong-direction resistance;
+- vertical dismissal where it does not conflict with primary scrolling;
+- button tap, link navigation, drag beginning on a button/link, and release-click suppression;
+- input, textarea, select, contenteditable, and `data-drag-dismiss-ignore` interaction;
+- vertical scrolling feed coexistence, RTL, reduced motion, and browser-edge behavior;
+- resize during a gesture, snap-back re-grab, repeated gestures, and committed departure;
+- consumer `transform` composition during translation.
+
+Record qualitative motion continuity for both a slow release and a fast flick. Record browser and OS versions rather than inferring physical iOS behavior from desktop WebKit.
 
 Status for `0.1.0-alpha.0`: physical iPhone and Android testing pending.
diff --git a/package-lock.json b/package-lock.json
index b07b09b..25a5f1b 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@nipe-solutions/react-drag-dismiss",
-  "version": "0.1.0-alpha.0",
+  "version": "0.1.0-alpha.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@nipe-solutions/react-drag-dismiss",
-      "version": "0.1.0-alpha.0",
+      "version": "0.1.0-alpha.1",
       "license": "MIT",
       "devDependencies": {
         "@axe-core/playwright": "4.10.2",
diff --git a/package.json b/package.json
index b5295b9..a6dda18 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@nipe-solutions/react-drag-dismiss",
-  "version": "0.1.0-alpha.0",
+  "version": "0.1.0-alpha.1",
   "description": "Composable drag-to-dismiss mechanics for React.",
   "homepage": "https://react-drag-dismiss.nipesolutions.com",
   "repository": {
diff --git a/src/DragDismiss.test.tsx b/src/DragDismiss.test.tsx
index bbe5969..6132ac3 100644
--- a/src/DragDismiss.test.tsx
+++ b/src/DragDismiss.test.tsx
@@ -1,5 +1,5 @@
-import { fireEvent, render } from '@testing-library/react'
-import { StrictMode } from 'react'
+import { act, fireEvent, render } from '@testing-library/react'
+import { StrictMode, useState } from 'react'
 import { describe, expect, test, vi } from 'vitest'
 import { DragDismiss } from './DragDismiss'
 
@@ -15,6 +15,22 @@ function pointer(target: Element, type: string, init: Record<string, unknown>) {
   )
 }
 
+function measure(element: Element, width = 200, height = 80) {
+  Object.defineProperty(element, 'getBoundingClientRect', {
+    configurable: true,
+    value: () => ({
+      width,
+      height,
+      x: 0,
+      y: 0,
+      top: 0,
+      left: 0,
+      right: width,
+      bottom: height,
+    }),
+  })
+}
+
 describe('DragDismiss', () => {
   test('renders arbitrary content with the idle styling contract', () => {
     const { getByTestId } = render(
@@ -73,6 +89,558 @@ describe('DragDismiss', () => {
     expect(onDismiss).toHaveBeenCalledWith({ direction: 'end' })
   })
 
+  test('continuous progress and offset survive semantic and parent rerenders', () => {
+    function Fixture() {
+      const [label, setLabel] = useState('Before')
+      return (
+        <>
+          <button onClick={() => setLabel('After')}>Rerender</button>
+          <DragDismiss data-testid="root">{label}</DragDismiss>
+        </>
+      )
+    }
+    const { getByRole, getByTestId } = render(<Fixture />)
+    const root = getByTestId('root')
+    measure(root)
+    pointer(root, 'pointerdown', {
+      clientX: 0,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    pointer(root, 'pointermove', {
+      clientX: 100,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    expect(root.style.getPropertyValue('--drag-dismiss-progress')).toBe('1.25')
+    expect(root.style.getPropertyValue('--drag-dismiss-offset')).toBe('100px')
+    fireEvent.click(getByRole('button', { name: 'Rerender' }))
+    expect(root).toHaveTextContent('After')
+    expect(root.style.getPropertyValue('--drag-dismiss-progress')).toBe('1.25')
+    expect(root.style.getPropertyValue('--drag-dismiss-offset')).toBe('100px')
+  })
+
+  test('validates impossible public configuration precisely', () => {
+    expect(() =>
+      render(<DragDismiss directions={[]}>Item</DragDismiss>),
+    ).toThrow('`directions` must contain at least one direction.')
+    expect(() =>
+      render(<DragDismiss directions={['start', 'down']}>Item</DragDismiss>),
+    ).toThrow(
+      '`directions` must belong to one axis. Received "start" and "down".',
+    )
+    for (const threshold of [0, -0.1, 1.1, Number.NaN, Infinity]) {
+      expect(() =>
+        render(<DragDismiss threshold={threshold}>Item</DragDismiss>),
+      ).toThrow(
+        '`threshold` must be a finite number greater than 0 and less than or equal to 1.',
+      )
+    }
+  })
+
+  test('fires commit then completion exactly once when departure finishes', async () => {
+    const order: string[] = []
+    vi.stubGlobal('matchMedia', () => ({ matches: true }))
+    const { getByTestId } = render(
+      <DragDismiss
+        data-testid="root"
+        onDismiss={() => order.push('commit')}
+        onDismissComplete={() => order.push('complete')}
+      >
+        Item
+      </DragDismiss>,
+    )
+    const root = getByTestId('root')
+    measure(root)
+    pointer(root, 'pointerdown', {
+      clientX: 0,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    pointer(root, 'pointermove', {
+      clientX: 100,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    pointer(root, 'pointerup', {
+      clientX: 100,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    pointer(root, 'pointercancel', {
+      clientX: 100,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    expect(order).toEqual(['commit'])
+    await act(async () => Promise.resolve())
+    expect(order).toEqual(['commit', 'complete'])
+    vi.unstubAllGlobals()
+  })
+
+  test('committed departure never reverses from an overshot release', () => {
+    let frame: FrameRequestCallback | undefined
+    vi.stubGlobal(
+      'requestAnimationFrame',
+      vi.fn((callback: FrameRequestCallback) => {
+        frame = callback
+        return 1
+      }),
+    )
+    const { getByTestId } = render(
+      <DragDismiss data-testid="root">Item</DragDismiss>,
+    )
+    const root = getByTestId('root')
+    measure(root)
+    pointer(root, 'pointerdown', {
+      clientX: 0,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    pointer(root, 'pointermove', {
+      clientX: 400,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    const releasedAt = Number.parseFloat(
+      root.style.getPropertyValue('--drag-dismiss-offset'),
+    )
+    pointer(root, 'pointerup', {
+      clientX: 400,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    expect(releasedAt).toBeLessThan(250)
+    expect(releasedAt).toBeGreaterThan(200)
+    act(() => frame?.(performance.now() + 16))
+    expect(
+      Number.parseFloat(root.style.getPropertyValue('--drag-dismiss-offset')),
+    ).toBeGreaterThan(releasedAt)
+    vi.unstubAllGlobals()
+  })
+
+  test('cancel fires neither dismissal lifecycle callback', () => {
+    const onDismiss = vi.fn()
+    const onDismissComplete = vi.fn()
+    const { getByTestId } = render(
+      <DragDismiss
+        data-testid="root"
+        onDismiss={onDismiss}
+        onDismissComplete={onDismissComplete}
+      >
+        Item
+      </DragDismiss>,
+    )
+    const root = getByTestId('root')
+    measure(root)
+    pointer(root, 'pointerdown', {
+      clientX: 0,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    pointer(root, 'pointermove', {
+      clientX: 10,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    pointer(root, 'pointerup', {
+      clientX: 10,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    expect(onDismiss).not.toHaveBeenCalled()
+    expect(onDismissComplete).not.toHaveBeenCalled()
+  })
+
+  test('unmounting from onDismiss is safe and does not call completion', () => {
+    const onDismissComplete = vi.fn()
+    function Fixture() {
+      const [visible, setVisible] = useState(true)
+      return visible ? (
+        <DragDismiss
+          data-testid="root"
+          onDismiss={() => setVisible(false)}
+          onDismissComplete={onDismissComplete}
+        >
+          Item
+        </DragDismiss>
+      ) : null
+    }
+    const { getByTestId } = render(<Fixture />)
+    const root = getByTestId('root')
+    measure(root)
+    pointer(root, 'pointerdown', {
+      clientX: 0,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    pointer(root, 'pointermove', {
+      clientX: 100,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    expect(() =>
+      pointer(root, 'pointerup', {
+        clientX: 100,
+        clientY: 0,
+        pointerType: 'touch',
+      }),
+    ).not.toThrow()
+    expect(onDismissComplete).not.toHaveBeenCalled()
+  })
+
+  test('preserves a consumer transform while applying drag translation', () => {
+    const { getByTestId } = render(
+      <DragDismiss
+        data-testid="root"
+        style={{ transform: 'scale(.9) rotate(2deg)' }}
+      >
+        Item
+      </DragDismiss>,
+    )
+    const root = getByTestId('root')
+    measure(root)
+    pointer(root, 'pointerdown', {
+      clientX: 0,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    pointer(root, 'pointermove', {
+      clientX: 40,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    expect(root.style.transform).toBe('scale(.9) rotate(2deg)')
+    expect(root.style.translate).toBe('40px 0px')
+  })
+
+  test.each(['input', 'textarea', 'select', 'contenteditable'])(
+    'does not start a touch drag from %s',
+    (kind) => {
+      const child =
+        kind === 'input' ? (
+          <input aria-label="field" />
+        ) : kind === 'textarea' ? (
+          <textarea aria-label="field" />
+        ) : kind === 'select' ? (
+          <select aria-label="field">
+            <option>One</option>
+          </select>
+        ) : (
+          <div role="textbox" contentEditable aria-label="field" />
+        )
+      const { getByLabelText, getByTestId } = render(
+        <DragDismiss data-testid="root">{child}</DragDismiss>,
+      )
+      const control = getByLabelText('field')
+      pointer(control, 'pointerdown', {
+        clientX: 0,
+        clientY: 0,
+        pointerType: 'touch',
+      })
+      pointer(control, 'pointermove', {
+        clientX: 80,
+        clientY: 0,
+        pointerType: 'touch',
+      })
+      expect(getByTestId('root')).toHaveAttribute('data-state', 'idle')
+    },
+  )
+
+  test('data-drag-dismiss-ignore excludes custom interactive descendants', () => {
+    const { getByTestId } = render(
+      <DragDismiss data-testid="root">
+        <div data-testid="map" data-drag-dismiss-ignore>
+          Map
+        </div>
+      </DragDismiss>,
+    )
+    const map = getByTestId('map')
+    pointer(map, 'pointerdown', { clientX: 0, clientY: 0, pointerType: 'pen' })
+    pointer(map, 'pointermove', { clientX: 80, clientY: 0, pointerType: 'pen' })
+    expect(getByTestId('root')).toHaveAttribute('data-state', 'idle')
+  })
+
+  test('allows a real drag from a button and suppresses its release click', () => {
+    const onClick = vi.fn()
+    const { getByRole, getByTestId } = render(
+      <DragDismiss data-testid="root">
+        <button onClick={onClick}>Action</button>
+      </DragDismiss>,
+    )
+    const root = getByTestId('root')
+    const button = getByRole('button')
+    measure(root)
+    pointer(button, 'pointerdown', {
+      clientX: 0,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    pointer(button, 'pointermove', {
+      clientX: 40,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    pointer(button, 'pointerup', {
+      clientX: 40,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    fireEvent.click(button, { detail: 1 })
+    expect(onClick).not.toHaveBeenCalled()
+  })
+
+  test('pointer cancellation does not suppress a later click on an ignored control', () => {
+    const onClick = vi.fn()
+    const { getByLabelText, getByTestId } = render(
+      <DragDismiss data-testid="root">
+        <input aria-label="Field" onClick={onClick} />
+      </DragDismiss>,
+    )
+    const root = getByTestId('root')
+    const input = getByLabelText('Field')
+    measure(root)
+    pointer(root, 'pointerdown', {
+      clientX: 0,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    pointer(root, 'pointermove', {
+      clientX: 40,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    pointer(root, 'pointercancel', {
+      clientX: 40,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    pointer(input, 'pointerdown', {
+      clientX: 0,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    fireEvent.click(input, { detail: 1 })
+    expect(onClick).toHaveBeenCalledOnce()
+  })
+
+  test('attaches blur only for a pointer session and removes it when pending ends', () => {
+    const add = vi.spyOn(window, 'addEventListener')
+    const remove = vi.spyOn(window, 'removeEventListener')
+    const { getByTestId } = render(
+      <DragDismiss data-testid="root">Row</DragDismiss>,
+    )
+    const root = getByTestId('root')
+    pointer(root, 'pointerdown', {
+      clientX: 0,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    const registration = add.mock.calls.find(([type]) => type === 'blur')
+    expect(registration).toBeDefined()
+    pointer(root, 'pointerup', { clientX: 0, clientY: 0, pointerType: 'touch' })
+    expect(remove).toHaveBeenCalledWith('blur', registration?.[1])
+    add.mockRestore()
+    remove.mockRestore()
+  })
+
+  test('snapshots directions, threshold, and size for the active gesture', () => {
+    const onDismiss = vi.fn()
+    const { getByTestId, rerender } = render(
+      <DragDismiss
+        data-testid="root"
+        directions={['end']}
+        threshold={0.4}
+        onDismiss={onDismiss}
+      >
+        Row
+      </DragDismiss>,
+    )
+    const root = getByTestId('root')
+    measure(root, 200)
+    pointer(root, 'pointerdown', {
+      clientX: 0,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    rerender(
+      <DragDismiss
+        data-testid="root"
+        directions={['start']}
+        threshold={0.9}
+        onDismiss={onDismiss}
+      >
+        Row
+      </DragDismiss>,
+    )
+    measure(root, 1000)
+    pointer(root, 'pointermove', {
+      clientX: 100,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    pointer(root, 'pointerup', {
+      clientX: 100,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    expect(onDismiss).toHaveBeenCalledWith({ direction: 'end' })
+  })
+
+  test('disabled during a claimed drag cancels safely', () => {
+    const onDragEnd = vi.fn()
+    const { getByTestId, rerender } = render(
+      <DragDismiss data-testid="root" onDragEnd={onDragEnd}>
+        Row
+      </DragDismiss>,
+    )
+    const root = getByTestId('root')
+    measure(root)
+    pointer(root, 'pointerdown', {
+      clientX: 0,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    pointer(root, 'pointermove', {
+      clientX: 30,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    rerender(
+      <DragDismiss data-testid="root" disabled onDragEnd={onDragEnd}>
+        Row
+      </DragDismiss>,
+    )
+    expect(onDragEnd).toHaveBeenCalledOnce()
+    expect(onDragEnd).toHaveBeenCalledWith({ dismissed: false })
+    expect(root).toHaveAttribute('data-state', 'settling')
+  })
+
+  test('re-grabs snap-back from its current rendered offset without a jump', () => {
+    let frame: FrameRequestCallback | undefined
+    vi.stubGlobal('requestAnimationFrame', (callback: FrameRequestCallback) => {
+      frame = callback
+      return 1
+    })
+    vi.stubGlobal('cancelAnimationFrame', vi.fn())
+    vi.stubGlobal('matchMedia', () => ({ matches: false }))
+    const { getByTestId } = render(
+      <DragDismiss data-testid="root">Row</DragDismiss>,
+    )
+    const root = getByTestId('root')
+    measure(root)
+    pointer(root, 'pointerdown', {
+      clientX: 0,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    pointer(root, 'pointermove', {
+      clientX: 40,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    pointer(root, 'pointercancel', {
+      clientX: 40,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    act(() => frame?.(performance.now() + 80))
+    const rendered = Number.parseFloat(
+      root.style.getPropertyValue('--drag-dismiss-offset'),
+    )
+    expect(rendered).toBeGreaterThan(0)
+    expect(rendered).toBeLessThan(40)
+    pointer(root, 'pointerdown', {
+      clientX: 0,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    expect(
+      Number.parseFloat(root.style.getPropertyValue('--drag-dismiss-offset')),
+    ).toBeCloseTo(rendered)
+    pointer(root, 'pointermove', {
+      clientX: 10,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    expect(
+      Number.parseFloat(root.style.getPropertyValue('--drag-dismiss-offset')),
+    ).toBeCloseTo(rendered + 10)
+    vi.unstubAllGlobals()
+  })
+
+  test('a tap that interrupts snap-back resumes the return instead of stranding offset', () => {
+    const frames: FrameRequestCallback[] = []
+    vi.stubGlobal(
+      'requestAnimationFrame',
+      vi.fn((callback: FrameRequestCallback) => {
+        frames.push(callback)
+        return frames.length
+      }),
+    )
+    vi.stubGlobal('cancelAnimationFrame', vi.fn())
+    vi.stubGlobal('matchMedia', () => ({ matches: false }))
+    const { getByTestId } = render(
+      <DragDismiss data-testid="root">Row</DragDismiss>,
+    )
+    const root = getByTestId('root')
+    measure(root)
+    pointer(root, 'pointerdown', {
+      clientX: 0,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    pointer(root, 'pointermove', {
+      clientX: 40,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    pointer(root, 'pointercancel', {
+      clientX: 40,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    expect(frames).toHaveLength(1)
+    pointer(root, 'pointerdown', {
+      clientX: 0,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    pointer(root, 'pointerup', {
+      clientX: 0,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    expect(frames).toHaveLength(2)
+    expect(root).toHaveAttribute('data-state', 'settling')
+    vi.unstubAllGlobals()
+  })
+
+  test('1000 idle instances do not register window blur listeners or RAF', () => {
+    const add = vi.spyOn(window, 'addEventListener')
+    const raf = vi.spyOn(window, 'requestAnimationFrame')
+    const { container } = render(
+      <>
+        {Array.from({ length: 1000 }, (_, index) => (
+          <DragDismiss key={index}>Row</DragDismiss>
+        ))}
+      </>,
+    )
+    expect(add.mock.calls.filter(([type]) => type === 'blur')).toHaveLength(0)
+    expect(raf).not.toHaveBeenCalled()
+    const first = container.querySelector('[data-drag-dismiss]')
+    if (!first) throw new Error('Large-list fixture did not render')
+    pointer(first, 'pointerdown', {
+      clientX: 0,
+      clientY: 0,
+      pointerType: 'touch',
+    })
+    expect(add.mock.calls.filter(([type]) => type === 'blur')).toHaveLength(1)
+    expect(raf).not.toHaveBeenCalled()
+    add.mockRestore()
+    raf.mockRestore()
+  })
+
   test('abandons a perpendicular gesture without preventing it', () => {
     const { getByTestId } = render(
       <DragDismiss data-testid="root">Message</DragDismiss>,
@@ -110,7 +678,7 @@ describe('DragDismiss', () => {
     expect(root).toHaveAttribute('data-disabled', '')
   })
 
-  test('does not start a mouse drag from an interactive child', () => {
+  test('keeps a small mouse movement on a button as a click', () => {
     const onClick = vi.fn()
     const { getByRole, getByTestId } = render(
       <DragDismiss data-testid="root">
@@ -124,7 +692,7 @@ describe('DragDismiss', () => {
       pointerType: 'mouse',
     })
     pointer(button, 'pointermove', {
-      clientX: 100,
+      clientX: 2,
       clientY: 0,
       pointerType: 'mouse',
     })
@@ -159,12 +727,8 @@ describe('DragDismiss', () => {
       clientY: 0,
       pointerType: 'mouse',
     })
-    pointer(root, 'pointerdown', {
-      clientX: 0,
-      clientY: 0,
-      pointerType: 'mouse',
-    })
-    pointer(root, 'pointerup', { clientX: 0, clientY: 0, pointerType: 'mouse' })
+    fireEvent.click(root, { detail: 1 })
+    expect(onClick).not.toHaveBeenCalled()
     fireEvent.click(root, { detail: 1 })
     expect(onClick).toHaveBeenCalledOnce()
   })
diff --git a/src/DragDismiss.tsx b/src/DragDismiss.tsx
index d926762..ba61a6f 100644
--- a/src/DragDismiss.tsx
+++ b/src/DragDismiss.tsx
@@ -1,5 +1,6 @@
 import {
   forwardRef,
+  useCallback,
   useEffect,
   useImperativeHandle,
   useRef,
@@ -14,6 +15,7 @@ import {
   getAxis,
   getPhysicalSign,
   getRecentVelocity,
+  getSettleDuration,
   resolveIntent,
   updateArmed,
   type Axis,
@@ -50,27 +52,68 @@ export interface DragDismissProps extends Omit<
   onDragStart?: () => void
   onDragEnd?: (event: DragDismissEndEvent) => void
   onDismiss?: (event: DragDismissEvent) => void
+  onDismissComplete?: (event: DragDismissEvent) => void
 }
 
-interface Session {
+interface GestureConfig {
+  axis: Axis
+  directions: readonly DragDismissDirection[]
+  signs: readonly number[]
+  writingDirection: WritingDirection
+  threshold: number
+  size: number
+  onDragStart: (() => void) | undefined
+  onDragEnd: ((event: DragDismissEndEvent) => void) | undefined
+  onDismiss: ((event: DragDismissEvent) => void) | undefined
+  onDismissComplete: ((event: DragDismissEvent) => void) | undefined
+}
+
+interface Session extends GestureConfig {
   pointerId: number
   startX: number
   startY: number
   startOffset: number
-  size: number
-  status: 'pending' | 'claimed' | 'abandoned'
+  status: 'pending' | 'claimed'
   samples: PointerSample[]
+  blurHandler: () => void
+  interruptedReturn: boolean
 }
 
-type DragStyle = CSSProperties & {
-  '--drag-dismiss-offset'?: string
-  '--drag-dismiss-progress'?: number
+interface Motion extends GestureConfig {
+  kind: 'return' | 'departure'
+  direction: DragDismissDirection | undefined
+  frame: number | null
 }
 
-const interactiveSelector =
-  'button, a[href], input, select, textarea, [contenteditable="true"]'
+const DEFAULT_DIRECTIONS = ['end'] as const
+const editingSelector =
+  'input, select, textarea, [contenteditable]:not([contenteditable="false"]), [data-drag-dismiss-ignore]'
+
+function validateConfiguration(
+  directions: readonly DragDismissDirection[],
+  threshold: number,
+): Axis {
+  if (directions.length === 0)
+    throw new Error('`directions` must contain at least one direction.')
+  const first = directions[0] as DragDismissDirection
+  const axis = getAxis(first)
+  const differentAxis = directions.find(
+    (direction) => getAxis(direction) !== axis,
+  )
+  if (differentAxis) {
+    throw new Error(
+      `\`directions\` must belong to one axis. Received "${first}" and "${differentAxis}".`,
+    )
+  }
+  if (!Number.isFinite(threshold) || threshold <= 0 || threshold > 1) {
+    throw new Error(
+      '`threshold` must be a finite number greater than 0 and less than or equal to 1.',
+    )
+  }
+  return axis
+}
 
-function writingDirection(element: HTMLElement): WritingDirection {
+function resolveWritingDirection(element: HTMLElement): WritingDirection {
   const explicit = element.closest('[dir]')?.getAttribute('dir')
   if (explicit === 'rtl') return 'rtl'
   if (explicit === 'ltr') return 'ltr'
@@ -87,125 +130,156 @@ function directionForSign(
   )
 }
 
+function initializeContinuousStyles(node: HTMLElement) {
+  node.style.translate = '0px 0px'
+  node.style.setProperty('--drag-dismiss-offset', '0px')
+  node.style.setProperty('--drag-dismiss-progress', '0')
+}
+
 export const DragDismiss = forwardRef<HTMLDivElement, DragDismissProps>(
   function DragDismiss(
     {
       children,
-      directions = ['end'],
+      directions = DEFAULT_DIRECTIONS,
       threshold = 0.4,
       disabled = false,
       onDragStart,
       onDragEnd,
       onDismiss,
+      onDismissComplete,
       onClickCapture,
       style,
       ...props
     },
     forwardedRef,
   ) {
+    const axis = validateConfiguration(directions, threshold)
     const nodeRef = useRef<HTMLDivElement>(null)
     const sessionRef = useRef<Session | null>(null)
-    const frameRef = useRef<number | null>(null)
+    const motionRef = useRef<Motion | null>(null)
     const offsetRef = useRef(0)
     const suppressClickRef = useRef(false)
     const committedRef = useRef(false)
     const armedRef = useRef(false)
+    const mountedRef = useRef(false)
     const [state, setState] = useState<
       'idle' | 'dragging' | 'settling' | 'dismissed'
     >('idle')
 
-    useImperativeHandle(forwardedRef, () => nodeRef.current as HTMLDivElement)
+    const setNodeRef = useCallback((node: HTMLDivElement | null) => {
+      nodeRef.current = node
+      if (node) initializeContinuousStyles(node)
+    }, [])
 
-    const axis: Axis = getAxis(directions[0] ?? 'end')
-    const activeDirections = directions.filter(
-      (direction) => getAxis(direction) === axis,
-    )
+    useImperativeHandle(forwardedRef, () => nodeRef.current as HTMLDivElement)
 
-    function renderOffset(offset: number, size: number) {
+    function writeContinuous(offset: number, config: GestureConfig) {
       const node = nodeRef.current
       if (!node) return
       offsetRef.current = offset
-      const x = axis === 'x' ? offset : 0
-      const y = axis === 'y' ? offset : 0
-      node.style.transform = `translate3d(${x}px, ${y}px, 0)`
+      const x = config.axis === 'x' ? offset : 0
+      const y = config.axis === 'y' ? offset : 0
+      node.style.translate = `${x}px ${y}px`
       node.style.setProperty('--drag-dismiss-offset', `${offset}px`)
       node.style.setProperty(
         '--drag-dismiss-progress',
-        String(size > 0 ? offset / (size * threshold) : 0),
-      )
-      const dir = writingDirection(node)
-      const allowedSigns = activeDirections.map((candidate) =>
-        getPhysicalSign(candidate, dir),
+        String(offset / (config.size * config.threshold)),
       )
       const activeDirection = directionForSign(
-        activeDirections,
-        dir,
+        config.directions,
+        config.writingDirection,
         Math.sign(offset),
       )
       if (activeDirection) node.setAttribute('data-direction', activeDirection)
       else node.removeAttribute('data-direction')
-      const supported = allowedSigns.some((sign) => sign === Math.sign(offset))
+      const supported = config.signs.includes(Math.sign(offset))
       const armed = supported
-        ? updateArmed(armedRef.current, Math.abs(offset) / (size * threshold))
+        ? updateArmed(
+            armedRef.current,
+            Math.abs(offset) / (config.size * config.threshold),
+          )
         : false
       armedRef.current = armed
       if (armed) node.setAttribute('data-dismiss-intent', 'true')
       else node.removeAttribute('data-dismiss-intent')
     }
 
-    function stopMotion() {
-      if (frameRef.current !== null) cancelAnimationFrame(frameRef.current)
-      frameRef.current = null
+    function detachSession(session: Session | null) {
+      if (!session) return
+      window.removeEventListener('blur', session.blurHandler)
+      if (sessionRef.current === session) sessionRef.current = null
+    }
+
+    function stopMotion(allowDeparture = false) {
+      const motion = motionRef.current
+      if (!motion || (motion.kind === 'departure' && !allowDeparture))
+        return false
+      if (motion.frame !== null) cancelAnimationFrame(motion.frame)
+      motionRef.current = null
+      return true
     }
 
-    function settleTo(target: number, finalState: 'idle' | 'dismissed') {
-      stopMotion()
-      const node = nodeRef.current
-      if (!node) return
+    function finishMotion(motion: Motion, target: number) {
+      if (motionRef.current !== motion || !mountedRef.current) return
+      writeContinuous(target, motion)
+      motionRef.current = null
+      if (motion.kind === 'departure' && motion.direction) {
+        setState('dismissed')
+        motion.onDismissComplete?.({ direction: motion.direction })
+      } else {
+        setState('idle')
+      }
+    }
+
+    function settleTo(
+      config: GestureConfig,
+      target: number,
+      initialVelocity: number,
+      kind: Motion['kind'],
+      direction?: DragDismissDirection,
+    ) {
+      stopMotion(true)
+      if (!nodeRef.current) return
+      const motion: Motion = {
+        ...config,
+        kind,
+        direction,
+        frame: null,
+      }
+      motionRef.current = motion
+      setState(kind === 'return' ? 'settling' : 'dismissed')
+      const start = offsetRef.current
+      const distance = target - start
       const reduceMotion = window.matchMedia?.(
         '(prefers-reduced-motion: reduce)',
       ).matches
-      const start = offsetRef.current
-      const distance = target - start
       if (reduceMotion || Math.abs(distance) < 0.5) {
-        renderOffset(
-          target,
-          Math.max(1, axis === 'x' ? node.clientWidth : node.clientHeight),
-        )
-        setState(finalState)
+        queueMicrotask(() => finishMotion(motion, target))
         return
       }
-      setState(finalState === 'idle' ? 'settling' : 'dismissed')
       const began = performance.now()
-      const duration = Math.min(280, Math.max(140, Math.abs(distance) * 0.7))
+      const duration = getSettleDuration(distance, initialVelocity)
       const tick = (now: number) => {
+        if (motionRef.current !== motion || !mountedRef.current) return
         const progress = Math.min(1, (now - began) / duration)
         const eased = 1 - Math.pow(1 - progress, 3)
-        renderOffset(
-          start + distance * eased,
-          Math.max(1, axis === 'x' ? node.clientWidth : node.clientHeight),
-        )
-        if (progress < 1) frameRef.current = requestAnimationFrame(tick)
-        else {
-          frameRef.current = null
-          setState(finalState)
-        }
+        writeContinuous(start + distance * eased, motion)
+        if (progress < 1) motion.frame = requestAnimationFrame(tick)
+        else finishMotion(motion, target)
       }
-      frameRef.current = requestAnimationFrame(tick)
-    }
-
-    function clearSession() {
-      sessionRef.current = null
+      motion.frame = requestAnimationFrame(tick)
     }
 
     function cancelGesture() {
       const session = sessionRef.current
       if (!session) return
       const claimed = session.status === 'claimed'
-      clearSession()
+      detachSession(session)
       if (claimed) {
-        onDragEnd?.({ dismissed: false })
-        settleTo(0, 'idle')
+        session.onDragEnd?.({ dismissed: false })
+        settleTo(session, 0, 0, 'return')
+      } else if (session.interruptedReturn && offsetRef.current !== 0) {
+        settleTo(session, 0, 0, 'return')
       } else setState('idle')
     }
 
@@ -214,64 +288,79 @@ export const DragDismiss = forwardRef<HTMLDivElement, DragDismissProps>(
         disabled ||
         committedRef.current ||
         !event.isPrimary ||
-        event.button !== 0
+        event.button !== 0 ||
+        sessionRef.current
       )
         return
-      suppressClickRef.current = false
       if (
-        event.pointerType === 'mouse' &&
         event.target instanceof Element &&
-        event.target.closest(interactiveSelector)
+        event.target.closest(editingSelector)
       )
         return
+      suppressClickRef.current = false
+      if (motionRef.current?.kind === 'departure') return
+      const interruptedReturn = motionRef.current?.kind === 'return'
       stopMotion()
       const node = nodeRef.current
       if (!node) return
       const rect = node.getBoundingClientRect()
-      sessionRef.current = {
+      const writingDirection = resolveWritingDirection(node)
+      const snapshotDirections = [...directions]
+      const snapshotAxis = getAxis(
+        snapshotDirections[0] as DragDismissDirection,
+      )
+      const session: Session = {
         pointerId: event.pointerId,
         startX: event.clientX,
         startY: event.clientY,
         startOffset: offsetRef.current,
-        size: Math.max(1, axis === 'x' ? rect.width : rect.height),
+        size: Math.max(1, snapshotAxis === 'x' ? rect.width : rect.height),
         status: 'pending',
         samples: [{ position: offsetRef.current, time: event.timeStamp }],
+        axis: snapshotAxis,
+        directions: snapshotDirections,
+        signs: snapshotDirections.map((candidate) =>
+          getPhysicalSign(candidate, writingDirection),
+        ),
+        writingDirection,
+        threshold,
+        onDragStart,
+        onDragEnd,
+        onDismiss,
+        onDismissComplete,
+        blurHandler: () => {},
+        interruptedReturn,
       }
-      setState('idle')
+      session.blurHandler = () => cancelGesture()
+      sessionRef.current = session
+      window.addEventListener('blur', session.blurHandler)
     }
 
     function handlePointerMove(event: ReactPointerEvent<HTMLDivElement>) {
       const session = sessionRef.current
-      if (
-        !session ||
-        session.pointerId !== event.pointerId ||
-        session.status === 'abandoned'
-      )
-        return
+      if (!session || session.pointerId !== event.pointerId) return
       const movementX = event.clientX - session.startX
       const movementY = event.clientY - session.startY
       if (session.status === 'pending') {
-        const intent = resolveIntent(movementX, movementY, axis)
+        const intent = resolveIntent(movementX, movementY, session.axis)
         if (intent === 'pending') return
         if (intent === 'abandon') {
-          session.status = 'abandoned'
-          setState('idle')
+          detachSession(session)
+          if (session.interruptedReturn && offsetRef.current !== 0)
+            settleTo(session, 0, 0, 'return')
+          else setState('idle')
           return
         }
         session.status = 'claimed'
         event.currentTarget.setPointerCapture?.(event.pointerId)
         setState('dragging')
-        onDragStart?.()
+        session.onDragStart?.()
       }
       event.preventDefault()
       const rawOffset =
-        session.startOffset + (axis === 'x' ? movementX : movementY)
-      const direction = writingDirection(event.currentTarget)
-      const signs = activeDirections.map((candidate) =>
-        getPhysicalSign(candidate, direction),
-      )
-      const offset = applyResistance(rawOffset, signs)
-      renderOffset(offset, session.size)
+        session.startOffset + (session.axis === 'x' ? movementX : movementY)
+      const offset = applyResistance(rawOffset, session.signs, session.size)
+      writeContinuous(offset, session)
       session.samples.push({ position: offset, time: event.timeStamp })
       session.samples = session.samples.filter(
         (sample) => event.timeStamp - sample.time <= 140,
@@ -284,17 +373,17 @@ export const DragDismiss = forwardRef<HTMLDivElement, DragDismissProps>(
     ) {
       const session = sessionRef.current
       if (!session || session.pointerId !== event.pointerId) return
-      clearSession()
+      detachSession(session)
       if (session.status !== 'claimed') {
-        setState('idle')
+        if (session.interruptedReturn && offsetRef.current !== 0)
+          settleTo(session, 0, 0, 'return')
+        else setState('idle')
         return
       }
       event.currentTarget.releasePointerCapture?.(event.pointerId)
-      suppressClickRef.current = true
-      const direction = writingDirection(event.currentTarget)
-      const signs = activeDirections.map((candidate) =>
-        getPhysicalSign(candidate, direction),
-      )
+      // A canceled pointer stream does not produce a release click. Keeping
+      // suppression armed here would swallow the next unrelated interaction.
+      suppressClickRef.current = !canceled
       const velocity = canceled
         ? 0
         : getRecentVelocity(session.samples, event.timeStamp)
@@ -304,33 +393,37 @@ export const DragDismiss = forwardRef<HTMLDivElement, DragDismissProps>(
             offset: offsetRef.current,
             size: session.size,
             velocity,
-            allowedSigns: signs,
-            threshold,
+            allowedSigns: session.signs,
+            threshold: session.threshold,
           })
       const dismissedDirection =
         sign === null
           ? undefined
-          : directionForSign(activeDirections, direction, sign)
+          : directionForSign(session.directions, session.writingDirection, sign)
       if (sign === null || !dismissedDirection) {
-        onDragEnd?.({ dismissed: false })
-        settleTo(0, 'idle')
+        session.onDragEnd?.({ dismissed: false })
+        settleTo(session, 0, velocity, 'return')
         return
       }
       committedRef.current = true
       setState('dismissed')
-      onDragEnd?.({ dismissed: true, direction: dismissedDirection })
-      onDismiss?.({ direction: dismissedDirection })
-      const margin = 16
-      settleTo(sign * (session.size + margin), 'dismissed')
+      session.onDragEnd?.({ dismissed: true, direction: dismissedDirection })
+      session.onDismiss?.({ direction: dismissedDirection })
+      settleTo(
+        session,
+        sign * Math.max(session.size + 16, Math.abs(offsetRef.current) + 16),
+        velocity,
+        'departure',
+        dismissedDirection,
+      )
     }
 
     useEffect(() => {
-      const cancel = () => cancelGesture()
-      window.addEventListener('blur', cancel)
+      mountedRef.current = true
       return () => {
-        window.removeEventListener('blur', cancel)
-        stopMotion()
-        sessionRef.current = null
+        mountedRef.current = false
+        detachSession(sessionRef.current)
+        stopMotion(true)
       }
     }, [])
 
@@ -338,11 +431,8 @@ export const DragDismiss = forwardRef<HTMLDivElement, DragDismissProps>(
       if (disabled) cancelGesture()
     }, [disabled])
 
-    const mechanicalStyle: DragStyle = {
+    const mechanicalStyle: CSSProperties = {
       ...style,
-      '--drag-dismiss-offset': `${offsetRef.current}px`,
-      '--drag-dismiss-progress': 0,
-      transform: `translate3d(${axis === 'x' ? offsetRef.current : 0}px, ${axis === 'y' ? offsetRef.current : 0}px, 0)`,
       touchAction: disabled
         ? style?.touchAction
         : axis === 'x'
@@ -353,7 +443,7 @@ export const DragDismiss = forwardRef<HTMLDivElement, DragDismissProps>(
     return (
       <div
         {...props}
-        ref={nodeRef}
+        ref={setNodeRef}
         style={mechanicalStyle}
         data-drag-dismiss=""
         data-state={state}
diff --git a/src/core.css b/src/core.css
index 0893ed2..1d20b89 100644
--- a/src/core.css
+++ b/src/core.css
@@ -1,9 +1,9 @@
 [data-drag-dismiss] {
-  transform: translate3d(var(--drag-dismiss-offset, 0px), 0, 0);
+  translate: 0px 0px;
 }
 
 [data-drag-dismiss][data-state='dragging'],
 [data-drag-dismiss][data-state='settling'],
 [data-drag-dismiss][data-state='dismissed'] {
-  will-change: transform;
+  will-change: translate;
 }
diff --git a/src/gesture.test.ts b/src/gesture.test.ts
index 9572eb1..a1fa8e3 100644
--- a/src/gesture.test.ts
+++ b/src/gesture.test.ts
@@ -1,6 +1,7 @@
 import { describe, expect, test } from 'vitest'
 import {
   applyResistance,
+  getSettleDuration,
   decideDismiss,
   getAxis,
   getPhysicalSign,
@@ -39,6 +40,9 @@ describe('intent and resistance', () => {
     expect(resolveIntent(3, 12, 'x')).toBe('abandon'))
   test('resists unsupported travel', () =>
     expect(applyResistance(-100, [1])).toBeCloseTo(-24))
+  test('resists supported travel beyond the element size', () => {
+    expect(applyResistance(400, [1], 200)).toBeCloseTo(233.94, 1)
+  })
 })
 
 describe('velocity and commitment', () => {
@@ -98,3 +102,13 @@ describe('velocity and commitment', () => {
     ).toBe(1)
   })
 })
+
+describe('settle motion', () => {
+  test('release velocity makes the same remaining distance settle faster within bounds', () => {
+    expect(getSettleDuration(180, 0)).toBe(266)
+    expect(getSettleDuration(180, 1.5)).toBeLessThan(266)
+    expect(getSettleDuration(180, -1.5)).toBe(266)
+    expect(getSettleDuration(180, 100)).toBeGreaterThanOrEqual(110)
+    expect(getSettleDuration(2_000, 0)).toBeLessThanOrEqual(320)
+  })
+})
diff --git a/src/gesture.ts b/src/gesture.ts
index adb9bf9..fc4ca45 100644
--- a/src/gesture.ts
+++ b/src/gesture.ts
@@ -40,10 +40,15 @@ export function resolveIntent(
 export function applyResistance(
   offset: number,
   allowedSigns: readonly number[],
+  limit = Number.POSITIVE_INFINITY,
 ): number {
   const sign = Math.sign(offset)
-  if (offset === 0 || allowedSigns.includes(sign)) return offset
-  return sign * Math.sqrt(Math.abs(offset)) * 2.4
+  if (offset === 0) return offset
+  if (!allowedSigns.includes(sign))
+    return sign * Math.sqrt(Math.abs(offset)) * 2.4
+  const absoluteOffset = Math.abs(offset)
+  if (absoluteOffset <= limit) return offset
+  return sign * (limit + Math.sqrt(absoluteOffset - limit) * 2.4)
 }
 
 export function updateArmed(
@@ -81,6 +86,21 @@ export function getRecentVelocity(
   return denominator === 0 ? 0 : numerator / denominator
 }
 
+export function getSettleDuration(
+  distance: number,
+  initialVelocity: number,
+): number {
+  const absoluteDistance = Math.abs(distance)
+  const base = Math.min(320, Math.max(160, 140 + absoluteDistance * 0.7))
+  const alignedVelocity = Math.max(
+    0,
+    Math.sign(distance) *
+      (Number.isFinite(initialVelocity) ? initialVelocity : 0),
+  )
+  const velocityFactor = 1 - Math.min(0.58, alignedVelocity * 0.28)
+  return Math.round(Math.min(320, Math.max(110, base * velocityFactor)))
+}
+
 export interface DismissDecision {
   offset: number
   size: number
diff --git a/test/browser/interaction.spec.ts b/test/browser/interaction.spec.ts
index 8a79492..8cb7696 100644
--- a/test/browser/interaction.spec.ts
+++ b/test/browser/interaction.spec.ts
@@ -58,3 +58,22 @@ test('RTL logical end moves left and the page has no serious axe violations', as
     ),
   ).toEqual([])
 })
+
+test('drag translation preserves a consumer CSS transform', async ({
+  page,
+}) => {
+  const card = page.locator('.hero-demo .demo-card')
+  const box = await card.boundingBox()
+  if (!box) throw new Error('Demo card was not measurable')
+  await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2)
+  await page.mouse.down()
+  await page.mouse.move(box.x + box.width / 2 + 40, box.y + box.height / 2)
+  await expect(card).toHaveAttribute('data-state', 'dragging')
+  const styles = await card.evaluate((node) => {
+    const computed = getComputedStyle(node)
+    return { transform: computed.transform, translate: computed.translate }
+  })
+  expect(styles.transform).not.toBe('none')
+  expect(styles.translate).not.toBe('none')
+  await page.mouse.up()
+})
diff --git a/website/App.test.tsx b/website/App.test.tsx
index 536e1be..402c364 100644
--- a/website/App.test.tsx
+++ b/website/App.test.tsx
@@ -27,5 +27,20 @@ describe('documentation site', () => {
     expect(
       screen.getByRole('heading', { name: 'Known limitations' }),
     ).toBeInTheDocument()
+    expect(
+      screen.getByRole('heading', { name: 'Troubleshooting' }),
+    ).toBeInTheDocument()
+    expect(screen.getAllByText('onDismissComplete').length).toBeGreaterThan(0)
+    for (const name of [
+      'GitHub',
+      'Changelog',
+      'Security',
+      'License',
+      'NIPE Open Source',
+      'Imprint',
+      'Privacy',
+    ]) {
+      expect(screen.getAllByRole('link', { name }).length).toBeGreaterThan(0)
+    }
   })
 })
diff --git a/website/App.tsx b/website/App.tsx
index 1d41bf1..dd3c80f 100644
--- a/website/App.tsx
+++ b/website/App.tsx
@@ -8,7 +8,8 @@ const code = `import { DragDismiss } from '@nipe-solutions/react-drag-dismiss'
 
 <DragDismiss
   directions={['start', 'end']}
-  onDismiss={({ direction }) => removeItem(id, direction)}
+  onDismiss={({ direction }) => recordCommit(id, direction)}
+  onDismissComplete={() => removeItem(id)}
 >
   <Notification />
 </DragDismiss>`
@@ -29,7 +30,7 @@ function DemoCard({
         <DragDismiss
           className="demo-card"
           directions={directions}
-          onDismiss={() => setVisible(false)}
+          onDismissComplete={() => setVisible(false)}
         >
           <span className="demo-mark" aria-hidden="true">
             N
@@ -97,7 +98,7 @@ export function App() {
         <section className="hero">
           <div className="hero-copy">
             <p className="status">
-              <span /> 0.1.0 alpha
+              <span /> 0.1.0-alpha.1
             </p>
             <h1>Drag to dismiss.</h1>
             <p className="hero-principle">
@@ -129,7 +130,7 @@ export function App() {
           </p>
           <p>
             <strong>Application-owned</strong>
-            <span>One semantic callback.</span>
+            <span>Commit and completion, never presence.</span>
           </p>
           <p>
             <strong>Zero runtime dependencies</strong>
@@ -149,6 +150,7 @@ export function App() {
               <a href="#accessibility">Accessibility</a>
               <a href="#styling">Styling</a>
               <a href="#api">API reference</a>
+              <a href="#troubleshooting">Troubleshooting</a>
               <a href="#limitations">Limitations</a>
             </nav>
           </aside>
@@ -208,9 +210,15 @@ export function App() {
               <p>
                 Unsupported directions receive restrained resistance. Canceled
                 gestures settle to origin and can be grabbed again from their
-                current visual position. A committed release calls{' '}
-                <code>onDismiss</code> immediately and continues off the
-                measured edge if the consumer keeps it mounted.
+                current visual position. Release velocity adjusts a bounded
+                settle duration so quick flicks continue briskly while slow
+                releases remain calm.
+              </p>
+              <p>
+                A committed release calls <code>onDismiss</code> immediately,
+                then departs beyond the measured edge. If the component stays
+                mounted, <code>onDismissComplete</code> fires once at the final
+                visual target. Committed departure cannot be re-grabbed.
               </p>
             </Section>
 
@@ -260,9 +268,10 @@ export function App() {
                 <div>
                   <h3>Interactive children</h3>
                   <p>
-                    Buttons, links, form controls, and text keep their normal
-                    behavior. Mouse drags do not originate from interactive
-                    controls.
+                    Buttons and links retain taps, while a claimed drag
+                    suppresses its release click. Inputs, textareas, selects,
+                    contenteditable regions, and descendants marked{' '}
+                    <code>data-drag-dismiss-ignore</code> never initiate drag.
                   </p>
                 </div>
                 <div>
@@ -308,12 +317,13 @@ export function App() {
                 replacement for a semantic dismiss control.
               </blockquote>
               <p>
-                Use the same application handler from a clearly named button.
-                The application decides focus after unmount. Drag Dismiss
-                injects no ARIA and invents no keyboard shortcuts.
+                Use a clearly named button for the same application action. If a
+                focused list item is removed, move focus to the next item or the
+                list container in application code. Drag Dismiss injects no
+                ARIA, moves no focus, and invents no keyboard shortcuts.
               </p>
               <pre>
-                <code>{`const dismiss = () => removeNotification(id)\n\n<button onClick={dismiss}>Dismiss notification</button>\n<DragDismiss onDismiss={dismiss}>…</DragDismiss>`}</code>
+                <code>{`const remove = () => removeNotification(id)\n\n<button onClick={remove}>Dismiss notification</button>\n<DragDismiss\n  onDismiss={() => logDismissIntent(id)}\n  onDismissComplete={remove}\n>\n  …\n</DragDismiss>`}</code>
               </pre>
             </Section>
 
@@ -328,7 +338,9 @@ export function App() {
                 <code>data-state="idle|dragging|settling|dismissed"</code>,{' '}
                 <code>data-dismiss-intent="true"</code>, and{' '}
                 <code>data-disabled</code>. Core motion translates only;
-                opacity, scale, and rotation remain yours.
+                consumer transform, opacity, scale, and rotation remain yours.
+                The individual CSS <code>translate</code> property is reserved
+                for mechanical drag offset.
               </p>
             </Section>
 
@@ -360,7 +372,16 @@ export function App() {
                 <div>
                   <code>onDismiss</code>
                   <span>
-                    Called once at commit with <code>{`{ direction }`}</code>.
+                    Called exactly once when release commits, before departure.
+                  </span>
+                </div>
+                <div>
+                  <code>onDismissComplete</code>
+                  <span>
+                    Optional; called once after mounted departure reaches its
+                    target, with the same <code>{`{ direction }`}</code>. It
+                    does not fire if the consumer unmounts first. Reduced motion
+                    preserves commit-before-complete ordering.
                   </span>
                 </div>
                 <div>
@@ -370,6 +391,44 @@ export function App() {
               </div>
             </Section>
 
+            <Section id="troubleshooting" title="Troubleshooting">
+              <div className="two-col">
+                <div>
+                  <h3>Card disappears before departure</h3>
+                  <p>
+                    The consumer unmounted from <code>onDismiss</code>. Keep the
+                    node mounted and remove it from{' '}
+                    <code>onDismissComplete</code> when visual completion
+                    matters.
+                  </p>
+                </div>
+                <div>
+                  <h3>Exclude a custom control</h3>
+                  <p>
+                    Form editors are protected automatically. Add{' '}
+                    <code>data-drag-dismiss-ignore</code> to a slider, map,
+                    canvas, editor, or other custom interaction surface.
+                  </p>
+                </div>
+                <div>
+                  <h3>Compose transforms</h3>
+                  <p>
+                    Keep scale and rotation in <code>transform</code>. Drag
+                    Dismiss uses the independent <code>translate</code>{' '}
+                    property, so both remain active.
+                  </p>
+                </div>
+                <div>
+                  <h3>Horizontal gesture conflict</h3>
+                  <p>
+                    A surface should generally have one horizontal owner. Choose
+                    Drag Dismiss or Swipe Actions, or separate their starting
+                    surfaces explicitly.
+                  </p>
+                </div>
+              </div>
+            </Section>
+
             <Section id="limitations" title="Known limitations">
               <ul>
                 <li>
@@ -382,8 +441,9 @@ export function App() {
                   globally.
                 </li>
                 <li>
-                  A committed callback may unmount immediately and therefore cut
-                  the optional exit motion short.
+                  Unmounting in <code>onDismiss</code> intentionally cuts the
+                  departure short; use <code>onDismissComplete</code> when the
+                  visual exit must finish.
                 </li>
                 <li>
                   Physical iOS and Android device QA is pending for this alpha.
@@ -398,7 +458,20 @@ export function App() {
           Part of{' '}
           <a href="https://opensource.nipesolutions.com">NIPE Open Source</a>.
         </p>
-        <nav aria-label="Legal">
+        <nav aria-label="Project and legal links">
+          <a href="https://github.com/NIPE-Solutions/react-drag-dismiss">
+            GitHub
+          </a>
+          <a href="https://github.com/NIPE-Solutions/react-drag-dismiss/blob/main/CHANGELOG.md">
+            Changelog
+          </a>
+          <a href="https://github.com/NIPE-Solutions/react-drag-dismiss/security/policy">
+            Security
+          </a>
+          <a href="https://github.com/NIPE-Solutions/react-drag-dismiss/blob/main/LICENSE">
+            License
+          </a>
+          <a href="https://opensource.nipesolutions.com">NIPE Open Source</a>
           <a href="https://opensource.nipesolutions.com/impressum">Imprint</a>
           <a href="https://opensource.nipesolutions.com/privacy">Privacy</a>
         </nav>
diff --git a/website/styles.css b/website/styles.css
index ef465e7..697c778 100644
--- a/website/styles.css
+++ b/website/styles.css
@@ -166,6 +166,7 @@ h1 {
   box-shadow: 12px 14px 0 #10223f13;
   cursor: grab;
   user-select: none;
+  transform: scale(1);
 }
 .demo-card:active {
   cursor: grabbing;
@@ -374,6 +375,10 @@ footer {
   justify-content: space-between;
   font-size: 14px;
 }
+footer nav {
+  flex-wrap: wrap;
+  justify-content: flex-end;
+}
 @media (max-width: 800px) {
   .site-header nav a:not(:last-child) {
     display: none;