@lovelace_lol/embody 0.0.6 → 0.0.8

package/package.json

@@ -1,75 +1,69 @@
 {
   "name": "@lovelace_lol/embody",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "Renderer-agnostic character animation runtime for facial AUs, visemes, and bone-driven motion",
   "type": "module",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
+  "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
-    },
-    "./core": {
-      "types": "./dist/core/index.d.ts",
-      "import": "./dist/core.js",
-      "require": "./dist/core.cjs"
+      "default": "./dist/index.js"
     },
     "./three": {
-      "types": "./dist/engines/three/index.d.ts",
+      "types": "./dist/three/index.d.ts",
       "import": "./dist/three.js",
-      "require": "./dist/three.cjs"
-    },
-    "./cljs": {
-      "types": "./dist/cljs.d.ts",
-      "import": "./dist/cljs.js",
-      "require": "./dist/cljs.cjs"
+      "default": "./dist/three.js"
     },
     "./wasm": {
-      "types": "./dist/wasm.d.ts",
+      "types": "./dist/wasm/index.d.ts",
       "import": "./dist/wasm.js",
-      "require": "./dist/wasm.cjs"
-    }
+      "default": "./dist/wasm.js"
+    },
+    "./character-asset-service-worker.js": "./service-worker/character-asset-service-worker.js"
   },
   "files": [
     "dist",
+    "service-worker",
     "README.md",
     "LICENSE"
   ],
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": false
   },
   "scripts": {
-    "build": "tsup --config tsup.wasm.config.ts && tsup --config tsup.config.ts && tsc -p tsconfig.declarations.json && node scripts/export-preset-json.mjs --check && npm run wasm:build",
-    "dev": "tsup --watch",
+    "build": "tsup --config tsup.config.mjs && npm run wasm:build && tsc -p tsconfig.declarations.json",
+    "dev": "tsup --config tsup.config.mjs --watch",
     "typecheck": "tsc --noEmit",
-    "pretest": "npm run wasm:build",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "test:exports": "npm run build && node scripts/smoke/package-exports.mjs && node scripts/smoke/package-declarations.mjs",
-    "test:pack": "npm run build && npm pack --dry-run",
-    "preset:export": "tsup --config tsup.config.ts && node scripts/export-preset-json.mjs",
+    "test": "npm run rust:test && npm run typecheck && npm run test:annotations",
+    "test:service-worker": "node --test scripts/test/character-asset-service-worker.test.mjs",
+    "test:scene": "node --test scripts/test/character-scene.test.mjs",
+    "test:exports": "node scripts/smoke/package-exports.mjs && node scripts/smoke/body-controls.mjs && node scripts/smoke/semantic-pose.mjs && node scripts/smoke/morph-authoring.mjs && node scripts/smoke/mesh-profile.mjs && node scripts/smoke/inherited-starts.mjs && node scripts/smoke/bilateral-channels.mjs && node scripts/smoke/viseme-state.mjs && node scripts/smoke/reference-pose.mjs && node scripts/smoke/clip-interpolation.mjs && node scripts/smoke/gaze-focus.mjs && node scripts/smoke/package-declarations.mjs",
+    "test:pack": "node scripts/smoke/package-contents.mjs",
+    "test:package": "npm run check:dist && npm run test:exports && npm run test:scene && npm run test:pack && npm run test:annotations",
+    "check:dist": "node scripts/ci/check-built-package.mjs",
+    "check:generated": "node scripts/ci/check-no-tracked-generated.mjs",
     "extract:humanoid-skeleton-template": "node scripts/extract-humanoid-skeleton-template.cjs",
-    "bench:runtime": "npm run build && node scripts/bench/runtime.mjs",
-    "rust:test": "RUSTC=$(rustup which rustc) RUSTDOC=$(rustup which rustdoc) rustup run stable cargo test --manifest-path rust/embody-wasm/Cargo.toml",
-    "rust:wasm-build": "RUSTC=$(rustup which rustc) RUSTDOC=$(rustup which rustdoc) rustup run stable cargo build --manifest-path rust/embody-wasm/Cargo.toml --target wasm32-unknown-unknown --release",
+    "rust:test": "RUSTC=$(rustup which rustc) RUSTDOC=$(rustup which rustdoc) rustup run stable cargo test",
+    "rust:wasm-build": "RUSTC=$(rustup which rustc) RUSTDOC=$(rustup which rustdoc) rustup run stable cargo build --target wasm32-unknown-unknown --release",
     "wasm:build": "node scripts/build-wasm.mjs",
-    "prepublishOnly": "npm run build"
+    "prepack": "npm run check:dist",
+    "prepublishOnly": "npm run check:dist",
+    "test:annotations": "vitest run --config vitest.config.ts"
   },
   "peerDependencies": {
-    "three": ">=0.150.0"
+    "three": ">=0.184.0"
   },
   "devDependencies": {
     "@types/node": "^26.1.1",
-    "@types/three": "^0.170.0",
-    "@vitest/coverage-v8": "^3.2.4",
-    "three": "^0.170.0",
+    "@types/three": "0.184.0",
+    "pkg-pr-new": "0.0.87",
+    "three": "0.184.0",
     "tsup": "^8.0.0",
     "typescript": "^5.9.0",
-    "vitest": "^3.2.4",
+    "vitest": "^3.2.7",
     "wasm-pack": "^0.15.0"
   },
   "keywords": [
@@ -96,5 +90,6 @@
   "homepage": "https://github.com/meekmachine/embody#readme",
   "author": "Jonathan Sutton Fields",
   "license": "MIT",
-  "packageManager": "npm@10.9.2"
+  "packageManager": "npm@10.9.2",
+  "gitHead": "a55e89edbb22b26059a63ce002a2c3e25caf0cf0"
 }

