refactor: consolidate gesture planning policy

Author: thymikee

src/commands/interaction/runtime/gesture-command.ts

@@ -1,8 +1,6 @@
 import type { AgentDeviceRuntime, CommandContext } from '../../../runtime-contract.ts';
 import type { GestureIntent, GestureSemanticInput } from '../../../contracts/gesture-plan-types.ts';
 import { buildGesturePlan } from '../../../contracts/gesture-plan.ts';
-import type { NormalizedGestureInput } from '../../../contracts/gesture-normalization.ts';
-import { buildSwipePresetGesturePlan } from '../../../contracts/scroll-gesture.ts';
 import type { Point, Rect } from '../../../kernel/snapshot.ts';
 import { AppError } from '../../../kernel/errors.ts';
 import { successText } from '../../../utils/success-text.ts';
@@ -16,7 +14,7 @@ import { assertSupportedInteractionSurface, captureInteractionSnapshot } from '.
 import { resolveVisibleSnapshotViewport } from './viewport.ts';
 
 export type GestureCommandOptions = CommandContext & {
-  gesture: NormalizedGestureInput;
+  gesture: GestureSemanticInput;
 };
 
 export type GestureCommandResult = {
@@ -36,8 +34,7 @@ export const gestureCommand: RuntimeCommand<GestureCommandOptions, GestureComman
   }
   await assertSupportedInteractionSurface(runtime, options, options.gesture.intent);
   const viewport = await captureGestureViewport(runtime, options);
-  const gesture = resolvePresetGesture(options.gesture, viewport);
-  const plan = buildGesturePlan(gesture, viewport, runtime.backend.platform);
+  const plan = buildGesturePlan(options.gesture, viewport, runtime.backend.platform);
   const backendResult = await runtime.backend.performGesture(
     toBackendContext(runtime, options),
     plan,
@@ -46,13 +43,13 @@ export const gestureCommand: RuntimeCommand<GestureCommandOptions, GestureComman
   const from = centroidAt(plan.pointers, 0);
   const to = centroidAt(plan.pointers, -1);
   return {
-    kind: gesture.intent,
+    kind: plan.intent,
     durationMs: plan.durationMs,
     pointerCount: plan.topology === 'single' ? 1 : 2,
     from,
     to,
     ...(formattedBackendResult ? { backendResult: formattedBackendResult } : {}),
-    ...successText(gestureMessage(gesture)),
+    ...successText(gestureMessage(options.gesture, from, to)),
   };
 };
 
@@ -68,23 +65,6 @@ async function captureGestureViewport(
   return resolveVisibleSnapshotViewport(capture.snapshot.nodes, 'gesture');
 }
 
-function resolvePresetGesture(input: NormalizedGestureInput, viewport: Rect): GestureSemanticInput {
-  if (!('preset' in input)) return input;
-  const relative = buildSwipePresetGesturePlan(input.preset, {
-    referenceWidth: viewport.width,
-    referenceHeight: viewport.height,
-  });
-  const from = { x: viewport.x + relative.x1, y: viewport.y + relative.y1 };
-  const to = { x: viewport.x + relative.x2, y: viewport.y + relative.y2 };
-  if (input.intent === 'fling') return { intent: 'fling', from, to };
-  return {
-    intent: 'pan',
-    origin: from,
-    delta: { x: to.x - from.x, y: to.y - from.y },
-    durationMs: input.durationMs,
-  };
-}
-
 function centroidAt(
   pointers: readonly { samples: readonly { point: Point }[] }[],
   index: 0 | -1,
@@ -102,10 +82,13 @@ function centroidAt(
   };
 }
 
-function gestureMessage(input: GestureSemanticInput): string {
+function gestureMessage(input: GestureSemanticInput, from: Point, to: Point): string {
   switch (input.intent) {
-    case 'pan':
-      return `Panned (${input.origin.x}, ${input.origin.y}) by (${input.delta.x}, ${input.delta.y})`;
+    case 'pan': {
+      const origin = 'preset' in input ? from : input.origin;
+      const delta = 'preset' in input ? { x: to.x - from.x, y: to.y - from.y } : input.delta;
+      return `Panned (${origin.x}, ${origin.y}) by (${delta.x}, ${delta.y})`;
+    }
     case 'fling':
       return 'direction' in input ? `Flung ${input.direction}` : 'Flung';
     case 'pinch':

src/contracts/gesture-normalization.ts

@@ -1,6 +1,6 @@
 import type { Point } from '../kernel/snapshot.ts';
 import { AppError } from '../kernel/errors.ts';
-import type { SwipePreset } from './scroll-gesture.ts';
+import { gestureDirectionDelta } from './scroll-gesture.ts';
 import { readGesturePayload, type GesturePayload } from './gesture-input.ts';
 import { GESTURE_FLING_DEFAULT_DISTANCE } from './gesture-plan.ts';
 import type { GestureSemanticInput } from './gesture-plan-types.ts';
@@ -12,13 +12,8 @@ export type GestureDeprecation = {
   replacement: string;
 };
 
-export type NormalizedGestureInput =
-  | GestureSemanticInput
-  | { intent: 'fling'; preset: SwipePreset }
-  | { intent: 'pan'; preset: SwipePreset; durationMs: number };
-
 export type NormalizedPublicGesture = {
-  gesture: NormalizedGestureInput;
+  gesture: GestureSemanticInput;
   deprecations: GestureDeprecation[];
 };
 
@@ -171,7 +166,7 @@ export function normalizePublicGesture(input: GesturePayload): NormalizedPublicG
           gesture: {
             intent: 'pan',
             origin: input.origin,
-            delta: directionDelta(
+            delta: gestureDirectionDelta(
               input.direction,
               input.distance ?? GESTURE_FLING_DEFAULT_DISTANCE,
             ),
@@ -256,19 +251,6 @@ export function normalizePublicSwipeMotion(input: {
   };
 }
 
-function directionDelta(direction: 'up' | 'down' | 'left' | 'right', distance: number): Point {
-  switch (direction) {
-    case 'up':
-      return { x: 0, y: -distance };
-    case 'down':
-      return { x: 0, y: distance };
-    case 'left':
-      return { x: -distance, y: 0 };
-    case 'right':
-      return { x: distance, y: 0 };
-  }
-}
-
 function optionalPositionNumber(value: string | undefined): number | undefined {
   return value === undefined ? undefined : Number(value);
 }

src/contracts/gesture-plan-types.ts

@@ -1,5 +1,5 @@
 import type { Point, Rect } from '../kernel/snapshot.ts';
-import type { ScrollDirection } from './scroll-gesture.ts';
+import type { ScrollDirection, SwipePreset } from './scroll-gesture.ts';
 
 export type GesturePointerCount = 1 | 2;
 
@@ -10,6 +10,7 @@ export type GestureIntent = 'fling' | 'pan' | 'pinch' | 'rotate' | 'transform';
 
 export type GestureSemanticInput =
   | { intent: 'fling'; from: Point; to: Point }
+  | { intent: 'fling'; preset: SwipePreset }
   | {
       intent: 'fling';
       direction: ScrollDirection;
@@ -23,6 +24,7 @@ export type GestureSemanticInput =
       pointerCount?: GesturePointerCount;
       durationMs?: number;
     }
+  | { intent: 'pan'; preset: SwipePreset; durationMs: number }
   | { intent: 'pinch'; origin?: Point; scale: number }
   | { intent: 'rotate'; origin?: Point; degrees: number }
   | {