@ssafy-mhk/e-ver 1.0.3 → 1.0.4

package/README.md

@@ -1,189 +1,244 @@
-# `@ssafy-mhk/e-ver` - Virtual Fitting React SDK 👗👕
+# `@ssafy-mhk/e-ver`
 
-S14P21M104 가상 피팅(WebAR) 프로젝트를 위한 공식 프론트엔드 React SDK입니다.
-복잡한 Three.js 카메라 및 조명 설정, MediaPipe AI 바디 트래킹 연동, SkinnedMesh 기반 의류 렌더링 로직을 추상화하여, **단순한 React 컴포넌트와 Hook**으로 증강현실(AR) 가상 피팅 기능을 빠르게 구현할 수 있도록 지원합니다.
+React 기반 가상 피팅 SDK입니다. `generate-3d`로 생성한 의류 GLB를 불러오고, 웹캠과 MediaPipe Pose 추적을 이용해 body preset 기반 가상 피팅 씬을 구성할 수 있습니다.
 
-## 개발 스택 (Technology Stack)
+현재 SDK가 책임지는 범위는 다음입니다.
 
-- **Framework**: React / Next.js 호환
-- **3D & AR Rendering**: Three.js, React Three Fiber (R3F), Drei, three-vrm
-- **AI Tracking**: MediaPipe Pose Landmarker (Lite)
-- **State Management**: Zustand
+- 의류 생성 API client와 생성 플로우
+- webcam, pose tracking, body measurement, body preset selection
+- tracked garment 렌더링
+- 최종 보정이 반영된 `finalGarmentScale` 계산
 
----
+현재 SDK가 책임지지 않는 범위는 다음입니다.
 
-## 🛠 설치 방법 (Installation)
+- 패널 UI, 디버그 UI, overlay
+- foreground occlusion 같은 앱 전용 시각 효과
+- 사진 기반 개인 avatar 생성
 
-이 패키지는 배포 전 로컬 검증 시 tarball로 패키징한 뒤 소비 애플리케이션에 설치해서 확인하는 방식을 권장합니다.
-
-### 배포된 패키지 설치
-
-여러분의 Next.js 프로젝트 최상위 폴더에서 아래 명령어를 실행하세요.
+## 설치
 
 ```bash
-# pnpm 사용 시
 pnpm add @ssafy-mhk/e-ver
-
-# 또는 패키지 매니저에 따라
-npm install @ssafy-mhk/e-ver
-yarn add @ssafy-mhk/e-ver
 ```
 
-_(의존성 설치가 잘 되었는지 꼭 `package.json` 코드를 확인하세요.)_
+필수 peer dependency:
 
-### 이 레포에서 `frontend`로 로컬 검증할 경우
+```bash
+pnpm add react react-dom three @react-three/fiber @react-three/drei @mediapipe/tasks-vision zustand
+```
 
-`/ever/frontend`에서 아래 명령어를 실행하면 `/ever/sdk`를 빌드하고 tarball로 패키징한 뒤 현재 프론트엔드에 설치합니다.
+이 레포에서 `ever/frontend`로 로컬 검증할 때는:
 
 ```bash
 pnpm run sdk:use-tarball
 ```
 
-검증 후 퍼블리시된 버전으로 되돌릴 때는 아래 명령어를 사용합니다.
+퍼블리시된 버전으로 되돌릴 때는:
 
 ```bash
-pnpm run sdk:use-version -- 1.0.3
+pnpm run sdk:use-version -- 1.0.4
 ```
 
----
+## 서버와 인증
+
+기본 API 서버는 `http://localhost:8000/api/v1`입니다.
 
