@flighthq/shape 0.1.0

package/src/shapeCommands.test.ts

@@ -0,0 +1,429 @@
+import { createShape } from './shape';
+import {
+  appendShapeArc,
+  appendShapeArcTo,
+  appendShapeBeginBitmapFill,
+  appendShapeBeginFill,
+  appendShapeBeginGradientFill,
+  appendShapeCircle,
+  appendShapeCubicCurveTo,
+  appendShapeCurveTo,
+  appendShapeDrawTriangles,
+  appendShapeEllipse,
+  appendShapeEndFill,
+  appendShapeLineBitmapStyle,
+  appendShapeLineGradientStyle,
+  appendShapeLineStyle,
+  appendShapeLineTo,
+  appendShapeMoveTo,
+  appendShapePath,
+  appendShapePolygon,
+  appendShapePolyline,
+  appendShapeRectangle,
+  appendShapeRoundRectangle,
+  appendShapeRoundRectangleVarying,
+  PathCommand,
+} from './shapeCommands';
+
+const fakeImageSource = { id: 1, height: 10, source: null, width: 10 } as never;
+const fakeMatrix = { id: 2, a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 } as never;
+
+describe('appendShapeArc', () => {
+  it('emits a moveTo followed by at least one cubicCurveTo', () => {
+    const shape = createShape();
+    appendShapeArc(shape, 50, 50, 25, 0, Math.PI);
+    const keys: string[] = [];
+    let i = 0;
+    while (i < shape.data.commands.length) {
+      const key = shape.data.commands[i] as string;
+      const argCount = shape.data.commands[i + 1] as number;
+      keys.push(key);
+      i += argCount + 2;
+    }
+    expect(keys[0]).toBe('moveTo');
+    expect(keys.slice(1).every((k) => k === 'cubicCurveTo')).toBe(true);
+    expect(keys.length).toBeGreaterThan(1);
+  });
+
+  it('arc start point is on the circle at startAngle', () => {
+    const shape = createShape();
+    appendShapeArc(shape, 0, 0, 10, 0, Math.PI / 2);
+    // moveTo args are at indices [2] and [3]
+    expect(shape.data.commands[2]).toBeCloseTo(10, 5);
+    expect(shape.data.commands[3]).toBeCloseTo(0, 5);
+  });
+
+  it('a full circle uses 4 cubic segments', () => {
+    const shape = createShape();
+    appendShapeArc(shape, 0, 0, 10, 0, Math.PI * 2);
+    let count = 0;
+    let i = 0;
+    while (i < shape.data.commands.length) {
+      const key = shape.data.commands[i] as string;
+      const argCount = shape.data.commands[i + 1] as number;
+      if (key === 'cubicCurveTo') count++;
+      i += argCount + 2;
+    }
+    expect(count).toBe(4);
+  });
+
+  it('anticlockwise arc sweeps in the negative direction', () => {
+    const shape = createShape();
+    appendShapeArc(shape, 0, 0, 10, 0, Math.PI / 2, true);
+    // 3/4-circle anticlockwise; should use 3 cubicCurveTo segments.
+    let count = 0;
+    let i = 0;
+    while (i < shape.data.commands.length) {
+      const key = shape.data.commands[i] as string;
+      const argCount = shape.data.commands[i + 1] as number;
+      if (key === 'cubicCurveTo') count++;
+      i += argCount + 2;
+    }
+    expect(count).toBe(3);
+  });
+});
+
+describe('appendShapeArcTo', () => {
+  it('emits a lineTo followed by cubicCurveTo commands for a right-angle corner', () => {
+    const shape = createShape();
+    // Start at (100, 0), corner at (100, 100), end direction toward (0, 100) with radius 20.
+    appendShapeMoveTo(shape, 100, 0);
+    appendShapeArcTo(shape, 100, 100, 0, 100, 20);
+    const keys: string[] = [];
+    let i = 0;
+    while (i < shape.data.commands.length) {
+      const key = shape.data.commands[i] as string;
+      const argCount = shape.data.commands[i + 1] as number;
+      keys.push(key);
+      i += argCount + 2;
+    }
+    // moveTo, lineTo (to tangent start), then cubicCurveTo arc segments.
+    expect(keys[0]).toBe('moveTo');
+    expect(keys[1]).toBe('lineTo');
+    expect(keys.slice(2).every((k) => k === 'cubicCurveTo')).toBe(true);
+  });
+
+  it('falls back to a lineTo when the tangent has zero length', () => {
+    const shape = createShape();
+    // pen at (100, 100), corner at (100, 100) — zero-length tangent.
+    appendShapeMoveTo(shape, 100, 100);
+    appendShapeArcTo(shape, 100, 100, 200, 100, 10);
+    const keys: string[] = [];
+    let i = 0;
+    while (i < shape.data.commands.length) {
+      const key = shape.data.commands[i] as string;
+      const argCount = shape.data.commands[i + 1] as number;
+      keys.push(key);
+      i += argCount + 2;
+    }
+    // Degenerate: should only have the original moveTo and one lineTo.
+    expect(keys).toContain('lineTo');
+    expect(keys.every((k) => k === 'moveTo' || k === 'lineTo')).toBe(true);
+  });
+});
+
+describe('appendShapeBeginBitmapFill', () => {
+  it('pushes a beginBitmapFill command with bitmap, matrix, repeat, smooth', () => {
+    const shape = createShape();
+    appendShapeBeginBitmapFill(shape, fakeImageSource, fakeMatrix, false, true);
+    expect(shape.data.commands).toEqual(['beginBitmapFill', 4, fakeImageSource, fakeMatrix, false, true]);
+  });
+
+  it('defaults matrix to null, repeat to true, smooth to false', () => {
+    const shape = createShape();
+    appendShapeBeginBitmapFill(shape, fakeImageSource);
+    expect(shape.data.commands).toEqual(['beginBitmapFill', 4, fakeImageSource, null, true, false]);
+  });
+});
+
+describe('appendShapeBeginFill', () => {
+  it('pushes a beginFill command with color and alpha', () => {
+    const shape = createShape();
+    appendShapeBeginFill(shape, 0xff0000, 0.5);
+    expect(shape.data.commands).toEqual(['beginFill', 2, 0xff0000, 0.5]);
+  });
+
+  it('defaults to color 0 and alpha 1', () => {
+    const shape = createShape();
+    appendShapeBeginFill(shape);
+    expect(shape.data.commands).toEqual(['beginFill', 2, 0, 1]);
+  });
+});
+
+describe('appendShapeBeginGradientFill', () => {
+  it('pushes a beginGradientFill command with all fields', () => {
+    const shape = createShape();
+    appendShapeBeginGradientFill(
+      shape,
+      'linear',
+      [0xff0000, 0x0000ff],
+      [1, 1],
+      [0, 255],
+      fakeMatrix,
+      'reflect',
+      'linearRGB',
+      0.5,
+    );
+    expect(shape.data.commands).toEqual([
+      'beginGradientFill',
+      8,
+      'linear',
+      [0xff0000, 0x0000ff],
+      [1, 1],
+      [0, 255],
+      fakeMatrix,
+      'reflect',
+      'linearRGB',
+      0.5,
+    ]);
+  });
+
+  it('defaults matrix null, spreadMethod pad, interpolationMethod rgb, focalPointRatio 0', () => {
+    const shape = createShape();
+    appendShapeBeginGradientFill(shape, 'radial', [0xffffff], [1], [0]);
+    expect(shape.data.commands).toEqual([
+      'beginGradientFill',
+      8,
+      'radial',
+      [0xffffff],
+      [1],
+      [0],
+      null,
+      'pad',
+      'rgb',
+      0,
+    ]);
+  });
+});
+
+describe('appendShapeCircle', () => {
+  it('pushes a drawCircle command with position and radius', () => {
+    const shape = createShape();
+    appendShapeCircle(shape, 50, 50, 25);
+    expect(shape.data.commands).toEqual(['drawCircle', 3, 50, 50, 25]);
+  });
+});
+
+describe('appendShapeCubicCurveTo', () => {
+  it('pushes a cubicCurveTo command with all control and anchor points', () => {
+    const shape = createShape();
+    appendShapeCubicCurveTo(shape, 10, 20, 30, 40, 50, 60);
+    expect(shape.data.commands).toEqual(['cubicCurveTo', 6, 10, 20, 30, 40, 50, 60]);
+  });
+});
+
+describe('appendShapeCurveTo', () => {
+  it('pushes a curveTo command with control and anchor points', () => {
+    const shape = createShape();
+    appendShapeCurveTo(shape, 10, 20, 30, 40);
+    expect(shape.data.commands).toEqual(['curveTo', 4, 10, 20, 30, 40]);
+  });
+});
+
+describe('appendShapeDrawTriangles', () => {
+  it('pushes a drawTriangles command with vertices, null indices, null uvtData, and culling none', () => {
+    const shape = createShape();
+    const verts = [0, 0, 100, 0, 50, 80];
+    appendShapeDrawTriangles(shape, verts);
+    expect(shape.data.commands).toEqual(['drawTriangles', 4, verts, null, null, 'none']);
+  });
+
+  it('pushes a drawTriangles command with indices and uvtData', () => {
+    const shape = createShape();
+    const verts = [0, 0, 100, 0, 50, 80];
+    const indices = [0, 1, 2];
+    const uvt = [0, 0, 1, 0, 0.5, 1];
+    appendShapeDrawTriangles(shape, verts, indices, uvt, 'positive');
+    expect(shape.data.commands).toEqual(['drawTriangles', 4, verts, indices, uvt, 'positive']);
+  });
+});
+
+describe('appendShapeEllipse', () => {
+  it('pushes a drawEllipse command with position and dimensions', () => {
+    const shape = createShape();
+    appendShapeEllipse(shape, 10, 20, 100, 50);
+    expect(shape.data.commands).toEqual(['drawEllipse', 4, 10, 20, 100, 50]);
+  });
+});
+
+describe('appendShapeEndFill', () => {
+  it('pushes an endFill command', () => {
+    const shape = createShape();
+    appendShapeEndFill(shape);
+    expect(shape.data.commands).toEqual(['endFill', 0]);
+  });
+});
+
+describe('appendShapeLineBitmapStyle', () => {
+  it('pushes a lineBitmapStyle command with bitmap, matrix, repeat, smooth', () => {
+    const shape = createShape();
+    appendShapeLineBitmapStyle(shape, fakeImageSource, fakeMatrix, false, true);
+    expect(shape.data.commands).toEqual(['lineBitmapStyle', 4, fakeImageSource, fakeMatrix, false, true]);
+  });
+
+  it('defaults matrix to null, repeat to true, smooth to false', () => {
+    const shape = createShape();
+    appendShapeLineBitmapStyle(shape, fakeImageSource);
+    expect(shape.data.commands).toEqual(['lineBitmapStyle', 4, fakeImageSource, null, true, false]);
+  });
+});
+
+describe('appendShapeLineGradientStyle', () => {
+  it('pushes a lineGradientStyle command with all fields', () => {
+    const shape = createShape();
+    appendShapeLineGradientStyle(shape, 'linear', [0xff0000], [1], [0]);
+    expect(shape.data.commands).toEqual([
+      'lineGradientStyle',
+      8,
+      'linear',
+      [0xff0000],
+      [1],
+      [0],
+      null,
+      'pad',
+      'rgb',
+      0,
+    ]);
+  });
+});
+
+describe('appendShapeLineStyle', () => {
+  it('pushes a lineStyle command with all parameters', () => {
+    const shape = createShape();
+    appendShapeLineStyle(shape, 2, 0x0000ff, 0.8, true, 'horizontal', 'round', 'bevel', 5);
+    expect(shape.data.commands).toEqual(['lineStyle', 8, 2, 0x0000ff, 0.8, true, 'horizontal', 'round', 'bevel', 5]);
+  });
+
+  it('defaults thickness 1, color 0, alpha 1, pixelHinting false, scaleMode normal, caps none, joints round, miterLimit 3', () => {
+    const shape = createShape();
+    appendShapeLineStyle(shape);
+    expect(shape.data.commands).toEqual(['lineStyle', 8, 1, 0, 1, false, 'normal', 'none', 'round', 3]);
+  });
+});
+
+describe('appendShapeLineTo', () => {
+  it('pushes a lineTo command with position', () => {
+    const shape = createShape();
+    appendShapeLineTo(shape, 100, 200);
+    expect(shape.data.commands).toEqual(['lineTo', 2, 100, 200]);
+  });
+});
+
+describe('appendShapeMoveTo', () => {
+  it('pushes a moveTo command with position', () => {
+    const shape = createShape();
+    appendShapeMoveTo(shape, 10, 20);
+    expect(shape.data.commands).toEqual(['moveTo', 2, 10, 20]);
+  });
+});
+
+describe('appendShapePath', () => {
+  it('pushes a drawPath command with commands, data, and winding', () => {
+    const shape = createShape();
+    const cmds = [PathCommand.MOVE_TO, PathCommand.LINE_TO];
+    appendShapePath(shape, cmds, [0, 0, 100, 100], 'nonZero');
+    expect(shape.data.commands).toEqual(['drawPath', 3, cmds, [0, 0, 100, 100], 'nonZero']);
+  });
+
+  it('defaults winding to evenOdd', () => {
+    const shape = createShape();
+    appendShapePath(shape, [], []);
+    expect(shape.data.commands).toEqual(['drawPath', 3, [], [], 'evenOdd']);
+  });
+});
+
+describe('appendShapePolygon', () => {
+  it('emits moveTo + lineTo commands and closes back to first vertex', () => {
+    const shape = createShape();
+    appendShapePolygon(shape, [0, 0, 100, 0, 50, 80]);
+    const keys: string[] = [];
+    let i = 0;
+    while (i < shape.data.commands.length) {
+      const key = shape.data.commands[i] as string;
+      const argCount = shape.data.commands[i + 1] as number;
+      keys.push(key);
+      i += argCount + 2;
+    }
+    // moveTo + 2 lineTo + 1 closing lineTo = 4 entries.
+    expect(keys).toEqual(['moveTo', 'lineTo', 'lineTo', 'lineTo']);
+    // The last lineTo should return to (0, 0).
+    const lastIdx = shape.data.commands.length - 4; // lineTo has argCount=2, so 4 elements from end
+    expect(shape.data.commands[lastIdx + 2]).toBe(0);
+    expect(shape.data.commands[lastIdx + 3]).toBe(0);
+  });
+
+  it('emits nothing for fewer than 2 points', () => {
+    const shape = createShape();
+    appendShapePolygon(shape, [0, 0]);
+    expect(shape.data.commands).toHaveLength(0);
+  });
+});
+
+describe('appendShapePolyline', () => {
+  it('emits moveTo + lineTo commands without closing', () => {
+    const shape = createShape();
+    appendShapePolyline(shape, [0, 0, 50, 50, 100, 0]);
+    const keys: string[] = [];
+    let i = 0;
+    while (i < shape.data.commands.length) {
+      const key = shape.data.commands[i] as string;
+      const argCount = shape.data.commands[i + 1] as number;
+      keys.push(key);
+      i += argCount + 2;
+    }
+    // moveTo + 2 lineTo; no closing lineTo.
+    expect(keys).toEqual(['moveTo', 'lineTo', 'lineTo']);
+  });
+
+  it('emits nothing for fewer than 2 points', () => {
+    const shape = createShape();
+    appendShapePolyline(shape, [0, 0]);
+    expect(shape.data.commands).toHaveLength(0);
+  });
+});
+
+describe('appendShapeRectangle', () => {
+  it('pushes a drawRectangle command with position and dimensions', () => {
+    const shape = createShape();
+    appendShapeRectangle(shape, 10, 20, 100, 50);
+    expect(shape.data.commands).toEqual(['drawRectangle', 4, 10, 20, 100, 50]);
+  });
+});
+
+describe('appendShapeRoundRectangle', () => {
+  it('pushes a drawRoundRectangle command with position, dimensions, and corner radii', () => {
+    const shape = createShape();
+    appendShapeRoundRectangle(shape, 0, 0, 100, 50, 10, 8);
+    expect(shape.data.commands).toEqual(['drawRoundRectangle', 6, 0, 0, 100, 50, 10, 8]);
+  });
+});
+
+describe('appendShapeRoundRectangleVarying', () => {
+  it('expands to moveTo/lineTo/curveTo commands (no new command type)', () => {
+    const shape = createShape();
+    appendShapeRoundRectangleVarying(shape, 0, 0, 100, 50, 5, 5, 5, 5);
+    const knownPrimitives = ['moveTo', 'lineTo', 'curveTo'];
+    const keys: string[] = [];
+    let i = 0;
+    while (i < shape.data.commands.length) {
+      const key = shape.data.commands[i] as string;
+      const argCount = shape.data.commands[i + 1] as number;
+      keys.push(key);
+      i += argCount + 2;
+    }
+    expect(keys.length).toBeGreaterThan(1);
+    expect(keys.every((k) => knownPrimitives.includes(k))).toBe(true);
+  });
+});
+
+describe('PathCommand', () => {
+  it('has expected numeric values', () => {
+    expect(PathCommand.NO_OP).toBe(0);
+    expect(PathCommand.MOVE_TO).toBe(1);
+    expect(PathCommand.LINE_TO).toBe(2);
+    expect(PathCommand.CURVE_TO).toBe(3);
+    expect(PathCommand.WIDE_MOVE_TO).toBe(4);
+    expect(PathCommand.WIDE_LINE_TO).toBe(5);
+    expect(PathCommand.CUBIC_CURVE_TO).toBe(6);
+  });
+});

