@ssafy-mhk/e-ver 1.0.2 → 1.0.4

package/dist/measurement/garmentScaler.d.ts

@@ -0,0 +1,19 @@
+import type { BodyMeasurements, GarmentScaleParams } from "../types/measurement";
+export interface GarmentSpec {
+    refShoulderWidthCm: number;
+    refHeightCm: number;
+    refArmLengthCm: number;
+    refChestCircumferenceCm: number;
+    refWaistCircumferenceCm: number;
+    refHipWidthCm: number;
+    refTorsoLengthCm: number;
+    shoulderEaseCm: number;
+    chestEaseCm: number;
+    waistEaseCm: number;
+    hipEaseCm: number;
+    torsoEaseCm: number;
+    armEaseCm: number;
+    fitEaseScale: number;
+}
+export declare const DEFAULT_GARMENT_SPEC: GarmentSpec;
+export declare function computeGarmentScale(measurements: BodyMeasurements, spec?: GarmentSpec): GarmentScaleParams;

package/dist/measurement/scaleCalculator.d.ts

@@ -0,0 +1,5 @@
+import type { BodyMeasurements, SilhouetteWidths } from "../types/measurement";
+import { type PoseLandmarkLike } from "../types/pose";
+export declare function computeScale(landmarks: PoseLandmarkLike[], referenceHeightCm: number, imageHeight?: number): number;
+export declare function computeBmiCorrectionFactor(bmi: number): number;
+export declare function measureBody(landmarks: PoseLandmarkLike[], referenceHeightCm: number, weightKg?: number | null, silhouetteWidths?: SilhouetteWidths | null, imageWidth?: number, imageHeight?: number): BodyMeasurements;

package/dist/measurement/scaleCalculator.test.d.ts

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

package/dist/measurement/silhouetteExtractor.d.ts

@@ -0,0 +1,3 @@
+import type { SilhouetteWidths } from "../types/measurement";
+import { type PoseLandmarkLike } from "../types/pose";
+export declare function extractSilhouetteWidths(maskData: Float32Array, maskWidth: number, maskHeight: number, landmarks: PoseLandmarkLike[]): SilhouetteWidths | null;

package/dist/measurement/sizeRecommender.d.ts

@@ -0,0 +1,2 @@
+import type { BodyMeasurements, SizeRecommendation } from "../types/measurement";
+export declare function recommendSize(measurements: BodyMeasurements): SizeRecommendation | null;

package/dist/pose/boneMapping.d.ts

@@ -0,0 +1,14 @@
+import type { JointRotation, PoseRig } from "../types/pose";
+type RotationScale = number | Partial<Record<keyof JointRotation, number>>;
+interface BoneMappingEntry {
+    rigKey: keyof PoseRig | null;
+    rotationScale?: RotationScale;
+    rotationLimits?: Partial<Record<keyof JointRotation, {
+        min: number;
+        max: number;
+    }>>;
+}
+export declare const BONE_MAPPING: Record<string, BoneMappingEntry>;
+export declare function normalizeBoneName(boneName: string): string;
+export declare function getBoneRotation(boneName: string, poseRig: PoseRig): JointRotation | null;
+export {};

package/dist/pose/coordinateTransform.d.ts

@@ -0,0 +1,9 @@
+import type { NormalizedLandmark } from "@mediapipe/tasks-vision";
+import * as THREE from "three";
+export interface CoordinateTransformOptions {
+    mirrorX?: boolean;
+    sourceWidth?: number;
+    sourceHeight?: number;
+    target?: THREE.Vector3;
+}
+export declare function landmarkToThreePosition(landmark: NormalizedLandmark, viewportWidth: number, viewportHeight: number, mirrorXOrOptions?: boolean | CoordinateTransformOptions, target?: THREE.Vector3): THREE.Vector3;

package/dist/pose/facingDetector.d.ts

