From 2486c3cb6385e7e77c531d79befbacb4f9722ebc Mon Sep 17 00:00:00 2001
From: L1Z0 <2grif484d@mozmail.com>
Date: Mon, 28 Sep 2026 21:30:49 +0200
Subject: [PATCH] added a way to auto import full animations

---
 AnimationDirector.js            | 1339 +++++++++++++++++--------------
 test/automatic-import.test.js   |  372 +++++++++
 test/block-requirements.test.js |  142 +++-
 3 files changed, 1254 insertions(+), 599 deletions(-)
 create mode 100644 test/automatic-import.test.js

diff --git a/AnimationDirector.js b/AnimationDirector.js
index 638da22..e3dfc0e 100644
--- a/AnimationDirector.js
+++ b/AnimationDirector.js
@@ -15,6 +15,9 @@
   let blockRequirementPanel, blockRequirementPanelListener, blockRequirementPanelCss;
   let blockRequirementPendingTimer;
   let blockGuideProjectListener;
+  let importAnimationDefinitionAction;
+  let automaticImportAction;
+  let packFoldersAction;
   const SYSTEM_TAG_OPTIONS = {
     '': 'None (normal animation)',
     manualpeak: 'Manual peak',
@@ -26,7 +29,7 @@
     other: 'Other',
   };
 
-  let importAction, replaceActorAction, importConjoinedAnimationAction, importSplitAnimationAction, exportSelectedAction, exportAllAction, exportConjoinedAction, createAnimationDefinitionAction, actorPreferencesAction, boneTextureOverridesAction, exportGeckoModelAction;
+  let importAction, replaceActorAction, importConjoinedAnimationAction, exportConjoinedAction, createAnimationDefinitionAction, actorPreferencesAction, boneTextureOverridesAction, exportGeckoModelAction;
   let actorNamesProjectProperty, actorTexturesProjectProperty, boneTextureOverridesProjectProperty, actorAnimdefMetadataProjectProperty, animdefAnimatorsProjectProperty, animdefDefinitionsProjectProperty;
   let actorTexturePreviewProjectListener;
   const ACTOR_TEXTURE_PREVIEW_EVENTS = ['load_project', 'select_project', 'setup_project', 'load_from_recent_project_data', 'add_texture', 'change_texture_path'];
@@ -519,15 +522,6 @@
     return i;
   }
 
-  function getMaxActorIndexFromProject() {
-    let max = 0;
-    for (const g of Group.all) {
-      const idx = readActorIndexFromName(g?.name || '');
-      if (idx && idx > max) max = idx;
-    }
-    return max;
-  }
-
   function extractGeckoGeometryRoot(json) {
     return json?.['minecraft:geometry']?.[0] || null;
   }
@@ -794,7 +788,7 @@
     if (elements.length) Canvas.updateView({ elements, element_aspects: { faces: true, uv: true } });
   }
 
