packages/slides/src/view/canvas/shapes/equation/math-divide.handles.test.ts (1)

4-21: ⚡ Quick win

Consider adding apply() round-trip tests.

The test validates position() output but doesn't verify that apply() correctly updates adjustments when a handle is dragged. Round-trip tests (position → simulated drag → apply → verify adjustment values) would strengthen confidence in the handle behavior, especially for handle[2] which depends on the bar adjustment.

Example test structure

it('handle[0] apply updates bar thickness', () => {
  const initial = [23520, 5880, 11760];
  const size = { w: 200, h: 100 };
  // Simulate dragging bar handle upward (reduce bar thickness)
  const result = MATH_DIVIDE_HANDLES[0].apply(size, initial, { x: 100, y: 30 });
  expect(result[0]).toBeLessThan(initial[0]);
  expect(result[0]).toBeGreaterThanOrEqual(MATH_DIVIDE_ADJUSTMENTS[0].min);
});

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/slides/src/view/canvas/shapes/equation/math-divide.handles.test.ts`
around lines 4 - 21, Add round-trip tests that exercise MATH_DIVIDE_HANDLES'
position() → simulated drag → apply() flow to ensure adjustments update
correctly; for each handle (especially MATH_DIVIDE_HANDLES[0], [1], and [2])
call position() to get the handle coords, simulate a drag target (e.g., move y
up/down or x left/right), invoke the handle's apply(size, initialAdjustments,
draggedPoint) and assert the returned adjustments changed in the expected
direction and remain within MATH_DIVIDE_ADJUSTMENTS[n].min/max bounds (and for
handle[2] include cases where bar adjustment from handle[0] affects its result).
Ensure tests reference the functions MATH_DIVIDE_HANDLES.position and
MATH_DIVIDE_HANDLES.apply and use the MATH_DIVIDE_ADJUSTMENTS constants for
assertions.

packages/slides/src/view/canvas/shapes/arrows/left-arrow.handles.test.ts (1)

4-11: ⚡ Quick win

Consider adding test coverage for apply logic and boundary conditions.

The test only verifies handle count and a single position call with default adjustments. Consider adding tests for:

• The apply function's pointer-to-adjustment conversion and clamping
• Boundary values (min/max from ARROW_ADJUSTMENTS)
• Edge cases like zero dimensions or extreme pointer positions

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/slides/src/view/canvas/shapes/arrows/left-arrow.handles.test.ts`
around lines 4 - 11, Add unit tests for LEFT_ARROW_HANDLES to cover the apply
logic and boundary conditions: write tests that call LEFT_ARROW_HANDLES[0].apply
(and other handles) with pointer vectors that map to min/max ARROW_ADJUSTMENTS
values and verify clamping, test pointer-to-adjustment conversion for typical
and extreme pointer positions (very large/small/negative), and include edge
cases like zero width or height to ensure position({w:0,h:0}, ...) and apply
behave correctly; reference LEFT_ARROW_HANDLES, its apply and position methods,
and ARROW_ADJUSTMENTS in your assertions.

packages/slides/src/view/canvas/shapes/equation/math-equal.handles.test.ts (1)

4-15: ⚡ Quick win

Add apply() and boundary clamp assertions for both handles.

This suite currently verifies only position(). The critical pointer→adjustment conversion path in apply() (including min/max clamping) is untested.

Proposed test additions

 describe('MATH_EQUAL_HANDLES', () => {
   it('registers thickness and gap handles', () => {
@@
     expect(p1.y).toBeCloseTo(44.12, 2);
   });
+
+  it('thickness apply updates index 0 and preserves index 1', () => {
+    const next = MATH_EQUAL_HANDLES[0].apply({ w: 200, h: 100 }, [23520, 11760], { x: 100, y: 0 });
+    expect(next).toEqual([44120, 11760]);
+  });
+
+  it('gap apply clamps to spec range', () => {
+    const hi = MATH_EQUAL_HANDLES[1].apply({ w: 200, h: 100 }, [23520, 11760], { x: 100, y: 0 });
+    const lo = MATH_EQUAL_HANDLES[1].apply({ w: 200, h: 100 }, [23520, 11760], { x: 100, y: 100 });
+    expect(hi).toEqual([23520, 50000]);
+    expect(lo).toEqual([23520, 0]);
+  });
 });