@@ -0,0 +1,35 @@
+import type { NormalizedLandmark } from "@mediapipe/tasks-vision";
+import { type YawDirection } from "./yawDirectionStabilizer";
+export type FacingZone = "front" | "side" | "back";
+export interface FacingState {
+    zone: FacingZone;
+    rawZone: FacingZone;
+    isFrontFacing: boolean;
+    pitchClamped: boolean;
+    bodyYaw: number;
+    bodyPitch: number;
+    rawYawDirection: YawDirection;
+    yawDirection: YawDirection;
+    committedYawDirection: YawDirection;
+}
+export interface FacingSignals {
+    shoulderOrder: boolean;
+    noseVisible: boolean;
+    earSymmetry: boolean;
+}
+export declare function extractFacingSignals(landmarks: NormalizedLandmark[] | null): FacingSignals;
+export declare function isRawFrontFacing(signals: FacingSignals): boolean;
+export declare class FacingDetector {
+    private _zone;
+    private _consecutiveCount;
+    private _lastRawZone;
+    private _2dFrontCount;
+    private _2dBackCount;
+    private _2dIsFront;
+    private _yawDirectionStabilizer;
+    update(landmarks: NormalizedLandmark[] | null, bodyYaw?: number, bodyPitch?: number): FacingState;
+    reset(): void;
+    private _resolve2dFallback;
+    private _applyHysteresis;
+    private _getTransitionThreshold;
+}

package/dist/pose/interpolation.d.ts

@@ -0,0 +1,16 @@
+import type { SilhouetteWidths } from "../types/measurement";
+import type { PoseLandmarkLike, PoseRig } from "../types/pose";
+export interface PoseFrameSnapshot {
+    landmarks: PoseLandmarkLike[] | null;
+    worldLandmarks: PoseLandmarkLike[] | null;
+    poseRig: PoseRig | null;
+    confidence: number;
+    isTracking: boolean;
+    silhouetteWidths: SilhouetteWidths | null;
+}
+export declare function lerpValue(start: number, end: number, alpha: number): number;
+export declare function interpolateLandmarks(previous: PoseLandmarkLike[] | null, next: PoseLandmarkLike[] | null, alpha: number): PoseLandmarkLike[] | null;
+export declare function interpolatePoseRig(previous: PoseRig | null, next: PoseRig | null, alpha: number): PoseRig | null;
+export declare function interpolateSilhouetteWidths(previous: SilhouetteWidths | null, next: SilhouetteWidths | null, alpha: number): SilhouetteWidths | null;
+export declare function createInitialPoseSnapshot(): PoseFrameSnapshot;
+export declare function interpolatePoseSnapshot(previous: PoseFrameSnapshot | null, next: PoseFrameSnapshot, alpha: number): PoseFrameSnapshot;

package/dist/pose/landmarkPoseSolver.d.ts

@@ -0,0 +1,9 @@
+import * as THREE from "three";
+import { type PoseLandmarkLike } from "../types/pose";
+export type LandmarkCoordinateSpace = "normalized" | "world";
+export type LandmarkSelector = number | readonly [number, number];
+export declare function computeLandmarkSegmentDirection(from: LandmarkSelector, to: LandmarkSelector, landmarks: PoseLandmarkLike[], target: THREE.Vector3, coordinateSpace?: LandmarkCoordinateSpace): boolean;
+export declare function computeBoneDirectionFromLandmarks(boneName: string, landmarks: PoseLandmarkLike[], target: THREE.Vector3, coordinateSpace?: LandmarkCoordinateSpace): boolean;
+export declare function getBoneLandmarkInfluence(boneName: string): number | undefined;
+export declare function computeBoneRotationFromLandmarks(boneName: string, landmarks: PoseLandmarkLike[], target: THREE.Quaternion, coordinateSpace?: LandmarkCoordinateSpace): boolean;
+export declare function hasLandmarkMapping(boneName: string): boolean;