-## 🚀 코어로직 한눈에 보기 (SDK 핵심 요소)
+```tsx
+import { EverClient } from "@ssafy-mhk/e-ver";
 
-SDK는 크게 **State(상태 관리)**, **Renderer(렌더링 UI)**, **Tracker(추적/측정 Hook)** 이렇게 3가지 핵심 축으로 구성됩니다.
+const client = new EverClient();
 
-| 분류         | 모듈명            | 역할                                                                                 |
-| ------------ | ----------------- | ------------------------------------------------------------------------------------ |
-| **State**    | `useEverStore`    | 웹캠 활성화 여부, 렌더링 중인 옷/아바타 주소, 최종 핏 결과(체형 측정) 관리           |
-| **Renderer** | `EverCanvas`      | AR/3D 환경에 최적화된 조명과 카메라 세팅을 내장한 R3F 캔버스 래퍼                    |
-| **Renderer** | `AvatarModel`     | 사용자의 AI 기반 생성 3D 아바타(GLB)를 로딩하고, 뼈대(Bone) 구조를 추출              |
-| **Renderer** | `GarmentModel`    | 사용자가 선택한 옷(GLB)을 로딩하고, 옷의 SkinnedMesh를 대상 아바타에 입힘            |
-| **Tracker**  | `usePoseTracker`  | 브라우저 내에서 MediaPipe를 가동시켜 실시간 30-60Hz 웹캠 추적                        |
-| **Tracker**  | `usePoseMapper`   | 웹캠에서 얻은 2D/3D 점(Landmarks)을 필수 13본(Bone)의 회전값(Quaternion)으로 변환    |
-| **Tracker**  | `useBodyMeasurer` | AR 카메라 상에서 사용자 실루엣 기반 사이즈(어깨, 가슴, 허리)를 연산하여 옷의 핏 평가 |
+const publicClient = new EverClient({
+  apiKey: "ever_live_xxxxxxxx",
+});
+```
 
----
+- 기본 생성자: 쿠키 인증 또는 같은 오리진 환경에서 사용
+- `apiKey` 지정 시: `/sdk/public/*` 경로를 사용하는 공개 SDK 모드
 
-## 📖 사용 가이드 (Usage Guide)
+`useEverGeneration`도 동일하게 `apiKey`를 받을 수 있습니다.
 
-아래는 Next.js(App Router) 환경에서 가상 피팅 서비스를 구축하는 기본 예제 코드입니다.
+## 권장 사용 흐름
 
-### Step 1. Zustand로 글로벌 상태 세팅하기
+가장 권장되는 경로는 아래입니다.
 
-우선, 애플리케이션 외부 버튼 조작을 위해 스토어를 호출할 수 있습니다.
+1. `useEverGeneration`으로 의류 생성
+2. 생성이 끝나면 `resultUrl` 확보
+3. `EverFittingScene`에 `garmentUrl={resultUrl}` 전달
+4. `onRuntimeStateChange`에서 `measurements`, `bodyPresetSelection`, `finalGarmentScale` 소비
+
+## 핵심 API
+
+| 분류 | 모듈 | 역할 |
+| --- | --- | --- |
+| Client | `EverClient` | body preset 조회/매칭, garment 생성, 이미지 업로드, `generate-3d`, polling |
+| Hook | `useEverGeneration` | 의류 생성 플로우를 훅으로 제공 |
+| Scene | `EverFittingScene` | webcam, tracking, measurement, body preset selection, garment 렌더링 통합 |
+| Scene | `EverTrackedGarment` | 준비된 의류 GLB를 추적 렌더링 |
+| Hook | `useEverFitting` | 고수준 fitting runtime 상태 제공 |
+| Hook | `useBodyPresetSelection` | 측정값 기반 body preset 자동 선택 |
+| Renderer | `EverCanvas` | 저수준 R3F canvas wrapper |
+
+## Quick Start
 
 ```tsx
-// app/fitting/page.tsx
-"use client";
+import { EverFittingScene, useEverGeneration } from "@ssafy-mhk/e-ver";
 
-import { useEverStore } from "@ssafy-mhk/e-ver";
+function Demo() {
+  const { createGarment, resultUrl, status } = useEverGeneration({
+    apiKey: process.env.NEXT_PUBLIC_EVER_API_KEY,
+  });
 
-export default function FittingControls() {
-  const { setWebcamActive, setActiveGarmentUrl, fitResult } = useEverStore();
+  const handleGenerate = async () => {
+    await createGarment(
+      { name: "오버핏 셔츠", category: "top" },
+      frontImageBlob,
+      backImageBlob,
+    );
+  };
 
   return (
-    <div className="absolute top-4 left-4 z-10 flex flex-col gap-2">
-      <button onClick={() => setWebcamActive(true)}>웹캠 가동 시작 🎥</button>
-      <button onClick={() => setActiveGarmentUrl("/path/to/clothes.glb")}>
-        새로운 옷 입어보기 👕
+    <div className="relative h-screen w-full">
+      <button onClick={handleGenerate} disabled={status !== "idle"}>
+        3D 생성
       </button>
 
-      {fitResult && (
-        <div className="bg-white/80 p-2 rounded">
-          핏 타입: {fitResult.type} (적합도 {fitResult.suitability}%)
-        </div>
-      )}
+      <EverFittingScene
+        garmentUrl={resultUrl}
+        enabled
+        measurementEnabled
+        autoStartMeasurement
+        fitType="regular"
+        onRuntimeStateChange={(runtime) => {
+          console.log(runtime.measurements);
+          console.log(runtime.bodyPresetSelection);
+          console.log(runtime.finalGarmentScale);
+        }}
+      />
     </div>
   );
 }
 ```
 