package/src/shapeFill.test.ts

@@ -0,0 +1,116 @@
+import { PathCommand } from '@flighthq/types';
+
+import { createShape } from './shape';
+import {
+  appendShapeBeginFill,
+  appendShapeBeginGradientFill,
+  appendShapeCircle,
+  appendShapeEndFill,
+  appendShapeLineStyle,
+  appendShapeLineTo,
+  appendShapeMoveTo,
+  appendShapeRectangle,
+} from './shapeCommands';
+import { getShapeFillRegions, hasNonSolidShapeFill } from './shapeFill';
+
+describe('getShapeFillRegions', () => {
+  it('resolves a solid rectangle fill into one region with a closed outline', () => {
+    const shape = createShape();
+    appendShapeBeginFill(shape, 0xff0000, 1);
+    appendShapeRectangle(shape, 10, 20, 100, 50);
+    appendShapeEndFill(shape);
+
+    const regions = getShapeFillRegions(shape.data.commands);
+
+    expect(regions).not.toBeNull();
+    expect(regions!.length).toBe(1);
+    expect(regions![0].color).toBe(0xff0000);
+    expect(regions![0].alpha).toBe(1);
+    expect(regions![0].path.commands).toEqual([
+      PathCommand.MOVE_TO,
+      PathCommand.LINE_TO,
+      PathCommand.LINE_TO,
+      PathCommand.LINE_TO,
+      PathCommand.LINE_TO,
+    ]);
+    expect(regions![0].path.data.slice(0, 4)).toEqual([10, 20, 110, 20]);
+  });
+
+  it('expands a circle into four cubic curves', () => {
+    const shape = createShape();
+    appendShapeBeginFill(shape, 0x00ff00);
+    appendShapeCircle(shape, 50, 50, 20);
+    appendShapeEndFill(shape);
+
+    const regions = getShapeFillRegions(shape.data.commands)!;
+    expect(regions[0].path.commands).toEqual([
+      PathCommand.MOVE_TO,
+      PathCommand.CUBIC_CURVE_TO,
+      PathCommand.CUBIC_CURVE_TO,
+      PathCommand.CUBIC_CURVE_TO,
+      PathCommand.CUBIC_CURVE_TO,
+    ]);
+    // Starts at the rightmost point (cx + r, cy).
+    expect(regions[0].path.data.slice(0, 2)).toEqual([70, 50]);
+  });
+
+  it('resolves a moveTo/lineTo polygon fill', () => {
+    const shape = createShape();
+    appendShapeBeginFill(shape, 0x0000ff);
+    appendShapeMoveTo(shape, 0, 0);
+    appendShapeLineTo(shape, 100, 0);
+    appendShapeLineTo(shape, 50, 80);
+    appendShapeEndFill(shape);
+
+    const regions = getShapeFillRegions(shape.data.commands)!;
+    expect(regions.length).toBe(1);
+    expect(regions[0].path.commands).toEqual([PathCommand.MOVE_TO, PathCommand.LINE_TO, PathCommand.LINE_TO]);
+  });
+
+  it('returns a region per fill span when fills are not explicitly ended', () => {
+    const shape = createShape();
+    appendShapeBeginFill(shape, 0x111111);
+    appendShapeRectangle(shape, 0, 0, 10, 10);
+    appendShapeBeginFill(shape, 0x222222);
+    appendShapeRectangle(shape, 20, 20, 10, 10);
+    appendShapeEndFill(shape);
+
+    const regions = getShapeFillRegions(shape.data.commands)!;
+    expect(regions.map((r) => r.color)).toEqual([0x111111, 0x222222]);
+  });
+
+  it('returns null for a gradient fill (falls back to raster)', () => {
+    const shape = createShape();
+    appendShapeBeginGradientFill(shape, 'linear', [0xff0000, 0x0000ff], [1, 1], [0, 255]);
+    appendShapeRectangle(shape, 0, 0, 10, 10);
+    appendShapeEndFill(shape);
+
+    expect(getShapeFillRegions(shape.data.commands)).toBeNull();
+  });
+
+  it('returns null when a stroke is present', () => {
+    const shape = createShape();
+    appendShapeLineStyle(shape, 2, 0x000000);
+    appendShapeBeginFill(shape, 0xff0000);
+    appendShapeRectangle(shape, 0, 0, 10, 10);
+    appendShapeEndFill(shape);
+
+    expect(getShapeFillRegions(shape.data.commands)).toBeNull();
+  });
+});
+
+describe('hasNonSolidShapeFill', () => {
+  it('is false for solid fills only', () => {
+    const shape = createShape();
+    appendShapeBeginFill(shape, 0xff0000);
+    appendShapeRectangle(shape, 0, 0, 10, 10);
+    appendShapeEndFill(shape);
+    expect(hasNonSolidShapeFill(shape.data.commands)).toBe(false);
+  });
+
+  it('is true when a bitmap or gradient fill or stroke is present', () => {
+    const shape = createShape();
+    appendShapeLineStyle(shape, 1, 0);
+    expect(hasNonSolidShapeFill(shape.data.commands)).toBe(true);
+  });
+});