-  function rebuildBlockRequirementGuides(animationId, entry) {
+  function rebuildBlockRequirementGuides(animationId, entry, importedDefinition, manageUndo = true) {
     const boxes = entry ? buildBlockRequirementGuideBoxes(entry) : [];
     const groupName = `${BLOCK_GUIDE_PREFIX}${animationId}`;
     const oldGroups = Group.all.filter((group) => group.name === groupName);
@@ -805,8 +799,8 @@
     else updated[animationId] = { requirement: null };
     const createdElements = [];
     const createdGroups = [];
-    Undo.initEdit({ outliner: true, elements: oldElements, groups: oldGroups,
-      block_requirement_edit: true });
+    if (manageUndo) Undo.initEdit({ outliner: true, elements: oldElements, groups: oldGroups,
+      block_requirement_edit: true, animdef_edit: importedDefinition !== undefined });
     if (entry) {
       const root = oldGroups[0] || new Group({ name: groupName, export: false });
       if (!oldGroups.length) { root.init(); root.addTo('root'); }
@@ -828,19 +822,21 @@
       for (const group of oldGroups) group.remove();
     }
     Project[BLOCK_REQUIREMENTS_PROPERTY] = JSON.stringify(updated);
+    if (importedDefinition !== undefined) saveAnimdef(animationId, importedDefinition);
     hideInternalBlockGuideFaces(createdElements);
     // Rebuilding every cube would reset forced actor materials in single-texture formats.
     Canvas.updateView({ elements: createdElements, groups: createdGroups,
       element_aspects: { transform: true, geometry: true, faces: true, uv: true, visibility: true } });
     for (const cube of createdElements) applyBlockRequirementGuideMaterial(cube);
-    Undo.finishEdit(entry ? 'Set block requirement' : 'Remove block requirement',
-      { outliner: true, elements: createdElements, groups: createdGroups, block_requirement_edit: true });
+    if (manageUndo) Undo.finishEdit(importedDefinition !== undefined ? 'Import animation definition' : entry ? 'Set block requirement' : 'Remove block requirement',
+      { outliner: true, elements: createdElements, groups: createdGroups, block_requirement_edit: true,
+        animdef_edit: importedDefinition !== undefined });
     Project.saved = false;
   }
 
-  function buildBlockRequirementForm(animationId) {
+  function buildBlockRequirementForm(animationId, importedRequirement) {
     const entry = getAuthoredBlockRequirement(animationId);
-    const req = (entry ? entry.requirement : getSavedAnimdef(animationId).block_requirements) || {};
+    const req = importedRequirement ?? (entry ? entry.requirement : getSavedAnimdef(animationId).block_requirements) ?? {};
     const wall = (result) => result?.type === 'wall';
     const center = (result) => result?.type === 'center_support';
     const directional = (result) => wall(result) || result?.placement !== 'surface_footprint';
@@ -1108,7 +1104,7 @@
     return { rebound, missing };
   }
 
-  function importGeometryIntoCurrentProject(geo, actorIndex, replaceExisting = false) {
+  function importGeometryIntoCurrentProject(geo, actorIndex, replaceExisting = false, manageUndo = true) {
     const bones = Array.isArray(geo?.bones) ? geo.bones : [];
     if (!bones.length) {
       Blockbench.showQuickMessage('No bones found in this geometry JSON.', 2500);
@@ -1118,7 +1114,7 @@
     const prefix = `actor${actorIndex}_`;
     const previousBindings = replaceExisting ? captureActorAnimationBindings(actorIndex) : null;
 
-    Undo.initEdit({ outliner: true, selection: true, elements: [], textures: [],
+    if (manageUndo) Undo.initEdit({ outliner: true, selection: true, elements: [], textures: [],
       animations: previousBindings ? previousBindings.map((entry) => entry.animation) : [] });
     if (replaceExisting) removeActorGeometry(actorIndex);
 
@@ -1205,15 +1201,17 @@
       ? rebindActorAnimations(actorIndex, previousBindings)
       : { rebound: 0, missing: 0 };
 
-    Canvas.updateAll();
-    applyAllActorTexturePreviews(false);
+    if (manageUndo) {
+      Canvas.updateAll();
+      applyAllActorTexturePreviews(false);
+    }
     if (replaceExisting && typeof Animation !== 'undefined' && Animation.selected) Animation.selected.select();
-    Undo.finishEdit(`${replaceExisting ? 'Replace' : 'Import'} Actor ${actorIndex}`);
+    if (manageUndo) Undo.finishEdit(`${replaceExisting ? 'Replace' : 'Import'} Actor ${actorIndex}`);
 
     const animationNotice = replaceExisting && animationResult.rebound
       ? `, rebound ${animationResult.rebound} animation channel${animationResult.rebound === 1 ? '' : 's'}`
       : '';
-    Blockbench.showQuickMessage(`${replaceExisting ? 'Replaced' : 'Imported'} actor with prefix "${prefix}"${animationNotice}`, 3000);
+    if (manageUndo) Blockbench.showQuickMessage(`${replaceExisting ? 'Replaced' : 'Imported'} actor with prefix "${prefix}"${animationNotice}`, 3000);
 
     if (replaceExisting && animationResult.missing) {
       Blockbench.showMessageBox({
@@ -2198,31 +2196,7 @@
     return out;
   }
 
-  function buildActorAnimationOutputsForAnimation(anim, maxActor) {
-    if (typeof anim?.compileBedrockAnimation !== 'function') {
-      throw new Error(`Animation compiler not available for "${anim?.name || 'animation'}" (missing compileBedrockAnimation).`);
-    }
-
-    const animKey = anim.name || 'animation.unnamed';
-    const safeAnim = sanitizeFilePart(animKey);
-
-    const compiled = anim.compileBedrockAnimation() || {};
-    const baseFile = compiled.animations ? compiled : { format_version: '1.8.0', animations: { [animKey]: compiled } };
-
-    const outputs = [];
-    for (let i = 1; i <= maxActor; i++) {
-      const f = clone(baseFile);
-      stripPrefixFromAnimationFileForActor(f, i);
-      const safeActor = sanitizeFilePart(getActorExportLabel(i)) || `actor${i}`;
-      outputs.push({
-        name: `${safeAnim}_${safeActor}.animation`,
-        content: stringifyInlineVec3(f, 2),
-      });
-    }
-    return outputs;
-  }
-
-  function exportActorAnimationOutputs(outputs, doneMessage) {
+  function exportAnimationOutputs(outputs, doneMessage) {
     let idx = 0;
     const next = () => {
       if (idx >= outputs.length) {
@@ -2244,59 +2218,6 @@
     next();
   }
 
-  function exportSelectedActorAnimation() {
-    const anim = getSelectedAnimation();
-    if (!anim) {
-      Blockbench.showQuickMessage('No animation selected.', 2500);
-      return;
-    }
-
-    const maxActor = getMaxActorIndexFromProject();
-    if (maxActor < 1) {
-      Blockbench.showQuickMessage('No actorN_ bones found in this project.', 2500);
-      return;
-    }
-
-    try {
-      const outputs = buildActorAnimationOutputsForAnimation(anim, maxActor);
-      exportActorAnimationOutputs(outputs, `Exported ${outputs.length} actor animation files`);
-    } catch (e) {
-      console.error(e);
-      Blockbench.showMessageBox({
-        title: 'Export Selected Animations (Split Files)',
-        message: `Export failed: ${e?.message || e}`,
-        buttons: ['OK'],
-      });
-    }
-  }
-
-  function exportAllActorAnimations() {
-    const animations = Array.isArray(Animation.all) ? Animation.all.filter((a) => a) : [];
-    if (!animations.length) {
-      Blockbench.showQuickMessage('No animations found.', 2500);
-      return;
-    }
-
-    const maxActor = getMaxActorIndexFromProject();
-    if (maxActor < 1) {
-      Blockbench.showQuickMessage('No actorN_ bones found in this project.', 2500);
-      return;
-    }
-
-    try {
-      const outputs = [];
-      for (const anim of animations) outputs.push(...buildActorAnimationOutputsForAnimation(anim, maxActor));
-      exportActorAnimationOutputs(outputs, `Exported ${outputs.length} actor animation files from ${animations.length} animations`);
-    } catch (e) {
-      console.error(e);
-      Blockbench.showMessageBox({
-        title: 'Export All Animations (Split Files)',
-        message: `Export failed: ${e?.message || e}`,
-        buttons: ['OK'],
-      });
-    }
-  }
-
   function parseAfwStageAnimationName(animation) {
     const name = String(animation?.name || '').trim();
     const match = /^([a-z0-9._-]+)\.p(\d+)$/.exec(name);
@@ -2470,7 +2391,7 @@
   function exportSelectedConjoinedAnimationGroups(groups) {
     try {
       const outputs = groups.map(buildConjoinedAnimationOutput);
-      exportActorAnimationOutputs(
+      exportAnimationOutputs(
         outputs,
         `Exported ${outputs.length} animation file${outputs.length === 1 ? '' : 's'}`
       );
@@ -2727,9 +2648,154 @@
     );
   }
 
+  const DEFINITION_GENERATOR_KEYS = new Set(['display_name', 'animators', 'system_tags', 'animation_tags',
+    'content_tags', 'required_union_tags', 'join_after', 'match_content_on_join', 'weight', 'attack_eligible',
+    'liquid_gain_multiplier', 'speed', 'water', 'position_anchor_actor', 'camera', 'manual_peak', 'tease', 'stuck',
+    'actors', 'stages', 'block_requirements']);
+  const ACTOR_GENERATOR_KEYS = new Set(['label', 'entity_types', 'entity_variant', 'actor_tags', 'actor_tags_any',
+    'activity', 'injector', 'receiver', 'injects_into', 'held_item']);
+  const STAGE_GENERATOR_KEYS = new Set(['stage', 'loop', 'cycle_seconds', 'allow_join', 'escapable', 'non_peak',
+    'speed', 'use_stage', 'stage_seconds', 'stage_duration_multiplier', 'cycle_midpoint_offset_seconds']);
+
+  function unmanagedAnimdefFields(source, keys) {
+    return Object.fromEntries(Object.entries(source || {}).filter(([key]) => !keys.has(key)));
+  }
+
+  function prepareAnimationDefinitionImport(source, analysis) {
+    const isObject = (value) => value && typeof value === 'object' && !Array.isArray(value);
+    if (!isObject(source) || !Array.isArray(source.actors) || !source.actors.length
+      || !Array.isArray(source.stages) || !source.stages.length) {
+      throw new Error('Expected an animation definition JSON with non-empty actors and stages arrays (not an animation asset).');
+    }
+    const definition = clone(source);
+    for (const key of ['animators', 'system_tags', 'animation_tags', 'content_tags', 'required_union_tags', 'join_after']) {
+      if (definition[key] !== undefined && (!Array.isArray(definition[key]) || definition[key].some((value) => typeof value !== 'string'))) {
+        throw new Error(`${key} must be an array of strings.`);
+      }
+    }
+    for (const key of ['camera', 'manual_peak', 'tease', 'stuck', 'block_requirements']) {
+      if (definition[key] !== undefined && !isObject(definition[key])) throw new Error(`${key} must be an object.`);
+    }
+    if (definition.system_tags === undefined && definition.animation_tags !== undefined) {
+      definition.system_tags = definition.animation_tags;
+    }
+    delete definition.animation_tags;
+    if (definition.actors.length !== analysis.actorIndices.length) {
+      throw new Error(`The definition has ${definition.actors.length} actors, but this animation has ${analysis.actorIndices.length}. Select an animation with the same actors.`);
+    }
+    const stageNumbers = new Set(analysis.stages.map((stage) => stage.stageNumber));
+    const seenStages = new Set();
+    for (const stage of definition.stages) {
+      if (!isObject(stage) || !Number.isInteger(stage.stage) || !stageNumbers.has(stage.stage) || seenStages.has(stage.stage)) {
+        throw new Error('Imported stages must have unique stage numbers matching the target animation.');
+      }
+      seenStages.add(stage.stage);
+    }
+    if (seenStages.size !== stageNumbers.size) throw new Error('The definition must include every stage of the target animation.');
+
+    const roles = analysis.actorIndices.map((index) => analysis.actorLabels.get(index));
+    const labels = new Set();
+    for (const actor of definition.actors) {
+      if (!isObject(actor)) throw new Error('Every actor must be an object.');
+      if (actor.label !== undefined && (typeof actor.label !== 'string' || !actor.label.trim() || labels.has(actor.label))) {
+        throw new Error('Explicit actor labels must be non-empty, unique strings.');
+      }
+      if (actor.label) labels.add(actor.label);
+      for (const key of ['entity_types', 'actor_tags', 'actor_tags_any']) {
+        if (actor[key] !== undefined && (!Array.isArray(actor[key]) || actor[key].some((value) => typeof value !== 'string'))) {
+          throw new Error(`Actor ${key} must be an array of strings.`);
+        }
+      }
+      if (actor.held_item !== undefined && !isObject(actor.held_item)) throw new Error('Actor held_item must be an object.');
+    }
+    // Reserve exact matches first; unmatched or unlabeled actors use remaining roles in order.
+    const assigned = definition.actors.map((actor) => roles.includes(actor.label) ? actor.label : null);
+    const available = roles.filter((role) => !assigned.includes(role));
+    const labelMap = new Map();
+    definition.actors.forEach((actor, index) => {
+      assigned[index] ||= available.shift();
+      labelMap.set(actor.label || `actor${index + 1}`, assigned[index]);
+    });
+    definition.actors.forEach((actor, index) => {
+      actor.label = assigned[index];
+      if (actor.injects_into !== undefined) {
+        const targets = typeof actor.injects_into === 'string' ? [actor.injects_into] : actor.injects_into;
+        if (!Array.isArray(targets) || targets.some((target) => !labelMap.has(target))) {
+          throw new Error(`Actor ${actor.label} references an unknown injection target.`);
+        }
+        actor.injects_into = targets.map((target) => labelMap.get(target));
+        if (actor.injects_into.includes(actor.label)) throw new Error('An actor cannot inject into itself.');
+      }
+    });
+    definition.actors.sort((a, b) => roles.indexOf(a.label) - roles.indexOf(b.label));
+    if (definition.position_anchor_actor !== undefined) {
+      if (!labelMap.has(definition.position_anchor_actor)) throw new Error('The position anchor references an unknown actor.');
+      definition.position_anchor_actor = labelMap.get(definition.position_anchor_actor);
+    }
+    return definition;
+  }
+
+  function applyAnimationDefinitionImport(group, analysis, source) {
+    const definition = prepareAnimationDefinitionImport(source, analysis);
+    let entry = null;
+    if (definition.block_requirements) {
+      const req = definition.block_requirements;
+      if (!['wall', 'center_support'].includes(req.type)
+        || (req.facing && !['front', 'back', 'left', 'right'].includes(req.facing))
+        || (req.support && !['full_block', 'slab', 'half_height', 'surface'].includes(req.support))
+        || (req.placement && !['directional_clearance', 'surface_footprint'].includes(req.placement))) {
+        throw new Error('The block requirement has an unsupported type, support, placement or facing.');
+      }
+      const form = buildBlockRequirementForm(group.id, req);
+      const values = Object.fromEntries(Object.entries(form).filter(([, field]) => field.type !== 'info').map(([key, field]) => [key, field.value]));
+      entry = readBlockRequirementForm(values);
+      buildBlockRequirementGuideBoxes(entry);
+    }
+    cancelBlockRequirementUpdate();
+    rebuildBlockRequirementGuides(group.id, entry, definition);
+    if (blockRequirementPanel?.vue) blockRequirementPanel.vue.load(group.id);
+    showAnimationDefinitionReviewDialog(group, analysis);
+  }
+
+  function importAnimationDefinition() {
+    if (!Project) return Blockbench.showQuickMessage('Open an animation project first.', 2500);
+    const projectId = Project.uuid;
+    Filesystem.importFile({ type: 'AFW Animation Definition', extensions: ['json'], multiple: false,
+      readtype: 'text', title: 'Import Animation Definition' }, (files) => {
+      if (!files?.length) return;
+      const report = (error) => Blockbench.showMessageBox({ title: 'Import Animation Definition', message: error.message, buttons: ['OK'] });
+      try {
+        if (!Project || Project.uuid !== projectId) throw new Error('The active project changed. Import the definition again.');
+        const source = JSON.parse(String(files[0].content || '').replace(/^\uFEFF/, ''));
+        const groups = collectConjoinedAnimationGroups().groups;
+        if (!groups.length) throw new Error('Import your animation assets first (named <animationId>.p<number>), then import their definition.');
+        const options = Object.fromEntries(groups.map((group) => [group.id, group.id]));
+        const fileId = String(files[0].name || files[0].path || '').split(/[\\/]/).pop().replace(/\.json$/i, '');
+        const selected = parseAfwStageAnimationName(getSelectedAnimation());
+        new Dialog({ id: 'animationdirector_import_animdef', title: 'Import Animation Definition', width: 520,
+          form: {
+            _info: { type: 'info', text: 'Choose the target animation. This replaces its saved definition and block guides. Actor labels are matched first; remaining actors are assigned in order. Keyframes and models are unchanged.' },
+            animation_id: { label: 'Animation', type: 'select', options,
+              value: options[fileId] ? fileId : options[selected?.id] ? selected.id : groups[0].id },
+          },
+          onConfirm(result) {
+            try {
+              if (!Project || Project.uuid !== projectId) throw new Error('The active project changed. Import the definition again.');
+              const group = collectConjoinedAnimationGroups().groups.find((candidate) => candidate.id === result.animation_id);
+              if (!group) throw new Error('The selected animation no longer exists.');
+              applyAnimationDefinitionImport(group, analyzeAnimationDefinitionGroup(group), source);
+              return true;
+            } catch (e) { report(e); return false; }
+          },
+        }).show();
+      } catch (e) { report(e); }
+    });
+  }
+
   function showAnimationDefinitionReviewDialog(group, analysis) {
     const savedMetadata = getProjectActorAnimdefMetadata();
     const saved = getSavedAnimdef(group.id);
+    const savedActors = new Map((Array.isArray(saved.actors) ? saved.actors : []).map((actor) => [actor.label, actor]));
     const savedStages = new Map((Array.isArray(saved.stages) ? saved.stages : []).map((stage) => [stage.stage, stage]));
     const savedSystemTags = uniqueTrimmedStrings((Array.isArray(saved.system_tags) ? saved.system_tags : [])
       .map((tag) => String(tag).toLowerCase()));
@@ -2949,7 +3015,10 @@
     form._actors = { type: 'info', text: '### Actor constraints' };
     analysis.actorIndices.forEach((actorIndex, actorPosition) => {
       const label = analysis.actorLabels.get(actorIndex);
-      const metadata = actorAnimdefMetadataWithInference(actorIndex, savedMetadata[String(actorIndex)]);
+      const savedActor = savedActors.get(label);
+      const metadata = savedActor ? cleanActorAnimdefMetadata({ ...savedActor,
+        injects_into: typeof savedActor.injects_into === 'string' ? [savedActor.injects_into] : savedActor.injects_into })
+        : actorAnimdefMetadataWithInference(actorIndex, savedMetadata[String(actorIndex)]);
       addActorAnimdefFormFields(
         form,
         'stub_actor',
@@ -3000,12 +3069,12 @@
         type: 'select',
         options: { default: 'Use top-level default', true: 'Yes', false: 'No' },
         value: savedStage.escapable == null
-          ? (isLastStage ? 'false' : 'default') : String(savedStage.escapable),
+          ? (savedStages.has(stage.stageNumber) ? 'default' : isLastStage ? 'false' : 'default') : String(savedStage.escapable),
       };
       form[`${base}_peaked`] = {
         label: 'Peaked stage',
         type: 'checkbox',
-        value: savedStage.non_peak ?? isLastStage,
+        value: savedStages.has(stage.stageNumber) ? savedStage.non_peak === true : isLastStage,
         description: "Marks this as NoN's peaked stage.",
       };
       form[`${base}_advanced`] = {
@@ -3077,12 +3146,14 @@
             const metadata = readActorAnimdefFormFields(result, 'stub_actor', actorIndex);
             actorMetadata[String(actorIndex)] = metadata;
             if (!metadata.entity_types?.length) unresolvedLabels.push(label);
-            actors.push(buildActorConstraint(label, metadata));
+            actors.push({ ...unmanagedAnimdefFields(savedActors.get(label), ACTOR_GENERATOR_KEYS),
+              ...buildActorConstraint(label, metadata) });
           }
 
-          const stages = analysis.stages.map((stage, index) =>
-            readStageDefinitionFromForm(result, stage, index === analysis.stages.length - 1)
-          );
+          const stages = analysis.stages.map((stage, index) => ({
+            ...unmanagedAnimdefFields(savedStages.get(stage.stageNumber), STAGE_GENERATOR_KEYS),
+            ...readStageDefinitionFromForm(result, stage, index === analysis.stages.length - 1),
+          }));
           const actorsByLabel = new Map(actors.map((actor) => [actor.label, actor]));
           const explicitReceivers = actors.some((actor) => actor.receiver);
           const inferredReceivers = actors.some((actor) => !actor.injector);
@@ -3108,7 +3179,7 @@
           }
           const displayName = String(result?.display_name || '').trim();
           const animators = normalizeAnimatorNames(String(result?.animators || '').split(','));
-          const definition = {};
+          const definition = unmanagedAnimdefFields(saved, DEFINITION_GENERATOR_KEYS);
           const authored = getAuthoredBlockRequirement(group.id);
           const requirement = authored ? authored.requirement : saved.block_requirements;
           if (requirement) definition.block_requirements = clone(requirement);
@@ -3146,7 +3217,7 @@
           if (water !== 'none') definition.water = water;
           const anchor = String(result?.position_anchor_actor || '');
           if (anchor) definition.position_anchor_actor = anchor;
-          const camera = {};
+          const camera = unmanagedAnimdefFields(saved.camera, new Set(['torso_tracking', 'block_requirement_collision']));
           if (result?.camera_torso_tracking === 'continuous') camera.torso_tracking = 'continuous';
           if (result?.camera_block_collision === 'ignore') camera.block_requirement_collision = 'ignore';
           if (Object.keys(camera).length) definition.camera = camera;
@@ -3156,7 +3227,9 @@
           if (systemTags.includes('manualpeak')) {
             const priority = parseOptionalNumber(result?.manual_peak_priority,
               'Manual peak priority', Number.isInteger);
-            if (priority !== null && priority !== 0) definition.manual_peak = { priority };
+            const manualPeak = unmanagedAnimdefFields(saved.manual_peak, new Set(['priority']));
+            if (priority !== null && priority !== 0) manualPeak.priority = priority;
+            if (Object.keys(manualPeak).length) definition.manual_peak = manualPeak;
           }
           if (systemTags.includes('tease')) {
             const multiplier = parseOptionalNumber(
@@ -3165,7 +3238,7 @@
               (value) => value >= 1 && value <= 20
             );
             if (multiplier === null) throw new Error('Nearby energy multiplier is required.');
-            definition.tease = { near_animation_energy_multiplier: multiplier };
+            definition.tease = { ...saved.tease, near_animation_energy_multiplier: multiplier };
           }
           if (systemTags.includes('stuck')) {
             if (!contentTags.length) {
@@ -3206,6 +3279,7 @@
               throw new Error('Final escape difficulty cannot be harder than the initial difficulty.');
             }
             definition.stuck = {
+              ...saved.stuck,
               initial_escape_difficulty_multiplier: initial,
               final_escape_difficulty_multiplier: finalDifficulty,
               ease_delay_seconds: delay,
@@ -3303,73 +3377,6 @@
   // ----------------------------
   // Import Animations
   // ----------------------------
-  function stripJsonSuffix(name) {
-    const s = String(name || '');
-    return s.toLowerCase().endsWith('.json') ? s.slice(0, -5) : s;
-  }
-
-  function stripAnimationSuffix(name) {
-    const s = String(name || '');
-    return s.toLowerCase().endsWith('.animation') ? s.slice(0, -10) : s;
-  }
-
-  function parseActorSuffix(base) {
-    const marker = '_actor';
-    const at = base.lastIndexOf(marker);
-    if (at === -1) return null;
-
-    let i = at + marker.length;
-    let digits = '';
-    while (i < base.length) {
-      const c = base[i];
-      if (c < '0' || c > '9') break;
-      digits += c;
-      i++;
-    }
-
-    if (!digits) return null;
-    if (i !== base.length) return null;
-
-    const idx = parseInt(digits, 10);
-    return Number.isFinite(idx) && idx > 0 ? idx : null;
-  }
-
-  function splitWeakBaseAndLabel(base) {
-    const s = String(base || '');
-    const last = s.lastIndexOf('_');
-    if (last <= 0 || last >= s.length - 1) return { base: null, label: null };
-    return { base: s.slice(0, last), label: s.slice(last + 1) };
-  }
-
-  function getFilenameParts(fileName) {
-    const rawBase = stripAnimationSuffix(stripJsonSuffix(fileName));
-
-    // Strong rule: ..._actorN
-    const actor = parseActorSuffix(rawBase);
-    if (actor) {
-      const marker = '_actor';
-      const at = rawBase.lastIndexOf(marker);
-      const strictBaseName = at === -1 ? rawBase : rawBase.slice(0, at);
-      return {
-        rawBase,
-        strictActorIndex: actor,
-        strictBaseName,
-        weakBaseName: null,
-        weakLabel: null,
-      };
-    }
-
-    // Weak rule: split at last underscore: <anim>_<label>
-    const w = splitWeakBaseAndLabel(rawBase);
-    return {
-      rawBase,
-      strictActorIndex: null,
-      strictBaseName: null,
-      weakBaseName: w.base,
-      weakLabel: w.label,
-    };
-  }
-
   function hasActorPrefix(name) {
     return readActorIndexFromName(name) !== null;
   }
@@ -3414,155 +3421,6 @@
     return a;
   }
 
-  function parseSplitStageAnimationName(name) {
-    const match = /^(.+)\.p([1-9]\d*)$/.exec(String(name || '').trim());
-    if (!match) return null;
-    return {
-      animationId: match[1],
-      stageNumber: Number(match[2]),
-    };
-  }
-
-  function parseSplitStageFilename(rawBase) {
-    const match = /^(.+?\.p[1-9]\d*)_(.+)$/.exec(String(rawBase || '').trim());
-    if (!match) return null;
-    return {
-      stageName: match[1],
-      actorLabel: match[2],
-    };
-  }
-
-  function describeSplitFileActor(parts, animKey, fileIndex) {
-    const filenameIdentity = parseSplitStageFilename(parts.rawBase);
-    if (filenameIdentity) {
-      const actorMatch = /^actor([1-9]\d*)$/.exec(filenameIdentity.actorLabel);
-      const actorGuess = actorMatch ? Number(actorMatch[1]) : null;
-      return {
-        stageName: filenameIdentity.stageName,
-        key: actorGuess ? `actor:${actorGuess}` : `label:${filenameIdentity.actorLabel}`,
-        label: filenameIdentity.actorLabel,
-        actorGuess,
-      };
-    }
-
-    if (parts.strictActorIndex) {
-      return {
-        stageName: parts.strictBaseName || animKey,
-        key: `actor:${parts.strictActorIndex}`,
-        label: `actor${parts.strictActorIndex}`,
-        actorGuess: parts.strictActorIndex,
-      };
-    }
-
-    const exactPrefix = `${animKey}_`;
-    let label = parts.rawBase.startsWith(exactPrefix)
-      ? parts.rawBase.slice(exactPrefix.length)
-      : parts.weakLabel;
-    label = String(label || '').trim();
-
-    if (!label) {
-      return {
-        stageName: animKey,
-        key: `file:${fileIndex}`,
-        label: parts.rawBase || `File ${fileIndex + 1}`,
-        actorGuess: null,
-      };
-    }
-
-    const actorMatch = /^actor([1-9]\d*)$/.exec(label);
-    return {
-      stageName: animKey,
-      key: `label:${label}`,
-      label,
-      actorGuess: actorMatch ? Number(actorMatch[1]) : null,
-    };
-  }
-
-  function analyzeSplitAnimationFiles(parsed) {
-    const stagesByName = new Map();
-    const actorsByKey = new Map();
-
-    for (let i = 0; i < parsed.length; i++) {
-      const entry = parsed[i];
-      const actor = describeSplitFileActor(entry.parts, entry.animKey, i);
-      entry.actorKey = actor.key;
-      entry.stageName = actor.stageName;
-
-      let stage = stagesByName.get(entry.stageName);
-      if (!stage) {
-        stage = {
-          animKey: entry.stageName,
-          parsedName: parseSplitStageAnimationName(entry.stageName),
-          firstFileIndex: i,
-          entries: [],
-        };
-        stagesByName.set(entry.stageName, stage);
-      }
-      if (stage.entries.some((stageEntry) => stageEntry.actorKey === actor.key)) {
-        throw new Error(`Stage "${entry.stageName}" contains more than one file for actor "${actor.label}".`);
-      }
-      stage.entries.push(entry);
-
-      if (!actorsByKey.has(actor.key)) {
-        actorsByKey.set(actor.key, { ...actor, fileCount: 1 });
-      } else {
-        actorsByKey.get(actor.key).fileCount++;
-      }
-    }
-
-    const stages = Array.from(stagesByName.values());
-    const parsedStageNames = stages.map((stage) => stage.parsedName);
-    const commonAnimationId = parsedStageNames.length > 0
-      && parsedStageNames.every((stage) => stage && stage.animationId === parsedStageNames[0].animationId)
-      ? parsedStageNames[0].animationId
-      : null;
-
-    if (commonAnimationId) {
-      stages.sort((a, b) => a.parsedName.stageNumber - b.parsedName.stageNumber);
-    } else {
-      stages.sort((a, b) => a.firstFileIndex - b.firstFileIndex);
-    }
-
-    return {
-      stages,
-      actors: Array.from(actorsByKey.values()),
-      commonAnimationId,
-    };
-  }
-
-  function buildSplitImportFile(analysis, actorMapping, requestedName, formatVersion) {
-    const animations = {};
-    const stageNames = [];
-
-    for (const stage of analysis.stages) {
-      let outputName;
-      if (analysis.commonAnimationId) {
-        outputName = `${requestedName}.p${stage.parsedName.stageNumber}`;
-      } else if (analysis.stages.length === 1) {
-        outputName = requestedName;
-      } else {
-        outputName = stage.animKey;
-      }
-
-      const mergeStage = {
-        entries: stage.entries.map((entry) => ({
-          actorLabel: entry.actorKey,
-          animObj: entry.animObj,
-        })),
-      };
-      animations[outputName] = mergeConjoinedStage(mergeStage, actorMapping, outputName);
-      stageNames.push(outputName);
-    }
-
-    return {
-      fileObj: {
-        format_version: formatVersion || '1.8.0',
-        animations,
-      },
-      stageNames,
-    };
-  }
-
   function parseConjoinedStageActorKey(key) {
     const match = /^p([1-9]\d*)_(.+)$/.exec(String(key || '').trim());
     if (!match || !/^[a-z0-9._-]+$/.test(match[2])) return null;
@@ -3921,238 +3779,529 @@
     else if (typeof a.delete === 'function') a.delete();
   }
 
-  function importSplitActorAnimation() {
-    if (!Project) {
-      Blockbench.showQuickMessage('No project open. Create/open a project first.', 2500);
-      return;
+  // Automatic import reads only explicitly registered, extracted packs. No network access.
+  const PACK_FOLDERS_KEY = 'animationdirector_pack_folders';
+  const IMPORT_METADATA = [ACTOR_NAMES_PROPERTY, ACTOR_TEXTURES_PROPERTY, BONE_TEXTURE_OVERRIDES_PROPERTY,
+    ACTOR_ANIMDEF_METADATA_PROPERTY, ANIMDEF_ANIMATORS_PROPERTY, ANIMDEF_DEFINITIONS_PROPERTY, BLOCK_REQUIREMENTS_PROPERTY];
+
+  function desktopFiles() {
+    const load = typeof requireNativeModule === 'function' ? requireNativeModule
+      : typeof require === 'function' ? require : null;
+    if (!load) throw new Error('Automatic import requires desktop Blockbench. The Manual Import tools remain available in the browser.');
+    const fs = load('fs'), path = load('path');
+    if (!fs || !['readFileSync', 'statSync', 'existsSync', 'readdirSync'].every((method) => typeof fs[method] === 'function')) {
+      throw new Error('Filesystem access is unavailable. Allow filesystem access for AnimationDirector and try again.');
+    }
+    return { fs, path };
+  }
+
+  function importFilePath(file, io) {
+    if (typeof io.fs.realpathSync === 'function') return io.fs.realpathSync(file);
+    const resolved = io.path.resolve(file);
+    // Blockbench's scoped filesystem omits realpath/lstat. Dirent can still detect links.
+    // Reject linked ancestors rather than silently weakening resource containment checks.
+    io.checkedImportPaths ||= new Set();
+    const check = (candidate) => {
+      if (io.checkedImportPaths.has(candidate)) return;
+      const parent = io.path.dirname(candidate);
+      if (parent !== candidate) {
+        check(parent);
+        io.importDirectoryEntries ||= new Map();
+        if (!io.importDirectoryEntries.has(parent)) {
+          io.importDirectoryEntries.set(parent, io.fs.readdirSync(parent, { withFileTypes: true }));
+        }
+        const name = io.path.basename(candidate);
+        const entry = io.importDirectoryEntries.get(parent).find((item) => io.path.sep === '\\'
+          ? item.name.toLowerCase() === name.toLowerCase() : item.name === name);
+        if (entry?.isSymbolicLink()) throw new Error(`Linked paths are not supported by this Blockbench filesystem. Select the actual extracted pack folder: ${candidate}`);
+      }
+      io.checkedImportPaths.add(candidate);
+    };
+    check(resolved);
+    return resolved;
+  }
+
+  function savedPackFolders() {
+    try {
+      const value = JSON.parse(localStorage.getItem(PACK_FOLDERS_KEY) || '[]');
+      return Array.isArray(value) ? uniqueTrimmedStrings(value.filter((item) => typeof item === 'string')) : [];
+    } catch (_) { return []; }
+  }
+
+  function readImportJson(file, io) {
+    if (io.fs.statSync(file).size > 128 * 1024 * 1024) throw new Error(`JSON file is too large: ${file}`);
+    return JSON.parse(io.fs.readFileSync(file, 'utf8').replace(/^\uFEFF/, ''));
+  }
+
+  function insidePack(root, relative, io) {
+    const file = io.path.resolve(root, relative);
+    const contained = (candidate) => {
+      const rel = io.path.relative(root, candidate);
+      return rel !== '..' && !rel.startsWith(`..${io.path.sep}`) && !io.path.isAbsolute(rel);
+    };
+    if (!contained(file)) throw new Error(`Resource path escapes its pack: ${relative}`);
+    if (!io.fs.existsSync(file)) return null;
+    const real = importFilePath(file, io);
+    if (!contained(real)) throw new Error(`Resource symlink escapes its pack: ${relative}`);
+    return real;
+  }
+
+  function importResourceId(value) {
+    if (typeof value !== 'string' || !RESOURCE_ID_PATTERN.test(value)) return null;
+    const [namespace, resource] = value.split(':');
+    if (resource.split('/').some((part) => !part || part === '.' || part === '..')) return null;
+    return { namespace, resource };
+  }
+
+  function readImportPack(folder, io) {
+    const root = importFilePath(folder, io);
+    const metadata = readImportJson(insidePack(root, 'pack.mcmeta', io) || (() => {
+      throw new Error(`Select an extracted pack folder containing pack.mcmeta: ${folder}`);
+    })(), io);
+    const afw = metadata.animationframework || {};
+    return { root, metadata: afw, id: importResourceId(afw.id) ? afw.id : null,
+      name: typeof afw.name === 'string' ? afw.name : io.path.basename(root) };
+  }
+
+  function findImportPack(file, io) {
+    let folder = io.path.dirname(io.path.resolve(file));
+    while (true) {
+      if (io.fs.existsSync(io.path.join(folder, 'pack.mcmeta'))) return readImportPack(folder, io);
+      const parent = io.path.dirname(folder);
+      if (parent === folder) throw new Error('The selected file must be inside an extracted pack containing pack.mcmeta. ZIP files are not supported.');
+      folder = parent;
+    }
+  }
+
+  function importPackRegistry(source, folders, io) {
+    const packs = [], warnings = [], seen = new Set();
+    // An unregistered source goes first; registered sources retain their configured priority.
+    for (const folder of [ ...folders, source.root ]) {
+      try {
+        const pack = readImportPack(folder, io);
+        if (!seen.has(pack.root)) { packs.push(pack); seen.add(pack.root); }
+      } catch (error) { warnings.push(error.message); }
+    }
+    if (!folders.some((folder) => {
+      try { return importFilePath(folder, io) === source.root; } catch (_) { return false; }
+    })) {
+      const index = packs.findIndex((pack) => pack.root === source.root);
+      if (index >= 0) packs.unshift(...packs.splice(index, 1));
+    }
+    const ids = new Set();
+    for (const pack of packs) {
+      if (pack.id && ids.has(pack.id)) warnings.push(`Duplicate pack ID ${pack.id}; configured folder priority decides resource overrides.`);
+      if (pack.id) ids.add(pack.id);
+    }
+    return { packs, warnings };
+  }
+
+  function findImportResource(packs, id, directory, extension, io) {
+    const parsed = importResourceId(id);
+    if (!parsed) return null;
+    const relative = `assets/${parsed.namespace}/${directory}${parsed.resource}${extension}`;
+    for (const pack of packs) {
+      const file = insidePack(pack.root, relative, io);
+      if (file && io.fs.statSync(file).isFile()) return { file, pack, id };
+    }
+    return null;
+  }
+
+  function importModelCandidates(entity, gender, variant, slim = false) {
+    const parsed = importResourceId(entity);
+    if (!parsed || !['m', 'f', 'mf'].includes(gender)) throw new Error('Choose a concrete entity ID and model gender for every actor.');
+    if (variant && (!/^[a-z0-9/._-]+$/.test(variant) || variant.split('/').some((part) => !part || part === '..' || part === '.'))) {
+      throw new Error(`Invalid entity variant: ${variant}`);
+    }
+    const paths = variant ? [`${parsed.resource}_${variant}`, parsed.resource] : [parsed.resource];
+    if (slim && entity === 'minecraft:player') paths.unshift('player_slim');
+    const fallbacks = gender === 'mf' ? ['m', 'f'] : [gender === 'm' ? 'f' : 'm'];
+    return [...paths.map((base) => `${base}.${gender}`), ...paths,
+      ...fallbacks.flatMap((suffix) => paths.map((base) => `${base}.${suffix}`))];
+  }
+
+  function resolveImportModel(source, packs, entity, gender, variant, io, slim = false) {
+    const roots = [];
+    const addRoot = (id, kind) => {
+      if (roots.length < 32 && importResourceId(id) && !roots.some((root) => root.id === id)) roots.push({ id, kind });
+    };
+    if (source.id) addRoot(`${source.id}/entity`, 'Local');
+    for (const entry of Array.isArray(source.metadata.model_imports) ? source.metadata.model_imports : []) {
+      if (entry?.pack !== source.id && Array.isArray(entry?.entities) && entry.entities.includes(entity)) {
+        addRoot(`${entry.pack}/entity`, `Imported ${entry.pack}`);
+      }
+    }
+    const revision = (value) => Number.isInteger(value) && value > 0 ? value : 1;
+    const target = revision(source.metadata.default_model_revision);
+    const current = Math.max(1, ...packs.filter((pack) => pack.id === 'needsofnature:default_pack')
+      .map((pack) => revision(pack.metadata.default_model_revision)));
+    // Sparse archives: only changed models exist in each old revision directory.
+    for (let number = target; number < current && roots.length < 32; number++) {
+      addRoot(`needsofnature:default_pack_compat/revision_${number}/entity`, `Default revision ${number}`);
+    }
+    roots.push({ id: 'animationframework:entity', kind: 'Shared' });
+    roots.push({ id: 'animationframework:', kind: 'Shared legacy' });
+    // Gender-specific candidates precede generic candidates across ALL providers, as in NoN.
+    for (const candidate of importModelCandidates(entity, gender, variant, slim)) {
+      for (const root of roots) {
+        const id = root.id.endsWith(':') ? root.id + candidate : `${root.id}/${candidate}`;
+        const found = findImportResource(packs, id, 'geckolib/models/', '.geo.json', io);
+        if (found) return { ...found, kind: root.kind };
+      }
+    }
+    return null;
+  }
+
+  function definitionActorKeys(actors) {
+    const sanitize = (value) => String(value).toLowerCase().replace(/[^a-z0-9_]/g, '_');
+    const counts = new Map();
+    return actors.map((actor) => {
+      let base;
+      if (actor.label) base = sanitize(actor.label);
+      else {
+        base = (actor.entity_types || []).map((id) => String(id).split(':').pop()).sort().join('_') || 'actor';
+        if (actor.actor_tags?.length) base += '_' + [...actor.actor_tags].sort().map(sanitize).join('_');
+        if (actor.actor_tags_any?.length) base += '_any_' + [...actor.actor_tags_any].sort().map(sanitize).join('_');
+        if (actor.entity_variant) base += '_' + actor.entity_variant;
+        if (actor.age === 'baby') base += '_baby';
+        base = sanitize(base);
+      }
+      const count = (counts.get(base) || 0) + 1;
+      counts.set(base, count);
+      return count === 1 ? base : `${base}_${count}`;
+    });
+  }
+
+  function inferImportGender(actor) {
+    const required = actor.actor_tags || [];
+    const male = required.includes('gender.male'), female = required.includes('gender.female');
+    // Matching either flag also permits male+female actors: let creators select the intended model.
+    if (male && female) return 'mf';
+    return '';
+  }
+
+  function defaultImportClipRoles(actors, clipLabels) {
+    const keys = definitionActorKeys(actors);
+    const assigned = actors.map((_, index) => clipLabels.includes(keys[index]) ? keys[index] : '');
+    const entityNames = actors.map((actor) => actor.entity_types?.length === 1
+      ? String(actor.entity_types[0]).split(':').pop() : '');
+    actors.forEach((_, index) => {
+      const name = entityNames[index];
+      // Older clips often omit constraint tags. Only infer a short label when unambiguous.
+      if (!assigned[index] && name && clipLabels.includes(name) && !assigned.includes(name)
+        && entityNames.filter((candidate, position) => candidate === name && !assigned[position]).length === 1) assigned[index] = name;
+    });
+    return assigned;
+  }
+
+  function validateImportGeometry(json) {
+    const geo = extractGeckoGeometryRoot(json);
+    if (!geo || !Array.isArray(geo.bones) || !geo.bones.length) throw new Error('The model must contain a non-empty minecraft:geometry bones array.');
+    const bones = new Map();
+    for (const bone of geo.bones) {
+      if (!bone || typeof bone.name !== 'string' || !bone.name || bones.has(bone.name)) throw new Error('Model bone names must be non-empty and unique.');
+      bones.set(bone.name, bone);
+    }
+    const completed = new Set();
+    for (const bone of bones.values()) {
+      const visited = new Set();
+      let cursor = bone;
+      while (cursor && !completed.has(cursor.name)) {
+        if (visited.has(cursor.name)) throw new Error(`Cyclic model hierarchy at ${cursor.name}.`);
+        visited.add(cursor.name);
+        cursor = bones.get(cursor.parent);
+      }
+      for (const name of visited) completed.add(name);
+    }
+    return geo;
+  }
+
+  function companionImportFiles(source, file, io) {
+    const relative = io.path.relative(source.root, io.path.resolve(file)).replace(/\\/g, '/');
+    const definition = /^data\/([^/]+)\/afw_animdefs\/(.+)\.json$/.exec(relative);
+    const animation = /^assets\/([^/]+)\/(?:geckolib\/)?animations\/afw\/(.+)\.animation\.json$/.exec(relative);
+    const match = definition || animation;
+    if (!match || !importResourceId(`${match[1]}:${match[2]}`)) {
+      throw new Error('Choose data/<namespace>/afw_animdefs/<ID>.json or assets/<namespace>/geckolib/animations/afw/<ID>.animation.json.');
+    }
+    let id = match[2];
+    const parts = id.split('/');
+    if (animation && parts.length > 1 && parts.at(-1) === parts.at(-2)) id = parts.slice(0, -1).join('/');
+    const namespace = match[1];
+    const namespaces = (kind) => {
+      const folder = insidePack(source.root, kind, io);
+      return folder ? io.fs.readdirSync(folder, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name) : [];
+    };
+    const candidates = (kind, middles, names, suffix) => [...new Set([namespace, ...namespaces(kind)])]
+      .flatMap((ns) => middles.flatMap((middle) => names.map((name) => insidePack(source.root, `${kind}/${ns}/${middle}/${name}${suffix}`, io)))).filter(Boolean);
+    return { id,
+      definitions: definition ? [io.path.resolve(file)] : candidates('data', ['afw_animdefs'], [id], '.json'),
+      animations: animation ? [io.path.resolve(file)] : candidates('assets', ['geckolib/animations/afw', 'animations/afw'],
+        [id, `${id}/${id.split('/').pop()}`], '.animation.json') };
+  }
+
+  function importDialog(title, form, confirmText = 'Continue') {
+    return new Promise((resolve) => new Dialog({ id: 'animationdirector_automatic_import_step', title, width: 680, form,
+      buttons: ['Cancel', confirmText], cancelIndex: 0, confirmIndex: 1,
+      onConfirm(result) { resolve(result); }, onCancel() { resolve(null); } }).show());
+  }
+
+  function pickImportFile(title) {
+    return new Promise((resolve) => Filesystem.importFile({ type: 'JSON', title, extensions: ['json'],
+      multiple: false, readtype: 'text' }, (files) => resolve(files?.[0] || null)));
+  }
+
+  async function chooseCompanion(files, title) {
+    if (files.length === 1) return files[0];
+    if (!files.length) return (await pickImportFile(`${title} (not found in pack)`))?.path || null;
+    const result = await importDialog(title, { file: { type: 'select', label: 'File', value: files[0],
+      options: { '': 'Choose a file...', ...Object.fromEntries(files.map((file) => [file, file])) } } });
+    if (!result) return null;
+    if (!files.includes(result.file)) throw new Error('Select the companion file explicitly.');
+    return result.file;
+  }
+
+  function editImportPackFolders() {
+    const io = desktopFiles();
+    const folders = savedPackFolders();
+    const dialog = new Dialog({ id: 'animationdirector_pack_folders', title: 'Animation Import Pack Folders', width: 680,
+      component: {
+        data() { return { folders, error: '' }; },
+        methods: {
+          add() {
+            const folder = Blockbench.pickDirectory({ title: 'Select extracted pack folder', resource_id: PACK_FOLDERS_KEY });
+            if (!folder) return;
+            try {
+              const pack = readImportPack(folder, io);
+              if (!this.folders.includes(pack.root)) this.folders.push(pack.root);
+              this.error = '';
+            } catch (error) { this.error = error.message; }
+          },
+          move(index, direction) {
+            const next = index + direction;
+            if (next < 0 || next >= this.folders.length) return;
+            const item = this.folders.splice(index, 1)[0];
+            this.folders.splice(next, 0, item);
+          },
+        },
+        template: `<div style="padding:12px"><p>Highest priority first. Add the default pack and any model-import provider packs. These folders are remembered for future imports; Minecraft's load order is unchanged.</p>
+          <div v-for="(folder,index) in folders" :key="folder" style="display:flex;gap:6px;margin:8px 0;align-items:center">
+            <span style="flex:1;overflow-wrap:anywhere">{{folder}}</span>
+            <button @click="move(index,-1)" :disabled="index===0">Up</button><button @click="move(index,1)" :disabled="index===folders.length-1">Down</button>
+            <button @click="folders.splice(index,1)">Remove</button></div>
+          <button @click="add">Add Pack Folder</button><p style="color:var(--color-error)">{{error}}</p></div>`,
+      },
+      onConfirm() { localStorage.setItem(PACK_FOLDERS_KEY, JSON.stringify(folders)); },
+    });
+    dialog.show();
+  }
+
+  function loadImportTextures(row, packs, io) {
+    const ids = new Set(Object.values(row.json.afw_bone_textures || {}).filter((value) => typeof value === 'string'));
+    if (typeof row.json.afw_texture === 'string') ids.add(row.json.afw_texture);
+    else {
+      const entity = importResourceId(row.entity);
+      for (const resource of [`${entity.namespace}:textures/entity/${entity.resource}/${entity.resource}.png`,
+        `${entity.namespace}:textures/entity/${entity.resource}.png`]) {
+        if (findImportResource(packs, resource, '', '', io)) { row.defaultTexture = resource; ids.add(resource); break; }
+      }
+    }
+    if (typeof row.json.afw_texture === 'string') row.defaultTexture = row.json.afw_texture;
+    row.textures = new Map();
+    for (const resource of ids) {
+      const id = resource.includes(':') ? resource : `minecraft:${resource}`;
+      const texture = findImportResource(packs, id, '', '', io);
+      if (texture) row.textures.set(resource, texture);
+    }
+  }
+
+  function commitAutomaticImport(plan) {
+    if (!Formats.geckolib_model) throw new Error('Install/enable the GeckoLib Blockbench plugin before importing an animation.');
+    cancelBlockRequirementUpdate();
+    if (!newProject(Formats.geckolib_model)) throw new Error('Could not create the GeckoLib project.');
+    const projectId = Project.uuid;
+    const aspects = { outliner: true, selection: true, elements: [], groups: [], textures: [], animations: [],
+      automatic_animation_import: true };
+    Undo.initEdit(aspects);
+    try {
+      Project.name = plan.parsed.animationId;
+      const description = plan.rows[0]?.geo.description || {};
+      const dimension = (value) => Number.isFinite(value) && value > 0 ? value : 64;
+      Project.texture_width = dimension(description.texture_width);
+      Project.texture_height = dimension(description.texture_height);
+      const names = {}, textures = {}, metadata = {}, overrides = {}, loadedTextures = new Map();
+      for (const [offset, row] of plan.rows.entries()) {
+        const index = offset + 1;
+        names[index] = row.label;
+        metadata[index] = plan.definition.actors[offset];
+        importGeometryIntoCurrentProject(row.geo, index, false, false);
+        for (const [name, resource] of row.textures) {
+          if (!loadedTextures.has(resource.file)) {
+            const texture = new Texture({ name, uv_width: row.geo.description?.texture_width || 64,
+              uv_height: row.geo.description?.texture_height || 64 });
+            texture.keep_size = true;
+            texture.load_callback = () => { if (Project?.uuid === projectId) scheduleActorTexturePreviewApply(); };
+            texture.fromPath(resource.file);
+            texture.name = name;
+            texture.add(false);
+            loadedTextures.set(resource.file, name);
+          }
+        }
+        if (row.textures.has(row.defaultTexture)) textures[index] = loadedTextures.get(row.textures.get(row.defaultTexture).file);
+        for (const [bone, textureName] of Object.entries(row.json.afw_bone_textures || {})) {
+          const group = Group.all.find((candidate) => candidate.name === `actor${index}_${bone}`);
+          if (group && row.textures.has(textureName)) overrides[group.uuid] = { uuid: group.uuid, name: group.name,
+            texture: loadedTextures.get(row.textures.get(textureName).file) };
+        }
+      }
+      setProjectActorNames(names);
+      setProjectActorTextures(textures);
+      setProjectActorAnimdefMetadata(metadata);
+      setProjectBoneTextureOverrides(overrides);
+      setProjectAnimdefAnimators(plan.definition.animators || []);
+      Animator.loadFile({ name: `${plan.parsed.animationId}.animation.json`, path: '', content: JSON.stringify(plan.imported.fileObj) }, plan.imported.stageNames);
+      rebuildBlockRequirementGuides(plan.parsed.animationId, plan.blockEntry, plan.definition, false);
+      Canvas.updateAll();
+      applyAllActorTexturePreviews(false);
+      refreshBlockGuideFaces();
+      const finished = { ...aspects, elements: Outliner.elements.slice(), groups: Group.all.slice(),
+        textures: Texture.all.slice(), animations: Animation.all.slice() };
+      Undo.finishEdit('Automatically import animation', finished);
+      Project.saved = false;
+      if (Animation.all[0]) Animation.all[0].select();
+      if (blockRequirementPanel?.vue) blockRequirementPanel.vue.load(plan.parsed.animationId);
+      Blockbench.showQuickMessage(`Imported ${plan.parsed.animationId}: ${plan.rows.length} actors, ${plan.imported.stageNames.length} stages.`, 4000);
+    } catch (error) {
+      Undo.cancelEdit();
+      throw error;
+    }
+  }
+
+  async function automaticallyImportAnimation() {
+    try {
+      const io = desktopFiles();
+      const file = await pickImportFile('Automatically Import Animation (definition or animation file)');
+      if (!file) return;
+      const source = findImportPack(file.path, io);
+      const companions = companionImportFiles(source, file.path, io);
+      if (!/^[a-z0-9._-]+$/.test(companions.id)) {
+        throw new Error('This editor requires an animation ID without subfolders. Nested <ID>/<ID>.animation.json files are supported.');
+      }
+      const defFile = await chooseCompanion(companions.definitions, 'Choose Animation Definition');
+      if (!defFile) return;
+      const animFile = await chooseCompanion(companions.animations, 'Choose Animation File');
+      if (!animFile) return;
+      const definition = readImportJson(defFile, io);
+      const parsed = parseConjoinedAnimationFile({ name: io.path.basename(animFile), path: animFile,
+        content: JSON.stringify(readImportJson(animFile, io)) });
+      if (parsed.animationId !== companions.id.split('/').pop()) throw new Error('The companion animation filename must use the same animation ID.');
+      parsed.animationId = companions.id;
+      if (!Array.isArray(definition.actors) || !definition.actors.length) {
+        throw new Error('The definition must contain at least one actor.');
+      }
+      const registry = importPackRegistry(source, savedPackFolders(), io);
+      const keys = definitionActorKeys(definition.actors);
+      const clipRoles = defaultImportClipRoles(definition.actors, parsed.actorLabels);
+      const usedClips = new Set(clipRoles.filter(Boolean));
+      clipRoles.forEach((label, index) => {
+        if (label) return;
+        const available = parsed.actorLabels.find((candidate) => !usedClips.has(candidate));
+        if (available) { clipRoles[index] = available; usedClips.add(available); }
+      });
+      const form = { info: { type: 'info', text: `### ${companions.id}\nImport into a NEW GeckoLib project. Choose concrete actors and confirm their clip roles. Use Manual Import > Pack Folders to register shared/default packs before importing.\nFolder priority: ${registry.packs.map((pack) => pack.name).join(' > ')}` } };
+      definition.actors.forEach((actor, index) => {
+        const entities = (actor.entity_types || []).filter((id) => importResourceId(id));
+        form[`heading_${index}`] = { type: 'info', text: `### Actor ${index + 1}: ${keys[index]}` };
+        form[`clip_${index}`] = { type: 'select', label: 'Animation actor', value: clipRoles[index],
+          options: { '': 'Choose actor...', ...Object.fromEntries(parsed.actorLabels.map((label) => [label, label])) } };
+        form[`entity_${index}`] = entities.length ? { type: 'select', label: 'Entity', value: entities[0],
+          options: Object.fromEntries(entities.map((id) => [id, id])) }
+          : { type: 'text', label: 'Concrete entity ID', value: '', placeholder: 'minecraft:player' };
+        const required = actor.actor_tags || [];
+        const genders = {};
+        if (!required.includes('gender.female')) genders.m = 'Male';
+        if (!required.includes('gender.male')) genders.f = 'Female';
+        genders.mf = 'Male + female';
+        form[`gender_${index}`] = { type: 'select', label: 'Model gender', value: inferImportGender(actor) || Object.keys(genders)[0], options: genders };
+        if (!entities.length || entities.includes('minecraft:player')) form[`slim_${index}`] = { type: 'checkbox', label: 'Slim player model', value: false,
+          condition: (result) => result[`entity_${index}`] === 'minecraft:player' };
+      });
+      const choices = await importDialog('Automatic Import: Actors', form);
+      if (!choices) return;
+      const rows = definition.actors.map((actor, index) => ({ actor, label: choices[`clip_${index}`], entity: choices[`entity_${index}`], gender: choices[`gender_${index}`], slim: !!choices[`slim_${index}`] }));
+      if (new Set(rows.map((row) => row.label)).size !== rows.length || rows.some((row) => !parsed.actorLabels.includes(row.label))) {
+        throw new Error('Each definition actor must be assigned a distinct animation actor.');
+      }
+      const selectedLabels = new Set(rows.map((row) => row.label));
+      const ignoredLabels = parsed.actorLabels.filter((label) => !selectedLabels.has(label));
+      // The definition owns the actor set; discard all tracks and effects belonging to unused clips.
+      parsed.actorLabels = parsed.actorLabels.filter((label) => selectedLabels.has(label));
+      parsed.stages = parsed.stages.map((stage) => ({ ...stage,
+        entries: stage.entries.filter((entry) => selectedLabels.has(entry.actorLabel))
+      })).filter((stage) => stage.entries.length);
+      // Preserve role references while relabeling the definition for the selected asset clips.
+      const relabeled = clone(definition);
+      relabeled.actors.forEach((actor, index) => { actor.label ||= keys[index]; });
+      const analysis = { actorIndices: rows.map((_, index) => index + 1), actorLabels: new Map(rows.map((row, index) => [index + 1, row.label])),
+        stages: parsed.stages.map((stage) => ({ stageNumber: stage.stageNumber })) };
+      const labelMap = new Map(relabeled.actors.map((actor, index) => [actor.label, rows[index].label]));
+      relabeled.actors.forEach((actor, index) => {
+        actor.label = rows[index].label;
+        if (actor.injects_into !== undefined) {
+          const targets = Array.isArray(actor.injects_into) ? actor.injects_into : [actor.injects_into];
+          actor.injects_into = targets.map((target) => {
+            if (!labelMap.has(target)) throw new Error(`Unknown injection target: ${target}`);
+            return labelMap.get(target);
+          });
+        }
+      });
+      for (const stage of relabeled.stages || []) {
+        if (stage.props && typeof stage.props === 'object' && !Array.isArray(stage.props)) {
+          stage.props = Object.fromEntries(Object.entries(stage.props).map(([key, value]) => [labelMap.get(key) || key, value]));
+        }
+      }
+      if (relabeled.position_anchor_actor !== undefined) relabeled.position_anchor_actor = labelMap.get(relabeled.position_anchor_actor) || relabeled.position_anchor_actor;
+      const prepared = prepareAnimationDefinitionImport(relabeled, analysis);
+      const warnings = registry.warnings.slice();
+      if (ignoredLabels.length) warnings.push(`Ignored animation actors not mapped to the definition: ${ignoredLabels.join(', ')}.`);
+      const models = { info: { type: 'info', text: '### Actor models\nModels follow local, declared imports, old default revisions, and shared fallbacks. Choose a replacement only when necessary; missing models must be selected manually.' } };
+      rows.forEach((row, index) => {
+        row.resolved = resolveImportModel(source, registry.packs, row.entity, row.gender, row.actor.entity_variant, io, row.slim);
+        models[`source_${index}`] = { type: 'info', text: `### ${row.label}\n${row.resolved ? `${row.resolved.kind}: ${row.resolved.file}` : 'Model not found. Select a geometry file below.'}` };
+        models[`model_${index}`] = { type: 'file', label: row.resolved ? 'Override model (optional)' : 'Select model (required)',
+          return_as: 'file', extensions: ['json'], readtype: 'text', filetype: 'GeckoLib geometry' };
+      });
+      const modelChoices = await importDialog('Automatic Import: Models', models);
+      if (!modelChoices) return;
+      for (const [index, row] of rows.entries()) {
+        if (modelChoices[`model_${index}`]?.path) row.resolved = { file: modelChoices[`model_${index}`].path, kind: 'Manually selected' };
+        if (!row.resolved) throw new Error(`Select a model for ${row.label}.`);
+        row.json = readImportJson(row.resolved.file, io);
+        row.geo = validateImportGeometry(row.json);
+        loadImportTextures(row, registry.packs, io);
+        const names = new Set(row.geo.bones.map((bone) => bone.name));
+        const missing = new Set(parsed.stages.flatMap((stage) => stage.entries.filter((entry) => entry.actorLabel === row.label)
+          .flatMap((entry) => Object.keys(entry.animObj.bones || {}).filter((bone) => !names.has(bone)))));
+        if (missing.size) warnings.push(`${row.label}: model lacks animated bones: ${[...missing].join(', ')}. Tracks will be retained.`);
+        if (!row.textures.has(row.defaultTexture)) warnings.push(`${row.label}: no base texture found locally. Set its preview texture using Actor Preferences.`);
+      }
+      const imported = buildConjoinedImportFile(parsed, parsed.animationId, new Map(rows.map((row, index) => [row.label, index + 1])));
+      let blockEntry = null;
+      if (prepared.block_requirements) {
+        const fields = buildBlockRequirementForm(parsed.animationId, prepared.block_requirements);
+        blockEntry = readBlockRequirementForm(Object.fromEntries(Object.entries(fields).filter(([, value]) => value.type !== 'info').map(([key, value]) => [key, value.value])));
+        buildBlockRequirementGuideBoxes(blockEntry);
+      }
+      const review = { info: { type: 'info', text: `### Import ${parsed.animationId}\n${rows.map((row) => `${row.label}: ${row.resolved.kind}\n${row.resolved.file}`).join('\n\n')}\n\n${warnings.join('\n')}` } };
+      const accepted = await importDialog('Automatic Import: Review', review, 'Create Project and Import');
+      if (!accepted) return;
+      commitAutomaticImport({ parsed, rows, definition: prepared, imported, blockEntry });
+      localStorage.setItem(PACK_FOLDERS_KEY, JSON.stringify(registry.packs.map((pack) => pack.root)));
+    } catch (error) {
+      Blockbench.showMessageBox({ title: 'Automatically Import Animation', message: error.message, buttons: ['OK'] });
     }
-
-    if (typeof Animator?.loadFile !== 'function') {
-      Blockbench.showMessageBox({
-        title: 'Import Animation (Split Files)',
-        message: 'Animation importer not available in this Blockbench setup (missing Animator.loadFile).',
-        buttons: ['OK'],
-      });
-      return;
-    }
-
-    Filesystem.importFile(
-      {
-        type: 'GeckoLib Animation JSON (per actor)',
-        extensions: ['json'],
-        multiple: true,
-        readtype: 'text',
-        resource_id: 'animation',
-        title: 'Select split per-actor animation files to combine',
-      },
-      (files) => {
-        if (!files?.length) return;
-
-        try {
-          const parsed = [];
-          for (let fileIndex = 0; fileIndex < files.length; fileIndex++) {
-            const f = files[fileIndex];
-            const text = f?.content;
-            if (typeof text !== 'string' || !text.trim()) throw new Error(`Could not read file contents: ${f?.name || '(unknown)'}`);
-
-            const json = JSON.parse(text);
-            const anims = json?.animations;
-            if (!anims || typeof anims !== 'object') throw new Error(`Missing "animations" map in ${f?.name || '(unknown)'}`);
-
-            const keys = Object.keys(anims);
-            if (keys.length !== 1) {
-              throw new Error(
-                `Expected exactly 1 animation clip inside ${f?.name || '(unknown)'} (found ${keys.length}). Each selected split file must contain one actor's clip for one stage.`
-              );
-            }
-
-            const animKey = keys[0];
-            const animObj = anims[animKey];
-            if (!animObj || typeof animObj !== 'object') throw new Error(`Invalid animation object in ${f?.name || '(unknown)'}`);
-
-            const parts = getFilenameParts(f?.name || '');
-
-            parsed.push({
-              file: f,
-              format_version: json?.format_version,
-              animKey,
-              animObj,
-              parts,
-              fileIndex,
-            });
-          }
-
-          const analysis = analyzeSplitAnimationFiles(parsed);
-          const actorOptions = buildActorSelectOptions();
-          const actorOptionKeys = Object.keys(actorOptions);
-          if (!actorOptionKeys.length) {
-            Blockbench.showQuickMessage('No actorN_ bones found in this project.', 2500);
-            return;
-          }
-
-          const canRename = analysis.commonAnimationId !== null || analysis.stages.length === 1;
-          const defaultName = analysis.commonAnimationId || analysis.stages[0]?.animKey || 'animation';
-          const form = {};
-          if (canRename) {
-            form.name = {
-              label: analysis.stages.length > 1 ? 'Animation ID' : 'Combined animation name',
-              type: 'text',
-              value: defaultName,
-              placeholder: analysis.stages.length > 1 ? 'wolfmplayer' : 'wolfmplayer.p1',
-            };
-          }
-          form._info = {
-            type: 'info',
-            text: analysis.stages.length > 1
-              ? `Detected ${analysis.stages.length} stages. Map each file actor once; the mapping is reused for every stage.`
-              : "Pick which project actor each file actor belongs to. Bones receive that actor's 'actorN_' prefix.",
-          };
-          if (!canRename) {
-            form._stage_names = {
-              type: 'info',
-              text: `The selected files use unrelated animation names, so they will be preserved: ${analysis.stages.map((stage) => stage.animKey).join(', ')}`,
-            };
-          }
-
-          for (let i = 0; i < analysis.actors.length; i++) {
-            const actor = analysis.actors[i];
-            const guessedActor = String(actor.actorGuess || '');
-            form[`actor_${i}`] = {
-              label: `${actor.label} (${actor.fileCount} file${actor.fileCount === 1 ? '' : 's'})`,
-              type: 'select',
-              options: actorOptions,
-              value: Object.prototype.hasOwnProperty.call(actorOptions, guessedActor)
-                ? guessedActor
-                : defaultActorOptionForLabel(actor.label, actorOptions),
-            };
-          }
-
-          const dialog = new Dialog({
-            id: 'import_combined_actor_animation',
-            title: 'Import Animation (Split Files)',
-            width: 720,
-            form,
-            buttons: ['Cancel', 'Import'],
-            cancelIndex: 0,
-            confirmIndex: 1,
-            onConfirm: (result) => {
-              try {
-                const requestedName = canRename
-                  ? String(result?.name || '').trim() || defaultName
-                  : defaultName;
-                if (canRename && !requestedName) throw new Error('Animation name cannot be empty.');
-
-                const actorMapping = new Map();
-                const usedActorIndices = new Set();
-                for (let i = 0; i < analysis.actors.length; i++) {
-                  const actor = analysis.actors[i];
-                  const actorIndex = Number(result?.[`actor_${i}`]);
-                  if (!Number.isFinite(actorIndex) || actorIndex <= 0) {
-                    throw new Error(`Invalid project actor selected for "${actor.label}".`);
-                  }
-                  const normalizedActorIndex = Math.floor(actorIndex);
-                  if (usedActorIndices.has(normalizedActorIndex)) {
-                    throw new Error('Each file actor must map to a different project actor.');
-                  }
-                  actorMapping.set(actor.key, normalizedActorIndex);
-                  usedActorIndices.add(normalizedActorIndex);
-                }
-
-                const imported = buildSplitImportFile(
-                  analysis,
-                  actorMapping,
-                  requestedName,
-                  parsed[0]?.format_version
-                );
-
-                const doImport = (nameOverrides = null) => {
-                  const animations = {};
-                  const finalNames = [];
-                  for (const sourceName of imported.stageNames) {
-                    const finalName = nameOverrides?.get(sourceName) || sourceName;
-                    animations[finalName] = imported.fileObj.animations[sourceName];
-                    finalNames.push(finalName);
-                  }
-
-                  const fakeFile = {
-                    name: `${sanitizeFilePart(requestedName || 'split_animation_import')}.animation.json`,
-                    path: '',
-                    content: JSON.stringify({
-                      format_version: imported.fileObj.format_version,
-                      animations,
-                    }, null, 2),
-                  };
-
-                  Animator.loadFile(fakeFile, finalNames);
-                  Blockbench.showQuickMessage(
-                    `Imported ${finalNames.length} stage${finalNames.length === 1 ? '' : 's'} from ${files.length} split files`,
-                    2500
-                  );
-                };
-
-                const existing = imported.stageNames.filter(animationNameExists);
-                if (existing.length) {
-                  Blockbench.showMessageBox(
-                    {
-                      title: 'Import Animation (Split Files)',
-                      message: `The following animations already exist:\n\n${existing.map((name) => `- ${name}`).join('\n')}`,
-                      buttons: ['Cancel', 'Overwrite', 'Import Copies'],
-                    },
-                    (button) => {
-                      if (button === 1 || button === 'Overwrite') {
-                        for (const name of existing) removeAnimationByName(name);
-                        doImport();
-                      } else if (button === 2 || button === 'Import Copies') {
-                        const usedNames = new Set(
-                          (Array.isArray(Animation.all) ? Animation.all : [])
-                            .map((animation) => animation?.name)
-                            .filter(Boolean)
-                        );
-                        const copyNames = new Map();
-                        for (const name of imported.stageNames) {
-                          let copyName = name;
-                          let suffix = 2;
-                          while (usedNames.has(copyName)) copyName = `${name}_${suffix++}`;
-                          usedNames.add(copyName);
-                          copyNames.set(name, copyName);
-                        }
-                        doImport(copyNames);
-                      }
-                    }
-                  );
-                } else {
-                  doImport();
-                }
-
-                return true;
-              } catch (e) {
-                console.error(e);
-                Blockbench.showMessageBox({
-                  title: 'Import Animation (Split Files)',
-                  message: `Import failed: ${e?.message || e}`,
-                  buttons: ['OK'],
-                });
-                return false;
-              }
-            },
-          });
-
-          dialog.show();
-        } catch (e) {
-          console.error(e);
-          Blockbench.showMessageBox({
-            title: 'Import Animation (Split Files)',
-            message: `Import failed: ${e?.message || e}`,
-            buttons: ['OK'],
-          });
-        }
-      }
-    );
   }
 
-  // ----------------------------
-  // Register
-  // ----------------------------
   Plugin.register(PLUGIN_ID, {
     title: 'AnimationDirector',
     author: 'L1Z0',
@@ -4162,7 +4311,7 @@
 
 It lets you import and animate multiple actors in one project without Blockbench auto-renaming bones when different models use the same bone names (like head, body, etc.). It does this by organizing each actor with an actorN_ prefix, so everything stays consistent.
 
-You can import or export complete AFW animation IDs as one file containing all stages and actors, or generate a configurable AFW animation definition from the current project. The deprecated split-file import and export tools remain available for older projects.`,
+You can import or export complete AFW animation IDs as one file containing all stages and actors, or generate a configurable AFW animation definition from the current project.`,
     version: '1.1.0',
     variant: 'both',
     onload() {
@@ -4212,9 +4361,18 @@ You can import or export complete AFW animation IDs as one file containing all s
       refreshBlockGuideFaces();
       blockRequirementUndoSaveListener = ({ save, aspects }) => {
         if (aspects.block_requirement_edit) save[BLOCK_REQUIREMENTS_PROPERTY] = Project[BLOCK_REQUIREMENTS_PROPERTY] || '{}';
+        if (aspects.animdef_edit) save[ANIMDEF_DEFINITIONS_PROPERTY] = Project[ANIMDEF_DEFINITIONS_PROPERTY] || '{}';
+        if (aspects.automatic_animation_import) {
+          for (const property of IMPORT_METADATA) save[property] = Project[property] ?? (property === ANIMDEF_ANIMATORS_PROPERTY ? '' : '{}');
+        }
       };
       blockRequirementUndoLoadListener = ({ save }) => {
         if (save[BLOCK_REQUIREMENTS_PROPERTY] !== undefined) Project[BLOCK_REQUIREMENTS_PROPERTY] = save[BLOCK_REQUIREMENTS_PROPERTY];
+        if (save[ANIMDEF_DEFINITIONS_PROPERTY] !== undefined) Project[ANIMDEF_DEFINITIONS_PROPERTY] = save[ANIMDEF_DEFINITIONS_PROPERTY];
+        for (const property of IMPORT_METADATA) {
+          if (save[property] !== undefined) Project[property] = save[property];
+        }
+        scheduleActorTexturePreviewApply();
       };
       Blockbench.on('create_undo_save', blockRequirementUndoSaveListener);
       Blockbench.on('load_undo_save', blockRequirementUndoLoadListener);
@@ -4247,14 +4405,6 @@ You can import or export complete AFW animation IDs as one file containing all s
         click: importConjoinedAnimation,
       });
 
-      importSplitAnimationAction = new Action('import_split_actor_animation', {
-        name: 'Import Animation (Split Files)',
-        description:
-          'Select split per-actor files from one or more stages, rebuild each stage, and re-apply actor prefixes.',
-        icon: 'playlist_add',
-        click: importSplitActorAnimation,
-      });
-
       actorPreferencesAction = new Action('edit_actor_preferences', {
         name: 'Actor Preferences',
         description: 'Set project-specific export names, preview textures, and animation-definition metadata for each actor.',
@@ -4276,22 +4426,6 @@ You can import or export complete AFW animation IDs as one file containing all s
         click: exportGeckoModel,
       });
 
-      exportSelectedAction = new Action('export_selected_actor_animation', {
-        name: 'Export Selected Animations (Split Files)',
-        description:
-          'Export selected animation as one <animation>_<actor name>.animation.json per actor, stripping actor prefixes from bone names.',
-        icon: 'file_download',
-        click: exportSelectedActorAnimation,
-      });
-
-      exportAllAction = new Action('export_all_actor_animations', {
-        name: 'Export All Animations (Split Files)',
-        description:
-          'Export every animation as one <animation>_<actor name>.animation.json per actor, stripping actor prefixes from bone names.',
-        icon: 'download_for_offline',
-        click: exportAllActorAnimations,
-      });
-
       exportConjoinedAction = new Action('export_conjoined_actor_animations', {
         name: 'Export Animations',
         description:
@@ -4306,6 +4440,25 @@ You can import or export complete AFW animation IDs as one file containing all s
         icon: 'post_add',
         click: showCreateAnimationDefinitionDialog,
       });
+      importAnimationDefinitionAction = new Action('import_afw_animation_definition', {
+        name: 'Import Animation Definition',
+        description: 'Load generator fields and block requirement guides from an existing animdef JSON.',
+        icon: 'file_open',
+        click: importAnimationDefinition,
+      });
+      automaticImportAction = new Action('animationdirector_automatic_import', {
+        name: 'Automatically Import Animation', icon: 'auto_awesome',
+        description: 'Import an animation definition, actor models and all stages from extracted packs into a new project.',
+        click: automaticallyImportAnimation,
+      });
+      packFoldersAction = new Action('animationdirector_pack_folders', {
+        name: 'Pack Folders', icon: 'folder',
+        description: 'Remember extracted packs and their model/texture lookup priority for automatic import.',
+        click() {
+          try { editImportPackFolders(); }
+          catch (error) { Blockbench.showMessageBox({ title: 'Pack Folders', message: error.message, buttons: ['OK'] }); }
+        },
+      });
 
       MenuBar.menus.tools.addAction({
         id: 'animationdirector_model',
@@ -4319,19 +4472,15 @@ You can import or export complete AFW animation IDs as one file containing all s
         name: 'AnimationDirector Anims',
         icon: 'movie',
         children: [
-          importAction,
-          importConjoinedAnimationAction,
+          automaticImportAction,
+          { id: 'animationdirector_manual_import', name: 'Manual Import', icon: 'file_open', children: [
+            importAction, importConjoinedAnimationAction, importAnimationDefinitionAction, packFoldersAction,
+          ] },
           actorPreferencesAction,
           replaceActorAction,
           exportConjoinedAction,
-          createAnimationDefinitionAction,
           blockRequirementAction,
-          {
-            id: 'animationdirector_deprecated',
-            name: 'Deprecated',
-            icon: 'history',
-            children: [importSplitAnimationAction, exportSelectedAction, exportAllAction],
-          },
+          createAnimationDefinitionAction,
         ],
       });
 
@@ -4355,15 +4504,15 @@ You can import or export complete AFW animation IDs as one file containing all s
       MenuBar.menus.tools.removeAction('animationdirector_anims');
       importAction.delete();
       importConjoinedAnimationAction.delete();
-      importSplitAnimationAction.delete();
       actorPreferencesAction.delete();
       boneTextureOverridesAction.delete();
       exportGeckoModelAction.delete();
       replaceActorAction.delete();
-      exportSelectedAction.delete();
-      exportAllAction.delete();
       exportConjoinedAction.delete();
       createAnimationDefinitionAction.delete();
+      importAnimationDefinitionAction.delete();
+      automaticImportAction.delete();
+      packFoldersAction.delete();
       blockRequirementAction.delete();
       Blockbench.removeListener('select_project', blockGuideProjectListener);
       cancelBlockRequirementUpdate();
diff --git a/test/automatic-import.test.js b/test/automatic-import.test.js
new file mode 100644
index 0000000..51d0af8
--- /dev/null
+++ b/test/automatic-import.test.js
@@ -0,0 +1,372 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const test = require('node:test');
+const vm = require('node:vm');
+
+const plugin = fs.readFileSync(path.join(__dirname, '..', 'AnimationDirector.js'), 'utf8');
+const io = { fs, path };
+
+function harness(capture = false) {
+  const source = plugin.replace('  Plugin.register(PLUGIN_ID, {', `
+    globalThis.api = { desktopFiles, importFilePath, insidePack, importResourceId, readImportPack, findImportPack, importPackRegistry,
+      resolveImportModel, importModelCandidates, companionImportFiles, definitionActorKeys, defaultImportClipRoles,
+      validateImportGeometry, automaticallyImportAnimation, loadImportTextures, commitAutomaticImport };
+    Plugin.register(PLUGIN_ID, {`).replace('  function commitAutomaticImport(plan) {',
+    `  function commitAutomaticImport(plan) { ${capture ? 'globalThis.importedPlan = plan; return;' : ''}`);
+  const storage = new Map(), dialogs = [], errors = [], undo = [], messages = [];
+  let sequence = 0;
+  class Group {
+    static all = [];
+    constructor(data) { Object.assign(this, data, { uuid: `group-${++sequence}`, children: [] }); }
+    init() { Group.all.push(this); }
+    addTo(parent) { this.parent = parent; if (typeof parent === 'object') parent.children.push(this); }
+  }
+  class Texture {
+    static all = [];
+    constructor(data) { Object.assign(this, data); }
+    fromPath(file) { this.path = file; this.name = path.basename(file); return this; }
+    add(undo) { assert.equal(undo, false); Texture.all.push(this); }
+  }
+  const context = {
+    Project: { uuid: 'original' }, Group, Cube: { all: [] }, Texture, Outliner: { elements: [] },
+    Plugin: { register() {} }, requireNativeModule: require,
+    localStorage: { getItem: (key) => storage.get(key), setItem: (key, value) => storage.set(key, value) },
+    Formats: { geckolib_model: { id: 'geckolib_model' } },
+    newProject(format) {
+      assert.equal(format.id, 'geckolib_model');
+      context.Project = { uuid: 'new-project' };
+      return true;
+    },
+    Undo: {
+      initEdit(aspects) { undo.push({ type: 'begin', aspects }); },
+      finishEdit(action, aspects) { undo.push({ type: 'finish', action, aspects }); },
+      cancelEdit() { undo.push({ type: 'cancel' }); Group.all = []; Texture.all = []; context.Animation.all = []; },
+    },
+    Animator: {
+      loadFile(file, names) {
+        context.loadedAnimation = JSON.parse(file.content);
+        context.Animation.all = names.map((name) => ({ name, select() {} }));
+      },
+    },
+    Animation: { all: [] }, Canvas: { updateAll() {}, updateView() {} },
+    setTimeout() { return 1; }, clearTimeout() {}, console,
+    Blockbench: { showMessageBox(options) { errors.push(options.message); }, showQuickMessage(message) { messages.push(message); } },
+    Filesystem: { importFile(options, callback) { callback(context.selectedFile ? [context.selectedFile] : []); } },
+    Dialog: class {
+      constructor(options) { this.options = options; }
+      show() {
+        dialogs.push(this.options);
+        const result = Object.fromEntries(Object.entries(this.options.form).filter(([, value]) => 'value' in value)
+          .map(([key, value]) => [key, value.value]));
+        const choice = context.answer?.(this.options, result) ?? result;
+        if (choice === false) this.options.onCancel();
+        else this.options.onConfirm(choice);
+      }
+    },
+  };
+  vm.runInNewContext(source, context);
+  return { ...context.api, context, storage, dialogs, errors, undo, messages };
+}
+
+function fixtures(t) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'animationdirector-import-'));
+  t.after(() => {
+    assert.equal(path.dirname(root), fs.realpathSync(os.tmpdir()));
+    fs.rmSync(root, { recursive: true, force: true });
+  });
+  const write = (file, data) => {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, typeof data === 'string' ? data : JSON.stringify(data));
+    return file;
+  };
+  const makePack = (name, metadata = {}) => {
+    const folder = path.join(root, name);
+    write(path.join(folder, 'pack.mcmeta'), { animationframework: { id: `test:${name}`, ...metadata } });
+    return harness().readImportPack(folder, io);
+  };
+  const model = (pack, id, description = {}) => {
+    const [namespace, resource] = id.split(':');
+    return write(path.join(pack.root, 'assets', namespace, 'geckolib', 'models', `${resource}.geo.json`),
+      { ...description, 'minecraft:geometry': [{ description: { texture_width: 64, texture_height: 64 }, bones: [{ name: 'body' }] }] });
+  };
+  return { root, write, makePack, model };
+}
+
+function scopedFilesystem() {
+  return Object.fromEntries(['existsSync', 'readFileSync', 'readdirSync', 'statSync']
+    .map((method) => [method, fs[method].bind(fs)]));
+}
+
+test('Blockbench scoped filesystem without realpathSync supports folder registration and resource lookup', (t) => {
+  const f = fixtures(t), h = harness(), pack = f.makePack('source');
+  h.context.requireNativeModule = (name) => name === 'fs' ? scopedFilesystem() : path;
+  const restricted = h.desktopFiles();
+  assert.equal(restricted.fs.realpathSync, undefined);
+  const model = f.model(pack, 'test:source/entity/wolf.m');
+  const source = h.readImportPack(pack.root, restricted);
+  assert.equal(source.root, path.resolve(pack.root));
+  assert.equal(h.findImportPack(model, restricted).root, source.root);
+  assert.equal(h.resolveImportModel(source, [source], 'minecraft:wolf', 'm', '', restricted).file, model);
+  assert.equal(h.importPackRegistry(source, [source.root], restricted).warnings.length, 0);
+  assert.throws(() => h.insidePack(source.root, '../outside.json', restricted), /escapes/);
+});
+
+test('scoped filesystem fallback rejects linked paths instead of bypassing containment checks', (t) => {
+  const f = fixtures(t), h = harness(), pack = f.makePack('source');
+  const link = path.join(pack.root, 'linked');
+  const target = path.join(f.root, 'outside');
+  fs.mkdirSync(target);
+  fs.symlinkSync(target, link, process.platform === 'win32' ? 'junction' : 'dir');
+  assert.throws(() => h.importFilePath(link, { fs: scopedFilesystem(), path }), /Linked paths/);
+});
+
+test('denied filesystem permission reports an actionable message', () => {
+  const h = harness();
+  h.context.requireNativeModule = (name) => name === 'fs' ? undefined : path;
+  assert.throws(() => h.desktopFiles(), /Allow filesystem access/);
+});
+
+test('model lookup respects local/import/shared priority per gender candidate, not per provider', (t) => {
+  const f = fixtures(t), h = harness();
+  const source = f.makePack('source', { model_imports: [{ pack: 'test:provider', entities: ['minecraft:wolf'] }] });
+  const provider = f.makePack('provider');
+  f.model(source, 'test:source/entity/wolf');
+  const imported = f.model(provider, 'test:provider/entity/wolf.m');
+  const shared = f.model(provider, 'animationframework:entity/wolf.m');
+  assert.equal(h.resolveImportModel(source, [source, provider], 'minecraft:wolf', 'm', '', io).file, imported);
+  assert.equal(h.resolveImportModel(source, [source, provider], 'minecraft:wolf', 'm', '', io).kind, 'Imported test:provider');
+  f.model(source, 'test:source/entity/wolf.m');
+  assert.equal(h.resolveImportModel(source, [source, provider], 'minecraft:wolf', 'm', '', io).kind, 'Local');
+  source.metadata.model_imports = [];
+  fs.unlinkSync(path.join(source.root, 'assets/test/geckolib/models/source/entity/wolf.m.geo.json'));
+  assert.equal(h.resolveImportModel(source, [source, provider], 'minecraft:wolf', 'm', '', io).file, shared);
+});
+
+test('imports are entity-specific and non-transitive; shared overrides follow folder order', (t) => {
+  const f = fixtures(t), h = harness();
+  const source = f.makePack('source', { model_imports: [{ pack: 'test:b', entities: ['minecraft:wolf'] }] });
+  const b = f.makePack('b', { model_imports: [{ pack: 'test:c', entities: ['minecraft:wolf'] }] });
+  const c = f.makePack('c');
+  f.model(c, 'test:c/entity/wolf.m');
+  f.model(b, 'test:b/entity/horse.m');
+  assert.equal(h.resolveImportModel(source, [source, b, c], 'minecraft:wolf', 'm', '', io), null);
+  assert.equal(h.resolveImportModel(source, [source, b, c], 'minecraft:horse', 'm', '', io), null);
+  const top = f.model(b, 'animationframework:entity/wolf.m');
+  f.model(c, 'animationframework:entity/wolf.m');
+  assert.equal(h.resolveImportModel(source, [source, b, c], 'minecraft:wolf', 'm', '', io).file, top);
+});
+
+test('sparse default revisions resolve oldest applicable model before current shared models', (t) => {
+  const f = fixtures(t), h = harness();
+  const source = f.makePack('source');
+  const defaults = f.makePack('defaults', { id: 'needsofnature:default_pack', default_model_revision: 4 });
+  const old = f.model(defaults, 'needsofnature:default_pack_compat/revision_2/entity/horse.m');
+  const later = f.model(defaults, 'needsofnature:default_pack_compat/revision_3/entity/horse.m');
+  const current = f.model(defaults, 'animationframework:entity/horse.m');
+  assert.equal(h.resolveImportModel(source, [source, defaults], 'minecraft:horse', 'm', '', io).file, old);
+  source.metadata.default_model_revision = 3;
+  assert.equal(h.resolveImportModel(source, [source, defaults], 'minecraft:horse', 'm', '', io).file, later);
+  source.metadata.default_model_revision = 4;
+  assert.equal(h.resolveImportModel(source, [source, defaults], 'minecraft:horse', 'm', '', io).file, current);
+});
+
+test('variant, slim and male+female candidates use NoN fallback order, including legacy shared paths', (t) => {
+  const f = fixtures(t), h = harness(), source = f.makePack('source');
+  assert.deepEqual(Array.from(h.importModelCandidates('minecraft:wolf', 'mf', 'snow')), [
+    'wolf_snow.mf', 'wolf.mf', 'wolf_snow', 'wolf', 'wolf_snow.m', 'wolf.m', 'wolf_snow.f', 'wolf.f',
+  ]);
+  assert.equal(h.importModelCandidates('minecraft:player', 'f', '', true)[0], 'player_slim.f');
+  const legacy = f.model(source, 'animationframework:wolf.f');
+  assert.equal(h.resolveImportModel(source, [source], 'minecraft:wolf', 'm', '', io).file, legacy);
+});
+
+test('companion lookup accepts either entry point and detects namespace alternatives without broad scans', (t) => {
+  const f = fixtures(t), h = harness(), pack = f.makePack('source');
+  const def = f.write(path.join(pack.root, 'data/test/afw_animdefs/example.json'), {});
+  const animation = f.write(path.join(pack.root, 'assets/other/animations/afw/example.animation.json'), {});
+  assert.equal(h.findImportPack(def, io).root, pack.root);
+  assert.deepEqual(Array.from(h.companionImportFiles(pack, def, io).animations), [animation]);
+  assert.deepEqual(Array.from(h.companionImportFiles(pack, animation, io).definitions), [def]);
+  assert.throws(() => h.companionImportFiles(pack, path.join(pack.root, 'random.json'), io), /Choose data/);
+  const nested = f.write(path.join(pack.root, 'assets/test/geckolib/animations/afw/nested/nested.animation.json'), {});
+  const nestedDef = f.write(path.join(pack.root, 'data/test/afw_animdefs/nested.json'), {});
+  assert.equal(h.companionImportFiles(pack, nested, io).id, 'nested');
+  assert.deepEqual(Array.from(h.companionImportFiles(pack, nested, io).definitions), [nestedDef]);
+});
+
+test('resource paths cannot escape packs, and invalid/cyclic models are rejected before importing', (t) => {
+  const f = fixtures(t), h = harness(), pack = f.makePack('source');
+  assert.throws(() => h.insidePack(pack.root, '../escape.json', io), /escapes/);
+  for (const id of ['test:../file', 'test:a/../../file', 'test:/absolute', 'test:a//file']) assert.equal(h.importResourceId(id), null);
+  assert.throws(() => h.validateImportGeometry({ 'minecraft:geometry': [{ bones: [{ name: 'a', parent: 'b' }, { name: 'b', parent: 'a' }] }] }), /Cyclic/);
+  assert.throws(() => h.validateImportGeometry({ 'minecraft:geometry': [{ bones: [{ name: 'a' }, { name: 'a' }] }] }), /unique/);
+});
+
+test('registry preserves explicit priority, inserts only new source first, and reports unavailable folders', (t) => {
+  const f = fixtures(t), h = harness(), source = f.makePack('source'), top = f.makePack('top');
+  assert.deepEqual(Array.from(h.importPackRegistry(source, [top.root, source.root], io).packs, (pack) => pack.root), [top.root, source.root]);
+  assert.deepEqual(Array.from(h.importPackRegistry(source, [top.root], io).packs, (pack) => pack.root), [source.root, top.root]);
+  assert.equal(h.importPackRegistry(source, [path.join(f.root, 'missing')], io).warnings.length, 1);
+});
+
+test('actor keys match NoN including required tags, repeated roles and entity variants', () => {
+  const h = harness();
+  assert.deepEqual(Array.from(h.definitionActorKeys([
+    { entity_types: ['minecraft:wolf'], actor_tags: ['gender.male'] },
+    { entity_types: ['minecraft:wolf'], actor_tags: ['gender.male'] },
+    { label: 'Custom Role' },
+    { entity_types: ['minecraft:fox'], actor_tags_any: ['gender.male', 'gender.female'], entity_variant: 'snow', age: 'baby' },
+  ])), ['wolf_gender_male', 'wolf_gender_male_2', 'custom_role', 'fox_any_gender_female_gender_male_snow_baby']);
+});
+
+test('short clip names are inferred only for unambiguous actors; repeated entities require explicit choices', () => {
+  const h = harness();
+  assert.deepEqual(Array.from(h.defaultImportClipRoles([
+    { entity_types: ['minecraft:player'] }, { entity_types: ['minecraft:wolf'], actor_tags: ['gender.male'] },
+  ], ['player', 'wolf'])), ['player', 'wolf']);
+  assert.deepEqual(Array.from(h.defaultImportClipRoles([
+    { entity_types: ['minecraft:player'], actor_tags: ['gender.male'] },
+    { entity_types: ['minecraft:player'], actor_tags: ['gender.female'] },
+  ], ['player', 'player2'])), ['', '']);
+});
+
+test('complete import prepares all stages, actor models, local textures and definition fields without touching the current project', async (t) => {
+  const f = fixtures(t), h = harness(true), source = f.makePack('source');
+  const def = { actors: [{ label: 'wolf', entity_types: ['minecraft:wolf', 'minecraft:fox'], actor_tags: ['gender.male'] }],
+    animators: ['Creator'], content_tags: ['example'], stages: [{ stage: 1, non_peak: true }, { stage: 2 }] };
+  const defFile = f.write(path.join(source.root, 'data/test/afw_animdefs/example.json'), def);
+  f.write(path.join(source.root, 'assets/test/geckolib/animations/afw/example.animation.json'), { animations: {
+    p1_wolf: { animation_length: 1, bones: { body: { rotation: [0, 0, 0] } } },
+    p2_wolf: { animation_length: 1, bones: { body: { rotation: [1, 2, 3] } } },
+  } });
+  f.model(source, 'test:source/entity/wolf.m', { afw_texture: 'test:textures/wolf.png' });
+  f.write(path.join(source.root, 'assets/test/textures/wolf.png'), 'local image');
+  h.context.selectedFile = { path: defFile };
+  h.context.requireNativeModule = (name) => name === 'fs' ? scopedFilesystem() : path;
+  await h.automaticallyImportAnimation();
+  assert.deepEqual(h.errors, []);
+  assert.equal(h.context.Project.uuid, 'original');
+  const plan = h.context.importedPlan;
+  assert.equal(plan.rows[0].resolved.kind, 'Local');
+  assert.equal(plan.rows[0].entity, 'minecraft:wolf');
+  const actorForm = h.dialogs.find((dialog) => dialog.title.endsWith('Actors')).form;
+  assert.equal(actorForm.entity_0.type, 'select');
+  assert.equal(actorForm.entity_0.value, 'minecraft:wolf');
+  assert.equal(actorForm.entity_0.options['minecraft:fox'], 'minecraft:fox');
+  assert.equal(actorForm.gender_0.value, 'm');
+  assert.equal(plan.rows[0].textures.size, 1);
+  assert.deepEqual(Array.from(plan.imported.stageNames), ['example.p1', 'example.p2']);
+  assert.ok(plan.imported.fileObj.animations['example.p2'].bones.actor1_body);
+  assert.equal(plan.definition.actors[0].label, 'wolf');
+  assert.equal(plan.definition.stages[1].non_peak, undefined);
+  assert.equal(h.undo.length, 0);
+  assert.ok(h.storage.get('animationdirector_pack_folders').includes(source.root.replace(/\\/g, '\\\\')));
+});
+
+test('definition actors exclude extra clips, their effects and stages containing only unused actors', async (t) => {
+  const f = fixtures(t), h = harness(true), source = f.makePack('source');
+  const file = f.write(path.join(source.root, 'data/test/afw_animdefs/example.json'), {
+    actors: [{ label: 'wolf', entity_types: ['minecraft:wolf'] }], stages: [{ stage: 1 }],
+  });
+  f.write(path.join(source.root, 'assets/test/animations/afw/example.animation.json'), { animations: {
+    p1_unused: { animation_length: 99, bones: { discarded: { rotation: [1, 2, 3] } },
+      sound_effects: { '0': { effect: 'discarded_sound' } }, particle_effects: { '0': { effect: 'discarded_particle' } } },
+    p1_wolf: { animation_length: 1, bones: { body: { rotation: [0, 0, 0] } } },
+    p2_unused: { animation_length: 99, bones: {} },
+  } });
+  f.model(source, 'test:source/entity/wolf.m');
+  h.context.selectedFile = { path: file };
+  h.context.answer = (dialog, result) => dialog.title.endsWith('Actors') ? { ...result, gender_0: 'm' } : result;
+  await h.automaticallyImportAnimation();
+  assert.deepEqual(h.errors, []);
+  const plan = h.context.importedPlan;
+  assert.equal(plan.rows.length, 1);
+  assert.deepEqual(Array.from(plan.parsed.actorLabels), ['wolf']);
+  assert.deepEqual(Array.from(plan.imported.stageNames), ['example.p1']);
+  const clip = plan.imported.fileObj.animations['example.p1'];
+  assert.equal(clip.animation_length, 1);
+  assert.deepEqual(Object.keys(clip.bones), ['actor1_body']);
+  assert.equal(clip.sound_effects, undefined);
+  assert.equal(clip.particle_effects, undefined);
+  assert.match(h.dialogs.at(-1).form.info.text, /Ignored animation actors.*unused/);
+});
+
+test('a definition actor without a distinct clip still requires a valid mapping', async (t) => {
+  const f = fixtures(t), h = harness(true), source = f.makePack('source');
+  const file = f.write(path.join(source.root, 'data/test/afw_animdefs/example.json'), {
+    actors: [{ label: 'wolf', entity_types: ['minecraft:wolf'] },
+      { label: 'player', entity_types: ['minecraft:player'] }], stages: [{ stage: 1 }],
+  });
+  f.write(path.join(source.root, 'assets/test/animations/afw/example.animation.json'), {
+    animations: { p1_wolf: { animation_length: 1, bones: {} } },
+  });
+  h.context.selectedFile = { path: file };
+  await h.automaticallyImportAnimation();
+  assert.match(h.errors[0], /Each definition actor must be assigned a distinct animation actor/);
+  assert.equal(h.context.importedPlan, undefined);
+  assert.equal(h.context.Project.uuid, 'original');
+});
+
+test('canceling actor review leaves the open project and saved folders unchanged', async (t) => {
+  const f = fixtures(t), h = harness(true), source = f.makePack('source');
+  const file = f.write(path.join(source.root, 'data/test/afw_animdefs/example.json'), {
+    actors: [{ label: 'wolf', entity_types: ['minecraft:wolf'] }], stages: [{ stage: 1 }],
+  });
+  f.write(path.join(source.root, 'assets/test/animations/afw/example.animation.json'), {
+    animations: { p1_wolf: { animation_length: 1, bones: {} } },
+  });
+  h.context.selectedFile = { path: file };
+  h.context.answer = () => false;
+  await h.automaticallyImportAnimation();
+  assert.equal(h.context.Project.uuid, 'original');
+  assert.equal(h.context.importedPlan, undefined);
+  assert.equal(h.storage.size, 0);
+});
+
+test('missing models can be supplied manually, and their locally supplied textures are not downloaded', async (t) => {
+  const f = fixtures(t), h = harness(true), source = f.makePack('source');
+  const file = f.write(path.join(source.root, 'data/test/afw_animdefs/example.json'), {
+    actors: [{ label: 'wolf', entity_types: ['minecraft:wolf'] }], stages: [{ stage: 1 }],
+  });
+  f.write(path.join(source.root, 'assets/test/geckolib/animations/afw/example.animation.json'), {
+    animations: { p1_wolf: { animation_length: 1, bones: { body: { position: [1, 2, 3] } } } },
+  });
+  const model = f.model(source, 'test:unrelated/wolf.m', { afw_texture: 'test:textures/unavailable.png' });
+  h.context.selectedFile = { path: file };
+  h.context.answer = (dialog, result) => dialog.title.endsWith('Actors') ? { ...result, gender_0: 'm' }
+    : dialog.title.endsWith('Models') ? { ...result, model_0: { path: model } } : result;
+  await h.automaticallyImportAnimation();
+  assert.deepEqual(h.errors, []);
+  assert.equal(h.context.importedPlan.rows[0].resolved.kind, 'Manually selected');
+  assert.equal(h.context.importedPlan.rows[0].textures.size, 0);
+  assert.match(h.dialogs.at(-1).form.info.text, /no base texture found locally/);
+});
+
+test('batch import uses a new project, one undo entry, actor prefixes and texture override bindings', () => {
+  const h = harness();
+  const plan = { parsed: { animationId: 'example' }, blockEntry: null,
+    definition: { actors: [{ label: 'wolf', entity_types: ['minecraft:wolf'] }], animators: ['Creator'], stages: [{ stage: 1 }] },
+    imported: { stageNames: ['example.p1'], fileObj: { animations: { 'example.p1': { bones: { actor1_body: { rotation: [1, 2, 3] } } } } } },
+    rows: [{ label: 'wolf', json: { afw_bone_textures: { body: 'test:textures/wolf.png' } },
+      geo: { bones: [{ name: 'body' }] }, defaultTexture: 'test:textures/wolf.png',
+      textures: new Map([['test:textures/wolf.png', { file: 'wolf.png' }]]) }] };
+  h.commitAutomaticImport(plan);
+  assert.equal(h.context.Project.uuid, 'new-project');
+  assert.equal(h.context.Group.all[0].name, 'actor1_body');
+  assert.deepEqual(h.undo.map((entry) => entry.type), ['begin', 'finish']);
+  assert.equal(h.undo[1].aspects.automatic_animation_import, true);
+  assert.equal(h.undo[1].aspects.groups.length, 1);
+  const override = JSON.parse(h.context.Project.multiactor_bone_texture_overrides);
+  assert.equal(override[h.context.Group.all[0].uuid].texture, 'test:textures/wolf.png');
+  assert.ok(JSON.parse(h.context.Project.animationdirector_animdef_definitions).example);
+});
+
+test('unexpected animation-load failures cancel the batch rather than keeping a partial import', () => {
+  const h = harness();
+  h.context.Animator.loadFile = () => { throw new Error('load failed'); };
+  assert.throws(() => h.commitAutomaticImport({ parsed: { animationId: 'example' }, rows: [],
+    definition: {}, imported: { fileObj: {}, stageNames: [] } }), /load failed/);
+  assert.deepEqual(h.undo.map((entry) => entry.type), ['begin', 'cancel']);
+});
diff --git a/test/block-requirements.test.js b/test/block-requirements.test.js
index 3960bf2..32ae3f1 100644
--- a/test/block-requirements.test.js
+++ b/test/block-requirements.test.js
@@ -7,7 +7,7 @@ const vm = require('node:vm');
 function harness() {
   const source = fs.readFileSync(path.join(__dirname, '..', 'AnimationDirector.js'), 'utf8').replace(
     '  Plugin.register(PLUGIN_ID, {',
-    '  globalThis.blockTest = { readBlockRequirementForm, buildBlockRequirementGuideBoxes, stripBlockRequirementGuideBones, showAnimationDefinitionReviewDialog, rebuildBlockRequirementGuides, getAuthoredBlockRequirement, compileGeckoModelJson, createBlockRequirementPanel, hideInternalBlockGuideFaces, refreshBlockGuideFaces, getPanel: () => blockRequirementPanel };\n  Plugin.register(PLUGIN_ID, {'
+    '  globalThis.blockTest = { readBlockRequirementForm, buildBlockRequirementGuideBoxes, stripBlockRequirementGuideBones, showAnimationDefinitionReviewDialog, rebuildBlockRequirementGuides, getAuthoredBlockRequirement, compileGeckoModelJson, createBlockRequirementPanel, hideInternalBlockGuideFaces, refreshBlockGuideFaces, prepareAnimationDefinitionImport, applyAnimationDefinitionImport, importAnimationDefinition, getSavedAnimdef, getPanel: () => blockRequirementPanel };\n  Plugin.register(PLUGIN_ID, {'
   );
   const project = { uuid: 'project-one', multiactor_actor_names: JSON.stringify({ 1: 'player', 2: 'wolf' }) };
   const dialogs = [];
@@ -18,6 +18,7 @@ function harness() {
   const previewEvents = new Map();
   const timers = new Map();
   const previewUpdates = [];
+  const menus = [];
   let sequence = 0;
   class Group {
     static all = [];
@@ -45,7 +46,7 @@ function harness() {
   }
   const context = {
     Project: project, Group, Cube, Plugin: { register(id, definition) { context.registration = definition; } },
-    Action: class { constructor(id, options) { Object.assign(this, options); } },
+    Action: class { constructor(id, options) { Object.assign(this, options, { id }); } },
     Panel: class {
       constructor(id, options) {
         this.options = options;
@@ -55,7 +56,7 @@ function harness() {
     },
     setTimeout(callback) { const id = ++sequence; timers.set(id, callback); return id; },
     clearTimeout(id) { timers.delete(id); },
-    MenuBar: { menus: { tools: { addAction() {} } }, update() {} },
+    MenuBar: { menus: { tools: { addAction(menu) { menus.push(menu); } } }, update() {} },
     THREE: { MeshBasicMaterial: class { constructor(options) { Object.assign(this, options); } }, DoubleSide: 2 },
     Canvas: {
       updateAll() {
@@ -85,7 +86,7 @@ function harness() {
     console,
   };
   vm.runInNewContext(source, context);
-  return { ...context.blockTest, context, project, dialogs, exports, errors, edits, events, previewEvents, timers, previewUpdates, Group, Cube };
+  return { ...context.blockTest, context, project, dialogs, exports, errors, edits, events, previewEvents, timers, previewUpdates, menus, Group, Cube };
 }
 
 function wallForm(overrides = {}) {
@@ -93,6 +94,139 @@ function wallForm(overrides = {}) {
     facing: '', clearance_width: 1, clearance_height: 2, clearance_depth: 1, wall_thickness: 1, ...overrides };
 }
 
+function importAnalysis() {
+  return { actorIndices: [1, 2], actorLabels: new Map([[1, 'player'], [2, 'wolf']]),
+    stages: [{ stageNumber: 1, name: 'test.p1', loop: true, cycleSeconds: 1 },
+      { stageNumber: 2, name: 'test.p2', loop: false, cycleSeconds: 2 }], warnings: [] };
+}
+
+test('animation menu orders import and creation actions and has no deprecated split-file tools', () => {
+  const h = harness();
+  h.context.registration.onload();
+  const menu = h.menus.find((entry) => entry.id === 'animationdirector_anims');
+  assert.deepEqual(Array.from(menu.children, (action) => action.name), [
+    'Automatically Import Animation', 'Manual Import', 'Actor Preferences',
+    'Replace Actor Model', 'Export Animations', 'Block Requirements', 'Create Animation Definition',
+  ]);
+  assert.deepEqual(Array.from(menu.children[1].children, (action) => action.name), [
+    'Import Actor', 'Import Animation', 'Import Animation Definition', 'Pack Folders',
+  ]);
+  const source = fs.readFileSync(path.join(__dirname, '..', 'AnimationDirector.js'), 'utf8');
+  assert.doesNotMatch(source, /importSplitActorAnimation|buildSplitImportFile|analyzeSplitAnimationFiles|exportSelectedActorAnimation|exportAllActorAnimations|animationdirector_deprecated/);
+});
+
+test('import prefills generator fields, builds guides and retains fields without UI controls on export', () => {
+  const h = harness();
+  const source = {
+    display_name: 'Imported animation', animators: ['Animator'], content_tags: ['test'],
+    system_tags: ['manualpeak'], weight: 2.5, required_union_tags: ['example.tag'],
+    join_after: ['example:previous'], match_content_on_join: true, attack_eligible: false,
+    liquid_gain_multiplier: 0.5, manual_peak: { priority: 5 }, speed: 1.5,
+    water: 'surface', position_anchor_actor: 'wolf',
+    camera: { torso_tracking: 'continuous', block_requirement_collision: 'ignore' },
+    addon_data: { example: { flag: true } }, escapable: false,
+    actors: [
+      { label: 'player', entity_types: ['minecraft:player'], activity: 'passive', receiver: true, age: 'adult' },
+      { label: 'wolf', entity_types: ['minecraft:wolf'], actor_tags: ['gender.male'], activity: 'active',
+        injector: 'V', injects_into: 'player', held_item: { items: ['#minecraft:swords'], hand: 'either', prop_slot: 'right' } },
+    ],
+    stages: [
+      { stage: 1, loop: true, cycle_seconds: 0.75, allow_join: false, escapable: true,
+        speed: 1.25, stage_duration_multiplier: 0.5, cycle_midpoint_offset_seconds: 0.1,
+        props: { right: { item: 'minecraft:carrot' } } },
+      { stage: 2, loop: false, cycle_seconds: 1.75, allow_join: true, escapable: false, non_peak: true },
+    ],
+    block_requirements: { type: 'wall', blocks: '#minecraft:fences', height: { min: 3 },
+      width: { min: 2, max: 2, both_axes: true }, facing: 'front', clearance: { width: 1, height: 2, depth: 1 } },
+  };
+  h.applyAnimationDefinitionImport({ id: 'test' }, importAnalysis(), source);
+  const dialog = h.dialogs.at(-1);
+  const values = Object.fromEntries(Object.entries(dialog.form)
+    .filter(([, field]) => field && typeof field === 'object' && 'value' in field).map(([key, field]) => [key, field.value]));
+  assert.equal(values.display_name, source.display_name);
+  assert.equal(values.animators, 'Animator');
+  assert.equal(values.weight, 2.5);
+  assert.equal(values.system_tags, 'manualpeak');
+  assert.equal(values.manual_peak_priority, 5);
+  assert.equal(values.stub_actor_1_receiver, true);
+  assert.equal(values.stub_actor_2_injector, 'V');
+  assert.deepEqual(Array.from(values.stub_actor_2_injects_into), ['player']);
+  assert.equal(values.stub_actor_2_held_items, '#minecraft:swords');
+  assert.equal(values.stub_actor_2_held_hand, 'either');
+  assert.equal(values.stub_stage_1_duration_multiplier, 0.5);
+  assert.equal(values.stub_stage_1_cycle_seconds, 0.75);
+  assert.equal(values.stub_stage_2_peaked, true);
+  assert.ok(h.Cube.all.length > 0);
+  assert.equal(h.edits.length, 1);
+  assert.equal(h.edits[0].action, 'Import animation definition');
+  assert.equal(h.edits[0].aspects.animdef_edit, true);
+  assert.equal(dialog.onConfirm(values), true);
+  const exported = h.exports.at(-1);
+  assert.deepEqual(exported.stages[0].props, source.stages[0].props);
+  assert.deepEqual(exported.addon_data, source.addon_data);
+  assert.equal(exported.actors[0].age, 'adult');
+  assert.equal(exported.actors[1].injects_into, 'player');
+  assert.equal(exported.block_requirements.width.both_axes, true);
+  assert.equal(h.errors.length, 0);
+});
+
+test('import maps explicit labels before positional fallbacks and updates actor references', () => {
+  const h = harness();
+  const source = { actors: [{ label: 'wolf', injector: 'V', injects_into: 'bottom' },
+    { label: 'bottom', receiver: true }], stages: [{ stage: 1 }, { stage: 2 }], position_anchor_actor: 'bottom' };
+  const definition = h.prepareAnimationDefinitionImport(source, importAnalysis());
+  assert.equal(definition.actors[0].label, 'player');
+  assert.equal(definition.actors[0].receiver, true);
+  assert.equal(definition.actors[1].label, 'wolf');
+  assert.deepEqual(Array.from(definition.actors[1].injects_into), ['player']);
+  assert.equal(definition.position_anchor_actor, 'player');
+  assert.equal(source.actors[1].label, 'bottom', 'Input JSON is not mutated');
+  const positional = h.prepareAnimationDefinitionImport({ actors: [{ receiver: true }, { injector: 'V' }],
+    stages: [{ stage: 1 }, { stage: 2 }] }, importAnalysis());
+  assert.equal(positional.actors[0].label, 'player');
+  assert.equal(positional.actors[1].label, 'wolf');
+});
+
+test('invalid imports leave definitions and guides unchanged', () => {
+  const h = harness();
+  h.rebuildBlockRequirementGuides('test', h.readBlockRequirementForm(wallForm()));
+  const before = h.project.animationdirector_block_requirements;
+  const source = { actors: [{}, {}], stages: [{ stage: 1 }, { stage: 2 }] };
+  for (const invalid of [null, { animations: {} }, { ...source, actors: [{}] },
+    { ...source, stages: [{ stage: 1 }] }, { ...source, stages: [{ stage: 1 }, { stage: 1 }] },
+    { ...source, actors: [{ label: 'same' }, { label: 'same' }] },
+    { ...source, actors: [{ injects_into: 'unknown' }, {}] },
+    { ...source, content_tags: 'wrong' },
+    { ...source, block_requirements: { type: 'wall', width: { min: 2, max: 1 } } }]) {
+    assert.throws(() => h.applyAnimationDefinitionImport({ id: 'test' }, importAnalysis(), invalid));
+  }
+  assert.equal(h.project.animationdirector_block_requirements, before);
+  assert.equal(h.project.animationdirector_animdef_definitions, undefined);
+  assert.equal(h.edits.length, 1);
+});
+
+test('import without a requirement removes old guides and undo restores definition metadata too', () => {
+  const h = harness();
+  h.context.registration.onload();
+  h.rebuildBlockRequirementGuides('test', h.readBlockRequirementForm(wallForm()));
+  const before = {};
+  h.events.get('create_undo_save')({ save: before, aspects: { block_requirement_edit: true, animdef_edit: true } });
+  h.applyAnimationDefinitionImport({ id: 'test' }, importAnalysis(), {
+    actors: [{}, {}], stages: [{ stage: 1 }, { stage: 2 }], animation_tags: ['defeat'] });
+  assert.equal(h.Cube.all.length, 0);
+  assert.equal(h.getAuthoredBlockRequirement('test').requirement, null);
+  assert.deepEqual(Array.from(h.getSavedAnimdef('test').system_tags), ['defeat']);
+  assert.equal(h.dialogs.at(-1).form.stub_stage_2_peaked.value, false, 'Missing peak flags are not invented');
+  const after = {};
+  h.events.get('create_undo_save')({ save: after, aspects: { block_requirement_edit: true, animdef_edit: true } });
+  h.events.get('load_undo_save')({ save: before });
+  assert.equal(h.getAuthoredBlockRequirement('test').requirement.type, 'wall');
+  assert.equal(Object.keys(h.getSavedAnimdef('test')).length, 0);
+  h.events.get('load_undo_save')({ save: after });
+  assert.equal(h.getAuthoredBlockRequirement('test').requirement, null);
+  assert.equal(h.getSavedAnimdef('test').actors.length, 2);
+});
+
 test('building, editing, refreshing and removing guides never resets actor or folder texture overrides', () => {
   const h = harness();
   const actor = new h.Group({ name: 'actor1_body' });