package/dist/pose/landmarkerFactory.d.ts

@@ -0,0 +1,13 @@
+import { PoseLandmarker } from "@mediapipe/tasks-vision";
+export declare const MEDIAPIPE_TASKS_VISION_VERSION = "0.10.32";
+export declare const WASM_FILES_URL = "https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@0.10.32/wasm";
+export declare const POSE_DETECTION_INTERVAL = 2;
+export declare const DEFAULT_NUM_POSES = 3;
+export declare const INTERPOLATION_ALPHA = 0.5;
+export declare const MODEL_ASSET_PATHS: {
+    readonly lite: "https://storage.googleapis.com/mediapipe-models/pose_landmarker/pose_landmarker_lite/float16/latest/pose_landmarker_lite.task";
+    readonly full: "https://storage.googleapis.com/mediapipe-models/pose_landmarker/pose_landmarker_full/float16/latest/pose_landmarker_full.task";
+    readonly heavy: "https://storage.googleapis.com/mediapipe-models/pose_landmarker/pose_landmarker_heavy/float16/latest/pose_landmarker_heavy.task";
+};
+export type ModelComplexity = keyof typeof MODEL_ASSET_PATHS;
+export declare function createPoseLandmarker(modelAssetPath: string, minDetectionConfidence: number, minTrackingConfidence: number, outputSegmentationMasks: boolean, numPoses?: number): Promise<PoseLandmarker>;

package/dist/pose/poseSolver.d.ts

@@ -0,0 +1,2 @@
+import type { PoseLandmarkLike, PoseRig } from "../types/pose";
+export declare function solvePose(landmarks: PoseLandmarkLike[], worldLandmarks?: PoseLandmarkLike[] | null): PoseRig | null;

package/dist/pose/segmentation.d.ts

@@ -0,0 +1,9 @@
+import type { SilhouetteWidths } from "../types/measurement";
+export interface SegmentationMaskLike {
+    width: number;
+    height: number;
+    getAsFloat32Array: () => Float32Array;
+}
+export declare function getSegmentationMaskData(mask: unknown): SegmentationMaskLike | null;
+export declare function closeSegmentationMasks(masks: readonly unknown[] | undefined): void;
+export declare function scaleSilhouetteWidths(silhouetteWidths: SilhouetteWidths, frameWidth: number, maskWidth: number): SilhouetteWidths;

package/dist/pose/smoothing.d.ts

@@ -0,0 +1,12 @@
+import { type JointRotation, type PoseLandmarkLike, type PoseRig, type SmoothingConfig } from "../types/pose";
+export declare function normalizeLandmark(landmark: PoseLandmarkLike): PoseLandmarkLike;
+export declare function normalizeLandmarks(landmarks: PoseLandmarkLike[]): PoseLandmarkLike[];
+export declare class LandmarkSmoother {
+    private prev;
+    private readonly config;
+    constructor(config?: SmoothingConfig);
+    smooth(current: PoseLandmarkLike[]): PoseLandmarkLike[];
+    reset(): void;
+}
+export declare function lerpRotation(prev: JointRotation, next: JointRotation, alpha: number): JointRotation;
+export declare function smoothPoseRig(prev: PoseRig | null, next: PoseRig, alpha?: number): PoseRig;

package/dist/pose/yawDirectionStabilizer.d.ts

@@ -0,0 +1,20 @@
+export type YawDirection = "positive" | "negative" | "unknown";
+export interface StabilizedYawState {
+    rawYawDirection: YawDirection;
+    yawDirection: YawDirection;
+    committedYawDirection: YawDirection;
+    pendingYawDirection: YawDirection;
+    pendingCount: number;
+    stableYaw: number;
+}
+type FacingZoneLike = "front" | "side" | "back";
+export declare class YawDirectionStabilizer {
+    private _committedYawDirection;
+    private _pendingYawDirection;
+    private _pendingCount;
+    update(zone: FacingZoneLike, yaw: number): StabilizedYawState;
+    reset(): void;
+    private _buildState;
+    private _clearPending;
+}
+export {};