package/src/shapeHitTestBuiltins.test.ts

@@ -0,0 +1,77 @@
+import { enableShapeHitTesting } from './shapeHitTestBuiltins';
+import { hitTestShapeCommandPoint } from './shapeHitTestRegistry';
+
+// Call once to register built-in handlers for this test module.
+enableShapeHitTesting();
+
+describe('enableShapeHitTesting', () => {
+  describe('drawCircle', () => {
+    it('returns true for a point inside the circle', () => {
+      const buf = ['drawCircle', 3, 50, 50, 25];
+      expect(hitTestShapeCommandPoint(buf, 0, 50, 50)).toBe(true);
+    });
+    it('returns true for a point exactly on the edge', () => {
+      const buf = ['drawCircle', 3, 0, 0, 10];
+      expect(hitTestShapeCommandPoint(buf, 0, 10, 0)).toBe(true);
+    });
+    it('returns false for a point outside the circle', () => {
+      const buf = ['drawCircle', 3, 50, 50, 25];
+      expect(hitTestShapeCommandPoint(buf, 0, 100, 100)).toBe(false);
+    });
+  });
+
+  describe('drawEllipse', () => {
+    it('returns true for a point at the ellipse center', () => {
+      // drawEllipse args: x (top-left), y (top-left), width, height
+      const buf = ['drawEllipse', 4, 0, 0, 100, 60];
+      expect(hitTestShapeCommandPoint(buf, 0, 50, 30)).toBe(true);
+    });
+    it('returns false for a point outside the ellipse', () => {
+      const buf = ['drawEllipse', 4, 0, 0, 100, 60];
+      expect(hitTestShapeCommandPoint(buf, 0, 0, 0)).toBe(false);
+    });
+  });
+
+  describe('drawRectangle', () => {
+    it('returns true for a point inside the rectangle', () => {
+      const buf = ['drawRectangle', 4, 10, 10, 80, 60];
+      expect(hitTestShapeCommandPoint(buf, 0, 50, 40)).toBe(true);
+    });
+    it('returns true for a point on the rectangle edge', () => {
+      const buf = ['drawRectangle', 4, 10, 10, 80, 60];
+      expect(hitTestShapeCommandPoint(buf, 0, 10, 10)).toBe(true);
+    });
+    it('returns false for a point outside the rectangle', () => {
+      const buf = ['drawRectangle', 4, 10, 10, 80, 60];
+      expect(hitTestShapeCommandPoint(buf, 0, 0, 0)).toBe(false);
+    });
+  });
+
+  describe('drawRoundRectangle', () => {
+    it('returns true for a point in the rectangular bounds', () => {
+      const buf = ['drawRoundRectangle', 6, 0, 0, 100, 50, 10, 10];
+      expect(hitTestShapeCommandPoint(buf, 0, 50, 25)).toBe(true);
+    });
+    it('returns false for a point outside the rectangular bounds', () => {
+      const buf = ['drawRoundRectangle', 6, 0, 0, 100, 50, 10, 10];
+      expect(hitTestShapeCommandPoint(buf, 0, 200, 200)).toBe(false);
+    });
+    it('returns false for a point in the corner cutout region', () => {
+      // With ellipseWidth=40, ellipseHeight=40: corner arcs have rx=cy=20.
+      // The very corner (0, 0) is outside the rounded shape.
+      const buf = ['drawRoundRectangle', 6, 0, 0, 100, 100, 40, 40];
+      // (1, 1) is in the corner cutout — distance from corner center (20, 20) is sqrt(361)~19,
+      // which is < 20 so it's inside the ellipse. Actually let's test a clearly-outside corner:
+      // corner ellipse center is at (20, 20) with rx=ry=20; (2, 2) is dist ~18/20=0.9 < 1 => inside.
+      // Use (0, 0) — normalized: (0-20)/20, (0-20)/20 => (-1, -1) => 1+1=2 > 1 => outside.
+      expect(hitTestShapeCommandPoint(buf, 0, 0, 0)).toBe(false);
+    });
+    it('returns true for a point on the rounded corner arc boundary', () => {
+      // Corner center at (20, 20) with rx=ry=20; point at (20, 0) is exactly on the top edge.
+      const buf = ['drawRoundRectangle', 6, 0, 0, 100, 100, 40, 40];
+      // (20, 0): corner check: inLeft=(20<20)=false, inTop=(0<20)=true, inRight=false.
+      // Since not both inLeft/inRight AND inTop/inBottom, falls to the cross check → inside.
+      expect(hitTestShapeCommandPoint(buf, 0, 20, 0)).toBe(true);
+    });
+  });
+});