-### Step 2. 3D AR 캔버스 및 모델 구축하기
+## 생성 API
 
-SDK에서 제공하는 `EverCanvas`, `AvatarModel`, `GarmentModel`을 활용하여 화면을 그립니다.
+### `useEverGeneration`
 
-```tsx
-// components/VirtualFittingScene.tsx
-"use client";
+`createGarment`는 아래 순서를 묶습니다.
 
-import { useState } from "react";
-import {
-  EverCanvas,
-  AvatarModel,
-  GarmentModel,
-  useEverStore,
-} from "@ssafy-mhk/e-ver";
+1. garment 생성
+2. front/back 이미지 업로드
+3. `generate-3d` 요청
+4. 의류 모델 준비 완료까지 polling
 
-export default function VirtualFittingScene() {
-  const [avatarBones, setAvatarBones] = useState<Record<string, THREE.Bone>>();
-  const { activeGarmentUrl } = useEverStore();
+```tsx
+import { useEverGeneration } from "@ssafy-mhk/e-ver";
 
-  // 내 계정의 3D 아바타 파일 경로
-  const AVATAR_URL = "/models/my-avatar.glb";
+function Generator() {
+  const { createGarment, resultUrl, status, error } = useEverGeneration();
 
   return (
-    <div className="w-full h-screen bg-transparent relative">
-      {/* 1. 기본 AR 조명이 세팅된 캔버스 호출 */}
-      <EverCanvas showEnvironment={true}>
-        {/* 2. 사용자의 베이스 아바타 불러오기 */}
-        <AvatarModel
-          url={AVATAR_URL}
-          onBonesReady={(bones) => setAvatarBones(bones)}
-        />
-
-        {/* 3. 활성화된 옷이 있다면 아바타 위에 덧입히기 */}
-        {activeGarmentUrl && avatarBones && (
-          <GarmentModel
-            url={activeGarmentUrl}
-            targetAvatarBones={avatarBones}
-          />
-        )}
-      </EverCanvas>
-    </div>
+    <>
+      <button
+        onClick={() =>
+          createGarment(
+            { name: "니트", category: "top" },
+            frontImageBlob,
+            backImageBlob,
+          )
+        }
+      >
+        생성
+      </button>
+      <p>{status}</p>
+      {error ? <p>{error}</p> : null}
+      {resultUrl ? <p>{resultUrl}</p> : null}
+    </>
   );
 }
 ```
 
-### Step 3. AI 바디 트래킹 연동하기
+## 고수준 Scene
 
-웹캠 화면과 R3F 화면을 겹쳐주려면 `<video>` 태그를 `usePoseTracker`에 넘겨 연결해 주어야 합니다.
+### `EverFittingScene`
 
-```tsx
-// components/ArCameraView.tsx
-"use client";
+가장 권장되는 엔트리입니다. 내부에서 다음을 수행합니다.
+
+- webcam 준비
+- MediaPipe Pose tracking
+- 측정값 계산
+- body preset 선택
+- tracked garment 렌더링
+- 최종 보정 scale 계산
+
+주요 props:
+
+- `garmentUrl: string | null`
+- `enabled?: boolean`
+- `measurementEnabled?: boolean`
+- `autoStartMeasurement?: boolean`
+- `fitType?: "slim" | "regular" | "oversize"`
+- `garmentScaleHint?: number | null`
+- `onRuntimeStateChange?: (runtime) => void`
+- `onGarmentLoadStateChange?: (state) => void`
+
+`runtime`에서 특히 많이 쓰는 값:
+
+- `measurements`
+- `bodyPresetSelection`
+- `sizeRecommendation`
+- `garmentScale`
+- `finalGarmentScale`
+- `bodyMorphResult`
+- `isTracking`
+- `webcamError`
 
