From 3e1f67c52cb0f0ac8ea2dbc27646e544945f5813 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Thu, 10 Sep 2026 20:46:13 +0000 Subject: [PATCH] Sync generated provider output --- .agent/skills/impeccable/reference/adapt.md | 6 ++++++ .agent/skills/impeccable/reference/audit.md | 3 ++- .agent/skills/impeccable/reference/harden.md | 9 +++++++++ .agents/skills/impeccable/reference/adapt.md | 6 ++++++ .agents/skills/impeccable/reference/audit.md | 3 ++- .agents/skills/impeccable/reference/harden.md | 9 +++++++++ .claude/skills/impeccable/reference/adapt.md | 6 ++++++ .claude/skills/impeccable/reference/audit.md | 3 ++- .claude/skills/impeccable/reference/harden.md | 9 +++++++++ .cursor/skills/impeccable/reference/adapt.md | 6 ++++++ .cursor/skills/impeccable/reference/audit.md | 3 ++- .cursor/skills/impeccable/reference/harden.md | 9 +++++++++ .dsh/skills/impeccable/reference/adapt.md | 6 ++++++ .dsh/skills/impeccable/reference/audit.md | 3 ++- .dsh/skills/impeccable/reference/harden.md | 9 +++++++++ .gemini/skills/impeccable/reference/adapt.md | 6 ++++++ .gemini/skills/impeccable/reference/audit.md | 3 ++- .gemini/skills/impeccable/reference/harden.md | 9 +++++++++ .github/skills/impeccable/reference/adapt.md | 6 ++++++ .github/skills/impeccable/reference/audit.md | 3 ++- .github/skills/impeccable/reference/harden.md | 9 +++++++++ .grok/skills/impeccable/reference/adapt.md | 6 ++++++ .grok/skills/impeccable/reference/audit.md | 3 ++- .grok/skills/impeccable/reference/harden.md | 9 +++++++++ .hermes/skills/impeccable/reference/adapt.md | 6 ++++++ .hermes/skills/impeccable/reference/audit.md | 3 ++- .hermes/skills/impeccable/reference/harden.md | 9 +++++++++ .kiro/skills/impeccable/reference/adapt.md | 6 ++++++ .kiro/skills/impeccable/reference/audit.md | 3 ++- .kiro/skills/impeccable/reference/harden.md | 9 +++++++++ .opencode/skills/impeccable/reference/adapt.md | 6 ++++++ .opencode/skills/impeccable/reference/audit.md | 3 ++- .opencode/skills/impeccable/reference/harden.md | 9 +++++++++ .pi/skills/impeccable/reference/adapt.md | 6 ++++++ .pi/skills/impeccable/reference/audit.md | 3 ++- .pi/skills/impeccable/reference/harden.md | 9 +++++++++ .qoder/skills/impeccable/reference/adapt.md | 6 ++++++ .qoder/skills/impeccable/reference/audit.md | 3 ++- .qoder/skills/impeccable/reference/harden.md | 9 +++++++++ .rovodev/skills/impeccable/reference/adapt.md | 6 ++++++ .rovodev/skills/impeccable/reference/audit.md | 3 ++- .rovodev/skills/impeccable/reference/harden.md | 9 +++++++++ .trae-cn/skills/impeccable/reference/adapt.md | 6 ++++++ .trae-cn/skills/impeccable/reference/audit.md | 3 ++- .trae-cn/skills/impeccable/reference/harden.md | 9 +++++++++ .trae/skills/impeccable/reference/adapt.md | 6 ++++++ .trae/skills/impeccable/reference/audit.md | 3 ++- .trae/skills/impeccable/reference/harden.md | 9 +++++++++ .veto/skills/impeccable/reference/adapt.md | 6 ++++++ .veto/skills/impeccable/reference/audit.md | 3 ++- .veto/skills/impeccable/reference/harden.md | 9 +++++++++ .vibe/skills/impeccable/reference/adapt.md | 6 ++++++ .vibe/skills/impeccable/reference/audit.md | 3 ++- .vibe/skills/impeccable/reference/harden.md | 9 +++++++++ cursor-plugin/skills/impeccable/reference/adapt.md | 6 ++++++ cursor-plugin/skills/impeccable/reference/audit.md | 3 ++- cursor-plugin/skills/impeccable/reference/harden.md | 9 +++++++++ plugin/skills/impeccable/reference/adapt.md | 6 ++++++ plugin/skills/impeccable/reference/audit.md | 3 ++- plugin/skills/impeccable/reference/harden.md | 9 +++++++++ 60 files changed, 340 insertions(+), 20 deletions(-) diff --git a/.agent/skills/impeccable/reference/adapt.md b/.agent/skills/impeccable/reference/adapt.md index 7f76bbbb4..58d54aa3e 100644 --- a/.agent/skills/impeccable/reference/adapt.md +++ b/.agent/skills/impeccable/reference/adapt.md @@ -188,6 +188,12 @@ Test thoroughly across contexts: - **Edge cases**: Very small screens (320px), very large screens (4K) - **Slow connections**: Test on throttled network +**Custom controls** (sliders, drag surfaces, scrollable control strips): a before/after slider can pass every width check above and still refuse to drag on iOS, so exercise each one in scope in the same batched round as the checks above: + +- **Primary gesture**: Tap it and confirm it responds as designed, then drag it with the target input method; the drag must complete, not just start +- **Scroll across it**: A swipe along the page's scroll axis across the control scrolls the page or container without activating it; a drag that starts on the control along its axis moves the control, not the page. Neither failure throws an error, so try both +- **Evidence**: Say what produced the evidence: an emulated viewport, synthesized touch input through a browser tool, which engine ran it (Chromium is not Safari), or a physical device. Screenshots and resized viewports verify layout, never a gesture. Name what stayed untested and move on; unreachable hardware is a reported gap, not a blocker + When the adaptation feels native to each context, hand off to `/impeccable polish` for the final pass. --- diff --git a/.agent/skills/impeccable/reference/audit.md b/.agent/skills/impeccable/reference/audit.md index 474af4154..98c56d066 100644 --- a/.agent/skills/impeccable/reference/audit.md +++ b/.agent/skills/impeccable/reference/audit.md @@ -48,11 +48,12 @@ Run comprehensive checks across 5 dimensions. Score each dimension 0-4 using the **Check for**: - **Fixed widths**: Hard-coded widths that break on mobile - **Touch targets**: Interactive elements < 44x44px +- **Broken touch interaction**: Custom sliders, drag surfaces, and scrollable control strips whose primary gesture fails under touch, that swallow page scroll or lose the drag to it, or that stay stuck after an interrupted gesture. Code tells: mouse-only handlers, no `touch-action` on a pointer-event drag surface, drag state that nothing clears on cancel, lost capture, or blur. Exercise the gesture when a browser tool can synthesize touch (a rendered viewport proves layout, not the gesture), then say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and what stayed untested - **Horizontal scroll**: Content overflow on narrow viewports - **Text scaling**: Layouts that break when text size increases - **Missing breakpoints**: No mobile/tablet variants -**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets) +**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets, gestures work under touch) ### 5. Implementation Integrity (CRITICAL) diff --git a/.agent/skills/impeccable/reference/harden.md b/.agent/skills/impeccable/reference/harden.md index 46ca8a7c3..cbe2941e5 100644 --- a/.agent/skills/impeccable/reference/harden.md +++ b/.agent/skills/impeccable/reference/harden.md @@ -205,6 +205,11 @@ t('items', { count }) // Handles complex plural rules - Optimistic updates with rollback - Conflict resolution +**Interrupted gestures** (custom sliders, drag surfaces, scrollable control strips): +- A second finger or pointer lands mid-drag: the first drag keeps its pointer or ends cleanly, never jumps to the new one +- The browser cancels the gesture to scroll (`pointercancel`), capture is lost (`lostpointercapture`), the pointer is released outside the control, or the window loses focus (`blur`) mid-drag: clear the dragging state and release capture +- After each of these, the next tap or drag works without a reload + **Permission states**: - No permission to view - No permission to edit @@ -304,6 +309,7 @@ const throttledScroll = throttle(handleScroll, 100); - Unit tests for edge cases - Integration tests for error scenarios - E2E tests for critical paths +- A behavioral regression for each confirmed gesture fix, when the project's test runner can drive input - Visual regression tests - Accessibility tests (axe, WAVE) @@ -330,7 +336,10 @@ Test thoroughly with edge cases: - **Network issues**: Disable internet, throttle connection - **Large datasets**: Test with 1000+ items - **Concurrent actions**: Click submit 10 times rapidly +- **Interrupted gestures**: Add a second finger mid-drag, scroll across the control, release outside it, switch windows mid-drag; then drag again - **Errors**: Force API errors, test all error states - **Empty**: Remove all data, test empty states +For gestures, say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and name what stayed untested. + When edge cases are covered, hand off to `/impeccable polish` for the final pass. diff --git a/.agents/skills/impeccable/reference/adapt.md b/.agents/skills/impeccable/reference/adapt.md index 314d11f1c..85f7c022f 100644 --- a/.agents/skills/impeccable/reference/adapt.md +++ b/.agents/skills/impeccable/reference/adapt.md @@ -188,6 +188,12 @@ Test thoroughly across contexts: - **Edge cases**: Very small screens (320px), very large screens (4K) - **Slow connections**: Test on throttled network +**Custom controls** (sliders, drag surfaces, scrollable control strips): a before/after slider can pass every width check above and still refuse to drag on iOS, so exercise each one in scope in the same batched round as the checks above: + +- **Primary gesture**: Tap it and confirm it responds as designed, then drag it with the target input method; the drag must complete, not just start +- **Scroll across it**: A swipe along the page's scroll axis across the control scrolls the page or container without activating it; a drag that starts on the control along its axis moves the control, not the page. Neither failure throws an error, so try both +- **Evidence**: Say what produced the evidence: an emulated viewport, synthesized touch input through a browser tool, which engine ran it (Chromium is not Safari), or a physical device. Screenshots and resized viewports verify layout, never a gesture. Name what stayed untested and move on; unreachable hardware is a reported gap, not a blocker + When the adaptation feels native to each context, hand off to `$impeccable polish` for the final pass. --- diff --git a/.agents/skills/impeccable/reference/audit.md b/.agents/skills/impeccable/reference/audit.md index b6a0bb358..0af13e165 100644 --- a/.agents/skills/impeccable/reference/audit.md +++ b/.agents/skills/impeccable/reference/audit.md @@ -48,11 +48,12 @@ Run comprehensive checks across 5 dimensions. Score each dimension 0-4 using the **Check for**: - **Fixed widths**: Hard-coded widths that break on mobile - **Touch targets**: Interactive elements < 44x44px +- **Broken touch interaction**: Custom sliders, drag surfaces, and scrollable control strips whose primary gesture fails under touch, that swallow page scroll or lose the drag to it, or that stay stuck after an interrupted gesture. Code tells: mouse-only handlers, no `touch-action` on a pointer-event drag surface, drag state that nothing clears on cancel, lost capture, or blur. Exercise the gesture when a browser tool can synthesize touch (a rendered viewport proves layout, not the gesture), then say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and what stayed untested - **Horizontal scroll**: Content overflow on narrow viewports - **Text scaling**: Layouts that break when text size increases - **Missing breakpoints**: No mobile/tablet variants -**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets) +**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets, gestures work under touch) ### 5. Implementation Integrity (CRITICAL) diff --git a/.agents/skills/impeccable/reference/harden.md b/.agents/skills/impeccable/reference/harden.md index 0bbb16499..124742e1c 100644 --- a/.agents/skills/impeccable/reference/harden.md +++ b/.agents/skills/impeccable/reference/harden.md @@ -205,6 +205,11 @@ t('items', { count }) // Handles complex plural rules - Optimistic updates with rollback - Conflict resolution +**Interrupted gestures** (custom sliders, drag surfaces, scrollable control strips): +- A second finger or pointer lands mid-drag: the first drag keeps its pointer or ends cleanly, never jumps to the new one +- The browser cancels the gesture to scroll (`pointercancel`), capture is lost (`lostpointercapture`), the pointer is released outside the control, or the window loses focus (`blur`) mid-drag: clear the dragging state and release capture +- After each of these, the next tap or drag works without a reload + **Permission states**: - No permission to view - No permission to edit @@ -304,6 +309,7 @@ const throttledScroll = throttle(handleScroll, 100); - Unit tests for edge cases - Integration tests for error scenarios - E2E tests for critical paths +- A behavioral regression for each confirmed gesture fix, when the project's test runner can drive input - Visual regression tests - Accessibility tests (axe, WAVE) @@ -330,7 +336,10 @@ Test thoroughly with edge cases: - **Network issues**: Disable internet, throttle connection - **Large datasets**: Test with 1000+ items - **Concurrent actions**: Click submit 10 times rapidly +- **Interrupted gestures**: Add a second finger mid-drag, scroll across the control, release outside it, switch windows mid-drag; then drag again - **Errors**: Force API errors, test all error states - **Empty**: Remove all data, test empty states +For gestures, say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and name what stayed untested. + When edge cases are covered, hand off to `$impeccable polish` for the final pass. diff --git a/.claude/skills/impeccable/reference/adapt.md b/.claude/skills/impeccable/reference/adapt.md index 7f76bbbb4..58d54aa3e 100644 --- a/.claude/skills/impeccable/reference/adapt.md +++ b/.claude/skills/impeccable/reference/adapt.md @@ -188,6 +188,12 @@ Test thoroughly across contexts: - **Edge cases**: Very small screens (320px), very large screens (4K) - **Slow connections**: Test on throttled network +**Custom controls** (sliders, drag surfaces, scrollable control strips): a before/after slider can pass every width check above and still refuse to drag on iOS, so exercise each one in scope in the same batched round as the checks above: + +- **Primary gesture**: Tap it and confirm it responds as designed, then drag it with the target input method; the drag must complete, not just start +- **Scroll across it**: A swipe along the page's scroll axis across the control scrolls the page or container without activating it; a drag that starts on the control along its axis moves the control, not the page. Neither failure throws an error, so try both +- **Evidence**: Say what produced the evidence: an emulated viewport, synthesized touch input through a browser tool, which engine ran it (Chromium is not Safari), or a physical device. Screenshots and resized viewports verify layout, never a gesture. Name what stayed untested and move on; unreachable hardware is a reported gap, not a blocker + When the adaptation feels native to each context, hand off to `/impeccable polish` for the final pass. --- diff --git a/.claude/skills/impeccable/reference/audit.md b/.claude/skills/impeccable/reference/audit.md index 474af4154..98c56d066 100644 --- a/.claude/skills/impeccable/reference/audit.md +++ b/.claude/skills/impeccable/reference/audit.md @@ -48,11 +48,12 @@ Run comprehensive checks across 5 dimensions. Score each dimension 0-4 using the **Check for**: - **Fixed widths**: Hard-coded widths that break on mobile - **Touch targets**: Interactive elements < 44x44px +- **Broken touch interaction**: Custom sliders, drag surfaces, and scrollable control strips whose primary gesture fails under touch, that swallow page scroll or lose the drag to it, or that stay stuck after an interrupted gesture. Code tells: mouse-only handlers, no `touch-action` on a pointer-event drag surface, drag state that nothing clears on cancel, lost capture, or blur. Exercise the gesture when a browser tool can synthesize touch (a rendered viewport proves layout, not the gesture), then say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and what stayed untested - **Horizontal scroll**: Content overflow on narrow viewports - **Text scaling**: Layouts that break when text size increases - **Missing breakpoints**: No mobile/tablet variants -**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets) +**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets, gestures work under touch) ### 5. Implementation Integrity (CRITICAL) diff --git a/.claude/skills/impeccable/reference/harden.md b/.claude/skills/impeccable/reference/harden.md index 46ca8a7c3..cbe2941e5 100644 --- a/.claude/skills/impeccable/reference/harden.md +++ b/.claude/skills/impeccable/reference/harden.md @@ -205,6 +205,11 @@ t('items', { count }) // Handles complex plural rules - Optimistic updates with rollback - Conflict resolution +**Interrupted gestures** (custom sliders, drag surfaces, scrollable control strips): +- A second finger or pointer lands mid-drag: the first drag keeps its pointer or ends cleanly, never jumps to the new one +- The browser cancels the gesture to scroll (`pointercancel`), capture is lost (`lostpointercapture`), the pointer is released outside the control, or the window loses focus (`blur`) mid-drag: clear the dragging state and release capture +- After each of these, the next tap or drag works without a reload + **Permission states**: - No permission to view - No permission to edit @@ -304,6 +309,7 @@ const throttledScroll = throttle(handleScroll, 100); - Unit tests for edge cases - Integration tests for error scenarios - E2E tests for critical paths +- A behavioral regression for each confirmed gesture fix, when the project's test runner can drive input - Visual regression tests - Accessibility tests (axe, WAVE) @@ -330,7 +336,10 @@ Test thoroughly with edge cases: - **Network issues**: Disable internet, throttle connection - **Large datasets**: Test with 1000+ items - **Concurrent actions**: Click submit 10 times rapidly +- **Interrupted gestures**: Add a second finger mid-drag, scroll across the control, release outside it, switch windows mid-drag; then drag again - **Errors**: Force API errors, test all error states - **Empty**: Remove all data, test empty states +For gestures, say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and name what stayed untested. + When edge cases are covered, hand off to `/impeccable polish` for the final pass. diff --git a/.cursor/skills/impeccable/reference/adapt.md b/.cursor/skills/impeccable/reference/adapt.md index 7f76bbbb4..58d54aa3e 100644 --- a/.cursor/skills/impeccable/reference/adapt.md +++ b/.cursor/skills/impeccable/reference/adapt.md @@ -188,6 +188,12 @@ Test thoroughly across contexts: - **Edge cases**: Very small screens (320px), very large screens (4K) - **Slow connections**: Test on throttled network +**Custom controls** (sliders, drag surfaces, scrollable control strips): a before/after slider can pass every width check above and still refuse to drag on iOS, so exercise each one in scope in the same batched round as the checks above: + +- **Primary gesture**: Tap it and confirm it responds as designed, then drag it with the target input method; the drag must complete, not just start +- **Scroll across it**: A swipe along the page's scroll axis across the control scrolls the page or container without activating it; a drag that starts on the control along its axis moves the control, not the page. Neither failure throws an error, so try both +- **Evidence**: Say what produced the evidence: an emulated viewport, synthesized touch input through a browser tool, which engine ran it (Chromium is not Safari), or a physical device. Screenshots and resized viewports verify layout, never a gesture. Name what stayed untested and move on; unreachable hardware is a reported gap, not a blocker + When the adaptation feels native to each context, hand off to `/impeccable polish` for the final pass. --- diff --git a/.cursor/skills/impeccable/reference/audit.md b/.cursor/skills/impeccable/reference/audit.md index 474af4154..98c56d066 100644 --- a/.cursor/skills/impeccable/reference/audit.md +++ b/.cursor/skills/impeccable/reference/audit.md @@ -48,11 +48,12 @@ Run comprehensive checks across 5 dimensions. Score each dimension 0-4 using the **Check for**: - **Fixed widths**: Hard-coded widths that break on mobile - **Touch targets**: Interactive elements < 44x44px +- **Broken touch interaction**: Custom sliders, drag surfaces, and scrollable control strips whose primary gesture fails under touch, that swallow page scroll or lose the drag to it, or that stay stuck after an interrupted gesture. Code tells: mouse-only handlers, no `touch-action` on a pointer-event drag surface, drag state that nothing clears on cancel, lost capture, or blur. Exercise the gesture when a browser tool can synthesize touch (a rendered viewport proves layout, not the gesture), then say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and what stayed untested - **Horizontal scroll**: Content overflow on narrow viewports - **Text scaling**: Layouts that break when text size increases - **Missing breakpoints**: No mobile/tablet variants -**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets) +**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets, gestures work under touch) ### 5. Implementation Integrity (CRITICAL) diff --git a/.cursor/skills/impeccable/reference/harden.md b/.cursor/skills/impeccable/reference/harden.md index 46ca8a7c3..cbe2941e5 100644 --- a/.cursor/skills/impeccable/reference/harden.md +++ b/.cursor/skills/impeccable/reference/harden.md @@ -205,6 +205,11 @@ t('items', { count }) // Handles complex plural rules - Optimistic updates with rollback - Conflict resolution +**Interrupted gestures** (custom sliders, drag surfaces, scrollable control strips): +- A second finger or pointer lands mid-drag: the first drag keeps its pointer or ends cleanly, never jumps to the new one +- The browser cancels the gesture to scroll (`pointercancel`), capture is lost (`lostpointercapture`), the pointer is released outside the control, or the window loses focus (`blur`) mid-drag: clear the dragging state and release capture +- After each of these, the next tap or drag works without a reload + **Permission states**: - No permission to view - No permission to edit @@ -304,6 +309,7 @@ const throttledScroll = throttle(handleScroll, 100); - Unit tests for edge cases - Integration tests for error scenarios - E2E tests for critical paths +- A behavioral regression for each confirmed gesture fix, when the project's test runner can drive input - Visual regression tests - Accessibility tests (axe, WAVE) @@ -330,7 +336,10 @@ Test thoroughly with edge cases: - **Network issues**: Disable internet, throttle connection - **Large datasets**: Test with 1000+ items - **Concurrent actions**: Click submit 10 times rapidly +- **Interrupted gestures**: Add a second finger mid-drag, scroll across the control, release outside it, switch windows mid-drag; then drag again - **Errors**: Force API errors, test all error states - **Empty**: Remove all data, test empty states +For gestures, say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and name what stayed untested. + When edge cases are covered, hand off to `/impeccable polish` for the final pass. diff --git a/.dsh/skills/impeccable/reference/adapt.md b/.dsh/skills/impeccable/reference/adapt.md index 7f76bbbb4..58d54aa3e 100644 --- a/.dsh/skills/impeccable/reference/adapt.md +++ b/.dsh/skills/impeccable/reference/adapt.md @@ -188,6 +188,12 @@ Test thoroughly across contexts: - **Edge cases**: Very small screens (320px), very large screens (4K) - **Slow connections**: Test on throttled network +**Custom controls** (sliders, drag surfaces, scrollable control strips): a before/after slider can pass every width check above and still refuse to drag on iOS, so exercise each one in scope in the same batched round as the checks above: + +- **Primary gesture**: Tap it and confirm it responds as designed, then drag it with the target input method; the drag must complete, not just start +- **Scroll across it**: A swipe along the page's scroll axis across the control scrolls the page or container without activating it; a drag that starts on the control along its axis moves the control, not the page. Neither failure throws an error, so try both +- **Evidence**: Say what produced the evidence: an emulated viewport, synthesized touch input through a browser tool, which engine ran it (Chromium is not Safari), or a physical device. Screenshots and resized viewports verify layout, never a gesture. Name what stayed untested and move on; unreachable hardware is a reported gap, not a blocker + When the adaptation feels native to each context, hand off to `/impeccable polish` for the final pass. --- diff --git a/.dsh/skills/impeccable/reference/audit.md b/.dsh/skills/impeccable/reference/audit.md index 474af4154..98c56d066 100644 --- a/.dsh/skills/impeccable/reference/audit.md +++ b/.dsh/skills/impeccable/reference/audit.md @@ -48,11 +48,12 @@ Run comprehensive checks across 5 dimensions. Score each dimension 0-4 using the **Check for**: - **Fixed widths**: Hard-coded widths that break on mobile - **Touch targets**: Interactive elements < 44x44px +- **Broken touch interaction**: Custom sliders, drag surfaces, and scrollable control strips whose primary gesture fails under touch, that swallow page scroll or lose the drag to it, or that stay stuck after an interrupted gesture. Code tells: mouse-only handlers, no `touch-action` on a pointer-event drag surface, drag state that nothing clears on cancel, lost capture, or blur. Exercise the gesture when a browser tool can synthesize touch (a rendered viewport proves layout, not the gesture), then say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and what stayed untested - **Horizontal scroll**: Content overflow on narrow viewports - **Text scaling**: Layouts that break when text size increases - **Missing breakpoints**: No mobile/tablet variants -**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets) +**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets, gestures work under touch) ### 5. Implementation Integrity (CRITICAL) diff --git a/.dsh/skills/impeccable/reference/harden.md b/.dsh/skills/impeccable/reference/harden.md index 46ca8a7c3..cbe2941e5 100644 --- a/.dsh/skills/impeccable/reference/harden.md +++ b/.dsh/skills/impeccable/reference/harden.md @@ -205,6 +205,11 @@ t('items', { count }) // Handles complex plural rules - Optimistic updates with rollback - Conflict resolution +**Interrupted gestures** (custom sliders, drag surfaces, scrollable control strips): +- A second finger or pointer lands mid-drag: the first drag keeps its pointer or ends cleanly, never jumps to the new one +- The browser cancels the gesture to scroll (`pointercancel`), capture is lost (`lostpointercapture`), the pointer is released outside the control, or the window loses focus (`blur`) mid-drag: clear the dragging state and release capture +- After each of these, the next tap or drag works without a reload + **Permission states**: - No permission to view - No permission to edit @@ -304,6 +309,7 @@ const throttledScroll = throttle(handleScroll, 100); - Unit tests for edge cases - Integration tests for error scenarios - E2E tests for critical paths +- A behavioral regression for each confirmed gesture fix, when the project's test runner can drive input - Visual regression tests - Accessibility tests (axe, WAVE) @@ -330,7 +336,10 @@ Test thoroughly with edge cases: - **Network issues**: Disable internet, throttle connection - **Large datasets**: Test with 1000+ items - **Concurrent actions**: Click submit 10 times rapidly +- **Interrupted gestures**: Add a second finger mid-drag, scroll across the control, release outside it, switch windows mid-drag; then drag again - **Errors**: Force API errors, test all error states - **Empty**: Remove all data, test empty states +For gestures, say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and name what stayed untested. + When edge cases are covered, hand off to `/impeccable polish` for the final pass. diff --git a/.gemini/skills/impeccable/reference/adapt.md b/.gemini/skills/impeccable/reference/adapt.md index 7f76bbbb4..58d54aa3e 100644 --- a/.gemini/skills/impeccable/reference/adapt.md +++ b/.gemini/skills/impeccable/reference/adapt.md @@ -188,6 +188,12 @@ Test thoroughly across contexts: - **Edge cases**: Very small screens (320px), very large screens (4K) - **Slow connections**: Test on throttled network +**Custom controls** (sliders, drag surfaces, scrollable control strips): a before/after slider can pass every width check above and still refuse to drag on iOS, so exercise each one in scope in the same batched round as the checks above: + +- **Primary gesture**: Tap it and confirm it responds as designed, then drag it with the target input method; the drag must complete, not just start +- **Scroll across it**: A swipe along the page's scroll axis across the control scrolls the page or container without activating it; a drag that starts on the control along its axis moves the control, not the page. Neither failure throws an error, so try both +- **Evidence**: Say what produced the evidence: an emulated viewport, synthesized touch input through a browser tool, which engine ran it (Chromium is not Safari), or a physical device. Screenshots and resized viewports verify layout, never a gesture. Name what stayed untested and move on; unreachable hardware is a reported gap, not a blocker + When the adaptation feels native to each context, hand off to `/impeccable polish` for the final pass. --- diff --git a/.gemini/skills/impeccable/reference/audit.md b/.gemini/skills/impeccable/reference/audit.md index 474af4154..98c56d066 100644 --- a/.gemini/skills/impeccable/reference/audit.md +++ b/.gemini/skills/impeccable/reference/audit.md @@ -48,11 +48,12 @@ Run comprehensive checks across 5 dimensions. Score each dimension 0-4 using the **Check for**: - **Fixed widths**: Hard-coded widths that break on mobile - **Touch targets**: Interactive elements < 44x44px +- **Broken touch interaction**: Custom sliders, drag surfaces, and scrollable control strips whose primary gesture fails under touch, that swallow page scroll or lose the drag to it, or that stay stuck after an interrupted gesture. Code tells: mouse-only handlers, no `touch-action` on a pointer-event drag surface, drag state that nothing clears on cancel, lost capture, or blur. Exercise the gesture when a browser tool can synthesize touch (a rendered viewport proves layout, not the gesture), then say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and what stayed untested - **Horizontal scroll**: Content overflow on narrow viewports - **Text scaling**: Layouts that break when text size increases - **Missing breakpoints**: No mobile/tablet variants -**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets) +**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets, gestures work under touch) ### 5. Implementation Integrity (CRITICAL) diff --git a/.gemini/skills/impeccable/reference/harden.md b/.gemini/skills/impeccable/reference/harden.md index 46ca8a7c3..cbe2941e5 100644 --- a/.gemini/skills/impeccable/reference/harden.md +++ b/.gemini/skills/impeccable/reference/harden.md @@ -205,6 +205,11 @@ t('items', { count }) // Handles complex plural rules - Optimistic updates with rollback - Conflict resolution +**Interrupted gestures** (custom sliders, drag surfaces, scrollable control strips): +- A second finger or pointer lands mid-drag: the first drag keeps its pointer or ends cleanly, never jumps to the new one +- The browser cancels the gesture to scroll (`pointercancel`), capture is lost (`lostpointercapture`), the pointer is released outside the control, or the window loses focus (`blur`) mid-drag: clear the dragging state and release capture +- After each of these, the next tap or drag works without a reload + **Permission states**: - No permission to view - No permission to edit @@ -304,6 +309,7 @@ const throttledScroll = throttle(handleScroll, 100); - Unit tests for edge cases - Integration tests for error scenarios - E2E tests for critical paths +- A behavioral regression for each confirmed gesture fix, when the project's test runner can drive input - Visual regression tests - Accessibility tests (axe, WAVE) @@ -330,7 +336,10 @@ Test thoroughly with edge cases: - **Network issues**: Disable internet, throttle connection - **Large datasets**: Test with 1000+ items - **Concurrent actions**: Click submit 10 times rapidly +- **Interrupted gestures**: Add a second finger mid-drag, scroll across the control, release outside it, switch windows mid-drag; then drag again - **Errors**: Force API errors, test all error states - **Empty**: Remove all data, test empty states +For gestures, say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and name what stayed untested. + When edge cases are covered, hand off to `/impeccable polish` for the final pass. diff --git a/.github/skills/impeccable/reference/adapt.md b/.github/skills/impeccable/reference/adapt.md index 7f76bbbb4..58d54aa3e 100644 --- a/.github/skills/impeccable/reference/adapt.md +++ b/.github/skills/impeccable/reference/adapt.md @@ -188,6 +188,12 @@ Test thoroughly across contexts: - **Edge cases**: Very small screens (320px), very large screens (4K) - **Slow connections**: Test on throttled network +**Custom controls** (sliders, drag surfaces, scrollable control strips): a before/after slider can pass every width check above and still refuse to drag on iOS, so exercise each one in scope in the same batched round as the checks above: + +- **Primary gesture**: Tap it and confirm it responds as designed, then drag it with the target input method; the drag must complete, not just start +- **Scroll across it**: A swipe along the page's scroll axis across the control scrolls the page or container without activating it; a drag that starts on the control along its axis moves the control, not the page. Neither failure throws an error, so try both +- **Evidence**: Say what produced the evidence: an emulated viewport, synthesized touch input through a browser tool, which engine ran it (Chromium is not Safari), or a physical device. Screenshots and resized viewports verify layout, never a gesture. Name what stayed untested and move on; unreachable hardware is a reported gap, not a blocker + When the adaptation feels native to each context, hand off to `/impeccable polish` for the final pass. --- diff --git a/.github/skills/impeccable/reference/audit.md b/.github/skills/impeccable/reference/audit.md index 474af4154..98c56d066 100644 --- a/.github/skills/impeccable/reference/audit.md +++ b/.github/skills/impeccable/reference/audit.md @@ -48,11 +48,12 @@ Run comprehensive checks across 5 dimensions. Score each dimension 0-4 using the **Check for**: - **Fixed widths**: Hard-coded widths that break on mobile - **Touch targets**: Interactive elements < 44x44px +- **Broken touch interaction**: Custom sliders, drag surfaces, and scrollable control strips whose primary gesture fails under touch, that swallow page scroll or lose the drag to it, or that stay stuck after an interrupted gesture. Code tells: mouse-only handlers, no `touch-action` on a pointer-event drag surface, drag state that nothing clears on cancel, lost capture, or blur. Exercise the gesture when a browser tool can synthesize touch (a rendered viewport proves layout, not the gesture), then say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and what stayed untested - **Horizontal scroll**: Content overflow on narrow viewports - **Text scaling**: Layouts that break when text size increases - **Missing breakpoints**: No mobile/tablet variants -**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets) +**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets, gestures work under touch) ### 5. Implementation Integrity (CRITICAL) diff --git a/.github/skills/impeccable/reference/harden.md b/.github/skills/impeccable/reference/harden.md index 46ca8a7c3..cbe2941e5 100644 --- a/.github/skills/impeccable/reference/harden.md +++ b/.github/skills/impeccable/reference/harden.md @@ -205,6 +205,11 @@ t('items', { count }) // Handles complex plural rules - Optimistic updates with rollback - Conflict resolution +**Interrupted gestures** (custom sliders, drag surfaces, scrollable control strips): +- A second finger or pointer lands mid-drag: the first drag keeps its pointer or ends cleanly, never jumps to the new one +- The browser cancels the gesture to scroll (`pointercancel`), capture is lost (`lostpointercapture`), the pointer is released outside the control, or the window loses focus (`blur`) mid-drag: clear the dragging state and release capture +- After each of these, the next tap or drag works without a reload + **Permission states**: - No permission to view - No permission to edit @@ -304,6 +309,7 @@ const throttledScroll = throttle(handleScroll, 100); - Unit tests for edge cases - Integration tests for error scenarios - E2E tests for critical paths +- A behavioral regression for each confirmed gesture fix, when the project's test runner can drive input - Visual regression tests - Accessibility tests (axe, WAVE) @@ -330,7 +336,10 @@ Test thoroughly with edge cases: - **Network issues**: Disable internet, throttle connection - **Large datasets**: Test with 1000+ items - **Concurrent actions**: Click submit 10 times rapidly +- **Interrupted gestures**: Add a second finger mid-drag, scroll across the control, release outside it, switch windows mid-drag; then drag again - **Errors**: Force API errors, test all error states - **Empty**: Remove all data, test empty states +For gestures, say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and name what stayed untested. + When edge cases are covered, hand off to `/impeccable polish` for the final pass. diff --git a/.grok/skills/impeccable/reference/adapt.md b/.grok/skills/impeccable/reference/adapt.md index 7f76bbbb4..58d54aa3e 100644 --- a/.grok/skills/impeccable/reference/adapt.md +++ b/.grok/skills/impeccable/reference/adapt.md @@ -188,6 +188,12 @@ Test thoroughly across contexts: - **Edge cases**: Very small screens (320px), very large screens (4K) - **Slow connections**: Test on throttled network +**Custom controls** (sliders, drag surfaces, scrollable control strips): a before/after slider can pass every width check above and still refuse to drag on iOS, so exercise each one in scope in the same batched round as the checks above: + +- **Primary gesture**: Tap it and confirm it responds as designed, then drag it with the target input method; the drag must complete, not just start +- **Scroll across it**: A swipe along the page's scroll axis across the control scrolls the page or container without activating it; a drag that starts on the control along its axis moves the control, not the page. Neither failure throws an error, so try both +- **Evidence**: Say what produced the evidence: an emulated viewport, synthesized touch input through a browser tool, which engine ran it (Chromium is not Safari), or a physical device. Screenshots and resized viewports verify layout, never a gesture. Name what stayed untested and move on; unreachable hardware is a reported gap, not a blocker + When the adaptation feels native to each context, hand off to `/impeccable polish` for the final pass. --- diff --git a/.grok/skills/impeccable/reference/audit.md b/.grok/skills/impeccable/reference/audit.md index 474af4154..98c56d066 100644 --- a/.grok/skills/impeccable/reference/audit.md +++ b/.grok/skills/impeccable/reference/audit.md @@ -48,11 +48,12 @@ Run comprehensive checks across 5 dimensions. Score each dimension 0-4 using the **Check for**: - **Fixed widths**: Hard-coded widths that break on mobile - **Touch targets**: Interactive elements < 44x44px +- **Broken touch interaction**: Custom sliders, drag surfaces, and scrollable control strips whose primary gesture fails under touch, that swallow page scroll or lose the drag to it, or that stay stuck after an interrupted gesture. Code tells: mouse-only handlers, no `touch-action` on a pointer-event drag surface, drag state that nothing clears on cancel, lost capture, or blur. Exercise the gesture when a browser tool can synthesize touch (a rendered viewport proves layout, not the gesture), then say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and what stayed untested - **Horizontal scroll**: Content overflow on narrow viewports - **Text scaling**: Layouts that break when text size increases - **Missing breakpoints**: No mobile/tablet variants -**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets) +**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets, gestures work under touch) ### 5. Implementation Integrity (CRITICAL) diff --git a/.grok/skills/impeccable/reference/harden.md b/.grok/skills/impeccable/reference/harden.md index 46ca8a7c3..cbe2941e5 100644 --- a/.grok/skills/impeccable/reference/harden.md +++ b/.grok/skills/impeccable/reference/harden.md @@ -205,6 +205,11 @@ t('items', { count }) // Handles complex plural rules - Optimistic updates with rollback - Conflict resolution +**Interrupted gestures** (custom sliders, drag surfaces, scrollable control strips): +- A second finger or pointer lands mid-drag: the first drag keeps its pointer or ends cleanly, never jumps to the new one +- The browser cancels the gesture to scroll (`pointercancel`), capture is lost (`lostpointercapture`), the pointer is released outside the control, or the window loses focus (`blur`) mid-drag: clear the dragging state and release capture +- After each of these, the next tap or drag works without a reload + **Permission states**: - No permission to view - No permission to edit @@ -304,6 +309,7 @@ const throttledScroll = throttle(handleScroll, 100); - Unit tests for edge cases - Integration tests for error scenarios - E2E tests for critical paths +- A behavioral regression for each confirmed gesture fix, when the project's test runner can drive input - Visual regression tests - Accessibility tests (axe, WAVE) @@ -330,7 +336,10 @@ Test thoroughly with edge cases: - **Network issues**: Disable internet, throttle connection - **Large datasets**: Test with 1000+ items - **Concurrent actions**: Click submit 10 times rapidly +- **Interrupted gestures**: Add a second finger mid-drag, scroll across the control, release outside it, switch windows mid-drag; then drag again - **Errors**: Force API errors, test all error states - **Empty**: Remove all data, test empty states +For gestures, say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and name what stayed untested. + When edge cases are covered, hand off to `/impeccable polish` for the final pass. diff --git a/.hermes/skills/impeccable/reference/adapt.md b/.hermes/skills/impeccable/reference/adapt.md index 7f76bbbb4..58d54aa3e 100644 --- a/.hermes/skills/impeccable/reference/adapt.md +++ b/.hermes/skills/impeccable/reference/adapt.md @@ -188,6 +188,12 @@ Test thoroughly across contexts: - **Edge cases**: Very small screens (320px), very large screens (4K) - **Slow connections**: Test on throttled network +**Custom controls** (sliders, drag surfaces, scrollable control strips): a before/after slider can pass every width check above and still refuse to drag on iOS, so exercise each one in scope in the same batched round as the checks above: + +- **Primary gesture**: Tap it and confirm it responds as designed, then drag it with the target input method; the drag must complete, not just start +- **Scroll across it**: A swipe along the page's scroll axis across the control scrolls the page or container without activating it; a drag that starts on the control along its axis moves the control, not the page. Neither failure throws an error, so try both +- **Evidence**: Say what produced the evidence: an emulated viewport, synthesized touch input through a browser tool, which engine ran it (Chromium is not Safari), or a physical device. Screenshots and resized viewports verify layout, never a gesture. Name what stayed untested and move on; unreachable hardware is a reported gap, not a blocker + When the adaptation feels native to each context, hand off to `/impeccable polish` for the final pass. --- diff --git a/.hermes/skills/impeccable/reference/audit.md b/.hermes/skills/impeccable/reference/audit.md index 474af4154..98c56d066 100644 --- a/.hermes/skills/impeccable/reference/audit.md +++ b/.hermes/skills/impeccable/reference/audit.md @@ -48,11 +48,12 @@ Run comprehensive checks across 5 dimensions. Score each dimension 0-4 using the **Check for**: - **Fixed widths**: Hard-coded widths that break on mobile - **Touch targets**: Interactive elements < 44x44px +- **Broken touch interaction**: Custom sliders, drag surfaces, and scrollable control strips whose primary gesture fails under touch, that swallow page scroll or lose the drag to it, or that stay stuck after an interrupted gesture. Code tells: mouse-only handlers, no `touch-action` on a pointer-event drag surface, drag state that nothing clears on cancel, lost capture, or blur. Exercise the gesture when a browser tool can synthesize touch (a rendered viewport proves layout, not the gesture), then say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and what stayed untested - **Horizontal scroll**: Content overflow on narrow viewports - **Text scaling**: Layouts that break when text size increases - **Missing breakpoints**: No mobile/tablet variants -**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets) +**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets, gestures work under touch) ### 5. Implementation Integrity (CRITICAL) diff --git a/.hermes/skills/impeccable/reference/harden.md b/.hermes/skills/impeccable/reference/harden.md index 46ca8a7c3..cbe2941e5 100644 --- a/.hermes/skills/impeccable/reference/harden.md +++ b/.hermes/skills/impeccable/reference/harden.md @@ -205,6 +205,11 @@ t('items', { count }) // Handles complex plural rules - Optimistic updates with rollback - Conflict resolution +**Interrupted gestures** (custom sliders, drag surfaces, scrollable control strips): +- A second finger or pointer lands mid-drag: the first drag keeps its pointer or ends cleanly, never jumps to the new one +- The browser cancels the gesture to scroll (`pointercancel`), capture is lost (`lostpointercapture`), the pointer is released outside the control, or the window loses focus (`blur`) mid-drag: clear the dragging state and release capture +- After each of these, the next tap or drag works without a reload + **Permission states**: - No permission to view - No permission to edit @@ -304,6 +309,7 @@ const throttledScroll = throttle(handleScroll, 100); - Unit tests for edge cases - Integration tests for error scenarios - E2E tests for critical paths +- A behavioral regression for each confirmed gesture fix, when the project's test runner can drive input - Visual regression tests - Accessibility tests (axe, WAVE) @@ -330,7 +336,10 @@ Test thoroughly with edge cases: - **Network issues**: Disable internet, throttle connection - **Large datasets**: Test with 1000+ items - **Concurrent actions**: Click submit 10 times rapidly +- **Interrupted gestures**: Add a second finger mid-drag, scroll across the control, release outside it, switch windows mid-drag; then drag again - **Errors**: Force API errors, test all error states - **Empty**: Remove all data, test empty states +For gestures, say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and name what stayed untested. + When edge cases are covered, hand off to `/impeccable polish` for the final pass. diff --git a/.kiro/skills/impeccable/reference/adapt.md b/.kiro/skills/impeccable/reference/adapt.md index 7f76bbbb4..58d54aa3e 100644 --- a/.kiro/skills/impeccable/reference/adapt.md +++ b/.kiro/skills/impeccable/reference/adapt.md @@ -188,6 +188,12 @@ Test thoroughly across contexts: - **Edge cases**: Very small screens (320px), very large screens (4K) - **Slow connections**: Test on throttled network +**Custom controls** (sliders, drag surfaces, scrollable control strips): a before/after slider can pass every width check above and still refuse to drag on iOS, so exercise each one in scope in the same batched round as the checks above: + +- **Primary gesture**: Tap it and confirm it responds as designed, then drag it with the target input method; the drag must complete, not just start +- **Scroll across it**: A swipe along the page's scroll axis across the control scrolls the page or container without activating it; a drag that starts on the control along its axis moves the control, not the page. Neither failure throws an error, so try both +- **Evidence**: Say what produced the evidence: an emulated viewport, synthesized touch input through a browser tool, which engine ran it (Chromium is not Safari), or a physical device. Screenshots and resized viewports verify layout, never a gesture. Name what stayed untested and move on; unreachable hardware is a reported gap, not a blocker + When the adaptation feels native to each context, hand off to `/impeccable polish` for the final pass. --- diff --git a/.kiro/skills/impeccable/reference/audit.md b/.kiro/skills/impeccable/reference/audit.md index 474af4154..98c56d066 100644 --- a/.kiro/skills/impeccable/reference/audit.md +++ b/.kiro/skills/impeccable/reference/audit.md @@ -48,11 +48,12 @@ Run comprehensive checks across 5 dimensions. Score each dimension 0-4 using the **Check for**: - **Fixed widths**: Hard-coded widths that break on mobile - **Touch targets**: Interactive elements < 44x44px +- **Broken touch interaction**: Custom sliders, drag surfaces, and scrollable control strips whose primary gesture fails under touch, that swallow page scroll or lose the drag to it, or that stay stuck after an interrupted gesture. Code tells: mouse-only handlers, no `touch-action` on a pointer-event drag surface, drag state that nothing clears on cancel, lost capture, or blur. Exercise the gesture when a browser tool can synthesize touch (a rendered viewport proves layout, not the gesture), then say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and what stayed untested - **Horizontal scroll**: Content overflow on narrow viewports - **Text scaling**: Layouts that break when text size increases - **Missing breakpoints**: No mobile/tablet variants -**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets) +**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets, gestures work under touch) ### 5. Implementation Integrity (CRITICAL) diff --git a/.kiro/skills/impeccable/reference/harden.md b/.kiro/skills/impeccable/reference/harden.md index 46ca8a7c3..cbe2941e5 100644 --- a/.kiro/skills/impeccable/reference/harden.md +++ b/.kiro/skills/impeccable/reference/harden.md @@ -205,6 +205,11 @@ t('items', { count }) // Handles complex plural rules - Optimistic updates with rollback - Conflict resolution +**Interrupted gestures** (custom sliders, drag surfaces, scrollable control strips): +- A second finger or pointer lands mid-drag: the first drag keeps its pointer or ends cleanly, never jumps to the new one +- The browser cancels the gesture to scroll (`pointercancel`), capture is lost (`lostpointercapture`), the pointer is released outside the control, or the window loses focus (`blur`) mid-drag: clear the dragging state and release capture +- After each of these, the next tap or drag works without a reload + **Permission states**: - No permission to view - No permission to edit @@ -304,6 +309,7 @@ const throttledScroll = throttle(handleScroll, 100); - Unit tests for edge cases - Integration tests for error scenarios - E2E tests for critical paths +- A behavioral regression for each confirmed gesture fix, when the project's test runner can drive input - Visual regression tests - Accessibility tests (axe, WAVE) @@ -330,7 +336,10 @@ Test thoroughly with edge cases: - **Network issues**: Disable internet, throttle connection - **Large datasets**: Test with 1000+ items - **Concurrent actions**: Click submit 10 times rapidly +- **Interrupted gestures**: Add a second finger mid-drag, scroll across the control, release outside it, switch windows mid-drag; then drag again - **Errors**: Force API errors, test all error states - **Empty**: Remove all data, test empty states +For gestures, say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and name what stayed untested. + When edge cases are covered, hand off to `/impeccable polish` for the final pass. diff --git a/.opencode/skills/impeccable/reference/adapt.md b/.opencode/skills/impeccable/reference/adapt.md index 7f76bbbb4..58d54aa3e 100644 --- a/.opencode/skills/impeccable/reference/adapt.md +++ b/.opencode/skills/impeccable/reference/adapt.md @@ -188,6 +188,12 @@ Test thoroughly across contexts: - **Edge cases**: Very small screens (320px), very large screens (4K) - **Slow connections**: Test on throttled network +**Custom controls** (sliders, drag surfaces, scrollable control strips): a before/after slider can pass every width check above and still refuse to drag on iOS, so exercise each one in scope in the same batched round as the checks above: + +- **Primary gesture**: Tap it and confirm it responds as designed, then drag it with the target input method; the drag must complete, not just start +- **Scroll across it**: A swipe along the page's scroll axis across the control scrolls the page or container without activating it; a drag that starts on the control along its axis moves the control, not the page. Neither failure throws an error, so try both +- **Evidence**: Say what produced the evidence: an emulated viewport, synthesized touch input through a browser tool, which engine ran it (Chromium is not Safari), or a physical device. Screenshots and resized viewports verify layout, never a gesture. Name what stayed untested and move on; unreachable hardware is a reported gap, not a blocker + When the adaptation feels native to each context, hand off to `/impeccable polish` for the final pass. --- diff --git a/.opencode/skills/impeccable/reference/audit.md b/.opencode/skills/impeccable/reference/audit.md index 474af4154..98c56d066 100644 --- a/.opencode/skills/impeccable/reference/audit.md +++ b/.opencode/skills/impeccable/reference/audit.md @@ -48,11 +48,12 @@ Run comprehensive checks across 5 dimensions. Score each dimension 0-4 using the **Check for**: - **Fixed widths**: Hard-coded widths that break on mobile - **Touch targets**: Interactive elements < 44x44px +- **Broken touch interaction**: Custom sliders, drag surfaces, and scrollable control strips whose primary gesture fails under touch, that swallow page scroll or lose the drag to it, or that stay stuck after an interrupted gesture. Code tells: mouse-only handlers, no `touch-action` on a pointer-event drag surface, drag state that nothing clears on cancel, lost capture, or blur. Exercise the gesture when a browser tool can synthesize touch (a rendered viewport proves layout, not the gesture), then say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and what stayed untested - **Horizontal scroll**: Content overflow on narrow viewports - **Text scaling**: Layouts that break when text size increases - **Missing breakpoints**: No mobile/tablet variants -**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets) +**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets, gestures work under touch) ### 5. Implementation Integrity (CRITICAL) diff --git a/.opencode/skills/impeccable/reference/harden.md b/.opencode/skills/impeccable/reference/harden.md index 46ca8a7c3..cbe2941e5 100644 --- a/.opencode/skills/impeccable/reference/harden.md +++ b/.opencode/skills/impeccable/reference/harden.md @@ -205,6 +205,11 @@ t('items', { count }) // Handles complex plural rules - Optimistic updates with rollback - Conflict resolution +**Interrupted gestures** (custom sliders, drag surfaces, scrollable control strips): +- A second finger or pointer lands mid-drag: the first drag keeps its pointer or ends cleanly, never jumps to the new one +- The browser cancels the gesture to scroll (`pointercancel`), capture is lost (`lostpointercapture`), the pointer is released outside the control, or the window loses focus (`blur`) mid-drag: clear the dragging state and release capture +- After each of these, the next tap or drag works without a reload + **Permission states**: - No permission to view - No permission to edit @@ -304,6 +309,7 @@ const throttledScroll = throttle(handleScroll, 100); - Unit tests for edge cases - Integration tests for error scenarios - E2E tests for critical paths +- A behavioral regression for each confirmed gesture fix, when the project's test runner can drive input - Visual regression tests - Accessibility tests (axe, WAVE) @@ -330,7 +336,10 @@ Test thoroughly with edge cases: - **Network issues**: Disable internet, throttle connection - **Large datasets**: Test with 1000+ items - **Concurrent actions**: Click submit 10 times rapidly +- **Interrupted gestures**: Add a second finger mid-drag, scroll across the control, release outside it, switch windows mid-drag; then drag again - **Errors**: Force API errors, test all error states - **Empty**: Remove all data, test empty states +For gestures, say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and name what stayed untested. + When edge cases are covered, hand off to `/impeccable polish` for the final pass. diff --git a/.pi/skills/impeccable/reference/adapt.md b/.pi/skills/impeccable/reference/adapt.md index 7f76bbbb4..58d54aa3e 100644 --- a/.pi/skills/impeccable/reference/adapt.md +++ b/.pi/skills/impeccable/reference/adapt.md @@ -188,6 +188,12 @@ Test thoroughly across contexts: - **Edge cases**: Very small screens (320px), very large screens (4K) - **Slow connections**: Test on throttled network +**Custom controls** (sliders, drag surfaces, scrollable control strips): a before/after slider can pass every width check above and still refuse to drag on iOS, so exercise each one in scope in the same batched round as the checks above: + +- **Primary gesture**: Tap it and confirm it responds as designed, then drag it with the target input method; the drag must complete, not just start +- **Scroll across it**: A swipe along the page's scroll axis across the control scrolls the page or container without activating it; a drag that starts on the control along its axis moves the control, not the page. Neither failure throws an error, so try both +- **Evidence**: Say what produced the evidence: an emulated viewport, synthesized touch input through a browser tool, which engine ran it (Chromium is not Safari), or a physical device. Screenshots and resized viewports verify layout, never a gesture. Name what stayed untested and move on; unreachable hardware is a reported gap, not a blocker + When the adaptation feels native to each context, hand off to `/impeccable polish` for the final pass. --- diff --git a/.pi/skills/impeccable/reference/audit.md b/.pi/skills/impeccable/reference/audit.md index 474af4154..98c56d066 100644 --- a/.pi/skills/impeccable/reference/audit.md +++ b/.pi/skills/impeccable/reference/audit.md @@ -48,11 +48,12 @@ Run comprehensive checks across 5 dimensions. Score each dimension 0-4 using the **Check for**: - **Fixed widths**: Hard-coded widths that break on mobile - **Touch targets**: Interactive elements < 44x44px +- **Broken touch interaction**: Custom sliders, drag surfaces, and scrollable control strips whose primary gesture fails under touch, that swallow page scroll or lose the drag to it, or that stay stuck after an interrupted gesture. Code tells: mouse-only handlers, no `touch-action` on a pointer-event drag surface, drag state that nothing clears on cancel, lost capture, or blur. Exercise the gesture when a browser tool can synthesize touch (a rendered viewport proves layout, not the gesture), then say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and what stayed untested - **Horizontal scroll**: Content overflow on narrow viewports - **Text scaling**: Layouts that break when text size increases - **Missing breakpoints**: No mobile/tablet variants -**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets) +**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets, gestures work under touch) ### 5. Implementation Integrity (CRITICAL) diff --git a/.pi/skills/impeccable/reference/harden.md b/.pi/skills/impeccable/reference/harden.md index 46ca8a7c3..cbe2941e5 100644 --- a/.pi/skills/impeccable/reference/harden.md +++ b/.pi/skills/impeccable/reference/harden.md @@ -205,6 +205,11 @@ t('items', { count }) // Handles complex plural rules - Optimistic updates with rollback - Conflict resolution +**Interrupted gestures** (custom sliders, drag surfaces, scrollable control strips): +- A second finger or pointer lands mid-drag: the first drag keeps its pointer or ends cleanly, never jumps to the new one +- The browser cancels the gesture to scroll (`pointercancel`), capture is lost (`lostpointercapture`), the pointer is released outside the control, or the window loses focus (`blur`) mid-drag: clear the dragging state and release capture +- After each of these, the next tap or drag works without a reload + **Permission states**: - No permission to view - No permission to edit @@ -304,6 +309,7 @@ const throttledScroll = throttle(handleScroll, 100); - Unit tests for edge cases - Integration tests for error scenarios - E2E tests for critical paths +- A behavioral regression for each confirmed gesture fix, when the project's test runner can drive input - Visual regression tests - Accessibility tests (axe, WAVE) @@ -330,7 +336,10 @@ Test thoroughly with edge cases: - **Network issues**: Disable internet, throttle connection - **Large datasets**: Test with 1000+ items - **Concurrent actions**: Click submit 10 times rapidly +- **Interrupted gestures**: Add a second finger mid-drag, scroll across the control, release outside it, switch windows mid-drag; then drag again - **Errors**: Force API errors, test all error states - **Empty**: Remove all data, test empty states +For gestures, say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and name what stayed untested. + When edge cases are covered, hand off to `/impeccable polish` for the final pass. diff --git a/.qoder/skills/impeccable/reference/adapt.md b/.qoder/skills/impeccable/reference/adapt.md index 7f76bbbb4..58d54aa3e 100644 --- a/.qoder/skills/impeccable/reference/adapt.md +++ b/.qoder/skills/impeccable/reference/adapt.md @@ -188,6 +188,12 @@ Test thoroughly across contexts: - **Edge cases**: Very small screens (320px), very large screens (4K) - **Slow connections**: Test on throttled network +**Custom controls** (sliders, drag surfaces, scrollable control strips): a before/after slider can pass every width check above and still refuse to drag on iOS, so exercise each one in scope in the same batched round as the checks above: + +- **Primary gesture**: Tap it and confirm it responds as designed, then drag it with the target input method; the drag must complete, not just start +- **Scroll across it**: A swipe along the page's scroll axis across the control scrolls the page or container without activating it; a drag that starts on the control along its axis moves the control, not the page. Neither failure throws an error, so try both +- **Evidence**: Say what produced the evidence: an emulated viewport, synthesized touch input through a browser tool, which engine ran it (Chromium is not Safari), or a physical device. Screenshots and resized viewports verify layout, never a gesture. Name what stayed untested and move on; unreachable hardware is a reported gap, not a blocker + When the adaptation feels native to each context, hand off to `/impeccable polish` for the final pass. --- diff --git a/.qoder/skills/impeccable/reference/audit.md b/.qoder/skills/impeccable/reference/audit.md index 474af4154..98c56d066 100644 --- a/.qoder/skills/impeccable/reference/audit.md +++ b/.qoder/skills/impeccable/reference/audit.md @@ -48,11 +48,12 @@ Run comprehensive checks across 5 dimensions. Score each dimension 0-4 using the **Check for**: - **Fixed widths**: Hard-coded widths that break on mobile - **Touch targets**: Interactive elements < 44x44px +- **Broken touch interaction**: Custom sliders, drag surfaces, and scrollable control strips whose primary gesture fails under touch, that swallow page scroll or lose the drag to it, or that stay stuck after an interrupted gesture. Code tells: mouse-only handlers, no `touch-action` on a pointer-event drag surface, drag state that nothing clears on cancel, lost capture, or blur. Exercise the gesture when a browser tool can synthesize touch (a rendered viewport proves layout, not the gesture), then say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and what stayed untested - **Horizontal scroll**: Content overflow on narrow viewports - **Text scaling**: Layouts that break when text size increases - **Missing breakpoints**: No mobile/tablet variants -**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets) +**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets, gestures work under touch) ### 5. Implementation Integrity (CRITICAL) diff --git a/.qoder/skills/impeccable/reference/harden.md b/.qoder/skills/impeccable/reference/harden.md index 46ca8a7c3..cbe2941e5 100644 --- a/.qoder/skills/impeccable/reference/harden.md +++ b/.qoder/skills/impeccable/reference/harden.md @@ -205,6 +205,11 @@ t('items', { count }) // Handles complex plural rules - Optimistic updates with rollback - Conflict resolution +**Interrupted gestures** (custom sliders, drag surfaces, scrollable control strips): +- A second finger or pointer lands mid-drag: the first drag keeps its pointer or ends cleanly, never jumps to the new one +- The browser cancels the gesture to scroll (`pointercancel`), capture is lost (`lostpointercapture`), the pointer is released outside the control, or the window loses focus (`blur`) mid-drag: clear the dragging state and release capture +- After each of these, the next tap or drag works without a reload + **Permission states**: - No permission to view - No permission to edit @@ -304,6 +309,7 @@ const throttledScroll = throttle(handleScroll, 100); - Unit tests for edge cases - Integration tests for error scenarios - E2E tests for critical paths +- A behavioral regression for each confirmed gesture fix, when the project's test runner can drive input - Visual regression tests - Accessibility tests (axe, WAVE) @@ -330,7 +336,10 @@ Test thoroughly with edge cases: - **Network issues**: Disable internet, throttle connection - **Large datasets**: Test with 1000+ items - **Concurrent actions**: Click submit 10 times rapidly +- **Interrupted gestures**: Add a second finger mid-drag, scroll across the control, release outside it, switch windows mid-drag; then drag again - **Errors**: Force API errors, test all error states - **Empty**: Remove all data, test empty states +For gestures, say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and name what stayed untested. + When edge cases are covered, hand off to `/impeccable polish` for the final pass. diff --git a/.rovodev/skills/impeccable/reference/adapt.md b/.rovodev/skills/impeccable/reference/adapt.md index 7f76bbbb4..58d54aa3e 100644 --- a/.rovodev/skills/impeccable/reference/adapt.md +++ b/.rovodev/skills/impeccable/reference/adapt.md @@ -188,6 +188,12 @@ Test thoroughly across contexts: - **Edge cases**: Very small screens (320px), very large screens (4K) - **Slow connections**: Test on throttled network +**Custom controls** (sliders, drag surfaces, scrollable control strips): a before/after slider can pass every width check above and still refuse to drag on iOS, so exercise each one in scope in the same batched round as the checks above: + +- **Primary gesture**: Tap it and confirm it responds as designed, then drag it with the target input method; the drag must complete, not just start +- **Scroll across it**: A swipe along the page's scroll axis across the control scrolls the page or container without activating it; a drag that starts on the control along its axis moves the control, not the page. Neither failure throws an error, so try both +- **Evidence**: Say what produced the evidence: an emulated viewport, synthesized touch input through a browser tool, which engine ran it (Chromium is not Safari), or a physical device. Screenshots and resized viewports verify layout, never a gesture. Name what stayed untested and move on; unreachable hardware is a reported gap, not a blocker + When the adaptation feels native to each context, hand off to `/impeccable polish` for the final pass. --- diff --git a/.rovodev/skills/impeccable/reference/audit.md b/.rovodev/skills/impeccable/reference/audit.md index 474af4154..98c56d066 100644 --- a/.rovodev/skills/impeccable/reference/audit.md +++ b/.rovodev/skills/impeccable/reference/audit.md @@ -48,11 +48,12 @@ Run comprehensive checks across 5 dimensions. Score each dimension 0-4 using the **Check for**: - **Fixed widths**: Hard-coded widths that break on mobile - **Touch targets**: Interactive elements < 44x44px +- **Broken touch interaction**: Custom sliders, drag surfaces, and scrollable control strips whose primary gesture fails under touch, that swallow page scroll or lose the drag to it, or that stay stuck after an interrupted gesture. Code tells: mouse-only handlers, no `touch-action` on a pointer-event drag surface, drag state that nothing clears on cancel, lost capture, or blur. Exercise the gesture when a browser tool can synthesize touch (a rendered viewport proves layout, not the gesture), then say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and what stayed untested - **Horizontal scroll**: Content overflow on narrow viewports - **Text scaling**: Layouts that break when text size increases - **Missing breakpoints**: No mobile/tablet variants -**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets) +**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets, gestures work under touch) ### 5. Implementation Integrity (CRITICAL) diff --git a/.rovodev/skills/impeccable/reference/harden.md b/.rovodev/skills/impeccable/reference/harden.md index 46ca8a7c3..cbe2941e5 100644 --- a/.rovodev/skills/impeccable/reference/harden.md +++ b/.rovodev/skills/impeccable/reference/harden.md @@ -205,6 +205,11 @@ t('items', { count }) // Handles complex plural rules - Optimistic updates with rollback - Conflict resolution +**Interrupted gestures** (custom sliders, drag surfaces, scrollable control strips): +- A second finger or pointer lands mid-drag: the first drag keeps its pointer or ends cleanly, never jumps to the new one +- The browser cancels the gesture to scroll (`pointercancel`), capture is lost (`lostpointercapture`), the pointer is released outside the control, or the window loses focus (`blur`) mid-drag: clear the dragging state and release capture +- After each of these, the next tap or drag works without a reload + **Permission states**: - No permission to view - No permission to edit @@ -304,6 +309,7 @@ const throttledScroll = throttle(handleScroll, 100); - Unit tests for edge cases - Integration tests for error scenarios - E2E tests for critical paths +- A behavioral regression for each confirmed gesture fix, when the project's test runner can drive input - Visual regression tests - Accessibility tests (axe, WAVE) @@ -330,7 +336,10 @@ Test thoroughly with edge cases: - **Network issues**: Disable internet, throttle connection - **Large datasets**: Test with 1000+ items - **Concurrent actions**: Click submit 10 times rapidly +- **Interrupted gestures**: Add a second finger mid-drag, scroll across the control, release outside it, switch windows mid-drag; then drag again - **Errors**: Force API errors, test all error states - **Empty**: Remove all data, test empty states +For gestures, say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and name what stayed untested. + When edge cases are covered, hand off to `/impeccable polish` for the final pass. diff --git a/.trae-cn/skills/impeccable/reference/adapt.md b/.trae-cn/skills/impeccable/reference/adapt.md index 7f76bbbb4..58d54aa3e 100644 --- a/.trae-cn/skills/impeccable/reference/adapt.md +++ b/.trae-cn/skills/impeccable/reference/adapt.md @@ -188,6 +188,12 @@ Test thoroughly across contexts: - **Edge cases**: Very small screens (320px), very large screens (4K) - **Slow connections**: Test on throttled network +**Custom controls** (sliders, drag surfaces, scrollable control strips): a before/after slider can pass every width check above and still refuse to drag on iOS, so exercise each one in scope in the same batched round as the checks above: + +- **Primary gesture**: Tap it and confirm it responds as designed, then drag it with the target input method; the drag must complete, not just start +- **Scroll across it**: A swipe along the page's scroll axis across the control scrolls the page or container without activating it; a drag that starts on the control along its axis moves the control, not the page. Neither failure throws an error, so try both +- **Evidence**: Say what produced the evidence: an emulated viewport, synthesized touch input through a browser tool, which engine ran it (Chromium is not Safari), or a physical device. Screenshots and resized viewports verify layout, never a gesture. Name what stayed untested and move on; unreachable hardware is a reported gap, not a blocker + When the adaptation feels native to each context, hand off to `/impeccable polish` for the final pass. --- diff --git a/.trae-cn/skills/impeccable/reference/audit.md b/.trae-cn/skills/impeccable/reference/audit.md index 474af4154..98c56d066 100644 --- a/.trae-cn/skills/impeccable/reference/audit.md +++ b/.trae-cn/skills/impeccable/reference/audit.md @@ -48,11 +48,12 @@ Run comprehensive checks across 5 dimensions. Score each dimension 0-4 using the **Check for**: - **Fixed widths**: Hard-coded widths that break on mobile - **Touch targets**: Interactive elements < 44x44px +- **Broken touch interaction**: Custom sliders, drag surfaces, and scrollable control strips whose primary gesture fails under touch, that swallow page scroll or lose the drag to it, or that stay stuck after an interrupted gesture. Code tells: mouse-only handlers, no `touch-action` on a pointer-event drag surface, drag state that nothing clears on cancel, lost capture, or blur. Exercise the gesture when a browser tool can synthesize touch (a rendered viewport proves layout, not the gesture), then say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and what stayed untested - **Horizontal scroll**: Content overflow on narrow viewports - **Text scaling**: Layouts that break when text size increases - **Missing breakpoints**: No mobile/tablet variants -**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets) +**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets, gestures work under touch) ### 5. Implementation Integrity (CRITICAL) diff --git a/.trae-cn/skills/impeccable/reference/harden.md b/.trae-cn/skills/impeccable/reference/harden.md index 46ca8a7c3..cbe2941e5 100644 --- a/.trae-cn/skills/impeccable/reference/harden.md +++ b/.trae-cn/skills/impeccable/reference/harden.md @@ -205,6 +205,11 @@ t('items', { count }) // Handles complex plural rules - Optimistic updates with rollback - Conflict resolution +**Interrupted gestures** (custom sliders, drag surfaces, scrollable control strips): +- A second finger or pointer lands mid-drag: the first drag keeps its pointer or ends cleanly, never jumps to the new one +- The browser cancels the gesture to scroll (`pointercancel`), capture is lost (`lostpointercapture`), the pointer is released outside the control, or the window loses focus (`blur`) mid-drag: clear the dragging state and release capture +- After each of these, the next tap or drag works without a reload + **Permission states**: - No permission to view - No permission to edit @@ -304,6 +309,7 @@ const throttledScroll = throttle(handleScroll, 100); - Unit tests for edge cases - Integration tests for error scenarios - E2E tests for critical paths +- A behavioral regression for each confirmed gesture fix, when the project's test runner can drive input - Visual regression tests - Accessibility tests (axe, WAVE) @@ -330,7 +336,10 @@ Test thoroughly with edge cases: - **Network issues**: Disable internet, throttle connection - **Large datasets**: Test with 1000+ items - **Concurrent actions**: Click submit 10 times rapidly +- **Interrupted gestures**: Add a second finger mid-drag, scroll across the control, release outside it, switch windows mid-drag; then drag again - **Errors**: Force API errors, test all error states - **Empty**: Remove all data, test empty states +For gestures, say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and name what stayed untested. + When edge cases are covered, hand off to `/impeccable polish` for the final pass. diff --git a/.trae/skills/impeccable/reference/adapt.md b/.trae/skills/impeccable/reference/adapt.md index 7f76bbbb4..58d54aa3e 100644 --- a/.trae/skills/impeccable/reference/adapt.md +++ b/.trae/skills/impeccable/reference/adapt.md @@ -188,6 +188,12 @@ Test thoroughly across contexts: - **Edge cases**: Very small screens (320px), very large screens (4K) - **Slow connections**: Test on throttled network +**Custom controls** (sliders, drag surfaces, scrollable control strips): a before/after slider can pass every width check above and still refuse to drag on iOS, so exercise each one in scope in the same batched round as the checks above: + +- **Primary gesture**: Tap it and confirm it responds as designed, then drag it with the target input method; the drag must complete, not just start +- **Scroll across it**: A swipe along the page's scroll axis across the control scrolls the page or container without activating it; a drag that starts on the control along its axis moves the control, not the page. Neither failure throws an error, so try both +- **Evidence**: Say what produced the evidence: an emulated viewport, synthesized touch input through a browser tool, which engine ran it (Chromium is not Safari), or a physical device. Screenshots and resized viewports verify layout, never a gesture. Name what stayed untested and move on; unreachable hardware is a reported gap, not a blocker + When the adaptation feels native to each context, hand off to `/impeccable polish` for the final pass. --- diff --git a/.trae/skills/impeccable/reference/audit.md b/.trae/skills/impeccable/reference/audit.md index 474af4154..98c56d066 100644 --- a/.trae/skills/impeccable/reference/audit.md +++ b/.trae/skills/impeccable/reference/audit.md @@ -48,11 +48,12 @@ Run comprehensive checks across 5 dimensions. Score each dimension 0-4 using the **Check for**: - **Fixed widths**: Hard-coded widths that break on mobile - **Touch targets**: Interactive elements < 44x44px +- **Broken touch interaction**: Custom sliders, drag surfaces, and scrollable control strips whose primary gesture fails under touch, that swallow page scroll or lose the drag to it, or that stay stuck after an interrupted gesture. Code tells: mouse-only handlers, no `touch-action` on a pointer-event drag surface, drag state that nothing clears on cancel, lost capture, or blur. Exercise the gesture when a browser tool can synthesize touch (a rendered viewport proves layout, not the gesture), then say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and what stayed untested - **Horizontal scroll**: Content overflow on narrow viewports - **Text scaling**: Layouts that break when text size increases - **Missing breakpoints**: No mobile/tablet variants -**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets) +**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets, gestures work under touch) ### 5. Implementation Integrity (CRITICAL) diff --git a/.trae/skills/impeccable/reference/harden.md b/.trae/skills/impeccable/reference/harden.md index 46ca8a7c3..cbe2941e5 100644 --- a/.trae/skills/impeccable/reference/harden.md +++ b/.trae/skills/impeccable/reference/harden.md @@ -205,6 +205,11 @@ t('items', { count }) // Handles complex plural rules - Optimistic updates with rollback - Conflict resolution +**Interrupted gestures** (custom sliders, drag surfaces, scrollable control strips): +- A second finger or pointer lands mid-drag: the first drag keeps its pointer or ends cleanly, never jumps to the new one +- The browser cancels the gesture to scroll (`pointercancel`), capture is lost (`lostpointercapture`), the pointer is released outside the control, or the window loses focus (`blur`) mid-drag: clear the dragging state and release capture +- After each of these, the next tap or drag works without a reload + **Permission states**: - No permission to view - No permission to edit @@ -304,6 +309,7 @@ const throttledScroll = throttle(handleScroll, 100); - Unit tests for edge cases - Integration tests for error scenarios - E2E tests for critical paths +- A behavioral regression for each confirmed gesture fix, when the project's test runner can drive input - Visual regression tests - Accessibility tests (axe, WAVE) @@ -330,7 +336,10 @@ Test thoroughly with edge cases: - **Network issues**: Disable internet, throttle connection - **Large datasets**: Test with 1000+ items - **Concurrent actions**: Click submit 10 times rapidly +- **Interrupted gestures**: Add a second finger mid-drag, scroll across the control, release outside it, switch windows mid-drag; then drag again - **Errors**: Force API errors, test all error states - **Empty**: Remove all data, test empty states +For gestures, say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and name what stayed untested. + When edge cases are covered, hand off to `/impeccable polish` for the final pass. diff --git a/.veto/skills/impeccable/reference/adapt.md b/.veto/skills/impeccable/reference/adapt.md index 7f76bbbb4..58d54aa3e 100644 --- a/.veto/skills/impeccable/reference/adapt.md +++ b/.veto/skills/impeccable/reference/adapt.md @@ -188,6 +188,12 @@ Test thoroughly across contexts: - **Edge cases**: Very small screens (320px), very large screens (4K) - **Slow connections**: Test on throttled network +**Custom controls** (sliders, drag surfaces, scrollable control strips): a before/after slider can pass every width check above and still refuse to drag on iOS, so exercise each one in scope in the same batched round as the checks above: + +- **Primary gesture**: Tap it and confirm it responds as designed, then drag it with the target input method; the drag must complete, not just start +- **Scroll across it**: A swipe along the page's scroll axis across the control scrolls the page or container without activating it; a drag that starts on the control along its axis moves the control, not the page. Neither failure throws an error, so try both +- **Evidence**: Say what produced the evidence: an emulated viewport, synthesized touch input through a browser tool, which engine ran it (Chromium is not Safari), or a physical device. Screenshots and resized viewports verify layout, never a gesture. Name what stayed untested and move on; unreachable hardware is a reported gap, not a blocker + When the adaptation feels native to each context, hand off to `/impeccable polish` for the final pass. --- diff --git a/.veto/skills/impeccable/reference/audit.md b/.veto/skills/impeccable/reference/audit.md index 474af4154..98c56d066 100644 --- a/.veto/skills/impeccable/reference/audit.md +++ b/.veto/skills/impeccable/reference/audit.md @@ -48,11 +48,12 @@ Run comprehensive checks across 5 dimensions. Score each dimension 0-4 using the **Check for**: - **Fixed widths**: Hard-coded widths that break on mobile - **Touch targets**: Interactive elements < 44x44px +- **Broken touch interaction**: Custom sliders, drag surfaces, and scrollable control strips whose primary gesture fails under touch, that swallow page scroll or lose the drag to it, or that stay stuck after an interrupted gesture. Code tells: mouse-only handlers, no `touch-action` on a pointer-event drag surface, drag state that nothing clears on cancel, lost capture, or blur. Exercise the gesture when a browser tool can synthesize touch (a rendered viewport proves layout, not the gesture), then say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and what stayed untested - **Horizontal scroll**: Content overflow on narrow viewports - **Text scaling**: Layouts that break when text size increases - **Missing breakpoints**: No mobile/tablet variants -**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets) +**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets, gestures work under touch) ### 5. Implementation Integrity (CRITICAL) diff --git a/.veto/skills/impeccable/reference/harden.md b/.veto/skills/impeccable/reference/harden.md index 46ca8a7c3..cbe2941e5 100644 --- a/.veto/skills/impeccable/reference/harden.md +++ b/.veto/skills/impeccable/reference/harden.md @@ -205,6 +205,11 @@ t('items', { count }) // Handles complex plural rules - Optimistic updates with rollback - Conflict resolution +**Interrupted gestures** (custom sliders, drag surfaces, scrollable control strips): +- A second finger or pointer lands mid-drag: the first drag keeps its pointer or ends cleanly, never jumps to the new one +- The browser cancels the gesture to scroll (`pointercancel`), capture is lost (`lostpointercapture`), the pointer is released outside the control, or the window loses focus (`blur`) mid-drag: clear the dragging state and release capture +- After each of these, the next tap or drag works without a reload + **Permission states**: - No permission to view - No permission to edit @@ -304,6 +309,7 @@ const throttledScroll = throttle(handleScroll, 100); - Unit tests for edge cases - Integration tests for error scenarios - E2E tests for critical paths +- A behavioral regression for each confirmed gesture fix, when the project's test runner can drive input - Visual regression tests - Accessibility tests (axe, WAVE) @@ -330,7 +336,10 @@ Test thoroughly with edge cases: - **Network issues**: Disable internet, throttle connection - **Large datasets**: Test with 1000+ items - **Concurrent actions**: Click submit 10 times rapidly +- **Interrupted gestures**: Add a second finger mid-drag, scroll across the control, release outside it, switch windows mid-drag; then drag again - **Errors**: Force API errors, test all error states - **Empty**: Remove all data, test empty states +For gestures, say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and name what stayed untested. + When edge cases are covered, hand off to `/impeccable polish` for the final pass. diff --git a/.vibe/skills/impeccable/reference/adapt.md b/.vibe/skills/impeccable/reference/adapt.md index 7f76bbbb4..58d54aa3e 100644 --- a/.vibe/skills/impeccable/reference/adapt.md +++ b/.vibe/skills/impeccable/reference/adapt.md @@ -188,6 +188,12 @@ Test thoroughly across contexts: - **Edge cases**: Very small screens (320px), very large screens (4K) - **Slow connections**: Test on throttled network +**Custom controls** (sliders, drag surfaces, scrollable control strips): a before/after slider can pass every width check above and still refuse to drag on iOS, so exercise each one in scope in the same batched round as the checks above: + +- **Primary gesture**: Tap it and confirm it responds as designed, then drag it with the target input method; the drag must complete, not just start +- **Scroll across it**: A swipe along the page's scroll axis across the control scrolls the page or container without activating it; a drag that starts on the control along its axis moves the control, not the page. Neither failure throws an error, so try both +- **Evidence**: Say what produced the evidence: an emulated viewport, synthesized touch input through a browser tool, which engine ran it (Chromium is not Safari), or a physical device. Screenshots and resized viewports verify layout, never a gesture. Name what stayed untested and move on; unreachable hardware is a reported gap, not a blocker + When the adaptation feels native to each context, hand off to `/impeccable polish` for the final pass. --- diff --git a/.vibe/skills/impeccable/reference/audit.md b/.vibe/skills/impeccable/reference/audit.md index 474af4154..98c56d066 100644 --- a/.vibe/skills/impeccable/reference/audit.md +++ b/.vibe/skills/impeccable/reference/audit.md @@ -48,11 +48,12 @@ Run comprehensive checks across 5 dimensions. Score each dimension 0-4 using the **Check for**: - **Fixed widths**: Hard-coded widths that break on mobile - **Touch targets**: Interactive elements < 44x44px +- **Broken touch interaction**: Custom sliders, drag surfaces, and scrollable control strips whose primary gesture fails under touch, that swallow page scroll or lose the drag to it, or that stay stuck after an interrupted gesture. Code tells: mouse-only handlers, no `touch-action` on a pointer-event drag surface, drag state that nothing clears on cancel, lost capture, or blur. Exercise the gesture when a browser tool can synthesize touch (a rendered viewport proves layout, not the gesture), then say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and what stayed untested - **Horizontal scroll**: Content overflow on narrow viewports - **Text scaling**: Layouts that break when text size increases - **Missing breakpoints**: No mobile/tablet variants -**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets) +**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets, gestures work under touch) ### 5. Implementation Integrity (CRITICAL) diff --git a/.vibe/skills/impeccable/reference/harden.md b/.vibe/skills/impeccable/reference/harden.md index 46ca8a7c3..cbe2941e5 100644 --- a/.vibe/skills/impeccable/reference/harden.md +++ b/.vibe/skills/impeccable/reference/harden.md @@ -205,6 +205,11 @@ t('items', { count }) // Handles complex plural rules - Optimistic updates with rollback - Conflict resolution +**Interrupted gestures** (custom sliders, drag surfaces, scrollable control strips): +- A second finger or pointer lands mid-drag: the first drag keeps its pointer or ends cleanly, never jumps to the new one +- The browser cancels the gesture to scroll (`pointercancel`), capture is lost (`lostpointercapture`), the pointer is released outside the control, or the window loses focus (`blur`) mid-drag: clear the dragging state and release capture +- After each of these, the next tap or drag works without a reload + **Permission states**: - No permission to view - No permission to edit @@ -304,6 +309,7 @@ const throttledScroll = throttle(handleScroll, 100); - Unit tests for edge cases - Integration tests for error scenarios - E2E tests for critical paths +- A behavioral regression for each confirmed gesture fix, when the project's test runner can drive input - Visual regression tests - Accessibility tests (axe, WAVE) @@ -330,7 +336,10 @@ Test thoroughly with edge cases: - **Network issues**: Disable internet, throttle connection - **Large datasets**: Test with 1000+ items - **Concurrent actions**: Click submit 10 times rapidly +- **Interrupted gestures**: Add a second finger mid-drag, scroll across the control, release outside it, switch windows mid-drag; then drag again - **Errors**: Force API errors, test all error states - **Empty**: Remove all data, test empty states +For gestures, say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and name what stayed untested. + When edge cases are covered, hand off to `/impeccable polish` for the final pass. diff --git a/cursor-plugin/skills/impeccable/reference/adapt.md b/cursor-plugin/skills/impeccable/reference/adapt.md index 7f76bbbb4..58d54aa3e 100644 --- a/cursor-plugin/skills/impeccable/reference/adapt.md +++ b/cursor-plugin/skills/impeccable/reference/adapt.md @@ -188,6 +188,12 @@ Test thoroughly across contexts: - **Edge cases**: Very small screens (320px), very large screens (4K) - **Slow connections**: Test on throttled network +**Custom controls** (sliders, drag surfaces, scrollable control strips): a before/after slider can pass every width check above and still refuse to drag on iOS, so exercise each one in scope in the same batched round as the checks above: + +- **Primary gesture**: Tap it and confirm it responds as designed, then drag it with the target input method; the drag must complete, not just start +- **Scroll across it**: A swipe along the page's scroll axis across the control scrolls the page or container without activating it; a drag that starts on the control along its axis moves the control, not the page. Neither failure throws an error, so try both +- **Evidence**: Say what produced the evidence: an emulated viewport, synthesized touch input through a browser tool, which engine ran it (Chromium is not Safari), or a physical device. Screenshots and resized viewports verify layout, never a gesture. Name what stayed untested and move on; unreachable hardware is a reported gap, not a blocker + When the adaptation feels native to each context, hand off to `/impeccable polish` for the final pass. --- diff --git a/cursor-plugin/skills/impeccable/reference/audit.md b/cursor-plugin/skills/impeccable/reference/audit.md index 474af4154..98c56d066 100644 --- a/cursor-plugin/skills/impeccable/reference/audit.md +++ b/cursor-plugin/skills/impeccable/reference/audit.md @@ -48,11 +48,12 @@ Run comprehensive checks across 5 dimensions. Score each dimension 0-4 using the **Check for**: - **Fixed widths**: Hard-coded widths that break on mobile - **Touch targets**: Interactive elements < 44x44px +- **Broken touch interaction**: Custom sliders, drag surfaces, and scrollable control strips whose primary gesture fails under touch, that swallow page scroll or lose the drag to it, or that stay stuck after an interrupted gesture. Code tells: mouse-only handlers, no `touch-action` on a pointer-event drag surface, drag state that nothing clears on cancel, lost capture, or blur. Exercise the gesture when a browser tool can synthesize touch (a rendered viewport proves layout, not the gesture), then say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and what stayed untested - **Horizontal scroll**: Content overflow on narrow viewports - **Text scaling**: Layouts that break when text size increases - **Missing breakpoints**: No mobile/tablet variants -**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets) +**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets, gestures work under touch) ### 5. Implementation Integrity (CRITICAL) diff --git a/cursor-plugin/skills/impeccable/reference/harden.md b/cursor-plugin/skills/impeccable/reference/harden.md index add850742..01d1d318b 100644 --- a/cursor-plugin/skills/impeccable/reference/harden.md +++ b/cursor-plugin/skills/impeccable/reference/harden.md @@ -205,6 +205,11 @@ t('items', { count }) // Handles complex plural rules - Optimistic updates with rollback - Conflict resolution +**Interrupted gestures** (custom sliders, drag surfaces, scrollable control strips): +- A second finger or pointer lands mid-drag: the first drag keeps its pointer or ends cleanly, never jumps to the new one +- The browser cancels the gesture to scroll (`pointercancel`), capture is lost (`lostpointercapture`), the pointer is released outside the control, or the window loses focus (`blur`) mid-drag: clear the dragging state and release capture +- After each of these, the next tap or drag works without a reload + **Permission states**: - No permission to view - No permission to edit @@ -304,6 +309,7 @@ const throttledScroll = throttle(handleScroll, 100); - Unit tests for edge cases - Integration tests for error scenarios - E2E tests for critical paths +- A behavioral regression for each confirmed gesture fix, when the project's test runner can drive input - Visual regression tests - Accessibility tests (axe, WAVE) @@ -330,7 +336,10 @@ Test thoroughly with edge cases: - **Network issues**: Disable internet, throttle connection - **Large datasets**: Test with 1000+ items - **Concurrent actions**: Click submit 10 times rapidly +- **Interrupted gestures**: Add a second finger mid-drag, scroll across the control, release outside it, switch windows mid-drag; then drag again - **Errors**: Force API errors, test all error states - **Empty**: Remove all data, test empty states +For gestures, say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and name what stayed untested. + When edge cases are covered, hand off to `/impeccable polish` for the final pass. diff --git a/plugin/skills/impeccable/reference/adapt.md b/plugin/skills/impeccable/reference/adapt.md index 7f76bbbb4..58d54aa3e 100644 --- a/plugin/skills/impeccable/reference/adapt.md +++ b/plugin/skills/impeccable/reference/adapt.md @@ -188,6 +188,12 @@ Test thoroughly across contexts: - **Edge cases**: Very small screens (320px), very large screens (4K) - **Slow connections**: Test on throttled network +**Custom controls** (sliders, drag surfaces, scrollable control strips): a before/after slider can pass every width check above and still refuse to drag on iOS, so exercise each one in scope in the same batched round as the checks above: + +- **Primary gesture**: Tap it and confirm it responds as designed, then drag it with the target input method; the drag must complete, not just start +- **Scroll across it**: A swipe along the page's scroll axis across the control scrolls the page or container without activating it; a drag that starts on the control along its axis moves the control, not the page. Neither failure throws an error, so try both +- **Evidence**: Say what produced the evidence: an emulated viewport, synthesized touch input through a browser tool, which engine ran it (Chromium is not Safari), or a physical device. Screenshots and resized viewports verify layout, never a gesture. Name what stayed untested and move on; unreachable hardware is a reported gap, not a blocker + When the adaptation feels native to each context, hand off to `/impeccable polish` for the final pass. --- diff --git a/plugin/skills/impeccable/reference/audit.md b/plugin/skills/impeccable/reference/audit.md index 474af4154..98c56d066 100644 --- a/plugin/skills/impeccable/reference/audit.md +++ b/plugin/skills/impeccable/reference/audit.md @@ -48,11 +48,12 @@ Run comprehensive checks across 5 dimensions. Score each dimension 0-4 using the **Check for**: - **Fixed widths**: Hard-coded widths that break on mobile - **Touch targets**: Interactive elements < 44x44px +- **Broken touch interaction**: Custom sliders, drag surfaces, and scrollable control strips whose primary gesture fails under touch, that swallow page scroll or lose the drag to it, or that stay stuck after an interrupted gesture. Code tells: mouse-only handlers, no `touch-action` on a pointer-event drag surface, drag state that nothing clears on cancel, lost capture, or blur. Exercise the gesture when a browser tool can synthesize touch (a rendered viewport proves layout, not the gesture), then say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and what stayed untested - **Horizontal scroll**: Content overflow on narrow viewports - **Text scaling**: Layouts that break when text size increases - **Missing breakpoints**: No mobile/tablet variants -**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets) +**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets, gestures work under touch) ### 5. Implementation Integrity (CRITICAL) diff --git a/plugin/skills/impeccable/reference/harden.md b/plugin/skills/impeccable/reference/harden.md index 46ca8a7c3..cbe2941e5 100644 --- a/plugin/skills/impeccable/reference/harden.md +++ b/plugin/skills/impeccable/reference/harden.md @@ -205,6 +205,11 @@ t('items', { count }) // Handles complex plural rules - Optimistic updates with rollback - Conflict resolution +**Interrupted gestures** (custom sliders, drag surfaces, scrollable control strips): +- A second finger or pointer lands mid-drag: the first drag keeps its pointer or ends cleanly, never jumps to the new one +- The browser cancels the gesture to scroll (`pointercancel`), capture is lost (`lostpointercapture`), the pointer is released outside the control, or the window loses focus (`blur`) mid-drag: clear the dragging state and release capture +- After each of these, the next tap or drag works without a reload + **Permission states**: - No permission to view - No permission to edit @@ -304,6 +309,7 @@ const throttledScroll = throttle(handleScroll, 100); - Unit tests for edge cases - Integration tests for error scenarios - E2E tests for critical paths +- A behavioral regression for each confirmed gesture fix, when the project's test runner can drive input - Visual regression tests - Accessibility tests (axe, WAVE) @@ -330,7 +336,10 @@ Test thoroughly with edge cases: - **Network issues**: Disable internet, throttle connection - **Large datasets**: Test with 1000+ items - **Concurrent actions**: Click submit 10 times rapidly +- **Interrupted gestures**: Add a second finger mid-drag, scroll across the control, release outside it, switch windows mid-drag; then drag again - **Errors**: Force API errors, test all error states - **Empty**: Remove all data, test empty states +For gestures, say what produced the evidence (emulated viewport, synthesized touch, which engine, physical device) and name what stayed untested. + When edge cases are covered, hand off to `/impeccable polish` for the final pass.