package/dist/pose/yawFreezeController.d.ts

@@ -0,0 +1,11 @@
+import type { FacingZone } from "./facingDetector";
+export interface YawFreezeState {
+    isFrozen: boolean;
+    frozenYaw: number | null;
+}
+export declare class YawFreezeController {
+    private _isFrozen;
+    private _frozenYaw;
+    update(zone: FacingZone, yaw: number, _displayYaw: number): YawFreezeState;
+    reset(): void;
+}

package/dist/publicApi.test.d.ts

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

package/dist/store/useEverStore.d.ts

@@ -1,17 +1,22 @@
+export interface PoseLandmark {
+    x: number;
+    y: number;
+    z: number;
+    visibility?: number;
+    presence?: number;
+}
 export interface EverState {
     isWebcamActive: boolean;
-    activeAvatarUrl: string | null;
     activeGarmentUrl: string | null;
-    landmarks: any | null;
-    worldLandmarks: any | null;
+    landmarks: PoseLandmark[] | null;
+    worldLandmarks: PoseLandmark[] | null;
     fitResult: {
         type: "slim" | "regular" | "oversize" | null;
         suitability: number;
     } | null;
     setWebcamActive: (active: boolean) => void;
-    setActiveAvatarUrl: (url: string | null) => void;
     setActiveGarmentUrl: (url: string | null) => void;
-    setLandmarks: (landmarks: any, worldLandmarks: any) => void;
+    setLandmarks: (landmarks: PoseLandmark[] | null, worldLandmarks: PoseLandmark[] | null) => void;
     setFitResult: (result: EverState["fitResult"]) => void;
 }
 export declare const useEverStore: import("zustand").UseBoundStore<import("zustand").StoreApi<EverState>>;

package/dist/tracking/personLock.d.ts

@@ -0,0 +1,39 @@
+import type { VisibleNormalizedRegion } from "../compositing/videoCover";
+import type { PoseLandmarkLike } from "../types/pose";
+export interface NormalizedRect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export interface PoseCandidate {
+    poseIndex: number;
+    personId: string;
+    landmarks: PoseLandmarkLike[];
+    worldLandmarks: PoseLandmarkLike[] | null;
+    bounds: NormalizedRect;
+    expandedBounds: NormalizedRect;
+    meanVisibility: number;
+    area: number;
+}
+export interface LockedPoseCandidate {
+    poseIndex: number;
+    personId: string;
+    bounds: NormalizedRect;
+    expandedBounds: NormalizedRect;
+}
+interface SelectLockedPoseCandidateOptions {
+    previousCandidate: LockedPoseCandidate | null;
+    allowRelock?: boolean;
+    minIouToKeep?: number;
+}
+export declare function clampNormalizedRect(rect: NormalizedRect | null): NormalizedRect | null;
+export declare function computeLandmarkBoundsNormalized(landmarks: PoseLandmarkLike[]): NormalizedRect | null;
+export declare function expandNormalizedRect(rect: NormalizedRect | null, expandRatio?: number): NormalizedRect | null;
+export declare function calcRectIoU(a: NormalizedRect | null, b: NormalizedRect | null): number;
+export declare function createPoseCandidates(landmarkSets: PoseLandmarkLike[][], worldLandmarkSets?: PoseLandmarkLike[][]): PoseCandidate[];
+export declare function selectLockedPoseCandidate(candidates: PoseCandidate[], { previousCandidate, allowRelock, minIouToKeep, }: SelectLockedPoseCandidateOptions): PoseCandidate | null;
+export declare function isCandidateInVisibleRegion(candidate: PoseCandidate, visibleRegion: VisibleNormalizedRegion | null): boolean;
+export declare function filterCandidatesByVisibleRegion(candidates: PoseCandidate[], visibleRegion: VisibleNormalizedRegion | null): PoseCandidate[];
+export declare function toLockedPoseCandidate(candidate: PoseCandidate | null): LockedPoseCandidate | null;
+export {};

