@lovelace_lol/embody 0.0.1

package/dist/authoring/boneAuthoring.d.ts

@@ -0,0 +1,132 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,15 @@
+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;

package/dist/camera/rustAnnotationCameraCore.d.ts

@@ -0,0 +1,136 @@
+import type { WasmCameraFlightHandle, WasmCameraOrbitHandle } from '../wasmTypes';
+export interface Vec3Like {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface QuatLike {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+export interface BoundsLike {
+    center: Vec3Like;
+    size: Vec3Like;
+}
+export interface CameraFramingResult {
+    position: Vec3Like;
+    target: Vec3Like;
+    distance: number;
+}
+export interface CameraPoseSample extends Omit<CameraFramingResult, 'distance'> {
+    done: boolean;
+}
+export interface FocusFramingOptions {
+    focusBounds: BoundsLike;
+    modelBounds?: BoundsLike | null;
+    modelQuaternion?: QuatLike | null;
+    fovDegrees: number;
+    aspect: number;
+    minDistance: number;
+    closeUpPaddingFactor: number;
+    zoomPaddingFactor: number;
+    fullBodyPaddingFactor: number;
+    overridePadding?: number;
+    cameraAngle?: number;
+    angleSpace?: 'model' | 'world';
+}
+export interface FullBodyFramingOptions {
+    boxMin: Vec3Like;
+    boxMax: Vec3Like;
+    modelQuaternion?: QuatLike | null;
+    fovDegrees: number;
+    aspect: number;
+    minDistance: number;
+    fullBodyPaddingFactor: number;
+    overridePadding?: number;
+    cameraAngle?: number;
+    angleSpace?: 'model' | 'world';
+}
+export type MarkerSoloState = 'none' | 'soloed' | 'other-soloed';
+export interface MarkerVisibilityAnimationFactors {
+    itemOpacityFactor: number;
+    labelScaleFactor: number;
+    lineOpacityFactor: number;
+}
+export interface MarkerEndpointSeparationOptions {
+    /** Packed marker surface anchors as `[x, y, z, ...]`. */
+    starts: ArrayLike<number>;
+    /** Packed marker leader-line ends as `[x, y, z, ...]`. */
+    ends: ArrayLike<number>;
+    modelCenter: Vec3Like;
+    modelHeight: number;
+}
+export declare class RustCameraFlight {
+    private handle;
+    constructor(handle: WasmCameraFlightHandle);
+    sample(elapsedMs: number): CameraPoseSample;
+    get durationMs(): number;
+    dispose(): void;
+}
+export declare class RustCameraOrbit {
+    private handle;
+    constructor(handle: WasmCameraOrbitHandle);
+    sample(elapsedMs: number): CameraPoseSample;
+    get durationMs(): number;
+    dispose(): void;
+}
+export declare class RustAnnotationCameraCore {
+    private core;
+    private constructor();
+    static create(): Promise<RustAnnotationCameraCore>;
+    normalizeCameraAngle(angle: number): number;
+    worldDirectionForCameraAngle(modelQuaternion: QuatLike | null, cameraAngle: number): Vec3Like;
+    resolveFocusCameraDirection(modelQuaternion: QuatLike | null, effectiveAngle: number, cameraAngle: number | undefined, angleSpace?: 'model' | 'world'): Vec3Like;
+    resolveAutoCloseupAngle(horizontalOffset: number, focusSize: Vec3Like, modelSize: Vec3Like): number | undefined;
+    focusPaddingFactor(size: number, closeUpPaddingFactor: number, zoomPaddingFactor: number, fullBodyPaddingFactor: number): number;
+    solveFocusFraming(options: FocusFramingOptions): CameraFramingResult;
+    solveFullBodyFraming(options: FullBodyFramingOptions): CameraFramingResult;
+    createCameraFlight(startPosition: Vec3Like, startTarget: Vec3Like, endPosition: Vec3Like, endTarget: Vec3Like, durationMs: number): RustCameraFlight;
+    createCameraOrbit(center: Vec3Like, radius: number, height: number, durationMs: number): RustCameraOrbit;
+    passesMarkerCameraAngleGate(params: {
+        markerAngle?: number;
+        currentCameraAngle?: number;
+        rangeDegrees?: number;
+    }): boolean;
+    shouldShowMarker(params: {
+        hiddenChild: boolean;
+        solo: MarkerSoloState;
+        markerAngle?: number;
+        currentCameraAngle?: number;
+    }): boolean;
+    resolveViewportConstrainedLineScale(params: {
+        startClip: readonly number[];
+        endClip: readonly number[];
+        safeX: number;
+        safeY: number;
+        minLengthRatio?: number;
+    }): {
+        visible: boolean;
+        lineScale: number;
+    };
+    resolveViewportSafeBounds(params: {
+        labelScaleX: number;
+        labelScaleY: number;
+        projectionXScale: number;
+        projectionYScale: number;
+        viewportWidth: number;
+        viewportHeight: number;
+        edgePaddingPx?: number;
+    }): {
+        safeX: number;
+        safeY: number;
+    };
+    /** Returns `(segments + 1)` points as a flat `[x, y, z, ...]` array. */
+    sampleMarkerBezierCurve(start: Vec3Like, end: Vec3Like, segments?: number): Float32Array;
+    /** Returns `(segments + 1)` points as a flat `[x, y, z, ...]` array. */
+    sampleMarkerArcCurve(start: Vec3Like, end: Vec3Like, segments?: number): Float32Array;
+    markerVisibilityAnimationFactors(visible: boolean, t: number): MarkerVisibilityAnimationFactors;
+    /**
+     * Separates overlapping leader-line endpoints while retaining marker anchors
+     * and leader-line lengths. Returns packed `[x, y, z, ...]` endpoints.
+     */
+    separateOverlappingMarkerEndpoints(options: MarkerEndpointSeparationOptions): Float32Array;
+}
+export declare function createRustAnnotationCameraCore(): Promise<RustAnnotationCameraCore>;

package/dist/cljs.cjs

@@ -0,0 +1,362 @@
+'use strict';
+
+// src/cljs.ts
+var LOOP_MODES = /* @__PURE__ */ new Set(["once", "repeat", "pingpong"]);
+function nowMs() {
+  return Date.now();
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function numberOr(value, fallback) {
+  return finiteNumber(value) ? value : fallback;
+}
+function clamp(low, high, value) {
+  const next = numberOr(value, low);
+  return Math.min(high, Math.max(low, next));
+}
+function keyToString(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number") return String(value);
+  if (typeof value === "symbol") return value.description ?? "";
+  return "";
+}
+function getConnectorFunction(connector, name) {
+  const candidate = connector[name];
+  return typeof candidate === "function" ? candidate : null;
+}
+function callFirst(connector, names, ...args) {
+  for (const name of names) {
+    const callback = getConnectorFunction(connector, name);
+    if (callback) {
+      return callback(...args);
+    }
+  }
+  return void 0;
+}
+function normalizePoint(point) {
+  const source = isRecord(point) ? point : {};
+  return {
+    time: numberOr(source.time ?? source.t, 0),
+    intensity: numberOr(source.intensity ?? source.v, 0),
+    inherit: Boolean(source.inherit)
+  };
+}
+function normalizeCurves(curves) {
+  if (!isRecord(curves)) {
+    return {};
+  }
+  return Object.fromEntries(
+    Object.entries(curves).map(([curveId, points]) => [
+      keyToString(curveId),
+      (Array.isArray(points) ? points : []).map(normalizePoint).sort((a, b) => a.time - b.time)
+    ])
+  );
+}
+function calculateDuration(curves, fallback) {
+  return Object.values(curves).reduce((duration, points) => {
+    const last = points[points.length - 1];
+    return Math.max(duration, numberOr(last?.time, duration));
+  }, numberOr(fallback, 0));
+}
+function normalizeLoopMode(options) {
+  const mode = options.loopMode ?? options.mixerLoopMode;
+  if (typeof mode === "string" && LOOP_MODES.has(mode)) {
+    return mode;
+  }
+  return options.loop === false ? "once" : "repeat";
+}
+function normalizeOptions(options) {
+  const source = isRecord(options) ? options : {};
+  const loopMode = normalizeLoopMode(source);
+  const rate = source.playbackRate ?? source.rate ?? source.speed;
+  const weight = source.weight ?? source.intensity ?? source.mixerWeight;
+  return {
+    ...source,
+    weight: Math.max(0, numberOr(weight, 1)),
+    rate: Math.max(0, numberOr(rate, 1)),
+    loopMode,
+    loop: loopMode !== "once",
+    repeatCount: finiteNumber(source.repeatCount) ? source.repeatCount : void 0,
+    reverse: Boolean(source.reverse),
+    source: keyToString(source.source) || "clip",
+    startTime: Math.max(0, numberOr(source.startTime, 0)),
+    balance: clamp(-1, 1, source.balance),
+    jawScale: Math.max(0, numberOr(source.jawScale, 1)),
+    intensityScale: Math.max(0, numberOr(source.intensityScale, 1))
+  };
+}
+function makeActionId(clipName) {
+  return `${clipName}#${nowMs()}-${Math.floor(Math.random() * 1e6)}`;
+}
+function emitCommand(connector, op, clipName, payload = {}) {
+  const command = {
+    type: "clipCommand",
+    op,
+    clipName,
+    timestamp: nowMs(),
+    ...payload
+  };
+  connector.onCommand?.(command);
+  return command;
+}
+function emitState(connector, state) {
+  connector.onState?.(snapshotState(state));
+}
+function snapshotState(state) {
+  return {
+    handles: Object.fromEntries(
+      Object.entries(state.handles).map(([clipName, handle]) => [clipName, { ...handle }])
+    ),
+    order: [...state.order],
+    eventCount: state.eventCount,
+    lastEvent: state.lastEvent ? { ...state.lastEvent } : null,
+    lastUpdatedTime: state.lastUpdatedTime,
+    config: { ...state.config }
+  };
+}
+function createAnimationRuntime(config = null, connector = null) {
+  const renderer = connector ?? {};
+  const state = {
+    handles: {},
+    order: [],
+    eventCount: 0,
+    lastEvent: null,
+    lastUpdatedTime: null,
+    config: isRecord(config) ? { ...config } : {}
+  };
+  const listeners = /* @__PURE__ */ new Map();
+  const finishers = /* @__PURE__ */ new Map();
+  const upsertHandle = (handle) => {
+    state.handles[handle.clipName] = handle;
+    if (!state.order.includes(handle.clipName)) {
+      state.order.push(handle.clipName);
+    }
+    state.lastUpdatedTime = nowMs();
+  };
+  const updateHandle = (clipName, apply) => {
+    const current = state.handles[clipName];
+    if (!current) return;
+    state.handles[clipName] = apply({ ...current, updatedAt: nowMs() });
+    state.lastUpdatedTime = nowMs();
+  };
+  const removeHandle = (clipName) => {
+    delete state.handles[clipName];
+    state.order = state.order.filter((name) => name !== clipName);
+    state.lastUpdatedTime = nowMs();
+  };
+  const notifyListeners = (clipName, event) => {
+    for (const listener of Array.from(listeners.get(clipName) ?? [])) {
+      try {
+        listener(event);
+      } catch (error) {
+        console.error("[Embody runtime] clip listener failed", error);
+      }
+    }
+  };
+  const resolveFinished = (clipName) => {
+    const resolve = finishers.get(clipName);
+    if (resolve) {
+      resolve();
+      finishers.delete(clipName);
+    }
+  };
+  const makeHandle = (clipName) => {
+    const finished = new Promise((resolve) => {
+      finishers.set(clipName, resolve);
+    });
+    return {
+      clipName,
+      actionId: state.handles[clipName]?.actionId,
+      play: () => {
+        updateHandle(clipName, (handle) => ({ ...handle, status: "playing" }));
+        emitCommand(renderer, "play", clipName);
+        callFirst(renderer, ["playClip", "play"], clipName);
+        emitState(renderer, state);
+      },
+      stop: () => {
+        updateHandle(clipName, (handle) => ({ ...handle, status: "stopped" }));
+        emitCommand(renderer, "stop", clipName);
+        callFirst(renderer, ["stopClip", "stop"], clipName);
+        resolveFinished(clipName);
+        emitState(renderer, state);
+      },
+      pause: () => {
+        updateHandle(clipName, (handle) => ({ ...handle, status: "paused" }));
+        emitCommand(renderer, "pause", clipName);
+        callFirst(renderer, ["pauseClip", "pause"], clipName);
+        emitState(renderer, state);
+      },
+      resume: () => {
+        updateHandle(clipName, (handle) => ({ ...handle, status: "playing" }));
+        emitCommand(renderer, "resume", clipName);
+        callFirst(renderer, ["resumeClip", "resume"], clipName);
+        emitState(renderer, state);
+      },
+      setWeight: (weight) => {
+        const nextWeight = Math.max(0, numberOr(weight, 1));
+        updateHandle(clipName, (handle) => ({ ...handle, weight: nextWeight }));
+        emitCommand(renderer, "setWeight", clipName, { weight: nextWeight });
+        callFirst(renderer, ["setClipWeight", "setWeight"], clipName, nextWeight);
+        emitState(renderer, state);
+      },
+      setPlaybackRate: (rate) => {
+        const nextRate = Math.max(0, numberOr(rate, 1));
+        updateHandle(clipName, (handle) => ({ ...handle, rate: nextRate }));
+        emitCommand(renderer, "setPlaybackRate", clipName, { rate: nextRate });
+        callFirst(renderer, ["setClipPlaybackRate", "setPlaybackRate"], clipName, nextRate);
+        emitState(renderer, state);
+      },
+      setLoop: (mode, repeatCount) => {
+        const nextMode = LOOP_MODES.has(mode) ? mode : "repeat";
+        updateHandle(clipName, (handle) => ({
+          ...handle,
+          loopMode: nextMode,
+          loop: nextMode !== "once",
+          repeatCount
+        }));
+        emitCommand(renderer, "setLoop", clipName, { loopMode: nextMode, repeatCount });
+        callFirst(renderer, ["setClipLoop", "setLoop"], clipName, nextMode, repeatCount);
+        emitState(renderer, state);
+      },
+      setTime: (time) => {
+        const duration = state.handles[clipName]?.duration ?? 0;
+        const nextTime = clamp(0, duration, time);
+        updateHandle(clipName, (handle) => ({ ...handle, time: nextTime }));
+        emitCommand(renderer, "setTime", clipName, { time: nextTime });
+        callFirst(renderer, ["setClipTime", "setTime"], clipName, nextTime);
+        emitState(renderer, state);
+      },
+      getTime: () => {
+        const rendererTime = callFirst(renderer, ["getClipTime", "getTime"], clipName);
+        return numberOr(rendererTime, state.handles[clipName]?.time ?? 0);
+      },
+      getDuration: () => {
+        const rendererDuration = callFirst(renderer, ["getClipDuration", "getDuration"], clipName);
+        return numberOr(rendererDuration, state.handles[clipName]?.duration ?? 0);
+      },
+      subscribe: (listener) => {
+        const clipListeners = listeners.get(clipName) ?? /* @__PURE__ */ new Set();
+        clipListeners.add(listener);
+        listeners.set(clipName, clipListeners);
+        return () => {
+          clipListeners.delete(listener);
+        };
+      },
+      finished
+    };
+  };
+  const acceptClipEvent = (event) => {
+    const eventRecord = isRecord(event) ? event : {};
+    const clipName = keyToString(eventRecord.clipName ?? eventRecord.name);
+    if (!clipName) return true;
+    const eventType = keyToString(eventRecord.type ?? eventRecord.event);
+    const currentTime = numberOr(
+      eventRecord.currentTime,
+      numberOr(eventRecord.time, state.handles[clipName]?.time ?? 0)
+    );
+    if (["time", "progress", "frame", "keyframe", "seek", "loop"].includes(eventType)) {
+      updateHandle(clipName, (handle) => ({ ...handle, time: currentTime }));
+    } else if (eventType === "paused") {
+      updateHandle(clipName, (handle) => ({ ...handle, status: "paused" }));
+    } else if (["resumed", "started", "played"].includes(eventType)) {
+      updateHandle(clipName, (handle) => ({ ...handle, status: "playing" }));
+    } else if (["completed", "finished"].includes(eventType)) {
+      updateHandle(clipName, (handle) => ({
+        ...handle,
+        status: "completed",
+        time: handle.duration
+      }));
+      resolveFinished(clipName);
+    } else if (["stopped", "removed"].includes(eventType)) {
+      updateHandle(clipName, (handle) => ({ ...handle, status: "stopped" }));
+      resolveFinished(clipName);
+    }
+    state.eventCount += 1;
+    state.lastEvent = { ...eventRecord, timestamp: nowMs() };
+    notifyListeners(clipName, event);
+    emitState(renderer, state);
+    return true;
+  };
+  const buildClip = (clipNameInput, curvesInput, optionsInput) => {
+    const clipName = keyToString(clipNameInput);
+    if (!clipName) return null;
+    const curves = normalizeCurves(curvesInput);
+    const options = normalizeOptions(optionsInput);
+    const connectorResult = callFirst(renderer, ["buildClip", "playClip"], clipName, curves, options);
+    if (connectorResult == null || connectorResult === false) {
+      return null;
+    }
+    const result = isRecord(connectorResult) ? connectorResult : {};
+    const duration = calculateDuration(curves, result.duration);
+    const handleState = {
+      clipName,
+      actionId: keyToString(result.actionId ?? result.id) || makeActionId(clipName),
+      duration,
+      time: numberOr(result.time, options.startTime),
+      weight: options.weight,
+      rate: options.rate,
+      loopMode: options.loopMode,
+      loop: options.loop,
+      repeatCount: options.repeatCount,
+      reverse: options.reverse,
+      source: options.source,
+      status: "playing",
+      createdAt: nowMs(),
+      updatedAt: nowMs()
+    };
+    upsertHandle(handleState);
+    emitCommand(renderer, "buildClip", clipName, {
+      actionId: handleState.actionId,
+      duration: handleState.duration,
+      options
+    });
+    emitState(renderer, state);
+    return makeHandle(clipName);
+  };
+  return {
+    snapshot: () => snapshotState(state),
+    buildClip,
+    playSnippet: (clipName, curves, options) => buildClip(clipName, curves, { ...options, source: options?.source ?? "snippet" }),
+    acceptClipEvent,
+    cleanupSnippet: (clipNameInput) => {
+      const clipName = keyToString(clipNameInput);
+      if (!clipName) return false;
+      removeHandle(clipName);
+      emitCommand(renderer, "cleanupSnippet", clipName);
+      callFirst(renderer, ["cleanupSnippet", "removeClip"], clipName);
+      emitState(renderer, state);
+      return true;
+    },
+    updateClipParams: (clipNameInput, params) => {
+      const clipName = keyToString(clipNameInput);
+      if (!clipName) return false;
+      const source = isRecord(params) ? params : {};
+      updateHandle(clipName, (handle) => ({
+        ...handle,
+        weight: finiteNumber(source.weight) ? Math.max(0, source.weight) : handle.weight,
+        rate: finiteNumber(source.rate) ? Math.max(0, source.rate) : handle.rate,
+        loopMode: typeof source.loopMode === "string" && LOOP_MODES.has(source.loopMode) ? source.loopMode : handle.loopMode,
+        loop: typeof source.loop === "boolean" ? source.loop : handle.loop,
+        repeatCount: finiteNumber(source.repeatCount) ? source.repeatCount : handle.repeatCount,
+        reverse: typeof source.reverse === "boolean" ? source.reverse : handle.reverse
+      }));
+      emitCommand(renderer, "updateClipParams", clipName, { params: source });
+      const result = callFirst(renderer, ["updateClipParams"], clipName, source);
+      emitState(renderer, state);
+      return result === false ? false : true;
+    }
+  };
+}
+function installEmbody(target = globalThis) {
+  target.createAnimationRuntime = createAnimationRuntime;
+  return { createAnimationRuntime };
+}
+
+exports.createAnimationRuntime = createAnimationRuntime;
+exports.installEmbody = installEmbody;
+//# sourceMappingURL=cljs.cjs.map
+//# sourceMappingURL=cljs.cjs.map