@solid-labs/fab-one-widget 0.1.1 → 0.1.2

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

@@ -0,0 +1,37 @@
+import { type GirthManagerConfig } from "./config";
+import type { MeasurementData, WasmMeshSetType } from "./processing/types";
+export interface GirthManagerResult {
+    spacingType: "AK" | "BK";
+    sourceUnit: "mm" | "inch";
+    fileFormat: "obj" | "stl";
+    measurementSource: "scan_derived" | "form_provided";
+    isDoubleWall: boolean;
+    isUnitConverted: boolean;
+    formMeasurements: number[] | undefined;
+    scanMeasurements: MeasurementData[];
+    frontalHeight: number;
+    transverseML: number;
+    transverseAP: number;
+    scanUrl: string | undefined;
+}
+export interface GirthManagerCoreProps {
+    /** Feature config — controls which UI elements are rendered */
+    config: GirthManagerConfig;
+    /** Pre-set amputation/spacing type (skips the modal when set) */
+    spacingType?: "AK" | "BK";
+    /** URL to auto-load a scan file from (widget mode) */
+    scanUrl?: string;
+    /** Form-provided circumference measurements in mm, ordered by slice position (widget mode) */
+    formMeasurements?: number[];
+    /** Called when "Continue to Next Step" is clicked */
+    onComplete?: (result: GirthManagerResult) => void;
+    /** Whether current user can access debug features */
+    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;
+}
+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/AlignedOrbitControls.d.ts

@@ -0,0 +1,5 @@
+import * as THREE from "three";
+export declare const AlignedOrbitControls: ({ mesh, isDragging }: {
+    mesh: THREE.Mesh;
+    isDragging: boolean;
+}) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,11 @@
+import * as THREE from "three";
+export interface CameraFitProps {
+    modelSize: number;
+    isAligned: boolean;
+    isCut: boolean;
+    mesh: THREE.Mesh | null;
+    viewMode: "3D" | "2D";
+    sliceY?: number;
+    landmarkCount?: number;
+}
+export declare const CameraFit: ({ modelSize, isAligned, isCut, mesh, viewMode, sliceY, landmarkCount }: CameraFitProps) => null;

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