package/dist/tracking/trackingStability.d.ts

@@ -0,0 +1,6 @@
+import type { PoseFrameSnapshot } from "../pose/interpolation";
+import { type TrackingRuntimeState } from "../types/tracking";
+export declare const TRACKING_SNAPSHOT_HOLD_MS = 180;
+export declare function shouldHoldTrackingSnapshot(lastTrackedAt: number | null, now: number, holdMs?: number): boolean;
+export declare function createHeldTrackingSnapshot(snapshot: PoseFrameSnapshot | null): PoseFrameSnapshot | null;
+export declare function createTrackingLostRuntimeState(detectedPersonCount: number, updatedAt: number, lockedPersonId?: string | null): TrackingRuntimeState;

package/dist/tracking/trackingState.d.ts

@@ -0,0 +1,18 @@
+import { type TrackingQuality, type TrackingRuntimeState } from "../types/tracking";
+interface CreateTrackingQualityOptions {
+    detectedPersonCount: number;
+    isTracking: boolean;
+    lockedPersonId?: string | null;
+    meanVisibility?: number | null;
+    frameWidth?: number;
+    frameHeight?: number;
+    updatedAt?: number;
+}
+interface CreateTrackingRuntimeStateOptions extends CreateTrackingQualityOptions {
+    lockedPersonId?: string | null;
+}
+export declare function createIdleTrackingQuality(updatedAt?: number | null): TrackingQuality;
+export declare function createTrackingQuality({ detectedPersonCount, isTracking, lockedPersonId, meanVisibility, frameWidth, frameHeight, updatedAt, }: CreateTrackingQualityOptions): TrackingQuality;
+export declare function createInitialTrackingRuntimeState(): TrackingRuntimeState;
+export declare function createTrackingRuntimeState({ detectedPersonCount, isTracking, lockedPersonId, meanVisibility, frameWidth, frameHeight, updatedAt, }: CreateTrackingRuntimeStateOptions): TrackingRuntimeState;
+export {};

package/dist/types/bodyPreset.d.ts

@@ -0,0 +1,65 @@
+import type { BodyMeasurements } from "./measurement";
+export type BodyPresetGender = "male" | "female";
+export type BodyPresetSelectionSource = "match" | "default" | "fallback";
+export interface BodyPresetTaxonomy {
+    sizeBand: string;
+    upperBodySilhouette: string;
+    torsoOrPelvisProfile: string;
+}
+export interface BodyPresetMetrics {
+    heightCm: number | null;
+    chestCm: number | null;
+    waistCm: number | null;
+    hipCm: number | null;
+    shoulderWidthCm: number | null;
+    armLengthCm: number | null;
+    inseamCm: number | null;
+    torsoLengthCm: number | null;
+    neckToHipCm: number | null;
+}
+export interface BodyPresetSelection {
+    id: string | null;
+    presetId: string;
+    label: string;
+    modelUrl: string;
+    gender: BodyPresetGender;
+    source: BodyPresetSelectionSource;
+    taxonomy: BodyPresetTaxonomy;
+    metrics: BodyPresetMetrics;
+}
+export interface BodyPresetSelectionState {
+    selection: BodyPresetSelection;
+    loading: boolean;
+    error: string | null;
+}
+export interface BodyPresetSummary {
+    id: string;
+    presetId: string;
+    baseGender: BodyPresetGender;
+    sizeBand: string;
+    upperBodySilhouette: string;
+    torsoOrPelvisProfile: string;
+    modelUrl: string;
+    heightCm: number | null;
+    chestCm: number | null;
+    waistCm: number | null;
+    hipCm: number | null;
+    shoulderWidthCm: number | null;
+    armLengthCm: number | null;
+    inseamCm: number | null;
+    torsoLengthCm: number | null;
+    neckToHipCm: number | null;
+}
+export interface BodyPresetMatchRequest {
+    gender: BodyPresetGender;
+    height_cm?: number;
+    chest_cm?: number;
+    waist_cm?: number;
+    shoulder_width_cm?: number;
+}
+export interface UseBodyPresetSelectionOptions {
+    gender?: BodyPresetGender;
+    renderMode?: "rigged_avatar" | "preset-native";
+    legacyPresetId?: string;
+}
+export type { BodyMeasurements };

