@lovelace_lol/embody 0.0.1

package/dist/core.js

@@ -0,0 +1,1040 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/core/contracts/abi.ts
+var PACKED_MORPH_FRAME_DELTA_STRIDE = 4;
+var PACKED_BONE_FRAME_DELTA_STRIDE = 9;
+var PACKED_BONE_FLAG_HAS_POSITION = 1;
+var PACKED_BONE_FLAG_HAS_ROTATION = 2;
+var TEMPLATE_SKELETON_FIT_TRANSFORM_STRIDE = 4;
+var MESH_PROPORTIONS_STRIDE = 16;
+var TEMPLATE_SKELETON_FIT_SOLUTION_STRIDE = 10;
+var TEMPLATE_SKELETON_FIT_TRANSFORM_FIELDS = [
+  "scale",
+  "translationX",
+  "translationY",
+  "translationZ"
+];
+var MESH_PROPORTIONS_FIELDS = [
+  "minX",
+  "minY",
+  "minZ",
+  "maxX",
+  "maxY",
+  "maxZ",
+  "centerX",
+  "centerY",
+  "centerZ",
+  "spanX",
+  "spanY",
+  "spanZ",
+  "verticalHeight",
+  "crossAxisWideSpan",
+  "crossAxisNarrowSpan",
+  "humanoidLikelihood"
+];
+var TEMPLATE_SKELETON_FIT_SOLUTION_FIELDS = [
+  "scale",
+  "translationX",
+  "translationY",
+  "translationZ",
+  "confidence",
+  "meshHeight",
+  "templateHeight",
+  "meshCrossAxisWideSpan",
+  "templateCrossAxisWideSpan",
+  "status"
+];
+
+// src/core/contracts/skeletonFit.ts
+var TEMPLATE_SKELETON_FIT_METADATA_KIND = "template-skeleton-fit";
+var TEMPLATE_SKELETON_FIT_METADATA_VERSION = 1;
+var TEMPLATE_SKELETON_FIT_STATUSES = [
+  "unfitted",
+  "estimated",
+  "manual-adjusted",
+  "invalid"
+];
+var TEMPLATE_SKELETON_FIT_VERTICAL_AXES = ["x", "y", "z"];
+var TEMPLATE_SKELETON_FIT_VERTICAL_ANCHORS = ["min", "center", "max"];
+function isTemplateSkeletonFitStatus(value) {
+  return typeof value === "string" && TEMPLATE_SKELETON_FIT_STATUSES.includes(value);
+}
+function composeTemplateSkeletonFitTransform(fit, manualAdjustment = {}) {
+  return {
+    scale: positiveFiniteOr(fit.scale, 1) * positiveFiniteOr(manualAdjustment.scale ?? 1, 1),
+    translation: {
+      x: finiteOr(fit.translation.x, 0) + finiteOr(manualAdjustment.translation?.x ?? 0, 0),
+      y: finiteOr(fit.translation.y, 0) + finiteOr(manualAdjustment.translation?.y ?? 0, 0),
+      z: finiteOr(fit.translation.z, 0) + finiteOr(manualAdjustment.translation?.z ?? 0, 0)
+    }
+  };
+}
+function validateTemplateSkeletonFitMetadata(metadata) {
+  const errors = [];
+  if (!isRecord(metadata)) {
+    return { valid: false, errors: ["metadata must be an object"] };
+  }
+  if (metadata.kind !== TEMPLATE_SKELETON_FIT_METADATA_KIND) {
+    errors.push(`kind must be "${TEMPLATE_SKELETON_FIT_METADATA_KIND}"`);
+  }
+  if (metadata.version !== TEMPLATE_SKELETON_FIT_METADATA_VERSION) {
+    errors.push(`version must be ${TEMPLATE_SKELETON_FIT_METADATA_VERSION}`);
+  }
+  if (!isNonEmptyString(metadata.templateId)) {
+    errors.push("templateId must be a non-empty string");
+  }
+  if (!isNonEmptyString(metadata.sourceCharacterId)) {
+    errors.push("sourceCharacterId must be a non-empty string");
+  }
+  if (!TEMPLATE_SKELETON_FIT_VERTICAL_AXES.includes(metadata.verticalAxis)) {
+    errors.push(`verticalAxis must be one of: ${TEMPLATE_SKELETON_FIT_VERTICAL_AXES.join(", ")}`);
+  }
+  if (!TEMPLATE_SKELETON_FIT_VERTICAL_ANCHORS.includes(metadata.verticalAnchor)) {
+    errors.push(`verticalAnchor must be one of: ${TEMPLATE_SKELETON_FIT_VERTICAL_ANCHORS.join(", ")}`);
+  }
+  validateFitMetrics(metadata.fit, errors);
+  validateManualAdjustment(metadata.manualAdjustment, errors);
+  return { valid: errors.length === 0, errors };
+}
+function validateFitMetrics(value, errors) {
+  if (!isRecord(value)) {
+    errors.push("fit must be an object");
+    return;
+  }
+  if (!isPositiveFiniteNumber(value.scale)) {
+    errors.push("fit.scale must be a positive finite number");
+  }
+  validateVec3(value.translation, "fit.translation", errors);
+  if (!isFiniteNumber(value.confidence) || value.confidence < 0 || value.confidence > 1) {
+    errors.push("fit.confidence must be a finite number between 0 and 1");
+  }
+  if (!isPositiveFiniteNumber(value.meshHeight)) {
+    errors.push("fit.meshHeight must be a positive finite number");
+  }
+  if (!isPositiveFiniteNumber(value.templateHeight)) {
+    errors.push("fit.templateHeight must be a positive finite number");
+  }
+  validateVec3(value.crossAxisSpans, "fit.crossAxisSpans", errors, { min: 0 });
+  if (!isTemplateSkeletonFitStatus(value.status)) {
+    errors.push(`fit.status must be one of: ${TEMPLATE_SKELETON_FIT_STATUSES.join(", ")}`);
+  }
+}
+function validateManualAdjustment(value, errors) {
+  if (value == null) {
+    return;
+  }
+  if (!isRecord(value)) {
+    errors.push("manualAdjustment must be an object");
+    return;
+  }
+  if (value.scale != null && !isPositiveFiniteNumber(value.scale)) {
+    errors.push("manualAdjustment.scale must be a positive finite number");
+  }
+  if (value.translation != null) {
+    validateVec3(value.translation, "manualAdjustment.translation", errors);
+  }
+}
+function validateVec3(value, field, errors, options = {}) {
+  if (!isRecord(value)) {
+    errors.push(`${field} must be an object with finite x, y, and z values`);
+    return;
+  }
+  for (const axis of ["x", "y", "z"]) {
+    const axisValue = value[axis];
+    if (!isFiniteNumber(axisValue)) {
+      errors.push(`${field}.${axis} must be a finite number`);
+    } else if (options.min != null && axisValue < options.min) {
+      errors.push(`${field}.${axis} must be a finite number >= ${options.min}`);
+    }
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value != null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isPositiveFiniteNumber(value) {
+  return isFiniteNumber(value) && value > 0;
+}
+function finiteOr(value, fallback) {
+  return Number.isFinite(value) ? value : fallback;
+}
+function positiveFiniteOr(value, fallback) {
+  return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+
+// src/core/TsClipCompiler.ts
+var TsClipCompiler = class {
+  constructor(core) {
+    this.core = core;
+  }
+  compile(input) {
+    return JSON.parse(this.core.compile_clip(JSON.stringify(input)));
+  }
+  compileCurves(input) {
+    return JSON.parse(this.core.compile_clip_curves(JSON.stringify(input)));
+  }
+};
+function numericArrayToNumbers(values) {
+  return Array.from(values);
+}
+
+// src/core/compositeAxis.ts
+function toAUList(value) {
+  if (value === void 0) return [];
+  return Array.isArray(value) ? value : [value];
+}
+function findBoneBindingForNode(auToBones, auId, nodeKey) {
+  return auToBones[auId]?.find((candidate) => candidate.node === nodeKey) ?? null;
+}
+function getCompositeAxisValue(axisConfig, getValue) {
+  if (!axisConfig) return 0;
+  const negativeAUs = toAUList(axisConfig.negative);
+  const positiveAUs = toAUList(axisConfig.positive);
+  if (negativeAUs.length > 0 && positiveAUs.length > 0) {
+    const negativeValue = Math.max(...negativeAUs.map(getValue), 0);
+    const positiveValue = Math.max(...positiveAUs.map(getValue), 0);
+    return positiveValue - negativeValue;
+  }
+  if (axisConfig.aus.length > 1) {
+    return Math.max(...axisConfig.aus.map(getValue), 0);
+  }
+  return getValue(axisConfig.aus[0]);
+}
+function getCompositeAxisBinding(nodeKey, axisConfig, direction, getValue, auToBones) {
+  if (!axisConfig) return null;
+  const directionalAUs = direction < 0 ? toAUList(axisConfig.negative) : toAUList(axisConfig.positive);
+  const candidates = directionalAUs.length > 0 ? directionalAUs : axisConfig.aus;
+  const ranked = [...candidates].sort((a, b) => getValue(b) - getValue(a));
+  for (const auId of ranked) {
+    const binding = findBoneBindingForNode(auToBones, auId, nodeKey);
+    if (binding) return binding;
+  }
+  return null;
+}
+
+// src/mappings/visemeSystem.ts
+function hasOwn(value, key) {
+  return Boolean(value && Object.prototype.hasOwnProperty.call(value, key));
+}
+function toSlotId(label, index) {
+  const normalized = label.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return normalized || `viseme-${index}`;
+}
+function normalizeBindingWeight(weight) {
+  return Number.isFinite(weight) ? Math.max(0, weight ?? 1) : 1;
+}
+function getProfileVisemeSlots(profile) {
+  if (profile.visemeSlots && profile.visemeSlots.length > 0) {
+    return [...profile.visemeSlots].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  }
+  return (profile.visemeKeys || []).map((key, index) => {
+    const label = typeof key === "string" && key ? key : `Viseme ${index}`;
+    return {
+      id: toSlotId(label, index),
+      label,
+      order: index,
+      defaultJawAmount: profile.visemeJawAmounts?.[index]
+    };
+  });
+}
+function getVisemeSlotIndex(profile, slotId) {
+  return getProfileVisemeSlots(profile).findIndex((slot) => slot.id === slotId);
+}
+function getVisemeBindingTargets(profile, visemeIndex) {
+  const slots = getProfileVisemeSlots(profile);
+  const slot = slots[visemeIndex];
+  const binding = slot ? profile.visemeBindings?.[slot.id] : void 0;
+  const boundTargets = binding?.targets?.filter((target) => target.morph !== void 0 && target.morph !== "").map((target) => ({
+    morph: target.morph,
+    weight: normalizeBindingWeight(target.weight)
+  }));
+  if (boundTargets && boundTargets.length > 0) {
+    return boundTargets;
+  }
+  if (binding?.morph !== void 0 && binding.morph !== "") {
+    return [{ morph: binding.morph, weight: 1 }];
+  }
+  const legacyTarget = profile.visemeKeys?.[visemeIndex];
+  return legacyTarget !== void 0 && legacyTarget !== "" ? [{ morph: legacyTarget, weight: 1 }] : [];
+}
+function getVisemeJawAmounts(profile) {
+  const slots = getProfileVisemeSlots(profile);
+  if (slots.length === 0) return profile.visemeJawAmounts ? [...profile.visemeJawAmounts] : void 0;
+  return slots.map((slot, index) => slot.defaultJawAmount ?? profile.visemeJawAmounts?.[index] ?? 0);
+}
+function resolveVisemeMeshCategory(profile) {
+  const morphToMesh = profile.morphToMesh || {};
+  if (profile.visemeMeshCategory) return profile.visemeMeshCategory;
+  if (hasOwn(morphToMesh, "viseme")) return "viseme";
+  return "face";
+}
+function getMeshNamesForVisemeProfile(profile) {
+  const morphToMesh = profile.morphToMesh || {};
+  const category = resolveVisemeMeshCategory(profile);
+  if (hasOwn(morphToMesh, category)) {
+    return Array.isArray(morphToMesh[category]) ? [...morphToMesh[category]] : [];
+  }
+  return profile.visemeMeshCategory ? [] : [...morphToMesh.face || []];
+}
+function getMeshNamesForAUProfile(profile, auId) {
+  const morphToMesh = profile.morphToMesh || {};
+  const facePart = profile.auInfo?.[String(auId)]?.facePart;
+  const category = facePart ? profile.auFacePartToMeshCategory?.[facePart] : void 0;
+  if (category) return Array.isArray(morphToMesh[category]) ? [...morphToMesh[category]] : [];
+  return [...morphToMesh.face || []];
+}
+
+// src/core/TsRuntimeCore.ts
+var identityQuat = { x: 0, y: 0, z: 0, w: 1 };
+function isRotationBoneBinding(binding) {
+  return binding?.channel === "rx" || binding?.channel === "ry" || binding?.channel === "rz";
+}
+var TsRuntimeCore = class {
+  constructor(options) {
+    __publicField(this, "profile");
+    __publicField(this, "model");
+    __publicField(this, "auValues", {});
+    __publicField(this, "auBalances", {});
+    __publicField(this, "visemeValues");
+    __publicField(this, "visemeJawScales");
+    __publicField(this, "mixWeights");
+    this.profile = options.profile;
+    this.model = options.model;
+    this.visemeValues = new Array(getProfileVisemeSlots(this.profile).length).fill(0);
+    this.visemeJawScales = new Array(this.visemeValues.length).fill(1);
+    this.mixWeights = { ...this.profile.auMixDefaults };
+  }
+  setProfile(profile) {
+    this.profile = profile;
+    this.visemeValues = new Array(getProfileVisemeSlots(this.profile).length).fill(0);
+    this.visemeJawScales = new Array(this.visemeValues.length).fill(1);
+    this.mixWeights = { ...this.profile.auMixDefaults };
+  }
+  setModelDescriptor(model) {
+    this.model = model;
+  }
+  setAU(id, value, balance) {
+    if (value < 0 && this.profile.continuumPairs) {
+      const pairInfo = this.profile.continuumPairs[id];
+      if (pairInfo) {
+        const negAU = pairInfo.isNegative ? id : pairInfo.pairId;
+        const posAU = pairInfo.isNegative ? pairInfo.pairId : id;
+        this.setContinuum(negAU, posAU, pairInfo.isNegative ? -value : value, balance);
+        return;
+      }
+    }
+    this.auValues[id] = clamp01(value);
+    if (balance !== void 0) {
+      this.auBalances[id] = clampBalance(balance);
+    }
+  }
+  getAU(id) {
+    return this.auValues[id] ?? 0;
+  }
+  setContinuum(negAU, posAU, continuumValue, balance) {
+    const value = Math.max(-1, Math.min(1, continuumValue));
+    if (value < 0) {
+      this.setAU(posAU, 0, balance);
+      this.setAU(negAU, Math.abs(value), balance);
+      return;
+    }
+    if (value > 0) {
+      this.setAU(negAU, 0, balance);
+      this.setAU(posAU, value, balance);
+      return;
+    }
+    this.setAU(negAU, 0, balance);
+    this.setAU(posAU, 0, balance);
+  }
+  setViseme(visemeIndex, value, jawScale = 1) {
+    if (visemeIndex < 0 || visemeIndex >= this.visemeValues.length) return;
+    this.visemeValues[visemeIndex] = clamp01(value);
+    this.visemeJawScales[visemeIndex] = jawScale;
+  }
+  setVisemeById(slotId, value, jawScale = 1) {
+    const index = getVisemeSlotIndex(this.profile, slotId);
+    if (index < 0) return;
+    this.setViseme(index, value, jawScale);
+  }
+  setAUMixWeight(id, weight) {
+    this.mixWeights[id] = clamp01(weight);
+  }
+  evaluateFrameDelta(deltaSeconds) {
+    const morphWrites = /* @__PURE__ */ new Map();
+    this.collectAUWrites(morphWrites);
+    this.collectVisemeWrites(morphWrites);
+    return {
+      deltaSeconds,
+      morphTargets: Array.from(morphWrites.values()),
+      bones: this.collectBoneWrites()
+    };
+  }
+  collectAUWrites(morphWrites) {
+    for (const [auIdText, entry] of Object.entries(this.profile.auToMorphs || {})) {
+      const auId = Number(auIdText);
+      if (Number.isNaN(auId) || !entry) continue;
+      const mixWeight = this.isMixedAU(auId) ? this.getAUMixWeight(auId) : 1;
+      const base = clamp01(this.auValues[auId] ?? 0) * mixWeight;
+      const { left, right } = computeSideValues(base, this.auBalances[auId]);
+      const meshNames = getMeshNamesForAUProfile(this.profile, auId);
+      for (const morph of entry.left || []) {
+        this.addMorphWrites(morphWrites, morph, meshNames, left);
+      }
+      for (const morph of entry.right || []) {
+        this.addMorphWrites(morphWrites, morph, meshNames, right);
+      }
+      for (const morph of entry.center || []) {
+        this.addMorphWrites(morphWrites, morph, meshNames, base);
+      }
+    }
+  }
+  collectVisemeWrites(morphWrites) {
+    const meshNames = getMeshNamesForVisemeProfile(this.profile);
+    const localMax = /* @__PURE__ */ new Map();
+    for (let index = 0; index < this.visemeValues.length; index += 1) {
+      const value = clamp01(this.visemeValues[index] ?? 0);
+      for (const bindingTarget of getVisemeBindingTargets(this.profile, index)) {
+        const weighted = clamp01(value * bindingTarget.weight);
+        for (const resolved of this.resolveMorphTargets(bindingTarget.morph, meshNames)) {
+          const key = morphWriteKey(resolved.mesh.id, resolved.morphTarget.id);
+          const existing = localMax.get(key);
+          if (!existing || weighted > existing.value) {
+            localMax.set(key, {
+              meshId: resolved.mesh.id,
+              morphTargetId: resolved.morphTarget.id,
+              value: weighted,
+              mode: "absolute"
+            });
+          }
+        }
+      }
+    }
+    for (const [key, write] of localMax) {
+      const existing = morphWrites.get(key);
+      if (!existing || write.value > existing.value) {
+        morphWrites.set(key, write);
+      }
+    }
+  }
+  collectBoneWrites() {
+    const writes = [];
+    const rotations = this.computeRotationState();
+    for (const composite of this.profile.compositeRotations || []) {
+      const bone = this.findBoneDescriptor(composite.node);
+      if (!bone) continue;
+      const transform = this.evaluateCompositeTransform(bone, composite, rotations[composite.node]);
+      if (transform) {
+        writes.push({
+          boneId: bone.id,
+          transform,
+          mode: "absolute",
+          space: "local"
+        });
+      }
+    }
+    for (const [nodeKey, translation] of Object.entries(this.computeTranslations())) {
+      const bone = this.findBoneDescriptor(nodeKey);
+      if (!bone) continue;
+      const position = addVec3(bone.restTransform?.position, translation);
+      upsertBoneWrite(writes, bone.id, { position });
+    }
+    const jawAmount = this.getActiveVisemeJawAmount();
+    const jawBinding = this.findAutoVisemeJawBinding();
+    const jawBone = jawBinding ? this.findBoneDescriptor(jawBinding.node) : void 0;
+    if (jawBone && jawBinding?.maxDegrees && jawBinding.channel) {
+      const current = writes.find((write) => write.boneId === jawBone.id);
+      if (jawAmount > 1e-6 || !current?.transform.rotation) {
+        const rest = jawBone.restTransform?.rotation ?? identityQuat;
+        const rotation = jawAmount > 1e-6 ? multiplyQuat(
+          rest,
+          quatFromChannel(jawBinding.channel, deg2rad(jawBinding.maxDegrees) * jawAmount * jawBinding.scale)
+        ) : rest;
+        upsertBoneWrite(writes, jawBone.id, { rotation });
+      }
+    }
+    return writes;
+  }
+  computeRotationState() {
+    const rotations = {};
+    for (const composite of this.profile.compositeRotations || []) {
+      rotations[composite.node] = {
+        pitch: this.getCompositeAxisValueForNode(composite.node, composite.pitch),
+        yaw: this.getCompositeAxisValueForNode(composite.node, composite.yaw),
+        roll: this.getCompositeAxisValueForNode(composite.node, composite.roll)
+      };
+    }
+    return rotations;
+  }
+  evaluateCompositeTransform(bone, composite, state) {
+    if (!state) return null;
+    let rotation = bone.restTransform?.rotation ?? identityQuat;
+    const applyAxis = (axisConfig, direction) => {
+      if (!axisConfig || Math.abs(direction) <= 1e-6) return;
+      const binding = getCompositeAxisBinding(
+        composite.node,
+        axisConfig,
+        direction,
+        (auId) => this.getEffectiveBoneAUValue(auId, composite.node),
+        this.profile.auToBones
+      );
+      if (!binding?.maxDegrees || !binding.channel) return;
+      rotation = multiplyQuat(
+        rotation,
+        quatFromChannel(binding.channel, deg2rad(binding.maxDegrees) * Math.abs(direction) * binding.scale)
+      );
+    };
+    applyAxis(composite.yaw, state.yaw);
+    applyAxis(composite.pitch, state.pitch);
+    applyAxis(composite.roll, state.roll);
+    return { rotation };
+  }
+  computeTranslations() {
+    const translations = {};
+    for (const [auIdText, bindings] of Object.entries(this.profile.auToBones || {})) {
+      const auId = Number(auIdText);
+      if (Number.isNaN(auId)) continue;
+      const value = clamp01(this.auValues[auId] ?? 0);
+      for (const binding of bindings || []) {
+        if (binding.channel !== "tx" && binding.channel !== "ty" && binding.channel !== "tz") continue;
+        if (binding.maxUnits === void 0) continue;
+        const current = translations[binding.node] ?? { x: 0, y: 0, z: 0 };
+        translations[binding.node] = current;
+        if (value <= 1e-6) continue;
+        const offset = clampSigned(value * binding.scale) * binding.maxUnits;
+        translations[binding.node] = {
+          x: binding.channel === "tx" ? offset : current.x,
+          y: binding.channel === "ty" ? offset : current.y,
+          z: binding.channel === "tz" ? offset : current.z
+        };
+      }
+    }
+    return translations;
+  }
+  addMorphWrites(morphWrites, morph, meshNames, value) {
+    for (const resolved of this.resolveMorphTargets(morph, meshNames)) {
+      const key = morphWriteKey(resolved.mesh.id, resolved.morphTarget.id);
+      const existing = morphWrites.get(key);
+      if (existing && existing.value >= value) continue;
+      morphWrites.set(key, {
+        meshId: resolved.mesh.id,
+        morphTargetId: resolved.morphTarget.id,
+        value,
+        mode: "absolute"
+      });
+    }
+  }
+  resolveMorphTargets(morph, meshNames) {
+    const result = [];
+    for (const meshName of meshNames) {
+      const mesh = this.model.meshes.find((candidate) => candidate.name === meshName);
+      if (!mesh) continue;
+      const morphTargets = mesh.morphTargetIds.map((id) => this.model.morphTargets.find((candidate) => candidate.id === id)).filter((target2) => !!target2);
+      const target = typeof morph === "number" ? morphTargets.find((candidate) => candidate.hostIndex === morph) : resolveMorphTargetByName(morphTargets, morph, this.profile);
+      if (target) {
+        result.push({ mesh, morphTarget: target });
+      }
+    }
+    return result;
+  }
+  findBoneDescriptor(nodeKey) {
+    const configuredName = this.profile.boneNodes[nodeKey] || nodeKey;
+    const prefix = this.profile.bonePrefix ?? "";
+    const suffix = this.profile.boneSuffix ?? "";
+    const prefixedName = prefix && !configuredName.startsWith(prefix) ? `${prefix}${configuredName}` : configuredName;
+    const fullName = suffix && !prefixedName.endsWith(suffix) ? `${prefixedName}${suffix}` : prefixedName;
+    const candidates = /* @__PURE__ */ new Set([nodeKey, configuredName, fullName]);
+    return this.model.bones.find((bone) => candidates.has(bone.name));
+  }
+  findAutoVisemeJawBinding() {
+    const candidates = [
+      this.profile.auToBones[103]?.find(isRotationBoneBinding),
+      this.profile.auToBones[26]?.find(isRotationBoneBinding)
+    ].filter((binding) => !!binding);
+    return candidates.find((binding) => !!this.findBoneDescriptor(binding.node)) ?? candidates[0] ?? null;
+  }
+  getActiveVisemeJawAmount() {
+    const jawAmounts = getVisemeJawAmounts(this.profile) ?? [];
+    let jawAmount = 0;
+    for (let index = 0; index < this.visemeValues.length; index += 1) {
+      const value = clamp01(this.visemeValues[index] ?? 0);
+      if (value <= 1e-6) continue;
+      const jawScale = this.visemeJawScales[index] ?? 1;
+      if (Math.abs(jawScale) <= 1e-6) continue;
+      jawAmount = Math.max(jawAmount, (jawAmounts[index] ?? 0) * value * jawScale);
+    }
+    return jawAmount;
+  }
+  getCompositeAxisValueForNode(nodeKey, axisConfig) {
+    return getCompositeAxisValue(axisConfig, (auId) => this.getEffectiveBoneAUValue(auId, nodeKey));
+  }
+  getEffectiveBoneAUValue(auId, nodeKey) {
+    const rawValue = clamp01(this.auValues[auId] ?? 0);
+    if (rawValue <= 1e-6) return 0;
+    const binding = this.profile.auToBones[auId]?.find((candidate) => candidate.node === nodeKey) ?? null;
+    if (!binding?.side) return rawValue;
+    return rawValue * getSideScale(this.auBalances[auId] ?? 0, binding.side);
+  }
+  getAUMixWeight(auId) {
+    return this.mixWeights[auId] ?? this.profile.auMixDefaults?.[auId] ?? 1;
+  }
+  isMixedAU(auId) {
+    const morphs = this.profile.auToMorphs[auId];
+    const hasMorphs = !!(morphs?.left?.length || morphs?.right?.length || morphs?.center?.length);
+    return !!(hasMorphs && this.profile.auToBones[auId]?.length);
+  }
+};
+function resolveMorphTargetByName(targets, key, profile) {
+  const prefix = profile.morphPrefix || "";
+  const suffix = profile.morphSuffix || "";
+  const fullName = prefix + key + suffix;
+  const exact = targets.find((target) => target.name === fullName);
+  if (exact) return exact;
+  const suffixRegex = profile.suffixPattern ? new RegExp(profile.suffixPattern) : null;
+  if (!suffixRegex) return void 0;
+  return targets.find((target) => {
+    if (!target.name.startsWith(fullName)) return false;
+    const candidateSuffix = target.name.slice(fullName.length);
+    return candidateSuffix === "" || suffixRegex.test(candidateSuffix);
+  });
+}
+function computeSideValues(base, balance) {
+  const b = clampBalance(balance ?? 0);
+  if (b === 0) return { left: base, right: base };
+  if (b < 0) return { left: base, right: base * (1 + b) };
+  return { left: base * (1 - b), right: base };
+}
+function getSideScale(balance, side) {
+  if (side !== "left" && side !== "right") return 1;
+  const b = clampBalance(balance);
+  if (side === "left") return b > 0 ? 1 - b : 1;
+  return b < 0 ? 1 + b : 1;
+}
+function addVec3(base, offset) {
+  return {
+    x: (base?.x ?? 0) + offset.x,
+    y: (base?.y ?? 0) + offset.y,
+    z: (base?.z ?? 0) + offset.z
+  };
+}
+function upsertBoneWrite(writes, boneId, transform) {
+  const existingIndex = writes.findIndex((write) => write.boneId === boneId);
+  if (existingIndex >= 0) {
+    const existing = writes[existingIndex];
+    writes[existingIndex] = {
+      ...existing,
+      transform: {
+        ...existing.transform,
+        ...transform
+      }
+    };
+    return;
+  }
+  writes.push({
+    boneId,
+    transform,
+    mode: "absolute",
+    space: "local"
+  });
+}
+function quatFromChannel(channel, radians) {
+  if (channel === "rx") return quatFromAxis({ x: 1, y: 0, z: 0 }, radians);
+  if (channel === "ry") return quatFromAxis({ x: 0, y: 1, z: 0 }, radians);
+  return quatFromAxis({ x: 0, y: 0, z: 1 }, radians);
+}
+function quatFromAxis(axis, radians) {
+  const half = radians / 2;
+  const s = Math.sin(half);
+  return normalizeQuat({
+    x: axis.x * s,
+    y: axis.y * s,
+    z: axis.z * s,
+    w: Math.cos(half)
+  });
+}
+function multiplyQuat(a, b) {
+  return normalizeQuat({
+    x: a.w * b.x + a.x * b.w + a.y * b.z - a.z * b.y,
+    y: a.w * b.y - a.x * b.z + a.y * b.w + a.z * b.x,
+    z: a.w * b.z + a.x * b.y - a.y * b.x + a.z * b.w,
+    w: a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z
+  });
+}
+function normalizeQuat(q) {
+  const len = Math.hypot(q.x, q.y, q.z, q.w);
+  if (len <= 1e-12) return identityQuat;
+  return {
+    x: q.x / len,
+    y: q.y / len,
+    z: q.z / len,
+    w: q.w / len
+  };
+}
+function deg2rad(degrees) {
+  return degrees * Math.PI / 180;
+}
+function clamp01(value) {
+  if (!Number.isFinite(value)) return 0;
+  return value < 0 ? 0 : value > 1 ? 1 : value;
+}
+function clampSigned(value) {
+  if (!Number.isFinite(value)) return 0;
+  return value < -1 ? -1 : value > 1 ? 1 : value;
+}
+function clampBalance(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(-1, Math.min(1, value));
+}
+function morphWriteKey(meshId, morphTargetId) {
+  return `${meshId}:${morphTargetId}`;
+}
+
+// src/core/WasmRuntimeCore.ts
+var AU_MORPH_BINDING_STRIDE = 5;
+var VISEME_MORPH_BINDING_STRIDE = 4;
+var AXIS_GROUP_NEGATIVE = 0;
+var AXIS_GROUP_POSITIVE = 1;
+var AXIS_GROUP_PLAIN = 2;
+var BONE_SIDE_NONE = 0;
+var BONE_SIDE_LEFT = 1;
+var BONE_SIDE_RIGHT = 2;
+var ROTATION_CHANNELS = { rx: 0, ry: 1, rz: 2 };
+var TRANSLATION_CHANNELS = { tx: 0, ty: 1, tz: 2 };
+var WasmRuntimeCore = class {
+  constructor(options) {
+    __publicField(this, "wasm");
+    __publicField(this, "core");
+    __publicField(this, "profile");
+    __publicField(this, "model");
+    this.wasm = options.wasm;
+    this.profile = options.profile;
+    this.model = options.model;
+    const RuntimeCtor = options.wasm.RuntimeCore;
+    if (!RuntimeCtor) {
+      throw new Error("Embody Wasm module does not export RuntimeCore");
+    }
+    this.core = new RuntimeCtor(getProfileVisemeSlots(options.profile).length);
+    this.reloadBindings();
+  }
+  setProfile(profile) {
+    this.profile = profile;
+    this.core.set_viseme_slot_count(getProfileVisemeSlots(profile).length);
+    this.reloadBindings();
+  }
+  setModelDescriptor(model) {
+    this.model = model;
+    this.reloadBindings();
+  }
+  setAU(id, value, balance = 0) {
+    this.core.set_au(id >>> 0, value, balance);
+  }
+  getAU(id) {
+    return this.core.get_au(id >>> 0);
+  }
+  setAUMixWeight(id, weight) {
+    this.core.set_au_mix_weight(id >>> 0, weight);
+  }
+  setViseme(visemeIndex, value, jawScale) {
+    this.core.set_viseme(visemeIndex >>> 0, value);
+    if (jawScale !== void 0) {
+      this.core.set_viseme_jaw_scale(visemeIndex >>> 0, jawScale);
+    }
+  }
+  clear() {
+    this.core.clear();
+  }
+  evaluatePackedMorphFrameDelta() {
+    return this.core.evaluate_morph_frame_delta();
+  }
+  evaluatePackedBoneFrameDelta() {
+    return this.core.evaluate_bone_frame_delta();
+  }
+  evaluateMorphFrameDelta(deltaSeconds) {
+    return {
+      deltaSeconds,
+      morphTargets: unpackMorphFrameDelta(this.evaluatePackedMorphFrameDelta())
+    };
+  }
+  evaluateFrameDelta(deltaSeconds) {
+    return {
+      deltaSeconds,
+      morphTargets: unpackMorphFrameDelta(this.evaluatePackedMorphFrameDelta()),
+      bones: unpackBoneFrameDelta(this.evaluatePackedBoneFrameDelta())
+    };
+  }
+  reloadBindings() {
+    const { auBindings, mixedAus, visemeBindings } = compileMorphBindings(this.profile, this.model);
+    this.core.load_au_morph_bindings(auBindings);
+    this.core.load_viseme_morph_bindings(visemeBindings);
+    this.core.set_mixed_aus(mixedAus);
+    const boneBindings = compileBoneBindings(this.profile, this.model);
+    this.core.load_bone_rest_transforms(boneBindings.restTransforms);
+    this.core.load_composite_axes(boneBindings.compositeAxes);
+    this.core.load_bone_translations(boneBindings.translations);
+    this.core.load_jaw_binding(boneBindings.jawBinding);
+    this.core.load_viseme_jaw_amounts(boneBindings.visemeJawAmounts);
+  }
+};
+function compileMorphBindings(profile, model) {
+  const auRows = [];
+  const mixed = [];
+  for (const [auIdText, entry] of Object.entries(profile.auToMorphs || {})) {
+    const auId = Number(auIdText);
+    if (Number.isNaN(auId) || !entry) continue;
+    const meshNames = getMeshNamesForAUProfile(profile, auId);
+    const hasMorphs = !!(entry.left?.length || entry.right?.length || entry.center?.length);
+    if (hasMorphs && profile.auToBones?.[auId]?.length) {
+      mixed.push(auId);
+    }
+    pushAuSide(auRows, auId, 0, entry.left || [], meshNames, model, profile);
+    pushAuSide(auRows, auId, 1, entry.right || [], meshNames, model, profile);
+    pushAuSide(auRows, auId, 2, entry.center || [], meshNames, model, profile);
+  }
+  const visemeRows = [];
+  const visemeMeshNames = getMeshNamesForVisemeProfile(profile);
+  const slotCount = getProfileVisemeSlots(profile).length;
+  for (let index = 0; index < slotCount; index += 1) {
+    for (const bindingTarget of getVisemeBindingTargets(profile, index)) {
+      for (const resolved of resolveMorphTargets(model, profile, bindingTarget.morph, visemeMeshNames)) {
+        visemeRows.push(
+          index,
+          Number(resolved.mesh.id),
+          Number(resolved.morphTarget.id),
+          bindingTarget.weight
+        );
+      }
+    }
+  }
+  return {
+    auBindings: Float32Array.from(auRows),
+    visemeBindings: Float32Array.from(visemeRows),
+    mixedAus: Uint32Array.from(mixed)
+  };
+}
+function compileBoneBindings(profile, model) {
+  const referencedBones = /* @__PURE__ */ new Map();
+  const findBone = (nodeKey) => {
+    const bone = findBoneDescriptor(profile, model, nodeKey);
+    if (bone) referencedBones.set(bone.id, bone);
+    return bone;
+  };
+  const boneSideForAU = (auId, nodeKey) => {
+    const side = profile.auToBones?.[auId]?.find((candidate) => candidate.node === nodeKey)?.side;
+    if (side === "left") return BONE_SIDE_LEFT;
+    if (side === "right") return BONE_SIDE_RIGHT;
+    return BONE_SIDE_NONE;
+  };
+  const compositeRows = [];
+  for (const composite of profile.compositeRotations || []) {
+    const bone = findBone(composite.node);
+    if (!bone) continue;
+    const axes = [
+      { axis: 1, config: composite.yaw },
+      { axis: 0, config: composite.pitch },
+      { axis: 2, config: composite.roll }
+    ];
+    for (const { axis, config } of axes) {
+      if (!config) continue;
+      const negativeAUs = toAUList(config.negative);
+      const positiveAUs = toAUList(config.positive);
+      const hasDirectional = negativeAUs.length > 0 && positiveAUs.length > 0;
+      const valueRows = [];
+      if (hasDirectional) {
+        for (const auId of negativeAUs) {
+          valueRows.push([auId, AXIS_GROUP_NEGATIVE, boneSideForAU(auId, composite.node)]);
+        }
+        for (const auId of positiveAUs) {
+          valueRows.push([auId, AXIS_GROUP_POSITIVE, boneSideForAU(auId, composite.node)]);
+        }
+      } else {
+        for (const auId of config.aus) {
+          valueRows.push([auId, AXIS_GROUP_PLAIN, boneSideForAU(auId, composite.node)]);
+        }
+      }
+      const bindingRows = [];
+      const pushBindingRows = (auIds, group) => {
+        for (const auId of auIds) {
+          const binding = profile.auToBones?.[auId]?.find(
+            (candidate) => candidate.node === composite.node
+          );
+          if (!binding?.maxDegrees) continue;
+          const channel = ROTATION_CHANNELS[binding.channel];
+          if (channel === void 0) continue;
+          bindingRows.push([
+            auId,
+            group,
+            boneSideForAU(auId, composite.node),
+            channel,
+            binding.scale,
+            binding.maxDegrees
+          ]);
+        }
+      };
+      pushBindingRows(negativeAUs, AXIS_GROUP_NEGATIVE);
+      pushBindingRows(positiveAUs, AXIS_GROUP_POSITIVE);
+      pushBindingRows(config.aus, AXIS_GROUP_PLAIN);
+      compositeRows.push(
+        Number(bone.id),
+        axis,
+        hasDirectional ? 1 : 0,
+        valueRows.length,
+        bindingRows.length,
+        0,
+        0,
+        0
+      );
+      for (const row of valueRows) compositeRows.push(...row);
+      for (const row of bindingRows) compositeRows.push(...row);
+    }
+  }
+  const translationRows = [];
+  for (const [auIdText, bindings] of Object.entries(profile.auToBones || {})) {
+    const auId = Number(auIdText);
+    if (Number.isNaN(auId)) continue;
+    for (const binding of bindings || []) {
+      const channel = TRANSLATION_CHANNELS[binding.channel];
+      if (channel === void 0 || binding.maxUnits === void 0) continue;
+      const bone = findBone(binding.node);
+      if (!bone) continue;
+      translationRows.push(auId, Number(bone.id), channel, binding.scale, binding.maxUnits);
+    }
+  }
+  const jawRow = [];
+  const jawBinding = findAutoVisemeJawBinding(profile, model);
+  if (jawBinding?.maxDegrees) {
+    const bone = findBone(jawBinding.node);
+    const channel = ROTATION_CHANNELS[jawBinding.channel];
+    if (bone && channel !== void 0) {
+      jawRow.push(Number(bone.id), channel, jawBinding.scale, jawBinding.maxDegrees);
+    }
+  }
+  const restRows = [];
+  for (const bone of referencedBones.values()) {
+    const position = bone.restTransform?.position;
+    const rotation = bone.restTransform?.rotation;
+    restRows.push(
+      Number(bone.id),
+      position?.x ?? 0,
+      position?.y ?? 0,
+      position?.z ?? 0,
+      rotation?.x ?? 0,
+      rotation?.y ?? 0,
+      rotation?.z ?? 0,
+      rotation?.w ?? 1
+    );
+  }
+  return {
+    restTransforms: Float32Array.from(restRows),
+    compositeAxes: Float32Array.from(compositeRows),
+    translations: Float32Array.from(translationRows),
+    jawBinding: Float32Array.from(jawRow),
+    visemeJawAmounts: Float32Array.from(getVisemeJawAmounts(profile) ?? [])
+  };
+}
+function findBoneDescriptor(profile, model, nodeKey) {
+  const configuredName = profile.boneNodes?.[nodeKey] || nodeKey;
+  const prefix = profile.bonePrefix ?? "";
+  const suffix = profile.boneSuffix ?? "";
+  const prefixedName = prefix && !configuredName.startsWith(prefix) ? `${prefix}${configuredName}` : configuredName;
+  const fullName = suffix && !prefixedName.endsWith(suffix) ? `${prefixedName}${suffix}` : prefixedName;
+  const candidates = /* @__PURE__ */ new Set([nodeKey, configuredName, fullName]);
+  return model.bones.find((bone) => candidates.has(bone.name));
+}
+function findAutoVisemeJawBinding(profile, model) {
+  const isRotation = (binding) => binding?.channel === "rx" || binding?.channel === "ry" || binding?.channel === "rz";
+  const candidates = [
+    profile.auToBones?.[103]?.find(isRotation),
+    profile.auToBones?.[26]?.find(isRotation)
+  ].filter((binding) => !!binding);
+  return candidates.find((binding) => !!findBoneDescriptor(profile, model, binding.node)) ?? candidates[0] ?? null;
+}
+function unpackBoneFrameDelta(values) {
+  const stride = PACKED_BONE_FRAME_DELTA_STRIDE;
+  const writes = [];
+  for (let index = 0; index + stride <= values.length; index += stride) {
+    const flags = values[index + 8] ?? 0;
+    const hasPosition = (flags & PACKED_BONE_FLAG_HAS_POSITION) !== 0;
+    const hasRotation = (flags & PACKED_BONE_FLAG_HAS_ROTATION) !== 0;
+    if (!hasPosition && !hasRotation) continue;
+    writes.push({
+      boneId: values[index],
+      transform: {
+        ...hasPosition ? { position: { x: values[index + 1], y: values[index + 2], z: values[index + 3] } } : {},
+        ...hasRotation ? {
+          rotation: {
+            x: values[index + 4],
+            y: values[index + 5],
+            z: values[index + 6],
+            w: values[index + 7]
+          }
+        } : {}
+      },
+      mode: "absolute",
+      space: "local"
+    });
+  }
+  return writes;
+}
+function unpackMorphFrameDelta(values) {
+  const stride = PACKED_MORPH_FRAME_DELTA_STRIDE;
+  const writes = [];
+  for (let index = 0; index + stride <= values.length; index += stride) {
+    writes.push({
+      meshId: values[index],
+      morphTargetId: values[index + 1],
+      value: values[index + 2] ?? 0,
+      mode: (values[index + 3] ?? 0) === 1 ? "additive" : "absolute"
+    });
+  }
+  return writes;
+}
+function pushAuSide(rows, auId, side, morphs, meshNames, model, profile) {
+  for (const morph of morphs) {
+    for (const resolved of resolveMorphTargets(model, profile, morph, meshNames)) {
+      rows.push(
+        auId,
+        side,
+        Number(resolved.mesh.id),
+        Number(resolved.morphTarget.id),
+        1
+      );
+    }
+  }
+}
+function resolveMorphTargets(model, profile, morph, meshNames) {
+  const result = [];
+  for (const meshName of meshNames) {
+    const mesh = model.meshes.find((candidate) => candidate.name === meshName);
+    if (!mesh) continue;
+    const morphTargets = mesh.morphTargetIds.map((id) => model.morphTargets.find((candidate) => candidate.id === id)).filter((target2) => !!target2);
+    const target = typeof morph === "number" ? morphTargets.find((candidate) => candidate.hostIndex === morph) : resolveMorphTargetByName2(morphTargets, morph, profile);
+    if (target) {
+      result.push({ mesh, morphTarget: target });
+    }
+  }
+  return result;
+}
+function resolveMorphTargetByName2(targets, key, profile) {
+  const prefix = profile.morphPrefix || "";
+  const suffix = profile.morphSuffix || "";
+  const fullName = prefix + key + suffix;
+  const exact = targets.find((target) => target.name === fullName);
+  if (exact) return exact;
+  const suffixRegex = profile.suffixPattern ? new RegExp(profile.suffixPattern) : null;
+  if (!suffixRegex) return void 0;
+  return targets.find((target) => {
+    if (!target.name.startsWith(fullName)) return false;
+    const candidateSuffix = target.name.slice(fullName.length);
+    return candidateSuffix === "" || suffixRegex.test(candidateSuffix);
+  });
+}
+
+export { AU_MORPH_BINDING_STRIDE, MESH_PROPORTIONS_FIELDS, MESH_PROPORTIONS_STRIDE, TEMPLATE_SKELETON_FIT_METADATA_KIND, TEMPLATE_SKELETON_FIT_METADATA_VERSION, TEMPLATE_SKELETON_FIT_SOLUTION_FIELDS, TEMPLATE_SKELETON_FIT_SOLUTION_STRIDE, TEMPLATE_SKELETON_FIT_STATUSES, TEMPLATE_SKELETON_FIT_TRANSFORM_FIELDS, TEMPLATE_SKELETON_FIT_TRANSFORM_STRIDE, TEMPLATE_SKELETON_FIT_VERTICAL_ANCHORS, TEMPLATE_SKELETON_FIT_VERTICAL_AXES, TsClipCompiler, TsRuntimeCore, VISEME_MORPH_BINDING_STRIDE, WasmRuntimeCore, compileBoneBindings, compileMorphBindings, composeTemplateSkeletonFitTransform, isTemplateSkeletonFitStatus, numericArrayToNumbers, unpackBoneFrameDelta, unpackMorphFrameDelta, validateTemplateSkeletonFitMetadata };
+//# sourceMappingURL=core.js.map
+//# sourceMappingURL=core.js.map