-import { useRef } from "react";
-import { usePoseTracker, useEverStore } from "@ssafy-mhk/e-ver";
+## 저수준 조립
 
-export default function ArCameraView() {
-  const videoRef = useRef<HTMLVideoElement>(null);
+직접 조립이 필요하면 `useEverFitting`과 `EverTrackedGarment`를 사용할 수 있습니다.
 
-  // SDK 내부의 로직을 통해 실시간으로 프레임을 MediaPipe에 전송
-  const { isTrackerReady } = usePoseTracker(videoRef);
-  const { isWebcamActive } = useEverStore();
+```tsx
+import { EverCanvas, EverTrackedGarment, useEverFitting } from "@ssafy-mhk/e-ver";
+
+function CustomScene({ garmentUrl }: { garmentUrl: string }) {
+  const fitting = useEverFitting({
+    enabled: true,
+    fitType: "oversize",
+    garmentScaleHint: 1.04,
+  });
 
   return (
-    <div className="absolute inset-0 z-0">
-      <video
-        ref={videoRef}
-        autoPlay
-        playsInline
-        muted
-        className="w-full h-full object-cover"
-        style={{ display: isWebcamActive ? "block" : "none" }}
+    <EverCanvas showEnvironment={false}>
+      <EverTrackedGarment
+        url={garmentUrl}
+        landmarks={fitting.landmarks}
+        worldLandmarks={fitting.worldLandmarks}
+        poseFrameWidth={fitting.poseFrameWidth}
+        poseFrameHeight={fitting.poseFrameHeight}
       />
-      {/* Tracker가 로딩 중일 때 로딩 오버레이 표시 가능 */}
-      {!isTrackerReady && isWebcamActive && <p>AI 모델 로딩 중...</p>}
-    </div>
+    </EverCanvas>
   );
 }
 ```
 
----
+## fitting 결과
+
+`finalGarmentScale`은 아래 요소를 합성한 최종 결과입니다.
+
+- body measurement 기반 scale
+- body preset selection
+- `fitType`
+- `garmentScaleHint`
+
+showcase와 동일한 fitting 결과가 필요하면 소비 앱에서 별도 보정하지 말고 `runtime.finalGarmentScale`을 그대로 사용하면 됩니다.
+
+## 주의 사항
 
-## 🙋‍♂️ Q&A (추가 기능 문의)
+**`generateAvatar`는 사진 기반 개인 avatar 생성이 아닙니다.**  
+현재 버전에서는 body preset 매칭을 통해 기본 아바타 모델 URL을 찾습니다.
 
-**Q. 옷 핏 평가는 어떻게 동작하나요?**  
--> 내부에 구축된 `useBodyMeasurer` 훅이 약 1초 단위(1Hz)로 캔버스의 실루엣을 통해 [어깨, 가슴, 허리] 사이즈를 분석하여 `useEverStore`의 `fitResult`에 자동 업데이트합니다.
+**SDK는 UI kit이 아닙니다.**  
+측정 패널, 디버그 패널, overlay는 소비 앱에서 조립해야 합니다.
 
-**Q. 물리 엔진(Rapier.js)이 적용되어 있나요?**  
--> 현재 MVP 스코프에서 무거운 런타임 물리 물리엔진은 제외되었으며, 대신 **SkinnedMesh 본 바인딩(P0)**과 **Normal Map 애니메이션(P1)**을 통하여 주름과 디테일을 시뮬레이션합니다.
+**SDK 범위는 body preset 기반 fitting입니다.**  
+개인 사진 기반 avatar 생성이나 앱 전용 시각 효과는 현재 범위 밖입니다.

package/dist/api/EverClient.d.ts

@@ -138,13 +138,24 @@ export interface WaitForGarmentModelOptions {
     intervalMs?: number;
     timeoutMs?: number;
 }
+export interface EverClientOptions {
+    baseUrl?: string;
+    apiKey?: string;
+}
+export declare const DEFAULT_EVER_API_BASE_URL = "http://localhost:8000/api/v1";
 /**
  * EverClient provides methods to interact with the e-ver backend API.
+ *
+ * Supports two authentication modes:
+ * - **Cookie (default)**: browser session credentials (no apiKey).
+ * - **API Key**: pass `apiKey` in the constructor to use `X-API-Key` header
+ *   and route requests through `/sdk/public/*` endpoints.
  */
 export declare class EverClient {
     private readonly baseUrl;
     private readonly apiOrigin;
-    constructor(baseUrl?: string);
+    private readonly apiKey;
+    constructor(config?: string | EverClientOptions);
     resolveAssetUrl(assetUrl: string | null): string | null;
     listBodyPresets(gender?: string): Promise<BodyPreset[]>;
     matchBodyPreset(body: BodyPresetMatchRequest): Promise<BodyPreset>;

package/dist/avatar/VRMCompat.d.ts

@@ -0,0 +1,8 @@
+import type { VRM } from "@pixiv/three-vrm";
+import * as THREE from "three";
+export interface VRMCompatHumanoid {
+    getNormalizedBoneNode(boneName: string): THREE.Object3D | null;
+    update(delta: number): void;
+    vrm: VRM | null;
+}
+export declare function createVRMCompat(scene: THREE.Object3D, vrm: VRM | null | undefined): VRMCompatHumanoid;

package/dist/avatar/avatarLoader.d.ts

@@ -0,0 +1,12 @@
+import type { VRM } from "@pixiv/three-vrm";
+import * as THREE from "three";
+type UseGLTFSignature = typeof import("@react-three/drei")["useGLTF"];
+type AvatarLoader = Parameters<NonNullable<Parameters<UseGLTFSignature>[3]>>[0];
+export type AvatarAssetKind = "vrm" | "gltf";
+export declare function isVRMAssetUrl(url: string): boolean;
+export declare function getAvatarAssetKind(url: string): AvatarAssetKind;
+export declare function configureAvatarLoader(loader: AvatarLoader, url: string): void;
+export declare function createAvatarLoaderExtension(url: string): ((loader: AvatarLoader) => void) | undefined;
+export declare function prepareAvatarScene(scene: THREE.Object3D): void;
+export declare function prepareNativeVRM(vrm: VRM): void;
+export {};

package/dist/avatar/humanoidBindings.d.ts

@@ -0,0 +1,7 @@
+import * as THREE from "three";
+import { type GarmentBoneBindingMap } from "../garment/garmentFitProfile";
+interface HumanoidBoneSource {
+    getNormalizedBoneNode(name: string): THREE.Object3D | null;
+}
+export declare function createHumanoidBoneBindings(humanoid: HumanoidBoneSource): GarmentBoneBindingMap;
+export {};

package/dist/bodyPreset/presetSelection.d.ts

@@ -0,0 +1,31 @@
+import { EverClient } from "../api/EverClient";
+import type { BodyPreset } from "../api/EverClient";
+import type { BodyMeasurements } from "../types/measurement";
+import type { BodyPresetGender, BodyPresetMatchRequest, BodyPresetSelection, BodyPresetSummary } from "../types/bodyPreset";
+export declare const DEFAULT_MALE_BODY_PRESET_ID = "male-m-balanced-balanced";
+export declare const DEFAULT_FEMALE_BODY_PRESET_ID = "female-m-balanced-balanced";
+export declare const LEGACY_RIGGED_BODY_PRESET_ID = "rigged_avatar";
+export declare function normalizeBodyPresetGender(value?: string | null): BodyPresetGender;
+export declare function buildBodyPresetAssetUrl(presetId: string, options?: {
+    renderMode?: "rigged_avatar" | "preset-native";
+    legacyPresetId?: string;
+}): string;
+export declare function getDefaultBodyPresetId(gender: BodyPresetGender): string;
+export declare function toBodyPresetSummary(preset: BodyPreset, client: EverClient): BodyPresetSummary;
+export declare function ensureBodyPresetModelUrl(preset: BodyPresetSummary, options?: {
+    renderMode?: "rigged_avatar" | "preset-native";
+    legacyPresetId?: string;
+}): BodyPresetSummary;
+export declare function pickDefaultBodyPreset(presets: BodyPresetSummary[], options?: {
+    renderMode?: "rigged_avatar" | "preset-native";
+    legacyPresetId?: string;
+}): BodyPresetSummary | null;
+export declare function createFallbackBodyPresetSelection(gender: BodyPresetGender, options?: {
+    renderMode?: "rigged_avatar" | "preset-native";
+    legacyPresetId?: string;
+}): BodyPresetSelection;
+export declare function toBodyPresetSelection(preset: BodyPresetSummary, source: BodyPresetSelection["source"], options?: {
+    renderMode?: "rigged_avatar" | "preset-native";
+    legacyPresetId?: string;
+}): BodyPresetSelection;
+export declare function buildBodyPresetMatchRequest(measurements: BodyMeasurements, gender: BodyPresetGender): BodyPresetMatchRequest;

package/dist/components/CameraView.d.ts

@@ -2,6 +2,11 @@ import React from "react";
 export interface CameraViewProps {
     className?: string;
     style?: React.CSSProperties;
+    width?: number;
+    height?: number;
+    facingMode?: "user" | "environment";
+    enabled?: boolean;
+    mockMode?: boolean;
 }
 /**
  * CameraView handles the rendering of the user's webcam feed.

package/dist/components/EverCanvas.d.ts

@@ -2,6 +2,8 @@ import React from "react";
 export interface EverCanvasProps {
     children: React.ReactNode;
     showEnvironment?: boolean;
+    useDefaultLights?: boolean;
+    enableOrbitControls?: boolean;
 }
 /**
  * A wrapper around R3F <Canvas> specifically configured for optimal

package/dist/components/EverFittingScene.d.ts

@@ -0,0 +1,18 @@
+import { type CSSProperties } from "react";
+import type { UseBodyPresetSelectionOptions } from "../types/bodyPreset";
+import { type EverFittingOptions, type EverFittingRuntimeState } from "../hooks/useEverFitting";
+import { type GarmentLoadState } from "./EverTrackedGarment";
+export interface EverFittingSceneProps extends Pick<EverFittingOptions, "enabled" | "width" | "height" | "facingMode" | "mockMode" | "viewportWidth" | "viewportHeight" | "measurementEnabled" | "autoStartMeasurement" | "measurementConfig" | "fitType" | "garmentScaleHint"> {
+    garmentUrl: string | null;
+    bodyPresetOptions?: UseBodyPresetSelectionOptions;
+    className?: string;
+    style?: CSSProperties;
+    debugMaterials?: boolean;
+    showEnvironment?: boolean;
+    showStats?: boolean;
+    showWebcamBackground?: boolean;
+    onCanvasReadyChange?: (ready: boolean) => void;
+    onRuntimeStateChange?: (state: EverFittingRuntimeState) => void;
+    onGarmentLoadStateChange?: (state: GarmentLoadState) => void;
+}
+export declare function EverFittingScene({ garmentUrl, enabled, width, height, facingMode, mockMode, viewportWidth, viewportHeight, measurementEnabled, autoStartMeasurement, measurementConfig, fitType, garmentScaleHint, bodyPresetOptions, className, style, debugMaterials, showEnvironment, showStats, showWebcamBackground, onCanvasReadyChange, onRuntimeStateChange, onGarmentLoadStateChange, }: EverFittingSceneProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/EverFittingScene.test.d.ts

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

package/dist/components/EverTrackedGarment.d.ts

@@ -0,0 +1,15 @@
+import type { PoseLandmarkLike } from "../types/pose";
+export interface GarmentLoadState {
+    loaded: boolean;
+    error: string | null;
+}
+export interface EverTrackedGarmentProps {
+    url: string;
+    landmarks: PoseLandmarkLike[] | null;
+    worldLandmarks: PoseLandmarkLike[] | null;
+    poseFrameWidth: number;
+    poseFrameHeight: number;
+    debugMaterials?: boolean;
+    onLoadStateChange?: (state: GarmentLoadState) => void;
+}
+export declare function EverTrackedGarment({ url, landmarks, worldLandmarks, poseFrameWidth, poseFrameHeight, debugMaterials, onLoadStateChange, }: EverTrackedGarmentProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/TrackedGarmentPoseDriver.d.ts

@@ -0,0 +1,13 @@
+import type { NormalizedLandmark } from "@mediapipe/tasks-vision";
+import * as THREE from "three";
+import type { GarmentBoneBindingMap, GarmentFitProfile } from "../garment/garmentFitProfile";
+export interface TrackedGarmentPoseDriverProps {
+    garmentRootRef: React.RefObject<THREE.Group | null>;
+    boneBindingMap: GarmentBoneBindingMap;
+    fitProfile: GarmentFitProfile | null;
+    landmarks: NormalizedLandmark[] | null;
+    worldLandmarks: NormalizedLandmark[] | null;
+    poseFrameWidth: number;
+    poseFrameHeight: number;
+}
+export declare function TrackedGarmentPoseDriver({ garmentRootRef, boneBindingMap, fitProfile, landmarks, worldLandmarks, poseFrameWidth, poseFrameHeight, }: TrackedGarmentPoseDriverProps): null;

package/dist/components/WebcamPlaneBackground.d.ts

@@ -0,0 +1,7 @@
+import { type RefObject } from "react";
+interface WebcamPlaneBackgroundProps {
+    videoRef: RefObject<HTMLVideoElement | null>;
+    webcamReady: boolean;
+}
+export declare function WebcamPlaneBackground({ videoRef, webcamReady, }: WebcamPlaneBackgroundProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/compositing/videoCover.d.ts

@@ -0,0 +1,14 @@
+export interface VisibleNormalizedRegion {
+    xMin: number;
+    xMax: number;
+    yMin: number;
+    yMax: number;
+}
+export interface CoverRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare function computeCoverRect(viewportWidth: number, viewportHeight: number, sourceWidth: number, sourceHeight: number): CoverRect;
+export declare function computeVisibleNormalizedRegion(viewportWidth: number, viewportHeight: number, sourceWidth: number, sourceHeight: number): VisibleNormalizedRegion;

package/dist/fitting/bodyFirstFitting.d.ts

@@ -0,0 +1,14 @@
+import { type GarmentSpec } from "../measurement/garmentScaler";
+import type { BodyPresetSelection } from "../types/bodyPreset";
+import type { BodyFirstFittingResult, BodyMorphResult, FitType } from "../types/fitting";
+import type { BodyMeasurements, GarmentScaleParams } from "../types/measurement";
+export interface BodyFirstFittingParams {
+    measurements: BodyMeasurements | null;
+    measurementScale: GarmentScaleParams | null;
+    presetSelection: BodyPresetSelection | null;
+    fitType?: FitType;
+    garmentScaleHint?: number | null;
+    spec?: GarmentSpec;
+}
+export declare function deriveBodyMorphResult(measurements: BodyMeasurements, presetSelection: BodyPresetSelection): BodyMorphResult;
+export declare function computeBodyFirstFitting({ measurements, measurementScale, presetSelection, fitType, garmentScaleHint, spec, }: BodyFirstFittingParams): BodyFirstFittingResult;

package/dist/fitting/bodyFirstFitting.test.d.ts

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

package/dist/garment/constants.d.ts

@@ -0,0 +1 @@
+export declare const BONE_VISIBILITY_MAP: Record<string, readonly number[]>;

package/dist/garment/fitMotion.d.ts

@@ -0,0 +1,18 @@
+import type { NormalizedLandmark } from "@mediapipe/tasks-vision";
+import * as THREE from "three";
+interface StableShoulderWidthInput {
+    projectedShoulderWidth: number;
+    projectedTorsoHeight: number;
+    bodyYaw: number;
+    worldLandmarks?: NormalizedLandmark[] | null;
+}
+interface GarmentRootOrientationInput {
+    leftShoulder: THREE.Vector3;
+    rightShoulder: THREE.Vector3;
+    leftHip: THREE.Vector3;
+    rightHip: THREE.Vector3;
+}
+export declare function computeFacingAwareShoulderWidth(shoulderWidth: number, torsoHeight: number, bodyYaw: number): number;
+export declare function computeStableShoulderWidth({ projectedShoulderWidth, projectedTorsoHeight, bodyYaw, worldLandmarks, }: StableShoulderWidthInput): number;
+export declare function computeGarmentRootQuaternion({ leftShoulder, rightShoulder, leftHip, rightHip, }: GarmentRootOrientationInput, target?: THREE.Quaternion): THREE.Quaternion | null;
+export {};

package/dist/garment/garmentFitProfile.d.ts

@@ -0,0 +1,24 @@
+import * as THREE from "three";
+export interface GarmentBoneBinding {
+    bone: THREE.Bone;
+    restQuaternion: THREE.Quaternion;
+    restScale: THREE.Vector3;
+    restWorldPosition?: THREE.Vector3;
+    restWorldQuaternion?: THREE.Quaternion;
+    restParentWorldQuaternion?: THREE.Quaternion;
+}
+export type GarmentBoneBindingMap = Map<string, GarmentBoneBinding[]>;
+export interface GarmentFitProfile {
+    anchor: THREE.Vector3;
+    shoulderCenter: THREE.Vector3;
+    hipCenter: THREE.Vector3;
+    referenceWidth: number;
+    referenceTorsoHeight: number;
+    trackingHeight: number;
+    boundsCenter: THREE.Vector3;
+    boundsSize: THREE.Vector3;
+    hasBoneAnchors: boolean;
+}
+export declare function captureBoneBinding(bone: THREE.Bone): GarmentBoneBinding;
+export declare function computeGarmentFitProfile(scene: THREE.Group, bones: GarmentBoneBindingMap, fallbackWidth?: number): GarmentFitProfile;
+export declare function resetBoneRotations(bones: GarmentBoneBindingMap): void;

package/dist/garment/poseApplication.d.ts

@@ -0,0 +1,18 @@
+import type { NormalizedLandmark } from "@mediapipe/tasks-vision";
+import { type MutableRefObject } from "react";
+import * as THREE from "three";
+import { type LandmarkCoordinateSpace } from "../pose/landmarkPoseSolver";
+import { type GarmentBoneBindingMap } from "./garmentFitProfile";
+export interface PoseApplicationRefs {
+    clockRef: MutableRefObject<THREE.Timer>;
+    prevRotationsRef: MutableRefObject<Map<string, THREE.Quaternion>>;
+}
+interface ApplyLandmarkPoseOptions {
+    coordinateSpace?: LandmarkCoordinateSpace;
+    excludeBones?: Set<string>;
+}
+export declare function usePoseApplicationRefs(): PoseApplicationRefs;
+export declare function applyLandmarkPoseToGarment(landmarks: NormalizedLandmark[], bones: GarmentBoneBindingMap, refs: PoseApplicationRefs, options?: ApplyLandmarkPoseOptions): void;
+export declare function resetPoseState(bones: GarmentBoneBindingMap, refs: PoseApplicationRefs): void;
+export declare function blendBonesToRest(bones: GarmentBoneBindingMap, factor: number, delta: number, onlyBones?: Set<string>): void;
+export {};