package/dist/types/fitting.d.ts

@@ -0,0 +1,15 @@
+import type { GarmentScaleParams } from "./measurement";
+export type FitType = "slim" | "regular" | "oversize";
+export type PostureAdjust = "neutral" | "rounded_shoulder" | "sway_back";
+export interface BodyMorphResult {
+    torsoScale: number;
+    chestScale: number;
+    waistScale: number;
+    hipScale: number;
+    shoulderAdjust: number;
+    postureAdjust: PostureAdjust;
+}
+export interface BodyFirstFittingResult {
+    scale: GarmentScaleParams;
+    morph: BodyMorphResult | null;
+}

package/dist/types/measurement.d.ts

@@ -0,0 +1,42 @@
+export type MeasurementMethod = "silhouette_depth" | "silhouette_bmi" | "keypoint" | "user_input";
+export type AccuracyGrade = "premium" | "standard" | "estimate";
+export interface BodyMeasurements {
+    heightCm: number;
+    shoulderWidthCm: number | null;
+    chestCircumferenceCm: number | null;
+    waistCircumferenceCm: number | null;
+    hipWidthCm: number | null;
+    armLengthCm: number | null;
+    legLengthCm: number | null;
+    torsoLengthCm: number | null;
+    accuracyGrade?: AccuracyGrade | null;
+    confidenceScore?: number | null;
+    measurementMethod?: MeasurementMethod | null;
+    measuredAt?: string | null;
+}
+export interface SilhouetteWidths {
+    shoulderWidthPx: number;
+    chestWidthPx: number;
+    waistWidthPx: number;
+    hipWidthPx: number;
+}
+export interface GarmentScaleParams {
+    scaleX: number;
+    scaleY: number;
+    scaleZ: number;
+    sleeveScale: number;
+    fitEaseScale: number;
+}
+export type ClothingSize = "S" | "M" | "L" | "XL" | "2XL";
+export interface SizeRecommendation {
+    size: ClothingSize;
+    confidence: number;
+    fitDescription: string;
+}
+export interface MeasurementConfig {
+    referenceHeightCm: number;
+    weightKg: number | null;
+    stableFrameCount: number;
+    motionThreshold: number;
+}
+export declare const DEFAULT_MEASUREMENT_CONFIG: MeasurementConfig;

package/dist/types/pose.d.ts

