@solid-labs/fab-one-widget 0.1.5 → 0.1.7

package/dist/girth-manager-ui/src/GirthManagerCore.d.ts

@@ -1,5 +1,6 @@
 import { type GirthManagerConfig } from "./config";
-import type { MeasurementData, WasmMeshSetType } from "./processing/types";
+import type { MeasurementFormData } from "./components/MeasurementInputForm";
+import type { MeasurementData, WasmModule } from "./processing/types";
 export interface GirthManagerResult {
     spacingType: "AK" | "BK";
     sourceUnit: "mm" | "inch";
@@ -13,6 +14,13 @@ export interface GirthManagerResult {
     transverseML: number;
     transverseAP: number;
     scanUrl: string | undefined;
+    decision: "use_form_measurements" | "use_scan" | "continue" | "skip";
+    skipReason?: string;
+    userEnteredMeasurements?: MeasurementFormData;
+    screenshots?: {
+        frontal_view_png: string;
+        side_view_png: string;
+    };
 }
 export interface GirthManagerCoreProps {
     /** Feature config — controls which UI elements are rendered */
@@ -29,9 +37,7 @@ export interface GirthManagerCoreProps {
     isDebugUser?: boolean;
     /** Called when analytics events should fire (internal app wires this to PostHog) */
     onAnalyticsEvent?: (eventName: string, properties: Record<string, unknown>) => void;
-    /** Provide a loaded WASM module. If not provided, the core will attempt to dynamically import 'galileo-core-geo'. */
-    wasmModule?: {
-        WasmMeshSet: new () => WasmMeshSetType;
-    } | null;
+    /** Provide a loaded WASM module. If not provided, JS fallback is used. */
+    wasmModule?: WasmModule | null;
 }
 export declare const GirthManagerCore: ({ config, spacingType: presetSpacingType, scanUrl, formMeasurements: presetFormMeasurements, onComplete, isDebugUser, onAnalyticsEvent, wasmModule: externalWasmModule, }: GirthManagerCoreProps) => import("react/jsx-runtime").JSX.Element;

package/dist/girth-manager-ui/src/components/CameraFit.d.ts

@@ -7,5 +7,9 @@ export interface CameraFitProps {
     viewMode: "3D" | "2D";
     sliceY?: number;
     landmarkCount?: number;
+    /** Clipped geometry for measurements — camera zooms to this region when aligned */
+    measurementGeometry?: THREE.BufferGeometry | null;
+    /** Ref populated with a function that resets camera to flat front view */
+    resetCameraToFrontRef?: React.MutableRefObject<(() => void) | null>;
 }
-export declare const CameraFit: ({ modelSize, isAligned, isCut, mesh, viewMode, sliceY, landmarkCount }: CameraFitProps) => null;
+export declare const CameraFit: ({ modelSize, isAligned, isCut, mesh, viewMode, sliceY, landmarkCount, measurementGeometry, resetCameraToFrontRef }: CameraFitProps) => null;

package/dist/girth-manager-ui/src/components/CircumferenceMeasurements.d.ts

@@ -1,5 +1,6 @@
 import * as THREE from "three";
 import type { MeasurementData } from "../processing/types";
+import type { WasmSliceData } from "../processing/pipeline";
 export interface CircumferenceMeasurementsProps {
     mesh: THREE.Mesh;
     startY: number;
@@ -12,5 +13,7 @@ export interface CircumferenceMeasurementsProps {
     useInnerSurface?: boolean;
     formMeasurements?: number[];
     originY?: number;
+    /** WASM-computed slice data — when provided, uses WASM circumferences + loop points instead of JS BVH */
+    wasmSlices?: WasmSliceData | null;
 }
-export declare const CircumferenceMeasurements: ({ mesh, startY, endY, spacing, modelSize, onMeasurementsChange, reverseOrder, displayUnit, useInnerSurface, formMeasurements, originY }: CircumferenceMeasurementsProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare const CircumferenceMeasurements: ({ mesh, startY, endY, spacing, modelSize, onMeasurementsChange, reverseOrder, displayUnit, useInnerSurface, formMeasurements, originY, wasmSlices }: CircumferenceMeasurementsProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/girth-manager-ui/src/components/CircumferenceSlice.d.ts

@@ -1,4 +1,5 @@
 import * as THREE from "three";
+import { Vector3 } from "three";
 import { MeshBVH } from "three-mesh-bvh";
 import type { MeasurementData } from "../processing/types";
 export interface CircumferenceSliceProps {
@@ -12,5 +13,9 @@ export interface CircumferenceSliceProps {
     useInnerSurface?: boolean;
     formValue?: number;
     lineWidth?: number;
+    /** WASM-computed loop points for this slice (bypasses JS BVH when provided) */
+    wasmLoopPoints?: Vector3[];
+    /** WASM-computed circumference for this slice */
+    wasmCircumference?: number;
 }
-export declare const CircumferenceSlice: import("react").MemoExoticComponent<({ bvh, geometry, yPosition, color, labelX, onDataChange, displayUnit, useInnerSurface, formValue, lineWidth }: CircumferenceSliceProps) => import("react/jsx-runtime").JSX.Element | null>;
+export declare const CircumferenceSlice: import("react").MemoExoticComponent<({ bvh, geometry, yPosition, color, labelX, onDataChange, displayUnit, useInnerSurface, formValue, lineWidth, wasmLoopPoints, wasmCircumference }: CircumferenceSliceProps) => import("react/jsx-runtime").JSX.Element | null>;

package/dist/girth-manager-ui/src/components/ClickableMesh.d.ts

@@ -4,5 +4,9 @@ export interface ClickableMeshProps {
     maxPoints?: number;
     meshColor?: string;
     meshOpacity?: number;
+    /** When true, only render/click front faces (prevents clicking from inside the mesh) */
+    frontFaceOnly?: boolean;
+    /** When true, enables transparency mode optimized for double-shell meshes */
+    doubleShellTransparency?: boolean;
 }
-export declare const ClickableMesh: ({ mesh, maxPoints, meshColor, meshOpacity }: ClickableMeshProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ClickableMesh: ({ mesh, maxPoints, meshColor, meshOpacity, frontFaceOnly, doubleShellTransparency }: ClickableMeshProps) => import("react/jsx-runtime").JSX.Element;

package/dist/girth-manager-ui/src/components/DebugOverlays.d.ts

@@ -1,10 +1,17 @@
 import * as THREE from "three";
-import type { ComponentDebugInfo } from "../processing/wasm-loader";
+/** Per-component debug geometry (legacy — now passed as null) */
+export interface ComponentDebugInfo {
+    geometries: THREE.BufferGeometry[];
+    labels: string[];
+    colors: string[];
+    innerIdx: number | null;
+}
 export interface DebugLayerVisibility {
     pcaAxes: boolean;
     obb: boolean;
     obbAxis: boolean;
     shellComponents: boolean;
+    ambientOcclusion: boolean;
     circumferenceScan: boolean;
     landmarkAxis: boolean;
     iterativePCA: boolean;
@@ -23,8 +30,13 @@ export interface DebugOverlaysProps {
         };
     }[];
     componentDebug?: ComponentDebugInfo | null;
+    aoData?: Float32Array | null;
+    /** The geometry that aoData corresponds to (pre-extraction), since mesh.geometry may change after inner shell extraction */
+    aoGeometry?: THREE.BufferGeometry | null;
+    /** Clipped geometry used for measurements — rendered as wireframe in debug to show cut region */
+    measurementGeometry?: THREE.BufferGeometry | null;
 }
-export declare function DebugOverlays({ mesh, layers, landmarkPoints, componentDebug }: DebugOverlaysProps): import("react/jsx-runtime").JSX.Element;
+export declare function DebugOverlays({ mesh, layers, landmarkPoints, componentDebug, aoData, aoGeometry, measurementGeometry }: DebugOverlaysProps): import("react/jsx-runtime").JSX.Element;
 export interface OBBAlignmentLineProps {
     mesh: THREE.Mesh;
 }

package/dist/girth-manager-ui/src/components/DebugPanel.d.ts

@@ -2,5 +2,6 @@ import type { DebugLayerVisibility } from "./DebugOverlays";
 export interface DebugPanelProps {
     layers: DebugLayerVisibility;
     onToggleLayer: (layer: keyof DebugLayerVisibility) => void;
+    isDoubleShell?: boolean;
 }
-export declare function DebugPanel({ layers, onToggleLayer }: DebugPanelProps): import("react/jsx-runtime").JSX.Element;
+export declare function DebugPanel({ layers, onToggleLayer, isDoubleShell }: DebugPanelProps): import("react/jsx-runtime").JSX.Element;

package/dist/girth-manager-ui/src/components/ErrorBoundary.d.ts

@@ -0,0 +1,16 @@
+import { Component, type ReactNode } from "react";
+interface ErrorBoundaryProps {
+    children: ReactNode;
+    fallback?: (error: Error, reset: () => void) => ReactNode;
+}
+interface ErrorBoundaryState {
+    error: Error | null;
+}
+export declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    state: ErrorBoundaryState;
+    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
+    componentDidCatch(error: Error, info: React.ErrorInfo): void;
+    reset: () => void;
+    render(): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react/jsx-runtime").JSX.Element | null | undefined;
+}
+export {};

package/dist/girth-manager-ui/src/components/MeasurementInputForm.d.ts

@@ -0,0 +1,14 @@
+import type { MeasurementData } from "../processing/types";
+export interface MeasurementFormData {
+    circumferences: number[];
+    frontalHeight: number;
+}
+export interface MeasurementInputFormProps {
+    amputationType: "AK" | "BK";
+    spacingInches: 1 | 2;
+    scanMeasurements: MeasurementData[];
+    scanFrontalHeight: number;
+    onSave: (data: MeasurementFormData) => void;
+    onSkip: (reason: string) => void;
+}
+export declare const MeasurementInputForm: ({ amputationType, spacingInches, scanMeasurements, scanFrontalHeight, onSave, onSkip, }: MeasurementInputFormProps) => import("react/jsx-runtime").JSX.Element;

package/dist/girth-manager-ui/src/components/VerticalDimension.d.ts

@@ -4,5 +4,7 @@ export interface VerticalDimensionProps {
     greenY: number;
     modelSize: number;
     displayUnit?: "mm" | "inch";
+    /** When set, measure to this Y instead of the mesh bounding box bottom (used for double-shell) */
+    bottomY?: number;
 }
-export declare const VerticalDimension: ({ mesh, greenY, modelSize, displayUnit }: VerticalDimensionProps) => import("react/jsx-runtime").JSX.Element;
+export declare const VerticalDimension: ({ mesh, greenY, modelSize, displayUnit, bottomY }: VerticalDimensionProps) => import("react/jsx-runtime").JSX.Element;

package/dist/girth-manager-ui/src/config.d.ts

@@ -8,8 +8,6 @@ export interface GirthManagerConfig {
     showDragDrop: boolean;
     /** Show "Start Over" button */
     showStartOver: boolean;
-    /** Show "Insert Measurement" button and modal */
-    showInsertMeasurement: boolean;
     /** Allow debug mode toggle (requires isDebugUser) */
     showDebug: boolean;
     /** Show 1"/2" measurement spacing toggle */
@@ -20,6 +18,8 @@ export interface GirthManagerConfig {
     showNavigation: boolean;
     /** Show top toolbar ribbon */
     showToolbar: boolean;
+    /** Show manual "Save" screenshot button */
+    showSaveButton: boolean;
 }
 /** Default config for the internal application (all features enabled) */
 export declare const INTERNAL_CONFIG: GirthManagerConfig;

package/dist/girth-manager-ui/src/index.d.ts

@@ -3,20 +3,22 @@ export type { GirthManagerConfig } from "./config";
 export { GirthManagerCore } from "./GirthManagerCore";
 export type { GirthManagerCoreProps, GirthManagerResult } from "./GirthManagerCore";
 export { useMeasurementStore } from "./store";
-export type { WasmMeshSetType, LandmarkPoint, MeasurementData, SliceResult, Seg } from "./processing/types";
+export type { WasmModule, LandmarkPoint, MeasurementData, SliceResult, Seg } from "./processing/types";
 export { LABEL_X_OFFSET_RATIO, BVH_MAX_LEAF_TRIS, WELD_EPSILON, MM_PER_INCH, ABOVE_POINT_OFFSET_INCHES, AUTO_SCALE_VOLUME_THRESHOLD, RETRY_OFFSETS } from "./processing/constants";
 export { parseObjVertexColors, transferVertexColors } from "./processing/vertex-colors";
 export { computeSliceAtYOnce, computeSliceAtY, buildBVH, calcLineLength, computeCircumferenceAtPlane } from "./processing/slice";
 export { intersectMeshWithPlane, findBestCutPlane } from "./processing/cut-plane";
 export { computeBarycentricCoords, sliceMeshAtPlane } from "./processing/mesh-ops";
-export type { ShellDetectionResult } from "./processing/mesh-ops";
 export { runPCAOnRegion } from "./processing/alignment";
 export { validateProcessingResult } from "./processing/validation";
+export { logger } from "./processing/logger";
+export type { LogLevel } from "./processing/logger";
 export { stlToObjString } from "./processing/stl-convert";
-export { processWithWasm, processWithObjLoader } from "./processing/wasm-loader";
-export type { WasmProcessResult, ComponentDebugInfo } from "./processing/wasm-loader";
-export { runProcessingPipeline, cutMeshAtY } from "./processing/pipeline";
-export type { PipelineCallbacks } from "./processing/pipeline";
+export { processWithWasm, processWithObjLoader, extractArrays, buildGeometry } from "./processing/wasm-loader";
+export type { WasmProcessResult } from "./processing/wasm-loader";
+export { runProcessingPipeline } from "./processing/pipeline";
+export type { PipelineCallbacks, WasmSliceData } from "./processing/pipeline";
+export { ErrorBoundary } from "./components/ErrorBoundary";
 export { ErrorDisplay } from "./components/ErrorDisplay";
 export { LoadingSpinner } from "./components/LoadingSpinner";
 export { ClickableMesh } from "./components/ClickableMesh";
@@ -35,4 +37,6 @@ export { TransverseView } from "./components/TransverseView";
 export { DebugOverlays, DEFAULT_DEBUG_LAYERS, OBBAlignmentLine } from "./components/DebugOverlays";
 export type { DebugLayerVisibility } from "./components/DebugOverlays";
 export { DebugPanel } from "./components/DebugPanel";
+export { MeasurementInputForm } from "./components/MeasurementInputForm";
+export type { MeasurementInputFormProps, MeasurementFormData } from "./components/MeasurementInputForm";
 export { useCachedBVH } from "./hooks/useCachedBVH";

package/dist/girth-manager-ui/src/processing/logger.d.ts

@@ -0,0 +1,13 @@
+export type LogLevel = "debug" | "info" | "warn" | "error";
+declare let onLog: ((level: LogLevel, tag: string, message: string, data?: unknown) => void) | null;
+export declare const logger: {
+    /** Set minimum log level. Below this level, messages are silenced. */
+    setLevel(level: LogLevel): void;
+    /** Set an external log handler (e.g. for sending errors to monitoring). */
+    setHandler(handler: typeof onLog): void;
+    debug(tag: string, message: string, data?: unknown): void;
+    info(tag: string, message: string, data?: unknown): void;
+    warn(tag: string, message: string, data?: unknown): void;
+    error(tag: string, message: string, data?: unknown): void;
+};
+export {};

package/dist/girth-manager-ui/src/processing/mesh-ops.d.ts

@@ -1,27 +1,5 @@
 import * as THREE from "three";
 import { Vector3 } from "three";
-export interface ShellDetectionResult {
-    isDoubleShell: boolean;
-    sampledFaces: number;
-    opposingPairs: number;
-    confidence: number;
-}
-/**
- * Detect whether a mesh is single-shell or double-shell (has wall thickness).
- *
- * Method: BVH ray intersection counting.
- * For each of 3 cross-sections perpendicular to the red→green axis, the centroid
- * is computed, then 12 rays are cast radially outward from it. Each ray counts all
- * triangle intersections (both front and back faces via double-sided testing).
- *
- *   Single shell → each ray exits through 1 wall → avg hits ≈ 1
- *   Double shell → each ray exits through inner wall + outer wall → avg hits ≈ 2
- *
- * This is independent of normal direction and surface texture/roughness.
- * At least 2 of 3 sections must independently show avg hits > 1.5 to classify as
- * double-shell, preventing false positives from irregular endpoints.
- */
-export declare function detectDoubleShell(geometry: THREE.BufferGeometry, redPoint: Vector3, greenPoint: Vector3): ShellDetectionResult;
 /** Compute barycentric coordinates of point p with respect to triangle (a, b, c) */
 export declare function computeBarycentricCoords(p: Vector3, a: Vector3, b: Vector3, c: Vector3): {
     u: number;

package/dist/girth-manager-ui/src/processing/pipeline.d.ts

@@ -1,10 +1,23 @@
 import * as THREE from "three";
-import { Vector3 } from "three";
+import type { WasmModule } from "./types";
+/** WASM-computed horizontal slice data from batch_cross_sections_y */
+export interface WasmSliceData {
+    /** Y positions where slices were computed */
+    yValues: number[];
+    /** Circumference at each Y (mm) */
+    circumferences: number[];
+    /** All loop points concatenated [x,y,z,...] */
+    allLoopPoints: Float32Array;
+    /** Byte offsets into allLoopPoints for each slice */
+    offsets: Uint32Array;
+    /** MPT Y coordinate */
+    mptY: number;
+    /** Origin Y coordinate */
+    originY: number;
+}
 export interface PipelineCallbacks {
     onStatus: (message: string) => void;
     setDoubleShell?: (isDoubleShell: boolean) => void;
-    /** When true, skip double-shell detection (inner shell was already extracted during WASM processing) */
-    skipDoubleShellDetection?: boolean;
     addLandmarkPoint: (point: {
         faceIndex: number;
         vertexIndices: [number, number, number];
@@ -33,10 +46,25 @@ export interface PipelineCallbacks {
     setAdjustedEndY: (y: number | null) => void;
     setError: (error: string | null) => void;
     setClippedReferenceGeometry?: (geometry: THREE.BufferGeometry | null) => void;
+    setMeasurementGeometry?: (geometry: THREE.BufferGeometry | null) => void;
+    setAoData?: (data: Float32Array | null, geometry?: THREE.BufferGeometry) => void;
+    setInnerShellExtracted?: (extracted: boolean) => void;
+    /** Callback to set WASM-computed slice data (circumferences + loop geometry) */
+    setWasmSlices?: (data: WasmSliceData) => void;
+    wasmModule?: WasmModule;
 }
-/** Cut mesh at Y-plane, keep geometry below cutY, keep largest component closest to redPoint */
-export declare function cutMeshAtY(mesh: THREE.Mesh, currentLandmarks: Vector3[], geometry: THREE.BufferGeometry, cutOffsetInches: number, callbacks: PipelineCallbacks, refGeo?: THREE.BufferGeometry | null): Vector3[];
-/** Full processing pipeline: find cut plane, slice, align, PCA, cut, validate with retries */
+/**
+ * Full processing pipeline using WASM.
+ *
+ * Follows the reference pipeline exactly:
+ *   1. detect_shell
+ *   2. find_min_cross_section (at MPT)
+ *   3. align_to_origin (initial alignment)
+ *   4. subdivide_origin_to_plane (generate Y heights)
+ *   5. batch_cross_sections_y (at subdivision points → centroids)
+ *   6. refine_alignment (PCA on centroids)
+ *   7. batch_cross_sections_y (final 1" slicing)
+ */
 export declare function runProcessingPipeline(mesh: THREE.Mesh, landmarkPoints: {
     position: {
         x: number;

package/dist/girth-manager-ui/src/processing/types.d.ts

@@ -1,16 +1,116 @@
 import type { Vector3 } from "three";
-export interface WasmMeshSetType {
-    loadObjString(data: string): void;
-    applyCloseHoles(maxHoleSize: number): void;
-    applyMergeCloseVertices(threshold: number): void;
-    splitAndKeepLargest(): void;
-    getComponentCount(): number;
-    extractInnerShell(maxWallThickness: number): boolean;
-    getComponentLabels(): Int32Array;
-    getVertices(): Float32Array;
-    getFaces(): Int32Array;
-    autoScaleToMm(volumeThreshold: number): boolean;
-    free(): void;
+export interface PreprocessResult {
+    positions(): Float32Array;
+    indices(): Uint32Array;
+    bbox_size(): Float32Array;
+    detected_unit(): string;
+    unit_converted(): boolean;
+    max_dimension(): number;
+    weld_stats(): string;
+    holes_filled(): number;
+    log(): string;
+}
+export interface ShellDetectResult {
+    is_double_shell(): boolean;
+    thickness(): number;
+    ray_count(): number;
+    double_hit_count(): number;
+    avg_thickness(): number;
+    min_thickness(): number;
+    max_thickness(): number;
+    details(): string;
+    hit_ray_lines(): Float32Array;
+    miss_ray_lines(): Float32Array;
+    hit_points(): Float32Array;
+    surface_normal(): Float32Array;
+}
+export interface ExtractInnerShellResult {
+    positions(): Float32Array;
+    indices(): Uint32Array;
+    interior_point(): Float32Array;
+    inner_count(): number;
+    total_count(): number;
+    details(): string;
+}
+export interface AlignResult {
+    positions(): Float32Array;
+    mpt(): Float32Array;
+    origin(): Float32Array;
+    transform(): Float32Array;
+    details(): string;
+}
+export interface SecondaryPcaResult {
+    positions(): Float32Array;
+    mpt(): Float32Array;
+    origin(): Float32Array;
+    transform(): Float32Array;
+    details(): string;
+}
+export interface RefineAlignmentResult {
+    positions(): Float32Array;
+    mpt(): Float32Array;
+    origin(): Float32Array;
+    rotation(): Float32Array;
+    centroid_axis(): Float32Array;
+    correction_angle(): number;
+    details(): string;
+}
+export interface SubdivideLineResult {
+    points(): Float32Array;
+    count(): number;
+    spacing(): number;
+    total_distance(): number;
+}
+export interface CrossSectionResult {
+    loop_points(): Float32Array;
+    plane_normal(): Float32Array;
+    circumference(): number;
+    is_closed(): boolean;
+    details(): string;
+}
+export interface BatchCrossSectionResult {
+    all_loop_points(): Float32Array;
+    offsets(): Uint32Array;
+    circumferences(): Float32Array;
+    count(): number;
+    details(): string;
+}
+export interface MeshResult {
+    positions(): Float32Array;
+    indices(): Uint32Array;
+    stats(): string;
+}
+export interface FillHolesResult {
+    positions(): Float32Array;
+    indices(): Uint32Array;
+    holes_filled(): number;
+    details(): string;
+}
+/** WASM module — functional API, no persistent state */
+export interface WasmModule {
+    bounding_box(positions: Float32Array): Float32Array;
+    preprocess_mesh(positions: Float32Array, indices: Uint32Array, meter_threshold: number, weld_tolerance: number, max_hole_perimeter: number): PreprocessResult;
+    detect_and_convert_units(positions: Float32Array, meter_threshold: number): {
+        positions(): Float32Array;
+        detected_unit(): string;
+        converted(): boolean;
+        max_dimension(): number;
+    };
+    center_to_origin(positions: Float32Array): Float32Array;
+    weld_and_keep_largest(positions: Float32Array, tolerance: number): MeshResult;
+    weld_and_keep_largest_indexed(positions: Float32Array, indices: Uint32Array, tolerance: number): MeshResult;
+    fill_small_holes(positions: Float32Array, indices: Uint32Array, max_perimeter: number): FillHolesResult;
+    align_to_origin(positions: Float32Array, origin_pt: Float32Array, mpt: Float32Array, plane_normal: Float32Array): AlignResult;
+    secondary_pca(selected_positions: Float32Array, all_positions: Float32Array, origin_pt: Float32Array, mpt: Float32Array): SecondaryPcaResult;
+    refine_alignment(centroids: Float32Array, all_positions: Float32Array, origin_pt: Float32Array, mpt: Float32Array): RefineAlignmentResult;
+    subdivide_origin_to_plane(origin_pt: Float32Array, mpt: Float32Array, plane_normal: Float32Array): SubdivideLineResult;
+    detect_shell(positions: Float32Array, indices: Uint32Array, mpt: Float32Array, max_thickness: number): ShellDetectResult;
+    extract_inner_shell(positions: Float32Array, indices: Uint32Array, mpt: Float32Array, wall_thickness: number, hit_points: Float32Array): ExtractInnerShellResult;
+    ray_cast_bvh(positions: Float32Array, ray_origin: Float32Array, ray_dir: Float32Array): Uint32Array;
+    find_min_cross_section(positions: Float32Array, indices: Uint32Array, mpt: Float32Array, surface_normal: Float32Array, max_gap: number): CrossSectionResult;
+    batch_cross_sections_y(positions: Float32Array, indices: Uint32Array, y_values: Float32Array, max_gap: number): BatchCrossSectionResult;
+    batch_cross_sections_y_inner(positions: Float32Array, indices: Uint32Array, y_values: Float32Array, max_gap: number): BatchCrossSectionResult;
+    default(): Promise<void>;
 }
 export interface LandmarkPoint {
     faceIndex: number;

package/dist/girth-manager-ui/src/processing/vertex-colors.d.ts

@@ -4,5 +4,10 @@ export declare function parseObjVertexColors(objText: string): {
     positions: Float32Array;
     colors: Float32Array;
 } | null;
-/** Transfer vertex colors from original OBJ data to processed geometry via nearest-vertex matching with spatial grid. */
+/** Transfer vertex colors from original OBJ data to processed geometry via nearest-vertex matching with spatial grid.
+ *
+ * After preprocess_mesh, geometry is centered to origin (AABB center subtracted).
+ * Original OBJ positions are in their raw coordinate system. We compute the centering
+ * offset from the original positions so both spaces align for nearest-neighbor lookup.
+ */
 export declare function transferVertexColors(geometry: THREE.BufferGeometry, origPositions: Float32Array, origColors: Float32Array, scaleFactor: number): void;

package/dist/girth-manager-ui/src/processing/wasm-loader.d.ts

@@ -1,23 +1,23 @@
 import * as THREE from "three";
-import type { WasmMeshSetType } from "./types";
-/** Per-component debug geometry */
-export interface ComponentDebugInfo {
-    geometries: THREE.BufferGeometry[];
-    labels: string[];
-    colors: string[];
-    innerIdx: number | null;
-}
+import type { WasmModule } from "./types";
 export interface WasmProcessResult {
     geometry: THREE.BufferGeometry;
     wasScaled: boolean;
-    /** True if a double-shell was detected and the inner shell was extracted */
-    innerShellExtracted: boolean;
-    /** Debug: per-component colored geometries (only populated when componentCount >= 2) */
-    componentDebug: ComponentDebugInfo | null;
+    /** True if unit conversion from meters to mm occurred */
+    unitConverted: boolean;
+    /** Detected unit: "meter" | "mm" | "unknown" */
+    detectedUnit: string;
 }
-/** Process OBJ string through WASM pipeline (merge, clean, close holes, scale) */
-export declare function processWithWasm(objContents: string, wasmModule: {
-    WasmMeshSet: new () => WasmMeshSetType;
-}, onStatus?: (message: string) => void): Promise<WasmProcessResult | null>;
+/** Extract positions and indices from a THREE.BufferGeometry */
+declare function extractArrays(geometry: THREE.BufferGeometry): {
+    positions: Float32Array;
+    indices: Uint32Array;
+};
+/** Build a THREE.BufferGeometry from flat position + index arrays */
+declare function buildGeometry(positions: Float32Array, indices: Uint32Array): THREE.BufferGeometry;
+/** Process OBJ string through WASM pipeline (preprocess_mesh: units + center + weld + fill) */
+export declare function processWithWasm(objContents: string, wasmModule: WasmModule, onStatus?: (message: string) => void): Promise<WasmProcessResult | null>;
 /** Fallback: process OBJ string with Three.js OBJLoader */
 export declare function processWithObjLoader(objContents: string): THREE.BufferGeometry | null;
+/** Helper: extract flat arrays from THREE geometry for passing to WASM functions */
+export { extractArrays, buildGeometry };

package/dist/girth-manager-web-widget/src/GirthManagerWidget.d.ts

@@ -1,13 +1,11 @@
-import { type WasmMeshSetType } from "@galileo/girth-manager-ui";
+import { type WasmModule } from "@galileo/girth-manager-ui";
 import type { WidgetRequest, WidgetResponse } from "./types";
 export interface GirthManagerWidgetProps {
     /** Widget input configuration */
     request: WidgetRequest;
     /** Called when "Continue to Next Step" is clicked with the full response payload */
     onComplete?: (response: WidgetResponse) => void;
-    /** Pre-loaded WASM module. If omitted, the widget auto-loads galileo-core-geo. */
-    wasmModule?: {
-        WasmMeshSet: new () => WasmMeshSetType;
-    } | null;
+    /** Pre-loaded WASM module. If omitted, the widget auto-loads geo-wasm. */
+    wasmModule?: WasmModule | null;
 }
 export declare const GirthManagerWidget: ({ request, onComplete, wasmModule: externalWasm }: GirthManagerWidgetProps) => import("react/jsx-runtime").JSX.Element;

package/dist/girth-manager-web-widget/src/index.d.ts

@@ -1,4 +1,4 @@
 export { GirthManagerWidget } from "./GirthManagerWidget";
 export type { GirthManagerWidgetProps } from "./GirthManagerWidget";
-export type { WidgetRequest, WidgetResponse, Circumference } from "./types";
+export type { WidgetRequest, WidgetResponse, Circumference, SocketScreenshots } from "./types";
 export { getCircumferenceKeys, arrayToCircumference, circumferenceToArray } from "./types";

package/dist/girth-manager-web-widget/src/types.d.ts

@@ -41,6 +41,51 @@ export interface WidgetResponse {
     transverse_ml: number;
     /** Anterior-posterior transverse dimension (mm) */
     transverse_ap: number;
+    /**
+     * User's final decision:
+     * - "use_form_measurements": customer chose "Set to Measurements" (use their manually entered values)
+     * - "use_scan": customer chose "Go With Scan" (use scan-derived values)
+     * - "continue": all measurements were within tolerance (green) — customer confirmed to continue as-is
+     * - "skip": customer skipped the scan comparison entirely
+     */
+    decision: "use_form_measurements" | "use_scan" | "continue" | "skip";
+    /** Reason the user skipped scan comparison (only present when decision is "skip") */
+    skip_reason?: string;
+    /** User-entered circumference measurements (mm). Only present when user entered measurements. */
+    user_measurements?: Circumference;
+    /** User-entered frontal height (mm). Only present when user entered measurements. */
+    user_frontal_height?: number;
+    /**
+     * Final resolved circumference measurements (mm) to use for the order form.
+     * When decision is "use_form_measurements": contains the user's entered measurements.
+     * When decision is "use_scan" or "continue": contains the scan-derived measurements.
+     * When decision is "skip": contains the user's entered measurements (form_provided).
+     */
+    final_measurements: Circumference;
+    /** Final resolved frontal height (mm) to use for the order form, based on the user's decision. */
+    final_frontal_height: number;
+    /** Final resolved ML transverse dimension (mm) to use for the order form, based on the user's decision. */
+    final_transverse_ml: number;
+    /** Final resolved AP transverse dimension (mm) to use for the order form, based on the user's decision. */
+    final_transverse_ap: number;
+    /**
+     * PNG screenshots of the final rendered socket with measurement annotations.
+     * Includes a frontal view (BK: MPT anchor / AK: IT anchor) and a 90° side view.
+     * Both images are base64-encoded data URIs ready for display or upload.
+     * Omitted if screenshot capture was not possible (e.g. render not available).
+     */
+    screenshots?: SocketScreenshots;
+}
+/**
+ * Screenshot outputs of the final socket with measurements overlaid.
+ * BK: frontal view anchored at MPT point + 90° side view
+ * AK: frontal view anchored at IT point + 90° side view
+ */
+export interface SocketScreenshots {
+    /** Frontal view PNG encoded as a base64 data URI (e.g. "data:image/png;base64,...") */
+    frontal_view_png: string;
+    /** Side view (90° rotation) PNG encoded as a base64 data URI */
+    side_view_png: string;
 }
 export interface Circumference {
     /** 2" above the reference landmark (mm) */
@@ -67,6 +112,18 @@ export interface Circumference {
     "8_below"?: number | undefined | null;
     /** 9" below the reference landmark (mm) */
     "9_below"?: number | undefined | null;
+    /** 10" below the reference landmark (mm) */
+    "10_below"?: number | undefined | null;
+    /** 11" below the reference landmark (mm) */
+    "11_below"?: number | undefined | null;
+    /** 12" below the reference landmark (mm) */
+    "12_below"?: number | undefined | null;
+    /** 14" below the reference landmark (mm) */
+    "14_below"?: number | undefined | null;
+    /** 16" below the reference landmark (mm) */
+    "16_below"?: number | undefined | null;
+    /** 18" below the reference landmark (mm) */
+    "18_below"?: number | undefined | null;
 }
 /** Ordered keys for mapping measurement arrays to Circumference fields */
 export declare function getCircumferenceKeys(spacingType: "AK" | "BK"): (keyof Circumference)[];

package/dist/girth-manager-web-widget/src/web-component.d.ts

@@ -5,7 +5,7 @@ import type { WidgetRequest, WidgetResponse } from "./types";
  * Usage in Angular:
  *   // In the component class:
  *   async ngAfterViewInit() {
- *     const wasm = await import('galileo-core-geo');
+ *     const wasm = await import('geo-wasm');
  *     await wasm.default();
  *     this.widgetEl.nativeElement.wasmModule = wasm;
  *     this.widgetEl.nativeElement.request = { spacing_type: 'BK', scan_url: '...' };
@@ -21,7 +21,7 @@ declare class GirthManagerWidgetElement extends HTMLElement {
     static get observedAttributes(): string[];
     get request(): WidgetRequest | null;
     set request(value: WidgetRequest | string | null);
-    /** Set the pre-loaded WASM module (galileo-core-geo). Must be set before or alongside request. */
+    /** Set the pre-loaded WASM v2 module (geo-wasm). Must be set before or alongside request. */
     get wasmModule(): unknown;
     set wasmModule(value: unknown);
     connectedCallback(): void;