@lovelace_lol/loom3 1.0.41 → 1.0.43

package/dist/index.cjs

@@ -60,6 +60,223 @@ function getCompositeAxisBinding(nodeKey, axisConfig, direction, getValue, auToB
   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 bindingTargets(binding) {
+  if (!binding) return [];
+  const targets = binding.targets?.map((target) => target.morph).filter((morph) => morph !== "");
+  if (targets && targets.length > 0) return targets;
+  return binding.morph !== void 0 && binding.morph !== "" ? [binding.morph] : [];
+}
+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 compileVisemeKeys(profile) {
+  const slots = getProfileVisemeSlots(profile);
+  if (!profile.visemeBindings) return [...profile.visemeKeys || []];
+  return slots.map((slot, index) => {
+    const target = bindingTargets(profile.visemeBindings?.[slot.id])[0];
+    return target ?? profile.visemeKeys?.[index] ?? "";
+  });
+}
+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 || []];
+}
+function compileMatcher(pattern) {
+  try {
+    return new RegExp(pattern, "i");
+  } catch {
+    return null;
+  }
+}
+function classifyVisemeMorph(morphName, profile) {
+  const slots = getProfileVisemeSlots(profile);
+  const matches = [];
+  for (const slot of slots) {
+    const explicitTargets = bindingTargets(profile.visemeBindings?.[slot.id]);
+    if (explicitTargets.some((target) => String(target).toLowerCase() === morphName.toLowerCase())) {
+      matches.push({
+        slotId: slot.id,
+        label: slot.label,
+        confidence: 1,
+        reason: "explicit"
+      });
+      continue;
+    }
+    for (const pattern of slot.matchers || []) {
+      const matcher = compileMatcher(pattern);
+      if (matcher?.test(morphName)) {
+        matches.push({
+          slotId: slot.id,
+          label: slot.label,
+          confidence: 0.75,
+          reason: "regex",
+          pattern
+        });
+      }
+    }
+  }
+  return matches;
+}
+function buildMappingEditorModel(profile, morphNames = []) {
+  const sections = /* @__PURE__ */ new Map();
+  const configuredSections = profile.mappingSections || [];
+  const configuredById = new Map(configuredSections.map((section) => [section.id, section]));
+  let nextOrder = configuredSections.length;
+  for (const section of configuredSections) {
+    sections.set(section.id, { ...section });
+  }
+  const getOrder = (id, fallback) => {
+    const configured = configuredById.get(id);
+    if (configured) return configured.order;
+    if (fallback !== void 0) return fallback;
+    const order = nextOrder;
+    nextOrder += 1;
+    return order;
+  };
+  const auSectionOrders = /* @__PURE__ */ new Map();
+  for (const [auId, info] of Object.entries(profile.auInfo || {})) {
+    const label = info.facePart || "Unmapped";
+    auSectionOrders.set(label, Math.min(auSectionOrders.get(label) ?? Number.MAX_SAFE_INTEGER, Number(auId)));
+  }
+  if (configuredSections.length === 0 && auSectionOrders.size > 0) {
+    nextOrder = Math.max(...auSectionOrders.values()) + 1;
+  }
+  for (const info of Object.values(profile.auInfo || {})) {
+    const label = info.facePart || "Unmapped";
+    const configured = configuredById.get(label);
+    const meshCategory = profile.auFacePartToMeshCategory?.[label] || "face";
+    sections.set(label, {
+      ...configured,
+      id: label,
+      label: configured?.label || label,
+      kind: "au",
+      order: getOrder(label, auSectionOrders.get(label)),
+      meshCategory: configured?.meshCategory || meshCategory,
+      facePart: label
+    });
+  }
+  const configuredVisemes = configuredById.get("Visemes");
+  sections.set("Visemes", {
+    ...configuredVisemes,
+    id: "Visemes",
+    label: configuredVisemes?.label || "Visemes",
+    kind: "viseme",
+    order: getOrder("Visemes"),
+    meshCategory: configuredVisemes?.meshCategory || resolveVisemeMeshCategory(profile)
+  });
+  if (hasOwn(profile.morphToMesh, "hair")) {
+    const configuredHair = configuredById.get("Hair");
+    sections.set("Hair", {
+      ...configuredHair,
+      id: "Hair",
+      label: configuredHair?.label || "Hair",
+      kind: "hair",
+      order: getOrder("Hair"),
+      meshCategory: configuredHair?.meshCategory || "hair"
+    });
+  }
+  const configuredUnmapped = configuredById.get("Unmapped");
+  sections.set("Unmapped", {
+    ...configuredUnmapped,
+    id: "Unmapped",
+    label: configuredUnmapped?.label || "Unmapped",
+    kind: "unmapped",
+    order: getOrder("Unmapped"),
+    meshCategory: configuredUnmapped?.meshCategory || "face"
+  });
+  const candidates = morphNames.map((morph) => {
+    const matches = classifyVisemeMorph(morph, profile);
+    if (matches.length === 0) {
+      return { morph, sectionId: "Unmapped", kind: "unmapped", matches };
+    }
+    const explicit = matches.filter((match) => match.reason === "explicit");
+    if (explicit.length > 0) {
+      return { morph, sectionId: "Visemes", kind: "explicit", matches: explicit };
+    }
+    return {
+      morph,
+      sectionId: "Visemes",
+      kind: matches.length > 1 ? "conflict" : "candidate",
+      matches
+    };
+  });
+  return {
+    sections: Array.from(sections.values()).sort((a, b) => a.order - b.order || a.label.localeCompare(b.label)),
+    candidates
+  };
+}
+function mapProviderVisemeToSlot(profile, event) {
+  const slots = getProfileVisemeSlots(profile);
+  const provider = event.provider.toLowerCase();
+  if (event.id !== void 0) {
+    const id = String(event.id);
+    const index = slots.findIndex(
+      (slot) => (slot.providerIds?.[provider] || []).some((candidate) => String(candidate) === id)
+    );
+    if (index >= 0) {
+      return { slotId: slots[index].id, index, confidence: 1, reason: "provider" };
+    }
+  }
+  if (event.phoneme) {
+    const phoneme = event.phoneme.toLowerCase();
+    const index = slots.findIndex(
+      (slot) => (slot.phonemes || []).some((candidate) => candidate.toLowerCase() === phoneme)
+    );
+    if (index >= 0) {
+      return { slotId: slots[index].id, index, confidence: 0.8, reason: "phoneme" };
+    }
+  }
+  const restIndex = slots.findIndex((slot) => slot.id === "rest" || slot.features?.lipClosed === 1);
+  if (restIndex >= 0) {
+    return { slotId: slots[restIndex].id, index: restIndex, confidence: 0.25, reason: "rest" };
+  }
+  return null;
+}
+
 // src/engines/three/balanceUtils.ts
 function clampBalance(value) {
   if (!Number.isFinite(value)) return 0;
@@ -293,14 +510,19 @@ var Y_AXIS = new THREE2.Vector3(0, 1, 0);
 var Z_AXIS = new THREE2.Vector3(0, 0, 1);
 var CLIP_EVENT_METADATA_KEY = "__loom3ClipEvents";
 var CLIP_EVENT_EPSILON = 1e-4;
+var ADDITIVE_BAKED_RUNTIME_CLIP_SUFFIX = "__loom3_additive_delta";
 var BakedAnimationController = class {
   constructor(host) {
     __publicField(this, "host");
+    // Clip-backed snippets need a later mixer pass so they can override baked additive tracks.
     __publicField(this, "animationMixer", null);
+    __publicField(this, "clipAnimationMixer", null);
     __publicField(this, "mixerFinishedListenerAttached", false);
+    __publicField(this, "clipMixerFinishedListenerAttached", false);
     __publicField(this, "animationClips", []);
     __publicField(this, "bakedSourceClips", /* @__PURE__ */ new Map());
     __publicField(this, "bakedRuntimeActions", /* @__PURE__ */ new Map());
+    __publicField(this, "bakedAdditiveRuntimeClips", /* @__PURE__ */ new Map());
     __publicField(this, "bakedActionGroups", /* @__PURE__ */ new Map());
     __publicField(this, "bakedRuntimeClipToSource", /* @__PURE__ */ new Map());
     __publicField(this, "animationActions", /* @__PURE__ */ new Map());
@@ -325,6 +547,173 @@ var BakedAnimationController = class {
     action.__actionId = actionId;
     return actionId;
   }
+  clearActionId(action) {
+    if (!action) return;
+    const actionId = this.getActionId(action);
+    if (actionId) {
+      this.actionIdToClip.delete(actionId);
+    }
+    this.actionIds.delete(action);
+    delete action.__actionId;
+  }
+  uncacheClip(clip, mixer = this.animationMixer) {
+    if (!clip || !mixer) return;
+    try {
+      mixer.uncacheClip(clip);
+    } catch {
+    }
+  }
+  uncacheAction(action, mixer = this.animationMixer) {
+    if (!action || !mixer) return;
+    try {
+      const clip = action.getClip();
+      if (clip) {
+        mixer.uncacheAction(clip);
+        mixer.uncacheClip(clip);
+      }
+    } catch {
+    }
+  }
+  releaseBakedRuntimeAction(runtimeClipName) {
+    const action = this.bakedRuntimeActions.get(runtimeClipName);
+    if (!action) return;
+    try {
+      action.stop();
+    } catch {
+    }
+    this.uncacheAction(action);
+    this.clearActionId(action);
+    this.bakedRuntimeActions.delete(runtimeClipName);
+  }
+  clearBakedAdditiveRuntimeClip(runtimeClipName) {
+    const clip = this.bakedAdditiveRuntimeClips.get(runtimeClipName);
+    if (!clip) return;
+    this.uncacheClip(clip);
+    this.bakedAdditiveRuntimeClips.delete(runtimeClipName);
+  }
+  clearAllBakedAdditiveRuntimeClips() {
+    for (const runtimeClipName of Array.from(this.bakedAdditiveRuntimeClips.keys())) {
+      this.clearBakedAdditiveRuntimeClip(runtimeClipName);
+    }
+  }
+  resolveTrackTarget(model, parsed) {
+    const targetKey = parsed.objectName === "bones" && parsed.objectIndex ? parsed.objectIndex : parsed.nodeName;
+    if (!targetKey) {
+      return null;
+    }
+    return model.getObjectByProperty("uuid", targetKey) ?? THREE2.PropertyBinding.findNode(model, targetKey) ?? null;
+  }
+  getMorphTrackBaseValue(target, propertyIndex) {
+    if (!target) {
+      return 0;
+    }
+    const meshTarget = target;
+    const influences = meshTarget.morphTargetInfluences;
+    if (!influences) {
+      return 0;
+    }
+    let morphIndex;
+    if (typeof propertyIndex === "number" && Number.isInteger(propertyIndex)) {
+      morphIndex = propertyIndex;
+    } else if (typeof propertyIndex === "string") {
+      if (/^\d+$/.test(propertyIndex)) {
+        morphIndex = Number(propertyIndex);
+      } else {
+        morphIndex = meshTarget.morphTargetDictionary?.[propertyIndex];
+      }
+    }
+    if (morphIndex === void 0) {
+      return 0;
+    }
+    return influences[morphIndex] ?? 0;
+  }
+  canCreateFirstFrameReferenceTrack(track) {
+    const valueSize = track.getValueSize();
+    if (!Number.isFinite(valueSize) || valueSize <= 0 || track.values.length < valueSize) {
+      return false;
+    }
+    return track.ValueTypeName === "number" || track.ValueTypeName === "quaternion" || track.ValueTypeName === "vector";
+  }
+  createFirstFrameReferenceTrack(track) {
+    const valueSize = track.getValueSize();
+    if (!this.canCreateFirstFrameReferenceTrack(track)) {
+      return null;
+    }
+    const values = Array.from(track.values.slice(0, valueSize));
+    if (track.ValueTypeName === "number") {
+      return new THREE2.NumberKeyframeTrack(track.name, [0], values);
+    }
+    if (track.ValueTypeName === "quaternion") {
+      return new THREE2.QuaternionKeyframeTrack(track.name, [0], values);
+    }
+    if (track.ValueTypeName === "vector") {
+      return new THREE2.VectorKeyframeTrack(track.name, [0], values);
+    }
+    return null;
+  }
+  createAdditiveReferenceTrack(track, model) {
+    const trackName = typeof track?.name === "string" ? track.name : "";
+    if (!trackName) {
+      return null;
+    }
+    let parsed;
+    try {
+      parsed = THREE2.PropertyBinding.parseTrackName(trackName);
+    } catch {
+      return null;
+    }
+    const target = this.resolveTrackTarget(model, parsed);
+    if (parsed.propertyName === "morphTargetInfluences") {
+      return new THREE2.NumberKeyframeTrack(
+        track.name,
+        [0],
+        [this.getMorphTrackBaseValue(target, parsed.propertyIndex)]
+      );
+    }
+    return this.createFirstFrameReferenceTrack(track);
+  }
+  createAdditiveRuntimeClip(runtimeClip) {
+    const model = this.host.getModel();
+    if (!model) {
+      return null;
+    }
+    const additiveTracks = [];
+    const referenceTracks = [];
+    for (const track of runtimeClip.tracks) {
+      const referenceTrack = this.createAdditiveReferenceTrack(track, model);
+      if (!referenceTrack) {
+        continue;
+      }
+      additiveTracks.push(track.clone());
+      referenceTracks.push(referenceTrack);
+    }
+    const additiveClip = new THREE2.AnimationClip(
+      `${runtimeClip.name}${ADDITIVE_BAKED_RUNTIME_CLIP_SUFFIX}`,
+      runtimeClip.duration,
+      additiveTracks
+    );
+    if (additiveTracks.length > 0) {
+      const referenceClip = new THREE2.AnimationClip(
+        `${runtimeClip.name}${ADDITIVE_BAKED_RUNTIME_CLIP_SUFFIX}_reference`,
+        0,
+        referenceTracks
+      );
+      THREE2.AnimationUtils.makeClipAdditive(additiveClip, 0, referenceClip);
+    }
+    return additiveClip;
+  }
+  getOrCreateBakedAdditiveRuntimeClip(runtimeClip) {
+    const cached = this.bakedAdditiveRuntimeClips.get(runtimeClip.name);
+    if (cached) {
+      return cached;
+    }
+    const additiveClip = this.createAdditiveRuntimeClip(runtimeClip);
+    if (!additiveClip) {
+      return null;
+    }
+    this.bakedAdditiveRuntimeClips.set(runtimeClip.name, additiveClip);
+    return additiveClip;
+  }
   setClipEventMetadata(clip, metadata) {
     const userData = clip.userData ?? (clip.userData = {});
     userData[CLIP_EVENT_METADATA_KEY] = metadata;
@@ -610,21 +999,28 @@ var BakedAnimationController = class {
     }
     return 0;
   }
-  getOrCreateBakedRuntimeAction(sourceClipName, channel) {
+  getOrCreateBakedRuntimeAction(sourceClipName, channel, blendMode = "replace") {
     const bakedClip = this.getBakedSourceClip(sourceClipName);
     const runtimeClip = bakedClip?.runtimeClips.find((entry) => entry.channel === channel)?.clip;
     if (!runtimeClip) {
       return null;
     }
+    const desiredClip = blendMode === "additive" ? this.getOrCreateBakedAdditiveRuntimeClip(runtimeClip) : runtimeClip;
+    if (!desiredClip) {
+      return null;
+    }
     const existing = this.bakedRuntimeActions.get(runtimeClip.name);
-    if (existing) {
+    if (existing?.getClip() === desiredClip) {
       return existing;
     }
     this.ensureMixer();
     if (!this.animationMixer) {
       return null;
     }
-    const action = this.animationMixer.clipAction(runtimeClip);
+    if (existing) {
+      this.releaseBakedRuntimeAction(runtimeClip.name);
+    }
+    const action = this.animationMixer.clipAction(desiredClip);
     this.bakedRuntimeActions.set(runtimeClip.name, action);
     return action;
   }
@@ -642,7 +1038,15 @@ var BakedAnimationController = class {
     }
     const channelActions = /* @__PURE__ */ new Map();
     for (const runtimeClip of bakedClip.runtimeClips) {
-      const action = this.getOrCreateBakedRuntimeAction(clipName, runtimeClip.channel);
+      const channelBlendMode = resolveBakedChannelBlendMode(
+        runtimeClip.channel,
+        playbackState.requestedBlendMode
+      ) ?? "replace";
+      const action = this.getOrCreateBakedRuntimeAction(
+        clipName,
+        runtimeClip.channel,
+        channelBlendMode
+      );
       if (action) {
         channelActions.set(runtimeClip.channel, action);
       }
@@ -670,12 +1074,7 @@ var BakedAnimationController = class {
     if (typeof this.host.getMeshNamesForAU === "function") {
       return this.host.getMeshNamesForAU(auId) || [];
     }
-    const facePart = config.auInfo?.[String(auId)]?.facePart;
-    if (facePart) {
-      const category = config.auFacePartToMeshCategory?.[facePart];
-      if (category) return config.morphToMesh?.[category] || [];
-    }
-    return config.morphToMesh?.face || [];
+    return getMeshNamesForAUProfile(config, auId);
   }
   getMeshNamesForViseme(config, explicitMeshNames) {
     if (explicitMeshNames && explicitMeshNames.length > 0) {
@@ -684,18 +1083,41 @@ var BakedAnimationController = class {
     if (typeof this.host.getMeshNamesForViseme === "function") {
       return this.host.getMeshNamesForViseme() || [];
     }
-    const category = config.visemeMeshCategory || (config.morphToMesh?.viseme ? "viseme" : "face");
-    const visemeMeshes = config.morphToMesh?.[category];
-    if (visemeMeshes && visemeMeshes.length > 0) return visemeMeshes;
-    return config.morphToMesh?.face || [];
+    return getMeshNamesForVisemeProfile(config);
+  }
+  hasActiveAdditivePlayback() {
+    for (const [clipName, group] of this.bakedActionGroups) {
+      const state = this.playbackState.get(clipName);
+      if (state?.blendMode !== "additive") {
+        continue;
+      }
+      for (const action of group.channelActions.values()) {
+        if (action.isRunning() && !action.paused) {
+          return true;
+        }
+      }
+    }
+    for (const [clipName, action] of this.animationActions) {
+      const state = this.playbackState.get(clipName);
+      if (state?.blendMode !== "additive") {
+        continue;
+      }
+      if (action.isRunning() && !action.paused) {
+        return true;
+      }
+    }
+    return false;
   }
   update(dtSeconds) {
     if (this.animationMixer) {
+      this.animationMixer.update(dtSeconds);
+    }
+    if (this.clipAnimationMixer) {
       const snapshots = Array.from(this.clipMonitors.values()).map((monitor) => ({
         actionId: monitor.actionId,
         previousTime: monitor.action.time
       }));
-      this.animationMixer.update(dtSeconds);
+      this.clipAnimationMixer.update(dtSeconds);
       for (const { actionId, previousTime } of snapshots) {
         const monitor = this.clipMonitors.get(actionId);
         if (!monitor) continue;
@@ -714,16 +1136,27 @@ var BakedAnimationController = class {
         }
       }
     }
+    if (this.hasActiveAdditivePlayback()) {
+      this.host.reapplyProceduralState?.();
+    }
   }
   dispose() {
     this.stopAllAnimations();
+    this.clearAllBakedAdditiveRuntimeClips();
     if (this.animationMixer) {
       this.animationMixer.stopAllAction();
       this.animationMixer = null;
     }
+    if (this.clipAnimationMixer) {
+      this.clipAnimationMixer.stopAllAction();
+      this.clipAnimationMixer = null;
+    }
+    this.mixerFinishedListenerAttached = false;
+    this.clipMixerFinishedListenerAttached = false;
     this.animationClips = [];
     this.bakedSourceClips.clear();
     this.bakedRuntimeActions.clear();
+    this.bakedAdditiveRuntimeClips.clear();
     this.bakedActionGroups.clear();
     this.bakedRuntimeClipToSource.clear();
     this.animationActions.clear();
@@ -746,6 +1179,8 @@ var BakedAnimationController = class {
     if (this.animationMixer) {
       for (const bakedClip of this.bakedSourceClips.values()) {
         for (const runtimeClip of bakedClip.runtimeClips) {
+          this.releaseBakedRuntimeAction(runtimeClip.clip.name);
+          this.clearBakedAdditiveRuntimeClip(runtimeClip.clip.name);
           try {
             this.animationMixer.uncacheAction(runtimeClip.clip);
           } catch {
@@ -757,6 +1192,7 @@ var BakedAnimationController = class {
         }
       }
     }
+    this.clearAllBakedAdditiveRuntimeClips();
     for (const clipName of this.bakedSourceClips.keys()) {
       this.playbackState.delete(clipName);
       this.clipSources.delete(clipName);
@@ -797,6 +1233,8 @@ var BakedAnimationController = class {
     if (this.animationMixer) {
       for (const runtimeClip of bakedClip.runtimeClips) {
         const action = this.bakedRuntimeActions.get(runtimeClip.clip.name);
+        this.releaseBakedRuntimeAction(runtimeClip.clip.name);
+        this.clearBakedAdditiveRuntimeClip(runtimeClip.clip.name);
         try {
           this.animationMixer.uncacheAction(runtimeClip.clip);
         } catch {
@@ -805,7 +1243,6 @@ var BakedAnimationController = class {
           this.animationMixer.uncacheClip(runtimeClip.clip);
         } catch {
         }
-        this.bakedRuntimeActions.delete(runtimeClip.clip.name);
         this.bakedRuntimeClipToSource.delete(runtimeClip.clip.name);
         const actionId = this.getActionId(action);
         if (actionId && action) {
@@ -814,6 +1251,10 @@ var BakedAnimationController = class {
         }
       }
     }
+    for (const runtimeClip of bakedClip.runtimeClips) {
+      this.clearBakedAdditiveRuntimeClip(runtimeClip.clip.name);
+      this.bakedRuntimeActions.delete(runtimeClip.clip.name);
+    }
     this.animationClips = this.animationClips.filter((entry) => entry.name !== clipName);
     this.bakedSourceClips.delete(clipName);
     this.bakedActionGroups.delete(clipName);
@@ -874,12 +1315,12 @@ var BakedAnimationController = class {
       const actionId = this.getActionId(action);
       const isBaked = (this.clipSources.get(clipName) ?? "baked") === "baked";
       action.stop();
-      if (!isBaked && this.animationMixer) {
+      if (!isBaked && this.clipAnimationMixer) {
         try {
           const clip = action.getClip();
           if (clip) {
-            this.animationMixer.uncacheAction(clip);
-            this.animationMixer.uncacheClip(clip);
+            this.clipAnimationMixer.uncacheAction(clip);
+            this.clipAnimationMixer.uncacheClip(clip);
           }
         } catch {
         }
@@ -901,11 +1342,11 @@ var BakedAnimationController = class {
       const actionId = this.getActionId(clipAction);
       try {
         clipAction.stop();
-        if (this.animationMixer) {
+        if (this.clipAnimationMixer) {
           const clip = clipAction.getClip();
           if (clip) {
-            this.animationMixer.uncacheAction(clip);
-            this.animationMixer.uncacheClip(clip);
+            this.clipAnimationMixer.uncacheAction(clip);
+            this.clipAnimationMixer.uncacheClip(clip);
           }
         }
       } catch {
@@ -1109,8 +1550,23 @@ var BakedAnimationController = class {
       next.blendMode = this.getBakedAggregateBlendMode(clipName, next);
       const bakedGroup = this.bakedActionGroups.get(clipName);
       if (bakedGroup) {
-        for (const [channel, action2] of bakedGroup.channelActions) {
+        for (const [channel, currentAction] of Array.from(bakedGroup.channelActions)) {
+          const channelBlendMode = resolveBakedChannelBlendMode(channel, next.requestedBlendMode) ?? "replace";
+          const previousTime = currentAction.time;
+          const wasActive = currentAction.isRunning() || currentAction.paused;
+          const wasPaused = currentAction.paused;
+          const action2 = this.getOrCreateBakedRuntimeAction(clipName, channel, channelBlendMode);
+          if (!action2) {
+            bakedGroup.channelActions.delete(channel);
+            continue;
+          }
           this.applyPlaybackStateToBakedAction(action2, next, channel);
+          action2.time = Math.max(0, Math.min(action2.getClip().duration, previousTime));
+          if (action2 !== currentAction && wasActive) {
+            action2.play();
+          }
+          action2.paused = wasPaused;
+          bakedGroup.channelActions.set(channel, action2);
         }
       }
       this.setPlaybackState(clipName, next);
@@ -1125,6 +1581,10 @@ var BakedAnimationController = class {
   seekAnimation(clipName, time) {
     const bakedGroup = this.bakedActionGroups.get(clipName);
     if (bakedGroup) {
+      const state = this.getPlaybackStateSnapshot(clipName, {
+        loop: true,
+        source: this.clipSources.get(clipName) ?? "baked"
+      });
       const duration2 = this.getBakedSourceClip(clipName)?.sourceClip.duration ?? 0;
       const clamped = Math.max(0, Math.min(duration2, Number.isFinite(time) ? time : 0));
       for (const action2 of bakedGroup.channelActions.values()) {
@@ -1132,6 +1592,10 @@ var BakedAnimationController = class {
       }
       try {
         this.animationMixer?.update(0);
+        this.clipAnimationMixer?.update(0);
+        if (state.blendMode === "additive") {
+          this.host.reapplyProceduralState?.();
+        }
       } catch {
       }
       return;
@@ -1141,7 +1605,11 @@ var BakedAnimationController = class {
     const duration = action.getClip().duration;
     action.time = Math.max(0, Math.min(duration, Number.isFinite(time) ? time : 0));
     try {
-      this.animationMixer?.update(0);
+      this.clipAnimationMixer?.update(0);
+      const state = this.playbackState.get(clipName);
+      if (state?.blendMode === "additive") {
+        this.host.reapplyProceduralState?.();
+      }
     } catch {
     }
   }
@@ -1149,6 +1617,9 @@ var BakedAnimationController = class {
     if (this.animationMixer) {
       this.animationMixer.timeScale = timeScale;
     }
+    if (this.clipAnimationMixer) {
+      this.clipAnimationMixer.timeScale = timeScale;
+    }
   }
   getAnimationState(clipName) {
     const bakedClip = this.getBakedSourceClip(clipName);
@@ -1478,8 +1949,8 @@ var BakedAnimationController = class {
     return clip;
   }
   playClip(clip, options) {
-    this.ensureMixer();
-    if (!this.animationMixer) {
+    const mixer = this.ensureClipMixer();
+    if (!mixer) {
       console.warn("[Loom3] playClip: No model loaded, cannot create mixer");
       return null;
     }
@@ -1497,7 +1968,7 @@ var BakedAnimationController = class {
       actionId = this.setActionId(action, clip.name);
     }
     if (!action) {
-      action = this.animationMixer.clipAction(clip);
+      action = mixer.clipAction(clip);
       actionId = this.setActionId(action, clip.name);
     }
     const existingClip = this.animationClips.find((c) => c.name === clip.name);
@@ -1558,15 +2029,13 @@ var BakedAnimationController = class {
       },
       stop: () => {
         action.stop();
-        if (this.animationMixer) {
-          try {
-            this.animationMixer.uncacheAction(clip);
-          } catch {
-          }
-          try {
-            this.animationMixer.uncacheClip(clip);
-          } catch {
-          }
+        try {
+          mixer.uncacheAction(clip);
+        } catch {
+        }
+        try {
+          mixer.uncacheClip(clip);
+        } catch {
         }
         this.clipActions.delete(clip.name);
         this.animationActions.delete(clip.name);
@@ -1607,7 +2076,7 @@ var BakedAnimationController = class {
         const clamped = Math.max(0, Math.min(clip.duration, t));
         action.time = clamped;
         try {
-          this.animationMixer?.update(0);
+          mixer.update(0);
         } catch {
         }
         this.syncClipMonitorTime(monitor, clamped, true);
@@ -1640,16 +2109,16 @@ var BakedAnimationController = class {
     return this.playClip(clip, { ...options, source: options?.source ?? "clip" });
   }
   cleanupSnippet(name) {
-    if (!this.animationMixer || !this.host.getModel()) return;
+    if (!this.host.getModel()) return;
     for (const [clipName, action] of Array.from(this.clipActions.entries())) {
       if (clipName === name || clipName.startsWith(`${name}_`)) {
         const actionId = this.getActionId(action);
         try {
           action.stop();
           const clip = action.getClip();
-          if (clip) {
-            this.animationMixer.uncacheAction(clip);
-            this.animationMixer.uncacheClip(clip);
+          if (clip && this.clipAnimationMixer) {
+            this.clipAnimationMixer.uncacheAction(clip);
+            this.clipAnimationMixer.uncacheClip(clip);
           }
         } catch {
         }
@@ -1677,7 +2146,10 @@ var BakedAnimationController = class {
       clipActions: Array.from(this.clipActions.entries()).map(([k, a]) => ({ name: k, actionId: this.getActionId(a) })),
       animationActions: Array.from(this.animationActions.entries()).map(([k, a]) => ({ name: k, actionId: this.getActionId(a) })),
       clipHandles: Array.from(this.clipHandles.entries()).map(([k, h]) => ({ name: k, actionId: h.actionId })),
-      mixerActions: (this.animationMixer?._actions || []).map((a) => ({ name: a?.getClip?.()?.name || "", actionId: this.getActionId(a) }))
+      mixerActions: [
+        ...this.animationMixer?._actions || [],
+        ...this.clipAnimationMixer?._actions || []
+      ].map((a) => ({ name: a?.getClip?.()?.name || "", actionId: this.getActionId(a) }))
     });
     console.log("[Loom3] updateClipParams start", debugSnapshot());
     const apply = (action) => {
@@ -1740,7 +2212,7 @@ var BakedAnimationController = class {
   }
   addMorphTracks(tracks, morphKey, keyframes, intensityScale, meshNames) {
     const config = this.host.getConfig();
-    const hasExplicitMeshes = !!(meshNames && meshNames.length > 0);
+    const hasExplicitMeshes = meshNames !== void 0;
     const targetMeshNames = hasExplicitMeshes ? meshNames : config.morphToMesh?.face || [];
     const targetMeshes = targetMeshNames.length ? targetMeshNames.map((name) => this.host.getMeshByName(name)).filter(Boolean) : [];
     const addTrackForMesh = (mesh) => {
@@ -1764,7 +2236,7 @@ var BakedAnimationController = class {
   addMorphIndexTracks(tracks, morphIndex, keyframes, intensityScale, meshNames) {
     if (!Number.isInteger(morphIndex) || morphIndex < 0) return;
     const config = this.host.getConfig();
-    const hasExplicitMeshes = !!(meshNames && meshNames.length > 0);
+    const hasExplicitMeshes = meshNames !== void 0;
     const targetMeshNames = hasExplicitMeshes ? meshNames : config.morphToMesh?.face || [];
     const targetMeshes = targetMeshNames.length ? targetMeshNames.map((name) => this.host.getMeshByName(name)).filter(Boolean) : [];
     const addTrackForMesh = (mesh) => {
@@ -1791,35 +2263,48 @@ var BakedAnimationController = class {
       this.animationMixer = new THREE2.AnimationMixer(model);
     }
     if (this.animationMixer && !this.mixerFinishedListenerAttached) {
-      this.animationMixer.addEventListener("finished", (event) => {
-        const action = event.action;
-        const actionId = this.getActionId(action);
-        if (actionId) {
-          const monitor = this.clipMonitors.get(actionId);
-          if (monitor) {
-            monitor.finishedPending = true;
-            return;
-          }
-        }
-        const clip = action.getClip();
-        const bakedRuntime = this.bakedRuntimeClipToSource.get(clip.name);
-        if (bakedRuntime) {
-          const group = this.bakedActionGroups.get(bakedRuntime.sourceClipName);
-          if (group && group.pendingFinishedChannels.delete(bakedRuntime.channel) && group.pendingFinishedChannels.size === 0) {
-            group.resolveFinished();
-          }
-          return;
-        }
-        const callback = this.animationFinishedCallbacks.get(clip.name);
-        if (callback) {
-          callback();
-          this.animationFinishedCallbacks.delete(clip.name);
-        }
-      });
+      this.animationMixer.addEventListener("finished", (event) => this.handleMixerFinished(event));
       this.mixerFinishedListenerAttached = true;
     }
     return this.animationMixer;
   }
+  ensureClipMixer() {
+    const model = this.host.getModel();
+    if (!model) return null;
+    if (!this.clipAnimationMixer) {
+      this.clipAnimationMixer = new THREE2.AnimationMixer(model);
+    }
+    if (this.clipAnimationMixer && !this.clipMixerFinishedListenerAttached) {
+      this.clipAnimationMixer.addEventListener("finished", (event) => this.handleMixerFinished(event));
+      this.clipMixerFinishedListenerAttached = true;
+    }
+    return this.clipAnimationMixer;
+  }
+  handleMixerFinished(event) {
+    const action = event.action;
+    const actionId = this.getActionId(action);
+    if (actionId) {
+      const monitor = this.clipMonitors.get(actionId);
+      if (monitor) {
+        monitor.finishedPending = true;
+        return;
+      }
+    }
+    const clip = action.getClip();
+    const bakedRuntime = this.bakedRuntimeClipToSource.get(clip.name);
+    if (bakedRuntime) {
+      const group = this.bakedActionGroups.get(bakedRuntime.sourceClipName);
+      if (group && group.pendingFinishedChannels.delete(bakedRuntime.channel) && group.pendingFinishedChannels.size === 0) {
+        group.resolveFinished();
+      }
+      return;
+    }
+    const callback = this.animationFinishedCallbacks.get(clip.name);
+    if (callback) {
+      callback();
+      this.animationFinishedCallbacks.delete(clip.name);
+    }
+  }
   createAnimationHandle(clipName, action, finishedPromise) {
     return {
       actionId: this.getActionId(action),
@@ -2398,6 +2883,159 @@ var VISEME_JAW_AMOUNTS = [
   0.5
   // 14: W_OO
 ];
+var CC4_VISEME_SYSTEM_ID = "cc4-arkit-15";
+var CC4_VISEME_SLOTS = [
+  {
+    id: "ae",
+    label: "AE",
+    order: 0,
+    providerIds: { azure: [4], sapi: [4] },
+    phonemes: ["AE", "EH", "EY", "UH"],
+    matchers: ["(^|[_ .-])(v|viseme)?[_ .-]?(ae|eh|ey)([_ .-]|$)"],
+    features: { jawOpen: 0.75, lipSpread: 0.35 },
+    defaultJawAmount: VISEME_JAW_AMOUNTS[0]
+  },
+  {
+    id: "ah",
+    label: "Ah",
+    order: 1,
+    providerIds: { azure: [1, 2, 9, 11, 12], sapi: [1, 2, 9, 11, 12] },
+    phonemes: ["AA", "AE", "AH", "AX", "AW", "AY", "HH"],
+    matchers: ["(^|[_ .-])(v|viseme)?[_ .-]?(ah|aa|aah|open)([_ .-]|$)"],
+    features: { jawOpen: 0.8 },
+    defaultJawAmount: VISEME_JAW_AMOUNTS[1]
+  },
+  {
+    id: "b-m-p",
+    label: "B_M_P",
+    order: 2,
+    providerIds: { azure: [0, 21], sapi: [0, 21] },
+    phonemes: ["B", "M", "P"],
+    matchers: ["(^|[_ .-])(v|viseme)?[_ .-]?(b[_ .-]?m[_ .-]?p|bmp|closed|sil|rest)([_ .-]|$)"],
+    features: { jawOpen: 0, lipClosed: 1 },
+    defaultJawAmount: VISEME_JAW_AMOUNTS[2]
+  },
+  {
+    id: "ch-j",
+    label: "Ch_J",
+    order: 3,
+    providerIds: { azure: [16], sapi: [16] },
+    phonemes: ["CH", "JH", "SH", "ZH"],
+    matchers: ["(^|[_ .-])(v|viseme)?[_ .-]?(ch|j|sh|zh)([_ .-]|$)"],
+    features: { jawOpen: 0.3, fricative: 0.6 },
+    defaultJawAmount: VISEME_JAW_AMOUNTS[3]
+  },
+  {
+    id: "ee",
+    label: "EE",
+    order: 4,
+    providerIds: { azure: [6], sapi: [6] },
+    phonemes: ["IY", "IH", "IX", "Y"],
+    matchers: ["(^|[_ .-])(v|viseme)?[_ .-]?(ee|iy|y)([_ .-]|$)"],
+    features: { jawOpen: 0.2, lipSpread: 0.8 },
+    defaultJawAmount: VISEME_JAW_AMOUNTS[4]
+  },
+  {
+    id: "er",
+    label: "Er",
+    order: 5,
+    providerIds: { azure: [5], sapi: [5] },
+    phonemes: ["ER"],
+    matchers: ["(^|[_ .-])(v|viseme)?[_ .-]?(er)([_ .-]|$)"],
+    features: { jawOpen: 0.35, lipRound: 0.35 },
+    defaultJawAmount: VISEME_JAW_AMOUNTS[5]
+  },
+  {
+    id: "f-v",
+    label: "F_V",
+    order: 6,
+    providerIds: { azure: [18], sapi: [18] },
+    phonemes: ["F", "V"],
+    matchers: ["(^|[_ .-])(v|viseme)?[_ .-]?(f[_ .-]?v|fv)([_ .-]|$)"],
+    features: { jawOpen: 0.1, fricative: 1 },
+    defaultJawAmount: VISEME_JAW_AMOUNTS[6]
+  },
+  {
+    id: "ih",
+    label: "Ih",
+    order: 7,
+    providerIds: { azure: [6], sapi: [6] },
+    phonemes: ["IH", "IX"],
+    matchers: ["(^|[_ .-])(v|viseme)?[_ .-]?(ih|ix)([_ .-]|$)"],
+    features: { jawOpen: 0.2, lipSpread: 0.55 },
+    defaultJawAmount: VISEME_JAW_AMOUNTS[7]
+  },
+  {
+    id: "k-g-h-ng",
+    label: "K_G_H_NG",
+    order: 8,
+    providerIds: { azure: [20], sapi: [20] },
+    phonemes: ["K", "G", "NG"],
+    matchers: ["(^|[_ .-])(v|viseme)?[_ .-]?(k[_ .-]?g[_ .-]?h?[_ .-]?ng|kg|ng)([_ .-]|$)"],
+    features: { jawOpen: 0.35 },
+    defaultJawAmount: VISEME_JAW_AMOUNTS[8]
+  },
+  {
+    id: "oh",
+    label: "Oh",
+    order: 9,
+    providerIds: { azure: [3, 8, 10], sapi: [3, 8, 10] },
+    phonemes: ["AO", "OW", "OY"],
+    matchers: ["(^|[_ .-])(v|viseme)?[_ .-]?(oh|ao|ow|oy)([_ .-]|$)"],
+    features: { jawOpen: 0.6, lipRound: 0.8 },
+    defaultJawAmount: VISEME_JAW_AMOUNTS[9]
+  },
+  {
+    id: "r",
+    label: "R",
+    order: 10,
+    providerIds: { azure: [13], sapi: [13] },
+    phonemes: ["R"],
+    matchers: ["(^|[_ .-])(v|viseme)?[_ .-]?(r)([_ .-]|$)"],
+    features: { jawOpen: 0.35, lipRound: 0.5 },
+    defaultJawAmount: VISEME_JAW_AMOUNTS[10]
+  },
+  {
+    id: "s-z",
+    label: "S_Z",
+    order: 11,
+    providerIds: { azure: [15], sapi: [15] },
+    phonemes: ["S", "Z"],
+    matchers: ["(^|[_ .-])(v|viseme)?[_ .-]?(s[_ .-]?z|sz)([_ .-]|$)"],
+    features: { jawOpen: 0.1, fricative: 1 },
+    defaultJawAmount: VISEME_JAW_AMOUNTS[11]
+  },
+  {
+    id: "t-l-d-n",
+    label: "T_L_D_N",
+    order: 12,
+    providerIds: { azure: [14, 19], sapi: [14, 19] },
+    phonemes: ["T", "L", "D", "N"],
+    matchers: ["(^|[_ .-])(v|viseme)?[_ .-]?(t[_ .-]?l[_ .-]?d[_ .-]?n|tldn|l)([_ .-]|$)"],
+    features: { jawOpen: 0.3, tongueTip: 1 },
+    defaultJawAmount: VISEME_JAW_AMOUNTS[12]
+  },
+  {
+    id: "th",
+    label: "Th",
+    order: 13,
+    providerIds: { azure: [17], sapi: [17] },
+    phonemes: ["TH", "DH"],
+    matchers: ["(^|[_ .-])(v|viseme)?[_ .-]?(th|dh)([_ .-]|$)"],
+    features: { jawOpen: 0.15, tongueTip: 0.8, fricative: 0.8 },
+    defaultJawAmount: VISEME_JAW_AMOUNTS[13]
+  },
+  {
+    id: "w-oo",
+    label: "W_OO",
+    order: 14,
+    providerIds: { azure: [7], sapi: [7] },
+    phonemes: ["W", "UW"],
+    matchers: ["(^|[_ .-])(v|viseme)?[_ .-]?(w[_ .-]?oo|woo|uw|oo)([_ .-]|$)"],
+    features: { jawOpen: 0.5, lipRound: 1 },
+    defaultJawAmount: VISEME_JAW_AMOUNTS[14]
+  }
+];
 var isMixedAU = (id) => {
   const morphs = AU_TO_MORPHS[id];
   const hasMorphs = !!(morphs?.left?.length || morphs?.right?.length || morphs?.center?.length);
@@ -2709,6 +3347,23 @@ var AU_FACEPART_TO_MESH_CATEGORY = {
   Eyelids: "eye",
   Tongue: "tongue"
 };
+var CC4_MAPPING_SECTIONS = [
+  { id: "Forehead", label: "Forehead", kind: "au", order: 0, meshCategory: "face", facePart: "Forehead" },
+  { id: "Eyelids", label: "Eyelids", kind: "au", order: 1, meshCategory: "eye", facePart: "Eyelids" },
+  { id: "Eyes", label: "Eyes", kind: "au", order: 2, meshCategory: "eye", facePart: "Eyes" },
+  { id: "Cheeks", label: "Cheeks", kind: "au", order: 3, meshCategory: "face", facePart: "Cheeks" },
+  { id: "Nose", label: "Nose", kind: "au", order: 4, meshCategory: "face", facePart: "Nose" },
+  { id: "Mouth", label: "Mouth", kind: "au", order: 5, meshCategory: "face", facePart: "Mouth" },
+  { id: "Chin", label: "Chin", kind: "au", order: 6, meshCategory: "face", facePart: "Chin" },
+  { id: "Jaw", label: "Jaw", kind: "au", order: 7, meshCategory: "face", facePart: "Jaw" },
+  { id: "Tongue", label: "Tongue", kind: "au", order: 8, meshCategory: "tongue", facePart: "Tongue" },
+  { id: "Head", label: "Head", kind: "au", order: 9, meshCategory: "face", facePart: "Head" },
+  { id: "Joint Controls", label: "Joint Controls", kind: "au", order: 10, meshCategory: "face", facePart: "Joint Controls" },
+  { id: "Eye", label: "Eye", kind: "au", order: 11, meshCategory: "eye", facePart: "Eye" },
+  { id: "Hair", label: "Hair", kind: "hair", order: 12, meshCategory: "hair" },
+  { id: "Visemes", label: "Visemes", kind: "viseme", order: 13, meshCategory: "viseme" },
+  { id: "Unmapped", label: "Unmapped", kind: "unmapped", order: 14, meshCategory: "face" }
+];
 var CC4_HAIR_PHYSICS = {
   stiffness: 7.5,
   damping: 0.18,
@@ -2755,7 +3410,10 @@ var CC4_PRESET = {
   suffixPattern: CC4_SUFFIX_PATTERN,
   morphToMesh: MORPH_TO_MESH,
   auFacePartToMeshCategory: AU_FACEPART_TO_MESH_CATEGORY,
+  mappingSections: CC4_MAPPING_SECTIONS,
   visemeKeys: VISEME_KEYS,
+  visemeSystemId: CC4_VISEME_SYSTEM_ID,
+  visemeSlots: CC4_VISEME_SLOTS,
   visemeMeshCategory: "viseme",
   visemeJawAmounts: VISEME_JAW_AMOUNTS,
   auMixDefaults: AU_MIX_DEFAULTS,
@@ -3642,8 +4300,13 @@ function extendPresetWithProfile(base, extension) {
     boneNodes: mergeRecord(base.boneNodes, extension.boneNodes),
     morphToMesh: mergeRecord(base.morphToMesh, extension.morphToMesh),
     auFacePartToMeshCategory: base.auFacePartToMeshCategory || extension.auFacePartToMeshCategory ? mergeRecord(base.auFacePartToMeshCategory || {}, extension.auFacePartToMeshCategory || {}) : void 0,
+    mappingSections: extension.mappingSections ? [...extension.mappingSections] : base.mappingSections ? [...base.mappingSections] : void 0,
     visemeKeys: extension.visemeKeys ? [...extension.visemeKeys] : [...base.visemeKeys],
+    visemeSystemId: extension.visemeSystemId ?? base.visemeSystemId,
+    visemeSlots: extension.visemeSlots ? [...extension.visemeSlots] : base.visemeSlots ? [...base.visemeSlots] : void 0,
+    visemeBindings: base.visemeBindings || extension.visemeBindings ? mergeRecord(base.visemeBindings || {}, extension.visemeBindings || {}) : void 0,
     visemeMeshCategory: extension.visemeMeshCategory ?? base.visemeMeshCategory,
+    visemeJawAmounts: extension.visemeJawAmounts ? [...extension.visemeJawAmounts] : base.visemeJawAmounts ? [...base.visemeJawAmounts] : void 0,
     auMixDefaults: base.auMixDefaults || extension.auMixDefaults ? mergeRecord(base.auMixDefaults || {}, extension.auMixDefaults || {}) : void 0,
     auInfo: base.auInfo || extension.auInfo ? mergeRecord(base.auInfo || {}, extension.auInfo || {}) : void 0,
     eyeMeshNodes: extension.eyeMeshNodes ?? base.eyeMeshNodes,
@@ -4605,7 +5268,8 @@ var _Loom3 = class _Loom3 {
       getCompositeRotations: () => this.compositeRotations,
       computeSideValues: (base, balance) => this.computeSideValues(base, balance),
       getAUMixWeight: (auId) => this.getAUMixWeight(auId),
-      isMixedAU: (auId) => this.isMixedAU(auId)
+      isMixedAU: (auId) => this.isMixedAU(auId),
+      reapplyProceduralState: () => this.reapplyProceduralStateAfterBakedUpdate()
     });
     this.hairPhysics = new HairPhysicsController({
       getMeshByName: (name) => this.meshByName.get(name),
@@ -5209,6 +5873,21 @@ var _Loom3 = class _Loom3 {
     const jawHandle = this.transitionBoneRotation("JAW", "pitch", jawAmount, durationMs);
     return this.combineHandles([morphHandle, jawHandle]);
   }
+  setVisemeById(slotId, value, jawScale = 1) {
+    const index = getVisemeSlotIndex(this.config, slotId);
+    if (index < 0) return;
+    this.setViseme(index, value, jawScale);
+  }
+  transitionVisemeById(slotId, to, durationMs = 80, jawScale = 1) {
+    const index = getVisemeSlotIndex(this.config, slotId);
+    if (index < 0) {
+      return { promise: Promise.resolve(), pause: () => {
+      }, resume: () => {
+      }, cancel: () => {
+      } };
+    }
+    return this.transitionViseme(index, to, durationMs, jawScale);
+  }
   // ============================================================================
   // MIX WEIGHT CONTROL
   // ============================================================================
@@ -5301,6 +5980,30 @@ var _Loom3 = class _Loom3 {
       this.model.updateMatrixWorld(true);
     }
   }
+  reapplyProceduralStateAfterBakedUpdate() {
+    if (!this.model) {
+      return;
+    }
+    let hasActiveOverrides = false;
+    for (const [auIdStr, value] of Object.entries(this.auValues)) {
+      if (value <= 0) continue;
+      const auId = Number(auIdStr);
+      if (Number.isNaN(auId)) continue;
+      hasActiveOverrides = true;
+      this.setAU(auId, value, this.auBalances[auId]);
+    }
+    for (let visemeIndex = 0; visemeIndex < this.visemeValues.length; visemeIndex += 1) {
+      const value = this.visemeValues[visemeIndex] ?? 0;
+      if (value <= 0) continue;
+      hasActiveOverrides = true;
+      this.setViseme(visemeIndex, value, this.visemeJawScales[visemeIndex] ?? 1);
+    }
+    if (!hasActiveOverrides) {
+      return;
+    }
+    this.flushPendingComposites();
+    this.model.updateMatrixWorld(true);
+  }
   // ============================================================================
   // MESH CONTROL
   // ============================================================================
@@ -5554,21 +6257,10 @@ var _Loom3 = class _Loom3 {
    * Routing is driven by `auFacePartToMeshCategory` in profile config.
    */
   getMeshNamesForAU(auId) {
-    const m = this.config.morphToMesh;
-    const info = this.config.auInfo?.[String(auId)];
-    const facePart = info?.facePart;
-    if (facePart) {
-      const category = this.config.auFacePartToMeshCategory?.[facePart];
-      if (category) {
-        return m?.[category] || [];
-      }
-    }
-    return m?.face || [];
+    return getMeshNamesForAUProfile(this.config, auId);
   }
   getMeshNamesForViseme() {
-    const m = this.config.morphToMesh;
-    const category = this.config.visemeMeshCategory || (m?.viseme ? "viseme" : "face");
-    return m?.[category] || m?.face || [];
+    return getMeshNamesForVisemeProfile(this.config);
   }
   // ============================================================================
   // HAIR PHYSICS
@@ -5836,7 +6528,7 @@ var _Loom3 = class _Loom3 {
     );
   }
   getVisemeJawAmount(visemeIndex) {
-    return this.config.visemeJawAmounts?.[visemeIndex] ?? _Loom3.VISEME_JAW_AMOUNTS[visemeIndex] ?? 0;
+    return getVisemeJawAmounts(this.config)?.[visemeIndex] ?? this.config.visemeJawAmounts?.[visemeIndex] ?? _Loom3.VISEME_JAW_AMOUNTS[visemeIndex] ?? 0;
   }
   collectResolvedExpressionMorphTargets() {
     const targets = [];
@@ -6314,7 +7006,11 @@ var PROFILE_OVERRIDE_KEYS = [
   "rightMorphSuffixes",
   "morphToMesh",
   "auFacePartToMeshCategory",
+  "mappingSections",
   "visemeKeys",
+  "visemeSystemId",
+  "visemeSlots",
+  "visemeBindings",
   "visemeMeshCategory",
   "visemeJawAmounts",
   "auMixDefaults",
@@ -7414,6 +8110,33 @@ function validateMappingConfig(config) {
     }
     visemeSeen.add(key);
   }
+  const morphCategories = new Set(Object.keys(config.morphToMesh || {}));
+  if (config.visemeMeshCategory && !morphCategories.has(config.visemeMeshCategory)) {
+    push(
+      "error",
+      "VISEME_MESH_CATEGORY_MISSING",
+      `visemeMeshCategory "${config.visemeMeshCategory}" is not present in morphToMesh`,
+      { category: config.visemeMeshCategory }
+    );
+  }
+  for (const [facePart, category] of Object.entries(config.auFacePartToMeshCategory || {})) {
+    if (!morphCategories.has(category)) {
+      push(
+        "error",
+        "AU_MESH_CATEGORY_MISSING",
+        `AU facePart "${facePart}" routes to missing morphToMesh category "${category}"`,
+        { facePart, category }
+      );
+    }
+  }
+  if (config.visemeJawAmounts && config.visemeJawAmounts.length !== (config.visemeKeys || []).length) {
+    push(
+      "warning",
+      "VISEME_JAW_AMOUNT_LENGTH_MISMATCH",
+      "visemeJawAmounts length does not match visemeKeys length",
+      { visemeKeys: (config.visemeKeys || []).length, visemeJawAmounts: config.visemeJawAmounts.length }
+    );
+  }
   if (config.auMixDefaults) {
     for (const key of Object.keys(config.auMixDefaults)) {
       const auId = Number(key);
@@ -7878,9 +8601,12 @@ exports.BONE_AU_TO_BINDINGS = BONE_AU_TO_BINDINGS;
 exports.CC4_BONE_NODES = CC4_BONE_NODES;
 exports.CC4_BONE_PREFIX = CC4_BONE_PREFIX;
 exports.CC4_EYE_MESH_NODES = CC4_EYE_MESH_NODES;
+exports.CC4_MAPPING_SECTIONS = CC4_MAPPING_SECTIONS;
 exports.CC4_MESHES = CC4_MESHES;
 exports.CC4_PRESET = CC4_PRESET;
 exports.CC4_SUFFIX_PATTERN = CC4_SUFFIX_PATTERN;
+exports.CC4_VISEME_SLOTS = CC4_VISEME_SLOTS;
+exports.CC4_VISEME_SYSTEM_ID = CC4_VISEME_SYSTEM_ID;
 exports.COMPOSITE_ROTATIONS = COMPOSITE_ROTATIONS;
 exports.CONTINUUM_LABELS = CONTINUUM_LABELS;
 exports.CONTINUUM_PAIRS_MAP = CONTINUUM_PAIRS_MAP;
@@ -7895,7 +8621,9 @@ exports.VISEME_JAW_AMOUNTS = VISEME_JAW_AMOUNTS;
 exports.VISEME_KEYS = VISEME_KEYS;
 exports.analyzeModel = analyzeModel;
 exports.applyCharacterProfileToPreset = applyCharacterProfileToPreset;
+exports.buildMappingEditorModel = buildMappingEditorModel;
 exports.collectMorphMeshes = collectMorphMeshes;
+exports.compileVisemeKeys = compileVisemeKeys;
 exports.computeCameraRelativeGazeOffset = computeCameraRelativeGazeOffset;
 exports.detectFacingDirection = detectFacingDirection;
 exports.extendCharacterConfigWithPreset = extendCharacterConfigWithPreset;
@@ -7906,18 +8634,25 @@ exports.extractProfileOverrides = extractProfileOverrides;
 exports.findFaceCenter = findFaceCenter;
 exports.fuzzyNameMatch = fuzzyNameMatch;
 exports.generateMappingCorrections = generateMappingCorrections;
+exports.getMeshNamesForAUProfile = getMeshNamesForAUProfile;
+exports.getMeshNamesForVisemeProfile = getMeshNamesForVisemeProfile;
 exports.getModelForwardDirection = getModelForwardDirection;
 exports.getPreset = getPreset;
 exports.getPresetWithProfile = getPresetWithProfile;
+exports.getProfileVisemeSlots = getProfileVisemeSlots;
+exports.getVisemeJawAmounts = getVisemeJawAmounts;
+exports.getVisemeSlotIndex = getVisemeSlotIndex;
 exports.hasLeftRightMorphs = hasLeftRightMorphs;
 exports.isMixedAU = isMixedAU;
 exports.isPresetCompatible = isPresetCompatible;
+exports.mapProviderVisemeToSlot = mapProviderVisemeToSlot;
 exports.mergeCharacterRegionsByName = mergeRegionsByName;
 exports.resolveBoneName = resolveBoneName;
 exports.resolveBoneNames = resolveBoneNames;
 exports.resolveFaceCenter = resolveFaceCenter;
 exports.resolvePreset = resolvePreset;
 exports.resolvePresetWithOverrides = resolvePresetWithOverrides;
+exports.resolveVisemeMeshCategory = resolveVisemeMeshCategory;
 exports.suggestBestPreset = suggestBestPreset;
 exports.validateMappingConfig = validateMappingConfig;
 exports.validateMappings = validateMappings;