@@ -0,0 +1,81 @@
+export interface PoseLandmarkLike {
+    x: number;
+    y: number;
+    z: number;
+    visibility?: number;
+    presence?: number;
+}
+export declare const LANDMARK: {
+    readonly NOSE: 0;
+    readonly LEFT_EYE_INNER: 1;
+    readonly LEFT_EYE: 2;
+    readonly LEFT_EYE_OUTER: 3;
+    readonly RIGHT_EYE_INNER: 4;
+    readonly RIGHT_EYE: 5;
+    readonly RIGHT_EYE_OUTER: 6;
+    readonly LEFT_EAR: 7;
+    readonly RIGHT_EAR: 8;
+    readonly MOUTH_LEFT: 9;
+    readonly MOUTH_RIGHT: 10;
+    readonly LEFT_SHOULDER: 11;
+    readonly RIGHT_SHOULDER: 12;
+    readonly LEFT_ELBOW: 13;
+    readonly RIGHT_ELBOW: 14;
+    readonly LEFT_WRIST: 15;
+    readonly RIGHT_WRIST: 16;
+    readonly LEFT_PINKY: 17;
+    readonly RIGHT_PINKY: 18;
+    readonly LEFT_INDEX: 19;
+    readonly RIGHT_INDEX: 20;
+    readonly LEFT_THUMB: 21;
+    readonly RIGHT_THUMB: 22;
+    readonly LEFT_HIP: 23;
+    readonly RIGHT_HIP: 24;
+    readonly LEFT_KNEE: 25;
+    readonly RIGHT_KNEE: 26;
+    readonly LEFT_ANKLE: 27;
+    readonly RIGHT_ANKLE: 28;
+    readonly LEFT_HEEL: 29;
+    readonly RIGHT_HEEL: 30;
+    readonly LEFT_FOOT_INDEX: 31;
+    readonly RIGHT_FOOT_INDEX: 32;
+};
+export interface JointRotation {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface PoseRig {
+    hips: {
+        position: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        rotation: JointRotation;
+    };
+    spine: JointRotation;
+    chest: JointRotation;
+    leftUpperArm: JointRotation;
+    leftLowerArm: JointRotation;
+    rightUpperArm: JointRotation;
+    rightLowerArm: JointRotation;
+    leftUpperLeg?: JointRotation;
+    leftLowerLeg?: JointRotation;
+    rightUpperLeg?: JointRotation;
+    rightLowerLeg?: JointRotation;
+}
+export interface PoseState {
+    landmarks: PoseLandmarkLike[] | null;
+    worldLandmarks: PoseLandmarkLike[] | null;
+    poseRig: PoseRig | null;
+    confidence: number;
+    fps: number;
+    isTracking: boolean;
+}
+export interface SmoothingConfig {
+    positionAlpha: number;
+    rotationAlpha: number;
+    visibilityThreshold: number;
+}
+export declare const DEFAULT_SMOOTHING: SmoothingConfig;

package/dist/types/tracking.d.ts

@@ -0,0 +1,13 @@
+export type TrackingQualityLevel = "idle" | "good" | "degraded" | "blocked";
+export type TrackingQualityReason = "no_person_detected" | "pose_not_locked" | "multi_person_detected" | "low_visibility" | "occluded" | "backlight_detected" | "distance_out_of_range" | "resolution_too_low" | "tracking_lost";
+export interface TrackingQuality {
+    level: TrackingQualityLevel;
+    reasons: TrackingQualityReason[];
+    updatedAt: number | null;
+}
+export interface TrackingRuntimeState {
+    detectedPersonCount: number;
+    lockedPersonId: string | null;
+    trackingQuality: TrackingQuality;
+}
+export declare const DEFAULT_LOCKED_PERSON_ID = "pose-0";

package/package.json

@@ -5,9 +5,7 @@
     "@react-three/drei": "^10.7.7",
     "@react-three/fiber": "^9.5.0",
     "@types/three": "^0.183.1",
-    "axios": "^1.13.6",
-    "three": "^0.183.2",
-    "zustand": "^5.0.12"
+    "axios": "^1.13.6"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.4",
@@ -44,15 +42,22 @@
   "name": "@ssafy-mhk/e-ver",
   "peerDependencies": {
     "react": ">=16.8.0",
-    "react-dom": ">=16.8.0"
+    "react-dom": ">=16.8.0",
+    "three": ">=0.150.0",
+    "@react-three/fiber": ">=8.0.0",
+    "@react-three/drei": ">=9.0.0",
+    "@mediapipe/tasks-vision": ">=0.10.0",
+    "zustand": ">=4.0.0"
   },
   "scripts": {
     "build": "vite build && tsc -p tsconfig.app.json",
     "dev": "vite",
     "lint": "eslint .",
-    "preview": "vite preview"
+    "preview": "vite preview",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "1.0.2"
+  "version": "1.0.4"
 }