okgeometry-api 1.1.5 → 1.1.7

package/src/Mesh.ts

@@ -23,7 +23,7 @@ import type {
   MeshBooleanLimits,
   MeshBooleanOptions,
 } from "./mesh-boolean.protocol.js";
-import * as wasm from "../wasm/okgeometrycore_bg.js";
+import * as wasm from "../wasm/okgeometrycore.js";
 import { mesh_topology_metrics } from "../wasm/okgeometrycore.js";
 
 export { MeshBooleanExecutionError };
@@ -47,79 +47,139 @@ export interface PlanarCircle {
   radius: number;
 }
 
-export interface PlanarArc {
-  points: Point[];
-  center: Point;
-  radius: number;
-  startAngle: number;
-  endAngle: number;
-  sweepAngle: number;
-}
-
-interface RawMeshBounds {
-  minX: number;
-  minY: number;
-  minZ: number;
-  maxX: number;
-  maxY: number;
-  maxZ: number;
+export interface PlanarArc {
+  points: Point[];
+  center: Point;
+  radius: number;
+  startAngle: number;
+  endAngle: number;
+  sweepAngle: number;
+}
+
+interface RawMeshBounds {
+  minX: number;
+  minY: number;
+  minZ: number;
+  maxX: number;
+  maxY: number;
+  maxZ: number;
+}
+
+export type MeshBooleanOperation = "union" | "subtraction" | "intersection";
+
+export interface MeshDebugBounds {
+  min: Point;
+  max: Point;
+  center: Point;
+  size: Vec3;
+  diagonal: number;
+}
+
+export interface MeshDebugSummary {
+  vertexCount: number;
+  faceCount: number;
+  trustedBooleanInput: boolean;
+  isClosedVolume: boolean;
+  topology: {
+    boundaryEdges: number;
+    nonManifoldEdges: number;
+  };
+  bounds: MeshDebugBounds;
+}
+
+export interface MeshDebugRayHit {
+  point: Point;
+  normal: Vec3;
+  faceIndex: number;
+  distance: number;
+}
+
+export interface MeshBooleanDebugProbe {
+  label: string;
+  origin: Point;
+  direction: Vec3;
+  maxDistance: number;
+  inputAHits: MeshDebugRayHit[];
+  inputBHits: MeshDebugRayHit[];
+  resultHits: MeshDebugRayHit[];
+}
+
+export type MeshBooleanDebugProbeId =
+  "posX" | "negX" | "posY" | "negY" | "posZ" | "negZ";
+
+export interface MeshBooleanDebugOptions {
+  rayPaddingScale?: number;
+  maxRayHits?: number;
+  probes?: MeshBooleanDebugProbeId[];
+}
+
+export interface MeshBooleanDebugReport {
+  operation: MeshBooleanOperation;
+  inputA: MeshDebugSummary;
+  inputB: MeshDebugSummary;
+  result: Mesh;
+  resultSummary: MeshDebugSummary;
+  probes: MeshBooleanDebugProbe[];
 }
 
-export type MeshBooleanOperation = "union" | "subtraction" | "intersection";
-
-export interface MeshDebugBounds {
-  min: Point;
-  max: Point;
-  center: Point;
-  size: Vec3;
-  diagonal: number;
+export interface MeshBooleanDebugProbeSummary {
+  label: string;
+  origin: { x: number; y: number; z: number };
+  direction: { x: number; y: number; z: number };
+  inputAFirst: {
+    point: { x: number; y: number; z: number };
+    normal: { x: number; y: number; z: number };
+    faceIndex: number;
+    distance: number;
+  } | null;
+  inputBFirst: {
+    point: { x: number; y: number; z: number };
+    normal: { x: number; y: number; z: number };
+    faceIndex: number;
+    distance: number;
+  } | null;
+  resultFirst: {
+    point: { x: number; y: number; z: number };
+    normal: { x: number; y: number; z: number };
+    faceIndex: number;
+    distance: number;
+  } | null;
+  inputAHits: number;
+  inputBHits: number;
+  resultHits: number;
 }
 
-export interface MeshDebugSummary {
-  vertexCount: number;
-  faceCount: number;
+export interface MeshBooleanReproOperand {
   trustedBooleanInput: boolean;
-  isClosedVolume: boolean;
-  topology: {
-    boundaryEdges: number;
-    nonManifoldEdges: number;
-  };
-  bounds: MeshDebugBounds;
+  summary: MeshDebugSummary;
+  buffer: number[];
 }
 
-export interface MeshDebugRayHit {
-  point: Point;
-  normal: Vec3;
-  faceIndex: number;
-  distance: number;
+export interface MeshBooleanReproResult {
+  summary: MeshDebugSummary;
+  buffer: number[];
+  probeSummary?: MeshBooleanDebugProbeSummary[];
 }
 
-export interface MeshBooleanDebugProbe {
-  label: string;
-  origin: Point;
-  direction: Vec3;
-  maxDistance: number;
-  inputAHits: MeshDebugRayHit[];
-  inputBHits: MeshDebugRayHit[];
-  resultHits: MeshDebugRayHit[];
+export interface MeshBooleanReproError {
+  name: string;
+  message: string;
+  stack?: string;
 }
 
-export type MeshBooleanDebugProbeId =
-  "posX" | "negX" | "posY" | "negY" | "posZ" | "negZ";
-
-export interface MeshBooleanDebugOptions {
-  rayPaddingScale?: number;
-  maxRayHits?: number;
-  probes?: MeshBooleanDebugProbeId[];
+export interface MeshBooleanReproPayload {
+  version: 1;
+  operation: MeshBooleanOperation;
+  options: MeshBooleanOptions | null;
+  inputA: MeshBooleanReproOperand;
+  inputB: MeshBooleanReproOperand;
+  result?: MeshBooleanReproResult;
+  error?: MeshBooleanReproError;
 }
 
-export interface MeshBooleanDebugReport {
-  operation: MeshBooleanOperation;
-  inputA: MeshDebugSummary;
-  inputB: MeshDebugSummary;
-  result: Mesh;
-  resultSummary: MeshDebugSummary;
-  probes: MeshBooleanDebugProbe[];
+export interface MeshBooleanReproOptions {
+  includeResult?: boolean;
+  debugOptions?: MeshBooleanDebugOptions;
 }
 
 /**
@@ -128,18 +188,18 @@ export interface MeshBooleanDebugReport {
  *
  * Buffer format: [vertexCount, x1,y1,z1, ..., i1,i2,i3, ...]
  */
-export class Mesh {
-  private _buffer: Float64Array;
-  private _vertexCount: number;
-  private _trustedBooleanInput: boolean;
-  private static readonly DEFAULT_BOOLEAN_DEBUG_PROBES: MeshBooleanDebugProbeId[] = [
-    "posX",
-    "negX",
-    "posY",
-    "negY",
-    "posZ",
-    "negZ",
-  ];
+export class Mesh {
+  private _buffer: Float64Array;
+  private _vertexCount: number;
+  private _trustedBooleanInput: boolean;
+  private static readonly DEFAULT_BOOLEAN_DEBUG_PROBES: MeshBooleanDebugProbeId[] = [
+    "posX",
+    "negX",
+    "posY",
+    "negY",
+    "posZ",
+    "negZ",
+  ];
 
   private static readonly DEFAULT_BOOLEAN_LIMITS: MeshBooleanLimits = {
     maxInputFacesPerMesh: 120_000,
@@ -242,322 +302,377 @@ export class Mesh {
     return Number.isFinite(diag) && diag > 0 ? diag : 1;
   }
 
-  private static booleanContactTolerance(a: RawMeshBounds | null, b: RawMeshBounds | null): number {
-    const scale = Math.max(Mesh.boundsDiag(a), Mesh.boundsDiag(b));
-    return Math.min(1e-4, Math.max(1e-9, scale * 1e-6));
-  }
-
-  private static toDebugBounds(bounds: { min: Point; max: Point }): MeshDebugBounds {
-    const size = new Vec3(
-      bounds.max.x - bounds.min.x,
-      bounds.max.y - bounds.min.y,
-      bounds.max.z - bounds.min.z,
-    );
+  private static booleanContactTolerance(a: RawMeshBounds | null, b: RawMeshBounds | null): number {
+    const scale = Math.max(Mesh.boundsDiag(a), Mesh.boundsDiag(b));
+    return Math.min(1e-4, Math.max(1e-9, scale * 1e-6));
+  }
+
+  private static toDebugBounds(bounds: { min: Point; max: Point }): MeshDebugBounds {
+    const size = new Vec3(
+      bounds.max.x - bounds.min.x,
+      bounds.max.y - bounds.min.y,
+      bounds.max.z - bounds.min.z,
+    );
+    return {
+      min: bounds.min,
+      max: bounds.max,
+      center: new Point(
+        (bounds.min.x + bounds.max.x) * 0.5,
+        (bounds.min.y + bounds.max.y) * 0.5,
+        (bounds.min.z + bounds.max.z) * 0.5,
+      ),
+      size,
+      diagonal: Math.hypot(size.x, size.y, size.z),
+    };
+  }
+
+  private static clampDebugHitCount(count?: number): number {
+    if (!Number.isFinite(count)) return 4;
+    return Math.max(1, Math.min(32, Math.floor(count ?? 4)));
+  }
+
+  private static collectDebugHits(
+    mesh: Mesh,
+    origin: Point,
+    direction: Vec3,
+    maxDistance: number,
+    maxHits: number,
+  ): MeshDebugRayHit[] {
+    return mesh.raycastAll(origin, direction, maxDistance).slice(0, maxHits).map((hit) => ({
+      point: hit.point,
+      normal: hit.normal,
+      faceIndex: hit.faceIndex,
+      distance: hit.distance,
+    }));
+  }
+
+  private static uniqueDebugProbeIds(
+    probeIds: MeshBooleanDebugProbeId[],
+  ): MeshBooleanDebugProbeId[] {
+    return [...new Set(probeIds)];
+  }
+
+  private static buildInputBProbeOriginOffsets(
+    jitter: number,
+  ): Record<MeshBooleanDebugProbeId, Vec3> {
+    const major = jitter;
+    const minor = jitter * 0.61803398875;
+    const micro = jitter * 0.38196601125;
+    return {
+      posX: new Vec3(0, minor, -major),
+      negX: new Vec3(0, -minor, major),
+      posY: new Vec3(major, 0, micro),
+      negY: new Vec3(-major, 0, -micro),
+      posZ: new Vec3(major, -minor, 0),
+      negZ: new Vec3(-major, minor, 0),
+    };
+  }
+
+  private static buildDirectionalDebugProbes(
+    inputA: Mesh,
+    inputB: Mesh,
+    result: Mesh,
+    center: Point,
+    pad: number,
+    maxDistance: number,
+    maxHits: number,
+    probeIds: MeshBooleanDebugProbeId[],
+    labelPrefix = "",
+    originOffsets?: Partial<Record<MeshBooleanDebugProbeId, Vec3>>,
+  ): MeshBooleanDebugProbe[] {
+    const prefixed = (id: string) => (labelPrefix ? `${labelPrefix}:${id}` : id);
+    const probeSpecs: Record<
+      MeshBooleanDebugProbeId,
+      { origin: Point; direction: Vec3 }
+    > = {
+      posX: {
+        origin: new Point(center.x + pad, center.y, center.z),
+        direction: new Vec3(-1, 0, 0),
+      },
+      negX: {
+        origin: new Point(center.x - pad, center.y, center.z),
+        direction: new Vec3(1, 0, 0),
+      },
+      posY: {
+        origin: new Point(center.x, center.y + pad, center.z),
+        direction: new Vec3(0, -1, 0),
+      },
+      negY: {
+        origin: new Point(center.x, center.y - pad, center.z),
+        direction: new Vec3(0, 1, 0),
+      },
+      posZ: {
+        origin: new Point(center.x, center.y, center.z + pad),
+        direction: new Vec3(0, 0, -1),
+      },
+      negZ: {
+        origin: new Point(center.x, center.y, center.z - pad),
+        direction: new Vec3(0, 0, 1),
+      },
+    };
+
+    return probeIds.map((id) => {
+      const spec = probeSpecs[id];
+      const originOffset = originOffsets?.[id];
+      const origin = originOffset
+        ? new Point(
+          spec.origin.x + originOffset.x,
+          spec.origin.y + originOffset.y,
+          spec.origin.z + originOffset.z,
+        )
+        : spec.origin;
+      return {
+        label: prefixed(id),
+        origin,
+        direction: spec.direction,
+        maxDistance,
+        inputAHits: Mesh.collectDebugHits(inputA, origin, spec.direction, maxDistance, maxHits),
+        inputBHits: Mesh.collectDebugHits(inputB, origin, spec.direction, maxDistance, maxHits),
+        resultHits: Mesh.collectDebugHits(result, origin, spec.direction, maxDistance, maxHits),
+      };
+    });
+  }
+
+  private static buildBooleanDebugProbes(
+    inputA: Mesh,
+    inputB: Mesh,
+    result: Mesh,
+    options?: MeshBooleanDebugOptions,
+  ): MeshBooleanDebugProbe[] {
+    const boundsA = Mesh.toDebugBounds(inputA.getBounds());
+    const boundsB = Mesh.toDebugBounds(inputB.getBounds());
+    const resultBounds = Mesh.toDebugBounds(result.getBounds());
+    const min = new Point(
+      Math.min(boundsA.min.x, boundsB.min.x, resultBounds.min.x),
+      Math.min(boundsA.min.y, boundsB.min.y, resultBounds.min.y),
+      Math.min(boundsA.min.z, boundsB.min.z, resultBounds.min.z),
+    );
+    const max = new Point(
+      Math.max(boundsA.max.x, boundsB.max.x, resultBounds.max.x),
+      Math.max(boundsA.max.y, boundsB.max.y, resultBounds.max.y),
+      Math.max(boundsA.max.z, boundsB.max.z, resultBounds.max.z),
+    );
+    const center = new Point(
+      (min.x + max.x) * 0.5,
+      (min.y + max.y) * 0.5,
+      (min.z + max.z) * 0.5,
+    );
+    const diag = Math.max(
+      1e-6,
+      Math.hypot(max.x - min.x, max.y - min.y, max.z - min.z),
+    );
+    const padScale = Number.isFinite(options?.rayPaddingScale)
+      ? Math.max(0.01, options?.rayPaddingScale ?? 0.25)
+      : 0.25;
+    const pad = Math.max(1e-3, diag * padScale);
+    const maxHits = Mesh.clampDebugHitCount(options?.maxRayHits);
+    const sceneProbeIds = Mesh.uniqueDebugProbeIds(
+      options?.probes?.length
+        ? options.probes
+        : Mesh.DEFAULT_BOOLEAN_DEBUG_PROBES,
+    );
+    const inputBProbeIds = Mesh.uniqueDebugProbeIds(sceneProbeIds.concat(["posZ", "negZ"]));
+    const inputBJitter = Math.max(1e-6, Math.min(pad * 0.1, boundsB.diagonal * 0.01));
+    const maxDistance = diag + pad * 2;
+    const sceneCenterProbes = Mesh.buildDirectionalDebugProbes(
+      inputA,
+      inputB,
+      result,
+      center,
+      pad,
+      maxDistance,
+      maxHits,
+      sceneProbeIds,
+    );
+    const inputBCenterProbes = Mesh.buildDirectionalDebugProbes(
+      inputA,
+      inputB,
+      result,
+      boundsB.center,
+      pad,
+      maxDistance,
+      maxHits,
+      inputBProbeIds,
+      "inputB",
+      Mesh.buildInputBProbeOriginOffsets(inputBJitter),
+    );
+    return sceneCenterProbes.concat(inputBCenterProbes);
+  }
+
+  private static createBooleanDebugReport(
+    inputA: Mesh,
+    inputB: Mesh,
+    result: Mesh,
+    operation: MeshBooleanOperation,
+    debugOptions?: MeshBooleanDebugOptions,
+  ): MeshBooleanDebugReport {
+    return {
+      operation,
+      inputA: inputA.debugSummary(),
+      inputB: inputB.debugSummary(),
+      result,
+      resultSummary: result.debugSummary(),
+      probes: Mesh.buildBooleanDebugProbes(inputA, inputB, result, debugOptions),
+    };
+  }
+
+  private static roundDebugScalar(value: number): number {
+    return Number.isFinite(value) ? Number(value.toFixed(4)) : value;
+  }
+
+  private static summarizeDebugHit(hit: MeshDebugRayHit | undefined): {
+    point: { x: number; y: number; z: number };
+    normal: { x: number; y: number; z: number };
+    faceIndex: number;
+    distance: number;
+  } | null {
+    if (!hit) return null;
+    return {
+      point: {
+        x: Mesh.roundDebugScalar(hit.point.x),
+        y: Mesh.roundDebugScalar(hit.point.y),
+        z: Mesh.roundDebugScalar(hit.point.z),
+      },
+      normal: {
+        x: Mesh.roundDebugScalar(hit.normal.x),
+        y: Mesh.roundDebugScalar(hit.normal.y),
+        z: Mesh.roundDebugScalar(hit.normal.z),
+      },
+      faceIndex: hit.faceIndex,
+      distance: Mesh.roundDebugScalar(hit.distance),
+    };
+  }
+
+  private static summarizeDebugProbe(probe: MeshBooleanDebugProbe): MeshBooleanDebugProbeSummary {
     return {
-      min: bounds.min,
-      max: bounds.max,
-      center: new Point(
-        (bounds.min.x + bounds.max.x) * 0.5,
-        (bounds.min.y + bounds.max.y) * 0.5,
-        (bounds.min.z + bounds.max.z) * 0.5,
-      ),
-      size,
-      diagonal: Math.hypot(size.x, size.y, size.z),
+      label: probe.label,
+      origin: {
+        x: Mesh.roundDebugScalar(probe.origin.x),
+        y: Mesh.roundDebugScalar(probe.origin.y),
+        z: Mesh.roundDebugScalar(probe.origin.z),
+      },
+      direction: {
+        x: Mesh.roundDebugScalar(probe.direction.x),
+        y: Mesh.roundDebugScalar(probe.direction.y),
+        z: Mesh.roundDebugScalar(probe.direction.z),
+      },
+      inputAFirst: Mesh.summarizeDebugHit(probe.inputAHits[0]),
+      inputBFirst: Mesh.summarizeDebugHit(probe.inputBHits[0]),
+      resultFirst: Mesh.summarizeDebugHit(probe.resultHits[0]),
+      inputAHits: probe.inputAHits.length,
+      inputBHits: probe.inputBHits.length,
+      resultHits: probe.resultHits.length,
     };
   }
 
-  private static clampDebugHitCount(count?: number): number {
-    if (!Number.isFinite(count)) return 4;
-    return Math.max(1, Math.min(32, Math.floor(count ?? 4)));
-  }
-
-  private static collectDebugHits(
-    mesh: Mesh,
-    origin: Point,
-    direction: Vec3,
-    maxDistance: number,
-    maxHits: number,
-  ): MeshDebugRayHit[] {
-    return mesh.raycastAll(origin, direction, maxDistance).slice(0, maxHits).map((hit) => ({
-      point: hit.point,
-      normal: hit.normal,
-      faceIndex: hit.faceIndex,
-      distance: hit.distance,
-    }));
-  }
-
-  private static uniqueDebugProbeIds(
-    probeIds: MeshBooleanDebugProbeId[],
-  ): MeshBooleanDebugProbeId[] {
-    return [...new Set(probeIds)];
+  private static serializeBooleanOptions(options?: MeshBooleanOptions): MeshBooleanOptions | null {
+    return options == null ? null : { ...options };
   }
 
-  private static buildInputBProbeOriginOffsets(
-    jitter: number,
-  ): Record<MeshBooleanDebugProbeId, Vec3> {
-    const major = jitter;
-    const minor = jitter * 0.61803398875;
-    const micro = jitter * 0.38196601125;
+  private static serializeBooleanError(error: unknown): MeshBooleanReproError {
+    if (error instanceof Error) {
+      return {
+        name: error.name,
+        message: error.message,
+        stack: error.stack,
+      };
+    }
     return {
-      posX: new Vec3(0, minor, -major),
-      negX: new Vec3(0, -minor, major),
-      posY: new Vec3(major, 0, micro),
-      negY: new Vec3(-major, 0, -micro),
-      posZ: new Vec3(major, -minor, 0),
-      negZ: new Vec3(-major, minor, 0),
+      name: typeof error,
+      message: typeof error === "string" ? error : JSON.stringify(error),
     };
   }
 
-  private static buildDirectionalDebugProbes(
-    inputA: Mesh,
-    inputB: Mesh,
-    result: Mesh,
-    center: Point,
-    pad: number,
-    maxDistance: number,
-    maxHits: number,
-    probeIds: MeshBooleanDebugProbeId[],
-    labelPrefix = "",
-    originOffsets?: Partial<Record<MeshBooleanDebugProbeId, Vec3>>,
-  ): MeshBooleanDebugProbe[] {
-    const prefixed = (id: string) => (labelPrefix ? `${labelPrefix}:${id}` : id);
-    const probeSpecs: Record<
-      MeshBooleanDebugProbeId,
-      { origin: Point; direction: Vec3 }
-    > = {
-      posX: {
-        origin: new Point(center.x + pad, center.y, center.z),
-        direction: new Vec3(-1, 0, 0),
-      },
-      negX: {
-        origin: new Point(center.x - pad, center.y, center.z),
-        direction: new Vec3(1, 0, 0),
-      },
-      posY: {
-        origin: new Point(center.x, center.y + pad, center.z),
-        direction: new Vec3(0, -1, 0),
-      },
-      negY: {
-        origin: new Point(center.x, center.y - pad, center.z),
-        direction: new Vec3(0, 1, 0),
-      },
-      posZ: {
-        origin: new Point(center.x, center.y, center.z + pad),
-        direction: new Vec3(0, 0, -1),
-      },
-      negZ: {
-        origin: new Point(center.x, center.y, center.z - pad),
-        direction: new Vec3(0, 0, 1),
-      },
+  private static exportBooleanReproOperand(mesh: Mesh): MeshBooleanReproOperand {
+    return {
+      trustedBooleanInput: mesh._trustedBooleanInput,
+      summary: mesh.debugSummary(),
+      buffer: Array.from(mesh._buffer),
     };
-
-    return probeIds.map((id) => {
-      const spec = probeSpecs[id];
-      const originOffset = originOffsets?.[id];
-      const origin = originOffset
-        ? new Point(
-          spec.origin.x + originOffset.x,
-          spec.origin.y + originOffset.y,
-          spec.origin.z + originOffset.z,
-        )
-        : spec.origin;
-      return {
-        label: prefixed(id),
-        origin,
-        direction: spec.direction,
-        maxDistance,
-        inputAHits: Mesh.collectDebugHits(inputA, origin, spec.direction, maxDistance, maxHits),
-        inputBHits: Mesh.collectDebugHits(inputB, origin, spec.direction, maxDistance, maxHits),
-        resultHits: Mesh.collectDebugHits(result, origin, spec.direction, maxDistance, maxHits),
-      };
-    });
-  }
-
-  private static buildBooleanDebugProbes(
-    inputA: Mesh,
-    inputB: Mesh,
-    result: Mesh,
-    options?: MeshBooleanDebugOptions,
-  ): MeshBooleanDebugProbe[] {
-    const boundsA = Mesh.toDebugBounds(inputA.getBounds());
-    const boundsB = Mesh.toDebugBounds(inputB.getBounds());
-    const resultBounds = Mesh.toDebugBounds(result.getBounds());
-    const min = new Point(
-      Math.min(boundsA.min.x, boundsB.min.x, resultBounds.min.x),
-      Math.min(boundsA.min.y, boundsB.min.y, resultBounds.min.y),
-      Math.min(boundsA.min.z, boundsB.min.z, resultBounds.min.z),
-    );
-    const max = new Point(
-      Math.max(boundsA.max.x, boundsB.max.x, resultBounds.max.x),
-      Math.max(boundsA.max.y, boundsB.max.y, resultBounds.max.y),
-      Math.max(boundsA.max.z, boundsB.max.z, resultBounds.max.z),
-    );
-    const center = new Point(
-      (min.x + max.x) * 0.5,
-      (min.y + max.y) * 0.5,
-      (min.z + max.z) * 0.5,
-    );
-    const diag = Math.max(
-      1e-6,
-      Math.hypot(max.x - min.x, max.y - min.y, max.z - min.z),
-    );
-    const padScale = Number.isFinite(options?.rayPaddingScale)
-      ? Math.max(0.01, options?.rayPaddingScale ?? 0.25)
-      : 0.25;
-    const pad = Math.max(1e-3, diag * padScale);
-    const maxHits = Mesh.clampDebugHitCount(options?.maxRayHits);
-    const sceneProbeIds = Mesh.uniqueDebugProbeIds(
-      options?.probes?.length
-        ? options.probes
-        : Mesh.DEFAULT_BOOLEAN_DEBUG_PROBES,
-    );
-    const inputBProbeIds = Mesh.uniqueDebugProbeIds(sceneProbeIds.concat(["posZ", "negZ"]));
-    const inputBJitter = Math.max(1e-6, Math.min(pad * 0.1, boundsB.diagonal * 0.01));
-    const maxDistance = diag + pad * 2;
-    const sceneCenterProbes = Mesh.buildDirectionalDebugProbes(
-      inputA,
-      inputB,
-      result,
-      center,
-      pad,
-      maxDistance,
-      maxHits,
-      sceneProbeIds,
-    );
-    const inputBCenterProbes = Mesh.buildDirectionalDebugProbes(
-      inputA,
-      inputB,
-      result,
-      boundsB.center,
-      pad,
-      maxDistance,
-      maxHits,
-      inputBProbeIds,
-      "inputB",
-      Mesh.buildInputBProbeOriginOffsets(inputBJitter),
-    );
-    return sceneCenterProbes.concat(inputBCenterProbes);
   }
 
-  private static createBooleanDebugReport(
+  private static createBooleanReproPayload(
     inputA: Mesh,
     inputB: Mesh,
-    result: Mesh,
     operation: MeshBooleanOperation,
+    options?: MeshBooleanOptions,
+    result?: Mesh,
     debugOptions?: MeshBooleanDebugOptions,
-  ): MeshBooleanDebugReport {
-    return {
+    error?: unknown,
+  ): MeshBooleanReproPayload {
+    const payload: MeshBooleanReproPayload = {
+      version: 1,
       operation,
-      inputA: inputA.debugSummary(),
-      inputB: inputB.debugSummary(),
-      result,
-      resultSummary: result.debugSummary(),
-      probes: Mesh.buildBooleanDebugProbes(inputA, inputB, result, debugOptions),
+      options: Mesh.serializeBooleanOptions(options),
+      inputA: Mesh.exportBooleanReproOperand(inputA),
+      inputB: Mesh.exportBooleanReproOperand(inputB),
     };
-  }
 
-  private static roundDebugScalar(value: number): number {
-    return Number.isFinite(value) ? Number(value.toFixed(4)) : value;
-  }
+    if (result) {
+      payload.result = {
+        summary: result.debugSummary(),
+        buffer: Array.from(result._buffer),
+      };
+      if (debugOptions) {
+        try {
+          const report = Mesh.createBooleanDebugReport(inputA, inputB, result, operation, debugOptions);
+          payload.result.probeSummary = report.probes.map((probe) => Mesh.summarizeDebugProbe(probe));
+        } catch {
+          // Keep the repro payload usable even when extra debug probes fail.
+        }
+      }
+    }
 
-  private static summarizeDebugHit(hit: MeshDebugRayHit | undefined): {
-    point: { x: number; y: number; z: number };
-    normal: { x: number; y: number; z: number };
-    faceIndex: number;
-    distance: number;
-  } | null {
-    if (!hit) return null;
-    return {
-      point: {
-        x: Mesh.roundDebugScalar(hit.point.x),
-        y: Mesh.roundDebugScalar(hit.point.y),
-        z: Mesh.roundDebugScalar(hit.point.z),
-      },
-      normal: {
-        x: Mesh.roundDebugScalar(hit.normal.x),
-        y: Mesh.roundDebugScalar(hit.normal.y),
-        z: Mesh.roundDebugScalar(hit.normal.z),
-      },
-      faceIndex: hit.faceIndex,
-      distance: Mesh.roundDebugScalar(hit.distance),
-    };
-  }
+    if (error !== undefined) {
+      payload.error = Mesh.serializeBooleanError(error);
+    }
 
-  private static summarizeDebugProbe(probe: MeshBooleanDebugProbe): {
-    label: string;
-    origin: { x: number; y: number; z: number };
-    direction: { x: number; y: number; z: number };
-    inputAFirst: ReturnType<typeof Mesh.summarizeDebugHit>;
-    inputBFirst: ReturnType<typeof Mesh.summarizeDebugHit>;
-    resultFirst: ReturnType<typeof Mesh.summarizeDebugHit>;
-    inputAHits: number;
-    inputBHits: number;
-    resultHits: number;
-  } {
-    return {
-      label: probe.label,
-      origin: {
-        x: Mesh.roundDebugScalar(probe.origin.x),
-        y: Mesh.roundDebugScalar(probe.origin.y),
-        z: Mesh.roundDebugScalar(probe.origin.z),
-      },
-      direction: {
-        x: Mesh.roundDebugScalar(probe.direction.x),
-        y: Mesh.roundDebugScalar(probe.direction.y),
-        z: Mesh.roundDebugScalar(probe.direction.z),
-      },
-      inputAFirst: Mesh.summarizeDebugHit(probe.inputAHits[0]),
-      inputBFirst: Mesh.summarizeDebugHit(probe.inputBHits[0]),
-      resultFirst: Mesh.summarizeDebugHit(probe.resultHits[0]),
-      inputAHits: probe.inputAHits.length,
-      inputBHits: probe.inputBHits.length,
-      resultHits: probe.resultHits.length,
-    };
+    return payload;
   }
 
   private static logSubtractDebugSuccess(
     inputA: Mesh,
     inputB: Mesh,
-    result: Mesh,
-    options?: MeshBooleanOptions,
-  ): void {
-    try {
-      const report = Mesh.createBooleanDebugReport(
-        inputA,
-        inputB,
-        result,
-        "subtraction",
-        { maxRayHits: 2, probes: ["posX", "negX", "posY"] },
-      );
-      const probeSummary = report.probes.map((probe) => Mesh.summarizeDebugProbe(probe));
-      console.log("[okgeometry-api] Mesh.subtract debug", {
-        options: options ?? null,
-        inputA: report.inputA,
-        inputB: report.inputB,
-        result: report.resultSummary,
-        deltas: {
-          faceCount: report.resultSummary.faceCount - report.inputA.faceCount,
-          vertexCount: report.resultSummary.vertexCount - report.inputA.vertexCount,
-        },
-        probeSummary,
-        report,
-      });
-      console.log("[okgeometry-api] Mesh.subtract summary", {
-        inputAFaces: report.inputA.faceCount,
-        inputBFaces: report.inputB.faceCount,
-        resultFaces: report.resultSummary.faceCount,
-        inputAVerts: report.inputA.vertexCount,
-        inputBVerts: report.inputB.vertexCount,
-        resultVerts: report.resultSummary.vertexCount,
-        resultClosed: report.resultSummary.isClosedVolume,
-        resultTopology: report.resultSummary.topology,
-      });
-      console.log("[okgeometry-api] Mesh.subtract probeSummary", probeSummary);
-    } catch (debugError) {
-      console.error("[okgeometry-api] Mesh.subtract debug logging failed", debugError);
-    }
-  }
-
+    result: Mesh,
+    options?: MeshBooleanOptions,
+  ): void {
+    try {
+      const report = Mesh.createBooleanDebugReport(
+        inputA,
+        inputB,
+        result,
+        "subtraction",
+        { maxRayHits: 2, probes: ["posX", "negX", "posY"] },
+      );
+      const probeSummary = report.probes.map((probe) => Mesh.summarizeDebugProbe(probe));
+      console.log("[okgeometry-api] Mesh.subtract debug", {
+        options: options ?? null,
+        inputA: report.inputA,
+        inputB: report.inputB,
+        result: report.resultSummary,
+        deltas: {
+          faceCount: report.resultSummary.faceCount - report.inputA.faceCount,
+          vertexCount: report.resultSummary.vertexCount - report.inputA.vertexCount,
+        },
+        probeSummary,
+        report,
+      });
+      console.log("[okgeometry-api] Mesh.subtract summary", {
+        inputAFaces: report.inputA.faceCount,
+        inputBFaces: report.inputB.faceCount,
+        resultFaces: report.resultSummary.faceCount,
+        inputAVerts: report.inputA.vertexCount,
+        inputBVerts: report.inputB.vertexCount,
+        resultVerts: report.resultSummary.vertexCount,
+        resultClosed: report.resultSummary.isClosedVolume,
+        resultTopology: report.resultSummary.topology,
+      });
+      console.log("[okgeometry-api] Mesh.subtract probeSummary", probeSummary);
+    } catch (debugError) {
+      console.error("[okgeometry-api] Mesh.subtract debug logging failed", debugError);
+    }
+  }
+
   private static logSubtractDebugFailure(
     inputA: Mesh,
     inputB: Mesh,
@@ -565,12 +680,23 @@ export class Mesh {
     error: unknown,
   ): void {
     try {
+      const repro = Mesh.createBooleanReproPayload(
+        inputA,
+        inputB,
+        "subtraction",
+        options,
+        undefined,
+        undefined,
+        error,
+      );
       console.error("[okgeometry-api] Mesh.subtract failed", {
         options: options ?? null,
         inputA: inputA.debugSummary(),
         inputB: inputB.debugSummary(),
         error,
       });
+      console.error("[okgeometry-api] Mesh.subtract repro", repro);
+      console.error("[okgeometry-api] Mesh.subtract repro JSON", JSON.stringify(repro, null, 2));
     } catch (debugError) {
       console.error("[okgeometry-api] Mesh.subtract failure logging failed", debugError);
     }
@@ -689,22 +815,22 @@ export class Mesh {
     return new Mesh(buffer, true);
   }
 
-  get trustedBooleanInput(): boolean {
-    return this._trustedBooleanInput;
-  }
-
-  debugSummary(): MeshDebugSummary {
-    const bounds = Mesh.toDebugBounds(this.getBounds());
-    const topology = this.topologyMetrics();
-    return {
-      vertexCount: this.vertexCount,
-      faceCount: this.faceCount,
-      trustedBooleanInput: this._trustedBooleanInput,
-      isClosedVolume: this.isClosedVolume(),
-      topology,
-      bounds,
-    };
-  }
+  get trustedBooleanInput(): boolean {
+    return this._trustedBooleanInput;
+  }
+
+  debugSummary(): MeshDebugSummary {
+    const bounds = Mesh.toDebugBounds(this.getBounds());
+    const topology = this.topologyMetrics();
+    return {
+      vertexCount: this.vertexCount,
+      faceCount: this.faceCount,
+      trustedBooleanInput: this._trustedBooleanInput,
+      isClosedVolume: this.isClosedVolume(),
+      topology,
+      bounds,
+    };
+  }
 
   /**
    * Build an axis-aligned rectangle on a plane basis from opposite corners.
@@ -1007,10 +1133,10 @@ export class Mesh {
   }
 
   /**
-   * Create a UV sphere centered at origin.
+   * Create a geodesic sphere centered at origin, matching Manifold's sphere topology.
    * @param radius - Sphere radius
-   * @param segments - Number of longitudinal segments
-   * @param rings - Number of latitudinal rings
+   * @param segments - Segment hint; rounded up internally to a multiple of 4
+   * @param rings - Compatibility-only detail hint; the higher of `segments` and `rings` is used
    * @returns New Mesh representing the sphere
    */
   static createSphere(radius: number, segments: number, rings: number): Mesh {
@@ -1019,11 +1145,11 @@ export class Mesh {
   }
 
   /**
-   * Create a cylinder centered at origin with axis along Y.
+   * Create a cylinder centered at origin with axis along Z, matching Manifold.
    * @param radius - Cylinder radius
    * @param height - Total height (extends height/2 above and below origin)
    * @param segments - Number of circumferential segments
-   * @returns New Mesh with caps
+   * @returns New Mesh with cap triangulation matching Manifold
    */
   static createCylinder(radius: number, height: number, segments: number): Mesh {
     ensureInit();
@@ -1043,11 +1169,11 @@ export class Mesh {
   }
 
   /**
-   * Create a cone centered at origin with apex at top.
+   * Create a cone centered at origin with axis along Z, matching Manifold.
    * @param radius - Base radius
    * @param height - Height from base to apex
    * @param segments - Number of circumferential segments
-   * @returns New Mesh with base cap
+   * @returns New Mesh with base triangulation matching Manifold
    */
   static createCone(radius: number, height: number, segments: number): Mesh {
     ensureInit();
@@ -1461,12 +1587,12 @@ export class Mesh {
     return Mesh.fromTrustedBuffer(result);
   }
 
-  static encodeBooleanOperationToken(
-    operation: MeshBooleanOperation,
-    a: Mesh,
-    b: Mesh,
-    options?: MeshBooleanOptions,
-  ): string {
+  static encodeBooleanOperationToken(
+    operation: MeshBooleanOperation,
+    a: Mesh,
+    b: Mesh,
+    options?: MeshBooleanOptions,
+  ): string {
     const tokens: string[] = [operation];
     if (a._trustedBooleanInput && b._trustedBooleanInput) {
       tokens.push("trustedInput");
@@ -1508,29 +1634,29 @@ export class Mesh {
    * @param options - Optional safety overrides
    * @returns New mesh with other's volume removed from this
    */
-  subtract(other: Mesh, options?: MeshBooleanOptions): Mesh {
-    ensureInit();
-    const operationToken = Mesh.encodeBooleanOperationToken("subtraction", this, other, options);
-    try {
-      const result = this.runBoolean(
-        other,
-        "subtraction",
-        () => wasm.mesh_boolean_operation(
-          this._vertexCount,
-          this._buffer,
-          other._vertexCount,
-          other._buffer,
-          operationToken,
-        ),
-        options,
-      );
-      Mesh.logSubtractDebugSuccess(this, other, result, options);
-      return result;
-    } catch (error) {
-      Mesh.logSubtractDebugFailure(this, other, options, error);
-      throw error;
-    }
-  }
+  subtract(other: Mesh, options?: MeshBooleanOptions): Mesh {
+    ensureInit();
+    const operationToken = Mesh.encodeBooleanOperationToken("subtraction", this, other, options);
+    try {
+      const result = this.runBoolean(
+        other,
+        "subtraction",
+        () => wasm.mesh_boolean_operation(
+          this._vertexCount,
+          this._buffer,
+          other._vertexCount,
+          other._buffer,
+          operationToken,
+        ),
+        options,
+      );
+      Mesh.logSubtractDebugSuccess(this, other, result, options);
+      return result;
+    } catch (error) {
+      Mesh.logSubtractDebugFailure(this, other, options, error);
+      throw error;
+    }
+  }
 
   /**
    * Compute boolean intersection with another mesh.
@@ -1538,9 +1664,9 @@ export class Mesh {
    * @param options - Optional safety overrides
    * @returns New mesh containing only the overlapping volume
    */
-  intersect(other: Mesh, options?: MeshBooleanOptions): Mesh {
-    ensureInit();
-    const operationToken = Mesh.encodeBooleanOperationToken("intersection", this, other, options);
+  intersect(other: Mesh, options?: MeshBooleanOptions): Mesh {
+    ensureInit();
+    const operationToken = Mesh.encodeBooleanOperationToken("intersection", this, other, options);
     return this.runBoolean(
       other,
       "intersection",
@@ -1551,52 +1677,145 @@ export class Mesh {
         other._buffer,
         operationToken,
       ),
-      options,
-    );
+      options,
+    );
+  }
+
+  debugBoolean(
+    other: Mesh,
+    operation: MeshBooleanOperation,
+    options?: MeshBooleanOptions,
+    debugOptions?: MeshBooleanDebugOptions,
+  ): MeshBooleanDebugReport {
+    const result = operation === "union"
+      ? this.union(other, options)
+      : operation === "subtraction"
+        ? this.subtract(other, options)
+        : this.intersect(other, options);
+
+    return Mesh.createBooleanDebugReport(this, other, result, operation, debugOptions);
+  }
+
+  debugUnion(
+    other: Mesh,
+    options?: MeshBooleanOptions,
+    debugOptions?: MeshBooleanDebugOptions,
+  ): MeshBooleanDebugReport {
+    return this.debugBoolean(other, "union", options, debugOptions);
+  }
+
+  debugSubtract(
+    other: Mesh,
+    options?: MeshBooleanOptions,
+    debugOptions?: MeshBooleanDebugOptions,
+  ): MeshBooleanDebugReport {
+    return this.debugBoolean(other, "subtraction", options, debugOptions);
+  }
+
+  debugIntersect(
+    other: Mesh,
+    options?: MeshBooleanOptions,
+    debugOptions?: MeshBooleanDebugOptions,
+  ): MeshBooleanDebugReport {
+    return this.debugBoolean(other, "intersection", options, debugOptions);
   }
 
-  debugBoolean(
+  exportBooleanRepro(
     other: Mesh,
     operation: MeshBooleanOperation,
     options?: MeshBooleanOptions,
-    debugOptions?: MeshBooleanDebugOptions,
-  ): MeshBooleanDebugReport {
-    const result = operation === "union"
-      ? this.union(other, options)
-      : operation === "subtraction"
-        ? this.subtract(other, options)
-        : this.intersect(other, options);
+    reproOptions?: MeshBooleanReproOptions,
+  ): MeshBooleanReproPayload {
+    if (!reproOptions?.includeResult) {
+      return Mesh.createBooleanReproPayload(this, other, operation, options);
+    }
 
-    return Mesh.createBooleanDebugReport(this, other, result, operation, debugOptions);
+    try {
+      const result = operation === "union"
+        ? this.union(other, options)
+        : operation === "subtraction"
+          ? this.subtract(other, options)
+          : this.intersect(other, options);
+      return Mesh.createBooleanReproPayload(
+        this,
+        other,
+        operation,
+        options,
+        result,
+        reproOptions.debugOptions,
+      );
+    } catch (error) {
+      return Mesh.createBooleanReproPayload(
+        this,
+        other,
+        operation,
+        options,
+        undefined,
+        undefined,
+        error,
+      );
+    }
   }
 
-  debugUnion(
+  exportSubtractRepro(
     other: Mesh,
     options?: MeshBooleanOptions,
-    debugOptions?: MeshBooleanDebugOptions,
-  ): MeshBooleanDebugReport {
-    return this.debugBoolean(other, "union", options, debugOptions);
+    reproOptions?: MeshBooleanReproOptions,
+  ): MeshBooleanReproPayload {
+    return this.exportBooleanRepro(other, "subtraction", options, reproOptions);
   }
 
-  debugSubtract(
+  exportBooleanReproJSON(
     other: Mesh,
+    operation: MeshBooleanOperation,
     options?: MeshBooleanOptions,
-    debugOptions?: MeshBooleanDebugOptions,
-  ): MeshBooleanDebugReport {
-    return this.debugBoolean(other, "subtraction", options, debugOptions);
+    reproOptions?: MeshBooleanReproOptions,
+  ): string {
+    return JSON.stringify(this.exportBooleanRepro(other, operation, options, reproOptions), null, 2);
   }
 
-  debugIntersect(
+  exportSubtractReproJSON(
     other: Mesh,
     options?: MeshBooleanOptions,
-    debugOptions?: MeshBooleanDebugOptions,
-  ): MeshBooleanDebugReport {
-    return this.debugBoolean(other, "intersection", options, debugOptions);
+    reproOptions?: MeshBooleanReproOptions,
+  ): string {
+    return this.exportBooleanReproJSON(other, "subtraction", options, reproOptions);
   }
-
-  /**
-   * Compute boolean union in a dedicated Web Worker (non-blocking).
-   * Defaults to allowUnsafe=true so high-poly jobs can run off the UI thread.
+
+  exportUnionRepro(
+    other: Mesh,
+    options?: MeshBooleanOptions,
+    reproOptions?: MeshBooleanReproOptions,
+  ): MeshBooleanReproPayload {
+    return this.exportBooleanRepro(other, "union", options, reproOptions);
+  }
+
+  exportIntersectRepro(
+    other: Mesh,
+    options?: MeshBooleanOptions,
+    reproOptions?: MeshBooleanReproOptions,
+  ): MeshBooleanReproPayload {
+    return this.exportBooleanRepro(other, "intersection", options, reproOptions);
+  }
+
+  static replayBooleanRepro(payload: MeshBooleanReproPayload): Mesh {
+    const inputA = Mesh.fromBuffer(new Float64Array(payload.inputA.buffer), {
+      trustedBooleanInput: payload.inputA.trustedBooleanInput,
+    });
+    const inputB = Mesh.fromBuffer(new Float64Array(payload.inputB.buffer), {
+      trustedBooleanInput: payload.inputB.trustedBooleanInput,
+    });
+
+    return payload.operation === "union"
+      ? inputA.union(inputB, payload.options ?? undefined)
+      : payload.operation === "subtraction"
+        ? inputA.subtract(inputB, payload.options ?? undefined)
+        : inputA.intersect(inputB, payload.options ?? undefined);
+  }
+
+  /**
+   * Compute boolean union in a dedicated Web Worker (non-blocking).
+   * Defaults to allowUnsafe=true so high-poly jobs can run off the UI thread.
    */
   async unionAsync(other: Mesh, options?: MeshBooleanAsyncOptions): Promise<Mesh> {
     const result = await runMeshBooleanInWorkerPool(