package/src/shapeHitTestRegistry.test.ts

@@ -0,0 +1,45 @@
+import type { ShapeCommandKey } from '@flighthq/types';
+
+import { hitTestShapeCommandPoint, registerShapeHitTestCommand } from './shapeHitTestRegistry';
+
+describe('hitTestShapeCommandPoint', () => {
+  it('returns null for an unregistered command key', () => {
+    const buf: unknown[] = ['__unregistered__', 0];
+    expect(hitTestShapeCommandPoint(buf, 0, 0, 0)).toBeNull();
+  });
+
+  it('passes x, y, buf, and i+2 to the registered handler', () => {
+    const fn = vi.fn().mockReturnValue(false);
+    registerShapeHitTestCommand({ key: 'moveTo' as ShapeCommandKey, hitTest: fn });
+    const buf: unknown[] = ['moveTo', 2, 10, 20];
+    hitTestShapeCommandPoint(buf, 0, 5, 7);
+    expect(fn).toHaveBeenCalledWith(5, 7, buf, 2);
+  });
+
+  it('returns the handler return value', () => {
+    registerShapeHitTestCommand({ key: 'endFill' as ShapeCommandKey, hitTest: () => true });
+    const buf: unknown[] = ['endFill', 0];
+    expect(hitTestShapeCommandPoint(buf, 0, 0, 0)).toBe(true);
+  });
+});
+
+describe('registerShapeHitTestCommand', () => {
+  it('registers a handler that hitTestShapeCommandPoint can retrieve', () => {
+    const fn = vi.fn().mockReturnValue(true);
+    registerShapeHitTestCommand({ key: 'drawRectangle' as ShapeCommandKey, hitTest: fn });
+    const buf: unknown[] = ['drawRectangle', 4, 0, 0, 100, 100];
+    const result = hitTestShapeCommandPoint(buf, 0, 50, 50);
+    expect(result).toBe(true);
+  });
+
+  it('replaces an existing handler when registered again', () => {
+    const first = vi.fn().mockReturnValue(false);
+    const second = vi.fn().mockReturnValue(true);
+    registerShapeHitTestCommand({ key: 'drawCircle' as ShapeCommandKey, hitTest: first });
+    registerShapeHitTestCommand({ key: 'drawCircle' as ShapeCommandKey, hitTest: second });
+    const buf: unknown[] = ['drawCircle', 3, 50, 50, 25];
+    hitTestShapeCommandPoint(buf, 0, 50, 50);
+    expect(second).toHaveBeenCalled();
+    expect(first).not.toHaveBeenCalled();
+  });
+});