package/service-worker/character-asset-service-worker.js

@@ -0,0 +1,295 @@
+// Character asset cache service worker.
+//
+// Embody owns character loading, so it also ships this worker. Hosts copy the
+// file to their web root (it must be served same-origin at or above the page
+// scope) and register it, e.g.:
+//
+//   navigator.serviceWorker.register(`${BASE_URL}service-worker.js`);
+//
+// Caching policy: character assets (models, textures, thumbnails, preview
+// clips) are cache-first on deployed origins and network-first on localhost,
+// keyed by a stable origin-independent object path so preview deploys share
+// one cache.
+const SW_VERSION = 'v1';
+const CHARACTER_CACHE = `embody-character-assets-${SW_VERSION}`;
+const LEGACY_CACHE_PREFIXES = ['embody-character-assets-', 'loomlarge-character-assets-'];
+const SHARED_CACHE_DOMAINS = ['web.app'];
+const STABLE_ASSET_CACHE_ORIGIN = 'https://embody.asset-cache.local';
+const ASSET_SOURCE_HEADER = 'X-Embody-Asset-Source';
+const ASSET_PATH_PREFIXES = [
+  'characters',
+  'thumbnails',
+  'preview-clips',
+  'previews',
+  'textures',
+  'models',
+  'animations',
+];
+
+function isCharacterAssetRequest(url) {
+  const pathname = url.pathname || '';
+  return (
+    ASSET_PATH_PREFIXES.some((prefix) => pathname.includes(`/${prefix}/`)) ||
+    /\.(glb|gltf|bin|fbx|ktx2?|basis|png|jpe?g|webp|gif|avif|webm)(?:$|\?)/i.test(pathname)
+  );
+}
+
+function isLocalhost(url) {
+  return (
+    url.hostname === 'localhost' ||
+    url.hostname === '127.0.0.1' ||
+    url.hostname === '0.0.0.0'
+  );
+}
+
+function isCacheableResponse(response) {
+  if (!response) {
+    return false;
+  }
+
+  if (response.status !== 200) {
+    return false;
+  }
+
+  if (response.type === 'opaque') {
+    return false;
+  }
+
+  if (!response.ok) {
+    return false;
+  }
+
+  const contentType = response.headers.get('content-type') || '';
+  return !contentType.toLowerCase().includes('text/html');
+}
+
+// Identify the branch that served this response without reading or buffering
+// its body. "network" means fetch(), which can still revalidate the browser's
+// HTTP cache; "cache" means a response from our CacheStorage.
+function withAssetSource(response, source) {
+  // Opaque and error responses have status 0 and cannot be reconstructed.
+  if (response.status < 200 || response.status > 599) {
+    return response;
+  }
+
+  const headers = new Headers(response.headers);
+  headers.set(ASSET_SOURCE_HEADER, source);
+  const exposedHeaders = headers.get('Access-Control-Expose-Headers');
+  headers.set(
+    'Access-Control-Expose-Headers',
+    exposedHeaders ? `${exposedHeaders}, ${ASSET_SOURCE_HEADER}` : ASSET_SOURCE_HEADER,
+  );
+
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers,
+  });
+}
+
+// `response` must be a dedicated clone: cache.put consumes its body.
+async function putInCache(cacheName, request, response) {
+  if (!isCacheableResponse(response)) {
+    return;
+  }
+
+  try {
+    const cache = await caches.open(cacheName);
+    await cache.put(request, response);
+  } catch (error) {
+    console.warn('[ServiceWorker] Failed to cache character asset:', error);
+  }
+}
+
+// Avoid rewriting multi-hundred-megabyte cache entries when the network
+// response is byte-identical to what we already stored (localhost reloads
+// re-fetch every time, so this runs on every page load).
+async function hasSameCachedEntry(cacheKey, response) {
+  try {
+    const cache = await caches.open(CHARACTER_CACHE);
+    const cached = await cache.match(cacheKey);
+    if (!cached) {
+      return false;
+    }
+
+    const etag = response.headers.get('etag');
+    if (etag) {
+      return cached.headers.get('etag') === etag;
+    }
+
+    const contentLength = response.headers.get('content-length');
+    return Boolean(contentLength) && cached.headers.get('content-length') === contentLength;
+  } catch {
+    return false;
+  }
+}
+
+function normalizeCacheKey(url) {
+  const cacheUrl = new URL(url.toString());
+  cacheUrl.search = '';
+  cacheUrl.hash = '';
+  const sharedDomain = SHARED_CACHE_DOMAINS.find(
+    (domain) => cacheUrl.hostname === domain || cacheUrl.hostname.endsWith(`.${domain}`),
+  );
+
+  if (sharedDomain) {
+    cacheUrl.hostname = sharedDomain;
+    cacheUrl.port = '';
+  }
+
+  return cacheUrl.toString();
+}
+
+function normalizeAssetObjectPath(url) {
+  let decodedPathname = url.pathname || '';
+  try {
+    decodedPathname = decodeURIComponent(decodedPathname);
+  } catch {
+    // Keep the raw path if the URL contains a malformed escape sequence.
+  }
+
+  const pathname = decodedPathname.replace(/^\/+/, '');
+  const pathParts = pathname.split('/').filter(Boolean);
+  const supportedPrefixIndex = pathParts.findIndex((part) =>
+    ASSET_PATH_PREFIXES.includes(part),
+  );
+
+  if (supportedPrefixIndex >= 0) {
+    return pathParts.slice(supportedPrefixIndex).join('/');
+  }
+
+  if (pathParts[0] === 'assets' && pathParts.length > 1) {
+    return pathParts.slice(1).join('/');
+  }
+
+  return pathname || null;
+}
+
+function stableAssetCacheKey(url) {
+  const objectPath = normalizeAssetObjectPath(url);
+  if (!objectPath) {
+    return normalizeCacheKey(url);
+  }
+
+  return `${STABLE_ASSET_CACHE_ORIGIN}/${objectPath}`;
+}
+
+async function matchCachedAsset(cache, url) {
+  const cacheKey = stableAssetCacheKey(url);
+  const cached = await cache.match(cacheKey);
+  if (cached) {
+    return cached;
+  }
+
+  const objectPath = normalizeAssetObjectPath(url);
+  if (!objectPath) {
+    return null;
+  }
+
+  const cachedRequests = await cache.keys();
+  for (const request of cachedRequests) {
+    try {
+      const cachedUrl = new URL(request.url);
+      if (normalizeAssetObjectPath(cachedUrl) !== objectPath) {
+        continue;
+      }
+
+      const legacyCached = await cache.match(request);
+      if (legacyCached) {
+        await cache.put(cacheKey, legacyCached.clone());
+        return legacyCached;
+      }
+    } catch {
+      // Ignore malformed legacy cache entries.
+    }
+  }
+
+  return null;
+}
+
+// Cache in the background so the page starts consuming the response
+// immediately instead of waiting for the full body to be written to disk.
+function cacheInBackground(event, cacheKey, response, { skipIfUnchanged = false } = {}) {
+  if (!isCacheableResponse(response)) {
+    return;
+  }
+
+  const copy = response.clone();
+  event.waitUntil(
+    (async () => {
+      if (skipIfUnchanged && (await hasSameCachedEntry(cacheKey, copy))) {
+        return;
+      }
+      await putInCache(CHARACTER_CACHE, cacheKey, copy);
+    })(),
+  );
+}
+
+async function cacheFirstAsset(event, url) {
+  const cache = await caches.open(CHARACTER_CACHE);
+  const cached = await matchCachedAsset(cache, url);
+  if (cached) {
+    return withAssetSource(cached, 'cache');
+  }
+
+  const response = await fetch(event.request);
+  cacheInBackground(event, stableAssetCacheKey(url), response);
+  return withAssetSource(response, 'network');
+}
+
+async function networkFirst(event, url) {
+  const cacheKey = normalizeCacheKey(url);
+
+  try {
+    const response = await fetch(event.request);
+    cacheInBackground(event, cacheKey, response, { skipIfUnchanged: true });
+    return withAssetSource(response, 'network');
+  } catch (error) {
+    const cache = await caches.open(CHARACTER_CACHE);
+    const cached = await cache.match(cacheKey);
+    if (cached) {
+      return withAssetSource(cached, 'cache');
+    }
+    throw error;
+  }
+}
+
+self.addEventListener('install', (event) => {
+  event.waitUntil(self.skipWaiting());
+});
+
+self.addEventListener('activate', (event) => {
+  event.waitUntil(
+    (async () => {
+      const keys = await caches.keys();
+      await Promise.all(
+        keys
+          .filter(
+            (key) =>
+              LEGACY_CACHE_PREFIXES.some((prefix) => key.startsWith(prefix)) &&
+              key !== CHARACTER_CACHE,
+          )
+          .map((key) => caches.delete(key)),
+      );
+      await self.clients.claim();
+    })(),
+  );
+});
+
+self.addEventListener('fetch', (event) => {
+  if (event.request.method !== 'GET') {
+    return;
+  }
+
+  const url = new URL(event.request.url);
+  if (!isCharacterAssetRequest(url)) {
+    return;
+  }
+
+  if (isLocalhost(url)) {
+    event.respondWith(networkFirst(event, url));
+    return;
+  }
+
+  event.respondWith(cacheFirstAsset(event, url));
+});