As per coding guidelines, **/*.{test,spec}.{js,ts,jsx,tsx}: Write tests for critical business logic and edge cases.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/slides/src/view/canvas/shapes/equation/math-equal.handles.test.ts`
around lines 4 - 15, Add tests for the handles' apply() behavior and boundary
clamping: for each handle in MATH_EQUAL_HANDLES, call its apply(pointer, size,
currentValues) with representative pointer positions (including
edge/out-of-bounds cases) and assert the returned adjustment matches expected
thickness/gap deltas and is clamped within allowed min/max; keep existing
position() assertions and add symmetrically for both handles (use
MATH_EQUAL_HANDLES[0].apply and MATH_EQUAL_HANDLES[1].apply, and verify
pointer→adjustment conversion and min/max enforcement).

packages/slides/src/view/canvas/shapes/basic/octagon.handles.test.ts (1)

4-12: ⚡ Quick win

Expand this suite to cover apply() inversion and clamp boundaries.

Right now it only checks position(). Add apply() assertions so drag behavior and min/max clamping are protected from regressions.

Proposed test additions

 describe('OCTAGON_HANDLES', () => {
   it('registers a single linear-x handle on the top edge', () => {
@@
     expect(p.y).toBe(0);
   });
+
+  it('apply inverts pointer.x back to the adjustment domain', () => {
+    const next = OCTAGON_HANDLES[0].apply({ w: 200, h: 100 }, [29289], { x: 29.289, y: 0 });
+    expect(next).toEqual([29289]);
+  });
+
+  it('apply clamps at spec min/max', () => {
+    const min = OCTAGON_HANDLES[0].apply({ w: 200, h: 100 }, [29289], { x: -50, y: 0 });
+    const max = OCTAGON_HANDLES[0].apply({ w: 200, h: 100 }, [29289], { x: 9999, y: 0 });
+    expect(min).toEqual([0]);
+    expect(max).toEqual([50000]);
+  });
 });

As per coding guidelines, **/*.{test,spec}.{js,ts,jsx,tsx}: Write tests for critical business logic and edge cases.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/slides/src/view/canvas/shapes/basic/octagon.handles.test.ts` around
lines 4 - 12, Extend the OCTAGON_HANDLES test to also verify the handle's
apply() is the inverse of position() and that applied values are clamped: for
OCTAGON_HANDLES[0] (use the same size {w:200,h:100} and initial cut array
[29289]) compute p = position(...), then call apply(..., { x: p.x + 10, y: p.y
}) and assert the returned cut array changed from 29289 in the expected
direction (i.e. increased) and that re-running position() with the new cut
yields an x close to p.x + 10; also call apply with extreme points (e.g. x < 0
and x > w) and assert the returned cut is clamped to the min/max allowed values
(0 and 100000 normalised as in this codebase) so out-of-bounds drags produce
boundary values.

packages/slides/src/view/canvas/shapes/basic/triangle.handles.test.ts (1)

5-9: ⚡ Quick win

Cover inverse behavior with a round-trip test.

This test only checks position(). Add apply(position(...)) round-trip to catch inverse-mapping regressions.

Proposed test addition

 describe('TRIANGLE_HANDLES', () => {
   it('registers a single linear-x handle on the top edge', () => {
     expect(TRIANGLE_HANDLES).toHaveLength(1);
     const p = TRIANGLE_HANDLES[0].position({ w: 200, h: 100 }, [50000]);
     expect(p).toEqual({ x: 100, y: 0 }); // apex centred at default
   });
+
+  it('round-trips position ↔ apply at default', () => {
+    const frame = { w: 200, h: 100 };
+    const start = [50000];
+    const p = TRIANGLE_HANDLES[0].position(frame, start);
+    const back = TRIANGLE_HANDLES[0].apply(frame, start, p);
+    expect(back[0]).toBeCloseTo(start[0], -1);
+  });
 });

As per coding guidelines **/*.{test,spec}.{js,ts,jsx,tsx}: Write tests for critical business logic and edge cases.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/slides/src/view/canvas/shapes/basic/triangle.handles.test.ts` around
lines 5 - 9, Add a round-trip assertion that verifies the handle's inverse
mapping: for the first handle in TRIANGLE_HANDLES call position with the same
shape ({ w: 200, h: 100 }) and seed ([50000]) to get p, then call
TRIANGLE_HANDLES[0].apply(p, { w: 200, h: 100 }) and assert the result equals
the original input used by position (e.g., [50000]); this will ensure
position(...) → apply(...) round-trip consistency and catch inverse-mapping
regressions.