@@ -0,0 +1,16 @@
+import * as THREE from "three";
+import type { MeasurementData } from "../processing/types";
+export interface CircumferenceMeasurementsProps {
+    mesh: THREE.Mesh;
+    startY: number;
+    endY: number;
+    spacing: number;
+    modelSize: number;
+    onMeasurementsChange?: (measurements: MeasurementData[]) => void;
+    reverseOrder?: boolean;
+    displayUnit?: "mm" | "inch";
+    useInnerSurface?: boolean;
+    formMeasurements?: number[];
+    originY?: number;
+}
+export declare const CircumferenceMeasurements: ({ mesh, startY, endY, spacing, modelSize, onMeasurementsChange, reverseOrder, displayUnit, useInnerSurface, formMeasurements, originY }: CircumferenceMeasurementsProps) => import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1,16 @@
+import * as THREE from "three";
+import { MeshBVH } from "three-mesh-bvh";
+import type { MeasurementData } from "../processing/types";
+export interface CircumferenceSliceProps {
+    bvh: MeshBVH;
+    geometry: THREE.BufferGeometry;
+    yPosition: number;
+    color?: string;
+    labelX: number;
+    onDataChange?: (data: MeasurementData) => void;
+    displayUnit?: "mm" | "inch";
+    useInnerSurface?: boolean;
+    formValue?: number;
+    lineWidth?: 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>;

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

@@ -0,0 +1,8 @@
+import * as THREE from "three";
+export interface ClickableMeshProps {
+    mesh: THREE.Mesh;
+    maxPoints?: number;
+    meshColor?: string;
+    meshOpacity?: number;
+}
+export declare const ClickableMesh: ({ mesh, maxPoints, meshColor, meshOpacity }: ClickableMeshProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,31 @@
+import * as THREE from "three";
+import type { ComponentDebugInfo } from "../processing/wasm-loader";
+export interface DebugLayerVisibility {
+    pcaAxes: boolean;
+    obb: boolean;
+    obbAxis: boolean;
+    shellComponents: boolean;
+    circumferenceScan: boolean;
+    landmarkAxis: boolean;
+    iterativePCA: boolean;
+    fullRegionPCA: boolean;
+}
+export declare const DEFAULT_DEBUG_LAYERS: DebugLayerVisibility;
+export interface DebugOverlaysProps {
+    mesh: THREE.Mesh;
+    modelSize: number;
+    layers: DebugLayerVisibility;
+    landmarkPoints?: {
+        position: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    }[];
+    componentDebug?: ComponentDebugInfo | null;
+}
+export declare function DebugOverlays({ mesh, layers, landmarkPoints, componentDebug }: DebugOverlaysProps): import("react/jsx-runtime").JSX.Element;
+export interface OBBAlignmentLineProps {
+    mesh: THREE.Mesh;
+}
+export declare function OBBAlignmentLine({ mesh }: OBBAlignmentLineProps): import("react/jsx-runtime").JSX.Element | null;

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

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

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

@@ -0,0 +1,16 @@
+import * as THREE from "three";
+export interface DraggableLineHandleProps {
+    mesh: THREE.Mesh;
+    yPosition: number;
+    onYChange: (newY: number) => void;
+    minY: number;
+    maxY: number;
+    modelSize: number;
+    color: string;
+    hoverColor: string;
+    dragColor: string;
+    label: string;
+    onDragStart?: () => void;
+    onDragEnd?: () => void;
+}
+export declare const DraggableLineHandle: ({ mesh, yPosition, onYChange, minY, maxY, modelSize, color, hoverColor, dragColor, label, onDragStart, onDragEnd }: DraggableLineHandleProps) => import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1,4 @@
+export declare const ErrorDisplay: ({ message, onDismiss }: {
+    message: string;
+    onDismiss: () => void;
+}) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,5 @@
+export interface LandmarkMarkersProps {
+    modelSize: number;
+    labels?: string[];
+}
+export declare const LandmarkMarkers: ({ modelSize, labels }: LandmarkMarkersProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,3 @@
+export declare const LoadingSpinner: ({ message }: {
+    message?: string;
+}) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,5 @@
+export interface ScaleNoticeProps {
+    wasAutoScaled: boolean;
+    onDismiss: () => void;
+}
+export declare const ScaleNotice: ({ wasAutoScaled, onDismiss }: ScaleNoticeProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,5 @@
+export interface ShellNoticeProps {
+    isDoubleShell: boolean;
+    onDismiss: () => void;
+}
+export declare const ShellNotice: ({ isDoubleShell, onDismiss }: ShellNoticeProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,10 @@
+export interface StepperStep {
+    label: string;
+    number: number;
+}
+export interface StepperProps {
+    steps: StepperStep[];
+    currentStep: number;
+    accentColor?: string;
+}
+export declare const Stepper: ({ steps, currentStep, accentColor }: StepperProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,10 @@
+import * as THREE from "three";
+export interface TransverseViewProps {
+    mesh: THREE.Mesh;
+    upperY: number;
+    originY: number;
+    modelSize: number;
+    meshColor?: string;
+    displayUnit?: "mm" | "inch";
+}
+export declare const TransverseView: ({ mesh, upperY, originY, modelSize, meshColor, displayUnit }: TransverseViewProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,8 @@
+import * as THREE from "three";
+export interface VerticalDimensionProps {
+    mesh: THREE.Mesh;
+    greenY: number;
+    modelSize: number;
+    displayUnit?: "mm" | "inch";
+}
+export declare const VerticalDimension: ({ mesh, greenY, modelSize, displayUnit }: VerticalDimensionProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,29 @@
+/**
+ * Configuration that controls which UI features are visible
+ * in GirthManagerCore. The internal app enables all features;
+ * the external widget disables chrome, debug, drag-drop, etc.
+ */
+export interface GirthManagerConfig {
+    /** Show drag-and-drop file upload zone */
+    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 */
+    showSpacingToggle: boolean;
+    /** Show AK/BK amputation type selection modal */
+    showAmputationModal: boolean;
+    /** Show left navigation sidebar */
+    showNavigation: boolean;
+    /** Show top toolbar ribbon */
+    showToolbar: boolean;
+}
+/** Default config for the internal application (all features enabled) */
+export declare const INTERNAL_CONFIG: GirthManagerConfig;
+/** Config for the external widget (minimal UI) */
+export declare const WIDGET_CONFIG: GirthManagerConfig;
+export declare const GirthManagerConfigContext: import("react").Context<GirthManagerConfig>;
+export declare function useGirthManagerConfig(): GirthManagerConfig;

package/dist/girth-manager-ui/src/hooks/useCachedBVH.d.ts

@@ -0,0 +1,3 @@
+import * as THREE from "three";
+import { MeshBVH } from "three-mesh-bvh";
+export declare function useCachedBVH(geometry: THREE.BufferGeometry | null): MeshBVH | null;

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

@@ -0,0 +1,38 @@
+export { GirthManagerConfigContext, useGirthManagerConfig, INTERNAL_CONFIG, WIDGET_CONFIG } from "./config";
+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 { 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 { 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 { ErrorDisplay } from "./components/ErrorDisplay";
+export { LoadingSpinner } from "./components/LoadingSpinner";
+export { ClickableMesh } from "./components/ClickableMesh";
+export { LandmarkMarkers } from "./components/LandmarkMarkers";
+export { CircumferenceSlice } from "./components/CircumferenceSlice";
+export { CircumferenceMeasurements } from "./components/CircumferenceMeasurements";
+export { VerticalDimension } from "./components/VerticalDimension";
+export { DraggableLineHandle } from "./components/DraggableLineHandle";
+export { CameraFit } from "./components/CameraFit";
+export { AlignedOrbitControls } from "./components/AlignedOrbitControls";
+export { ScaleNotice } from "./components/ScaleNotice";
+export { ShellNotice } from "./components/ShellNotice";
+export { Stepper } from "./components/Stepper";
+export type { StepperStep, StepperProps } from "./components/Stepper";
+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 { useCachedBVH } from "./hooks/useCachedBVH";

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

@@ -0,0 +1,4 @@
+import * as THREE from "three";
+import { Vector3 } from "three";
+/** Run PCA alignment on a region from minY to maxY. Returns the principal axis or null. */
+export declare function runPCAOnRegion(geometry: THREE.BufferGeometry, minY: number, maxY: number): Vector3 | null;

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

@@ -0,0 +1,7 @@
+export declare const LABEL_X_OFFSET_RATIO = 0.45;
+export declare const BVH_MAX_LEAF_TRIS = 3;
+export declare const WELD_EPSILON = 0.001;
+export declare const MM_PER_INCH = 25.4;
+export declare const ABOVE_POINT_OFFSET_INCHES = 2;
+export declare const AUTO_SCALE_VOLUME_THRESHOLD = 5;
+export declare const RETRY_OFFSETS: number[];

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

@@ -0,0 +1,13 @@
+import * as THREE from "three";
+import { Vector3 } from "three";
+import { MeshBVH } from "three-mesh-bvh";
+import type { Seg } from "./types";
+export declare function intersectMeshWithPlane(bvhOrGeometry: MeshBVH | THREE.BufferGeometry, planePoint: Vector3, planeNormal: Vector3): Seg[];
+/** Like stitchOneLoop but picks the loop whose centroid is closest to `nearPoint` */
+export declare function stitchLoopNearPoint(segments: Seg[], nearPoint: Vector3, eps?: number): Vector3[];
+/** Compute the centroid of a closed loop of points */
+export declare function loopCentroid(loop: Vector3[]): Vector3;
+export declare function findBestCutPlane(geometry: THREE.BufferGeometry, greenPoint: Vector3, redPoint: Vector3): {
+    normal: Vector3;
+    circumference: number;
+};

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

@@ -0,0 +1,33 @@
+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;
+    v: number;
+    w: number;
+};
+/** Slice mesh at an arbitrary plane. By default keeps only the component closest to `keepPoint`;
+ *  pass `keepAllComponents = true` to retain all geometry on the kept side (e.g. double-shell). */
+export declare function sliceMeshAtPlane(geometry: THREE.BufferGeometry, planeOrigin: Vector3, planeNormal: Vector3, keepPoint: Vector3, keepAllComponents?: boolean): THREE.BufferGeometry;

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

@@ -0,0 +1,46 @@
+import * as THREE from "three";
+import { Vector3 } from "three";
+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];
+        position: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        barycentricCoords: {
+            u: number;
+            v: number;
+            w: number;
+        };
+    }) => void;
+    removeLandmarkPoint: (index: number) => void;
+    updateLandmarkPositions: (positions: {
+        x: number;
+        y: number;
+        z: number;
+    }[]) => void;
+    setAligned: (aligned: boolean) => void;
+    setCut: (cut: boolean) => void;
+    setModelSize: (size: number) => void;
+    setOriginalEndY: (y: number) => void;
+    setAdjustedStartY: (y: number | null) => void;
+    setAdjustedEndY: (y: number | null) => void;
+    setError: (error: string | null) => void;
+    setClippedReferenceGeometry?: (geometry: THREE.BufferGeometry | null) => void;
+}
+/** 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 */
+export declare function runProcessingPipeline(mesh: THREE.Mesh, landmarkPoints: {
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}[], measurementSpacingMm: number, callbacks: PipelineCallbacks): void;

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

@@ -0,0 +1,14 @@
+import * as THREE from "three";
+import { Vector3 } from "three";
+import { MeshBVH } from "three-mesh-bvh";
+import type { Seg, SliceResult } from "./types";
+export declare function weldKey(v: Vector3, eps: number): string;
+export declare function cleanLoop(points: Vector3[], eps: number): Vector3[];
+export declare function calcLineLength(points: Vector3[]): number;
+export declare function stitchOneLoop(segments: Seg[], eps?: number, preferInner?: boolean): Vector3[];
+export declare function computeSliceAtYOnce(bvh: MeshBVH, geometry: THREE.BufferGeometry, yPosition: number, useInnerSurface?: boolean): SliceResult;
+export declare function computeSliceAtY(bvh: MeshBVH, geometry: THREE.BufferGeometry, yPosition: number, useInnerSurface?: boolean): SliceResult;
+/** Compute circumference of the slice at an arbitrary plane (any normal). */
+export declare function computeCircumferenceAtPlane(bvh: MeshBVH, geometry: THREE.BufferGeometry, planePoint: Vector3, planeNormal: Vector3): number;
+/** Compute BVH for a geometry (used in useCachedBVH hook and standalone) */
+export declare function buildBVH(geometry: THREE.BufferGeometry): MeshBVH;

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

@@ -0,0 +1,2 @@
+/** Convert STL binary/ascii into OBJ text so it can go through the WASM pipeline */
+export declare function stlToObjString(file: File): Promise<string>;

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

@@ -0,0 +1,43 @@
+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 LandmarkPoint {
+    faceIndex: number;
+    vertexIndices: [number, number, number];
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    barycentricCoords: {
+        u: number;
+        v: number;
+        w: number;
+    };
+}
+export interface MeasurementData {
+    yPosition: number;
+    originalValue: number;
+    modifiedValue: number | null;
+}
+export interface SliceResult {
+    linePoints: Vector3[];
+    lineLength: number;
+    rightmostPoint: Vector3;
+    isClosed?: boolean;
+}
+export type Seg = {
+    a: Vector3;
+    b: Vector3;
+};

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

@@ -0,0 +1,6 @@
+import * as THREE from "three";
+/** Validate processing results: check geometry is non-empty, height, and circumference ratios */
+export declare function validateProcessingResult(finalGeometry: THREE.BufferGeometry, greenY: number, redY: number, spacing: number): {
+    valid: boolean;
+    reason: string;
+};

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

@@ -0,0 +1,8 @@
+import * as THREE from "three";
+/** Parse vertex positions and colors from OBJ text. Returns null if no vertex colors found. */
+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. */
+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

@@ -0,0 +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;
+}
+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;
+}
+/** 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>;
+/** Fallback: process OBJ string with Three.js OBJLoader */
+export declare function processWithObjLoader(objContents: string): THREE.BufferGeometry | null;

package/dist/{store.d.ts → girth-manager-ui/src/store.d.ts}

@@ -1,17 +1,4 @@
-export interface LandmarkPoint {
-    faceIndex: number;
-    vertexIndices: [number, number, number];
-    position: {
-        x: number;
-        y: number;
-        z: number;
-    };
-    barycentricCoords: {
-        u: number;
-        v: number;
-        w: number;
-    };
-}
+import type { LandmarkPoint } from "./processing/types";
 interface MeasurementStore {
     landmarkPoints: LandmarkPoint[];
     isAligned: boolean;

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

@@ -0,0 +1,13 @@
+import { type WasmMeshSetType } 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. The consuming app must load galileo-core-geo and pass it here. */
+    wasmModule?: {
+        WasmMeshSet: new () => WasmMeshSetType;
+    } | null;
+}
+export declare const GirthManagerWidget: ({ request, onComplete, wasmModule }: GirthManagerWidgetProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1 @@
+export {};

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

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

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

@@ -0,0 +1,76 @@
+/**
+ * Input contract for the Girth Manager widget.
+ * Mirrors the schema in docs/widget_interface.ts.
+ */
+export interface WidgetRequest {
+    /** Spacing type: above-knee or below-knee */
+    spacing_type: "AK" | "BK";
+    /** URL to the uploaded 3D scan file */
+    scan_url: string;
+    /** Optional circumference measurements from the order form (mm). Omit if not provided. */
+    form_measurements?: Circumference;
+}
+/**
+ * Output contract emitted by the widget when "Continue to Next Step" is clicked.
+ * Mirrors the schema in docs/widget_interface.ts.
+ */
+export interface WidgetResponse {
+    /** Spacing type: above-knee or below-knee */
+    spacing_type: "AK" | "BK";
+    /** Unit of all measurements in this response */
+    source_unit: "mm" | "inch";
+    /** File format of the scan */
+    file_format: "obj" | "stl";
+    /** Whether measurements were derived from the scan or taken from the order form */
+    measurement_source: "scan_derived" | "form_provided";
+    /** Whether the spacing uses a double-wall construction */
+    is_double_wall: boolean;
+    /** Whether measurements were converted from their original unit */
+    is_unit_converted: boolean;
+    /** Circumference measurements from the order form (mm). Only includes fields the user filled in. Omitted if none were provided. */
+    form_measurements?: Circumference;
+    /** Circumference measurements derived from the 3D scan (mm) */
+    scan_measurements: Circumference;
+    /** Difference between form and scan measurements (mm). Only present for positions where both form and scan values exist. Omitted if no form data was provided. */
+    measurement_variance?: Circumference;
+    /** URL to the uploaded 3D scan file */
+    scan_url: string;
+    /** Frontal height of the residual limb (mm) */
+    frontal_height: number;
+    /** Medio-lateral transverse dimension (mm) */
+    transverse_ml: number;
+    /** Anterior-posterior transverse dimension (mm) */
+    transverse_ap: number;
+}
+export interface Circumference {
+    /** 2" above the reference landmark (mm) */
+    "2_above"?: number | undefined | null;
+    /** 1" above the reference landmark (mm) */
+    "1_above"?: number | undefined | null;
+    /** At the reference landmark (mm) */
+    at_ref?: number | undefined | null;
+    /** 1" below the reference landmark (mm) */
+    "1_below"?: number | undefined | null;
+    /** 2" below the reference landmark (mm) */
+    "2_below"?: number | undefined | null;
+    /** 3" below the reference landmark (mm) */
+    "3_below"?: number | undefined | null;
+    /** 4" below the reference landmark (mm) */
+    "4_below"?: number | undefined | null;
+    /** 5" below the reference landmark (mm) */
+    "5_below"?: number | undefined | null;
+    /** 6" below the reference landmark (mm) */
+    "6_below"?: number | undefined | null;
+    /** 7" below the reference landmark (mm) */
+    "7_below"?: number | undefined | null;
+    /** 8" below the reference landmark (mm) */
+    "8_below"?: number | undefined | null;
+    /** 9" below the reference landmark (mm) */
+    "9_below"?: number | undefined | null;
+}
+/** Ordered keys for mapping measurement arrays to Circumference fields */
+export declare function getCircumferenceKeys(spacingType: "AK" | "BK"): (keyof Circumference)[];
+/** Convert a measurement values array to a Circumference object */
+export declare function arrayToCircumference(values: (number | null | undefined)[], spacingType: "AK" | "BK"): Circumference;
+/** Convert a Circumference object to an ordered measurement values array */
+export declare function circumferenceToArray(circ: Circumference | undefined, spacingType: "AK" | "BK"): number[] | undefined;