package/dist/authoring/boneAuthoring.d.ts

@@ -1,132 +0,0 @@
-import type { AUInfo } from '../core/types';
-import type { Profile } from '../mappings/types';
-export declare const JOINT_CONTROL_SECTION = "Joint Controls";
-export type BoneAxisKey = 'pitch' | 'yaw' | 'roll';
-export type RotationChannel = 'rx' | 'ry' | 'rz';
-export type BoneAxisDirection = 'negative' | 'positive';
-export type BoneAxisDirectionScale = -1 | 1;
-export interface BilateralAxisDirectionScaleState {
-    left: BoneAxisDirectionScale | null;
-    right: BoneAxisDirectionScale | null;
-}
-export interface BoneAxisBindingState {
-    axis: BoneAxisKey;
-    channel: RotationChannel;
-    nodeKey: string;
-    positiveAuId: number | null;
-    negativeAuId: number | null;
-    positiveMaxDegrees: number | null;
-    negativeMaxDegrees: number | null;
-    positiveScale: BoneAxisDirectionScale | null;
-    negativeScale: BoneAxisDirectionScale | null;
-}
-export interface BoneAxisBindingUpdate {
-    channel?: RotationChannel;
-    positiveAuId?: number | null;
-    negativeAuId?: number | null;
-    positiveMaxDegrees?: number | null;
-    negativeMaxDegrees?: number | null;
-    positiveScale?: BoneAxisDirectionScale | null;
-    negativeScale?: BoneAxisDirectionScale | null;
-    positiveLeftScale?: BoneAxisDirectionScale | null;
-    positiveRightScale?: BoneAxisDirectionScale | null;
-    negativeLeftScale?: BoneAxisDirectionScale | null;
-    negativeRightScale?: BoneAxisDirectionScale | null;
-}
-export declare function isMaxDegreesOnlyAxisBindingUpdate(update: BoneAxisBindingUpdate): boolean;
-export interface AUBoneBindingState {
-    auId: number;
-    boneName: string | null;
-    nodeKey: string | null;
-    axis: BoneAxisKey;
-    direction: BoneAxisDirection;
-    channel: RotationChannel | null;
-    maxDegrees: number | null;
-    oppositeAuId: number | null;
-    oppositeMaxDegrees: number | null;
-    hasBinding: boolean;
-    hasMultipleBindings: boolean;
-}
-export interface CreatedBoneAxisAu {
-    auId: number;
-    profile: Profile;
-}
-export interface ChiralBoneNamePair {
-    leftBoneName: string;
-    rightBoneName: string;
-    selectedSide: 'left' | 'right';
-    familyLabel: string;
-}
-export type BoneControlScope = 'Left Eye Only' | 'Right Eye Only' | 'Both Eyes';
-export type BoneControlFamily = 'Horizontal Gaze' | 'Vertical Gaze';
-export type BilateralBoneAxisScope = 'shared' | 'left' | 'right';
-export interface BilateralAxisScopeBindingState {
-    scope: BilateralBoneAxisScope;
-    label: string;
-    negativeAuId: number | null;
-    positiveAuId: number | null;
-    negativeMaxDegrees: number | null;
-    positiveMaxDegrees: number | null;
-    negativeScale: BilateralAxisDirectionScaleState;
-    positiveScale: BilateralAxisDirectionScaleState;
-}
-export interface BilateralAxisBindingState {
-    axis: BoneAxisKey;
-    familyLabel: string;
-    leftBoneName: string;
-    leftNodeKey: string;
-    rightBoneName: string;
-    rightNodeKey: string;
-    selectedSide: 'left' | 'right';
-    shared: BilateralAxisScopeBindingState;
-    left: BilateralAxisScopeBindingState;
-    right: BilateralAxisScopeBindingState;
-}
-export declare const DEFAULT_AXIS_TO_CHANNEL: Record<BoneAxisKey, RotationChannel>;
-export declare const DEFAULT_BONE_MAX_DEGREES = 60;
-export declare function inferChiralBoneNamePair(boneNames: string[], selectedBoneName: string): ChiralBoneNamePair | null;
-export declare function formatAxisLabel(axis: BoneAxisKey): string;
-export declare function formatAxisDirectionLabel(axis: BoneAxisKey, direction: BoneAxisDirection): string;
-export declare function stripConfiguredBoneAffixes(profile: {
-    bonePrefix?: string;
-    boneSuffix?: string;
-} | null | undefined, boneName: string): string;
-export declare function findNodeKeyForBone(boneName: string, profile: Profile | null): string | null;
-export declare function ensureBoneNodeKey(profile: Profile, boneName: string): {
-    nodeKey: string;
-    boneNodes: Record<string, string>;
-};
-export declare function ensureBilateralBoneNodeKeys(profile: Profile, leftBoneName: string, rightBoneName: string): Profile;
-export declare function resolveBoneNameForNodeKey(profile: Profile, nodeKey: string): string | null;
-export declare function inferEyeControlScope(profile: Pick<Profile, 'auToBones'>, binding: Pick<BoneAxisBindingState, 'nodeKey' | 'negativeAuId' | 'positiveAuId'>): BoneControlScope | null;
-export declare function inferEyeControlFamily(binding: Pick<BoneAxisBindingState, 'nodeKey' | 'axis'>): BoneControlFamily | null;
-export declare function resolveBoneAxisChannel(profile: Profile, boneName: string, axis: BoneAxisKey): RotationChannel;
-export declare function getBoneAxisBindingState(profile: Profile, boneName: string, axis: BoneAxisKey): BoneAxisBindingState;
-export declare function getBilateralAxisBindingState(profile: Profile, boneName: string, axis: BoneAxisKey): BilateralAxisBindingState | null;
-export declare function getAUBoneBindingState(profile: Profile, auId: number): AUBoneBindingState;
-export declare function applyAUBoneBindingUpdate(profile: Profile, auId: number, update: {
-    boneName: string | null;
-    axis: BoneAxisKey;
-    direction: BoneAxisDirection;
-    maxDegrees: number | null;
-}): Profile;
-export declare function resolveContinuumDisplayLabel(profile: Pick<Profile, 'continuumPairs' | 'continuumLabels' | 'auInfo' | 'boneNodes' | 'bonePrefix' | 'boneSuffix'>, negativeAuId: number, positiveAuId: number): string;
-export declare function applyBoneAxisBindingUpdate(profile: Profile, boneName: string, axis: BoneAxisKey, update: BoneAxisBindingUpdate): Profile;
-export declare function applyBilateralAxisBindingUpdate(profile: Profile, boneName: string, axis: BoneAxisKey, scope: BilateralBoneAxisScope, update: BoneAxisBindingUpdate): Profile;
-export declare function isJointControlAuInfo(info: Pick<AUInfo, 'facePart'> | null | undefined): boolean;
-export declare function classifyAuAsJointControl(profile: Profile, auId: number, options?: {
-    boneName?: string | null;
-    nodeKey?: string | null;
-}): Profile;
-export declare function createBoneAxisAu(profile: Profile, boneName: string, axis: BoneAxisKey, direction: BoneAxisDirection, options?: {
-    name?: string;
-}): CreatedBoneAxisAu;
-export declare function createBilateralBoneAxisAu(profile: Profile, boneName: string, axis: BoneAxisKey, scope: BilateralBoneAxisScope, direction: BoneAxisDirection, options?: {
-    name?: string;
-}): CreatedBoneAxisAu;
-export declare function buildBoneAuOptions(profile: Profile): Array<{
-    value: string;
-    label: string;
-    detail?: string;
-}>;
-export declare function getAxisFromChannel(channel: string | undefined): BoneAxisKey | null;