packages/slides/src/view/canvas/shapes/basic/hexagon.handles.test.ts (1)

5-10: ⚡ Quick win

Add an inverse round-trip assertion for the handle.

This currently validates only position(); a break in apply()/inverse math would still pass. Add a position↔apply round-trip check in this suite.

Proposed test addition

 describe('HEXAGON_HANDLES', () => {
   it('registers a single linear-x handle on the top edge', () => {
     expect(HEXAGON_HANDLES).toHaveLength(1);
     // notch = 25% * min(200, 100) = 25
     const p = HEXAGON_HANDLES[0].position({ w: 200, h: 100 }, [25000]);
     expect(p).toEqual({ x: 25, y: 0 });
   });
+
+  it('round-trips position ↔ apply at default', () => {
+    const frame = { w: 200, h: 100 };
+    const start = [25000];
+    const p = HEXAGON_HANDLES[0].position(frame, start);
+    const back = HEXAGON_HANDLES[0].apply(frame, start, p);
+    expect(back[0]).toBeCloseTo(start[0], -1);
+  });
 });

As per coding guidelines **/*.{test,spec}.{js,ts,jsx,tsx}: Write tests for critical business logic and edge cases.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/slides/src/view/canvas/shapes/basic/hexagon.handles.test.ts` around
lines 5 - 10, The test only asserts HEXAGON_HANDLES[0].position(...) — add an
inverse round-trip assertion that verifies apply() reverses position(): capture
the handle param used (e.g. values = [25000]), compute p =
HEXAGON_HANDLES[0].position({ w:200,h:100 }, values), then call
HEXAGON_HANDLES[0].apply({ w:200,h:100 }, p) and expect the returned values to
equal the original values (or equal within a small tolerance if numeric scaling
occurs). Use the same handle symbol HEXAGON_HANDLES[0], the position and apply
methods, and include the round-trip expect in the same test case.

packages/slides/src/view/canvas/shapes/callouts/wedge-round-rect-callout.handles.test.ts (1)

9-28: ⚡ Quick win

Add direct coverage for the tail handle path.

Line 9 onward validates only the corner-radius handle (handles[1]). Please add one assertion for handles[0] position(...) and one apply(...) check so both registered handles have shape-level integration coverage.

Proposed test extension

 describe('WEDGE_ROUND_RECT_CALLOUT_HANDLES', () => {
@@
   it('corner-radius handle controls adjustments[2], leaving tail adjustments unchanged', () => {
@@
     expect(next[2]).toBe(30000);
   });
+
+  it('tail handle updates tail adjustments', () => {
+    const start = [-20833, 62500, 16667];
+    const p = WEDGE_ROUND_RECT_CALLOUT_HANDLES[0].position({ w: 200, h: 100 }, start);
+    expect(p).toBeDefined();
+
+    const next = WEDGE_ROUND_RECT_CALLOUT_HANDLES[0].apply(
+      { w: 200, h: 100 },
+      start,
+      { x: 150, y: 120 },
+    );
+    expect(next[0]).not.toBe(start[0]);
+    expect(next[1]).not.toBe(start[1]);
+    expect(next[2]).toBe(start[2]);
+  });
 });

As per coding guidelines, "Write tests for critical business logic and edge cases".

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@packages/slides/src/view/canvas/shapes/callouts/wedge-round-rect-callout.handles.test.ts`
around lines 9 - 28, Add explicit coverage for the tail handle (handles[0]) by
calling WEDGE_ROUND_RECT_CALLOUT_HANDLES[0].position(...) with the same input
used for handles[1] and asserting the returned x/y match the expected
tail-position values, then call WEDGE_ROUND_RECT_CALLOUT_HANDLES[0].apply(...)
with a dragged point and assert that the tail values (first two entries) change
as expected while the radius (third entry) remains unchanged; locate usages of
WEDGE_ROUND_RECT_CALLOUT_HANDLES[1].position/apply in the test and mirror them
for index 0, asserting the correct mutated array entries for the tail and
unchanged radius.

packages/slides/src/view/canvas/shapes/equation/math-multiply.handles.test.ts (1)

4-12: ⚡ Quick win

Add apply coverage for clamp and inverse behavior.

This suite only validates position; apply (the drag mutation path) should also be covered with at least one round-trip and min/max clamp case.

Proposed test additions

 describe('MATH_MULTIPLY_HANDLES', () => {
   it('registers a single arm-thickness handle on the rotated cross', () => {
@@
     expect(p.y).toBeCloseTo(50 - 23.52 * Math.SQRT1_2, 2);
   });
+
+  it('apply round-trips position for an in-range value', () => {
+    const handle = MATH_MULTIPLY_HANDLES[0];
+    const frame = { w: 200, h: 100 };
+    const start = [23520];
+    const p = handle.position(frame, start);
+    const next = handle.apply(frame, start, p);
+    expect(next[0]).toBeCloseTo(start[0], 0);
+  });
+
+  it('apply clamps when dragged far below center', () => {
+    const next = MATH_MULTIPLY_HANDLES[0].apply(
+      { w: 200, h: 100 },
+      [23520],
+      { x: 100, y: 1000 },
+    );
+    expect(next[0]).toBe(0);
+  });
 });

As per coding guidelines, **/*.{test,spec}.{js,ts,jsx,tsx}: Write tests for critical business logic and edge cases.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@packages/slides/src/view/canvas/shapes/equation/math-multiply.handles.test.ts`
around lines 4 - 12, Add tests covering the handle's apply (drag) behavior for
MATH_MULTIPLY_HANDLES in addition to the existing position assertions: call the
handle's apply on MATH_MULTIPLY_HANDLES[0] with an initial args array (e.g.,
[23520]) and a delta that should round-trip (apply then re-calc position gives
same value), then add two separate tests that apply deltas pushing the parameter
below its minimum and above its maximum and assert the resulting value is
clamped to expected min/max; reference the handle via
MATH_MULTIPLY_HANDLES[0].apply(...) and verify by reading the mutated args
and/or recomputing position via MATH_MULTIPLY_HANDLES[0].position(...) to
confirm clamping and round-trip behavior.

packages/slides/src/view/canvas/shapes/equation/math-minus.handles.test.ts (1)

4-12: ⚡ Quick win

Cover the apply path in this suite.

Please add at least one inverse round-trip case and one clamp boundary case for MATH_MINUS_HANDLES[0].apply(...).

As per coding guidelines, **/*.{test,spec}.{js,ts,jsx,tsx}: Write tests for critical business logic and edge cases.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/slides/src/view/canvas/shapes/equation/math-minus.handles.test.ts`
around lines 4 - 12, Add tests that exercise the apply path of
MATH_MINUS_HANDLES[0]: (1) an inverse round-trip case — call
handler.position(...) to get a position, then pass that position through
MATH_MINUS_HANDLES[0].apply(...) and assert the returned values (e.g., the first
element of the values array) equal the original input within tolerance; and (2)
a clamp/boundary case — call .apply(...) with positions outside the allowed area
(e.g., beyond left/right/top/bottom or extreme y) and assert the returned value
is clamped to the min/max expected by the handler. Use the existing position
call to derive realistic inputs and reference MATH_MINUS_HANDLES[0].position and
MATH_MINUS_HANDLES[0].apply when locating code to change.

packages/slides/src/view/canvas/shapes/equation/math-not-equal.handles.test.ts (1)

4-16: ⚡ Quick win

Expand tests beyond slash-handle position.

Please add tests for apply (clamp + round-trip) and at least one check each for bar/gap handle positions to protect all three adjustment axes.

As per coding guidelines, **/*.{test,spec}.{js,ts,jsx,tsx}: Write tests for critical business logic and edge cases.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@packages/slides/src/view/canvas/shapes/equation/math-not-equal.handles.test.ts`
around lines 4 - 16, Add tests to cover all three adjustment axes for
MATH_NOT_EQUAL_HANDLES: extend the existing test suite to (1) assert the bar
handle (index 0) position for a given size and values array, (2) assert the gap
handle (index 1) position similarly, and (3) test the slash handle's apply
method by calling its apply with out-of-range values to verify clamping and then
calling position to verify round-trip rounding behavior; reference the handles
via MATH_NOT_EQUAL_HANDLES[0], [1], [2], use the handle.apply function to check
clamping/round-trip, and use handle.position to assert expected x/y coordinates
(use toBeCloseTo for floating checks).

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes