@flighthq/path-boolean 0.5.1-next.3302.76ece6b → 0.5.1-next.4304.322dc96

package/src/resolvePathRegions.test.ts

@@ -1,50 +1,61 @@
+// Generated from crates/flight-path-boolean/tests/resolve_path_regions_test.rs by flight-compiler.
+// Rust is authoritative; run `npm run generate` after changing it.
+
 import { createPath, flattenPath } from '@flighthq/path/contract';
-import type { Path } from '@flighthq/types/contract';
+import type { Path } from '@flighthq/path/contract';
 import { describe, expect, it } from 'vitest';
 
-import { martinezPathBooleanKernel } from './martinezKernel.ts';
-import { resolvePathRegions } from './resolvePathRegions.ts';
+import { createMartinezPathBooleanKernel, resolvePathRegions } from './contract.ts';
 
-const kernel = martinezPathBooleanKernel;
+function flattenedPath(path: Readonly<Path>, tolerance: number | undefined): number[][] {
+  const out = flattenPath(path, tolerance);
+  return out;
+}
 
 function pathArea(path: Readonly<Path>): number {
-  let total = 0;
-  for (const ring of flattenPath(path)) {
-    let area = 0;
+  let total: number = 0.0;
+  for (const ring of flattenedPath(path, 0.25)) {
+    let area: number = 0.0;
     const n = ring.length >> 1;
-    for (let i = 0, j = n - 1; i < n; j = i++) area += ring[j * 2] * ring[i * 2 + 1] - ring[i * 2] * ring[j * 2 + 1];
-    total += area / 2;
+    let j = n - 1;
+    for (let i = 0; i < n; i += 1) {
+      area += ring[j * 2] * ring[i * 2 + 1] - ring[i * 2] * ring[j * 2 + 1];
+      j = i;
+    }
+    total += area / 2.0;
   }
   return Math.abs(total);
 }
 
 function ringCount(path: Readonly<Path>): number {
-  return flattenPath(path).length;
+  return flattenedPath(path, 0.25).length;
 }
 
-const SQUARE_A = [0, 0, 4, 0, 4, 4, 0, 4];
-const SQUARE_B = [2, 2, 6, 2, 6, 6, 2, 6];
-
 describe('resolvePathRegions', () => {
   it('returns an empty path for no rings', () => {
-    const result = createPath('evenOdd');
-    resolvePathRegions(result, kernel, [], 'nonZero');
-    expect(result.commands).toHaveLength(0);
-    expect(result.data).toHaveLength(0);
-    expect(result.winding).toBe('nonZero');
+    const kernel = createMartinezPathBooleanKernel();
+    let out = createPath('nonZero');
+    resolvePathRegions(out, kernel, [], 'nonZero');
+    expect(out.commands.length).toEqual(0);
+    expect(out.data.length).toEqual(0);
+    expect(out.winding).toEqual('nonZero');
   });
-
-  it('self-unions overlapping rings into one outline under nonZero', () => {
-    const result = createPath('nonZero');
-    resolvePathRegions(result, kernel, [SQUARE_A, SQUARE_B], 'nonZero');
-    expect(ringCount(result)).toBe(1);
-    expect(pathArea(result)).toBeCloseTo(28, 6);
+  it('self unions overlapping rings into one outline under non zero', () => {
+    const kernel = createMartinezPathBooleanKernel();
+    const squareA = [0.0, 0.0, 4.0, 0.0, 4.0, 4.0, 0.0, 4.0];
+    const squareB = [2.0, 2.0, 6.0, 2.0, 6.0, 6.0, 2.0, 6.0];
+    let out = createPath('nonZero');
+    resolvePathRegions(out, kernel, [squareA, squareB], 'nonZero');
+    expect(ringCount(out)).toEqual(1);
+    expect(Math.abs(pathArea(out) - 28.0) < 5e-7).toBe(true);
   });
-
-  it('applies the fill rule to self-overlap under evenOdd', () => {
-    const result = createPath('nonZero');
-    resolvePathRegions(result, kernel, [SQUARE_A, SQUARE_B], 'evenOdd');
-    expect(pathArea(result)).toBeCloseTo(24, 6);
-    expect(ringCount(result)).toBeGreaterThan(1);
+  it('applies the fill rule to self overlap under even odd', () => {
+    const kernel = createMartinezPathBooleanKernel();
+    const squareA = [0.0, 0.0, 4.0, 0.0, 4.0, 4.0, 0.0, 4.0];
+    const squareB = [2.0, 2.0, 6.0, 2.0, 6.0, 6.0, 2.0, 6.0];
+    let out = createPath('nonZero');
+    resolvePathRegions(out, kernel, [squareA, squareB], 'evenOdd');
+    expect(Math.abs(pathArea(out) - 24.0) < 5e-7).toBe(true);
+    expect(ringCount(out) > 1).toBe(true);
   });
 });

package/src/simplifyPath.test.ts

@@ -1,152 +1,183 @@
+// Generated from crates/flight-path-boolean/tests/simplify_path_test.rs by flight-compiler.
+// Rust is authoritative; run `npm run generate` after changing it.
+
 import { appendPathClose, appendPathLineTo, appendPathMoveTo, createPath, flattenPath } from '@flighthq/path/contract';
-import type { Path, PathWinding } from '@flighthq/types/contract';
+import type { Path } from '@flighthq/path/contract';
 import { describe, expect, it } from 'vitest';
 
-import { martinezPathBooleanKernel } from './martinezKernel.ts';
-import { simplifyPath } from './simplifyPath.ts';
+import { createMartinezPathBooleanKernel, simplifyPath } from './contract.ts';
+import type { PathBooleanOptions } from './contract.ts';
+
+const BOWTIE: Float64Array = new Float64Array([0.0, 0.0, 2.0, 2.0, 2.0, 0.0, 0.0, 2.0]);
+
+const UNIT_SQUARE: Float64Array = new Float64Array([0.0, 0.0, 3.0, 0.0, 3.0, 3.0, 0.0, 3.0]);
 
-const kernel = martinezPathBooleanKernel;
+function flattenedPath(path: Readonly<Path>, tolerance: number | undefined): number[][] {
+  const out = flattenPath(path, tolerance);
+  return out;
+}
 
-function polygonPath(vertices: readonly number[], winding: PathWinding = 'nonZero'): Path {
-  const path = createPath(winding);
+function polygonPath(vertices: Readonly<number[]>): Path {
+  let path = createPath('nonZero');
   appendPathMoveTo(path, vertices[0], vertices[1]);
-  for (let i = 2; i < vertices.length; i += 2) appendPathLineTo(path, vertices[i], vertices[i + 1]);
+  let i = 2;
+  while (i < vertices.length) {
+    appendPathLineTo(path, vertices[i], vertices[i + 1]);
+    i += 2;
+  }
   appendPathClose(path);
   return path;
 }
 
-function pathBounds(path: Readonly<Path>): { minX: number; minY: number; maxX: number; maxY: number } {
-  let minX = Infinity;
-  let minY = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  for (const ring of flattenPath(path)) {
-    for (let i = 0; i < ring.length; i += 2) {
-      minX = Math.min(minX, ring[i]);
-      minY = Math.min(minY, ring[i + 1]);
-      maxX = Math.max(maxX, ring[i]);
-      maxY = Math.max(maxY, ring[i + 1]);
+function pathArea(path: Readonly<Path>): number {
+  let total: number = 0.0;
+  for (const ring of flattenedPath(path, 0.25)) {
+    let area: number = 0.0;
+    const n = ring.length >> 1;
+    let j = n - 1;
+    for (let i = 0; i < n; i += 1) {
+      area += ring[j * 2] * ring[i * 2 + 1] - ring[i * 2] * ring[j * 2 + 1];
+      j = i;
     }
+    total += area / 2.0;
   }
-  return { minX, minY, maxX, maxY };
+  return Math.abs(total);
 }
 
-function pathArea(path: Readonly<Path>): number {
-  let total = 0;
-  for (const ring of flattenPath(path)) {
-    let area = 0;
-    const n = ring.length >> 1;
-    for (let i = 0, j = n - 1; i < n; j = i++) area += ring[j * 2] * ring[i * 2 + 1] - ring[i * 2] * ring[j * 2 + 1];
-    total += area / 2;
+function pathBounds(path: Readonly<Path>): readonly [number, number, number, number] {
+  let minX = Number.POSITIVE_INFINITY;
+  let minY = Number.POSITIVE_INFINITY;
+  let maxX = Number.NEGATIVE_INFINITY;
+  let maxY = Number.NEGATIVE_INFINITY;
+  for (const ring of flattenedPath(path, 0.25)) {
+    let i = 0;
+    while (i < ring.length) {
+      if (ring[i] < minX) {
+        minX = ring[i];
+      }
+      if (ring[i + 1] < minY) {
+        minY = ring[i + 1];
+      }
+      if (ring[i] > maxX) {
+        maxX = ring[i];
+      }
+      if (ring[i + 1] > maxY) {
+        maxY = ring[i + 1];
+      }
+      i += 2;
+    }
   }
-  return Math.abs(total);
+  return [minX, minY, maxX, maxY];
 }
 
 function ringCount(path: Readonly<Path>): number {
-  return flattenPath(path).length;
+  return flattenedPath(path, 0.25).length;
 }
 
-function pentagramPath(radius: number, winding: PathWinding): Path {
+function pentagramPath(radius: number): Path {
   const order = [0, 2, 4, 1, 3];
-  const vertices: number[] = [];
+  let vertices: number[] = [] as never[];
   for (const k of order) {
-    const angle = -Math.PI / 2 + (k * 2 * Math.PI) / 5;
-    vertices.push(radius * Math.cos(angle), radius * Math.sin(angle));
+    const angle = -(Math.PI / 2.0) + (k * 2.0 * Math.PI) / 5.0;
+    vertices.push(radius * Math.cos(angle));
+    vertices.push(radius * Math.sin(angle));
   }
-  return polygonPath(vertices, winding);
+  return polygonPath(vertices);
 }
 
-const BOWTIE = [0, 0, 2, 2, 2, 0, 0, 2];
-
-const UNIT_SQUARE = [0, 0, 3, 0, 3, 3, 0, 3];
-
 describe('simplifyPath', () => {
-  it('writes into an existing output and is alias-safe', () => {
-    const path = polygonPath(BOWTIE);
-    simplifyPath(path, kernel, path);
-
-    expect(ringCount(path)).toBe(2);
-    expect(pathArea(path)).toBeCloseTo(2, 6);
+  it('writes into an existing output using a distinct source snapshot', () => {
+    const kernel = createMartinezPathBooleanKernel();
+    let path = polygonPath(Array.from(BOWTIE));
+    const pathClone = path;
+    simplifyPath(path, kernel, pathClone, undefined);
+    expect(ringCount(path)).toEqual(2);
+    expect(Math.abs(pathArea(path) - 2.0) < 5e-7).toBe(true);
   });
-
-  it('resolves a self-intersecting bowtie into two triangles', () => {
-    const result = createPath();
-    simplifyPath(result, kernel, polygonPath(BOWTIE));
-    expect(ringCount(result)).toBe(2);
-    expect(pathArea(result)).toBeCloseTo(2, 6);
+  it('resolves a self intersecting bowtie into two triangles', () => {
+    const kernel = createMartinezPathBooleanKernel();
+    let out = createPath('nonZero');
+    simplifyPath(out, kernel, polygonPath(Array.from(BOWTIE)), undefined);
+    expect(ringCount(out)).toEqual(2);
+    expect(Math.abs(pathArea(out) - 2.0) < 5e-7).toBe(true);
   });
-
-  it('fills a self-overlapping region solid under nonZero', () => {
-    const path = createPath('nonZero');
-    appendPathMoveTo(path, 0, 0);
-    appendPathLineTo(path, 4, 0);
-    appendPathLineTo(path, 4, 4);
-    appendPathLineTo(path, 0, 4);
+  it('fills a self overlapping region solid under non zero', () => {
+    const kernel = createMartinezPathBooleanKernel();
+    let path = createPath('nonZero');
+    appendPathMoveTo(path, 0.0, 0.0);
+    appendPathLineTo(path, 4.0, 0.0);
+    appendPathLineTo(path, 4.0, 4.0);
+    appendPathLineTo(path, 0.0, 4.0);
     appendPathClose(path);
-    appendPathMoveTo(path, 2, 2);
-    appendPathLineTo(path, 6, 2);
-    appendPathLineTo(path, 6, 6);
-    appendPathLineTo(path, 2, 6);
+    appendPathMoveTo(path, 2.0, 2.0);
+    appendPathLineTo(path, 6.0, 2.0);
+    appendPathLineTo(path, 6.0, 6.0);
+    appendPathLineTo(path, 2.0, 6.0);
     appendPathClose(path);
-    const result = createPath();
-    simplifyPath(result, kernel, path, { fillRule: 'nonZero' });
-    expect(ringCount(result)).toBe(1);
-    expect(pathArea(result)).toBeCloseTo(28, 6);
+    const opts: PathBooleanOptions = { fillRule: 'nonZero', tolerance: undefined } as const;
+    let out = createPath('nonZero');
+    simplifyPath(out, kernel, path, opts);
+    expect(ringCount(out)).toEqual(1);
+    expect(Math.abs(pathArea(out) - 28.0) < 5e-7).toBe(true);
   });
-
-  it('punches an even-odd hole through a self-overlapping region', () => {
-    const path = createPath('evenOdd');
-    appendPathMoveTo(path, 0, 0);
-    appendPathLineTo(path, 4, 0);
-    appendPathLineTo(path, 4, 4);
-    appendPathLineTo(path, 0, 4);
+  it('punches an even odd hole through a self overlapping region', () => {
+    const kernel = createMartinezPathBooleanKernel();
+    let path = createPath('nonZero');
+    path.winding = 'evenOdd';
+    appendPathMoveTo(path, 0.0, 0.0);
+    appendPathLineTo(path, 4.0, 0.0);
+    appendPathLineTo(path, 4.0, 4.0);
+    appendPathLineTo(path, 0.0, 4.0);
     appendPathClose(path);
-    appendPathMoveTo(path, 2, 2);
-    appendPathLineTo(path, 6, 2);
-    appendPathLineTo(path, 6, 6);
-    appendPathLineTo(path, 2, 6);
+    appendPathMoveTo(path, 2.0, 2.0);
+    appendPathLineTo(path, 6.0, 2.0);
+    appendPathLineTo(path, 6.0, 6.0);
+    appendPathLineTo(path, 2.0, 6.0);
     appendPathClose(path);
-    const result = createPath();
-    simplifyPath(result, kernel, path, { fillRule: 'evenOdd' });
-    expect(pathArea(result)).toBeCloseTo(24, 6);
-    expect(ringCount(result)).toBeGreaterThan(1);
+    const opts: PathBooleanOptions = { fillRule: 'evenOdd', tolerance: undefined } as const;
+    let out = createPath('nonZero');
+    simplifyPath(out, kernel, path, opts);
+    expect(Math.abs(pathArea(out) - 24.0) < 5e-7).toBe(true);
+    expect(ringCount(out) > 1).toBe(true);
   });
-
-  it('fills a self-overlapping star solid under nonZero but hollow under evenOdd', () => {
-    const solid = createPath();
-    const hollow = createPath();
-    simplifyPath(solid, kernel, pentagramPath(10, 'nonZero'), { fillRule: 'nonZero' });
-    simplifyPath(hollow, kernel, pentagramPath(10, 'evenOdd'), { fillRule: 'evenOdd' });
-    expect(ringCount(solid)).toBe(1);
-    expect(pathArea(solid)).toBeCloseTo(112.257, 2);
-    expect(ringCount(hollow)).toBeGreaterThan(1);
-    expect(pathArea(hollow)).toBeCloseTo(77.568, 2);
-    expect(pathArea(hollow)).toBeLessThan(pathArea(solid));
+  it('fills a pentagram solid under non zero but hollow under even odd', () => {
+    const kernel = createMartinezPathBooleanKernel();
+    const nzOpts: PathBooleanOptions = { fillRule: 'nonZero', tolerance: undefined } as const;
+    const eoOpts: PathBooleanOptions = { fillRule: 'evenOdd', tolerance: undefined } as const;
+    let solid = createPath('nonZero');
+    let hollow = createPath('nonZero');
+    simplifyPath(solid, kernel, pentagramPath(10.0), nzOpts);
+    simplifyPath(hollow, kernel, pentagramPath(10.0), eoOpts);
+    expect(ringCount(solid)).toEqual(1);
+    expect(Math.abs(pathArea(solid) - 112.257) < 0.005).toBe(true);
+    expect(ringCount(hollow) > 1).toBe(true);
+    expect(Math.abs(pathArea(hollow) - 77.568) < 0.005).toBe(true);
+    expect(pathArea(hollow) < pathArea(solid)).toBe(true);
   });
-
-  it('passes an already-simple convex path through unchanged', () => {
-    const result = createPath();
-    simplifyPath(result, kernel, polygonPath(UNIT_SQUARE));
-    expect(ringCount(result)).toBe(1);
-    expect(pathArea(result)).toBeCloseTo(9, 6);
-    const bounds = pathBounds(result);
-    expect(bounds.minX).toBeCloseTo(0, 6);
-    expect(bounds.minY).toBeCloseTo(0, 6);
-    expect(bounds.maxX).toBeCloseTo(3, 6);
-    expect(bounds.maxY).toBeCloseTo(3, 6);
+  it('passes an already simple convex path through unchanged', () => {
+    const kernel = createMartinezPathBooleanKernel();
+    let out = createPath('nonZero');
+    simplifyPath(out, kernel, polygonPath(Array.from(UNIT_SQUARE)), undefined);
+    expect(ringCount(out)).toEqual(1);
+    expect(Math.abs(pathArea(out) - 9.0) < 5e-7).toBe(true);
+    const [minX, minY, maxX, maxY] = pathBounds(out);
+    expect(Math.abs(minX - 0.0) < 5e-7).toBe(true);
+    expect(Math.abs(minY - 0.0) < 5e-7).toBe(true);
+    expect(Math.abs(maxX - 3.0) < 5e-7).toBe(true);
+    expect(Math.abs(maxY - 3.0) < 5e-7).toBe(true);
   });
-
   it('returns an empty path for empty input', () => {
-    const result = createPath();
-    simplifyPath(result, kernel, createPath('nonZero'));
-    expect(result.commands).toHaveLength(0);
-    expect(result.data).toHaveLength(0);
+    const kernel = createMartinezPathBooleanKernel();
+    let out = createPath('nonZero');
+    simplifyPath(out, kernel, createPath('nonZero'), undefined);
+    expect(out.commands.length).toEqual(0);
+    expect(out.data.length).toEqual(0);
   });
-
-  it('returns an empty path for a degenerate zero-area contour', () => {
-    const result = createPath();
-    simplifyPath(result, kernel, polygonPath([0, 0, 5, 0, 10, 0]));
-    expect(result.commands).toHaveLength(0);
-    expect(result.data).toHaveLength(0);
+  it('returns an empty path for a degenerate zero area contour', () => {
+    const kernel = createMartinezPathBooleanKernel();
+    let out = createPath('nonZero');
+    simplifyPath(out, kernel, polygonPath([0.0, 0.0, 5.0, 0.0, 10.0, 0.0]), undefined);
+    expect(out.commands.length).toEqual(0);
+    expect(out.data.length).toEqual(0);
   });
 });

package/src/unionAllPaths.test.ts

@@ -1,14 +1,26 @@
-import { appendPathClose, appendPathLineTo, appendPathMoveTo, createPath, flattenPath } from '@flighthq/path/contract';
-import type { Path } from '@flighthq/types/contract';
+// Generated from crates/flight-path-boolean/tests/union_all_paths_test.rs by flight-compiler.
+// Rust is authoritative; run `npm run generate` after changing it.
+
+import {
+  appendPathClose,
+  appendPathLineTo,
+  appendPathMoveTo,
+  clonePath,
+  createPath,
+  flattenPath,
+} from '@flighthq/path/contract';
+import type { Path } from '@flighthq/path/contract';
 import { describe, expect, it } from 'vitest';
 
-import { martinezPathBooleanKernel } from './martinezKernel.ts';
-import { unionAllPaths } from './unionAllPaths.ts';
+import { createMartinezPathBooleanKernel, unionAllPaths } from './contract.ts';
 
-const kernel = martinezPathBooleanKernel;
+function flattenedPath(path: Readonly<Path>, tolerance: number | undefined): number[][] {
+  const out = flattenPath(path, tolerance);
+  return out;
+}
 
 function squarePath(x: number, y: number, s: number): Path {
-  const path = createPath('nonZero');
+  let path = createPath('nonZero');
   appendPathMoveTo(path, x, y);
   appendPathLineTo(path, x + s, y);
   appendPathLineTo(path, x + s, y + s);
@@ -18,78 +30,98 @@ function squarePath(x: number, y: number, s: number): Path {
 }
 
 function pathArea(path: Readonly<Path>): number {
-  let total = 0;
-  for (const ring of flattenPath(path)) {
-    let area = 0;
+  let total: number = 0.0;
+  for (const ring of flattenedPath(path, 0.25)) {
+    let area: number = 0.0;
     const n = ring.length >> 1;
-    for (let i = 0, j = n - 1; i < n; j = i++) area += ring[j * 2] * ring[i * 2 + 1] - ring[i * 2] * ring[j * 2 + 1];
-    total += area / 2;
+    let j = n - 1;
+    for (let i = 0; i < n; i += 1) {
+      area += ring[j * 2] * ring[i * 2 + 1] - ring[i * 2] * ring[j * 2 + 1];
+      j = i;
+    }
+    total += area / 2.0;
   }
   return Math.abs(total);
 }
 
 function ringCount(path: Readonly<Path>): number {
-  return flattenPath(path).length;
+  return flattenedPath(path, 0.25).length;
 }
 
 describe('unionAllPaths', () => {
+  it('supports geometry clone form for a later list input', () => {
+    const kernel = createMartinezPathBooleanKernel();
+    const a = squarePath(0.0, 0.0, 10.0);
+    let b = squarePath(5.0, 5.0, 10.0);
+    const snapshot = clonePath(b);
+    unionAllPaths(b, kernel, [a, snapshot], undefined);
+    expect(Math.abs(pathArea(b) - 175.0) < 0.1).toBe(true);
+  });
   it('returns an empty path for an empty list', () => {
-    const result = createPath('nonZero');
-    unionAllPaths(result, kernel, []);
-    expect(result.commands).toHaveLength(0);
-    expect(result.data).toHaveLength(0);
+    const kernel = createMartinezPathBooleanKernel();
+    let out = createPath('nonZero');
+    unionAllPaths(out, kernel, [], undefined);
+    expect(out.commands.length).toEqual(0);
+    expect(out.data.length).toEqual(0);
   });
-
-  it('simplifies a single self-overlapping path', () => {
-    const overlap = createPath('nonZero');
-    appendPathMoveTo(overlap, 0, 0);
-    appendPathLineTo(overlap, 4, 0);
-    appendPathLineTo(overlap, 4, 4);
-    appendPathLineTo(overlap, 0, 4);
+  it('simplifies a single self overlapping path', () => {
+    const kernel = createMartinezPathBooleanKernel();
+    let overlap = createPath('nonZero');
+    appendPathMoveTo(overlap, 0.0, 0.0);
+    appendPathLineTo(overlap, 4.0, 0.0);
+    appendPathLineTo(overlap, 4.0, 4.0);
+    appendPathLineTo(overlap, 0.0, 4.0);
     appendPathClose(overlap);
-    appendPathMoveTo(overlap, 2, 2);
-    appendPathLineTo(overlap, 6, 2);
-    appendPathLineTo(overlap, 6, 6);
-    appendPathLineTo(overlap, 2, 6);
+    appendPathMoveTo(overlap, 2.0, 2.0);
+    appendPathLineTo(overlap, 6.0, 2.0);
+    appendPathLineTo(overlap, 6.0, 6.0);
+    appendPathLineTo(overlap, 2.0, 6.0);
     appendPathClose(overlap);
-    const result = createPath('nonZero');
-    unionAllPaths(result, kernel, [overlap]);
-    expect(ringCount(result)).toBe(1);
-    expect(pathArea(result)).toBeCloseTo(28, 6);
+    let out = createPath('nonZero');
+    unionAllPaths(out, kernel, [overlap], undefined);
+    expect(ringCount(out)).toEqual(1);
+    expect(Math.abs(pathArea(out) - 28.0) < 5e-7).toBe(true);
   });
-
   it('merges a list of overlapping squares into one outline', () => {
-    const result = createPath('nonZero');
-    unionAllPaths(result, kernel, [squarePath(0, 0, 10), squarePath(5, 5, 10), squarePath(8, 8, 10)]);
-    expect(ringCount(result)).toBe(1);
-    expect(pathArea(result)).toBeGreaterThan(100);
-    expect(pathArea(result)).toBeLessThan(300);
+    const kernel = createMartinezPathBooleanKernel();
+    const a = squarePath(0.0, 0.0, 10.0);
+    const b = squarePath(5.0, 5.0, 10.0);
+    const c = squarePath(8.0, 8.0, 10.0);
+    let out = createPath('nonZero');
+    unionAllPaths(out, kernel, [a, b, c], undefined);
+    expect(ringCount(out)).toEqual(1);
+    expect(pathArea(out) > 100.0).toBe(true);
+    expect(pathArea(out) < 300.0).toBe(true);
   });
-
-  it('keeps disjoint squares as separate rings summing their areas', () => {
-    const result = createPath('nonZero');
-    unionAllPaths(result, kernel, [squarePath(0, 0, 10), squarePath(20, 20, 10), squarePath(40, 0, 10)]);
-    expect(ringCount(result)).toBe(3);
-    expect(pathArea(result)).toBeCloseTo(300, 6);
+  it('keeps disjoint squares as separate rings', () => {
+    const kernel = createMartinezPathBooleanKernel();
+    const a = squarePath(0.0, 0.0, 10.0);
+    const b = squarePath(20.0, 20.0, 10.0);
+    const c = squarePath(40.0, 0.0, 10.0);
+    let out = createPath('nonZero');
+    unionAllPaths(out, kernel, [a, b, c], undefined);
+    expect(ringCount(out)).toEqual(3);
+    expect(Math.abs(pathArea(out) - 300.0) < 5e-7).toBe(true);
   });
-
-  it('folds order-independently (union is commutative across the list)', () => {
-    const a = squarePath(0, 0, 10);
-    const b = squarePath(5, 5, 10);
-    const c = squarePath(2, 8, 10);
-    const forward = createPath('nonZero');
-    const reversed = createPath('nonZero');
-    unionAllPaths(forward, kernel, [a, b, c]);
-    unionAllPaths(reversed, kernel, [c, b, a]);
-    expect(pathArea(forward)).toBeCloseTo(pathArea(reversed), 6);
-    expect(ringCount(forward)).toBe(ringCount(reversed));
+  it('folds order independently', () => {
+    const kernel = createMartinezPathBooleanKernel();
+    const a = squarePath(0.0, 0.0, 10.0);
+    const b = squarePath(5.0, 5.0, 10.0);
+    const c = squarePath(2.0, 8.0, 10.0);
+    let forward = createPath('nonZero');
+    let reversed = createPath('nonZero');
+    unionAllPaths(forward, kernel, [a, b, c], undefined);
+    unionAllPaths(reversed, kernel, [c, b, a], undefined);
+    expect(Math.abs(pathArea(forward) - pathArea(reversed)) < 5e-7).toBe(true);
+    expect(ringCount(forward)).toEqual(ringCount(reversed));
   });
-
-  it('writes into a provided out path that aliases an input', () => {
-    const a = squarePath(0, 0, 10);
-    const b = squarePath(5, 5, 10);
-    unionAllPaths(a, kernel, [a, b]);
-    expect(ringCount(a)).toBe(1);
-    expect(pathArea(a)).toBeCloseTo(175, 6);
+  it('writes into an existing path using a distinct input snapshot', () => {
+    const kernel = createMartinezPathBooleanKernel();
+    let a = squarePath(0.0, 0.0, 10.0);
+    const b = squarePath(5.0, 5.0, 10.0);
+    const aClone = a;
+    unionAllPaths(a, kernel, [aClone, b], undefined);
+    expect(ringCount(a)).toEqual(1);
+    expect(Math.abs(pathArea(a) - 175.0) < 5e-7).toBe(true);
   });
 });

package/src/writePathBooleanContours.test.ts

@@ -1,13 +1,51 @@
-import { createPath } from '@flighthq/path/contract';
+// Generated from crates/flight-path-boolean/tests/write_path_boolean_contours_test.rs by flight-compiler.
+// Rust is authoritative; run `npm run generate` after changing it.
+
+import { PathCommand, appendPathLineTo, appendPathMoveTo, createPath } from '@flighthq/path/contract';
 import { describe, expect, it } from 'vitest';
 
-import { writePathBooleanContours } from './writePathBooleanContours.ts';
+import { writePathBooleanContours } from './contract.ts';
 
 describe('writePathBooleanContours', () => {
   it('rebuilds into a supplied path without allocation', () => {
-    const out = createPath('evenOdd');
-    writePathBooleanContours(out, [[0, 0, 1, 0, 0, 1]]);
-    expect(out.winding).toBe('nonZero');
-    expect(out.commands.length).toBe(4);
+    let out = createPath('nonZero');
+    out.winding = 'evenOdd';
+    writePathBooleanContours(out, [[0.0, 0.0, 1.0, 0.0, 0.0, 1.0]]);
+    expect(out.winding).toEqual('nonZero');
+    expect(out.commands.length).toEqual(4);
+  });
+  it('skips rings with fewer than three vertices', () => {
+    let out = createPath('nonZero');
+    writePathBooleanContours(out, [[0.0, 0.0, 1.0, 1.0]]);
+    expect(out.commands.length).toEqual(0);
+    expect(out.data.length).toEqual(0);
+  });
+  it('converts multiple rings to separate sub paths', () => {
+    let out = createPath('nonZero');
+    writePathBooleanContours(out, [
+      [0.0, 0.0, 10.0, 0.0, 10.0, 10.0, 0.0, 10.0],
+      [20.0, 20.0, 30.0, 20.0, 30.0, 30.0],
+    ]);
+    let moveCount = 0;
+    for (const command of out.commands) {
+      if (command === (PathCommand.MOVE_TO & 0xff)) {
+        moveCount += 1;
+      }
+    }
+    let closeCount = 0;
+    for (const command of out.commands) {
+      if (command === (PathCommand.CLOSE & 0xff)) {
+        closeCount += 1;
+      }
+    }
+    expect(moveCount).toEqual(2);
+    expect(closeCount).toEqual(2);
+  });
+  it('clears existing content before writing', () => {
+    let out = createPath('nonZero');
+    appendPathMoveTo(out, 99.0, 99.0);
+    appendPathLineTo(out, 100.0, 100.0);
+    writePathBooleanContours(out, [[0.0, 0.0, 1.0, 0.0, 0.0, 1.0]]);
+    expect(out.commands.length).toEqual(4);
   });
 });