package/dist/camera/annotationCameraAngles.d.ts

@@ -1,28 +0,0 @@
-import * as THREE from 'three';
-import type { BoneResolutionProfile } from '../regions/regionMapping';
-import type { Region } from '../regions/types';
-type SemanticSide = 'left' | 'right';
-export interface AnnotationLaterality {
-    leftSideX: 1 | -1;
-    confidence: number;
-    evidence: string[];
-}
-type LateralityRegion = Pick<Region, 'name' | 'cameraAngle' | 'parent'>;
-export declare function getDefaultAnnotationLaterality(): AnnotationLaterality;
-export declare function normalizeCameraAngle(angle: number): number;
-export declare function getRegionSemanticSide(regionName?: string): SemanticSide | null;
-export declare function getSemanticHorizontalSign(regionName: string, laterality: AnnotationLaterality): 1 | -1 | null;
-export declare function getSemanticHorizontalSignForSide(side: SemanticSide, laterality: AnnotationLaterality): 1 | -1;
-export declare function detectAnnotationLaterality(model: THREE.Object3D | null, regions: Region[], characterConfig: BoneResolutionProfile | null): AnnotationLaterality;
-export declare function resolveRegionCameraAngle(region: LateralityRegion, laterality: AnnotationLaterality): number | undefined;
-export declare function resolveRegionVisibilityCameraAngle(region: LateralityRegion, laterality: AnnotationLaterality): number | undefined;
-export declare function toWorldDirection(model: THREE.Object3D | null, localDirection: THREE.Vector3): THREE.Vector3;
-export declare function toModelLocalDirection(model: THREE.Object3D | null, worldDirection: THREE.Vector3): THREE.Vector3;
-export declare function getWorldDirectionForCameraAngle(model: THREE.Object3D | null, cameraAngle: number): THREE.Vector3;
-export declare function getModelLocalOrbitAngle(model: THREE.Object3D | null, modelCenter: THREE.Vector3, worldPosition: THREE.Vector3): number;
-export declare function passesMarkerCameraAngleGate(params: {
-    markerAngle?: number;
-    currentCameraAngle?: number;
-    rangeDegrees?: number;
-}): boolean;
-export {};

package/dist/camera/cameraRelativeGaze.d.ts

@@ -1,15 +0,0 @@
-import * as THREE from 'three';
-export type CameraRelativeGazeOffset = {
-    x: number;
-    y: number;
-};
-export interface CameraRelativeGazeOptions {
-    yawWeight?: number;
-    pitchWeight?: number;
-    epsilon?: number;
-}
-/**
- * Convert the current camera position into a normalized gaze offset in model-local space.
- * This is intentionally pure so apps can cache or subscribe to camera changes however they want.
- */
-export declare function computeCameraRelativeGazeOffset(model: THREE.Object3D | null, cameraPosition: THREE.Vector3, targetPosition: THREE.Vector3, options?: CameraRelativeGazeOptions): CameraRelativeGazeOffset;