behaviortrees 0.0.0-stage → 0.1.0

package/dist/chunks/chunk-VTXL3OVS.js

@@ -0,0 +1,1902 @@
+// src/core/site.ts
+var SITE = (process.env.BEHAVIORTREES_SITE ?? "https://www.behaviortrees.com").replace(/\/$/, "");
+
+// ../examples/trees/cooldown-specials.json
+var cooldown_specials_default = {
+  id: "cooldown-specials",
+  title: "Cooldown-Gated Special Attacks",
+  description: "Attack selection with a priority selector: a dramatic rocket attack gated by a cooldown decorator, falling back to shooting while ammo lasts, then melee. Note the cooldown wraps the whole rocket sequence, not just the range check.",
+  root: "n1",
+  properties: {},
+  custom_nodes: [
+    { name: "Cooldown", category: "decorator", title: "Cooldown <milliseconds>ms", description: "Fails without running its child until the cooldown has elapsed since the last completed run.", properties: { milliseconds: 1e4 } },
+    { name: "IsPlayerInRange", category: "condition", title: "Is Player In Range?", description: "Succeeds if the player is within the given range.", properties: { range: 8 } },
+    { name: "FireRocket", category: "action", title: "Fire Rocket", description: "Fires the rocket launcher at the player.", properties: {} },
+    { name: "HasAmmo", category: "condition", title: "Has Ammo?", description: "Succeeds if the primary weapon has ammunition left.", properties: {} },
+    { name: "ShootPlayer", category: "action", title: "Shoot Player", description: "Fires the primary weapon at the player.", properties: {} },
+    { name: "MeleeAttack", category: "action", title: "Melee Attack", description: "Unconditional fallback: swings at the player up close.", properties: {} }
+  ],
+  nodes: {
+    n1: { id: "n1", name: "Priority", title: "Choose Attack", description: "Prefers the special whenever it is legal, degrading gracefully to basic attacks.", properties: {}, display: { x: 0, y: 0 }, children: ["n2", "n6", "n9"] },
+    n2: { id: "n2", name: "Cooldown", title: "Cooldown", description: "", properties: { milliseconds: 1e4 }, display: { x: 0, y: 0 }, child: "n3" },
+    n3: { id: "n3", name: "Sequence", title: "Rocket Attack", description: "", properties: {}, display: { x: 0, y: 0 }, children: ["n4", "n5"] },
+    n4: { id: "n4", name: "IsPlayerInRange", title: "Is Player In Range?", description: "", properties: { range: 8 }, display: { x: 0, y: 0 } },
+    n5: { id: "n5", name: "FireRocket", title: "Fire Rocket", description: "", properties: {}, display: { x: 0, y: 0 } },
+    n6: { id: "n6", name: "Sequence", title: "Shoot", description: "", properties: {}, display: { x: 0, y: 0 }, children: ["n7", "n8"] },
+    n7: { id: "n7", name: "HasAmmo", title: "Has Ammo?", description: "", properties: {}, display: { x: 0, y: 0 } },
+    n8: { id: "n8", name: "ShootPlayer", title: "Shoot Player", description: "", properties: {}, display: { x: 0, y: 0 } },
+    n9: { id: "n9", name: "MeleeAttack", title: "Melee Attack", description: "", properties: {}, display: { x: 0, y: 0 } }
+  }
+};
+
+// ../examples/trees/enemy-patrol.json
+var enemy_patrol_default = {
+  id: "enemy-patrol",
+  title: "Enemy Patrol AI",
+  description: "A classic enemy NPC: attack the player when in range, chase when visible, otherwise patrol between waypoints.",
+  root: "n1",
+  properties: {},
+  custom_nodes: [
+    { name: "IsPlayerInRange", category: "condition", title: "Is Player In Range?", description: "Succeeds if the player is within attack range.", properties: { range: 2 } },
+    { name: "AttackPlayer", category: "action", title: "Attack Player", description: "Performs an attack against the player.", properties: {} },
+    { name: "IsPlayerVisible", category: "condition", title: "Is Player Visible?", description: "Succeeds if the player is within sight distance and line of sight.", properties: { distance: 10 } },
+    { name: "MoveToPlayer", category: "action", title: "Move To Player", description: "Moves the agent toward the player's position.", properties: { speed: 4 } },
+    { name: "MoveToWaypoint", category: "action", title: "Move To Waypoint", description: "Moves the agent toward the current patrol waypoint.", properties: { speed: 2 } },
+    { name: "NextWaypoint", category: "action", title: "Next Waypoint", description: "Advances the patrol route to the next waypoint.", properties: {} }
+  ],
+  nodes: {
+    n1: { id: "n1", name: "Priority", title: "Enemy AI", description: "Tries each behavior in order until one succeeds.", properties: {}, display: { x: 0, y: 0 }, children: ["n2", "n5", "n8"] },
+    n2: { id: "n2", name: "Sequence", title: "Attack", description: "", properties: {}, display: { x: 0, y: 0 }, children: ["n3", "n4"] },
+    n3: { id: "n3", name: "IsPlayerInRange", title: "Is Player In Range?", description: "", properties: { range: 2 }, display: { x: 0, y: 0 } },
+    n4: { id: "n4", name: "AttackPlayer", title: "Attack Player", description: "", properties: {}, display: { x: 0, y: 0 } },
+    n5: { id: "n5", name: "Sequence", title: "Chase", description: "", properties: {}, display: { x: 0, y: 0 }, children: ["n6", "n7"] },
+    n6: { id: "n6", name: "IsPlayerVisible", title: "Is Player Visible?", description: "", properties: { distance: 10 }, display: { x: 0, y: 0 } },
+    n7: { id: "n7", name: "MoveToPlayer", title: "Move To Player", description: "", properties: { speed: 4 }, display: { x: 0, y: 0 } },
+    n8: { id: "n8", name: "Sequence", title: "Patrol", description: "", properties: {}, display: { x: 0, y: 0 }, children: ["n9", "n10", "n11"] },
+    n9: { id: "n9", name: "MoveToWaypoint", title: "Move To Waypoint", description: "", properties: { speed: 2 }, display: { x: 0, y: 0 } },
+    n10: { id: "n10", name: "Wait", title: "Wait", description: "", properties: { milliseconds: 2e3 }, display: { x: 0, y: 0 } },
+    n11: { id: "n11", name: "NextWaypoint", title: "Next Waypoint", description: "", properties: {}, display: { x: 0, y: 0 } }
+  }
+};
+
+// ../examples/trees/open-the-door.json
+var open_the_door_default = {
+  id: "open-the-door",
+  title: "Open The Door (Selector vs Sequence)",
+  description: "The classic teaching example: a selector tries strategies in priority order, and each strategy is a sequence of steps that must all succeed.",
+  root: "n1",
+  properties: {},
+  custom_nodes: [
+    { name: "IsDoorOpen", category: "condition", title: "Is Door Open?", description: "Succeeds if the door is already open.", properties: {} },
+    { name: "WalkThrough", category: "action", title: "Walk Through Door", description: "Walks the agent through the doorway.", properties: {} },
+    { name: "HasKey", category: "condition", title: "Has Key?", description: "Succeeds if the agent carries the door key.", properties: {} },
+    { name: "UnlockDoor", category: "action", title: "Unlock Door", description: "Unlocks the door with the key.", properties: {} },
+    { name: "OpenDoor", category: "action", title: "Open Door", description: "Opens the unlocked door.", properties: {} },
+    { name: "SmashDoor", category: "action", title: "Smash Door", description: "Breaks the door down as a last resort.", properties: { strengthRequired: 8 } }
+  ],
+  nodes: {
+    n1: { id: "n1", name: "Priority", title: "Enter The Room", description: "Tries the cheapest strategy first, falling back to more drastic ones.", properties: {}, display: { x: 0, y: 0 }, children: ["n2", "n5", "n10"] },
+    n2: { id: "n2", name: "Sequence", title: "Just Walk In", description: "", properties: {}, display: { x: 0, y: 0 }, children: ["n3", "n4"] },
+    n3: { id: "n3", name: "IsDoorOpen", title: "Is Door Open?", description: "", properties: {}, display: { x: 0, y: 0 } },
+    n4: { id: "n4", name: "WalkThrough", title: "Walk Through Door", description: "", properties: {}, display: { x: 0, y: 0 } },
+    n5: { id: "n5", name: "Sequence", title: "Use The Key", description: "", properties: {}, display: { x: 0, y: 0 }, children: ["n6", "n7", "n8", "n9"] },
+    n6: { id: "n6", name: "HasKey", title: "Has Key?", description: "", properties: {}, display: { x: 0, y: 0 } },
+    n7: { id: "n7", name: "UnlockDoor", title: "Unlock Door", description: "", properties: {}, display: { x: 0, y: 0 } },
+    n8: { id: "n8", name: "OpenDoor", title: "Open Door", description: "", properties: {}, display: { x: 0, y: 0 } },
+    n9: { id: "n9", name: "WalkThrough", title: "Walk Through Door", description: "", properties: {}, display: { x: 0, y: 0 } },
+    n10: { id: "n10", name: "Sequence", title: "Brute Force", description: "", properties: {}, display: { x: 0, y: 0 }, children: ["n11", "n12"] },
+    n11: { id: "n11", name: "SmashDoor", title: "Smash Door", description: "", properties: { strengthRequired: 8 }, display: { x: 0, y: 0 } },
+    n12: { id: "n12", name: "WalkThrough", title: "Walk Through Door", description: "", properties: {}, display: { x: 0, y: 0 } }
+  }
+};
+
+// ../examples/trees/robot-navigate-recovery.json
+var robot_navigate_recovery_default = {
+  id: "robot-navigate-recovery",
+  title: "Robot Navigation With Recovery",
+  description: "A Nav2-style navigate-to-pose tree: plan a path (with retries) and follow it; when navigation fails, run recovery behaviors in escalating fallback order \u2014 clear costmaps, spin, back up, wait \u2014 then retry navigation.",
+  root: "n1",
+  properties: {},
+  custom_nodes: [
+    { name: "ComputePathToPose", category: "action", title: "Compute Path To Pose", description: "Asks the planner for a path from the robot to the goal pose.", properties: { goal: "goal_pose" } },
+    { name: "FollowPath", category: "action", title: "Follow Path", description: "Drives the robot along the planned path; fails if the robot gets stuck or the path becomes blocked.", properties: { controller: "FollowPath" } },
+    { name: "ClearCostmaps", category: "action", title: "Clear Costmaps", description: "Cheapest recovery: wipes stale obstacle data so planning can see freed space.", properties: {} },
+    { name: "Spin", category: "action", title: "Spin In Place", description: "Rotates in place to refresh sensor coverage around the robot.", properties: { degrees: 90 } },
+    { name: "BackUp", category: "action", title: "Back Up", description: "Reverses a short distance to escape a tight spot.", properties: { distance: 0.3 } }
+  ],
+  nodes: {
+    n1: { id: "n1", name: "RepeatUntilSuccess", title: "Retry Navigation", description: "The whole attempt loops until navigation succeeds or the retry budget runs out.", properties: { maxLoop: 6 }, display: { x: 0, y: 0 }, child: "n2" },
+    n2: { id: "n2", name: "Priority", title: "Navigate Or Recover", description: "Try to navigate; only when that fails does a recovery run.", properties: {}, display: { x: 0, y: 0 }, children: ["n3", "n7"] },
+    n3: { id: "n3", name: "MemSequence", title: "Navigate", description: "A procedural checklist, so a long FollowPath is not restarted every tick.", properties: {}, display: { x: 0, y: 0 }, children: ["n4", "n6"] },
+    n4: { id: "n4", name: "RepeatUntilSuccess", title: "Retry Planning", description: "", properties: { maxLoop: 3 }, display: { x: 0, y: 0 }, child: "n5" },
+    n5: { id: "n5", name: "ComputePathToPose", title: "Compute Path To Pose", description: "", properties: { goal: "goal_pose" }, display: { x: 0, y: 0 } },
+    n6: { id: "n6", name: "FollowPath", title: "Follow Path", description: "", properties: { controller: "FollowPath" }, display: { x: 0, y: 0 } },
+    n7: { id: "n7", name: "Sequence", title: "Recover", description: "Runs one recovery, then deliberately fails so the retry loop navigates again.", properties: {}, display: { x: 0, y: 0 }, children: ["n8", "n13"] },
+    n8: { id: "n8", name: "Priority", title: "Recovery Behaviors", description: "Escalating fallbacks, cheapest first.", properties: {}, display: { x: 0, y: 0 }, children: ["n9", "n10", "n11", "n12"] },
+    n9: { id: "n9", name: "ClearCostmaps", title: "Clear Costmaps", description: "", properties: {}, display: { x: 0, y: 0 } },
+    n10: { id: "n10", name: "Spin", title: "Spin In Place", description: "", properties: { degrees: 90 }, display: { x: 0, y: 0 } },
+    n11: { id: "n11", name: "BackUp", title: "Back Up", description: "", properties: { distance: 0.3 }, display: { x: 0, y: 0 } },
+    n12: { id: "n12", name: "Wait", title: "Wait", description: "Last resort: wait for the world to change (a door to open, a person to pass).", properties: { milliseconds: 5e3 }, display: { x: 0, y: 0 } },
+    n13: { id: "n13", name: "Failer", title: "Recovery Done \u2014 Go Retry", description: "Forces the branch to fail so RepeatUntilSuccess ticks navigation again.", properties: {}, display: { x: 0, y: 0 } }
+  }
+};
+
+// ../examples/trees/robot-pick-and-place.json
+var robot_pick_and_place_default = {
+  id: "robot-pick-and-place",
+  title: "Robot Pick And Place",
+  description: "A robotics-style task: acquire an object if not already holding one, carry it to the target, and place it. Grasping retries until it succeeds.",
+  root: "n1",
+  properties: {},
+  custom_nodes: [
+    { name: "IsHoldingObject", category: "condition", title: "Is Holding Object?", description: "Succeeds if the gripper currently holds the object.", properties: {} },
+    { name: "MoveToObject", category: "action", title: "Move To Object", description: "Plans and executes a motion to the object's pose.", properties: { tolerance: 0.01 } },
+    { name: "GraspObject", category: "action", title: "Grasp Object", description: "Closes the gripper on the object.", properties: { force: 20 } },
+    { name: "MoveToTarget", category: "action", title: "Move To Target", description: "Carries the object to the target location.", properties: { tolerance: 0.01 } },
+    { name: "PlaceObject", category: "action", title: "Place Object", description: "Releases the object at the target pose.", properties: {} }
+  ],
+  nodes: {
+    n1: { id: "n1", name: "Sequence", title: "Pick And Place", description: "", properties: {}, display: { x: 0, y: 0 }, children: ["n2", "n7", "n8"] },
+    n2: { id: "n2", name: "Priority", title: "Ensure Holding Object", description: "Skip acquisition if the object is already held.", properties: {}, display: { x: 0, y: 0 }, children: ["n3", "n4"] },
+    n3: { id: "n3", name: "IsHoldingObject", title: "Is Holding Object?", description: "", properties: {}, display: { x: 0, y: 0 } },
+    n4: { id: "n4", name: "Sequence", title: "Acquire Object", description: "", properties: {}, display: { x: 0, y: 0 }, children: ["n5", "n6"] },
+    n5: { id: "n5", name: "MoveToObject", title: "Move To Object", description: "", properties: { tolerance: 0.01 }, display: { x: 0, y: 0 } },
+    n6: { id: "n6", name: "RepeatUntilSuccess", title: "Retry Grasp", description: "", properties: { maxLoop: 3 }, display: { x: 0, y: 0 }, child: "n6a" },
+    n6a: { id: "n6a", name: "GraspObject", title: "Grasp Object", description: "", properties: { force: 20 }, display: { x: 0, y: 0 } },
+    n7: { id: "n7", name: "MoveToTarget", title: "Move To Target", description: "", properties: { tolerance: 0.01 }, display: { x: 0, y: 0 } },
+    n8: { id: "n8", name: "PlaceObject", title: "Place Object", description: "", properties: {}, display: { x: 0, y: 0 } }
+  }
+};
+
+// ../examples/trees/survival-override.json
+var survival_override_default = {
+  id: "survival-override",
+  title: "Survival Override Enemy",
+  description: "A full enemy brain with a top-priority survival branch: when health runs low the agent abandons whatever it was doing to flee, heal, or fight cornered \u2014 no transitions required.",
+  root: "n1",
+  properties: {},
+  custom_nodes: [
+    { name: "IsHealthLow", category: "condition", title: "Is Health Low?", description: "Succeeds if health is below the threshold.", properties: { threshold: 30 } },
+    { name: "FleeToCover", category: "action", title: "Flee To Cover", description: "Runs to the nearest cover point away from the threat.", properties: { speed: 5 } },
+    { name: "UseHealthItem", category: "action", title: "Use Health Item", description: "Consumes a health item if one is carried; fails otherwise.", properties: {} },
+    { name: "FightCornered", category: "action", title: "Fight Cornered", description: "Last resort: attacks desperately when there is no escape.", properties: {} },
+    { name: "IsPlayerInRange", category: "condition", title: "Is Player In Range?", description: "Succeeds if the player is within attack range.", properties: { range: 2 } },
+    { name: "AttackPlayer", category: "action", title: "Attack Player", description: "Performs an attack against the player.", properties: {} },
+    { name: "IsPlayerVisible", category: "condition", title: "Is Player Visible?", description: "Succeeds if the player is within sight distance and line of sight.", properties: { distance: 10 } },
+    { name: "MoveToPlayer", category: "action", title: "Move To Player", description: "Moves the agent toward the player's position.", properties: { speed: 4 } },
+    { name: "MoveToWaypoint", category: "action", title: "Move To Waypoint", description: "Moves the agent toward the current patrol waypoint.", properties: { speed: 2 } },
+    { name: "NextWaypoint", category: "action", title: "Next Waypoint", description: "Advances the patrol route to the next waypoint.", properties: {} }
+  ],
+  nodes: {
+    n1: { id: "n1", name: "Priority", title: "Enemy AI", description: "The survival branch is evaluated first on every tick, so it preempts everything below it.", properties: {}, display: { x: 0, y: 0 }, children: ["n2", "n7", "n10", "n13"] },
+    n2: { id: "n2", name: "Sequence", title: "Survive", description: "", properties: {}, display: { x: 0, y: 0 }, children: ["n3", "n4"] },
+    n3: { id: "n3", name: "IsHealthLow", title: "Is Health Low?", description: "", properties: { threshold: 30 }, display: { x: 0, y: 0 } },
+    n4: { id: "n4", name: "Priority", title: "Stay Alive", description: "Escalating survival strategies, cheapest first.", properties: {}, display: { x: 0, y: 0 }, children: ["n5", "n6", "n6b"] },
+    n5: { id: "n5", name: "FleeToCover", title: "Flee To Cover", description: "", properties: { speed: 5 }, display: { x: 0, y: 0 } },
+    n6: { id: "n6", name: "UseHealthItem", title: "Use Health Item", description: "", properties: {}, display: { x: 0, y: 0 } },
+    n6b: { id: "n6b", name: "FightCornered", title: "Fight Cornered", description: "", properties: {}, display: { x: 0, y: 0 } },
+    n7: { id: "n7", name: "Sequence", title: "Attack", description: "", properties: {}, display: { x: 0, y: 0 }, children: ["n8", "n9"] },
+    n8: { id: "n8", name: "IsPlayerInRange", title: "Is Player In Range?", description: "", properties: { range: 2 }, display: { x: 0, y: 0 } },
+    n9: { id: "n9", name: "AttackPlayer", title: "Attack Player", description: "", properties: {}, display: { x: 0, y: 0 } },
+    n10: { id: "n10", name: "Sequence", title: "Chase", description: "", properties: {}, display: { x: 0, y: 0 }, children: ["n11", "n12"] },
+    n11: { id: "n11", name: "IsPlayerVisible", title: "Is Player Visible?", description: "", properties: { distance: 10 }, display: { x: 0, y: 0 } },
+    n12: { id: "n12", name: "MoveToPlayer", title: "Move To Player", description: "", properties: { speed: 4 }, display: { x: 0, y: 0 } },
+    n13: { id: "n13", name: "Sequence", title: "Patrol", description: "", properties: {}, display: { x: 0, y: 0 }, children: ["n14", "n15", "n16"] },
+    n14: { id: "n14", name: "MoveToWaypoint", title: "Move To Waypoint", description: "", properties: { speed: 2 }, display: { x: 0, y: 0 } },
+    n15: { id: "n15", name: "Wait", title: "Wait", description: "", properties: { milliseconds: 2e3 }, display: { x: 0, y: 0 } },
+    n16: { id: "n16", name: "NextWaypoint", title: "Next Waypoint", description: "", properties: {}, display: { x: 0, y: 0 } }
+  }
+};
+
+// ../../apps/editor/src/lib/behavior/defaults.ts
+var DEFAULT_NODES = {
+  Root: {
+    name: "Root",
+    title: "Root",
+    category: "root",
+    description: "The entry point of the behavior tree",
+    properties: {},
+    isDefault: true
+  },
+  // Composites
+  Sequence: {
+    name: "Sequence",
+    title: "Sequence",
+    category: "composite",
+    description: "Runs children in order; fails when one fails (AND)",
+    properties: {},
+    isDefault: true
+  },
+  Priority: {
+    name: "Priority",
+    title: "Priority",
+    category: "composite",
+    description: "Runs children in order; succeeds when one succeeds (OR / selector)",
+    properties: {},
+    isDefault: true
+  },
+  MemSequence: {
+    name: "MemSequence",
+    title: "MemSequence",
+    category: "composite",
+    description: "Sequence with memory: resumes from the running child",
+    properties: {},
+    isDefault: true
+  },
+  MemPriority: {
+    name: "MemPriority",
+    title: "MemPriority",
+    category: "composite",
+    description: "Priority with memory: resumes from the running child",
+    properties: {},
+    isDefault: true
+  },
+  // Decorators
+  Repeater: {
+    name: "Repeater",
+    title: "Repeat <maxLoop>x",
+    category: "decorator",
+    description: "Repeats the child up to maxLoop times (-1 = forever)",
+    properties: { maxLoop: -1 },
+    isDefault: true
+  },
+  RepeatUntilFailure: {
+    name: "RepeatUntilFailure",
+    title: "Repeat Until Failure",
+    category: "decorator",
+    description: "Repeats the child until it fails",
+    properties: { maxLoop: -1 },
+    isDefault: true
+  },
+  RepeatUntilSuccess: {
+    name: "RepeatUntilSuccess",
+    title: "Repeat Until Success",
+    category: "decorator",
+    description: "Repeats the child until it succeeds",
+    properties: { maxLoop: -1 },
+    isDefault: true
+  },
+  MaxTime: {
+    name: "MaxTime",
+    title: "Max <maxTime>ms",
+    category: "decorator",
+    description: "Fails the child if it runs longer than maxTime milliseconds",
+    properties: { maxTime: 0 },
+    isDefault: true
+  },
+  Inverter: {
+    name: "Inverter",
+    title: "Inverter",
+    category: "decorator",
+    description: "Inverts the result of the child",
+    properties: {},
+    isDefault: true
+  },
+  Limiter: {
+    name: "Limiter",
+    title: "Limit <maxLoop> Activations",
+    category: "decorator",
+    description: "Limits how many times the child can be executed",
+    properties: { maxLoop: 1 },
+    isDefault: true
+  },
+  // Actions
+  Failer: {
+    name: "Failer",
+    title: "Failer",
+    category: "action",
+    description: "Always returns failure",
+    properties: {},
+    isDefault: true
+  },
+  Succeeder: {
+    name: "Succeeder",
+    title: "Succeeder",
+    category: "action",
+    description: "Always returns success",
+    properties: {},
+    isDefault: true
+  },
+  Runner: {
+    name: "Runner",
+    title: "Runner",
+    category: "action",
+    description: "Always returns running",
+    properties: {},
+    isDefault: true
+  },
+  Error: {
+    name: "Error",
+    title: "Error",
+    category: "action",
+    description: "Always returns an error status",
+    properties: {},
+    isDefault: true
+  },
+  Wait: {
+    name: "Wait",
+    title: "Wait <milliseconds>ms",
+    category: "action",
+    description: "Waits for the given number of milliseconds",
+    properties: { milliseconds: 0 },
+    isDefault: true
+  }
+};
+
+// ../../node_modules/.pnpm/uuid@11.1.1/node_modules/uuid/dist/esm/stringify.js
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+
+// ../../node_modules/.pnpm/uuid@11.1.1/node_modules/uuid/dist/esm/rng.js
+import { randomFillSync } from "crypto";
+var rnds8Pool = new Uint8Array(256);
+var poolPtr = rnds8Pool.length;
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    randomFillSync(rnds8Pool);
+    poolPtr = 0;
+  }
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
+
+// ../../node_modules/.pnpm/uuid@11.1.1/node_modules/uuid/dist/esm/native.js
+import { randomUUID } from "crypto";
+var native_default = { randomUUID };
+
+// ../../node_modules/.pnpm/uuid@11.1.1/node_modules/uuid/dist/esm/v4.js
+function v4(options, buf, offset) {
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  options = options || {};
+  const rnds = options.random ?? options.rng?.() ?? rng();
+  if (rnds.length < 16) {
+    throw new Error("Random bytes length must be >= 16");
+  }
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+var v4_default = v4;
+
+// ../../apps/editor/src/lib/behavior/import-error.ts
+var InvalidFileError = class extends Error {
+  reason;
+  // Short parser message, safe to send to analytics
+  detail;
+  constructor(message, reason, detail) {
+    super(message);
+    this.name = "InvalidFileError";
+    this.reason = reason;
+    this.detail = detail;
+  }
+};
+
+// ../../apps/editor/src/lib/behavior/organize.ts
+var LAYOUT_STORAGE_KEY = "bt-layout";
+function readTreeLayout() {
+  try {
+    return localStorage.getItem(LAYOUT_STORAGE_KEY) === "vertical" ? "vertical" : "horizontal";
+  } catch {
+    return "horizontal";
+  }
+}
+function compareSiblings(layout) {
+  return (a, b) => layout === "horizontal" ? a.y - b.y || a.x - b.x : a.x - b.x || a.y - b.y;
+}
+function childIdsInOrder(tree, blockId, layout) {
+  const byPosition = compareSiblings(layout);
+  return Object.values(tree.connections).filter((c) => c.source === blockId).map((c) => tree.blocks[c.target]).filter((b) => !!b).sort((a, b) => byPosition(a.position, b.position)).map((b) => b.id);
+}
+var H_SPACING = 208;
+var V_SPACING = 88;
+var V_COMPENSATION = 42;
+function organizeTree(tree, layout = "horizontal", byIndex = false, orderLayout = layout) {
+  if (!tree.rootId || !tree.blocks[tree.rootId]) return;
+  const root = tree.blocks[tree.rootId];
+  const offsetX = root.position.x;
+  const offsetY = root.position.y;
+  const childIdsOf = (blockId) => byIndex ? Object.values(tree.connections).filter((c) => c.source === blockId && !!tree.blocks[c.target]).map((c) => c.target) : childIdsInOrder(tree, blockId, orderLayout);
+  let leafCount = 0;
+  const visited = /* @__PURE__ */ new Set();
+  const placed = [];
+  const step = (blockId, depth) => {
+    if (visited.has(blockId)) return 0;
+    visited.add(blockId);
+    placed.push(blockId);
+    const block = tree.blocks[blockId];
+    const children = childIdsOf(blockId);
+    let cross;
+    if (children.length === 0) {
+      leafCount += 1;
+      cross = leafCount * (layout === "horizontal" ? V_SPACING : H_SPACING);
+    } else {
+      let sum = 0;
+      children.forEach((childId) => {
+        sum += step(childId, depth + 1);
+      });
+      cross = sum / children.length;
+    }
+    if (layout === "horizontal") {
+      block.position = { x: depth * H_SPACING, y: cross };
+    } else {
+      block.position = { x: cross, y: depth * (V_SPACING + V_COMPENSATION) };
+    }
+    return cross;
+  };
+  step(tree.rootId, 0);
+  const dx = offsetX - root.position.x;
+  const dy = offsetY - root.position.y;
+  placed.forEach((id) => {
+    const block = tree.blocks[id];
+    block.position = { x: block.position.x + dx, y: block.position.y + dy };
+  });
+}
+
+// ../../apps/editor/src/lib/behavior/serializer.ts
+function deserializeTree(serializedTree) {
+  const tree = {
+    id: serializedTree.id,
+    title: serializedTree.title,
+    description: serializedTree.description,
+    rootId: serializedTree.rootId,
+    blocks: {},
+    connections: {},
+    viewport: serializedTree.viewport
+  };
+  Object.values(serializedTree.blocks).forEach((block) => {
+    const newBlock = {
+      id: block.id,
+      name: block.name,
+      title: block.title,
+      category: block.category || "action",
+      // Default to action if not specified
+      description: block.description,
+      properties: { ...block.properties },
+      position: block.position
+    };
+    tree.blocks[block.id] = newBlock;
+  });
+  Object.values(serializedTree.blocks).forEach((block) => {
+    if (block.children && Array.isArray(block.children)) {
+      block.children.forEach((childId) => {
+        const connectionId = `${block.id}-${childId}`;
+        const connection = {
+          id: connectionId,
+          source: block.id,
+          target: childId
+        };
+        tree.connections[connectionId] = connection;
+      });
+    }
+  });
+  return tree;
+}
+function deserializeProject(serializedProject) {
+  const project = {
+    id: serializedProject.id,
+    name: serializedProject.name,
+    description: serializedProject.description,
+    trees: {},
+    nodes: {},
+    // Will be populated with default + custom nodes
+    selectedTreeId: serializedProject.selectedTreeId,
+    createdAt: serializedProject.createdAt,
+    updatedAt: serializedProject.updatedAt
+  };
+  Object.values(serializedProject.trees).forEach((serializedTree) => {
+    const tree = deserializeTree(serializedTree);
+    project.trees[tree.id] = tree;
+  });
+  if (serializedProject.customNodes) {
+    Object.entries(serializedProject.customNodes).forEach(([key, node]) => {
+      project.nodes[key] = {
+        name: node.name,
+        category: node.category,
+        title: node.title,
+        description: node.description,
+        properties: node.properties,
+        isDefault: false
+      };
+    });
+  }
+  return project;
+}
+
+// ../../apps/editor/src/lib/behavior/b3.ts
+var B3_VERSION = "0.3.0";
+function treeToB3(tree, project, includeCustomNodes, layout = readTreeLayout()) {
+  const root = tree.rootId ? tree.blocks[tree.rootId] : void 0;
+  const rootChildren = root ? childIdsInOrder(tree, root.id, layout) : [];
+  const data = {
+    version: B3_VERSION,
+    scope: "tree",
+    id: tree.id,
+    title: tree.title,
+    description: tree.description ?? "",
+    root: rootChildren[0] ?? null,
+    properties: { ...tree.properties ?? {} },
+    nodes: {},
+    display: {
+      camera_x: tree.viewport.x,
+      camera_y: tree.viewport.y,
+      camera_z: tree.viewport.zoom,
+      x: root?.position.x ?? 0,
+      y: root?.position.y ?? 0
+    }
+  };
+  Object.values(tree.blocks).forEach((block) => {
+    if (block.category === "root") return;
+    const spec = {
+      id: block.id,
+      name: block.name,
+      title: block.title ?? block.name,
+      description: block.description ?? "",
+      properties: { ...block.properties },
+      display: { x: block.position.x, y: block.position.y }
+    };
+    const children = childIdsInOrder(tree, block.id, layout);
+    if (block.category === "composite") {
+      spec.children = children;
+    } else if (block.category === "decorator") {
+      spec.child = children[0];
+    }
+    data.nodes[block.id] = spec;
+  });
+  if (includeCustomNodes && project) {
+    data.custom_nodes = customNodesToB3(project);
+  }
+  return data;
+}
+function customNodesToB3(project) {
+  return Object.values(project.nodes).filter((node) => !node.isDefault).map((node) => ({
+    version: B3_VERSION,
+    scope: "node",
+    name: node.name,
+    category: node.category,
+    title: node.title,
+    description: node.description,
+    properties: { ...node.properties },
+    // Omitted when absent so behavior3-only files stay byte-identical
+    ...node.ports ? { ports: { ...node.ports } } : {}
+  }));
+}
+function projectToB3(project) {
+  return {
+    version: B3_VERSION,
+    scope: "project",
+    selectedTree: project.selectedTreeId ?? null,
+    trees: Object.values(project.trees).map((tree) => treeToB3(tree, null, false)),
+    custom_nodes: customNodesToB3(project),
+    id: project.id,
+    name: project.name,
+    description: project.description,
+    createdAt: project.createdAt,
+    updatedAt: project.updatedAt
+  };
+}
+function templateToNode(t) {
+  return {
+    name: t.name,
+    category: t.category ?? "action",
+    title: t.title,
+    description: t.description,
+    properties: { ...t.properties ?? {} },
+    ...t.ports ? { ports: { ...t.ports } } : {},
+    isDefault: false
+  };
+}
+function inferCategory(spec) {
+  if (spec.children) return "composite";
+  if (spec.child !== void 0) return "decorator";
+  return "action";
+}
+function collectNodeTemplates(data, known) {
+  const nodes = {};
+  (data.custom_nodes ?? []).forEach((t) => {
+    if (!known[t.name] && !nodes[t.name]) {
+      nodes[t.name] = templateToNode(t);
+    }
+  });
+  Object.values(data.nodes ?? {}).forEach((spec) => {
+    if (!known[spec.name] && !nodes[spec.name]) {
+      nodes[spec.name] = {
+        name: spec.name,
+        category: inferCategory(spec),
+        title: spec.title,
+        description: "",
+        properties: {},
+        isDefault: false
+      };
+    }
+  });
+  return nodes;
+}
+function b3ToTree(data, knownNodes) {
+  const treeId = data.id ?? v4_default();
+  const rootId = v4_default();
+  const rootBlock = {
+    id: rootId,
+    name: "Root",
+    title: data.title ?? "A behavior tree",
+    description: data.description ?? "",
+    category: "root",
+    properties: { ...data.properties ?? {} },
+    position: { x: data.display?.x ?? 0, y: data.display?.y ?? 0 }
+  };
+  const tree = {
+    id: treeId,
+    title: data.title ?? "A behavior tree",
+    description: data.description ?? "",
+    blocks: { [rootId]: rootBlock },
+    connections: {},
+    rootId,
+    properties: { ...data.properties ?? {} },
+    viewport: {
+      x: data.display?.camera_x ?? 0,
+      y: data.display?.camera_y ?? 0,
+      zoom: data.display?.camera_z ?? 1
+    }
+  };
+  const nodes = collectNodeTemplates(data, knownNodes);
+  const templateOf = (name) => knownNodes[name] ?? nodes[name];
+  const specs = Object.entries(data.nodes ?? {}).map(([key, spec]) => ({ ...spec, id: spec.id ?? key }));
+  specs.forEach((spec) => {
+    const template = templateOf(spec.name);
+    const block = {
+      id: spec.id,
+      name: spec.name,
+      title: spec.title ?? template?.title ?? spec.name,
+      description: spec.description ?? "",
+      category: template?.category ?? inferCategory(spec),
+      properties: { ...template?.properties ?? {}, ...spec.properties ?? {} },
+      position: spec.display ? { x: spec.display.x, y: spec.display.y } : { x: 0, y: 0 }
+    };
+    tree.blocks[block.id] = block;
+  });
+  const connect = (source, target) => {
+    if (!tree.blocks[source] || !tree.blocks[target]) return;
+    const connection = { id: v4_default(), source, target };
+    tree.connections[connection.id] = connection;
+  };
+  if (data.root && tree.blocks[data.root]) {
+    connect(rootId, data.root);
+  }
+  specs.forEach((spec) => {
+    const children = spec.children ?? (spec.child ? [spec.child] : []);
+    children.forEach((childId) => connect(spec.id, childId));
+  });
+  if (!data.display) {
+    organizeTree(tree, "horizontal", true);
+  }
+  return { tree, nodes };
+}
+function b3ToProject(data) {
+  const project = {
+    id: data.id ?? v4_default(),
+    name: data.name ?? "Imported Project",
+    description: data.description ?? "",
+    trees: {},
+    nodes: { ...DEFAULT_NODES },
+    selectedTreeId: void 0,
+    createdAt: data.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: data.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+  (data.custom_nodes ?? []).forEach((t) => {
+    if (!project.nodes[t.name]) {
+      project.nodes[t.name] = templateToNode(t);
+    }
+  });
+  (data.trees ?? []).forEach((treeData) => {
+    const { tree, nodes } = b3ToTree(treeData, project.nodes);
+    Object.assign(project.nodes, nodes);
+    project.trees[tree.id] = tree;
+  });
+  const treeIds = Object.keys(project.trees);
+  project.selectedTreeId = data.selectedTree && project.trees[data.selectedTree] ? data.selectedTree : treeIds[0];
+  return project;
+}
+function b3ToNodes(data) {
+  const nodes = {};
+  data.forEach((t) => {
+    if (t.name) {
+      nodes[t.name] = templateToNode(t);
+    }
+  });
+  return nodes;
+}
+function isLegacyReactProject(data) {
+  const d = data;
+  if (!d || typeof d !== "object" || Array.isArray(d.trees)) return false;
+  if (!d.trees || typeof d.trees !== "object") return false;
+  const trees = Object.values(d.trees);
+  return trees.length > 0 && !!trees[0].blocks;
+}
+var LEGACY_NAME_MAP = {
+  root: "Root",
+  sequence: "Sequence",
+  selector: "Priority",
+  priority: "Priority",
+  inverter: "Inverter",
+  repeater: "Repeater",
+  wait: "Wait",
+  succeeder: "Succeeder",
+  failer: "Failer"
+};
+function convertLegacyProject(data) {
+  const project = deserializeProject(data);
+  project.nodes = { ...DEFAULT_NODES, ...project.nodes };
+  Object.values(project.trees).forEach((tree) => {
+    Object.values(tree.blocks).forEach((block) => {
+      const mapped = LEGACY_NAME_MAP[block.name];
+      if (mapped) block.name = mapped;
+      if (!project.nodes[block.name]) {
+        project.nodes[block.name] = {
+          name: block.name,
+          category: block.category,
+          title: block.title,
+          description: block.description,
+          properties: {},
+          isDefault: false
+        };
+      }
+    });
+  });
+  return project;
+}
+function parseImportedJson(data) {
+  if (Array.isArray(data)) {
+    return { kind: "nodes", nodes: b3ToNodes(data) };
+  }
+  if (!data || typeof data !== "object") {
+    throw new InvalidFileError("Not a behavior tree file", "not_behavior_tree");
+  }
+  const d = data;
+  if (isLegacyReactProject(d)) {
+    return { kind: "project", project: convertLegacyProject(d) };
+  }
+  if (Array.isArray(d.trees)) {
+    return { kind: "project", project: b3ToProject(d) };
+  }
+  if (d.nodes && "root" in d) {
+    return { kind: "tree", tree: d };
+  }
+  if (d.scope === "node" && d.name) {
+    return { kind: "nodes", nodes: b3ToNodes([d]) };
+  }
+  throw new InvalidFileError("Unrecognized behavior tree file format", "not_behavior_tree");
+}
+
+// ../../apps/editor/src/lib/behavior/btcpp-catalog.ts
+var port = (direction, type, defaultValue) => ({
+  direction,
+  ...type ? { type } : {},
+  ...defaultValue !== void 0 ? { default: defaultValue } : {}
+});
+var input = (type, defaultValue) => port("input", type, defaultValue);
+var BOTH = [3, 4];
+var V4 = [4];
+var V3 = [3];
+var model = (category, versions, ports = {}) => ({
+  category,
+  versions,
+  ports
+});
+var switchPorts = (cases) => {
+  const ports = { variable: input("std::string") };
+  for (let i = 1; i <= cases; i++) ports[`case_${i}`] = input("std::string");
+  return ports;
+};
+var loopPorts = (type) => ({
+  queue: port("inout"),
+  if_empty: input("NodeStatus", "SUCCESS"),
+  value: port("output", type)
+});
+var blackboardCheckPorts = {
+  value_A: input(),
+  value_B: input(),
+  return_on_mismatch: input("NodeStatus")
+};
+var BTCPP_BUILTINS = {
+  // Controls
+  Fallback: model("composite", BOTH),
+  AsyncFallback: model("composite", V4),
+  Sequence: model("composite", BOTH),
+  AsyncSequence: model("composite", V4),
+  SequenceWithMemory: model("composite", BOTH),
+  Parallel: model("composite", BOTH, {
+    success_count: input("int", "-1"),
+    failure_count: input("int", "1")
+  }),
+  ParallelAll: model("composite", V4, { max_failures: input("int", "1") }),
+  ReactiveSequence: model("composite", BOTH),
+  ReactiveFallback: model("composite", BOTH),
+  IfThenElse: model("composite", BOTH),
+  WhileDoElse: model("composite", BOTH),
+  TryCatch: model("composite", V4, { catch_on_halt: input("bool", "false") }),
+  Switch2: model("composite", BOTH, switchPorts(2)),
+  Switch3: model("composite", BOTH, switchPorts(3)),
+  Switch4: model("composite", BOTH, switchPorts(4)),
+  Switch5: model("composite", BOTH, switchPorts(5)),
+  Switch6: model("composite", BOTH, switchPorts(6)),
+  ManualSelector: model("composite", V3, { repeat_last_selection: input("bool", "false") }),
+  // Decorators
+  Inverter: model("decorator", BOTH),
+  RetryUntilSuccessful: model("decorator", BOTH, { num_attempts: input("int") }),
+  KeepRunningUntilFailure: model("decorator", BOTH),
+  Repeat: model("decorator", BOTH, { num_cycles: input("int") }),
+  Timeout: model("decorator", BOTH, { msec: input("unsigned") }),
+  Delay: model("decorator", BOTH, { delay_msec: input("unsigned") }),
+  RunOnce: model("decorator", V4, { then_skip: input("bool", "true") }),
+  ForceSuccess: model("decorator", BOTH),
+  ForceFailure: model("decorator", BOTH),
+  Precondition: model("decorator", V4, { if: input("std::string"), else: input("NodeStatus", "FAILURE") }),
+  SkipUnlessUpdated: model("decorator", V4, { entry: input() }),
+  WaitValueUpdate: model("decorator", V4, { entry: input() }),
+  LoopInt: model("decorator", V4, loopPorts("int")),
+  LoopBool: model("decorator", V4, loopPorts("bool")),
+  LoopDouble: model("decorator", V4, loopPorts("double")),
+  LoopString: model("decorator", V4, loopPorts("std::string")),
+  BlackboardCheckInt: model("decorator", V3, blackboardCheckPorts),
+  BlackboardCheckDouble: model("decorator", V3, blackboardCheckPorts),
+  BlackboardCheckString: model("decorator", V3, blackboardCheckPorts),
+  BlackboardCheckBool: model("decorator", V3, blackboardCheckPorts),
+  // Leaves
+  AlwaysSuccess: model("action", BOTH),
+  AlwaysFailure: model("action", BOTH),
+  Script: model("action", V4, { code: input("std::string") }),
+  ScriptCondition: model("condition", V4, { code: input("std::string") }),
+  SetBlackboard: model("action", BOTH, { value: input(), output_key: port("inout") }),
+  Sleep: model("action", V4, { msec: input("unsigned") }),
+  UnsetBlackboard: model("action", V4, { key: input("std::string") }),
+  WasEntryUpdated: model("action", V4, { entry: input() }),
+  // A reference to another BehaviorTree in the file, by its ID. Kept as a
+  // leaf here: the referenced tree is a separate tree in the project.
+  SubTree: model("action", BOTH)
+};
+var V3_TO_V4_NAMES = {
+  SequenceStar: "SequenceWithMemory",
+  RetryUntilSuccesful: "RetryUntilSuccessful",
+  SubTreePlus: "SubTree"
+};
+var V4_TO_V3_NAMES = {
+  SequenceWithMemory: "SequenceStar"
+};
+var V3_TO_V4_PORTS = {
+  Parallel: { success_threshold: "success_count", failure_threshold: "failure_count" }
+};
+var NAV2_BY_CATEGORY = {
+  composite: ["PipelineSequence", "RecoveryNode", "RoundRobin"],
+  decorator: [
+    "DistanceController",
+    "GoalUpdatedController",
+    "GoalUpdater",
+    "PathLongerOnApproach",
+    "RateController",
+    "SingleTrigger",
+    "SpeedController"
+  ],
+  condition: [
+    "AreErrorCodesPresent",
+    "ArePosesNear",
+    "DistanceTraveled",
+    "GlobalUpdatedGoal",
+    "GoalReached",
+    "GoalUpdated",
+    "InitialPoseReceived",
+    "IsBatteryCharging",
+    "IsBatteryLow",
+    "IsPathValid",
+    "IsStuck",
+    "PathExpiringTimer",
+    "TimeExpired",
+    "TransformAvailable",
+    "WouldAControllerRecoveryHelp",
+    "WouldAPlannerRecoveryHelp",
+    "WouldASmootherRecoveryHelp"
+  ],
+  action: [
+    "AssistedTeleop",
+    "BackUp",
+    "CancelAssistedTeleop",
+    "CancelBackUp",
+    "CancelComputeAndTrackRoute",
+    "CancelControl",
+    "CancelDriveOnHeading",
+    "CancelSpin",
+    "CancelWait",
+    "ClearCostmapAroundPose",
+    "ClearCostmapAroundRobot",
+    "ClearCostmapExceptRegion",
+    "ClearEntireCostmap",
+    "ComputeAndTrackRoute",
+    "ComputePathThroughPoses",
+    "ComputePathToPose",
+    "ComputeRoute",
+    "ConcatenatePaths",
+    "ControllerSelector",
+    "DockRobot",
+    "DriveOnHeading",
+    "FollowPath",
+    "GetCurrentPose",
+    "GetPoseFromPath",
+    "GoalCheckerSelector",
+    "NavigateThroughPoses",
+    "NavigateToPose",
+    "PlannerSelector",
+    "ProgressCheckerSelector",
+    "ReinitializeGlobalLocalization",
+    "RemovePassedGoals",
+    "SmoothPath",
+    "SmootherSelector",
+    "Spin",
+    "TruncatePath",
+    "TruncatePathLocal",
+    "UndockRobot",
+    "Wait"
+  ]
+};
+var NAV2_CATEGORIES = Object.fromEntries(
+  Object.entries(NAV2_BY_CATEGORY).flatMap(
+    ([category, names]) => names.map((name) => [name, category])
+  )
+);
+var B3_TO_BTCPP = {
+  Priority: { name: "Fallback" },
+  MemSequence: { name: "SequenceWithMemory", v3Name: "SequenceStar" },
+  MaxTime: { name: "Timeout", props: { maxTime: "msec" } },
+  Repeater: { name: "Repeat", props: { maxLoop: "num_cycles" } },
+  RepeatUntilSuccess: { name: "RetryUntilSuccessful", props: { maxLoop: "num_attempts" } },
+  Succeeder: { name: "AlwaysSuccess" },
+  Failer: { name: "AlwaysFailure" },
+  // Only behavior3's Wait (properties ⊆ {milliseconds}); Nav2 has its own Wait
+  Wait: { name: "Sleep", props: { milliseconds: "msec" }, v4Only: true }
+};
+function catalogNode(name) {
+  const builtin = BTCPP_BUILTINS[name];
+  if (!builtin) return void 0;
+  const properties = name === "SubTree" ? { ID: "" } : Object.fromEntries(
+    Object.entries(builtin.ports).filter(([, p]) => p.direction !== "output").map(([key, p]) => [key, p.default ?? ""])
+  );
+  return {
+    name,
+    title: name,
+    category: builtin.category,
+    description: "",
+    properties,
+    ports: { ...builtin.ports },
+    isDefault: false
+  };
+}
+
+// ../../apps/editor/src/lib/behavior/btcpp.ts
+var WRAPPER_TAGS = {
+  Action: "action",
+  Condition: "condition",
+  Control: "composite",
+  Decorator: "decorator"
+};
+var MODEL_TAGS = {
+  action: "Action",
+  condition: "Condition",
+  composite: "Control",
+  decorator: "Decorator"
+};
+var PORT_TAGS = {
+  input_port: "input",
+  output_port: "output",
+  inout_port: "inout"
+};
+var XML_NAME = /^[A-Za-z_][\w.:-]*$/;
+var isLeaf = (category) => category === "action" || category === "condition";
+function isLikelyXml(text) {
+  return /^\s*</.test(text.replace(/^\uFEFF/, ""));
+}
+var CONTROL_NAME = /Sequence|Fallback|Selector|Parallel|Switch|Pipeline|RoundRobin|Recovery|Priority/;
+var CONDITION_NAME = /^(Is|Has|Are|Can|Would|Should|Check)[A-Z]|(Reached|Updated|Received|Available|Valid|Present|Near)$/;
+function guessCategory(name, maxChildren) {
+  if (maxChildren >= 2) return "composite";
+  if (maxChildren === 1) return CONTROL_NAME.test(name) ? "composite" : "decorator";
+  return CONDITION_NAME.test(name) ? "condition" : "action";
+}
+function parseDocument(text) {
+  if (/<!DOCTYPE/i.test(text)) {
+    throw new InvalidFileError("XML files with a DOCTYPE are not supported", "xml_doctype");
+  }
+  const doc = new DOMParser().parseFromString(text.replace(/^\uFEFF/, ""), "application/xml");
+  const error = doc.getElementsByTagName("parsererror")[0];
+  if (error) {
+    const detail = (error.textContent ?? "").replace(/^\s*This page contains the following errors:\s*/i, "").trim().split("\n")[0].slice(0, 160);
+    throw new InvalidFileError(`Not valid XML${detail ? `: ${detail}` : ""}`, "invalid_xml", detail || void 0);
+  }
+  if (doc.documentElement.tagName !== "root") {
+    throw new InvalidFileError("Not a BehaviorTree.CPP file: expected a <root> element", "not_behavior_tree");
+  }
+  return doc.documentElement;
+}
+function parseModel(el, name, category) {
+  const ports = {};
+  Array.from(el.children).forEach((portEl) => {
+    const direction = PORT_TAGS[portEl.tagName];
+    const portName = portEl.getAttribute("name");
+    if (!direction || !portName) return;
+    const type = portEl.getAttribute("type");
+    const defaultValue = portEl.getAttribute("default");
+    const description = (portEl.textContent ?? "").trim();
+    ports[portName] = {
+      direction,
+      ...type ? { type } : {},
+      ...defaultValue !== null ? { default: defaultValue } : {},
+      ...description ? { description } : {}
+    };
+  });
+  return {
+    name,
+    title: name,
+    category,
+    description: "",
+    properties: Object.fromEntries(
+      Object.entries(ports).filter(([, p]) => p.direction !== "output").map(([key, p]) => [key, p.default ?? ""])
+    ),
+    ports,
+    isDefault: false
+  };
+}
+var normalizeName = (name) => V3_TO_V4_NAMES[name] ?? name;
+function parseBtcppXml(text, knownNodes, layout = readTreeLayout()) {
+  const root = parseDocument(text);
+  const version = root.getAttribute("BTCPP_format") === "4" ? 4 : 3;
+  const issues = [];
+  const models = {};
+  const treeElements = [];
+  Array.from(root.children).forEach((el) => {
+    if (el.tagName === "TreeNodesModel") {
+      Array.from(el.children).forEach((modelEl) => {
+        const category = WRAPPER_TAGS[modelEl.tagName];
+        const id = modelEl.getAttribute("ID");
+        if (!category || !id) return;
+        const name = normalizeName(id);
+        models[name] = parseModel(modelEl, name, category);
+      });
+    } else if (el.tagName === "BehaviorTree") {
+      treeElements.push(el);
+    } else if (el.tagName === "include") {
+      issues.push({
+        level: "warning",
+        message: `Included file "${el.getAttribute("path") ?? ""}" wasn't loaded. Import it separately.`
+      });
+    } else {
+      issues.push({ level: "warning", message: `Skipped unknown <${el.tagName}> element` });
+    }
+  });
+  if (treeElements.length === 0) {
+    if (Object.keys(models).length === 0) {
+      throw new InvalidFileError("This file has no <BehaviorTree> or <TreeNodesModel>", "not_behavior_tree");
+    }
+    return { kind: "nodes", version, models, issues };
+  }
+  const nameOf = (el) => normalizeName(WRAPPER_TAGS[el.tagName] ? el.getAttribute("ID") ?? el.tagName : el.tagName);
+  const usage = {};
+  const survey = (el) => {
+    const name = nameOf(el);
+    const entry = usage[name] ??= { maxChildren: 0, keys: /* @__PURE__ */ new Set() };
+    entry.maxChildren = Math.max(entry.maxChildren, el.children.length);
+    if (WRAPPER_TAGS[el.tagName]) entry.explicit = WRAPPER_TAGS[el.tagName];
+    Array.from(el.attributes).forEach((attr) => entry.keys.add(attr.name));
+    Array.from(el.children).forEach(survey);
+  };
+  treeElements.forEach((treeEl) => Array.from(treeEl.children).forEach(survey));
+  const guessed = [];
+  const categories = {};
+  Object.entries(usage).forEach(([name, use]) => {
+    const known = knownNodes[name]?.category;
+    const category = (name === "SubTree" ? "action" : void 0) ?? use.explicit ?? models[name]?.category ?? (known && known !== "root" ? known : void 0) ?? BTCPP_BUILTINS[name]?.category ?? NAV2_CATEGORIES[name];
+    if (category) {
+      categories[name] = category;
+    } else {
+      categories[name] = guessCategory(name, use.maxChildren);
+      guessed.push(name);
+    }
+  });
+  if (guessed.length > 0) {
+    issues.push({
+      level: "info",
+      message: `Guessed the node type of ${guessed.join(", ")}. Import a TreeNodesModel file to set them exactly.`
+    });
+  }
+  const propertiesOf = (el, name) => {
+    const properties = {};
+    const renames = version === 3 ? V3_TO_V4_PORTS[name] ?? {} : {};
+    const classicSubTree = version === 3 && el.tagName === "SubTree";
+    Array.from(el.attributes).forEach(({ name: key, value }) => {
+      if (key === "name") return;
+      if (key === "ID" && WRAPPER_TAGS[el.tagName]) return;
+      if (key === "__autoremap") {
+        properties._autoremap = value;
+        return;
+      }
+      if (key === "__shared_blackboard") {
+        if (value === "true" || value === "1") {
+          properties._autoremap = "true";
+          issues.push({
+            level: "warning",
+            message: `SubTree "${el.getAttribute("ID") ?? ""}" shared its parent's blackboard (v3). It now uses _autoremap, which only shares the subtree's own ports.`
+          });
+        }
+        return;
+      }
+      if (classicSubTree && key !== "ID" && !/^\{.*\}$/.test(value)) {
+        properties[key] = `{${value}}`;
+        return;
+      }
+      properties[renames[key] ?? key] = value;
+    });
+    return properties;
+  };
+  const trees = [];
+  const reported = /* @__PURE__ */ new Set();
+  treeElements.forEach((treeEl, index) => {
+    const title = treeEl.getAttribute("ID") || `Tree ${index + 1}`;
+    if (!treeEl.getAttribute("ID")) {
+      issues.push({ level: "warning", message: `A <BehaviorTree> had no ID; named it "${title}"` });
+    }
+    const rootId = v4_default();
+    const tree = {
+      id: v4_default(),
+      title,
+      description: "",
+      blocks: {
+        [rootId]: {
+          id: rootId,
+          name: "Root",
+          title,
+          description: "",
+          category: "root",
+          properties: {},
+          position: { x: 0, y: 0 }
+        }
+      },
+      connections: {},
+      rootId,
+      properties: {},
+      viewport: { x: 0, y: 0, zoom: 1 }
+    };
+    const connect = (source, target) => {
+      const connection = { id: v4_default(), source, target };
+      tree.connections[connection.id] = connection;
+    };
+    const attachChildren = (parent, childIds) => {
+      const capacity = parent.category === "composite" ? Infinity : isLeaf(parent.category) ? 0 : 1;
+      childIds.forEach((childId, i) => {
+        if (i < capacity) connect(parent.id, childId);
+      });
+      const key = `${tree.title}/${parent.name}`;
+      if (childIds.length > capacity && !reported.has(key)) {
+        reported.add(key);
+        const label = parent.category === "root" ? `Tree "${tree.title}"` : `${parent.name} in "${tree.title}"`;
+        issues.push({
+          level: "error",
+          message: `${label} has ${childIds.length} children but can only have ${capacity}. The extra ones are left unconnected.`
+        });
+      }
+    };
+    const addBlock = (el) => {
+      const name = nameOf(el);
+      const block = {
+        id: v4_default(),
+        name,
+        title: el.getAttribute("name") || name,
+        description: "",
+        category: categories[name],
+        properties: propertiesOf(el, name),
+        position: { x: 0, y: 0 }
+      };
+      tree.blocks[block.id] = block;
+      attachChildren(block, Array.from(el.children).map(addBlock));
+      return block.id;
+    };
+    attachChildren(tree.blocks[rootId], Array.from(treeEl.children).map(addBlock));
+    organizeTree(tree, layout, true);
+    trees.push(tree);
+  });
+  const mainName = root.getAttribute("main_tree_to_execute");
+  let mainTree = mainName ? trees.find((t) => t.title === mainName) : void 0;
+  if (!mainTree) {
+    mainTree = trees[0];
+    if (mainName) {
+      issues.push({ level: "warning", message: `main_tree_to_execute names "${mainName}", which isn't in the file` });
+    } else if (trees.length > 1) {
+      issues.push({ level: "info", message: `No main_tree_to_execute; opened "${mainTree.title}"` });
+    }
+  }
+  const nodes = {};
+  Object.entries(usage).forEach(([name, use]) => {
+    if (knownNodes[name]) return;
+    nodes[name] = models[name] ?? catalogNode(name) ?? {
+      name,
+      title: name,
+      category: categories[name],
+      description: "",
+      properties: Object.fromEntries(
+        [...use.keys].filter((key) => key !== "name" && key !== "ID" && !key.startsWith("_")).map((key) => [key, ""])
+      ),
+      isDefault: false
+    };
+  });
+  return { kind: "trees", version, trees, mainTreeId: mainTree.id, nodes, models, issues };
+}
+function btcppToProject(imported, name) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: v4_default(),
+    name,
+    description: "",
+    trees: Object.fromEntries(imported.trees.map((tree) => [tree.id, tree])),
+    nodes: { ...DEFAULT_NODES, ...imported.nodes, ...imported.models },
+    selectedTreeId: imported.mainTreeId,
+    createdAt: now,
+    updatedAt: now
+  };
+}
+var escapeAttr = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/\n/g, "&#10;").replace(/\r/g, "&#13;").replace(/\t/g, "&#9;");
+var escapeText = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+var sanitizeId = (title) => title.trim().replace(/\s+/g, "_") || "Tree";
+var UNMAPPED_B3 = /* @__PURE__ */ new Set(["MemPriority", "Limiter", "RepeatUntilFailure", "Runner", "Error"]);
+function exportTrees(project, mainTreeId, treeIds, { version, layout = readTreeLayout(), includeNodesModel = true }) {
+  const issues = [];
+  const once = /* @__PURE__ */ new Set();
+  const issue = (level, message) => {
+    if (once.has(message)) return;
+    once.add(message);
+    issues.push({ level, message });
+  };
+  const allTrees = Object.values(project.trees);
+  const xmlIds = {};
+  const taken = /* @__PURE__ */ new Set();
+  allTrees.forEach((tree) => {
+    const base = sanitizeId(tree.title);
+    let id = base;
+    for (let n = 2; taken.has(id); n++) id = `${base}_${n}`;
+    taken.add(id);
+    xmlIds[tree.id] = id;
+  });
+  const resolveSubTree = (ref) => allTrees.find((t) => t.title === ref) ?? allTrees.find((t) => xmlIds[t.id] === ref);
+  const subTreeRefs = (tree) => Object.values(tree.blocks).filter((b) => b.name === "SubTree" && typeof b.properties.ID === "string" && b.properties.ID).map((b) => b.properties.ID);
+  let ordered;
+  if (treeIds === "referenced") {
+    ordered = [];
+    const seen = /* @__PURE__ */ new Set();
+    const queue = [project.trees[mainTreeId]];
+    while (queue.length > 0) {
+      const tree = queue.shift();
+      if (seen.has(tree.id)) continue;
+      seen.add(tree.id);
+      ordered.push(tree);
+      subTreeRefs(tree).forEach((ref) => {
+        const target = resolveSubTree(ref);
+        if (target) queue.push(target);
+      });
+    }
+  } else {
+    const main = project.trees[mainTreeId];
+    ordered = [main, ...treeIds.map((id) => project.trees[id]).filter((t) => t && t.id !== main.id)];
+  }
+  const visiting = [];
+  const done = /* @__PURE__ */ new Set();
+  const checkCycles = (tree) => {
+    if (done.has(tree.id)) return;
+    if (visiting.includes(tree.id)) {
+      const path = [...visiting.slice(visiting.indexOf(tree.id)), tree.id].map((id) => project.trees[id].title);
+      issue("error", `SubTrees form a loop: ${path.join(" \u2192 ")}. BT.CPP can't load recursive trees.`);
+      return;
+    }
+    visiting.push(tree.id);
+    subTreeRefs(tree).forEach((ref) => {
+      const target = resolveSubTree(ref);
+      if (target) checkCycles(target);
+      else issue("warning", `SubTree references "${ref}", which isn't in this project. Your runtime must register it.`);
+    });
+    visiting.pop();
+    done.add(tree.id);
+  };
+  ordered.forEach(checkCycles);
+  ordered.forEach((tree) => {
+    if (xmlIds[tree.id] !== tree.title) {
+      issue("info", `Tree "${tree.title}" is written with ID "${xmlIds[tree.id]}"`);
+    }
+  });
+  const modelUses = {};
+  const lines = [];
+  let droppedDescriptions = false;
+  const writeTree = (tree) => {
+    const id = xmlIds[tree.id];
+    if (tree.description || Object.keys(tree.properties ?? {}).length > 0) droppedDescriptions = true;
+    const root = tree.rootId ? tree.blocks[tree.rootId] : void 0;
+    if (!root) {
+      issue("error", `Tree "${tree.title}" has no root node`);
+      lines.push(`  <BehaviorTree ID="${escapeAttr(id)}"/>`);
+      return;
+    }
+    const visited = /* @__PURE__ */ new Set([root.id]);
+    const rootChildren = childIdsInOrder(tree, root.id, layout);
+    if (rootChildren.length !== 1) {
+      issue(
+        "error",
+        rootChildren.length === 0 ? `Tree "${tree.title}" is empty. BT.CPP needs one node under the root.` : `The root of "${tree.title}" has ${rootChildren.length} children. BT.CPP allows one.`
+      );
+    }
+    const writeBlock = (blockId, depth) => {
+      if (visited.has(blockId)) return;
+      visited.add(blockId);
+      const block = tree.blocks[blockId];
+      const template = project.nodes[block.name];
+      const where = `"${block.title || block.name}" in "${tree.title}"`;
+      if (block.description) droppedDescriptions = true;
+      let name = block.name;
+      let renames = {};
+      const translation = template?.isDefault ? B3_TO_BTCPP[name] : void 0;
+      const keys = Object.keys(block.properties);
+      const isB3Wait = name !== "Wait" || keys.every((k) => k === "milliseconds");
+      if (translation && isB3Wait) {
+        if (translation.v4Only && version === 3) {
+          issue("warning", `${name} has no BT.CPP v3 equivalent. Your runtime must register a "${name}" node.`);
+        } else {
+          name = translation.name;
+          renames = translation.props ?? {};
+        }
+      } else if (template?.isDefault && UNMAPPED_B3.has(name)) {
+        issue("warning", `${name} has no BT.CPP equivalent. Your runtime must register a "${name}" node.`);
+      }
+      const builtin = BTCPP_BUILTINS[name];
+      if (builtin && !builtin.versions.includes(version)) {
+        issue("warning", `${name} isn't a builtin in BT.CPP v${version}`);
+      }
+      const attrs = [];
+      Object.entries(block.properties).forEach(([rawKey, value]) => {
+        const key = renames[rawKey] ?? rawKey;
+        if (value === "" || value === null || value === void 0) return;
+        if (key === "name" || key === "ID" && name !== "SubTree") {
+          issue("warning", `Property "${key}" on ${where} is reserved in BT.CPP and was left out`);
+          return;
+        }
+        if (!XML_NAME.test(key)) {
+          issue("warning", `Property "${key}" on ${where} isn't a valid XML attribute name and was left out`);
+          return;
+        }
+        if (builtin && name !== "SubTree" && !builtin.ports[key] && !key.startsWith("_")) {
+          issue("warning", `${name} has no "${key}" port; it was left out of ${where}`);
+          return;
+        }
+        if (key.startsWith("_") && version === 3 && !(name === "SubTree" && key === "_autoremap")) {
+          issue("warning", `"${key}" on ${where} needs BT.CPP v4 and was left out`);
+          return;
+        }
+        let text;
+        if (typeof value === "object") {
+          text = JSON.stringify(value);
+          issue("warning", `Property "${key}" on ${where} is an object; it was written as JSON text`);
+        } else {
+          text = String(value);
+        }
+        attrs.push([key, text]);
+      });
+      if (builtin) {
+        Object.entries(builtin.ports).forEach(([key, port2]) => {
+          if (port2.direction === "input" && port2.default === void 0 && !attrs.some(([k]) => k === key)) {
+            issue("warning", `${where} is missing the "${key}" port that ${name} requires`);
+          }
+        });
+      }
+      let tag = name;
+      if (version === 3) {
+        tag = translation?.v3Name && name === translation.name ? translation.v3Name : V4_TO_V3_NAMES[name] ?? name;
+        const portRenames = Object.fromEntries(
+          Object.entries(V3_TO_V4_PORTS[name] ?? {}).map(([v3, v42]) => [v42, v3])
+        );
+        attrs.forEach((attr) => {
+          attr[0] = portRenames[attr[0]] ?? attr[0];
+        });
+        if (name === "SubTree") {
+          tag = "SubTreePlus";
+          attrs.forEach((attr) => {
+            if (attr[0] === "_autoremap") attr[0] = "__autoremap";
+          });
+        }
+      }
+      const title = block.title && block.title !== block.name && block.title !== template?.title ? block.title : "";
+      const ordered2 = name === "SubTree" ? [...attrs.filter(([k]) => k === "ID"), ...title ? [["name", title]] : [], ...attrs.filter(([k]) => k !== "ID")] : [...title ? [["name", title]] : [], ...attrs];
+      const attrText = ordered2.map(([k, v]) => ` ${k}="${escapeAttr(v)}"`).join("");
+      if (!builtin && name !== "SubTree") {
+        const use = modelUses[name] ??= { category: block.category, template, keys: /* @__PURE__ */ new Set(), references: /* @__PURE__ */ new Set() };
+        attrs.forEach(([k, v]) => {
+          use.keys.add(k);
+          if (/^\{.+\}$/.test(v)) use.references.add(k);
+        });
+      }
+      const children = childIdsInOrder(tree, block.id, layout);
+      if (block.category === "decorator" && children.length !== 1) {
+        issue("error", `${where} is a decorator with ${children.length} children. BT.CPP needs exactly one.`);
+      } else if (block.category === "composite" && children.length === 0) {
+        issue("error", `${where} has no children. BT.CPP needs at least one.`);
+      } else if (isLeaf(block.category) && children.length > 0) {
+        issue("error", `${where} is a leaf node but has children. BT.CPP doesn't allow that.`);
+      }
+      const indent = "  ".repeat(depth);
+      if (children.length === 0) {
+        lines.push(`${indent}<${tag}${attrText}/>`);
+      } else {
+        lines.push(`${indent}<${tag}${attrText}>`);
+        children.forEach((childId) => writeBlock(childId, depth + 1));
+        lines.push(`${indent}</${tag}>`);
+      }
+    };
+    lines.push(`  <BehaviorTree ID="${escapeAttr(id)}">`);
+    rootChildren.forEach((childId) => writeBlock(childId, 2));
+    lines.push("  </BehaviorTree>");
+    const unreachable = Object.keys(tree.blocks).filter((blockId) => !visited.has(blockId)).length;
+    if (unreachable > 0) {
+      issue(
+        "warning",
+        `${unreachable} node${unreachable === 1 ? "" : "s"} in "${tree.title}" ${unreachable === 1 ? "isn't" : "aren't"} connected to the root and ${unreachable === 1 ? "was" : "were"} left out`
+      );
+    }
+  };
+  ordered.forEach(writeTree);
+  if (droppedDescriptions) {
+    issue("info", "Descriptions and tree properties aren't part of BT.CPP XML and were left out");
+  }
+  const model2 = includeNodesModel ? nodesModelLines(modelUses) : { lines: [], inferred: [] };
+  if (model2.inferred.length > 0) {
+    issue(
+      "info",
+      `Port directions of ${model2.inferred.join(", ")} aren't known, so they were written as inputs. Import their TreeNodesModel (for Nav2, nav2_tree_nodes.xml) to get outputs right.`
+    );
+  }
+  const head = version === 4 ? `<root BTCPP_format="4" main_tree_to_execute="${escapeAttr(xmlIds[mainTreeId])}">` : `<root main_tree_to_execute="${escapeAttr(xmlIds[mainTreeId])}">`;
+  return {
+    xml: ['<?xml version="1.0" encoding="UTF-8"?>', head, ...lines, ...model2.lines, "</root>", ""].join("\n"),
+    issues
+  };
+}
+function nodesModelLines(uses) {
+  const names = Object.keys(uses).sort();
+  const inferred = [];
+  if (names.length === 0) return { lines: [], inferred };
+  const lines = ["  <TreeNodesModel>"];
+  names.forEach((name) => {
+    const { category, template, keys, references } = uses[name];
+    if (category === "root") return;
+    const ports = { ...template?.ports ?? {} };
+    const extra = template?.ports ? [] : Object.keys(template && !template.isDefault ? template.properties : {});
+    [...extra, ...keys].forEach((key) => {
+      if (!ports[key] && !key.startsWith("_")) {
+        if (references.has(key) && !inferred.includes(name)) inferred.push(name);
+        const fallback = template && !template.isDefault ? template.properties[key] : void 0;
+        ports[key] = {
+          direction: "input",
+          ...fallback !== void 0 && fallback !== "" && typeof fallback !== "object" ? { default: String(fallback) } : {}
+        };
+      }
+    });
+    const tag = MODEL_TAGS[category];
+    const portLines = Object.entries(ports).map(([key, port2]) => {
+      const portTag = `${port2.direction}_port`;
+      const attrs = ` name="${escapeAttr(key)}"` + (port2.type ? ` type="${escapeAttr(port2.type)}"` : "") + (port2.default !== void 0 ? ` default="${escapeAttr(port2.default)}"` : "");
+      return port2.description ? `      <${portTag}${attrs}>${escapeText(port2.description)}</${portTag}>` : `      <${portTag}${attrs}/>`;
+    });
+    if (portLines.length === 0) {
+      lines.push(`    <${tag} ID="${escapeAttr(name)}"/>`);
+    } else {
+      lines.push(`    <${tag} ID="${escapeAttr(name)}">`, ...portLines, `    </${tag}>`);
+    }
+  });
+  lines.push("  </TreeNodesModel>");
+  return { lines, inferred };
+}
+function treeToBtcpp(project, treeId, options) {
+  return exportTrees(project, treeId, "referenced", options);
+}
+function projectToBtcpp(project, options) {
+  const treeIds = Object.keys(project.trees);
+  if (treeIds.length === 0) throw new Error("This project has no trees");
+  const main = project.selectedTreeId && project.trees[project.selectedTreeId] ? project.selectedTreeId : treeIds[0];
+  return exportTrees(project, main, treeIds, options);
+}
+
+// ../../apps/editor/src/lib/share-link.ts
+var MAX_BYTES = 5e6;
+var toBase64Url = (bytes) => {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += 32768) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + 32768));
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+};
+var readCapped = async (stream) => {
+  const reader = stream.getReader();
+  const chunks = [];
+  let size = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    size += value.length;
+    if (size > MAX_BYTES) {
+      await reader.cancel();
+      throw new Error("Shared tree is too large");
+    }
+    chunks.push(value);
+  }
+  const out = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return out;
+};
+var transform = (bytes, stream) => readCapped(new Blob([bytes]).stream().pipeThrough(stream));
+async function encodeSharedTree(data) {
+  const json = new TextEncoder().encode(JSON.stringify(data));
+  return toBase64Url(await transform(json, new CompressionStream("deflate")));
+}
+
+// src/core/catalog.ts
+var listNodeTypes = () => Object.values(DEFAULT_NODES).filter((node) => node.category !== "root").map((node) => ({
+  name: node.name,
+  category: node.category,
+  title: node.title,
+  description: node.description,
+  properties: node.properties ?? {}
+}));
+var EXAMPLE_TREES = [
+  cooldown_specials_default,
+  enemy_patrol_default,
+  open_the_door_default,
+  robot_navigate_recovery_default,
+  robot_pick_and_place_default,
+  survival_override_default
+];
+var listExamples = () => EXAMPLE_TREES.map(({ id, title, description }) => ({
+  id,
+  title,
+  description,
+  editorUrl: `${SITE}/?example=${id}`
+}));
+var getExample = (id) => EXAMPLE_TREES.find((tree) => tree.id === id);
+
+// src/core/xml-dom.ts
+import { DOMParser as XmlDomParser } from "@xmldom/xmldom";
+var escapeText2 = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;");
+var NodeDOMParser = class {
+  parseFromString(text, type) {
+    try {
+      return new XmlDomParser({
+        onError: (level, message) => {
+          if (level !== "warning") throw new Error(message);
+        }
+      }).parseFromString(text, type);
+    } catch (error) {
+      const raw = String(error.message);
+      const [message] = (/caused Error: (.*)/.exec(raw)?.[1] ?? raw).split("\n");
+      const at = /line:(\d+),col:(\d+)/.exec(raw);
+      const detail = `${at ? `${at[1]}:${at[2]}: ` : ""}${message.trim()}`;
+      return new XmlDomParser().parseFromString(`<parsererror>${escapeText2(detail)}</parsererror>`, "application/xml");
+    }
+  }
+};
+var ensureDomParser = async () => {
+  if (typeof globalThis.DOMParser === "undefined") {
+    globalThis.DOMParser = NodeDOMParser;
+  }
+};
+
+// src/core/load.ts
+async function loadInput(input2) {
+  if (typeof input2 === "string" && isLikelyXml(input2.trim())) {
+    await ensureDomParser();
+    const parsed = parseBtcppXml(input2.trim(), { ...DEFAULT_NODES }, "horizontal");
+    if (parsed.kind === "nodes") {
+      throw new InvalidFileError("This BehaviorTree.CPP file only defines node models, with no trees", "not_behavior_tree");
+    }
+    const project = btcppToProject(parsed, "Imported project");
+    return {
+      format: "btcpp",
+      kind: parsed.trees.length === 1 ? "tree" : "project",
+      project,
+      b3Trees: [],
+      btcppVersion: parsed.version,
+      issues: parsed.issues
+    };
+  }
+  let json = input2;
+  if (typeof input2 === "string") {
+    try {
+      json = JSON.parse(input2.trim());
+    } catch (error) {
+      throw new InvalidFileError(`Not valid JSON or XML: ${error.message}`, "not_behavior_tree");
+    }
+  }
+  const imported = parseImportedJson(json);
+  if (imported.kind === "nodes") {
+    throw new InvalidFileError("This file only defines custom nodes, with no trees", "not_behavior_tree");
+  }
+  if (imported.kind === "tree") {
+    const tree = imported.tree;
+    const project = b3ToProject({ name: tree.title, trees: [tree], custom_nodes: tree.custom_nodes });
+    return { format: "behavior3", kind: "tree", project, b3Trees: [tree], json, issues: [] };
+  }
+  const raw = json;
+  const b3Trees = Array.isArray(raw.trees) ? raw.trees : [];
+  return { format: "behavior3", kind: "project", project: imported.project, b3Trees, json, issues: [] };
+}
+
+// src/core/convert.ts
+var CONVERT_TARGETS = ["behavior3", "btcpp-v4", "btcpp-v3"];
+var toB3 = (loaded) => {
+  const { project } = loaded;
+  const trees = Object.values(project.trees);
+  return loaded.kind === "tree" && trees.length === 1 ? treeToB3(trees[0], project, true) : projectToB3(project);
+};
+async function convertTree(input2, to) {
+  const loaded = await loadInput(input2);
+  const issues = loaded.issues.map((issue) => ({ level: issue.level, message: issue.message }));
+  if (to === "behavior3") {
+    return { output: `${JSON.stringify(toB3(loaded), null, 2)}
+`, format: to, issues };
+  }
+  const options = { version: to === "btcpp-v3" ? 3 : 4, layout: "horizontal" };
+  const { project } = loaded;
+  const trees = Object.values(project.trees);
+  const result = loaded.kind === "tree" && trees.length === 1 ? treeToBtcpp(project, trees[0].id, options) : projectToBtcpp(project, options);
+  issues.push(...result.issues.map((issue) => ({ level: issue.level, message: issue.message })));
+  return { output: result.xml.endsWith("\n") ? result.xml : `${result.xml}
+`, format: to, issues };
+}
+
+// src/core/guides.ts
+var get = async (url) => {
+  const response = await fetch(url, { headers: { "User-Agent": "behaviortrees-cli" } });
+  if (!response.ok) throw new Error(`${url} returned HTTP ${response.status}`);
+  return response;
+};
+var listGuides = async () => (await get(`${SITE}/learn/guides.json`)).json();
+var readGuide = async (slug) => {
+  if (!/^[a-z0-9-]+$/.test(slug)) throw new Error(`Not a guide slug: ${slug}`);
+  const response = await fetch(`${SITE}/learn/${slug}.md`, { headers: { "User-Agent": "behaviortrees-cli" } });
+  if (response.status === 404) {
+    const slugs = (await listGuides()).map((guide) => guide.slug);
+    throw new Error(`No guide "${slug}". Guides: ${slugs.join(", ")}`);
+  }
+  if (!response.ok) throw new Error(`Guide request returned HTTP ${response.status}`);
+  return response.text();
+};
+
+// src/core/validate.ts
+var CATEGORIES = /* @__PURE__ */ new Set(["composite", "decorator", "action", "condition"]);
+var ALIASES = {
+  Selector: "Priority",
+  Fallback: "Priority",
+  ReactiveSelector: "Priority",
+  ReactiveSequence: "Sequence",
+  Repeat: "Repeater",
+  Timeout: "MaxTime",
+  Invert: "Inverter",
+  Not: "Inverter",
+  AlwaysSuccess: "Succeeder",
+  AlwaysFailure: "Failer"
+};
+var article = (word) => /^[aeiou]/.test(word) ? `an ${word}` : `a ${word}`;
+function checkCustomNodes(templates, out, tree) {
+  for (const template of templates ?? []) {
+    if (!template?.name) {
+      out.push({ level: "error", message: 'A custom node has no "name"', tree });
+    } else if (template.category && !CATEGORIES.has(template.category)) {
+      out.push({
+        level: "error",
+        message: `Custom node "${template.name}" has category "${template.category}"; use action, condition, composite or decorator`,
+        tree
+      });
+    }
+  }
+}
+function checkTree(spec, categories, out) {
+  const tree = spec.title || spec.id || "Untitled tree";
+  const push = (level, message) => out.push({ level, message, tree });
+  if (!spec.nodes || typeof spec.nodes !== "object" || Array.isArray(spec.nodes)) {
+    push("error", 'The tree has no "nodes" object (node id \u2192 node)');
+    return;
+  }
+  checkCustomNodes(spec.custom_nodes, out, tree);
+  const treeCategories = new Map(categories);
+  for (const template of spec.custom_nodes ?? []) {
+    if (template?.name) treeCategories.set(template.name, template.category ?? "action");
+  }
+  const byId = /* @__PURE__ */ new Map();
+  for (const [key, node] of Object.entries(spec.nodes)) {
+    if (!node || typeof node !== "object") {
+      push("error", `Node "${key}" is not an object`);
+      continue;
+    }
+    const id = node.id ?? key;
+    if (node.id && node.id !== key) {
+      push("warning", `Node keyed "${key}" has id "${node.id}"; children and root must refer to "${node.id}"`);
+    }
+    byId.set(id, node);
+  }
+  const childrenOf = (node) => Array.isArray(node.children) ? node.children : node.child !== void 0 && node.child !== null ? [node.child] : [];
+  if (byId.size > 0) {
+    if (spec.root === void 0 || spec.root === null) {
+      push("error", 'The tree has nodes but no "root" (the id of the first node under the root)');
+    } else if (!byId.has(spec.root)) {
+      push("error", `"root" is "${spec.root}", but there is no node with that id`);
+    }
+  }
+  const parents = /* @__PURE__ */ new Map();
+  const undeclared = /* @__PURE__ */ new Map();
+  const aliased = /* @__PURE__ */ new Set();
+  for (const [id, node] of byId) {
+    if (!node.name) {
+      push("error", `Node "${id}" has no "name"`);
+      continue;
+    }
+    const known = treeCategories.get(node.name);
+    const category = known ?? (Array.isArray(node.children) ? "composite" : node.child !== void 0 ? "decorator" : "action");
+    if (!known && ALIASES[node.name] && !aliased.has(node.name)) {
+      aliased.add(node.name);
+      push(
+        "warning",
+        `"${node.name}" isn't a behavior3 node, so the editor adds it as a custom ${category}. Did you mean "${ALIASES[node.name]}"?`
+      );
+    }
+    if (!known && !ALIASES[node.name]) undeclared.set(node.name, category);
+    if (node.children !== void 0 && !Array.isArray(node.children)) {
+      push("error", `Node "${id}" has "children" that isn't an array`);
+    }
+    const children = childrenOf(node);
+    if (category === "composite" && node.child !== void 0 && !Array.isArray(node.children)) {
+      push("warning", `"${id}" is a composite (${node.name}); composites list "children", not a single "child"`);
+    }
+    if (category === "composite" && children.length === 0) {
+      push("warning", `Composite "${id}" (${node.name}) has no children, so it does nothing`);
+    }
+    if (category === "decorator") {
+      if (Array.isArray(node.children) && node.children.length > 1) {
+        push("error", `Decorator "${id}" (${node.name}) has ${node.children.length} children; decorators wrap exactly one "child"`);
+      } else if (Array.isArray(node.children)) {
+        push("warning", `Decorator "${id}" (${node.name}) uses "children"; decorators take a single "child"`);
+      } else if (children.length === 0) {
+        push("warning", `Decorator "${id}" (${node.name}) has no child`);
+      }
+    }
+    if ((category === "action" || category === "condition") && children.length > 0) {
+      push("error", `"${id}" is ${article(category)} (${node.name}), so it can't have children`);
+    }
+    for (const child of children) {
+      if (!byId.has(child)) {
+        push("error", `Node "${id}" lists child "${child}", which doesn't exist`);
+      } else if (child === spec.root) {
+        push("error", `The root node "${child}" is also a child of "${id}"`);
+      } else if (parents.has(child)) {
+        push("error", `Node "${child}" has two parents ("${parents.get(child)}" and "${id}"); each node can appear once`);
+      } else {
+        parents.set(child, id);
+      }
+    }
+  }
+  if (undeclared.size > 0) {
+    const names = [...undeclared].map(([name, category]) => `${name} (${category})`).join(", ");
+    push(
+      "info",
+      `Not built in and not in custom_nodes, so the editor infers their category: ${names}. Declare them in custom_nodes to set it, e.g. {"name": "IsEnemyVisible", "category": "condition"}.`
+    );
+  }
+  const reached = /* @__PURE__ */ new Set();
+  const walk = (id, path) => {
+    if (path.has(id)) {
+      push("error", `Cycle: "${id}" is its own descendant`);
+      return;
+    }
+    if (reached.has(id) || !byId.has(id)) return;
+    reached.add(id);
+    path.add(id);
+    for (const child of childrenOf(byId.get(id))) walk(child, path);
+    path.delete(id);
+  };
+  if (spec.root && byId.has(spec.root)) walk(spec.root, /* @__PURE__ */ new Set());
+  const orphans = [...byId.keys()].filter((id) => !reached.has(id));
+  if (orphans.length > 0 && spec.root && byId.has(spec.root)) {
+    push(
+      "warning",
+      `${orphans.length === 1 ? "Node" : "Nodes"} ${orphans.map((id) => `"${id}"`).join(", ")} ${orphans.length === 1 ? "isn't" : "aren't"} connected to the root, so ${orphans.length === 1 ? "it" : "they"} will never run`
+    );
+  }
+}
+async function validateTree(input2) {
+  let loaded;
+  try {
+    loaded = await loadInput(input2);
+  } catch (error) {
+    return { valid: false, trees: [], findings: [{ level: "error", message: error.message }] };
+  }
+  const findings = loaded.issues.map((issue) => ({ level: issue.level, message: issue.message }));
+  if (loaded.format === "behavior3") {
+    const categories = new Map(
+      Object.values(DEFAULT_NODES).map((node) => [node.name, node.category])
+    );
+    const projectNodes = loaded.json.custom_nodes;
+    if (loaded.kind === "project") checkCustomNodes(projectNodes, findings);
+    for (const template of projectNodes ?? []) {
+      if (template?.name) categories.set(template.name, template.category ?? "action");
+    }
+    for (const tree of loaded.b3Trees) checkTree(tree, categories, findings);
+  }
+  const trees = Object.values(loaded.project.trees).map((tree) => ({
+    title: tree.title,
+    nodes: Object.keys(tree.blocks).length - 1
+  }));
+  if (trees.length === 0) findings.push({ level: "error", message: "The project has no trees" });
+  return {
+    valid: !findings.some((finding) => finding.level === "error"),
+    format: loaded.format,
+    kind: loaded.kind,
+    trees,
+    findings
+  };
+}
+
+// src/core/link.ts
+var LONG_LINK = 3e4;
+var InvalidTreeError = class extends Error {
+  constructor(findings) {
+    super(
+      `The tree has errors:
+${findings.filter((finding) => finding.level === "error").map((finding) => `- ${finding.tree ? `${finding.tree}: ` : ""}${finding.message}`).join("\n")}`
+    );
+    this.findings = findings;
+  }
+  findings;
+};
+async function createEditorLink(input2) {
+  const validation = await validateTree(input2);
+  if (!validation.valid) throw new InvalidTreeError(validation.findings);
+  const loaded = await loadInput(input2);
+  const data = loaded.format === "behavior3" ? loaded.json : toB3(loaded);
+  const url = `${SITE}/editor#tree=${await encodeSharedTree(data)}`;
+  const findings = [...validation.findings];
+  if (url.length > LONG_LINK) {
+    findings.push({
+      level: "warning",
+      message: `The link is ${url.length.toLocaleString("en-US")} characters; some apps cut off long links, so also share the file`
+    });
+  }
+  return { url, title: validation.trees.map((tree) => tree.title).join(", "), findings };
+}
+
+export {
+  SITE,
+  listNodeTypes,
+  listExamples,
+  getExample,
+  CONVERT_TARGETS,
+  convertTree,
+  listGuides,
+  readGuide,
+  validateTree,
+  InvalidTreeError,
+  createEditorLink
+};