app.bundle.js

/* IntentionEditor bundle: generated by build-bundle.js */
(() => {
"use strict";

/* js/constants.js */
const APP_TITLE = "IntentionEditor";
const APP_VERSION = "1.7.0";

const STORAGE_KEY = "intention-editor.draft.v2";
const LOCALE_STORAGE_KEY = "intention-editor.locale.v1";
const THEME_STORAGE_KEY = "intention-editor.theme.v1";

const PREDICATE_SCOPES = {
  round: "round",
  candidate: "candidate",
  slot: "slot"
};

const PREDICATE_OPERATORS = {
  equals: "equals",
  notEquals: "notEquals",
  in: "in",
  notIn: "notIn",
  contains: "contains",
  notContains: "notContains",
  ">": ">",
  ">=": ">=",
  "<": "<",
  "<=": "<=",
  between: "between",
  sameAs: "sameAs",
  notSameAs: "notSameAs"
};

const VISIBILITY_TYPES = {
  visible: "visible",
  hidden: "hidden"
};

const REVEAL_TYPES = {
  none: "none",
  timer: "timer"
};

const TEXT_BINDING_SOURCES = {
  self: "self",
  slot: "slot",
  round: "round",
  literal: "literal"
};

const TEXT_LIMITS = {
  name: 35,
  summary: 35,
  description: 2000,
  oocInfo: 500,
  copyableText: 5000,
  hiddenLabel: 45
};

const INTENTION_KINDS = {
  primary: "primary",
  secondary: "secondary"
};

const OPERATORS_BY_FIELD_TYPE = {
  string: ["equals", "notEquals", "in", "notIn"],
  bool: ["equals", "notEquals"],
  int: ["equals", "notEquals", ">", ">=", "<", "<=", "between", "in", "notIn"],
  timespan: ["equals", "notEquals", ">", ">=", "<", "<=", "between", "in", "notIn"],
  "list-string": ["contains", "notContains", "in", "notIn"],
  "map-int": ["equals", "notEquals", ">", ">=", "<", "<=", "between", "in", "notIn"]
};


/* js/data/catalog-data.js */
const CATEGORY_CATALOG = [
  {
    id: "personal",
    title: {
      ru: "Личные",
      en: "Personal"
    },
    description: {
      ru: "Намерения, основанные на внутренних переживаниях, привычках и личных целях персонажа.",
      en: "Intentions driven by inner mood, habits, and personal goals."
    },
    examples: {
      ru: [
        "Персонаж хочет восстановить своё честное имя.",
        "Персонаж ставит себе цель не ругаться весь раунд.",
        "Персонаж хочет поднять настроение окружающим."
      ],
      en: [
        "The character wants to restore their good name.",
        "The character sets a goal to avoid swearing for the whole round.",
        "The character wants to lift the mood of the crew."
      ]
    }
  }
,
  {
    id: "social",
    title: {
      ru: "Социальные",
      en: "Social"
    },
    description: {
      ru: "Сценарии про отношения с экипажем, встречи, мероприятия и общественную жизнь станции.",
      en: "Scenarios about relationships, meetings, events, and station social life."
    },
    examples: {
      ru: [
        "Организуй неформальную встречу коллег в баре.",
        "Проведи маленькое мероприятие или игру.",
        "Подготовь и распространи петицию."
      ],
      en: [
        "Organize an informal department gathering at the bar.",
        "Run a small event, game, or contest.",
        "Write and circulate a petition."
      ]
    }
  },
  {
    id: "professional",
    title: {
      ru: "Профессиональные",
      en: "Professional"
    },
    description: {
      ru: "Намерения, завязанные на должности и рабочих обязанностях персонажа.",
      en: "Intentions tied to the character's job and day-to-day duties."
    },
    examples: {
      ru: [
        "Проведи мини-инструктаж по здоровью для экипажа.",
        "Придумай и представь уникальное блюдо и напиток.",
        "Регулярно уточняй состояние и нужды отделов."
      ],
      en: [
        "Give a short health briefing to the crew.",
        "Invent and present a unique dish and drink.",
        "Regularly check in with departments about their current needs."
      ]
    }
  },
  {
    id: "conflict",
    title: {
      ru: "Конфликтные",
      en: "Conflict"
    },
    description: {
      ru: "Сценарии с соперничеством, противостоянием, давлением или расследованием против кого-то.",
      en: "Scenarios built around rivalry, opposition, pressure, or informal investigation."
    },
    examples: {
      ru: [
        "Добейся, чтобы другого сотрудника перестали воспринимать всерьёз.",
        "Оспаривай решения командования и продвигай альтернативы.",
        "Подставь другого члена экипажа так, чтобы он выглядел виноватым."
      ],
      en: [
        "Undermine another crew member's reputation.",
        "Challenge command decisions and push alternatives.",
        "Set someone up so they look responsible."
      ]
    }
  },
  {
    id: "criminal",
    title: {
      ru: "Криминальные / незаконные",
      en: "Criminal / Illegal"
    },
    description: {
      ru: "Нелегальные действия: кражи, мошенничество, подлог, похищения и другие нарушения.",
      en: "Illegal actions such as theft, fraud, forgery, abduction, and similar misconduct."
    },
    examples: {
      ru: [
        "Незаметно присвой себе что-нибудь ценное.",
        "Подделай документ и получи выгоду.",
        "Соверши нелетальное нападение и не оставь следов."
      ],
      en: [
        "Quietly pocket something valuable.",
        "Forge a document for personal gain.",
        "Pull off a non-lethal assault without leaving evidence."
      ]
    }
  },
  {
    id: "sabotage",
    title: {
      ru: "Диверсионные",
      en: "Sabotage"
    },
    description: {
      ru: "Сценарии саботажа станции, цепочек поставок, систем жизнеобеспечения и отвлекающих инцидентов.",
      en: "Sabotage scenarios aimed at supplies, station systems, or manufactured distractions."
    },
    examples: {
      ru: [
        "Нарушь цепочку поставок или саботируй снабжение.",
        "Вмешайся в энергетику или жизнеобеспечение так, чтобы сбои казались случайными.",
        "Создай ложные угрозы, отвлекающие безопасность."
      ],
      en: [
        "Disrupt supply flow or cargo delivery.",
        "Interfere with power or life support so failures look accidental.",
        "Create false threats that keep security busy."
      ]
    }
  },
  {
    id: "antag",
    title: {
      ru: "Антагонистические",
      en: "Antagonist"
    },
    description: {
      ru: "Особые намерения, связанные с ролевой логикой антагонистов.",
      en: "Special intentions linked to antagonist roleplay and manipulation."
    },
    examples: {
      ru: [
        "Найди недовольного члена экипажа и мягко склони к сотрудничеству.",
        "Сделай так, чтобы цель начала на тебя полагаться.",
        "Используй чужой голос или репутацию, чтобы создать путаницу."
      ],
      en: [
        "Find a dissatisfied crew member and gently recruit them.",
        "Make your target rely on you over time.",
        "Use another person's voice or reputation to create confusion."
      ]
    }
  },
  {
    id: "events",
    title: {
      ru: "Событийные / праздничные",
      en: "Events / Holiday"
    },
    description: {
      ru: "Сценарии, приуроченные к праздникам, датам и специальным станционным событиям.",
      en: "Scenarios tied to holidays, seasonal events, and special station moments."
    },
    examples: {
      ru: [
        "Подготовь подарок для Тайного Санты.",
        "Организуй маленький день рождения для члена экипажа.",
        "Устрой романтическую встречу на День святого Валентина."
      ],
      en: [
        "Prepare a Secret Santa gift.",
        "Arrange a small birthday surprise for a crew member.",
        "Set up a Valentine's Day meeting for two people."
      ]
    }
  },
  {
    id: "admin",
    title: {
      ru: "Административные",
      en: "Admin"
    },
    description: {
      ru: "Сценарии, запускаемые вручную администраторами для сюжетов, тематических раундов и обучающих режимов.",
      en: "Scenarios launched manually by admins for events, themed rounds, and guided experiences."
    },
    examples: {
      ru: [
        "Внезапная инспекция Центрального Командования.",
        "Предварительный брифинг для командного состава.",
        "Служебные подсказки и правила для специального режима."
      ],
      en: [
        "A surprise Central Command inspection.",
        "A pre-briefed command-side event scenario.",
        "Rule and hint scenarios for a special game mode."
      ]
    }
  }
];

function humanizeDictionaryValue(value) {
  return value
    .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2")
    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
    .replace(/_/g, " ")
    .trim();
}

function buildDictionaryLabel(id, entry) {
  if (!entry) {
    return humanizeDictionaryValue(id) || id;
  }

  const english = entry.en ?? humanizeDictionaryValue(id) ?? id;
  const russian = entry.ru;
  if (!russian) {
    return english;
  }

  return {
    ru: `${id} · ${russian}`,
    en: english
  };
}

const VALUE_DICTIONARIES = {
  gameModes: [
    "AllAtOnce",
    "AllerAtOnce",
    "Deathmatch",
    "Dynamic",
    "Extended",
    "Greenshift",
    "KesslerSyndrome",
    "Nukeops",
    "Revolutionary",
    "Sandbox",
    "Secret",
    "Survival",
    "Traitor",
    "Wizard",
    "Xenoborgs",
    "Zombie",
    "Zombieteors"
  ],
  eventTags: [
    "AnimalsDay",
    "AnzacDay",
    "AprilFoolDay",
    "ArmisticeDay",
    "AutismAwarenessDay",
    "BastilleDay",
    "BeerDay",
    "Birthday13",
    "Birthday14",
    "BoxingDay",
    "CanadianThanksgiving",
    "ChineseNewYear",
    "Christmas",
    "CosmonauticsDay",
    "DoctorDay",
    "EarthDay",
    "Easter",
    "FathersDay",
    "FestiveSeason",
    "FirefighterDay",
    "FlowersDay",
    "FourTwenty",
    "FridayThirteenth",
    "FriendshipDay",
    "GarbageDay",
    "GroundhogDay",
    "Halloween",
    "InternationalPicnicDay",
    "KindnessDay",
    "LaborDay",
    "LeapDay",
    "LifeDay",
    "MayanDoomsday",
    "MikuDay",
    "MisterLizard",
    "MoMMIDay",
    "MonkeyDay",
    "MothersDay",
    "NewYear",
    "OwlAndPussycatDay",
    "PiDay",
    "ProgrammersDay",
    "RandomKindness",
    "SayingHelloDay",
    "Sinterklaas",
    "SmilingDay",
    "StPatricksDay",
    "StupidQuestionsDay",
    "SummerSolstice",
    "TalkLikeAPirateDay",
    "TeaDay",
    "Thanksgiving",
    "TowelDay",
    "UFODay",
    "USIndependenceDay",
    "ValentinesDay",
    "VeganDay",
    "WritersDay"
  ],
  jobs: [
    "AtmosphericTechnician",
    "Bartender",
    "Borg",
    "Botanist",
    "Captain",
    "CargoTechnician",
    "CBURN",
    "CentralCommandOfficial",
    "Chaplain",
    "Chef",
    "Chemist",
    "ChiefEngineer",
    "ChiefMedicalOfficer",
    "Clown",
    "DeathSquad",
    "Detective",
    "ERTChaplain",
    "ERTEngineer",
    "ERTJanitor",
    "ERTLeader",
    "ERTMedical",
    "ERTSecurity",
    "HeadOfPersonnel",
    "HeadOfSecurity",
    "Janitor",
    "Lawyer",
    "Librarian",
    "MedicalDoctor",
    "MedicalIntern",
    "Mime",
    "Musician",
    "Paramedic",
    "Passenger",
    "Psychologist",
    "Quartermaster",
    "Reporter",
    "ResearchAssistant",
    "ResearchDirector",
    "SalvageSpecialist",
    "Scientist",
    "SecurityCadet",
    "SecurityOfficer",
    "ServiceWorker",
    "StationAi",
    "StationEngineer",
    "TechnicalAssistant",
    "Visitor",
    "Warden"
  ],
  departments: [
    "Cargo",
    "CentralCommand",
    "Civilian",
    "Command",
    "Engineering",
    "Medical",
    "Science",
    "Security",
    "Silicon",
    "Specific"
  ],
  species: [
    "Arachnid",
    "Diona",
    "Dwarf",
    "Gingerbread",
    "Human",
    "Moth",
    "Reptilian",
    "Skeleton",
    "SlimePerson",
    "Vox",
    "Vulpkanin"
  ],
  sex: [
    "Female",
    "Male",
    "Unsexed"
  ],
  traits: [
    "Accentless",
    "Blindness",
    "FrenchAccent",
    "FrontalLisp",
    "GermanAccent",
    "Hemophilia",
    "ImpairedMobility",
    "Liar",
    "LightweightDrunk",
    "Monochromacy",
    "Muted",
    "Narcolepsy",
    "Pacifist",
    "PainNumbness",
    "Paracusia",
    "PoorVision",
    "ScottishAccent",
    "Snoring",
    "SocialAnxiety",
    "SouthernAccent",
    "SpanishAccent",
    "Unrevivable"
  ],
  antagRoles: [
    "Changeling",
    "Dragon",
    "GenericAntagonist",
    "GenericFreeAgent",
    "GenericSiliconAntagonist",
    "GenericTeamAntagonist",
    "HeadRev",
    "InitialInfected",
    "MothershipCore",
    "Nukeops",
    "NukeopsCommander",
    "NukeopsMedic",
    "ParadoxClone",
    "Rev",
    "SpaceNinja",
    "SubvertedSilicon",
    "Survivor",
    "Thief",
    "Traitor",
    "TraitorSleeper",
    "Wizard",
    "Xenoborg",
    "Zombie"
  ],
  objectiveTypes: [
    "AltarNanotrasenStealObjective",
    "AmePartFlatpackStealObjective",
    "BaseCaptainObjective",
    "BaseChangelingObjective",
    "BaseCMOStealObjective",
    "BaseCodeObjective",
    "BaseDragonObjective",
    "BaseFreeObjective",
    "BaseHelpProgressObjective",
    "BaseKeepAliveObjective",
    "BaseKillObjective",
    "BaseLivingObjective",
    "BaseNinjaObjective",
    "BaseObjective",
    "BaseParadoxCloneObjective",
    "BaseRDStealObjective",
    "BaseSocialObjective",
    "BaseStealObjective",
    "BaseSurviveObjective",
    "BaseTargetObjective",
    "BaseThiefObjective",
    "BaseThiefStealAnimalObjective",
    "BaseThiefStealCollectionObjective",
    "BaseThiefStealObjective",
    "BaseThiefStealStructureObjective",
    "BaseTraitorObjective",
    "BaseTraitorSocialObjective",
    "BaseTraitorStealObjective",
    "BaseWizardObjective",
    "BingusStealObjective",
    "BoozeDispenserStealObjective",
    "CaptainGunStealObjective",
    "CaptainIDStealObjective",
    "CaptainJetpackStealObjective",
    "CaptainSwordStealObjective",
    "CargoShuttleCircuitboardStealObjective",
    "CarpRiftsObjective",
    "ChangelingSurviveObjective",
    "ChemDispenserStealObjective",
    "ChiefEngineerToolbeltStealObjective",
    "ClipboardStealObjective",
    "ClothingEyesHudsStealCollectionObjective",
    "ClothingHeadHatWardenStealObjective",
    "ClothingHeadsetAltMedicalStealObjective",
    "ClothingNeckClownmedalStealObjective",
    "CMOCrewMonitorStealObjective",
    "CMOHyposprayStealObjective",
    "CorgiMeatStealObjective",
    "DieObjective",
    "DoorjackObjective",
    "DoorRemoteStealCollectionObjective",
    "DragonSurviveObjective",
    "EnergyMagnumStealObjective",
    "EscapeShuttleObjective",
    "EscapeThiefShuttleObjective",
    "FaxMachineCaptainStealObjective",
    "FlippoEngravedLighterStealObjective",
    "FreezerHeaterStealObjective",
    "HandTeleporterStealObjective",
    "HeadBedsheetStealCollectionObjective",
    "HeadCloakStealCollectionObjective",
    "HijackTradeStationObjective",
    "IanStealObjective",
    "IDCardsStealCollectionObjective",
    "KillRandomHeadObjective",
    "KillRandomPersonObjective",
    "KillStationAiObjective",
    "KnuckleDustersStealObjective",
    "LAMPStealCollectionObjective",
    "MagbootsStealObjective",
    "MailStealCollectionObjective",
    "MassArrestObjective",
    "McGriffStealObjective",
    "MedicalTechFabCircuitboardStealObjective",
    "MortyStealObjective",
    "NinjaSurviveObjective",
    "NuclearBombStealObjective",
    "NukeDiskStealObjective",
    "OfficerHandgunsStealCollectionObjective",
    "ParadoxCloneKillObjective",
    "ParadoxCloneLivingObjective",
    "PlantRDStealObjective",
    "RandomTraitorAliveObjective",
    "RandomTraitorProgressObjective",
    "RDHardsuitStealObjective",
    "RenaultStealObjective",
    "ShivaStealObjective",
    "SpiderChargeObjective",
    "StampStealCollectionObjective",
    "StealResearchObjective",
    "SupercritAnomaliesObjective",
    "TechnologyDiskStealCollectionObjective",
    "TegStealObjective",
    "TerrorObjective",
    "ToiletGoldenStealObjective",
    "TropicoStealObjective",
    "WalterStealObjective",
    "WantedListCartridgeStealObjective",
    "WizardDemonstrateObjective",
    "WizardSurviveObjective",
    "XenoArtifactStealObjective"
  ]
};

const GAME_MODE_LABELS = {
  AllAtOnce: { ru: "Все и сразу", en: "All At Once" },
  AllerAtOnce: { ru: "Aller At Once", en: "Aller At Once" },
  Deathmatch: { ru: "Смертельный матч", en: "Deathmatch" },
  Dynamic: { ru: "Динамический", en: "Dynamic" },
  Extended: { ru: "Расширенный", en: "Extended" },
  Greenshift: { ru: "Гриншифт", en: "Greenshift" },
  KesslerSyndrome: { ru: "Синдром Кесслера", en: "Kessler Syndrome" },
  Nukeops: { ru: "Ядерные оперативники", en: "Nuclear Operatives" },
  Revolutionary: { ru: "Революция", en: "Revolutionary" },
  Sandbox: { ru: "Песочница", en: "Sandbox" },
  Secret: { ru: "Секрет", en: "Secret" },
  Survival: { ru: "Выживание", en: "Survival" },
  Traitor: { ru: "Предатели", en: "Traitor" },
  Wizard: { ru: "Волшебник", en: "Wizard" },
  Xenoborgs: { ru: "Ксеноборги", en: "Xenoborgs" },
  Zombie: { ru: "Зомби", en: "Zombie" },
  Zombieteors: { ru: "Зомби-метеоры", en: "Zombieteors" }
};

const EVENT_TAG_LABELS = {
  AnimalsDay: { ru: "День животных", en: "Animals Day" },
  AnzacDay: { ru: "День АНЗАК", en: "Anzac Day" },
  AprilFoolDay: { ru: "День смеха", en: "April Fools Day" },
  ArmisticeDay: { ru: "День перемирия", en: "Armistice Day" },
  AutismAwarenessDay: { ru: "День осведомлённости об аутизме", en: "Autism Awareness Day" },
  BastilleDay: { ru: "День взятия Бастилии", en: "Bastille Day" },
  BeerDay: { ru: "День пива", en: "Beer Day" },
  Birthday13: { ru: "День рождения Space Station 13", en: "Space Station 13 Birthday" },
  Birthday14: { ru: "День рождения Space Station 14", en: "Space Station 14 Birthday" },
  BoxingDay: { ru: "День подарков", en: "Boxing Day" },
  CanadianThanksgiving: { ru: "Канадский День благодарения", en: "Canadian Thanksgiving" },
  ChineseNewYear: { ru: "Китайский Новый год", en: "Chinese New Year" },
  Christmas: { ru: "Рождество", en: "Christmas" },
  CosmonauticsDay: { ru: "День космонавтики", en: "Cosmonautics Day" },
  DoctorDay: { ru: "День врача", en: "Doctor's Day" },
  EarthDay: { ru: "День Земли", en: "Earth Day" },
  Easter: { ru: "Пасха", en: "Easter" },
  FathersDay: { ru: "День отца", en: "Father's Day" },
  FestiveSeason: { ru: "Праздничный сезон", en: "Festive Season" },
  FirefighterDay: { ru: "День пожарного", en: "Firefighter's Day" },
  FlowersDay: { ru: "День цветов", en: "Flowers Day" },
  FridayThirteenth: { ru: "Пятница, 13-е", en: "Friday the 13th" },
  FriendshipDay: { ru: "День дружбы", en: "Friendship Day" },
  GarbageDay: { ru: "День мусора", en: "Garbage Day" },
  GroundhogDay: { ru: "День сурка", en: "Groundhog Day" },
  Halloween: { ru: "Хэллоуин", en: "Halloween" },
  InternationalPicnicDay: { ru: "Международный день пикника", en: "International Picnic Day" },
  KindnessDay: { ru: "День доброты", en: "Kindness Day" },
  LaborDay: { ru: "День труда", en: "Labor Day" },
  LeapDay: { ru: "Високосный день", en: "Leap Day" },
  LifeDay: { ru: "День жизни", en: "Life Day" },
  MayanDoomsday: { ru: "Годовщина конца света майя", en: "Mayan Doomsday Anniversary" },
  MikuDay: { ru: "День Хацунэ Мику", en: "Hatsune Miku Day" },
  MisterLizard: { ru: "День рождения мистера Ящера", en: "Mister Lizard's Birthday" },
  MonkeyDay: { ru: "День обезьян", en: "Monkey Day" },
  MothersDay: { ru: "День матери", en: "Mother's Day" },
  NewYear: { ru: "Новый год", en: "New Year" },
  OwlAndPussycatDay: { ru: "День совы и кошечки", en: "Owl and Pussycat Day" },
  PiDay: { ru: "День числа Пи", en: "Pi Day" },
  ProgrammersDay: { ru: "День программиста", en: "Programmers' Day" },
  RandomKindness: { ru: "День случайных добрых дел", en: "Random Acts of Kindness Day" },
  SayingHelloDay: { ru: "День приветствий", en: "Saying Hello Day" },
  Sinterklaas: { ru: "Синтерклаас", en: "Sinterklaas" },
  SmilingDay: { ru: "День улыбки", en: "Smiling Day" },
  StPatricksDay: { ru: "День святого Патрика", en: "St. Patrick's Day" },
  StupidQuestionsDay: { ru: "День глупых вопросов", en: "Stupid Questions Day" },
  SummerSolstice: { ru: "Летнее солнцестояние", en: "Summer Solstice" },
  TalkLikeAPirateDay: { ru: "День пиратской речи", en: "Talk-Like-a-Pirate Day" },
  TeaDay: { ru: "День чая", en: "National Tea Day" },
  Thanksgiving: { ru: "День благодарения", en: "Thanksgiving" },
  TowelDay: { ru: "День полотенца", en: "Towel Day" },
  UFODay: { ru: "День НЛО", en: "UFO Day" },
  USIndependenceDay: { ru: "День независимости США", en: "US Independence Day" },
  ValentinesDay: { ru: "День святого Валентина", en: "Valentine's Day" },
  VeganDay: { ru: "День вегана", en: "Vegan Day" },
  WritersDay: { ru: "День писателя", en: "Writer's Day" }
};

const OBJECTIVE_TYPE_LABEL_OVERRIDES = {
  CarpRiftsObjective: { ru: "Открыть разломы карпов", en: "Open carp rifts objective" },
  DieObjective: { ru: "Погибнуть", en: "Die objective" },
  DoorjackObjective: { ru: "Взлом дверей", en: "Doorjack objective" },
  EscapeShuttleObjective: { ru: "Побег на шаттле", en: "Escape on shuttle objective" },
  EscapeThiefShuttleObjective: { ru: "Побег вора на шаттле", en: "Thief shuttle escape objective" },
  HijackTradeStationObjective: { ru: "Угон торговой станции", en: "Hijack trade station objective" },
  KillRandomHeadObjective: { ru: "Устранить случайного главу", en: "Kill random head objective" },
  KillRandomPersonObjective: { ru: "Устранить случайного персонажа", en: "Kill random person objective" },
  KillStationAiObjective: { ru: "Устранить ИИ станции", en: "Kill station AI objective" },
  MassArrestObjective: { ru: "Массовые аресты", en: "Mass arrest objective" },
  ParadoxCloneKillObjective: { ru: "Устранение парадоксального клона", en: "Paradox clone kill objective" },
  ParadoxCloneLivingObjective: { ru: "Выживание парадоксального клона", en: "Paradox clone survival objective" },
  RandomTraitorAliveObjective: { ru: "Сохранить предателя в живых", en: "Keep fellow traitor alive objective" },
  RandomTraitorProgressObjective: { ru: "Помочь прогрессу предателя", en: "Help fellow traitor progress objective" },
  SpiderChargeObjective: { ru: "Подрыв паучьего заряда", en: "Spider charge objective" },
  StealResearchObjective: { ru: "Кража исследований", en: "Steal research objective" },
  SupercritAnomaliesObjective: { ru: "Вывести аномалии в сверхкрит", en: "Supercritical anomalies objective" },
  TerrorObjective: { ru: "Террор", en: "Terror objective" },
  WizardDemonstrateObjective: { ru: "Продемонстрировать силу волшебника", en: "Wizard demonstration objective" },
  WizardSurviveObjective: { ru: "Выжить волшебником", en: "Wizard survival objective" }
};

const OBJECTIVE_TYPE_TOKEN_RU = {
  Altar: "алтарь",
  Ame: "ДАМ",
  Animal: "животное",
  Base: "базовая",
  Bedsheet: "простыня",
  Bingus: "Бингус",
  Bomb: "бомба",
  Booze: "алко",
  Captain: "капитан",
  Cargo: "карго",
  Cards: "карты",
  Cartridge: "картридж",
  Chem: "хим",
  Chief: "шеф",
  Circuitboard: "плата",
  Clipboard: "планшет",
  Clone: "клон",
  Clothing: "одежда",
  Cloak: "плащ",
  CMO: "главврач",
  Code: "коды",
  Collection: "коллекция",
  Corgi: "корги",
  Crew: "экипаж",
  Demonstrate: "демонстрация",
  Dispenser: "раздатчик",
  Door: "дверь",
  Dragon: "дракон",
  Engineer: "инженер",
  Energy: "энергетический",
  Eyes: "очки",
  Fab: "фаб",
  Fax: "факс",
  Flatpack: "упаковка",
  Flippo: "Флиппо",
  Free: "свободная",
  Freezer: "морозильник",
  Gun: "пистолет",
  Hand: "ручной",
  Handguns: "пистолеты",
  Hat: "шляпа",
  Head: "голова",
  Heater: "нагреватель",
  Help: "помощь",
  Huds: "HUD",
  Hypospray: "гипоспрей",
  Ian: "Иан",
  ID: "ID",
  Hijack: "угон",
  Jetpack: "джетпак",
  Keep: "сохранение",
  Kill: "устранение",
  Knuckle: "кастет",
  LAMP: "ЛАМП",
  List: "список",
  Living: "выживание",
  Magboots: "магбуты",
  Magnum: "магнум",
  Mail: "почта",
  Mass: "массовый",
  McGriff: "МакГрифф",
  Meat: "мясо",
  Medical: "медицинский",
  Monitor: "монитор",
  Morty: "Морти",
  Nanotrasen: "Нанотрейзен",
  Neck: "шея",
  Ninja: "ниндзя",
  Nuclear: "ядерный",
  Nuke: "нюк",
  Objective: "цель",
  Officer: "офицер",
  Part: "часть",
  Paradox: "парадокс",
  Person: "персонаж",
  Plant: "растение",
  Progress: "прогресс",
  RD: "НИО",
  Random: "случайный",
  Renault: "Рено",
  Research: "исследования",
  Remote: "пульт",
  Shiva: "Шива",
  Social: "социальная",
  Spider: "паучий",
  Stamp: "штамп",
  Station: "станция",
  Steal: "кража",
  Structure: "структура",
  Survive: "выживание",
  Sword: "меч",
  Target: "цель",
  Tech: "тех",
  Technology: "технологический",
  Teg: "Тег",
  Teleporter: "телепортер",
  Terror: "террор",
  Thief: "вор",
  Toilet: "туалет",
  Toolbelt: "пояс для инструментов",
  Trade: "торговый",
  Traitor: "предатель",
  Tropico: "Тропико",
  Walter: "Вальтер",
  Wanted: "разыскиваемых",
  Warden: "смотритель",
  Wizard: "волшебник",
  Xeno: "ксено",
  Artifact: "артефакт"
};

function splitCamelTokens(value) {
  return value
    .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2")
    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
    .trim()
    .split(/\s+/)
    .filter(Boolean);
}

function translateObjectivePhraseRu(value) {
  return splitCamelTokens(value)
    .map(token => OBJECTIVE_TYPE_TOKEN_RU[token] ?? token)
    .join(" ");
}

function buildObjectiveTypeRussianLabel(id) {
  const override = OBJECTIVE_TYPE_LABEL_OVERRIDES[id];
  if (override) {
    return override.ru;
  }

  const raw = id.replace(/Objective$/, "");

  if (raw.startsWith("Base")) {
    const phrase = translateObjectivePhraseRu(raw.slice(4));
    return phrase ? `Базовая цель: ${phrase}` : "Базовая цель";
  }

  if (raw.endsWith("StealCollection")) {
    return `Кража коллекции: ${translateObjectivePhraseRu(raw.slice(0, -"StealCollection".length))}`;
  }

  if (raw.endsWith("StealStructure")) {
    return `Кража структуры: ${translateObjectivePhraseRu(raw.slice(0, -"StealStructure".length))}`;
  }

  if (raw.endsWith("StealAnimal")) {
    return `Кража животного: ${translateObjectivePhraseRu(raw.slice(0, -"StealAnimal".length))}`;
  }

  if (raw.endsWith("Steal")) {
    return `Кража: ${translateObjectivePhraseRu(raw.slice(0, -"Steal".length))}`;
  }

  if (raw.endsWith("Survive")) {
    return `Выживание: ${translateObjectivePhraseRu(raw.slice(0, -"Survive".length))}`;
  }

  if (raw.endsWith("Kill")) {
    return `Устранение: ${translateObjectivePhraseRu(raw.slice(0, -"Kill".length))}`;
  }

  if (raw.endsWith("Living")) {
    return `Выживание: ${translateObjectivePhraseRu(raw.slice(0, -"Living".length))}`;
  }

  if (raw.endsWith("HelpProgress")) {
    return `Помощь прогрессу: ${translateObjectivePhraseRu(raw.slice(0, -"HelpProgress".length))}`;
  }

  if (raw.endsWith("KeepAlive")) {
    return `Сохранить в живых: ${translateObjectivePhraseRu(raw.slice(0, -"KeepAlive".length))}`;
  }

  if (raw.endsWith("Demonstrate")) {
    return `Демонстрация: ${translateObjectivePhraseRu(raw.slice(0, -"Demonstrate".length))}`;
  }

  return translateObjectivePhraseRu(raw);
}

const OBJECTIVE_TYPE_LABELS = Object.fromEntries(
  VALUE_DICTIONARIES.objectiveTypes.map(id => [
    id,
    {
      ru: buildObjectiveTypeRussianLabel(id),
      en: OBJECTIVE_TYPE_LABEL_OVERRIDES[id]?.en ?? humanizeDictionaryValue(id)
    }
  ])
);

const LOCALIZED_DICTIONARY_LABELS = {
  gameModes: GAME_MODE_LABELS,
  eventTags: EVENT_TAG_LABELS,
  objectiveTypes: OBJECTIVE_TYPE_LABELS,
  jobs: {
    AtmosphericTechnician: { ru: "Атмосферный техник", en: "Atmospheric Technician" },
    Bartender: { ru: "Бармен", en: "Bartender" },
    Botanist: { ru: "Ботаник", en: "Botanist" },
    Captain: { ru: "Капитан", en: "Captain" },
    CargoTechnician: { ru: "Грузчик", en: "Cargo Technician" },
    Chaplain: { ru: "Священник", en: "Chaplain" },
    Chef: { ru: "Повар", en: "Chef" },
    Chemist: { ru: "Химик", en: "Chemist" },
    ChiefEngineer: { ru: "Старший инженер", en: "Chief Engineer" },
    ChiefMedicalOfficer: { ru: "Главный врач", en: "Chief Medical Officer" },
    Clown: { ru: "Клоун", en: "Clown" },
    Detective: { ru: "Детектив", en: "Detective" },
    HeadOfPersonnel: { ru: "Глава персонала", en: "Head of Personnel" },
    HeadOfSecurity: { ru: "Глава службы безопасности", en: "Head of Security" },
    Janitor: { ru: "Уборщик", en: "Janitor" },
    Lawyer: { ru: "Юрист", en: "Lawyer" },
    Librarian: { ru: "Библиотекарь", en: "Librarian" },
    MedicalDoctor: { ru: "Врач", en: "Medical Doctor" },
    MedicalIntern: { ru: "Интерн", en: "Medical Intern" },
    Mime: { ru: "Мим", en: "Mime" },
    Musician: { ru: "Музыкант", en: "Musician" },
    Paramedic: { ru: "Парамедик", en: "Paramedic" },
    Passenger: { ru: "Пассажир", en: "Passenger" },
    Psychologist: { ru: "Психолог", en: "Psychologist" },
    Quartermaster: { ru: "Квартирмейстер", en: "Quartermaster" },
    Reporter: { ru: "Репортёр", en: "Reporter" },
    ResearchAssistant: { ru: "Научный ассистент", en: "Research Assistant" },
    ResearchDirector: { ru: "Научный руководитель", en: "Research Director" },
    SalvageSpecialist: { ru: "Утилизатор", en: "Salvage Specialist" },
    Scientist: { ru: "Учёный", en: "Scientist" },
    SecurityCadet: { ru: "Кадет СБ", en: "Security Cadet" },
    SecurityOfficer: { ru: "Офицер СБ", en: "Security Officer" },
    ServiceWorker: { ru: "Сервисный работник", en: "Service Worker" },
    StationAi: { ru: "ИИ станции", en: "Station AI" },
    StationEngineer: { ru: "Инженер", en: "Station Engineer" },
    TechnicalAssistant: { ru: "Технический ассистент", en: "Technical Assistant" },
    Warden: { ru: "Смотритель", en: "Warden" },
	Roboticist: { ru: "Робототехник", en: "Roboticist" },
	Boxer: { ru: "Боксёр", en: "Boxer" },
	Zookeeper: { ru: "Зоотехник", en: "Zookeeper" },
  },
  departments: {
    Cargo: { ru: "Снабжение", en: "Cargo" },
    CentralCommand: { ru: "Центральное командование", en: "Central Command" },
    Civilian: { ru: "Сервисный", en: "Civilian" },
    Command: { ru: "Командование", en: "Command" },
    Engineering: { ru: "Инженерный", en: "Engineering" },
    Medical: { ru: "Медицинский", en: "Medical" },
    Science: { ru: "Научный", en: "Science" },
    Security: { ru: "Служба безопасности", en: "Security" },
  },
  species: {
    Arachnid: { ru: "Арахнид", en: "Arachnid" },
    Diona: { ru: "Диона", en: "Diona" },
    Dwarf: { ru: "Дворф", en: "Dwarf" },
    Human: { ru: "Человек", en: "Human" },
    Moth: { ru: "Моль", en: "Moth" },
    Reptilian: { ru: "Рептилоид", en: "Reptilian" },
    SlimePerson: { ru: "Слаймолюд", en: "Slime Person" },
    Vox: { ru: "Вокс", en: "Vox" },
    Vulpkanin: { ru: "Вульпканин", en: "Vulpkanin" }
  },
  sex: {
    Female: { ru: "Женский", en: "Female" },
    Male: { ru: "Мужской", en: "Male" },
    Unsexed: { ru: "Бесполый", en: "Unsexed" }
  },
  traits: {
    Accentless: { ru: "Без акцента", en: "Accentless" },
    Blindness: { ru: "Слепота", en: "Blindness" },
    FrenchAccent: { ru: "Французский акцент", en: "French Accent" },
    FrontalLisp: { ru: "Шепелявость", en: "Frontal Lisp" },
    GermanAccent: { ru: "Немецкий акцент", en: "German Accent" },
    Hemophilia: { ru: "Гемофилия", en: "Hemophilia" },
    ImpairedMobility: { ru: "Ограниченная подвижность", en: "Impaired Mobility" },
    Liar: { ru: "Лжец", en: "Liar" },
    LightweightDrunk: { ru: "Легко пьянеет", en: "Lightweight Drunk" },
    Monochromacy: { ru: "Монохромия", en: "Monochromacy" },
    Muted: { ru: "Немота", en: "Muted" },
    Narcolepsy: { ru: "Нарколепсия", en: "Narcolepsy" },
    Pacifist: { ru: "Пацифист", en: "Pacifist" },
    PainNumbness: { ru: "Нечувствительность к боли", en: "Pain Numbness" },
    Paracusia: { ru: "Паракузия", en: "Paracusia" },
    PoorVision: { ru: "Плохое зрение", en: "Poor Vision" },
    ScottishAccent: { ru: "Шотландский акцент", en: "Scottish Accent" },
    Snoring: { ru: "Храп", en: "Snoring" },
    SocialAnxiety: { ru: "Социальная тревожность", en: "Social Anxiety" },
    SouthernAccent: { ru: "Южный акцент", en: "Southern Accent" },
    SpanishAccent: { ru: "Испанский акцент", en: "Spanish Accent" },
    Unrevivable: { ru: "Неоживляемый", en: "Unrevivable" }
  },
  antagRoles: {
    Changeling: { ru: "Генокрад", en: "Changeling" },
    Dragon: { ru: "Космический дракон", en: "Space Dragon" },
    GenericSiliconAntagonist: { ru: "Кремниевый антагонист", en: "Silicon Antagonist" },
    HeadRev: { ru: "Глава революции", en: "Head Revolutionary" },
    InitialInfected: { ru: "Нулевой заражённый", en: "Initial Infected" },
    MothershipCore: { ru: "Ядро ксеноборга", en: "Xenoborg Core" },
    Nukeops: { ru: "Ядерный оперативник", en: "Nuclear Operative" },
    NukeopsCommander: { ru: "Командир ядерных оперативников", en: "Nuclear Operative Commander" },
    NukeopsMedic: { ru: "Медик ядерных оперативников", en: "Nuclear Operative Corpsman" },
    ParadoxClone: { ru: "Парадоксальный клон", en: "Paradox Clone" },
    Rev: { ru: "Революционер", en: "Revolutionary" },
    SpaceNinja: { ru: "Космический ниндзя", en: "Space Ninja" },
    SubvertedSilicon: { ru: "Взломанный киборг", en: "Subverted Silicon" },
    Survivor: { ru: "Выживший", en: "Survivor" },
    Thief: { ru: "Вор", en: "Thief" },
    Traitor: { ru: "Предатель", en: "Traitor" },
    TraitorSleeper: { ru: "Спящий агент Синдиката", en: "Syndicate Sleeper Agent" },
    Wizard: { ru: "Волшебник", en: "Wizard" },
    Xenoborg: { ru: "Ксеноборг", en: "Xenoborg" },
    Zombie: { ru: "Зомби", en: "Zombie" }
  }
};


/* js/catalogs.js */
const TEXT_BINDING_FIELDS = [
  { id: "characterName", label: { ru: "Имя персонажа", en: "Character name" } },
  { id: "job", label: { ru: "Должность", en: "Job" } },
  { id: "department", label: { ru: "Отдел", en: "Department" } },
  { id: "age", label: { ru: "Возраст", en: "Age" } },
  { id: "species", label: { ru: "Вид", en: "Species" } },
  { id: "sex", label: { ru: "Пол", en: "Sex" } },
  { id: "traits", label: { ru: "Черты", en: "Traits" } },
  { id: "hasMindshield", label: { ru: "Есть защита разума", en: "Has mindshield" } },
  { id: "antagRole", label: { ru: "Роли антагониста", en: "Antag roles" } },
  { id: "antagObjectiveType", label: { ru: "Типы целей антагониста", en: "Antag objective types" } },
  { id: "mindId", label: { ru: "MindId", en: "MindId" } },
  { id: "ownerEntityUid", label: { ru: "Owner entity uid", en: "Owner entity uid" } }
];

const ROUND_TEXT_BINDING_FIELDS = [
  { id: "stationName", label: { ru: "Имя станции", en: "Station name" } },
  { id: "stationTime", label: { ru: "Время станции", en: "Station time" } }
];

const FIELD_DEFINITIONS = {
  round: {
    gameMode: {
      type: "string",
      dictionary: "gameModes",
      label: { ru: "Режим игры", en: "Game mode" }
    },
    stationTime: {
      type: "timespan",
      label: { ru: "Время станции", en: "Station time" }
    },
    crewCount: {
      type: "int",
      min: 0,
      label: { ru: "Число членов экипажа", en: "Crew count" }
    },
    securityCount: {
      type: "int",
      min: 0,
      label: { ru: "Число сотрудников СБ", en: "Security count" }
    },
    eventTags: {
      type: "list-string",
      dictionary: "eventTags",
      label: { ru: "Теги событий", en: "Event tags" }
    },
    "antagSummary.totalCount": {
      type: "int",
      min: 0,
      label: { ru: "Всего антагонистов", en: "Antag total count" }
    },
    "antagSummary.gameModeAntagCount": {
      type: "int",
      min: 0,
      label: { ru: "Антагонисты режима", en: "Game-mode antag count" }
    },
    "antagSummary.ghostRoleAntagCount": {
      type: "int",
      min: 0,
      label: { ru: "Ghost-role антагонисты", en: "Ghost-role antag count" }
    },
    "antagSummary.byRole": {
      type: "map-int",
      min: 0,
      dictionary: "antagRoles",
      keyLabel: { ru: "ID antag role", en: "Antag role id" },
      label: { ru: "Антагонисты по ролям", en: "Antag count by role" }
    },
    "antagSummary.byObjectiveType": {
      type: "map-int",
      min: 0,
      dictionary: "objectiveTypes",
      keyLabel: { ru: "ID objective type", en: "Objective type id" },
      label: { ru: "Антагонисты по типам целей", en: "Antag count by objective type" }
    }
  },
  candidate: {
    job: {
      type: "string",
      dictionary: "jobs",
      label: { ru: "Должность", en: "Job" }
    },
    department: {
      type: "string",
      dictionary: "departments",
      label: { ru: "Отдел", en: "Department" }
    },
    age: {
      type: "int",
      label: { ru: "Возраст", en: "Age" }
    },
    species: {
      type: "string",
      dictionary: "species",
      label: { ru: "Вид", en: "Species" }
    },
    sex: {
      type: "string",
      dictionary: "sex",
      label: { ru: "Пол", en: "Sex" }
    },
    traits: {
      type: "list-string",
      dictionary: "traits",
      label: { ru: "Черты", en: "Traits" }
    },
    hasMindshield: {
      type: "bool",
      label: { ru: "Есть защита разума", en: "Has mindshield" }
    },
    antagRole: {
      type: "list-string",
      dictionary: "antagRoles",
      label: { ru: "Роли антагониста", en: "Antag roles" }
    },
    antagObjectiveType: {
      type: "list-string",
      dictionary: "objectiveTypes",
      label: { ru: "Типы целей антагониста", en: "Antag objective types" }
    }
  }
};

function getCategory(categoryId) {
  return CATEGORY_CATALOG.find(category => category.id === categoryId) ?? null;
}

function getFieldDefinition(scope, field) {
  return FIELD_DEFINITIONS[scope]?.[field] ?? null;
}

function getFieldOptions(scope) {
  return Object.entries(FIELD_DEFINITIONS[scope] ?? {}).map(([id, meta]) => ({
    id,
    ...meta
  }));
}

function getDictionaryValues(dictionaryName) {
  return VALUE_DICTIONARIES[dictionaryName] ?? [];
}

function getDictionaryLabel(dictionaryName, value) {
  if (!value) {
    return "";
  }

  const entry = LOCALIZED_DICTIONARY_LABELS[dictionaryName]?.[value] ?? null;
  return buildDictionaryLabel(value, entry);
}

function getDictionaryOptions(dictionaryName) {
  return getDictionaryValues(dictionaryName).map(value => ({
    id: value,
    label: getDictionaryLabel(dictionaryName, value)
  }));
}

function getAllowedOperators(scope, field, options = {}) {
  const definition = getFieldDefinition(scope, field);
  if (!definition) {
    return [PREDICATE_OPERATORS.equals];
  }

  const operators = [...(OPERATORS_BY_FIELD_TYPE[definition.type] ?? [PREDICATE_OPERATORS.equals])];
  if (scope === PREDICATE_SCOPES.candidate && options.allowCompareOperators !== false) {
    operators.push(PREDICATE_OPERATORS.sameAs, PREDICATE_OPERATORS.notSameAs);
  }

  return operators;
}


/* js/data/ui-strings.js */
const STRINGS = {
  "ru": {
    "appTitle": "IntentionEditor",
    "ui": {
      "eyebrow": "Автономный статический редактор",
      "hero": "Редактор пакета сценария: scenario template, intention templates, slots, predicates и экспорт в YAML + FTL.",
      "reset": "Сбросить черновик",
      "rules": "Быстрые правила",
      "categories": "Категории",
      "locale": "Язык",
      "close": "Закрыть",
      "add": "Добавить",
      "delete": "Удалить",
      "choose": "Выбери",
      "none": "Не использовать",
      "saveHint": "Автосохранение активно. Черновик хранится в localStorage браузера.",
      "statusOk": "Ошибок в черновике не найдено.",
      "statusTitle": "Статус",
      "issuesTitle": "Ошибки валидации",
      "errors": "Ошибки",
      "warnings": "Предупреждения",
      "secondaryTemplates": "Второстепенные намерения",
      "secondarySlots": "Второстепенные слоты",
      "noIssues": "Пока нет ошибок и предупреждений.",
      "emptySection": "Отсутствуют.",
      "modalRulesTitle": "Быстрые правила",
      "modalCategoriesTitle": "Категории сценариев",
      "sections": {
        "scenario": "Шаблон сценария",
        "ownerIntention": "Шаблон основного намерения",
        "secondaryIntentions": "Шаблон намерения (второстепенные слоты)",
        "ownerSlot": "Слот основного намерения (primary)",
        "secondarySlots": "Слоты второстепенных намерений (secondary)",
        "export": "Экспорт"
      },
      "sectionDescriptions": {
        "scenario": "Основные параметры сценария и условия его участия в раунде.",
        "ownerIntention": "Обязательное намерение, которое всегда связано со слотом владельца сценария (owner).",
        "secondaryIntentions": "Переиспользуемая библиотека второстепенных шаблонов намерений.",
        "ownerSlot": "Основной слот владельца сценария (owner)",
        "secondarySlots": "Слева – второстепенные слоты сценария, справа – связанные с ними шаблоны намерений.",
        "export": "Предварительный просмотр и загрузка готовых YAML/FTL-файлов",
        "secondarySlotPair": "Настройка второстепенного слота: повторное использование, условия подбора кандидатов и параметры текста."
      },
      "fields": {
        "scenarioId": "Scenario ID",
        "humanName": "Техническое название",
        "category": "Категория",
        "weight": "Вес",
        "enabled": "Включен",
        "title": "Название",
        "summary": "Краткое описание",
        "description": "Полное описание",
        "oocInfo": "Out Of Character информация",
        "copyableText": "Материалы намерения",
        "hiddenLabel": "Скрытое название",
        "color": "Цвет",
        "author": "Автор",
        "creationDate": "Дата создания",
        "tags": "Тэги",
        "iconSprite": "Ссылка на иконку",
        "iconState": "Состояние иконки",
        "addIcon": "Добавить иконку",
        "templateId": "Template ID",
        "visibility": "Видимость по умолчанию",
        "slotId": "Slot ID",
        "intentionTemplate": "Шаблон намерения",
        "required": "Обязательное",
        "bindToSlot": "Привязать к слоту",
        "allowSameActorAs": "Разрешить совпадение участника",
        "candidatePredicates": "Условия выбора кандидата",
        "globalPredicates": "Глобальные условия",
        "textBindings": "Настройка текстовых параметров",
        "visibilityOverride": "Изменение видимости",
        "reveal": "Раскрыть содержимое",
        "revealMinutes": "Время до показа (мин.)",
        "compareSlot": "Сравнить с другим слотом",
        "parameter": "Параметр",
        "source": "Источник",
        "slot": "Слот",
        "field": "Поле",
        "value": "Значение",
        "values": "Значения",
        "valueFrom": "От",
        "valueTo": "До",
        "key": "Ключ",
        "operator": "Оператор"
      },
      "fieldHints": {
        "scenarioIdTooltip": "Уникальный идентификатор сценария.",
        "scenarioId": "Используйте латинские буквы без пробелов, каждое слово начинайте с большой буквы. Например, SecretMeetingScenario.",
        "humanName": "Название сценария для отображения и отладки.",
        "category": "Категория сценария",
        "weight": "Вес сценария в категории (weight). Чем выше значение, тем чаще сценарий будет выбираться.",
        "title35": "До 35 символов",
        "summary35": "До 35 символов",
        "description2000": "До 2000 символов.",
        "ooc500": "До 500 символов.",
        "copy5000": "До 5000 символов.",
        "hidden45": "До 45 символов.",
        "date": "Формат ГГГГ-ММ-ДД. Например, 2026-12-23",
        "tags": "Укажите через запятую теги, чтобы в дальнейшем упростить поиск сценария по темам, ролям и типам ситуаций.",
        "color": "Формат #RRGGBB или #RRGGBBAA.",
        "templateIdTooltip": "Уникальный идентификатор намерения.",
        "templateId": "Используйте латинские буквы без пробелов, каждое слово начинайте с большой буквы. Например, SecretMeetingIntention.",
        "slotId": "Уникальный идентификатор слота внутри сценария.",
        "author": "Имя автора намерения",
        "parameter": "Имя параметра для подстановки в текст, например partnerName.",
        "source": "Откуда брать значение для параметра:\nself – из текущего участника,\nslot – из другого slot,\nround – из данных раунда,\nliteral – вручную заданный текст.",
        "bindToSlot": "bindToSlot. Выдать это намерение тому же участнику, который уже выбран в другом слоте.",
        "allowSameActorAs": "allowSameActorAs. Разрешить повторное использование участника из указанных слотов (для случайного выбора). По умолчанию каждый участник должен быть уникальным.",
        "globalPredicates": "Условия участия сценария в раунде: режим раунда, время, количество активного экипажа и другие параметры. \nСценарий участвует в распределении только при выполнении всех условий.",
        "candidatePredicates": "Кандидат на слот должен соответствовать всем указанным условиям.",
        "visibilityOverride": "Задает видимость намерения вместо значения по умолчанию.",
        "reveal": "Тип раскрытия скрытого намерения. Сейчас поддерживается без раскрытия (none) или по таймеру (timer).",
        "textBindings": "Параметры для автоматической подстановки значений в текст. В готовом тексте параметр будет заменён на соответствующие данные, например имя персонажа, должность, название станции и другие значения. \nНажмите «Копировать параметр» и вставьте его в нужное текстовое поле шаблона намерения.",
        "defaultVisibility": "Базовая видимость намерения (может быть изменена в сценарии). Чтобы скрыть, выберите hidden.",
        "revealMinutes": "Время в минутах до раскрытия намерения.",
        "categoryTooltip": "Категория определяет правила распределения сценария (на раунд и персонажа) и стандартный внешний вид намерений (иконка и цвет).",
        "enabled": "Если выключено, то сценарий не будет участвовать в автоматическом распределении.",
        "field": "Поле данных, по которому проверяется условие. \nЗначения времени указываются в формате 00:00:00.",
        "operator": "Способ сравнения выбранного поля. \nОператоры sameAs и notSameAs доступны при наличии других слотов.",
        "value": "Одиночное значение для сравнения. ",
        "values": "Список допустимых или запрещённых значений.",
        "valueFrom": "Нижняя граница диапазона.",
        "valueTo": "Верхняя граница диапазона.",
        "compareSlot": "Другой слот, используемый для сравнения с текущим значением.",
        "copyableTextTooltip": "Готовый текстовый материал для сценария, который игрок может скопировать и использовать в отыгрыше. \nНапример, ответ, обращение, петиция, заявление, жалоба, листовка, объявление, письмо, песня, стихотворение, заметка, отчёт и тому подобное.",
        "summaryTooltip": "Короткое описание для компактного отображения на карточке намерения.",
        "oocInfoTooltip": "Пояснение вне роли (OOC): как отыгрывать намерение, какие рамки поведения допустимы и чего следует избегать.",
        "hiddenLabelTooltip": "Название, отображаемое до раскрытия скрытого намерения.",
        "colorTooltip": "Цвет карточки намерения в формате #RRGGBB или #RRGGBBAA.",
        "iconSprite": "Путь до RSI-файла иконки.",
        "iconState": "Состояние внутри RSI-файла иконки.",
        "required": "Сценарий собирается только при заполнении всех обязательных слотов. Если это невозможно, сценарий пропускается.",
        "slot": "Слот, из которого брать значение параметра.",
        "key": "Ключ map-поля, используемый для проверки условия."
      },
      "buttons": {
        "addSecondaryTemplate": "Добавить",
        "addGlobalPredicate": "Добавить",
        "addSecondarySlot": "Добавить",
        "addCandidatePredicate": "Добавить",
        "addBinding": "Добавить",
        "downloadScenario": "Скачать шаблон сценария YAML",
        "downloadIntentions": "Скачать шаблон намерения YAML",
        "downloadFtl": "Скачать текстовый контент FTL",
        "copyScenario": "Копировать шаблон сценария YAML",
        "copyIntentions": "Копировать шаблон намерения YAML",
        "copyFtl": "Копировать текстовый контент FTL"
      },
      "placeholders": {
        "scenarioId": "ScenarioExampleNew",
        "scenarioName": "Имя сценария",
        "templateId": "IntentionExampleNew",
        "tags": "traitor, bureaucracy, positive, command",
        "color": "#AABBCCFF",
        "iconSprite": "/Textures/Interface/Misc/job_icons.rsi",
        "iconState": "Passenger",
        "bindingParam": "newParameter",
        "literal": "Статический текст",
        "addValue": "Добавить значение",
        "selectTemplate": "Выбери шаблон",
        "selectSlot": "Выбери слот",
        "selectValue": "Выбери значение",
        "searchValue": "Поиск значения"
      },
      "select": {
        "noBind": "Не использовать bind",
        "none": "—",
        "clearValue": "Очистить выбор",
        "noMatches": "Нет совпадений"
      },
      "searchValueAria": "Поиск по значениям словаря",
      "export": {
        "blocked": "Сначала исправь ошибки валидации. Экспорт заблокирован.",
        "copied": "Содержимое {filename} скопировано в буфер.",
        "copyFailed": "Не удалось записать в буфер обмена в этом браузере.",
        "downloaded": "Скачан файл {filename}.",
        "slotBuildOrder": "Вычисляемый порядок сборки слотов",
        "generatedLocKeys": "Ключи локализации (сгенерированные)",
        "derivedCrew": "Минимальный экипаж (вычисляется автоматически)",
        "syntheticCrewAdded": "В экспорт автоматически добавляется условие crewCount.",
        "syntheticCrewSkipped": "Предикат crewCount не требуется: заданное правило уже обеспечивает нужную строгость."
      },
      "import": {
        "title": "Импорт YAML/FTL",
        "openButton": "Импорт",
        "description": "Вставьте scenarioTemplate YAML, intentionTemplate YAML и FTL. Черновик заменится только если импорт и валидация пройдут без ошибок.",
        "scenarioYaml": "Scenario YAML",
        "intentionsYaml": "Intentions YAML",
        "ftl": "FTL",
        "button": "Проверить и импортировать",
        "clear": "Очистить",
        "resultOk": "Импорт выполнен",
        "resultError": "Импорт не выполнен",
        "success": "Сценарий импортирован в редактор.",
        "scenarioPlaceholder": "- type: scenarioTemplate\n  id: ScenarioExample",
        "intentionsPlaceholder": "- type: intentionTemplate\n  id: IntentionExampleOwner",
        "ftlPlaceholder": "intentions-example-name = Название"
      },
      "kinds": {
        "ownerDescription": "Всегда связан со слотом владельца сценария (owner).",
        "secondaryDescription": "Можно переиспользовать в нескольких второстепенных слотах."
      },
      "ruleModal": [
        "Owner slot всегда один и всегда primary + required.",
        "bindToSlot и allowSameActorAs нельзя включать вместе.",
        "У bound slot не должно быть candidate predicates.",
        "sameAs / notSameAs собираются только через compareTo slot.",
        "Export генерирует контент-файлы и derived crewCount predicate, но не моделирует игровые квоты."
      ],
      "theme": "Тема",
      "themes": {
        "light": "Светлая",
        "dark": "Тёмная"
      },
      "untitledDraft": "Новый сценарий",
      "scenarioCommon": "Общие данные сценария",
      "visibilityAndReveal": "Видимость и раскрытие",
      "validationExportTitle": "Валидация, ошибки, статус и экспорт",
      "validationExportDescription": "Сводка проверки сценария.",
      "noSecondaryPairs": "Второстепенных слотов пока нет. Добавьте слот, чтобы создать связанную форму намерения.",
      "confirmDeleteSlot": "Удалить второстепенный слот вместе со связанным намерением?",
      "intentionTabs": "Вкладки намерений",
      "intentionTabOne": "Вкладка 1",
      "intentionTabsFuture": "+ (на будущее)",
      "textParameterTitle": "Текстовый параметр {index}",
      "copyPaste": {
        "copy": "Копировать контент",
        "paste": "Вставить контент",
        "copied": "Контент намерения скопирован.",
        "pasted": "Контент намерения вставлен.",
        "copyBindingToken": "Копировать параметр",
        "bindingTokenCopied": "FTL-подстановка {token} скопирована.",
        "bindingTokenEmpty": "Сначала заполните имя параметра."
      }
    },
    "issues": {
      "required": "{label} обязательно.",
      "lengthLimit": "{label} должно быть не длиннее {max} символов.",
      "unknownReference": "Значение \"{value}\" не найдено во встроенных подсказках редактора для поля {field}.",
      "conflictingPredicateValues": "Формы value / values / range / compareTo взаимно исключаются.",
      "missingPredicateValue": "Для выбранного оператора нужно значение.",
      "missingPredicateValues": "Для выбранного оператора нужен непустой список значений.",
      "missingPredicateRange": "Оператор between требует valueFrom и valueTo.",
      "missingCompareTo": "sameAs / notSameAs требуют compareTo.",
      "operatorFieldMismatchList": "contains / notContains работают только с list<string>.",
      "operatorFieldMismatchCompare": "Сравнение требует numeric / timespan / map-int поле.",
      "invalidPredicateValueType": "Тип значения не совпадает с типом выбранного поля.",
      "predicateMinValue": "Значение должно быть не меньше {min}.",
      "unexpectedCompareTo": "compareTo допустим только для sameAs / notSameAs.",
      "compareOutsideCandidate": "compareTo допустим только в candidate predicates.",
      "invalidCompareScope": "compareTo.scope должен быть slot.",
      "missingCompareSlot": "compareTo.slotId должен ссылаться на существующий slotId.",
      "compareFieldMismatch": "compareTo.field должен совпадать с field predicate.",
      "ownerSelfCompare": "Owner slot с compareTo почти наверняка сломает slotBuildOrder.",
      "invalidScope": "Ожидался scope={scope}.",
      "unknownField": "Неизвестное поле predicate.",
      "invalidOperator": "Оператор не поддерживается для выбранного поля.",
      "missingMapKey": "Для map-int поля нужен key.",
      "unexpectedMapKey": "key допустим только для map-int полей.",
      "missingBindingParameter": "У textParameterBinding должен быть параметр.",
      "invalidSelfBindingField": "Self binding использует неподдерживаемое поле.",
      "invalidTextBindingSlot": "Slot binding должен ссылаться на существующий slot.",
      "invalidSlotBindingField": "Slot binding использует неподдерживаемое поле.",
      "invalidRoundBinding": "Round binding поддерживает только stationName и stationTime.",
      "missingLiteralBinding": "Literal binding требует value.",
      "invalidTextBindingSource": "Источник binding должен быть self, slot, round или literal.",
      "invalidVisibilityType": "visibilityOverride.type должен быть visible или hidden.",
      "visibleWithReveal": "visible override не может иметь reveal.",
      "invalidRevealType": "reveal.type должен быть none или timer.",
      "invalidRevealMinutes": "timer reveal требует minutes > 0.",
      "unusedRevealMinutes": "minutes не используются, пока reveal.type = none.",
      "missingId": "{kind}: нужен id.",
      "invalidKind": "kind должен быть primary или secondary.",
      "invalidDefaultVisibility": "defaultVisibility должен быть visible или hidden.",
      "invalidColor": "Color должен быть в формате #RRGGBB или #RRGGBBAA.",
      "invalidCreationDate": "creationDate должен быть в формате YYYY-MM-DD.",
      "missingIconSprite": "Для icon нужен sprite.",
      "missingIconState": "Для icon нужен state.",
      "missingHiddenLabel": "Для hidden intention обычно стоит задать hiddenLabel.",
      "missingScenarioId": "Scenario id обязателен.",
      "missingScenarioName": "Scenario name обязателен.",
      "missingScenarioCategory": "Категория обязательна.",
      "categoryNotInCatalog": "Категория не найдена во встроенном каталоге редактора.",
      "invalidWeight": "Weight должен быть целым числом больше 0.",
      "duplicateIntentionId": "Intention id \"{id}\" должен быть уникальным внутри пакета.",
      "duplicateSlotId": "SlotId \"{id}\" должен быть уникальным.",
      "ownerSlotId": "Owner slot должен иметь slotId = owner.",
      "ownerSlotKind": "Owner slot должен быть primary.",
      "ownerSlotRequired": "Owner slot должен иметь required = true.",
      "ownerIntentionLink": "Owner slot должен ссылаться на owner intention template.",
      "missingSlotId": "SlotId обязателен.",
      "invalidSlotKind": "kind slot должен быть primary или secondary.",
      "missingIntentionReference": "Slot должен ссылаться на существующий intention template.",
      "kindMismatch": "kind slot должен совпадать с kind intention template.",
      "bindAndAllowSameActor": "bindToSlot и allowSameActorAs нельзя использовать вместе.",
      "missingBoundSlot": "bindToSlot должен ссылаться на существующий slot.",
      "selfBind": "bindToSlot не может ссылаться на текущий slot.",
      "boundSlotHasPredicates": "У bindToSlot-слота не должно быть candidatePredicates.",
      "selfAllowSameActor": "allowSameActorAs не может ссылаться на текущий slot.",
      "duplicateAllowSameActor": "allowSameActorAs не должен содержать дубликаты.",
      "missingAllowSameActorSlot": "allowSameActorAs должен ссылаться на существующие slot-ы.",
      "duplicateBindingParameter": "Имена textParameterBindings должны быть уникальны внутри slot.",
      "ownerHasDependencies": "Owner slot не должен зависеть от других slot-ов.",
      "slotDependencyCycle": "Граф зависимостей slot-ов содержит цикл.",
      "ownerNotFirst": "Owner slot должен быть первым в slotBuildOrder."
    },
    "operators": {
      "equals": "equals · равно",
      "notEquals": "notEquals · не равно",
      "in": "in · входит в список",
      "notIn": "notIn · не входит в список",
      "contains": "contains · содержит",
      "notContains": "notContains · не содержит",
      ">": "> · больше",
      ">=": ">= · больше либо равно",
      "<": "< · меньше",
      "<=": "<= · меньше либо равно",
      "between": "between · в диапазоне",
      "sameAs": "sameAs · как у другого слота",
      "notSameAs": "notSameAs · не как у другого слота"
    },
    "severity": {
      "error": "Ошибка",
      "warning": "Предупреждение",
      "ok": "OK"
    }
  },
  "en": {
    "appTitle": "IntentionEditor",
    "ui": {
      "eyebrow": "Standalone static editor",
      "hero": "Scenario package editor: scenario template, intention templates, slots, predicates, and YAML + FTL export.",
      "reset": "Reset draft",
      "rules": "Quick rules",
      "categories": "Categories",
      "locale": "Language",
      "theme": "Theme",
      "themes": {
        "light": "Light",
        "dark": "Dark"
      },
      "close": "Close",
      "add": "Add",
      "delete": "Delete",
      "choose": "Choose",
      "none": "None",
      "untitledDraft": "New scenario",
      "scenarioCommon": "Scenario common data",
      "visibilityAndReveal": "Visibility and reveal",
      "validationExportTitle": "Validation, issues, status, and export",
      "validationExportDescription": "Validation summary and generated YAML/FTL artifacts live at the bottom of the editor.",
      "noSecondaryPairs": "There are no secondary slots yet. Add a slot to create its linked intention form.",
      "confirmDeleteSlot": "Delete this secondary slot together with its linked intention?",
      "intentionTabs": "Intention tabs",
      "intentionTabOne": "Intention 1",
      "intentionTabsFuture": "+ tab later",
      "textParameterTitle": "Text parameter {index}",
      "copyPaste": {
        "copy": "Copy content",
        "paste": "Paste content",
        "copied": "Intention content copied.",
        "pasted": "Intention content pasted.",
        "copyBindingToken": "Copy FTL",
        "bindingTokenCopied": "FTL token {token} copied.",
        "bindingTokenEmpty": "Fill in the parameter name first."
      },
      "saveHint": "Autosave is on. The draft is stored in browser localStorage.",
      "statusOk": "The draft currently passes built-in validation.",
      "statusTitle": "Status",
      "issuesTitle": "Validation issues",
      "errors": "Errors",
      "warnings": "Warnings",
      "secondaryTemplates": "Secondary templates",
      "secondarySlots": "Secondary slots",
      "noIssues": "No errors or warnings right now.",
      "emptySection": "None.",
      "modalRulesTitle": "Quick rules",
      "modalCategoriesTitle": "Scenario categories",
      "sections": {
        "scenario": "Scenario template",
        "ownerIntention": "Owner intention template",
        "secondaryIntentions": "Secondary intention templates",
        "ownerSlot": "Owner slot",
        "secondarySlots": "Secondary slots",
        "export": "Export"
      },
      "sectionDescriptions": {
        "scenario": "Scenario metadata and round-level global predicates.",
        "ownerIntention": "The primary intention template always linked to the owner slot.",
        "secondaryIntentions": "Reusable library of secondary intention templates.",
        "ownerSlot": "Built-in primary slot for the scenario owner.",
        "secondarySlots": "Scenario structure: slots on the left and linked intention templates on the right.",
        "secondarySlotPair": "Secondary slot settings: candidate rules, links, and text parameters. The linked intention is edited on the right.",
        "export": "Preview and download the generated YAML/FTL artifacts."
      },
      "fields": {
        "scenarioId": "Scenario id",
        "humanName": "Human name",
        "category": "Category",
        "weight": "Weight",
        "enabled": "Enabled",
        "title": "Title",
        "summary": "Summary",
        "description": "Description",
        "oocInfo": "OOC note",
        "copyableText": "Copyable text",
        "hiddenLabel": "Hidden label",
        "color": "Color",
        "author": "Author",
        "creationDate": "Creation date",
        "tags": "Tags",
        "iconSprite": "Icon sprite",
        "iconState": "Icon state",
        "addIcon": "Enable icon",
        "templateId": "Template id",
        "visibility": "Visibility",
        "slotId": "slotId",
        "intentionTemplate": "Intention template",
        "required": "Required",
        "bindToSlot": "bindToSlot",
        "allowSameActorAs": "allowSameActorAs",
        "candidatePredicates": "Candidate predicates",
        "globalPredicates": "Global predicates",
        "textBindings": "Text parameter bindings",
        "visibilityOverride": "Visibility override",
        "reveal": "Reveal",
        "revealMinutes": "Reveal minutes",
        "compareSlot": "Compare slot",
        "parameter": "Parameter",
        "source": "Source",
        "slot": "Slot",
        "field": "Field",
        "value": "Value",
        "values": "Values",
        "valueFrom": "From",
        "valueTo": "To",
        "key": "Key",
        "operator": "Operator"
      },
      "fieldHints": {
        "scenarioIdTooltip": "Unique scenario identifier.",
        "scenarioId": "Unique scenario prototype id. ASCII-style PascalCase is recommended.",
        "humanName": "Human-readable scenario name for tooling and debug output.",
        "category": "Category from requirements. The YAML export uses the category id.",
        "weight": "Integer greater than 0. Higher weight means more likely selection.",
        "title35": "Up to 35 characters in the final localized string.",
        "summary35": "Up to 35 characters in the final localized string.",
        "description2000": "Up to 2000 characters.",
        "ooc500": "Up to 500 characters.",
        "copy5000": "Up to 5000 characters.",
        "hidden45": "Up to 45 characters.",
        "date": "Format: YYYY-MM-DD.",
        "tags": "Comma-separated. A trailing comma is allowed and will be cleaned during export.",
        "color": "Format: #RRGGBB or #RRGGBBAA.",
        "templateIdTooltip": "Unique intention identifier.",
        "templateId": "Use ASCII letters without spaces; start each word with a capital letter: SecretMeetingIntention.",
        "slotId": "Unique slot id within the scenario.",
        "author": "Short author label if you want it on the card.",
        "parameter": "FTL parameter name, for example partnerName.",
        "source": "Where the parameter value comes from:\nself - current participant,\nslot - another slot,\nround - round data,\nliteral - manually entered text.",
        "bindToSlot": "Assign this intention to the same participant already selected in another slot.",
        "allowSameActorAs": "Allow reusing the participant from selected slots, without forcing it.",
        "globalPredicates": "Round-wide checks. They only use round fields from the snapshot.",
        "candidatePredicates": "Per-participant checks. They only use candidate fields.",
        "visibilityOverride": "Overrides card visibility on top of the template defaultVisibility.",
        "reveal": "Automatic reveal for hidden intentions. Supported modes: none and timer.",
        "textBindings": "Values resolved once at commit time and injected into FTL.",
        "defaultVisibility": "Base card visibility before any slot override.",
        "revealMinutes": "Minimum 1 minute. Active only for hidden + timer.",
        "categoryTooltip": "Choose the scenario category; only its id is exported.",
        "enabled": "If disabled, the scenario remains in the file but should not be picked by normal distribution.",
        "field": "Snapshot or candidate field checked by this predicate.",
        "operator": "How the selected field is compared.",
        "value": "Single comparison value.",
        "values": "List of allowed or rejected values.",
        "valueFrom": "Lower range bound.",
        "valueTo": "Upper range bound.",
        "compareSlot": "Another slot used for sameAs / notSameAs comparison.",
        "copyableTextTooltip": "Material the player can copy from the intention card.",
        "summaryTooltip": "Short summary line for compact card display.",
        "oocInfoTooltip": "OOC note for tone, limits, or safety context.",
        "hiddenLabelTooltip": "Safe label shown before a hidden intention is revealed.",
        "colorTooltip": "Card color in #RRGGBB or #RRGGBBAA format.",
        "iconSprite": "Path to the icon RSI file.",
        "iconState": "State inside the icon RSI file.",
        "required": "A required slot must receive a participant during scenario build.",
        "slot": "Slot used as the text parameter source.",
        "key": "Map key when the predicate targets a map-int field."
      },
      "buttons": {
        "addSecondaryTemplate": "Add secondary template",
        "addGlobalPredicate": "Add predicate",
        "addSecondarySlot": "Add secondary slot",
        "addCandidatePredicate": "Add predicate",
        "addBinding": "Add binding",
        "downloadScenario": "Download scenario YAML",
        "downloadIntentions": "Download intention YAML",
        "downloadFtl": "Download FTL",
        "copyScenario": "Copy scenario YAML",
        "copyIntentions": "Copy intention YAML",
        "copyFtl": "Copy FTL"
      },
      "placeholders": {
        "scenarioId": "ScenarioCardDebt",
        "scenarioName": "Card debt",
        "templateId": "IntentionExamplePrimary",
        "tags": "traitor, bureaucracy, positive, command",
        "color": "#AABBCCFF",
        "iconSprite": "/Textures/Interface/Misc/job_icons.rsi",
        "iconState": "Passenger",
        "bindingParam": "For example, partnerName",
        "literal": "Literal text",
        "addValue": "Add value",
        "selectTemplate": "Choose template",
        "selectSlot": "Choose slot",
        "selectValue": "Choose value",
        "searchValue": "Search value"
      },
      "select": {
        "noBind": "No bind",
        "none": "—",
        "clearValue": "Clear selection",
        "noMatches": "No matches found"
      },
      "searchValueAria": "Search dictionary values",
      "export": {
        "blocked": "Fix validation errors first. Export is blocked.",
        "copied": "{filename} was copied to the clipboard.",
        "copyFailed": "Could not write to the clipboard in this browser.",
        "downloaded": "Downloaded {filename}.",
        "slotBuildOrder": "Derived slotBuildOrder",
        "generatedLocKeys": "Generated loc keys",
        "derivedCrew": "Derived minimum crew",
        "syntheticCrewAdded": "A synthetic crewCount predicate will be added to export.",
        "syntheticCrewSkipped": "No synthetic crewCount predicate is needed because an authored rule is already strict enough."
      },
      "import": {
        "title": "Import YAML/FTL",
        "openButton": "Import",
        "description": "Paste scenarioTemplate YAML, intentionTemplate YAML, and FTL. The current draft is replaced only after import and validation pass.",
        "scenarioYaml": "Scenario YAML",
        "intentionsYaml": "Intentions YAML",
        "ftl": "FTL",
        "button": "Validate and import",
        "clear": "Clear",
        "resultOk": "Import complete",
        "resultError": "Import failed",
        "success": "Scenario imported into the editor.",
        "scenarioPlaceholder": "- type: scenarioTemplate\n  id: ScenarioExample",
        "intentionsPlaceholder": "- type: intentionTemplate\n  id: IntentionExampleOwner",
        "ftlPlaceholder": "intentions-example-name = Name"
      },
      "kinds": {
        "ownerDescription": "Always linked to the owner slot.",
        "secondaryDescription": "Can be reused by multiple secondary slots."
      },
      "ruleModal": [
        "There is always exactly one owner slot, and it is always primary + required.",
        "bindToSlot and allowSameActorAs cannot be enabled together.",
        "A bound slot must not define candidate predicates.",
        "sameAs / notSameAs are created only through compareTo slot UI.",
        "Export generates content files and the derived crewCount predicate, but does not simulate runtime quotas."
      ]
    },
    "issues": {
      "required": "{label} is required.",
      "lengthLimit": "{label} must be at most {max} characters.",
      "unknownReference": "Value \"{value}\" is not present in the built-in suggestions for field {field}.",
      "conflictingPredicateValues": "value / values / range / compareTo are mutually exclusive.",
      "missingPredicateValue": "This operator requires a value.",
      "missingPredicateValues": "This operator requires a non-empty values list.",
      "missingPredicateRange": "between requires both valueFrom and valueTo.",
      "missingCompareTo": "sameAs / notSameAs require compareTo.",
      "operatorFieldMismatchList": "contains / notContains only work with list<string> fields.",
      "operatorFieldMismatchCompare": "Comparison operators require a numeric, timespan, or map-int field.",
      "invalidPredicateValueType": "The provided value does not match the selected field type.",
      "predicateMinValue": "The value must be at least {min}.",
      "unexpectedCompareTo": "compareTo is only allowed for sameAs / notSameAs.",
      "compareOutsideCandidate": "compareTo is only allowed in candidate predicates.",
      "invalidCompareScope": "compareTo.scope must be slot.",
      "missingCompareSlot": "compareTo.slotId must reference an existing slotId.",
      "compareFieldMismatch": "compareTo.field must match the predicate field.",
      "ownerSelfCompare": "A compareTo on the owner slot will likely break slotBuildOrder.",
      "invalidScope": "Expected scope={scope}.",
      "unknownField": "Unknown predicate field.",
      "invalidOperator": "This operator is not supported for the selected field.",
      "missingMapKey": "This map-int field requires a key.",
      "unexpectedMapKey": "key is only allowed for map-int fields.",
      "missingBindingParameter": "This textParameterBinding must have a parameter name.",
      "invalidSelfBindingField": "Self binding uses an unsupported field.",
      "invalidTextBindingSlot": "Slot binding must reference an existing slot.",
      "invalidSlotBindingField": "Slot binding uses an unsupported field.",
      "invalidRoundBinding": "Round binding only supports stationName and stationTime.",
      "missingLiteralBinding": "Literal binding requires a value.",
      "invalidTextBindingSource": "Binding source must be self, slot, round, or literal.",
      "invalidVisibilityType": "visibilityOverride.type must be visible or hidden.",
      "visibleWithReveal": "A visible override cannot define reveal.",
      "invalidRevealType": "reveal.type must be none or timer.",
      "invalidRevealMinutes": "A timer reveal requires minutes > 0.",
      "unusedRevealMinutes": "minutes are unused while reveal.type = none.",
      "missingId": "{kind}: id is required.",
      "invalidKind": "kind must be primary or secondary.",
      "invalidDefaultVisibility": "defaultVisibility must be visible or hidden.",
      "invalidColor": "Color must use #RRGGBB or #RRGGBBAA.",
      "invalidCreationDate": "creationDate must use YYYY-MM-DD.",
      "missingIconSprite": "Icon sprite is required when icon is enabled.",
      "missingIconState": "Icon state is required when icon is enabled.",
      "missingHiddenLabel": "A hidden intention should usually define hiddenLabel.",
      "missingScenarioId": "Scenario id is required.",
      "missingScenarioName": "Scenario name is required.",
      "missingScenarioCategory": "Category is required.",
      "categoryNotInCatalog": "The category is not present in the editor catalog.",
      "invalidWeight": "Weight must be an integer greater than 0.",
      "duplicateIntentionId": "Intention id \"{id}\" must be unique inside the package.",
      "duplicateSlotId": "SlotId \"{id}\" must be unique.",
      "ownerSlotId": "The owner slot must use slotId = owner.",
      "ownerSlotKind": "The owner slot must be primary.",
      "ownerSlotRequired": "The owner slot must have required = true.",
      "ownerIntentionLink": "The owner slot must reference the owner intention template.",
      "missingSlotId": "slotId is required.",
      "invalidSlotKind": "Slot kind must be primary or secondary.",
      "missingIntentionReference": "The slot must reference an existing intention template.",
      "kindMismatch": "The slot kind must match the intention template kind.",
      "bindAndAllowSameActor": "bindToSlot and allowSameActorAs cannot be used together.",
      "missingBoundSlot": "bindToSlot must reference an existing slot.",
      "selfBind": "bindToSlot cannot point to the current slot.",
      "boundSlotHasPredicates": "A bound slot must not define candidatePredicates.",
      "selfAllowSameActor": "allowSameActorAs cannot reference the current slot.",
      "duplicateAllowSameActor": "allowSameActorAs must not contain duplicates.",
      "missingAllowSameActorSlot": "allowSameActorAs must reference existing slots.",
      "duplicateBindingParameter": "textParameterBinding names must be unique inside the slot.",
      "ownerHasDependencies": "The owner slot must not depend on other slots.",
      "slotDependencyCycle": "The slot dependency graph contains a cycle.",
      "ownerNotFirst": "The owner slot must be first in slotBuildOrder."
    },
    "operators": {
      "equals": "equals · matches value",
      "notEquals": "notEquals · differs from value",
      "in": "in · is one of",
      "notIn": "notIn · is not one of",
      "contains": "contains · list contains",
      "notContains": "notContains · list does not contain",
      ">": "> · greater than",
      ">=": ">= · greater or equal",
      "<": "< · less than",
      "<=": "<= · less or equal",
      "between": "between · inside range",
      "sameAs": "sameAs · same as another slot",
      "notSameAs": "notSameAs · different from another slot"
    },
    "severity": {
      "error": "Error",
      "warning": "Warning",
      "ok": "OK"
    }
  }
};


/* js/i18n.js */
const SUPPORTED_LOCALES = ["ru", "en"];
const DEFAULT_LOCALE = "ru";

function lookup(locale, key) {
  return key.split(".").reduce((current, part) => current?.[part], STRINGS[locale]);
}

function normalizeLocale(locale) {
  return SUPPORTED_LOCALES.includes(locale) ? locale : DEFAULT_LOCALE;
}

function getLocaleLabel(locale) {
  return locale === "ru" ? "\u0420\u0443\u0441\u0441\u043a\u0438\u0439" : "English";
}

function t(locale, key, params = {}) {
  const safeLocale = normalizeLocale(locale);
  let message = lookup(safeLocale, key) ?? lookup(DEFAULT_LOCALE, key) ?? key;
  if (typeof message !== "string") {
    return message;
  }

  return message.replace(/\{(\w+)\}/g, (_, token) => `${params[token] ?? ""}`);
}

function getLocalizedText(locale, value) {
  if (value === null || value === undefined) {
    return "";
  }

  if (typeof value === "string") {
    return value;
  }

  const safeLocale = normalizeLocale(locale);
  return value[safeLocale] ?? value[DEFAULT_LOCALE] ?? "";
}


/* js/utils.js */
function nextUid(prefix = "uid") {
  nextUid.counter = (nextUid.counter ?? 0) + 1;
  return `${prefix}-${nextUid.counter}`;
}

function deepClone(value) {
  return JSON.parse(JSON.stringify(value));
}

function todayIsoDate() {
  const now = new Date();
  const year = now.getFullYear();
  const month = `${now.getMonth() + 1}`.padStart(2, "0");
  const day = `${now.getDate()}`.padStart(2, "0");
  return `${year}-${month}-${day}`;
}

function slugifyIdentifier(value) {
  return `${value ?? ""}`
    .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
    .replace(/[^A-Za-z0-9]+/g, "-")
    .replace(/^-+|-+$/g, "")
    .replace(/-{2,}/g, "-")
    .toLowerCase();
}

function escapeHtml(value) {
  return `${value ?? ""}`
    .replace(/&/g, "&amp;")
    .replace(/</g, "&lt;")
    .replace(/>/g, "&gt;")
    .replace(/"/g, "&quot;")
    .replace(/'/g, "&#39;");
}

function nonEmpty(value) {
  return `${value ?? ""}`.trim();
}

function formatCount(value, singular, plural = `${singular}s`) {
  return `${value} ${value === 1 ? singular : plural}`;
}

function isIsoDate(value) {
  if (!/^\d{4}-\d{2}-\d{2}$/.test(`${value ?? ""}`)) {
    return false;
  }

  const [year, month, day] = `${value}`.split("-").map(Number);
  const date = new Date(Date.UTC(year, month - 1, day));
  return date.getUTCFullYear() === year
    && date.getUTCMonth() === month - 1
    && date.getUTCDate() === day;
}

function isHexColor(value) {
  return /^#[0-9A-Fa-f]{6}([0-9A-Fa-f]{2})?$/.test(`${value ?? ""}`.trim());
}

function isIntString(value) {
  return /^-?\d+$/.test(`${value ?? ""}`.trim());
}

function isFloatString(value) {
  return /^-?\d+(\.\d+)?$/.test(`${value ?? ""}`.trim());
}

function isBooleanString(value) {
  return /^(true|false)$/i.test(`${value ?? ""}`.trim());
}

function isTimeSpanString(value) {
  return /^\d{1,2}:\d{2}:\d{2}$/.test(`${value ?? ""}`.trim());
}

function fileSafeName(value, fallback = "intentions-package") {
  const slug = slugifyIdentifier(value);
  return slug.length > 0 ? slug : fallback;
}

function splitTagsInput(text) {
  return `${text ?? ""}`
    .split(",")
    .map(tag => tag.trim())
    .filter(tag => tag.length > 0);
}

function tagsToInput(tags) {
  return (Array.isArray(tags) ? tags : []).join(", ");
}

function ensureTagsBuffer(intention) {
  const raw = intention.tagsInput ?? tagsToInput(intention.tags ?? []);
  return {
    ...intention,
    tagsInput: raw,
    tags: splitTagsInput(raw)
  };
}

function normalizeTagsOnBlur(intention) {
  const tags = splitTagsInput(intention.tagsInput ?? intention.tags ?? []);
  intention.tags = tags;
  intention.tagsInput = tagsToInput(tags);
}

function sortStrings(values, locale = "ru") {
  return [...values].sort((left, right) => left.localeCompare(right, locale));
}


/* js/draft.js */
function localizedSeed(locale) {
  if (locale === "en") {
    return {
      scenarioName: "New scenario",
      ownerName: "Primary intention",
      ownerDescription: "Briefly describe the scene or initiative launched by the scenario owner.",
      oocInfo: "This is a roleplay prompt, not a mandatory objective."
    };
  }

  return {
    scenarioName: "Новый сценарий",
    ownerName: "Основное намерение",
    ownerDescription: "Опишите сцену, ситуацию или инициативу, вокруг которой строится сценарий.",
    oocInfo: "Это ролевой ориентир для отыгрыша, а не обязательная задача. Другие игроки не обязаны вам подыгрывать. Соблюдайте правила сервера."
  };
}

function createPredicate(scope) {
  return {
    uid: nextUid("predicate"),
    scope,
    field: scope === "round" ? "crewCount" : "job",
    operator: "equals",
    value: "",
    values: [],
    valueFrom: "",
    valueTo: "",
    key: "",
    compareTo: null
  };
}

function createTextBinding() {
  return {
    uid: nextUid("binding"),
    parameter: "",
    source: TEXT_BINDING_SOURCES.self,
    slotId: "",
    field: "characterName",
    value: ""
  };
}

function createOwnerIntention(locale = "ru") {
  const seed = localizedSeed(locale);
  return ensureTagsBuffer({
    uid: nextUid("intention"),
    id: "IntentionNewOwner",
    kind: INTENTION_KINDS.primary,
    name: seed.ownerName,
    summary: "",
    description: seed.ownerDescription,
    oocInfo: seed.oocInfo,
    copyableText: "",
    defaultVisibility: VISIBILITY_TYPES.visible,
    hiddenLabel: "",
    tags: ["starter"],
    tagsInput: "",
    iconEnabled: false,
    iconSprite: "",
    iconState: "",
    color: "",
    author: "",
    creationDate: todayIsoDate()
  });
}

function createSecondaryIntention(locale = "ru") {
  const seed = localizedSeed(locale);
  return ensureTagsBuffer({
    uid: nextUid("intention"),
    id: "IntentionNewSecondary",
    kind: INTENTION_KINDS.secondary,
    name: "",
    summary: "",
    description: "",
    oocInfo: seed.oocInfo,
    copyableText: "",
    defaultVisibility: VISIBILITY_TYPES.visible,
    hiddenLabel: "",
    tags: [],
    tagsInput: "",
    iconEnabled: false,
    iconSprite: "",
    iconState: "",
    color: "",
    author: "",
    creationDate: todayIsoDate()
  });
}

function createOwnerSlot() {
  return {
    uid: nextUid("slot"),
    slotId: "owner",
    kind: INTENTION_KINDS.primary,
    intentionId: "IntentionNewOwner",
    required: true,
    candidatePredicates: [],
    bindToSlot: "",
    allowSameActorAs: [],
    textParameterBindings: [],
    visibilityEnabled: false,
    visibilityType: VISIBILITY_TYPES.visible,
    revealType: REVEAL_TYPES.none,
    revealMinutes: 15
  };
}

function createSecondarySlot(linkedIntentionUid = "") {
  return {
    uid: nextUid("slot"),
    slotId: "",
    kind: INTENTION_KINDS.secondary,
    intentionId: "",
    linkedIntentionUid,
    required: true,
    candidatePredicates: [],
    bindToSlot: "",
    allowSameActorAs: [],
    textParameterBindings: [],
    visibilityEnabled: false,
    visibilityType: VISIBILITY_TYPES.hidden,
    revealType: REVEAL_TYPES.none,
    revealMinutes: 15
  };
}

function createEmptyDraft(locale = "ru") {
  const seed = localizedSeed(locale);
  const ownerIntention = createOwnerIntention(locale);
  const ownerSlot = createOwnerSlot();
  ownerSlot.intentionId = ownerIntention.id;

  return {
    scenario: {
      id: "ScenarioNew",
      name: seed.scenarioName,
      category: "social",
      enabled: true,
      weight: 1
    },
    ownerIntention,
    secondaryIntentions: [],
    ownerSlot,
    secondarySlots: [],
    globalPredicates: [],
    lastUpdatedAt: new Date().toISOString()
  };
}

function normalizeDraft(rawDraft, locale = "ru") {
  const base = createEmptyDraft(locale);
  if (!rawDraft || typeof rawDraft !== "object") {
    return base;
  }

  const draft = deepClone(base);
  draft.scenario = { ...draft.scenario, ...(rawDraft.scenario ?? {}) };
  draft.ownerIntention = ensureTagsBuffer({
    ...draft.ownerIntention,
    ...(rawDraft.ownerIntention ?? {}),
    kind: INTENTION_KINDS.primary
  });
  draft.ownerSlot = { ...draft.ownerSlot, ...(rawDraft.ownerSlot ?? {}) };
  draft.ownerSlot.slotId = "owner";
  draft.ownerSlot.kind = INTENTION_KINDS.primary;
  draft.ownerSlot.required = true;
  draft.ownerSlot.intentionId = draft.ownerIntention.id;
  draft.ownerSlot.candidatePredicates = (rawDraft.ownerSlot?.candidatePredicates ?? []).map(predicate => ({
    ...createPredicate("candidate"),
    ...predicate,
    uid: predicate.uid ?? nextUid("predicate"),
    scope: "candidate"
  }));
  draft.ownerSlot.textParameterBindings = (rawDraft.ownerSlot?.textParameterBindings ?? []).map(binding => ({
    ...createTextBinding(),
    ...binding,
    uid: binding.uid ?? nextUid("binding")
  }));

  draft.secondaryIntentions = (rawDraft.secondaryIntentions ?? []).map(intention => ensureTagsBuffer({
    ...createSecondaryIntention(locale),
    ...intention,
    uid: intention.uid ?? nextUid("intention"),
    kind: INTENTION_KINDS.secondary
  }));

  const linkedIntentionUids = new Set();
  draft.secondarySlots = (rawDraft.secondarySlots ?? []).map(slot => ({
    ...createSecondarySlot(),
    ...slot,
    uid: slot.uid ?? nextUid("slot"),
    kind: INTENTION_KINDS.secondary,
    candidatePredicates: (slot.candidatePredicates ?? []).map(predicate => ({
      ...createPredicate("candidate"),
      ...predicate,
      uid: predicate.uid ?? nextUid("predicate"),
      scope: "candidate"
    })),
    textParameterBindings: (slot.textParameterBindings ?? []).map(binding => ({
      ...createTextBinding(),
      ...binding,
      uid: binding.uid ?? nextUid("binding")
    }))
  })).map(slot => {
    let linked = draft.secondaryIntentions.find(intention => intention.uid === slot.linkedIntentionUid) ?? null;
    if (!linked && slot.intentionId) {
      linked = draft.secondaryIntentions.find(intention => intention.id === slot.intentionId) ?? null;
    }
    if (!linked) {
      linked = draft.secondaryIntentions.find(intention => !linkedIntentionUids.has(intention.uid)) ?? null;
    }
    if (linked) {
      slot.linkedIntentionUid = linked.uid;
      slot.intentionId = linked.id;
      linkedIntentionUids.add(linked.uid);
    }
    return slot;
  });

  draft.globalPredicates = (rawDraft.globalPredicates ?? []).map(predicate => ({
    ...createPredicate("round"),
    ...predicate,
    uid: predicate.uid ?? nextUid("predicate"),
    scope: "round"
  }));

  draft.lastUpdatedAt = rawDraft.lastUpdatedAt ?? draft.lastUpdatedAt;
  return draft;
}

function getAllSlots(draft) {
  return [draft.ownerSlot, ...draft.secondarySlots];
}

function getAllIntentions(draft) {
  return [draft.ownerIntention, ...draft.secondaryIntentions];
}


/* js/storage.js */
function loadDraft(locale = DEFAULT_LOCALE) {
  try {
    const raw = window.localStorage.getItem(STORAGE_KEY);
    if (!raw) {
      return null;
    }

    return normalizeDraft(JSON.parse(raw), locale);
  } catch (error) {
    console.warn("Failed to load IntentionEditor draft:", error);
    return null;
  }
}

function saveDraft(draft) {
  try {
    window.localStorage.setItem(STORAGE_KEY, JSON.stringify(draft));
  } catch (error) {
    console.warn("Failed to save IntentionEditor draft:", error);
  }
}

function clearDraft() {
  try {
    window.localStorage.removeItem(STORAGE_KEY);
  } catch (error) {
    console.warn("Failed to clear IntentionEditor draft:", error);
  }
}

function loadLocale() {
  try {
    return normalizeLocale(window.localStorage.getItem(LOCALE_STORAGE_KEY) ?? DEFAULT_LOCALE);
  } catch (error) {
    console.warn("Failed to load IntentionEditor locale:", error);
    return DEFAULT_LOCALE;
  }
}

function saveLocale(locale) {
  try {
    window.localStorage.setItem(LOCALE_STORAGE_KEY, normalizeLocale(locale));
  } catch (error) {
    console.warn("Failed to save IntentionEditor locale:", error);
  }
}

function loadTheme() {
  try {
    const value = window.localStorage.getItem(THEME_STORAGE_KEY);
    return value === "dark" ? "dark" : "light";
  } catch (error) {
    console.warn("Failed to load IntentionEditor theme:", error);
    return "light";
  }
}

function saveTheme(theme) {
  try {
    window.localStorage.setItem(THEME_STORAGE_KEY, theme === "dark" ? "dark" : "light");
  } catch (error) {
    console.warn("Failed to save IntentionEditor theme:", error);
  }
}


/* js/validation.js */
function issue(severity, path, code, message) {
  return { severity, path, code, message };
}

function addIssue(issues, severity, path, code, message) {
  issues.push(issue(severity, path, code, message));
}

function issueText(locale, key, params = {}) {
  return t(locale, `issues.${key}`, params);
}

function uiText(locale, key, params = {}) {
  return t(locale, `ui.${key}`, params);
}

function validateTextLength(issues, locale, value, maxLength, path, label, required = false) {
  const text = `${value ?? ""}`;
  if (required && nonEmpty(text).length === 0) {
    addIssue(issues, "error", path, "required", issueText(locale, "required", { label }));
  }

  if (text.length > maxLength) {
    addIssue(issues, "error", path, "length-limit", issueText(locale, "lengthLimit", { label, max: maxLength }));
  }
}

function valueMatchesFieldType(value, fieldType, allowListElement = false) {
  if (value === null || value === undefined || `${value}`.trim().length === 0) {
    return false;
  }

  const text = `${value}`.trim();
  switch (fieldType) {
    case "string":
      return true;
    case "bool":
      return isBooleanString(text);
    case "int":
      return isIntString(text);
    case "timespan":
      return isTimeSpanString(text);
    case "list-string":
      return allowListElement;
    case "map-int":
      return isIntString(text);
    default:
      return false;
  }
}

function validateIdentifierAgainstPresets(issues, locale, path, field, values) {
  const fieldDefinition = getFieldDefinition(PREDICATE_SCOPES.round, field)
    ?? getFieldDefinition(PREDICATE_SCOPES.candidate, field);
  const dictionaryName = fieldDefinition?.dictionary;
  if (!dictionaryName) {
    return;
  }

  const dictionary = getDictionaryValues(dictionaryName);
  if (dictionary.length === 0) {
    return;
  }

  for (const value of values) {
    if (value && !dictionary.includes(value)) {
      addIssue(
        issues,
        "warning",
        path,
        "unknown-reference",
        issueText(locale, "unknownReference", { value, field })
      );
    }
  }
}

function validatePredicateShape(issues, locale, path, predicate, fieldDefinition) {
  const hasValue = nonEmpty(predicate.value).length > 0;
  const hasValues = Array.isArray(predicate.values) && predicate.values.length > 0;
  const hasRange = nonEmpty(predicate.valueFrom).length > 0 || nonEmpty(predicate.valueTo).length > 0;
  const hasCompare = predicate.compareTo !== null && nonEmpty(predicate.compareTo.slotId).length > 0;
  const formCount = [hasValue, hasValues, hasRange, hasCompare].filter(Boolean).length;

  if (formCount > 1) {
    addIssue(issues, "error", path, "conflicting-predicate-values", issueText(locale, "conflictingPredicateValues"));
  }

  switch (predicate.operator) {
    case PREDICATE_OPERATORS.equals:
    case PREDICATE_OPERATORS.notEquals:
    case PREDICATE_OPERATORS[">"]:
    case PREDICATE_OPERATORS[">="]:
    case PREDICATE_OPERATORS["<"]:
    case PREDICATE_OPERATORS["<="]:
    case PREDICATE_OPERATORS.contains:
    case PREDICATE_OPERATORS.notContains:
      if (!hasValue) {
        addIssue(issues, "error", `${path}.value`, "missing-predicate-value", issueText(locale, "missingPredicateValue"));
      }
      break;
    case PREDICATE_OPERATORS.in:
    case PREDICATE_OPERATORS.notIn:
      if (!hasValues) {
        addIssue(issues, "error", `${path}.values`, "missing-predicate-values", issueText(locale, "missingPredicateValues"));
      }
      break;
    case PREDICATE_OPERATORS.between:
      if (!nonEmpty(predicate.valueFrom) || !nonEmpty(predicate.valueTo)) {
        addIssue(issues, "error", path, "missing-predicate-range", issueText(locale, "missingPredicateRange"));
      }
      break;
    case PREDICATE_OPERATORS.sameAs:
    case PREDICATE_OPERATORS.notSameAs:
      if (!hasCompare) {
        addIssue(issues, "error", `${path}.compareTo`, "missing-compare-to", issueText(locale, "missingCompareTo"));
      }
      break;
  }

  if ((predicate.operator === PREDICATE_OPERATORS.contains || predicate.operator === PREDICATE_OPERATORS.notContains)
    && fieldDefinition.type !== "list-string") {
    addIssue(issues, "error", `${path}.operator`, "operator-field-mismatch", issueText(locale, "operatorFieldMismatchList"));
  }

  if ([PREDICATE_OPERATORS[">"], PREDICATE_OPERATORS[">="], PREDICATE_OPERATORS["<"], PREDICATE_OPERATORS["<="], PREDICATE_OPERATORS.between].includes(predicate.operator)
    && !["int", "timespan", "map-int"].includes(fieldDefinition.type)) {
    addIssue(issues, "error", `${path}.operator`, "operator-field-mismatch", issueText(locale, "operatorFieldMismatchCompare"));
  }
}

function validatePredicateValueTypes(issues, locale, path, predicate, fieldDefinition) {
  if (nonEmpty(predicate.value) && !valueMatchesFieldType(predicate.value, fieldDefinition.type, true)) {
    addIssue(issues, "error", `${path}.value`, "invalid-predicate-value-type", issueText(locale, "invalidPredicateValueType"));
  }

  if (predicate.values.length > 0) {
    for (const value of predicate.values) {
      if (!valueMatchesFieldType(value, fieldDefinition.type, true)) {
        addIssue(issues, "error", `${path}.values`, "invalid-predicate-value-type", issueText(locale, "invalidPredicateValueType"));
        break;
      }
    }
  }

  if (nonEmpty(predicate.valueFrom) && !valueMatchesFieldType(predicate.valueFrom, fieldDefinition.type, false)) {
    addIssue(issues, "error", `${path}.valueFrom`, "invalid-predicate-value-type", issueText(locale, "invalidPredicateValueType"));
  }

  if (nonEmpty(predicate.valueTo) && !valueMatchesFieldType(predicate.valueTo, fieldDefinition.type, false)) {
    addIssue(issues, "error", `${path}.valueTo`, "invalid-predicate-value-type", issueText(locale, "invalidPredicateValueType"));
  }
}

function validatePredicateNumericBounds(issues, locale, path, predicate, fieldDefinition) {
  if (!Number.isFinite(fieldDefinition.min) || !["int", "map-int"].includes(fieldDefinition.type)) {
    return;
  }

  const min = fieldDefinition.min;
  const numericEntries = [
    { path: `${path}.value`, value: predicate.value },
    { path: `${path}.valueFrom`, value: predicate.valueFrom },
    { path: `${path}.valueTo`, value: predicate.valueTo }
  ];

  for (const entry of numericEntries) {
    if (!nonEmpty(entry.value)) {
      continue;
    }

    const number = Number(entry.value);
    if (Number.isFinite(number) && number < min) {
      addIssue(issues, "error", entry.path, "predicate-min-value", issueText(locale, "predicateMinValue", { min }));
    }
  }

  if (Array.isArray(predicate.values)) {
    for (const value of predicate.values) {
      if (!nonEmpty(value)) {
        continue;
      }

      const number = Number(value);
      if (Number.isFinite(number) && number < min) {
        addIssue(issues, "error", `${path}.values`, "predicate-min-value", issueText(locale, "predicateMinValue", { min }));
        break;
      }
    }
  }
}

function validatePredicateIdentifiers(issues, locale, path, predicate, fieldDefinition) {
  const values = [];
  if (nonEmpty(predicate.key)) {
    values.push(predicate.key);
  }
  if (nonEmpty(predicate.value) && fieldDefinition.type !== "int" && fieldDefinition.type !== "timespan" && fieldDefinition.type !== "bool" && fieldDefinition.type !== "map-int") {
    values.push(predicate.value);
  }
  if (predicate.values.length > 0) {
    values.push(...predicate.values.filter(item => nonEmpty(item)));
  }
  validateIdentifierAgainstPresets(issues, locale, path, predicate.field, values);
}

function validateCompareTo(issues, locale, path, predicate, context) {
  if (![PREDICATE_OPERATORS.sameAs, PREDICATE_OPERATORS.notSameAs].includes(predicate.operator)) {
    if (predicate.compareTo) {
      addIssue(issues, "error", `${path}.compareTo`, "unexpected-compare-to", issueText(locale, "unexpectedCompareTo"));
    }
    return;
  }

  if (context.scope !== PREDICATE_SCOPES.candidate) {
    addIssue(issues, "error", `${path}.compareTo`, "compare-to-outside-candidate", issueText(locale, "compareOutsideCandidate"));
    return;
  }

  const compareTo = predicate.compareTo;
  if (!compareTo) {
    return;
  }

  if (compareTo.scope !== PREDICATE_SCOPES.slot) {
    addIssue(issues, "error", `${path}.compareTo.scope`, "invalid-compare-scope", issueText(locale, "invalidCompareScope"));
  }

  if (!context.slotIds.has(compareTo.slotId)) {
    addIssue(issues, "error", `${path}.compareTo.slotId`, "missing-compare-slot", issueText(locale, "missingCompareSlot"));
  }

  if (compareTo.field !== predicate.field) {
    addIssue(issues, "error", `${path}.compareTo.field`, "compare-field-mismatch", issueText(locale, "compareFieldMismatch"));
  }

  if (compareTo.slotId === context.currentSlotId) {
    addIssue(issues, "warning", `${path}.compareTo.slotId`, "owner-self-compare", issueText(locale, "ownerSelfCompare"));
  }
}

function validatePredicate(issues, locale, path, predicate, context) {
  if (predicate.scope !== context.scope) {
    addIssue(issues, "error", `${path}.scope`, "invalid-scope", issueText(locale, "invalidScope", { scope: context.scope }));
  }

  const fieldDefinition = getFieldDefinition(context.scope, predicate.field);
  if (!fieldDefinition) {
    addIssue(issues, "error", `${path}.field`, "unknown-field", issueText(locale, "unknownField"));
    return;
  }

  const allowedOperators = getAllowedOperators(context.scope, predicate.field, {
    allowCompareOperators: context.allowCompareOperators
  });
  if (!allowedOperators.includes(predicate.operator)) {
    addIssue(issues, "error", `${path}.operator`, "invalid-operator", issueText(locale, "invalidOperator"));
  }

  if (fieldDefinition.type === "map-int" && !nonEmpty(predicate.key)) {
    addIssue(issues, "error", `${path}.key`, "missing-map-key", issueText(locale, "missingMapKey"));
  }

  if (fieldDefinition.type !== "map-int" && nonEmpty(predicate.key)) {
    addIssue(issues, "error", `${path}.key`, "unexpected-map-key", issueText(locale, "unexpectedMapKey"));
  }

  validatePredicateShape(issues, locale, path, predicate, fieldDefinition);
  validatePredicateValueTypes(issues, locale, path, predicate, fieldDefinition);
  validatePredicateNumericBounds(issues, locale, path, predicate, fieldDefinition);
  validatePredicateIdentifiers(issues, locale, path, predicate, fieldDefinition);
  validateCompareTo(issues, locale, path, predicate, context);
}

function validateTextBinding(issues, locale, path, binding, slotIds) {
  if (!nonEmpty(binding.parameter)) {
    addIssue(issues, "error", `${path}.parameter`, "missing-binding-parameter", issueText(locale, "missingBindingParameter"));
  }

  switch (binding.source) {
    case TEXT_BINDING_SOURCES.self:
      if (!TEXT_BINDING_FIELDS.some(field => field.id === binding.field)) {
        addIssue(issues, "error", `${path}.field`, "invalid-self-binding-field", issueText(locale, "invalidSelfBindingField"));
      }
      break;
    case TEXT_BINDING_SOURCES.slot:
      if (!slotIds.has(binding.slotId)) {
        addIssue(issues, "error", `${path}.slotId`, "invalid-text-binding-slot", issueText(locale, "invalidTextBindingSlot"));
      }
      if (!TEXT_BINDING_FIELDS.some(field => field.id === binding.field)) {
        addIssue(issues, "error", `${path}.field`, "invalid-slot-binding-field", issueText(locale, "invalidSlotBindingField"));
      }
      break;
    case TEXT_BINDING_SOURCES.round:
      if (!ROUND_TEXT_BINDING_FIELDS.some(field => field.id === binding.field)) {
        addIssue(issues, "error", `${path}.field`, "invalid-round-binding", issueText(locale, "invalidRoundBinding"));
      }
      break;
    case TEXT_BINDING_SOURCES.literal:
      if (!nonEmpty(binding.value)) {
        addIssue(issues, "error", `${path}.value`, "missing-literal-binding", issueText(locale, "missingLiteralBinding"));
      }
      break;
    default:
      addIssue(issues, "error", `${path}.source`, "invalid-text-binding-source", issueText(locale, "invalidTextBindingSource"));
      break;
  }
}

function validateVisibility(issues, locale, path, slot) {
  if (!slot.visibilityEnabled) {
    return;
  }

  if (![VISIBILITY_TYPES.visible, VISIBILITY_TYPES.hidden].includes(slot.visibilityType)) {
    addIssue(issues, "error", `${path}.visibilityType`, "invalid-visibility-type", issueText(locale, "invalidVisibilityType"));
  }

  if (slot.visibilityType === VISIBILITY_TYPES.visible && slot.revealType !== REVEAL_TYPES.none) {
    addIssue(issues, "error", `${path}.revealType`, "visible-with-reveal", issueText(locale, "visibleWithReveal"));
  }

  if (![REVEAL_TYPES.none, REVEAL_TYPES.timer].includes(slot.revealType)) {
    addIssue(issues, "error", `${path}.revealType`, "invalid-reveal-type", issueText(locale, "invalidRevealType"));
  }

  if (slot.revealType === REVEAL_TYPES.timer && (!Number.isFinite(slot.revealMinutes) || slot.revealMinutes <= 0)) {
    addIssue(issues, "error", `${path}.revealMinutes`, "invalid-reveal-minutes", issueText(locale, "invalidRevealMinutes"));
  }

  if (slot.revealType === REVEAL_TYPES.none
    && slot.visibilityType === VISIBILITY_TYPES.hidden
    && Number.isFinite(slot.revealMinutes)
    && slot.revealMinutes <= 0) {
    addIssue(issues, "warning", `${path}.revealMinutes`, "unused-reveal-minutes", issueText(locale, "unusedRevealMinutes"));
  }
}

function validateIntentionTemplate(issues, locale, intention, path) {
  const kindLabel = intention.kind === INTENTION_KINDS.primary
    ? uiText(locale, "sections.ownerIntention")
    : uiText(locale, "sections.secondaryIntentions");

  if (!nonEmpty(intention.id)) {
    addIssue(issues, "error", `${path}.id`, "missing-id", issueText(locale, "missingId", { kind: kindLabel }));
  }

  if (![INTENTION_KINDS.primary, INTENTION_KINDS.secondary].includes(intention.kind)) {
    addIssue(issues, "error", `${path}.kind`, "invalid-kind", issueText(locale, "invalidKind"));
  }

  const titleLabel = uiText(locale, "fields.title");
  const summaryLabel = uiText(locale, "fields.summary");
  const descriptionLabel = uiText(locale, "fields.description");
  const oocLabel = uiText(locale, "fields.oocInfo");
  const copyLabel = uiText(locale, "fields.copyableText");
  const hiddenLabel = uiText(locale, "fields.hiddenLabel");

  validateTextLength(issues, locale, intention.name, TEXT_LIMITS.name, `${path}.name`, titleLabel, true);
  validateTextLength(issues, locale, intention.summary, TEXT_LIMITS.summary, `${path}.summary`, summaryLabel);
  validateTextLength(issues, locale, intention.description, TEXT_LIMITS.description, `${path}.description`, descriptionLabel, true);
  validateTextLength(issues, locale, intention.oocInfo, TEXT_LIMITS.oocInfo, `${path}.oocInfo`, oocLabel);
  validateTextLength(issues, locale, intention.copyableText, TEXT_LIMITS.copyableText, `${path}.copyableText`, copyLabel);
  validateTextLength(issues, locale, intention.hiddenLabel, TEXT_LIMITS.hiddenLabel, `${path}.hiddenLabel`, hiddenLabel);

  if (![VISIBILITY_TYPES.visible, VISIBILITY_TYPES.hidden].includes(intention.defaultVisibility)) {
    addIssue(issues, "error", `${path}.defaultVisibility`, "invalid-default-visibility", issueText(locale, "invalidDefaultVisibility"));
  }

  if (nonEmpty(intention.color) && !isHexColor(intention.color)) {
    addIssue(issues, "error", `${path}.color`, "invalid-color", issueText(locale, "invalidColor"));
  }

  if (nonEmpty(intention.creationDate) && !isIsoDate(intention.creationDate)) {
    addIssue(issues, "error", `${path}.creationDate`, "invalid-creation-date", issueText(locale, "invalidCreationDate"));
  }

  if (intention.iconEnabled) {
    if (!nonEmpty(intention.iconSprite)) {
      addIssue(issues, "error", `${path}.iconSprite`, "missing-icon-sprite", issueText(locale, "missingIconSprite"));
    }
    if (!nonEmpty(intention.iconState)) {
      addIssue(issues, "error", `${path}.iconState`, "missing-icon-state", issueText(locale, "missingIconState"));
    }
  }

  if (intention.defaultVisibility === VISIBILITY_TYPES.hidden && !nonEmpty(intention.hiddenLabel)) {
    addIssue(issues, "warning", `${path}.hiddenLabel`, "missing-hidden-label", issueText(locale, "missingHiddenLabel"));
  }
}

function buildSlotDependencies(slot) {
  const dependencies = new Set();
  if (nonEmpty(slot.bindToSlot)) {
    dependencies.add(slot.bindToSlot);
  }

  for (const allowedSlot of slot.allowSameActorAs) {
    if (nonEmpty(allowedSlot)) {
      dependencies.add(allowedSlot);
    }
  }

  for (const predicate of slot.candidatePredicates) {
    if (predicate.compareTo?.slotId) {
      dependencies.add(predicate.compareTo.slotId);
    }
  }

  return dependencies;
}

function computeSlotBuildOrder(slots) {
  const dependencies = new Map();
  for (const slot of slots) {
    dependencies.set(slot.slotId, buildSlotDependencies(slot));
  }

  const result = [];
  const processed = new Set();

  while (result.length < slots.length) {
    const next = slots.find(slot =>
      !processed.has(slot.slotId)
      && [...(dependencies.get(slot.slotId) ?? [])].every(item => processed.has(item)));

    if (!next) {
      return [];
    }

    processed.add(next.slotId);
    result.push(next.slotId);
  }

  return result;
}

function getComparableSlots(currentSlotId, slotIds) {
  return [...slotIds].filter(slotId => slotId !== currentSlotId);
}

function validateSlot(issues, locale, slot, path, context) {
  if (!nonEmpty(slot.slotId)) {
    addIssue(issues, "error", `${path}.slotId`, "missing-slot-id", issueText(locale, "missingSlotId"));
  }

  if (![INTENTION_KINDS.primary, INTENTION_KINDS.secondary].includes(slot.kind)) {
    addIssue(issues, "error", `${path}.kind`, "invalid-slot-kind", issueText(locale, "invalidSlotKind"));
  }

  if (!context.intentionById.has(slot.intentionId)) {
    addIssue(issues, "error", `${path}.intentionId`, "missing-intention-reference", issueText(locale, "missingIntentionReference"));
  } else if (context.intentionById.get(slot.intentionId).kind !== slot.kind) {
    addIssue(issues, "error", `${path}.intentionId`, "kind-mismatch", issueText(locale, "kindMismatch"));
  }

  if (slot.bindToSlot && slot.allowSameActorAs.length > 0) {
    addIssue(issues, "error", path, "bind-and-allow-same-actor", issueText(locale, "bindAndAllowSameActor"));
  }

  if (slot.bindToSlot) {
    if (!context.slotIds.has(slot.bindToSlot)) {
      addIssue(issues, "error", `${path}.bindToSlot`, "missing-bound-slot", issueText(locale, "missingBoundSlot"));
    }
    if (slot.bindToSlot === slot.slotId) {
      addIssue(issues, "error", `${path}.bindToSlot`, "self-bind", issueText(locale, "selfBind"));
    }
    if (slot.candidatePredicates.length > 0) {
      addIssue(issues, "error", `${path}.candidatePredicates`, "bound-slot-has-predicates", issueText(locale, "boundSlotHasPredicates"));
    }
  }

  const allowSet = new Set();
  for (const allowedSlot of slot.allowSameActorAs) {
    if (allowedSlot === slot.slotId) {
      addIssue(issues, "error", `${path}.allowSameActorAs`, "self-allow-same-actor", issueText(locale, "selfAllowSameActor"));
    }
    if (allowSet.has(allowedSlot)) {
      addIssue(issues, "error", `${path}.allowSameActorAs`, "duplicate-allow-same-actor", issueText(locale, "duplicateAllowSameActor"));
    }
    allowSet.add(allowedSlot);
    if (!context.slotIds.has(allowedSlot)) {
      addIssue(issues, "error", `${path}.allowSameActorAs`, "missing-allow-same-actor-slot", issueText(locale, "missingAllowSameActorSlot"));
    }
  }

  const compareOptionsAvailable = getComparableSlots(slot.slotId, context.slotIds).length > 0;
  slot.candidatePredicates.forEach((predicate, index) => {
    validatePredicate(issues, locale, `${path}.candidatePredicates.${index}`, predicate, {
      scope: PREDICATE_SCOPES.candidate,
      slotIds: context.slotIds,
      currentSlotId: slot.slotId,
      allowCompareOperators: compareOptionsAvailable
    });
  });

  const bindingNames = new Set();
  slot.textParameterBindings.forEach((binding, index) => {
    validateTextBinding(issues, locale, `${path}.textParameterBindings.${index}`, binding, context.slotIds);
    if (bindingNames.has(binding.parameter)) {
      addIssue(issues, "error", `${path}.textParameterBindings.${index}.parameter`, "duplicate-binding-parameter", issueText(locale, "duplicateBindingParameter"));
    }
    bindingNames.add(binding.parameter);
  });

  validateVisibility(issues, locale, path, slot);
}

function validateDraft(draft, locale = "ru") {
  const issues = [];

  if (!nonEmpty(draft.scenario.id)) {
    addIssue(issues, "error", "scenario.id", "missing-scenario-id", issueText(locale, "missingScenarioId"));
  }
  if (!nonEmpty(draft.scenario.name)) {
    addIssue(issues, "error", "scenario.name", "missing-scenario-name", issueText(locale, "missingScenarioName"));
  }
  if (!nonEmpty(draft.scenario.category)) {
    addIssue(issues, "error", "scenario.category", "missing-scenario-category", issueText(locale, "missingScenarioCategory"));
  } else if (!getCategory(draft.scenario.category)) {
    addIssue(issues, "error", "scenario.category", "category-not-in-catalog", issueText(locale, "categoryNotInCatalog"));
  }

  const weight = Number(draft.scenario.weight);
  if (!Number.isInteger(weight) || weight <= 0) {
    addIssue(issues, "error", "scenario.weight", "invalid-weight", issueText(locale, "invalidWeight"));
  }

  validateIntentionTemplate(issues, locale, {
    ...draft.ownerIntention,
    tags: splitTagsInput(draft.ownerIntention.tagsInput ?? draft.ownerIntention.tags ?? [])
  }, "ownerIntention");

  draft.secondaryIntentions.forEach((intention, index) => {
    validateIntentionTemplate(issues, locale, {
      ...intention,
      tags: splitTagsInput(intention.tagsInput ?? intention.tags ?? [])
    }, `secondaryIntentions.${index}`);
  });

  const allIntentions = getAllIntentions(draft);
  const intentionById = new Map();
  for (const intention of allIntentions) {
    if (!nonEmpty(intention.id)) {
      continue;
    }

    if (intentionById.has(intention.id)) {
      addIssue(issues, "error", "intentions", "duplicate-intention-id", issueText(locale, "duplicateIntentionId", { id: intention.id }));
    } else {
      intentionById.set(intention.id, intention);
    }
  }

  const slots = getAllSlots(draft);
  const slotIds = new Set();
  for (const slot of slots) {
    if (!nonEmpty(slot.slotId)) {
      continue;
    }

    if (slotIds.has(slot.slotId)) {
      addIssue(issues, "error", "slots", "duplicate-slot-id", issueText(locale, "duplicateSlotId", { id: slot.slotId }));
    } else {
      slotIds.add(slot.slotId);
    }
  }

  if (draft.ownerSlot.slotId !== "owner") {
    addIssue(issues, "error", "ownerSlot.slotId", "owner-slot-id", issueText(locale, "ownerSlotId"));
  }
  if (draft.ownerSlot.kind !== INTENTION_KINDS.primary) {
    addIssue(issues, "error", "ownerSlot.kind", "owner-slot-kind", issueText(locale, "ownerSlotKind"));
  }
  if (draft.ownerSlot.required !== true) {
    addIssue(issues, "error", "ownerSlot.required", "owner-slot-required", issueText(locale, "ownerSlotRequired"));
  }
  if (draft.ownerSlot.intentionId !== draft.ownerIntention.id) {
    addIssue(issues, "error", "ownerSlot.intentionId", "owner-intention-link", issueText(locale, "ownerIntentionLink"));
  }

  validateSlot(issues, locale, draft.ownerSlot, "ownerSlot", {
    slotIds,
    intentionById
  });

  draft.secondarySlots.forEach((slot, index) => {
    if (slot.kind !== INTENTION_KINDS.secondary) {
      addIssue(issues, "error", `secondarySlots.${index}.kind`, "secondary-slot-kind", issueText(locale, "invalidSlotKind"));
    }

    validateSlot(issues, locale, slot, `secondarySlots.${index}`, {
      slotIds,
      intentionById
    });
  });

  draft.globalPredicates.forEach((predicate, index) => {
    validatePredicate(issues, locale, `globalPredicates.${index}`, predicate, {
      scope: PREDICATE_SCOPES.round,
      slotIds: new Set(),
      currentSlotId: "",
      allowCompareOperators: false
    });
  });

  const slotBuildOrder = computeSlotBuildOrder(slots);
  if (buildSlotDependencies(draft.ownerSlot).size > 0) {
    addIssue(issues, "error", "ownerSlot", "owner-has-dependencies", issueText(locale, "ownerHasDependencies"));
  }
  if (slotBuildOrder.length === 0 && slots.length > 0) {
    addIssue(issues, "error", "slots", "slot-dependency-cycle", issueText(locale, "slotDependencyCycle"));
  } else if (slotBuildOrder.length > 0 && slotBuildOrder[0] !== "owner") {
    addIssue(issues, "error", "slots", "owner-not-first", issueText(locale, "ownerNotFirst"));
  }

  return {
    issues,
    errors: issues.filter(item => item.severity === "error"),
    warnings: issues.filter(item => item.severity === "warning"),
    slotBuildOrder,
    category: getCategory(draft.scenario.category),
    intentionCount: allIntentions.length,
    slotCount: slots.length
  };
}


/* js/exporters.js */
function yamlScalar(value) {
  if (typeof value === "boolean") {
    return value ? "true" : "false";
  }

  if (typeof value === "number") {
    return Number.isFinite(value) ? `${value}` : "0";
  }

  const text = `${value ?? ""}`;
  if (text.length === 0) {
    return "\"\"";
  }

  if (/^(true|false|null|~)$/i.test(text)) {
    return `"${text}"`;
  }

  if (/^[A-Za-z0-9_.\/:-]+$/.test(text)) {
    return text;
  }

  return `"${text
    .replace(/\\/g, "\\\\")
    .replace(/"/g, '\\"')
    .replace(/\n/g, "\\n")}"`;
}

function yamlInlineList(values) {
  return `[${values.map(item => yamlScalar(item)).join(", ")}]`;
}

function appendLine(lines, indent, text) {
  lines.push(`${"  ".repeat(indent)}${text}`);
}

function intentionLocKeys(intentionId) {
  const slug = slugifyIdentifier(intentionId || "intention");
  return {
    nameLoc: `intentions-${slug}-name`,
    summaryLoc: `intentions-${slug}-summary`,
    descriptionLoc: `intentions-${slug}-description`,
    oocInfoLoc: `intentions-${slug}-ooc-info`,
    copyableTextLoc: `intentions-${slug}-copy`,
    hiddenLabelLoc: `intentions-${slug}-hidden-label`
  };
}

function normalizeIntentionForExport(intention) {
  const tags = splitTagsInput(intention.tagsInput ?? intention.tags ?? []);
  return {
    ...intention,
    tags
  };
}

function serializePredicate(predicate) {
  const normalized = {
    scope: predicate.scope,
    field: predicate.field,
    operator: predicate.operator,
    key: predicate.key ?? "",
    value: predicate.value ?? "",
    values: Array.isArray(predicate.values) ? predicate.values.filter(item => nonEmpty(item)) : [],
    valueFrom: predicate.valueFrom ?? "",
    valueTo: predicate.valueTo ?? "",
    compareTo: predicate.compareTo?.slotId
      ? {
          scope: predicate.compareTo.scope,
          slotId: predicate.compareTo.slotId,
          field: predicate.compareTo.field
        }
      : null
  };

  if (normalized.operator === PREDICATE_OPERATORS.sameAs || normalized.operator === PREDICATE_OPERATORS.notSameAs) {
    normalized.value = "";
    normalized.values = [];
    normalized.valueFrom = "";
    normalized.valueTo = "";
  }

  return normalized;
}

function computeRequiredCrewGroups(draft, slotBuildOrder) {
  const slotById = new Map(getAllSlots(draft).map(slot => [slot.slotId, slot]));
  const requiredGroups = new Map();
  let nextGroupId = 0;

  function createGroup(slotId) {
    const groupId = `group-${nextGroupId}`;
    nextGroupId += 1;
    requiredGroups.set(slotId, groupId);
    return groupId;
  }

  for (const slotId of slotBuildOrder) {
    const slot = slotById.get(slotId);
    if (!slot || slot.required !== true) {
      continue;
    }

    if (slot.slotId === "owner") {
      createGroup(slot.slotId);
      continue;
    }

    if (nonEmpty(slot.bindToSlot)) {
      const targetGroup = requiredGroups.get(slot.bindToSlot);
      if (targetGroup) {
        requiredGroups.set(slot.slotId, targetGroup);
        continue;
      }
    }

    const reusableGroup = slot.allowSameActorAs
      .map(candidateSlotId => requiredGroups.get(candidateSlotId))
      .find(Boolean);

    if (reusableGroup) {
      requiredGroups.set(slot.slotId, reusableGroup);
      continue;
    }

    createGroup(slot.slotId);
  }

  return requiredGroups;
}

function computeMinimumRequiredCrew(draft, slotBuildOrder) {
  const groups = computeRequiredCrewGroups(draft, slotBuildOrder);
  return new Set(groups.values()).size || 1;
}

function authoredCrewPredicateSatisfies(predicate, minimumCrew) {
  if (predicate.field !== "crewCount") {
    return false;
  }

  if (!nonEmpty(predicate.value)) {
    return false;
  }

  const value = Number(predicate.value);
  if (!Number.isInteger(value)) {
    return false;
  }

  if (predicate.operator === PREDICATE_OPERATORS[">="]) {
    return value >= minimumCrew;
  }

  if (predicate.operator === PREDICATE_OPERATORS[">"]) {
    return value + 1 >= minimumCrew;
  }

  return false;
}

function buildSyntheticCrewPredicate(minimumCrew) {
  return {
    scope: "round",
    field: "crewCount",
    operator: PREDICATE_OPERATORS[">="],
    key: "",
    value: `${minimumCrew}`,
    values: [],
    valueFrom: "",
    valueTo: "",
    compareTo: null
  };
}

function appendPredicateYaml(lines, indent, predicate) {
  appendLine(lines, indent, `- scope: ${yamlScalar(predicate.scope)}`);
  appendLine(lines, indent + 1, `field: ${yamlScalar(predicate.field)}`);
  appendLine(lines, indent + 1, `operator: ${yamlScalar(predicate.operator)}`);

  if (nonEmpty(predicate.key)) {
    appendLine(lines, indent + 1, `key: ${yamlScalar(predicate.key)}`);
  }
  if (nonEmpty(predicate.value)) {
    appendLine(lines, indent + 1, `value: ${yamlScalar(predicate.value)}`);
  }
  if (predicate.values.length > 0) {
    appendLine(lines, indent + 1, `values: ${yamlInlineList(predicate.values)}`);
  }
  if (nonEmpty(predicate.valueFrom)) {
    appendLine(lines, indent + 1, `valueFrom: ${yamlScalar(predicate.valueFrom)}`);
  }
  if (nonEmpty(predicate.valueTo)) {
    appendLine(lines, indent + 1, `valueTo: ${yamlScalar(predicate.valueTo)}`);
  }
  if (predicate.compareTo?.slotId) {
    appendLine(lines, indent + 1, "compareTo:");
    appendLine(lines, indent + 2, `scope: ${yamlScalar(predicate.compareTo.scope)}`);
    appendLine(lines, indent + 2, `slotId: ${yamlScalar(predicate.compareTo.slotId)}`);
    appendLine(lines, indent + 2, `field: ${yamlScalar(predicate.compareTo.field)}`);
  }
}

function appendSlotYaml(lines, indent, slot) {
  appendLine(lines, indent, `- slotId: ${yamlScalar(slot.slotId)}`);
  appendLine(lines, indent + 1, `kind: ${yamlScalar(slot.kind)}`);
  appendLine(lines, indent + 1, `intentionId: ${yamlScalar(slot.intentionId)}`);
  appendLine(lines, indent + 1, `required: ${yamlScalar(Boolean(slot.required))}`);

  if (slot.candidatePredicates.length > 0) {
    appendLine(lines, indent + 1, "candidatePredicates:");
    slot.candidatePredicates.forEach(predicate => appendPredicateYaml(lines, indent + 2, serializePredicate(predicate)));
  }

  if (nonEmpty(slot.bindToSlot)) {
    appendLine(lines, indent + 1, `bindToSlot: ${yamlScalar(slot.bindToSlot)}`);
  }

  if (slot.allowSameActorAs.length > 0) {
    appendLine(lines, indent + 1, `allowSameActorAs: ${yamlInlineList(slot.allowSameActorAs)}`);
  }

  if (slot.textParameterBindings.length > 0) {
    appendLine(lines, indent + 1, "textParameterBindings:");
    slot.textParameterBindings.forEach(binding => {
      appendLine(lines, indent + 2, `${binding.parameter}:`);
      appendLine(lines, indent + 3, `source: ${yamlScalar(binding.source)}`);
      if (binding.source === TEXT_BINDING_SOURCES.slot && nonEmpty(binding.slotId)) {
        appendLine(lines, indent + 3, `slotId: ${yamlScalar(binding.slotId)}`);
      }
      if (binding.source === TEXT_BINDING_SOURCES.literal && nonEmpty(binding.value)) {
        appendLine(lines, indent + 3, `value: ${yamlScalar(binding.value)}`);
      } else if (binding.source !== TEXT_BINDING_SOURCES.literal && nonEmpty(binding.field)) {
        appendLine(lines, indent + 3, `field: ${yamlScalar(binding.field)}`);
      }
    });
  }

  if (slot.visibilityEnabled) {
    appendLine(lines, indent + 1, "visibilityOverride:");
    appendLine(lines, indent + 2, `type: ${yamlScalar(slot.visibilityType)}`);
    if (slot.visibilityType === VISIBILITY_TYPES.hidden) {
      appendLine(lines, indent + 2, "reveal:");
      appendLine(lines, indent + 3, `type: ${yamlScalar(slot.revealType)}`);
      if (slot.revealType === REVEAL_TYPES.timer) {
        appendLine(lines, indent + 3, `minutes: ${yamlScalar(Number(slot.revealMinutes) || 1)}`);
      }
    }
  }
}

function buildScenarioYaml(draft, exportMeta) {
  const lines = [];
  appendLine(lines, 0, "- type: scenarioTemplate");
  appendLine(lines, 1, `id: ${yamlScalar(draft.scenario.id)}`);
  appendLine(lines, 1, `name: ${yamlScalar(draft.scenario.name)}`);
  appendLine(lines, 1, `category: ${yamlScalar(draft.scenario.category)}`);
  appendLine(lines, 1, `enabled: ${yamlScalar(Boolean(draft.scenario.enabled))}`);
  appendLine(lines, 1, `weight: ${yamlScalar(Number(draft.scenario.weight) || 1)}`);

  const predicates = draft.globalPredicates.map(serializePredicate);
  if (exportMeta.syntheticCrewPredicateAdded) {
    predicates.push(buildSyntheticCrewPredicate(exportMeta.derivedCrewCount));
  }

  if (predicates.length > 0) {
    appendLine(lines, 1, "globalPredicates:");
    predicates.forEach(predicate => appendPredicateYaml(lines, 2, predicate));
  }

  appendLine(lines, 1, "entries:");
  getAllSlots(draft).forEach(slot => appendSlotYaml(lines, 2, slot));
  return `${lines.join("\n")}\n`;
}

function buildIntentionYaml(draft) {
  const lines = [];

  getAllIntentions(draft).map(normalizeIntentionForExport).forEach((intention, index) => {
    if (index > 0) {
      lines.push("");
    }

    const locKeys = intentionLocKeys(intention.id);
    appendLine(lines, 0, "- type: intentionTemplate");
    appendLine(lines, 1, `id: ${yamlScalar(intention.id)}`);
    appendLine(lines, 1, `kind: ${yamlScalar(intention.kind)}`);
    appendLine(lines, 1, `nameLoc: ${yamlScalar(locKeys.nameLoc)}`);
    if (nonEmpty(intention.summary)) {
      appendLine(lines, 1, `summaryLoc: ${yamlScalar(locKeys.summaryLoc)}`);
    }
    appendLine(lines, 1, `descriptionLoc: ${yamlScalar(locKeys.descriptionLoc)}`);
    if (nonEmpty(intention.oocInfo)) {
      appendLine(lines, 1, `oocInfoLoc: ${yamlScalar(locKeys.oocInfoLoc)}`);
    }
    if (nonEmpty(intention.copyableText)) {
      appendLine(lines, 1, `copyableTextLoc: ${yamlScalar(locKeys.copyableTextLoc)}`);
    }
    appendLine(lines, 1, `defaultVisibility: ${yamlScalar(intention.defaultVisibility)}`);
    if (nonEmpty(intention.hiddenLabel)) {
      appendLine(lines, 1, `hiddenLabelLoc: ${yamlScalar(locKeys.hiddenLabelLoc)}`);
    }
    if (intention.iconEnabled && nonEmpty(intention.iconSprite) && nonEmpty(intention.iconState)) {
      appendLine(lines, 1, "icon:");
      appendLine(lines, 2, `sprite: ${yamlScalar(intention.iconSprite)}`);
      appendLine(lines, 2, `state: ${yamlScalar(intention.iconState)}`);
    }
    if (nonEmpty(intention.color)) {
      appendLine(lines, 1, `color: ${yamlScalar(intention.color)}`);
    }
    if (intention.tags.length > 0) {
      appendLine(lines, 1, `tags: ${yamlInlineList(intention.tags)}`);
    }
    if (nonEmpty(intention.author)) {
      appendLine(lines, 1, `author: ${yamlScalar(intention.author)}`);
    }
    if (nonEmpty(intention.creationDate)) {
      appendLine(lines, 1, `creationDate: ${yamlScalar(intention.creationDate)}`);
    }
  });

  return `${lines.join("\n")}\n`;
}

function appendFtlEntry(lines, key, value) {
  const text = `${value ?? ""}`;
  const parts = text.split(/\r?\n/);
  if (parts.length === 0) {
    lines.push(`${key} =`);
    return;
  }

  lines.push(`${key} = ${parts[0]}`);
  for (let index = 1; index < parts.length; index += 1) {
    lines.push(`    ${parts[index]}`);
  }
}

function buildFtl(draft) {
  const lines = [];

  getAllIntentions(draft).map(normalizeIntentionForExport).forEach((intention, index) => {
    if (index > 0) {
      lines.push("");
    }

    const locKeys = intentionLocKeys(intention.id);
    appendFtlEntry(lines, locKeys.nameLoc, intention.name);
    if (nonEmpty(intention.summary)) {
      appendFtlEntry(lines, locKeys.summaryLoc, intention.summary);
    }
    appendFtlEntry(lines, locKeys.descriptionLoc, intention.description);
    if (nonEmpty(intention.oocInfo)) {
      appendFtlEntry(lines, locKeys.oocInfoLoc, intention.oocInfo);
    }
    if (nonEmpty(intention.copyableText)) {
      appendFtlEntry(lines, locKeys.copyableTextLoc, intention.copyableText);
    }
    if (nonEmpty(intention.hiddenLabel)) {
      appendFtlEntry(lines, locKeys.hiddenLabelLoc, intention.hiddenLabel);
    }
  });

  return `${lines.join("\n")}\n`;
}

function buildExportMeta(draft) {
  const validation = validateDraft(draft);
  const slotBuildOrder = validation.slotBuildOrder.length > 0
    ? validation.slotBuildOrder
    : getAllSlots(draft).map(slot => slot.slotId);
  const derivedCrewCount = computeMinimumRequiredCrew(draft, slotBuildOrder);
  const authoredCrewPredicate = draft.globalPredicates
    .map(serializePredicate)
    .find(predicate => authoredCrewPredicateSatisfies(predicate, derivedCrewCount));

  return {
    slotBuildOrder,
    derivedCrewCount,
    syntheticCrewPredicateAdded: !authoredCrewPredicate,
    authoredCrewPredicate
  };
}

function buildExportArtifacts(draft) {
  const fileStem = fileSafeName(draft.scenario.id);
  const meta = buildExportMeta(draft);

  return {
    scenario: {
      filename: `scenario_templates.${fileStem}.yml`,
      content: buildScenarioYaml(draft, meta)
    },
    intentions: {
      filename: `intention_templates.${fileStem}.yml`,
      content: buildIntentionYaml(draft)
    },
    ftl: {
      filename: `intentions.${fileStem}.ftl`,
      content: buildFtl(draft)
    },
    meta
  };
}

function getLocKeysForIntentions(draft) {
  return getAllIntentions(draft).map(intention => ({
    intentionId: intention.id,
    ...intentionLocKeys(intention.id)
  }));
}

function getDerivedExportMeta(draft) {
  return buildExportMeta(draft);
}


/* js/importers.js */
class ImportFailure extends Error {
  constructor(area, message, line = 0) {
    super(message);
    this.area = area;
    this.line = line;
  }
}

function importError(area, message, line = 0) {
  return {
    area,
    line,
    message: line > 0 ? `${message} (line ${line})` : message
  };
}

function fail(area, message, line = 0) {
  throw new ImportFailure(area, message, line);
}

function countIndent(rawLine, area, lineNumber) {
  if (/^\t+/.test(rawLine)) {
    fail(area, "Tabs are not supported for YAML indentation.", lineNumber);
  }

  return rawLine.match(/^ */)?.[0].length ?? 0;
}

function prepareYamlLines(text, area) {
  return `${text ?? ""}`
    .replace(/\r\n/g, "\n")
    .split("\n")
    .map((raw, index) => ({
      raw,
      line: index + 1,
      indent: countIndent(raw, area, index + 1),
      text: raw.trim()
    }))
    .filter(line => line.text.length > 0 && !line.text.startsWith("#"));
}

function splitKeyValue(text, area, lineNumber) {
  const index = text.indexOf(":");
  if (index <= 0) {
    fail(area, `Expected "key: value" but got "${text}".`, lineNumber);
  }

  return {
    key: text.slice(0, index).trim(),
    value: text.slice(index + 1).trim()
  };
}

function unquoteDoubleQuoted(text) {
  return text
    .slice(1, -1)
    .replace(/\\n/g, "\n")
    .replace(/\\"/g, "\"")
    .replace(/\\\\/g, "\\");
}

function unquoteSingleQuoted(text) {
  return text.slice(1, -1).replace(/''/g, "'");
}

function splitInlineList(text, area, lineNumber) {
  const values = [];
  let current = "";
  let quote = "";
  let escaped = false;

  for (const char of text) {
    if (escaped) {
      current += char;
      escaped = false;
      continue;
    }
    if (quote === "\"" && char === "\\") {
      current += char;
      escaped = true;
      continue;
    }
    if (quote) {
      current += char;
      if (char === quote) {
        quote = "";
      }
      continue;
    }
    if (char === "\"" || char === "'") {
      quote = char;
      current += char;
      continue;
    }
    if (char === ",") {
      values.push(current.trim());
      current = "";
      continue;
    }
    current += char;
  }

  if (quote) {
    fail(area, "Unclosed quote in inline list.", lineNumber);
  }

  if (current.trim().length > 0) {
    values.push(current.trim());
  }

  return values;
}

function parseScalar(text, area, lineNumber) {
  if (text === "") {
    return "";
  }
  if (text.startsWith("[") && text.endsWith("]")) {
    const body = text.slice(1, -1).trim();
    return body.length === 0
      ? []
      : splitInlineList(body, area, lineNumber).map(item => parseScalar(item, area, lineNumber));
  }
  if (text.startsWith("\"") && text.endsWith("\"")) {
    return unquoteDoubleQuoted(text);
  }
  if (text.startsWith("'") && text.endsWith("'")) {
    return unquoteSingleQuoted(text);
  }
  if (/^(true|false)$/i.test(text)) {
    return text.toLowerCase() === "true";
  }
  if (/^-?\d+$/.test(text)) {
    return Number(text);
  }
  if (/^-?\d+\.\d+$/.test(text)) {
    return Number(text);
  }

  return text;
}

function parseYamlBlock(lines, index, indent, area) {
  if (index >= lines.length) {
    return { value: null, index };
  }

  if (lines[index].indent < indent) {
    return { value: null, index };
  }

  return lines[index].text.startsWith("- ")
    ? parseYamlArray(lines, index, lines[index].indent, area)
    : parseYamlObject(lines, index, lines[index].indent, area);
}

function parseYamlArray(lines, index, indent, area) {
  const result = [];

  while (index < lines.length) {
    const line = lines[index];
    if (line.indent < indent) {
      break;
    }
    if (line.indent > indent) {
      fail(area, "Unexpected indentation.", line.line);
    }
    if (!line.text.startsWith("- ")) {
      break;
    }

    const itemText = line.text.slice(2).trim();
    if (itemText.length === 0) {
      const nested = parseYamlBlock(lines, index + 1, indent + 2, area);
      result.push(nested.value);
      index = nested.index;
      continue;
    }

    if (itemText.includes(":")) {
      const item = {};
      const pair = splitKeyValue(itemText, area, line.line);
      item[pair.key] = pair.value.length === 0
        ? {}
        : parseScalar(pair.value, area, line.line);
      index += 1;

      if (index < lines.length && lines[index].indent > indent) {
        const nested = parseYamlObject(lines, index, lines[index].indent, area);
        Object.assign(item, nested.value);
        index = nested.index;
      }

      result.push(item);
      continue;
    }

    result.push(parseScalar(itemText, area, line.line));
    index += 1;
    if (index < lines.length && lines[index].indent > indent) {
      fail(area, "Scalar list item cannot contain nested YAML.", lines[index].line);
    }
  }

  return { value: result, index };
}

function parseYamlObject(lines, index, indent, area) {
  const result = {};

  while (index < lines.length) {
    const line = lines[index];
    if (line.indent < indent) {
      break;
    }
    if (line.indent > indent) {
      fail(area, "Unexpected indentation.", line.line);
    }
    if (line.text.startsWith("- ")) {
      break;
    }

    const pair = splitKeyValue(line.text, area, line.line);
    index += 1;
    if (pair.value.length > 0) {
      result[pair.key] = parseScalar(pair.value, area, line.line);
      continue;
    }

    if (index < lines.length && lines[index].indent > indent) {
      const nested = parseYamlBlock(lines, index, lines[index].indent, area);
      result[pair.key] = nested.value;
      index = nested.index;
    } else {
      result[pair.key] = {};
    }
  }

  return { value: result, index };
}

function parseYamlDocument(text, area) {
  if (!nonEmpty(text)) {
    fail(area, "Input is empty.");
  }

  const lines = prepareYamlLines(text, area);
  if (lines.length === 0) {
    fail(area, "Input is empty.");
  }

  const parsed = parseYamlBlock(lines, 0, lines[0].indent, area);
  if (parsed.index < lines.length) {
    fail(area, "Unexpected trailing YAML content.", lines[parsed.index].line);
  }

  return parsed.value;
}

function parseFtl(text) {
  const entries = new Map();
  let currentKey = "";
  const lines = `${text ?? ""}`.replace(/\r\n/g, "\n").split("\n");

  function hasFollowingContinuation(startIndex) {
    for (let index = startIndex; index < lines.length; index += 1) {
      const nextLine = lines[index];
      const trimmed = nextLine.trim();
      if (trimmed.length === 0 || trimmed.startsWith("#")) {
        continue;
      }
      return /^\s+/.test(nextLine);
    }

    return false;
  }

  lines.forEach((line, index) => {
    const trimmed = line.trim();
    if (trimmed.length === 0) {
      if (currentKey && hasFollowingContinuation(index + 1)) {
        const previous = entries.get(currentKey) ?? "";
        entries.set(currentKey, `${previous}\n`);
      }
      return;
    }
    if (trimmed.startsWith("#")) {
      return;
    }

    const match = line.match(/^([A-Za-z0-9_.-]+)\s*=\s?(.*)$/);
    if (match) {
      currentKey = match[1];
      entries.set(currentKey, match[2] ?? "");
      return;
    }

    if (/^\s+/.test(line) && currentKey) {
      const previous = entries.get(currentKey) ?? "";
      entries.set(currentKey, `${previous}\n${line.replace(/^\s{1,4}/, "")}`);
      return;
    }

    fail("FTL", `Expected "key = value" entry.`, index + 1);
  });

  return entries;
}

function asArray(value) {
  return Array.isArray(value) ? value : [];
}

function asObject(value) {
  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
}

function asString(value) {
  return value === undefined || value === null ? "" : `${value}`;
}

function asNumber(value, fallback = 0) {
  const number = Number(value);
  return Number.isFinite(number) ? number : fallback;
}

function asBoolean(value, fallback = false) {
  if (typeof value === "boolean") {
    return value;
  }
  if (typeof value === "string" && /^(true|false)$/i.test(value)) {
    return value.toLowerCase() === "true";
  }
  return fallback;
}

function requireString(value, area, message) {
  const text = asString(value);
  if (!nonEmpty(text)) {
    fail(area, message);
  }
  return text;
}

function readLoc(ftlEntries, key, area, fieldName, required = false) {
  const locKey = asString(key);
  if (!nonEmpty(locKey)) {
    if (required) {
      fail(area, `Missing required loc key ${fieldName}.`);
    }
    return "";
  }

  if (!ftlEntries.has(locKey)) {
    fail("FTL", `Missing FTL entry "${locKey}" referenced by ${fieldName}.`);
  }

  return ftlEntries.get(locKey) ?? "";
}

function mapPredicate(rawPredicate, fallbackScope) {
  const raw = asObject(rawPredicate);
  const compareTo = asObject(raw.compareTo);
  return {
    scope: asString(raw.scope) || fallbackScope,
    field: asString(raw.field),
    operator: asString(raw.operator) || "equals",
    key: asString(raw.key),
    value: asString(raw.value),
    values: asArray(raw.values).map(asString).filter(item => nonEmpty(item)),
    valueFrom: asString(raw.valueFrom),
    valueTo: asString(raw.valueTo),
    compareTo: nonEmpty(compareTo.slotId)
      ? {
          scope: asString(compareTo.scope) || "slot",
          slotId: asString(compareTo.slotId),
          field: asString(compareTo.field)
        }
      : null
  };
}

function mapTextBindings(rawBindings) {
  const bindings = asObject(rawBindings);
  return Object.entries(bindings).map(([parameter, rawBinding]) => {
    const binding = asObject(rawBinding);
    return {
      parameter,
      source: asString(binding.source) || TEXT_BINDING_SOURCES.self,
      slotId: asString(binding.slotId),
      field: asString(binding.field),
      value: asString(binding.value)
    };
  });
}

function mapVisibility(rawVisibility) {
  const visibility = asObject(rawVisibility);
  const reveal = asObject(visibility.reveal);
  const enabled = Object.keys(visibility).length > 0;
  return {
    visibilityEnabled: enabled,
    visibilityType: asString(visibility.type) || VISIBILITY_TYPES.visible,
    revealType: asString(reveal.type) || REVEAL_TYPES.none,
    revealMinutes: asNumber(reveal.minutes, 15)
  };
}

function mapSlot(rawEntry) {
  const entry = asObject(rawEntry);
  const visibility = mapVisibility(entry.visibilityOverride);
  return {
    slotId: asString(entry.slotId),
    kind: asString(entry.kind),
    intentionId: asString(entry.intentionId),
    required: asBoolean(entry.required, true),
    candidatePredicates: asArray(entry.candidatePredicates).map(item => mapPredicate(item, "candidate")),
    bindToSlot: asString(entry.bindToSlot),
    allowSameActorAs: asArray(entry.allowSameActorAs).map(asString).filter(item => nonEmpty(item)),
    textParameterBindings: mapTextBindings(entry.textParameterBindings),
    ...visibility
  };
}

function mapIntention(rawTemplate, ftlEntries, expectedKind) {
  const template = asObject(rawTemplate);
  const id = requireString(template.id, "Intentions YAML", "Intention template is missing id.");
  const kind = asString(template.kind) || expectedKind;
  const icon = asObject(template.icon);
  const tags = asArray(template.tags).map(asString).filter(item => nonEmpty(item));

  return {
    id,
    kind,
    name: readLoc(ftlEntries, template.nameLoc, "Intentions YAML", `${id}.nameLoc`, true),
    summary: readLoc(ftlEntries, template.summaryLoc, "Intentions YAML", `${id}.summaryLoc`),
    description: readLoc(ftlEntries, template.descriptionLoc, "Intentions YAML", `${id}.descriptionLoc`, true),
    oocInfo: readLoc(ftlEntries, template.oocInfoLoc, "Intentions YAML", `${id}.oocInfoLoc`),
    copyableText: readLoc(ftlEntries, template.copyableTextLoc, "Intentions YAML", `${id}.copyableTextLoc`),
    defaultVisibility: asString(template.defaultVisibility) || VISIBILITY_TYPES.visible,
    hiddenLabel: readLoc(ftlEntries, template.hiddenLabelLoc, "Intentions YAML", `${id}.hiddenLabelLoc`),
    iconEnabled: nonEmpty(icon.sprite) && nonEmpty(icon.state),
    iconSprite: asString(icon.sprite),
    iconState: asString(icon.state),
    color: asString(template.color),
    tags,
    tagsInput: tags.join(", "),
    author: asString(template.author),
    creationDate: asString(template.creationDate)
  };
}

function selectOneTemplate(items, type, area) {
  const matches = asArray(items).filter(item => asObject(item).type === type);
  if (matches.length !== 1) {
    fail(area, `Expected exactly one ${type}, found ${matches.length}.`);
  }
  return matches[0];
}

function importScenarioPackage({
  scenarioYaml,
  intentionsYaml,
  ftlText,
  locale = "ru"
}) {
  const errors = [];
  let scenarioItems = null;
  let intentionItems = null;
  let ftlEntries = null;

  try {
    scenarioItems = parseYamlDocument(scenarioYaml, "Scenario YAML");
  } catch (error) {
    errors.push(error instanceof ImportFailure ? importError(error.area, error.message, error.line) : importError("Scenario YAML", `${error}`));
  }

  try {
    intentionItems = parseYamlDocument(intentionsYaml, "Intentions YAML");
  } catch (error) {
    errors.push(error instanceof ImportFailure ? importError(error.area, error.message, error.line) : importError("Intentions YAML", `${error}`));
  }

  try {
    ftlEntries = parseFtl(ftlText);
    if (ftlEntries.size === 0) {
      fail("FTL", "Input is empty.");
    }
  } catch (error) {
    errors.push(error instanceof ImportFailure ? importError(error.area, error.message, error.line) : importError("FTL", `${error}`));
  }

  if (errors.length > 0) {
    return { draft: null, errors };
  }

  try {
    const scenarioTemplate = selectOneTemplate(scenarioItems, "scenarioTemplate", "Scenario YAML");
    const intentionTemplates = asArray(intentionItems).filter(item => asObject(item).type === "intentionTemplate");
    if (intentionTemplates.length === 0) {
      fail("Intentions YAML", "No intentionTemplate entries found.");
    }

    const intentionsById = new Map();
    for (const template of intentionTemplates) {
      const id = asString(asObject(template).id);
      if (!nonEmpty(id)) {
        fail("Intentions YAML", "Intention template is missing id.");
      }
      if (intentionsById.has(id)) {
        fail("Intentions YAML", `Duplicate intentionTemplate id "${id}".`);
      }
      intentionsById.set(id, template);
    }

    const entries = asArray(scenarioTemplate.entries);
    const ownerEntry = entries.find(entry => asObject(entry).slotId === "owner" && asObject(entry).kind === "primary");
    if (!ownerEntry) {
      fail("Scenario YAML", "Owner entry with slotId: owner and kind: primary was not found.");
    }

    const ownerIntentionId = requireString(ownerEntry.intentionId, "Scenario YAML", "Owner entry is missing intentionId.");
    const ownerTemplate = intentionsById.get(ownerIntentionId);
    if (!ownerTemplate) {
      fail("Intentions YAML", `Missing intentionTemplate "${ownerIntentionId}" referenced by owner entry.`);
    }

    const secondaryEntries = entries.filter(entry => entry !== ownerEntry);
    const secondaryIntentions = [];
    const secondarySlots = [];
    for (const entry of secondaryEntries) {
      const slot = mapSlot(entry);
      if (!nonEmpty(slot.intentionId)) {
        fail("Scenario YAML", `Entry "${slot.slotId || "<unknown>"}" is missing intentionId.`);
      }
      const template = intentionsById.get(slot.intentionId);
      if (!template) {
        fail("Intentions YAML", `Missing intentionTemplate "${slot.intentionId}" referenced by slot "${slot.slotId}".`);
      }

      secondaryIntentions.push(mapIntention(template, ftlEntries, "secondary"));
      secondarySlots.push(slot);
    }

    const ownerSlot = mapSlot(ownerEntry);
    const rawDraft = {
      scenario: {
        id: asString(scenarioTemplate.id),
        name: asString(scenarioTemplate.name),
        category: asString(scenarioTemplate.category),
        enabled: asBoolean(scenarioTemplate.enabled, true),
        weight: asNumber(scenarioTemplate.weight, 1)
      },
      ownerIntention: mapIntention(ownerTemplate, ftlEntries, "primary"),
      secondaryIntentions,
      ownerSlot,
      secondarySlots,
      globalPredicates: asArray(scenarioTemplate.globalPredicates).map(item => mapPredicate(item, "round")),
      lastUpdatedAt: new Date().toISOString()
    };

    return {
      draft: normalizeDraft(rawDraft, locale),
      errors: []
    };
  } catch (error) {
    errors.push(error instanceof ImportFailure ? importError(error.area, error.message, error.line) : importError("Import", `${error}`));
    return { draft: null, errors };
  }
}


/* js/app.js */
const VISIBILITY_LABELS = {
  visible: { ru: "visible · видно", en: "visible" },
  hidden: { ru: "hidden · скрыто", en: "hidden" }
};

const REVEAL_LABELS = {
  none: { ru: "none · без авто-раскрытия", en: "none" },
  timer: { ru: "timer · по таймеру", en: "timer" }
};

const SOURCE_LABELS = {
  self: { ru: "self", en: "self" },
  slot: { ru: "slot", en: "slot" },
  round: { ru: "round", en: "round" },
  literal: { ru: "literal", en: "literal" }
};

const BOOLEAN_OPTIONS = [
  { id: "true", label: { ru: "true · да", en: "true" } },
  { id: "false", label: { ru: "false · нет", en: "false" } }
];

const MODAL_TYPES = {
  rules: "rules",
  categories: "categories",
  import: "import"
};

const INTENTION_CONTENT_FIELDS = [
  "name",
  "summary",
  "description",
  "oocInfo",
  "copyableText",
  "hiddenLabel"
];

const INTENTION_COPY_FIELDS = [
  ...INTENTION_CONTENT_FIELDS,
  "defaultVisibility",
  "author",
  "creationDate",
  "tags",
  "tagsInput",
  "color",
  "iconEnabled",
  "iconSprite",
  "iconState"
];

const SLOT_COPY_FIELDS = [
  "candidatePredicates",
  "textParameterBindings"
];

const HISTORY_MAX_DEPTH = 100;
const HISTORY_TEXT_COALESCE_MS = 1200;

function localized(locale, value) {
  return getLocalizedText(locale, value);
}

function fieldText(locale, key, params = {}) {
  return t(locale, `ui.fields.${key}`, params);
}

function hintText(locale, key, params = {}) {
  return t(locale, `ui.fieldHints.${key}`, params);
}

function buttonText(locale, key, params = {}) {
  return t(locale, `ui.buttons.${key}`, params);
}

function selectText(locale, key, params = {}) {
  return t(locale, `ui.select.${key}`, params);
}

function placeholderText(locale, key, params = {}) {
  return t(locale, `ui.placeholders.${key}`, params);
}

function exportText(locale, key, params = {}) {
  return t(locale, `ui.export.${key}`, params);
}

function issueSeverityText(locale, severity) {
  return t(locale, `severity.${severity}`);
}

function operatorLabel(locale, operator) {
  return t(locale, `operators.${operator}`);
}

function dictionaryLabel(locale, dictionaryName, value) {
  const label = getDictionaryLabel(dictionaryName, value);
  return typeof label === "string"
    ? label
    : localized(locale, label);
}

function predicateTitle(locale, index) {
  return locale === "ru" ? `Предикат ${index}` : `Predicate ${index}`;
}

function secondaryTemplateTitle(locale, index) {
  return locale === "ru" ? `Шаблон ${index}` : `Template ${index}`;
}

function secondarySlotTitle(locale, index) {
  return locale === "ru" ? `Слот ${index}` : `Slot ${index}`;
}

function renderHelpIcon(text) {
  if (!text) {
    return "";
  }

  return `
    <span class="help-icon" tabindex="0" aria-label="${escapeHtml(text)}" data-tooltip="${escapeHtml(text)}">?</span>
  `;
}

function renderFieldLabel(label, helpText = "") {
  return `
    <span class="field-label">
      ${escapeHtml(label)}
      ${renderHelpIcon(helpText)}
    </span>
  `;
}

function renderHint(text, counter = "") {
  if (!text && !counter) {
    return "";
  }

  return `
    <div class="field-hint-row">
      <span class="field-hint">${escapeHtml(text)}</span>
      ${counter}
    </div>
  `;
}

function renderCounter(current, max) {
  return `<span class="field-counter">${current} / ${max}</span>`;
}

function renderSelectOptions(locale, options, selectedValue, {
  allowEmpty = false,
  emptyLabel = ""
} = {}) {
  const html = [];
  if (allowEmpty) {
    html.push(`<option value="">${escapeHtml(emptyLabel || selectText(locale, "none"))}</option>`);
  }

  for (const option of options) {
    const selected = option.id === selectedValue ? " selected" : "";
    const label = typeof option.label === "string"
      ? option.label
      : localized(locale, option.label);
    html.push(`<option value="${escapeHtml(option.id)}"${selected}>${escapeHtml(label)}</option>`);
  }

  return html.join("");
}

function renderDatalist(id, values) {
  return `
    <datalist id="${escapeHtml(id)}">
      ${values.map(value => `<option value="${escapeHtml(value)}"></option>`).join("")}
    </datalist>
  `;
}

function getStatusTone(validation) {
  if (validation.errors.length > 0) {
    return "error";
  }
  if (validation.warnings.length > 0) {
    return "warning";
  }
  return "ok";
}

function createActionStatus(locale, key, params = {}, tone = "ok") {
  return {
    message: t(locale, key, params),
    tone
  };
}

function mountApp(root) {
  const initialLocale = loadLocale();
  const initialDraft = loadDraft(initialLocale) ?? createEmptyDraft(initialLocale);
  const initialTheme = loadTheme();

  const state = {
    locale: initialLocale,
    theme: initialTheme,
    draft: normalizeDraft(initialDraft, initialLocale),
    validation: validateDraft(initialDraft, initialLocale),
    artifacts: buildExportArtifacts(initialDraft),
    actionStatus: null,
    intentionClipboard: null,
    categoryDropdownOpen: false,
    searchableDropdown: {
      openId: "",
      filter: ""
    },
    predicateValueBuffers: {},
    importInputs: {
      scenarioYaml: "",
      intentionsYaml: "",
      ftlText: ""
    },
    importResult: null,
    pendingFocus: null,
    modal: null,
    textareaHeights: {},
    textareaScrollTops: {},
    history: {
      undoStack: [],
      redoStack: [],
      maxDepth: HISTORY_MAX_DEPTH,
      lastMutationKey: "",
      lastMutationAt: 0
    }
  };

  function synchronizeDraftTags({ normalizeBuffers = false } = {}) {
    for (const intention of getAllIntentions(state.draft)) {
      if (normalizeBuffers) {
        normalizeTagsOnBlur(intention);
      } else {
        intention.tags = splitTagsInput(intention.tagsInput ?? intention.tags ?? []);
      }
    }
  }

  function getControlKeyFromParts({
    entity = "",
    field = "",
    uid = "",
    ownerKind = "",
    ownerUid = ""
  }) {
    return [entity, field, uid, ownerKind, ownerUid].join("|");
  }

  function getControlKey(control) {
    return control.dataset.controlKey
      || getControlKeyFromParts({
        entity: control.dataset.entity ?? "",
        field: control.dataset.field ?? "",
        uid: control.dataset.uid ?? "",
        ownerKind: control.dataset.ownerKind ?? "",
        ownerUid: control.dataset.ownerUid ?? ""
      });
  }

  function rememberTextareaState(control) {
    if (!(control instanceof HTMLTextAreaElement)) {
      return;
    }
    if (!control.dataset.entity || !control.dataset.field) {
      return;
    }

    const key = getControlKey(control);
    if (key) {
      state.textareaHeights[key] = control.offsetHeight;
      state.textareaScrollTops[key] = control.scrollTop;
    }
  }

  function captureFocusSnapshot() {
    const active = document.activeElement;
    if (!active || !(active instanceof HTMLInputElement || active instanceof HTMLTextAreaElement || active instanceof HTMLSelectElement)) {
      return null;
    }
    if (!root.contains(active)) {
      return null;
    }
    rememberTextareaState(active);
    const controlKey = getControlKey(active);

    return {
      entity: active.dataset.entity ?? "",
      field: active.dataset.field ?? "",
      uid: active.dataset.uid ?? "",
      ownerKind: active.dataset.ownerKind ?? "",
      ownerUid: active.dataset.ownerUid ?? "",
      valueBuffer: active.dataset.valueBuffer ?? "",
      importField: active.dataset.importField ?? "",
      searchableFilterId: active.dataset.searchableFilterId ?? "",
      selectionStart: typeof active.selectionStart === "number" ? active.selectionStart : null,
      selectionEnd: typeof active.selectionEnd === "number" ? active.selectionEnd : null,
      scrollTop: active instanceof HTMLTextAreaElement ? active.scrollTop : null,
      controlKey
    };
  }

  function pushHistorySnapshot({
    key = "",
    coalesceMs = 0,
    force = false
  } = {}) {
    const now = Date.now();
    const canCoalesce = !force
      && key
      && coalesceMs > 0
      && state.history.lastMutationKey === key
      && now - state.history.lastMutationAt <= coalesceMs;

    if (canCoalesce) {
      state.history.lastMutationAt = now;
      return;
    }

    state.history.undoStack.push(deepClone(state.draft));
    if (state.history.undoStack.length > state.history.maxDepth) {
      state.history.undoStack.shift();
    }
    state.history.redoStack = [];
    state.history.lastMutationKey = key;
    state.history.lastMutationAt = now;
  }

  function resetHistoryCoalescing() {
    state.history.lastMutationKey = "";
    state.history.lastMutationAt = 0;
  }

  function clearTransientEditingState() {
    closeSearchableDropdown();
    state.categoryDropdownOpen = false;
    state.modal = null;
    state.predicateValueBuffers = {};
  }

  function restoreDraftFromHistory(snapshot) {
    const focusSnapshot = captureFocusSnapshot();
    state.draft = normalizeDraft(deepClone(snapshot), state.locale);
    clearTransientEditingState();
    restoreFocusSnapshot(focusSnapshot);
    recalculate({ save: true, preserveFocus: false });
  }

  function undoHistory() {
    const snapshot = state.history.undoStack.pop();
    if (!snapshot) {
      return;
    }

    state.history.redoStack.push(deepClone(state.draft));
    resetHistoryCoalescing();
    restoreDraftFromHistory(snapshot);
  }

  function redoHistory() {
    const snapshot = state.history.redoStack.pop();
    if (!snapshot) {
      return;
    }

    state.history.undoStack.push(deepClone(state.draft));
    if (state.history.undoStack.length > state.history.maxDepth) {
      state.history.undoStack.shift();
    }
    resetHistoryCoalescing();
    restoreDraftFromHistory(snapshot);
  }

  function restoreFocusSnapshot(snapshot) {
    if (!snapshot) {
      return;
    }

    let selector = "";
    if (snapshot.valueBuffer) {
      selector = `[data-value-buffer="${snapshot.valueBuffer}"]`;
    } else if (snapshot.importField) {
      selector = `[data-import-field="${snapshot.importField}"]`;
    } else if (snapshot.searchableFilterId) {
      selector = `[data-searchable-filter-id="${snapshot.searchableFilterId}"]`;
    } else if (snapshot.entity && snapshot.field) {
      selector = [
        `[data-entity="${snapshot.entity}"]`,
        `[data-field="${snapshot.field}"]`,
        snapshot.uid ? `[data-uid="${snapshot.uid}"]` : "",
        snapshot.ownerKind ? `[data-owner-kind="${snapshot.ownerKind}"]` : "",
        snapshot.ownerUid ? `[data-owner-uid="${snapshot.ownerUid}"]` : ""
      ].join("");
    }

    if (!selector) {
      return;
    }

    queueFocus(selector, snapshot.selectionStart, snapshot.selectionEnd, snapshot.scrollTop);
  }

  function recalculate({
    save = true,
    actionStatus = null,
    normalizeTagBuffers = false,
    preserveFocus = true
  } = {}) {
    const focusSnapshot = preserveFocus ? captureFocusSnapshot() : null;
    restoreFocusSnapshot(focusSnapshot);
    state.draft.ownerSlot.intentionId = state.draft.ownerIntention.id;
    synchronizeLinkedIntentions();
    state.draft.lastUpdatedAt = new Date().toISOString();
    synchronizeDraftTags({ normalizeBuffers: normalizeTagBuffers });
    state.validation = validateDraft(state.draft, state.locale);
    state.artifacts = buildExportArtifacts(state.draft);
    if (save) {
      saveDraft(state.draft);
    }
    state.actionStatus = actionStatus;
    render();
  }

  function queueFocus(selector, selectionStart = null, selectionEnd = null, scrollTop = null) {
    state.pendingFocus = { selector, selectionStart, selectionEnd, scrollTop };
  }

  function applyPendingFocus() {
    if (!state.pendingFocus) {
      return;
    }

    const pending = state.pendingFocus;
    state.pendingFocus = null;
    requestAnimationFrame(() => {
      const next = root.querySelector(pending.selector);
      if (!(next instanceof HTMLInputElement || next instanceof HTMLTextAreaElement || next instanceof HTMLSelectElement)) {
        return;
      }

      next.focus({ preventScroll: true });
      if (next instanceof HTMLTextAreaElement && pending.scrollTop !== null) {
        next.scrollTop = pending.scrollTop;
      }
      if (pending.selectionStart !== null && pending.selectionEnd !== null) {
        try {
          next.setSelectionRange(pending.selectionStart, pending.selectionEnd);
        } catch {
          // noop
        }
      }
    });
  }

  function setLocale(nextLocale) {
    state.locale = nextLocale;
    saveLocale(nextLocale);
    recalculate({ save: true });
  }

  function setTheme(nextTheme) {
    state.theme = nextTheme === "dark" ? "dark" : "light";
    saveTheme(state.theme);
    render();
  }

  function resetDraft() {
    pushHistorySnapshot({ key: "reset-draft", force: true });
    clearDraft();
    state.draft = createEmptyDraft(state.locale);
    resetHistoryCoalescing();
    recalculate({ save: true });
  }

  function withMutation(callback, options = {}) {
    const {
      history = true,
      historyKey = "",
      historyCoalesceMs = 0,
      historyForce = false,
      ...recalculateOptions
    } = options;
    if (history) {
      pushHistorySnapshot({
        key: historyKey,
        coalesceMs: historyCoalesceMs,
        force: historyForce
      });
    }
    callback();
    if (!historyKey || historyForce) {
      resetHistoryCoalescing();
    }
    recalculate(recalculateOptions);
  }

  function findSecondaryIntention(uid) {
    return state.draft.secondaryIntentions.find(item => item.uid === uid) ?? null;
  }

  function findLinkedIntention(slot) {
    if (!slot) {
      return null;
    }
    return state.draft.secondaryIntentions.find(item => item.uid === slot.linkedIntentionUid)
      ?? state.draft.secondaryIntentions.find(item => item.id === slot.intentionId)
      ?? null;
  }

  function synchronizeLinkedIntentions() {
    const used = new Set();
    for (const slot of state.draft.secondarySlots) {
      let intention = findLinkedIntention(slot);
      if (!intention || used.has(intention.uid)) {
        intention = state.draft.secondaryIntentions.find(item => !used.has(item.uid)) ?? null;
      }
      if (!intention) {
        intention = createSecondaryIntention(state.locale);
        state.draft.secondaryIntentions.push(intention);
      }
      slot.linkedIntentionUid = intention.uid;
      slot.intentionId = intention.id;
      used.add(intention.uid);
    }

    state.draft.secondaryIntentions = state.draft.secondaryIntentions.filter(intention => used.has(intention.uid));
  }

  function findSlot(ownerKind, uid) {
    if (ownerKind === "owner-slot") {
      return state.draft.ownerSlot;
    }
    return state.draft.secondarySlots.find(item => item.uid === uid) ?? null;
  }

  function findPredicate(ownerKind, ownerUid, uid) {
    const collection = ownerKind === "global"
      ? state.draft.globalPredicates
      : findSlot(ownerKind, ownerUid)?.candidatePredicates;
    return collection?.find(item => item.uid === uid) ?? null;
  }

  function findBinding(ownerKind, ownerUid, uid) {
    return findSlot(ownerKind, ownerUid)?.textParameterBindings.find(item => item.uid === uid) ?? null;
  }

  function getSlotsForSelection(excludeSlotId = "") {
    return getAllSlots(state.draft)
      .filter(slot => nonEmpty(slot.slotId) && slot.slotId !== excludeSlotId)
      .map(slot => ({
        id: slot.slotId,
        label: slot.slotId === "owner"
          ? { ru: "owner · владелец", en: "owner · scenario owner" }
          : slot.slotId
      }));
  }

  function getSecondaryIntentionOptions() {
    return state.draft.secondaryIntentions
      .filter(intention => nonEmpty(intention.id))
      .map(intention => ({
        id: intention.id,
        label: `${intention.id} · ${intention.name || t(state.locale, "ui.choose")}`
      }));
  }

  function getSearchableOptionLabel(option) {
    return typeof option.label === "string"
      ? option.label
      : localized(state.locale, option.label);
  }

  function filterSearchableOptions(options, filter) {
    const normalizedFilter = filter.trim().toLocaleLowerCase();
    if (!normalizedFilter) {
      return options;
    }

    return options.filter(option => {
      const label = getSearchableOptionLabel(option).toLocaleLowerCase();
      const id = option.id.toLocaleLowerCase();
      return label.includes(normalizedFilter) || id.includes(normalizedFilter);
    });
  }

  function closeSearchableDropdown() {
    state.searchableDropdown.openId = "";
    state.searchableDropdown.filter = "";
  }

  function setSearchableDropdownOpen(dropdownId, open) {
    if (open) {
      state.searchableDropdown.openId = dropdownId;
      state.searchableDropdown.filter = "";
      queueFocus(`[data-searchable-filter-id="${dropdownId}"]`);
      render();
      return;
    }

    closeSearchableDropdown();
    render();
  }

  function normalizePredicate(predicate, ownerKind, ownerUid) {
    const scope = ownerKind === "global" ? PREDICATE_SCOPES.round : PREDICATE_SCOPES.candidate;
    const currentSlotId = ownerKind === "global" ? "" : (findSlot(ownerKind, ownerUid)?.slotId ?? "");
    const fieldOptions = getFieldOptions(scope);
    if (!fieldOptions.some(item => item.id === predicate.field)) {
      predicate.field = fieldOptions[0]?.id ?? "";
    }

    const compareOptions = getSlotsForSelection(currentSlotId);
    const allowCompareOperators = scope === PREDICATE_SCOPES.candidate && compareOptions.length > 0;
    const allowedOperators = getAllowedOperators(scope, predicate.field, { allowCompareOperators });
    if (!allowedOperators.includes(predicate.operator)) {
      predicate.operator = allowedOperators[0];
    }

    const fieldDefinition = getFieldDefinition(scope, predicate.field);
    if (fieldDefinition?.type !== "map-int") {
      predicate.key = "";
    }

    if (predicate.operator === PREDICATE_OPERATORS.sameAs || predicate.operator === PREDICATE_OPERATORS.notSameAs) {
      predicate.value = "";
      predicate.values = [];
      predicate.valueFrom = "";
      predicate.valueTo = "";
      predicate.compareTo = {
        scope: PREDICATE_SCOPES.slot,
        slotId: predicate.compareTo?.slotId || compareOptions[0]?.id || "",
        field: predicate.field
      };
      return;
    }

    predicate.compareTo = null;

    if (predicate.operator === PREDICATE_OPERATORS.in || predicate.operator === PREDICATE_OPERATORS.notIn) {
      predicate.value = "";
      predicate.valueFrom = "";
      predicate.valueTo = "";
      return;
    }

    if (predicate.operator === PREDICATE_OPERATORS.between) {
      predicate.value = "";
      predicate.values = [];
      return;
    }

    predicate.values = [];
    predicate.valueFrom = "";
    predicate.valueTo = "";
  }

  function normalizeBinding(binding) {
    if (binding.source === TEXT_BINDING_SOURCES.round) {
      binding.slotId = "";
      binding.value = "";
      if (!ROUND_TEXT_BINDING_FIELDS.some(field => field.id === binding.field)) {
        binding.field = ROUND_TEXT_BINDING_FIELDS[0]?.id ?? "";
      }
      return;
    }

    if (binding.source === TEXT_BINDING_SOURCES.literal) {
      binding.slotId = "";
      binding.field = "";
      return;
    }

    binding.value = "";
    if (!TEXT_BINDING_FIELDS.some(field => field.id === binding.field)) {
      binding.field = TEXT_BINDING_FIELDS[0]?.id ?? "";
    }
    if (binding.source === TEXT_BINDING_SOURCES.self) {
      binding.slotId = "";
    }
  }

  function getInputHistoryOptions(target) {
    if (!(target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement)) {
      return {};
    }
    if (!target.dataset.entity || !target.dataset.field) {
      return {};
    }

    return {
      historyKey: `input:${getControlKey(target)}`,
      historyCoalesceMs: HISTORY_TEXT_COALESCE_MS
    };
  }

  function setField(target, options = {}) {
    const entity = target.dataset.entity;
    const field = target.dataset.field;
    const uid = target.dataset.uid;
    const ownerKind = target.dataset.ownerKind;
    const ownerUid = target.dataset.ownerUid;
    const valueType = target.dataset.valueType ?? "text";

    let model = null;
    switch (entity) {
      case "scenario":
        model = state.draft.scenario;
        break;
      case "owner-intention":
        model = state.draft.ownerIntention;
        break;
      case "secondary-intention":
        model = findSecondaryIntention(uid);
        break;
      case "owner-slot":
        model = state.draft.ownerSlot;
        break;
      case "slot":
        model = findSlot("slot", uid);
        break;
      case "predicate":
        model = findPredicate(ownerKind, ownerUid, uid);
        break;
      case "binding":
        model = findBinding(ownerKind, ownerUid, uid);
        break;
    }

    if (!model || !field) {
      return;
    }

    let nextValue;
    switch (valueType) {
      case "checkbox":
        nextValue = target.checked;
        break;
      case "number":
        nextValue = target.value === "" ? 0 : Number(target.value);
        break;
      default:
        nextValue = target.value;
        break;
    }

    withMutation(() => {
      if (entity === "predicate" && field === "compareSlotId") {
        model.compareTo = nextValue
          ? {
              scope: PREDICATE_SCOPES.slot,
              slotId: nextValue,
              field: model.field
            }
          : null;
        return;
      }

      model[field] = nextValue;

      if (entity === "owner-intention" && field === "id") {
        state.draft.ownerSlot.intentionId = model.id;
      }

      if (entity === "predicate" && field === "field" && model.compareTo) {
        model.compareTo.field = nextValue;
      }

      if (entity === "predicate") {
        normalizePredicate(model, ownerKind, ownerUid);
      }

      if (entity === "binding") {
        normalizeBinding(model);
      }

      if ((entity === "slot" || entity === "owner-slot") && field === "bindToSlot" && nonEmpty(model.bindToSlot)) {
        model.allowSameActorAs = [];
        model.candidatePredicates = [];
      }

      if ((entity === "slot" || entity === "owner-slot") && field === "visibilityType" && model.visibilityType === VISIBILITY_TYPES.visible) {
        model.revealType = REVEAL_TYPES.none;
      }
    }, options);
  }

  async function downloadArtifact(kind) {
    if (state.validation.errors.length > 0) {
      recalculate({
        save: false,
        actionStatus: createActionStatus(state.locale, "ui.export.blocked", {}, "error")
      });
      return;
    }

    const artifact = state.artifacts[kind];
    if (!artifact) {
      return;
    }

    const blob = new Blob([artifact.content], { type: "text/plain;charset=utf-8" });
    const url = URL.createObjectURL(blob);
    const anchor = document.createElement("a");
    anchor.href = url;
    anchor.download = artifact.filename;
    anchor.click();
    URL.revokeObjectURL(url);

    recalculate({
      save: false,
      actionStatus: createActionStatus(state.locale, "ui.export.downloaded", { filename: artifact.filename })
    });
  }

  async function copyArtifact(kind) {
    if (state.validation.errors.length > 0) {
      recalculate({
        save: false,
        actionStatus: createActionStatus(state.locale, "ui.export.blocked", {}, "error")
      });
      return;
    }

    const artifact = state.artifacts[kind];
    if (!artifact) {
      return;
    }

    try {
      await navigator.clipboard.writeText(artifact.content);
      recalculate({
        save: false,
        actionStatus: createActionStatus(state.locale, "ui.export.copied", { filename: artifact.filename })
      });
    } catch {
      recalculate({
        save: false,
        actionStatus: createActionStatus(state.locale, "ui.export.copyFailed", {}, "error")
      });
    }
  }

  async function copyBindingToken(ownerKind, ownerUid, uid) {
    const binding = findBinding(ownerKind, ownerUid, uid);
    const parameter = nonEmpty(binding?.parameter);
    if (!parameter) {
      recalculate({
        save: false,
        actionStatus: createActionStatus(state.locale, "ui.copyPaste.bindingTokenEmpty", {}, "warning")
      });
      return;
    }

    try {
      const token = `{$${parameter}}`;
      await navigator.clipboard.writeText(token);
      recalculate({
        save: false,
        actionStatus: createActionStatus(state.locale, "ui.copyPaste.bindingTokenCopied", { token })
      });
    } catch {
      recalculate({
        save: false,
        actionStatus: createActionStatus(state.locale, "ui.export.copyFailed", {}, "error")
      });
    }
  }

  function runImportScenarioPackage() {
    const result = importScenarioPackage({
      scenarioYaml: state.importInputs.scenarioYaml,
      intentionsYaml: state.importInputs.intentionsYaml,
      ftlText: state.importInputs.ftlText,
      locale: state.locale
    });

    if (result.errors.length > 0 || !result.draft) {
      state.importResult = {
        tone: "error",
        messages: result.errors.map(error => `${error.area}: ${error.message}`)
      };
      render();
      return;
    }

    const validation = validateDraft(result.draft, state.locale);
    if (validation.errors.length > 0) {
      state.importResult = {
        tone: "error",
        messages: validation.errors.map(error => `Validation: ${error.path}: ${error.message}`)
      };
      render();
      return;
    }

    withMutation(() => {
      state.draft = result.draft;
      state.importResult = {
        tone: "ok",
        messages: [t(state.locale, "ui.import.success")]
      };
      state.categoryDropdownOpen = false;
      state.searchableDropdown.openId = "";
      state.searchableDropdown.filter = "";
      state.predicateValueBuffers = {};
      state.textareaHeights = {};
      state.textareaScrollTops = {};
    }, {
      historyKey: "import-scenario-package",
      historyForce: true,
      preserveFocus: false,
      actionStatus: createActionStatus(state.locale, "ui.import.success")
    });
  }

  function handleClick(event) {
    const target = event.target;
    if (!(target instanceof Element)) {
      return;
    }

    const button = target.closest("[data-action]");
    if (!button) {
      if (state.modal) {
        const backdrop = target.closest(".modal-backdrop");
        const insideCard = target.closest("[data-modal-card]");
        if (backdrop && !insideCard) {
          state.modal = null;
          render();
        }
      }
      if (state.categoryDropdownOpen && !target.closest("[data-category-picker]")) {
        state.categoryDropdownOpen = false;
        render();
      }
      if (state.searchableDropdown.openId && !target.closest("[data-searchable-dropdown]")) {
        closeSearchableDropdown();
        render();
      }
      return;
    }

    const action = button.dataset.action;
    if (
      state.categoryDropdownOpen &&
      action !== "toggle-category-dropdown" &&
      action !== "set-category" &&
      !button.closest("[data-category-picker]")
    ) {
      state.categoryDropdownOpen = false;
    }
    if (
      state.searchableDropdown.openId &&
      ![
        "toggle-searchable-dropdown",
        "select-searchable-value",
        "clear-searchable-value"
      ].includes(action) &&
      !button.closest("[data-searchable-dropdown]")
    ) {
      closeSearchableDropdown();
    }

    switch (action) {
      case "reset-draft":
        resetDraft();
        return;
      case "set-locale":
        setLocale(button.dataset.locale);
        return;
      case "set-theme":
        setTheme(button.dataset.theme);
        return;
      case "toggle-category-dropdown":
        state.categoryDropdownOpen = !state.categoryDropdownOpen;
        render();
        return;
      case "set-category":
        withMutation(() => {
          state.draft.scenario.category = button.dataset.categoryId;
          state.categoryDropdownOpen = false;
        });
        return;
      case "toggle-searchable-dropdown":
        setSearchableDropdownOpen(
          button.dataset.dropdownId,
          state.searchableDropdown.openId !== button.dataset.dropdownId
        );
        return;
      case "select-searchable-value":
        if (button.dataset.mode === "buffer") {
          state.predicateValueBuffers[button.dataset.uid] = button.dataset.value ?? "";
          closeSearchableDropdown();
          render();
          return;
        }
        withMutation(() => {
          const predicate = findPredicate(button.dataset.ownerKind, button.dataset.ownerUid, button.dataset.uid);
          if (!predicate) {
            return;
          }
          if (button.dataset.mode === "key") {
            predicate.key = button.dataset.value ?? "";
          } else {
            predicate.value = button.dataset.value ?? "";
          }
          closeSearchableDropdown();
        });
        return;
      case "clear-searchable-value":
        if (button.dataset.mode === "buffer") {
          state.predicateValueBuffers[button.dataset.uid] = "";
          closeSearchableDropdown();
          render();
          return;
        }
        withMutation(() => {
          const predicate = findPredicate(button.dataset.ownerKind, button.dataset.ownerUid, button.dataset.uid);
          if (!predicate) {
            return;
          }
          if (button.dataset.mode === "key") {
            predicate.key = "";
          } else {
            predicate.value = "";
          }
          closeSearchableDropdown();
        });
        return;
      case "open-modal":
        state.modal = button.dataset.modal;
        render();
        return;
      case "close-modal":
        state.modal = null;
        render();
        return;
      case "clear-import-fields":
        state.importInputs = {
          scenarioYaml: "",
          intentionsYaml: "",
          ftlText: ""
        };
        state.importResult = null;
        render();
        return;
      case "add-secondary-intention":
        withMutation(() => {
          const intention = createSecondaryIntention(state.locale);
          const slot = createSecondarySlot(intention.uid);
          slot.intentionId = intention.id;
          state.draft.secondaryIntentions.push(intention);
          state.draft.secondarySlots.push(slot);
        });
        return;
      case "delete-secondary-intention":
        return;
      case "add-global-predicate":
        withMutation(() => {
          state.draft.globalPredicates.push(createPredicate(PREDICATE_SCOPES.round));
        });
        return;
      case "delete-global-predicate":
        withMutation(() => {
          state.draft.globalPredicates = state.draft.globalPredicates.filter(item => item.uid !== button.dataset.uid);
        });
        return;
      case "add-slot":
        withMutation(() => {
          const intention = createSecondaryIntention(state.locale);
          const slot = createSecondarySlot(intention.uid);
          slot.intentionId = intention.id;
          state.draft.secondaryIntentions.push(intention);
          state.draft.secondarySlots.push(slot);
        });
        return;
      case "delete-slot":
        if (!window.confirm(t(state.locale, "ui.confirmDeleteSlot"))) {
          return;
        }
        withMutation(() => {
          const slotUid = button.dataset.uid;
          const slot = findSlot("slot", slotUid);
          if (!slot) {
            return;
          }

          state.draft.secondarySlots = state.draft.secondarySlots.filter(item => item.uid !== slotUid);
          state.draft.secondaryIntentions = state.draft.secondaryIntentions.filter(item => item.uid !== slot.linkedIntentionUid);
          const removedSlotId = slot.slotId;
          for (const current of getAllSlots(state.draft)) {
            if (current.bindToSlot === removedSlotId) {
              current.bindToSlot = "";
            }
            current.allowSameActorAs = current.allowSameActorAs.filter(item => item !== removedSlotId);
            current.candidatePredicates.forEach(predicate => {
              if (predicate.compareTo?.slotId === removedSlotId) {
                predicate.compareTo = null;
                predicate.operator = PREDICATE_OPERATORS.equals;
              }
            });
            current.textParameterBindings.forEach(binding => {
              if (binding.slotId === removedSlotId) {
                binding.slotId = "";
              }
            });
          }
        });
        return;
      case "copy-intention-content":
        {
          const intention = button.dataset.entity === "owner-intention"
            ? state.draft.ownerIntention
            : findSecondaryIntention(button.dataset.uid);
          if (!intention) {
            return;
          }
          const slot = button.dataset.entity === "owner-intention"
            ? state.draft.ownerSlot
            : findSlot("slot", button.dataset.slotUid);
          state.intentionClipboard = {
            intention: Object.fromEntries(INTENTION_COPY_FIELDS.map(field => [field, deepClone(intention[field] ?? "")])),
            slot: slot
              ? Object.fromEntries(SLOT_COPY_FIELDS.map(field => [field, deepClone(slot[field] ?? [])]))
              : null
          };
          recalculate({
            save: false,
            actionStatus: createActionStatus(state.locale, "ui.copyPaste.copied")
          });
        }
        return;
      case "paste-intention-content":
        {
          if (!state.intentionClipboard) {
            return;
          }
          withMutation(() => {
            const intention = button.dataset.entity === "owner-intention"
              ? state.draft.ownerIntention
              : findSecondaryIntention(button.dataset.uid);
            if (!intention) {
              return;
            }
            const sourceIntention = state.intentionClipboard.intention ?? state.intentionClipboard;
            for (const field of INTENTION_COPY_FIELDS) {
              if (Object.hasOwn(sourceIntention, field)) {
                intention[field] = deepClone(sourceIntention[field]);
              }
            }
            const targetSlot = button.dataset.entity === "owner-intention"
              ? state.draft.ownerSlot
              : findSlot("slot", button.dataset.slotUid);
            if (targetSlot && state.intentionClipboard.slot) {
              for (const field of SLOT_COPY_FIELDS) {
                if (Object.hasOwn(state.intentionClipboard.slot, field)) {
                  targetSlot[field] = deepClone(state.intentionClipboard.slot[field]);
                }
              }
            }
          }, {
            actionStatus: createActionStatus(state.locale, "ui.copyPaste.pasted")
          });
        }
        return;
      case "add-slot-predicate":
        withMutation(() => {
          const slot = findSlot(button.dataset.ownerKind, button.dataset.ownerUid);
          if (!slot || nonEmpty(slot.bindToSlot)) {
            return;
          }
          slot.candidatePredicates.push(createPredicate(PREDICATE_SCOPES.candidate));
        });
        return;
      case "delete-predicate":
        withMutation(() => {
          const collection = button.dataset.ownerKind === "global"
            ? state.draft.globalPredicates
            : findSlot(button.dataset.ownerKind, button.dataset.ownerUid)?.candidatePredicates;
          if (!collection) {
            return;
          }
          const index = collection.findIndex(item => item.uid === button.dataset.uid);
          if (index >= 0) {
            collection.splice(index, 1);
          }
        });
        return;
      case "add-binding":
        withMutation(() => {
          const slot = findSlot(button.dataset.ownerKind, button.dataset.ownerUid);
          if (!slot) {
            return;
          }
          slot.textParameterBindings.push(createTextBinding());
        });
        return;
      case "delete-binding":
        withMutation(() => {
          const slot = findSlot(button.dataset.ownerKind, button.dataset.ownerUid);
          if (!slot) {
            return;
          }
          slot.textParameterBindings = slot.textParameterBindings.filter(item => item.uid !== button.dataset.uid);
        });
        return;
      case "copy-binding-token":
        copyBindingToken(button.dataset.ownerKind, button.dataset.ownerUid, button.dataset.uid);
        return;
      case "toggle-allow-same-actor":
        withMutation(() => {
          const slot = findSlot(button.dataset.ownerKind, button.dataset.ownerUid);
          if (!slot || nonEmpty(slot.bindToSlot)) {
            return;
          }
          const targetSlotId = button.dataset.targetSlotId;
          const exists = slot.allowSameActorAs.includes(targetSlotId);
          slot.allowSameActorAs = exists
            ? slot.allowSameActorAs.filter(item => item !== targetSlotId)
            : [...slot.allowSameActorAs, targetSlotId];
        });
        return;
      case "add-predicate-value":
        withMutation(() => {
          const predicate = findPredicate(button.dataset.ownerKind, button.dataset.ownerUid, button.dataset.uid);
          if (!predicate) {
            return;
          }
          const input = root.querySelector(`[data-value-buffer="${button.dataset.uid}"]`);
          const value = nonEmpty(state.predicateValueBuffers[button.dataset.uid] ?? input?.value);
          if (!value) {
            return;
          }
          predicate.values = [...predicate.values, value];
          state.predicateValueBuffers[button.dataset.uid] = "";
          if (input instanceof HTMLInputElement || input instanceof HTMLSelectElement) {
            input.value = "";
          }
        }, { save: true });
        return;
      case "remove-predicate-value":
        withMutation(() => {
          const predicate = findPredicate(button.dataset.ownerKind, button.dataset.ownerUid, button.dataset.uid);
          if (!predicate) {
            return;
          }
          const removeIndex = Number(button.dataset.valueIndex);
          predicate.values = predicate.values.filter((_, index) => index !== removeIndex);
        });
        return;
      case "copy-artifact":
        copyArtifact(button.dataset.kind);
        return;
      case "download-artifact":
        downloadArtifact(button.dataset.kind);
        return;
      case "import-scenario-package":
        runImportScenarioPackage();
        return;
    }
  }

  function handleInput(event) {
    const target = event.target;
    if (!(target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement || target instanceof HTMLSelectElement)) {
      return;
    }

    if (target.dataset.searchableFilterId) {
      state.searchableDropdown.filter = target.value;
      queueFocus(
        `[data-searchable-filter-id="${target.dataset.searchableFilterId}"]`,
        target.selectionStart ?? null,
        target.selectionEnd ?? null
      );
      render();
      return;
    }

    if (target.dataset.importField) {
      state.importInputs[target.dataset.importField] = target.value;
      return;
    }

    if (target.dataset.entity && target.dataset.field) {
      rememberTextareaState(target);
      const duplicateTextChange = event.type === "change"
        && !(target instanceof HTMLSelectElement)
        && target.type !== "checkbox";
      setField(target, duplicateTextChange ? { history: false } : getInputHistoryOptions(target));
    }
  }

  function handleFocusOut(event) {
    const target = event.target;
    if (!(target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement)) {
      return;
    }
    rememberTextareaState(target);
    if (target.dataset.field !== "tagsInput") {
      return;
    }

    const entity = target.dataset.entity;
    const uid = target.dataset.uid;
    const intention = entity === "owner-intention"
      ? state.draft.ownerIntention
      : entity === "secondary-intention"
        ? findSecondaryIntention(uid)
        : null;

    if (!intention) {
      return;
    }

    withMutation(() => {
      normalizeTagsOnBlur(intention);
    }, { history: false, normalizeTagBuffers: false });
  }

  function renderTopBar() {
    const draftTitle = nonEmpty(state.draft.scenario.name) || state.draft.scenario.id || t(state.locale, "ui.untitledDraft");
    return `
      <header class="app-topbar">
        <div class="brand-row">
          <strong>${escapeHtml(APP_TITLE)}</strong>
          <span>${escapeHtml(draftTitle)}</span>
        </div>
        <div class="topbar-actions">
          <div class="locale-switch" aria-label="${escapeHtml(t(state.locale, "ui.locale"))}">
            ${["ru", "en"].map(locale => `
              <button
                type="button"
                class="${locale === state.locale ? "is-active" : ""}"
                data-action="set-locale"
                data-locale="${locale}">
                ${escapeHtml(getLocaleLabel(locale))}
              </button>
            `).join("")}
          </div>
          <div class="locale-switch" aria-label="${escapeHtml(t(state.locale, "ui.theme"))}">
            ${["light", "dark"].map(theme => `
              <button
                type="button"
                class="${theme === state.theme ? "is-active" : ""}"
                data-action="set-theme"
                data-theme="${theme}">
                ${escapeHtml(t(state.locale, `ui.themes.${theme}`))}
              </button>
            `).join("")}
          </div>
          <button type="button" data-action="open-modal" data-modal="${MODAL_TYPES.import}">${escapeHtml(t(state.locale, "ui.import.openButton"))}</button>
          <button type="button" data-action="reset-draft">${escapeHtml(t(state.locale, "ui.reset"))}</button>
          <span class="version">v${APP_VERSION}</span>
        </div>
      </header>
    `;
  }

  function renderStatusPanel() {
    const tone = getStatusTone(state.validation);
    const chips = [
      { className: "error", label: t(state.locale, "ui.errors"), value: state.validation.errors.length },
      { className: "warning", label: t(state.locale, "ui.warnings"), value: state.validation.warnings.length },
      { className: "neutral", label: t(state.locale, "ui.secondaryTemplates"), value: state.draft.secondaryIntentions.length },
      { className: "neutral", label: t(state.locale, "ui.secondarySlots"), value: state.draft.secondarySlots.length }
    ];

    const message = state.actionStatus?.message
      ?? (state.validation.issues.length === 0 ? t(state.locale, "ui.statusOk") : t(state.locale, "ui.saveHint"));
    const messageTone = state.actionStatus?.tone ?? tone;

    return `
      <section class="sidebar-block status-panel status-panel-${tone}">
        <h2>${escapeHtml(t(state.locale, "ui.statusTitle"))}</h2>
        <div class="status-chip-row">
          ${chips.map(chip => `
            <div class="severity-chip severity-chip-${chip.className}">
              <span>${escapeHtml(chip.label)}</span>
              <strong>${chip.value}</strong>
            </div>
          `).join("")}
        </div>
        <p class="status-copy status-copy-${messageTone}">${escapeHtml(message)}</p>
      </section>
    `;
  }

  function renderIssue(issueItem) {
    return `
      <li class="issue issue-${issueItem.severity}">
        <div class="issue-head">
          <strong>${escapeHtml(issueSeverityText(state.locale, issueItem.severity))}</strong>
          <code>${escapeHtml(issueItem.code)}</code>
        </div>
        <span>${escapeHtml(issueItem.message)}</span>
        <code>${escapeHtml(issueItem.path)}</code>
      </li>
    `;
  }

  function renderIssuePanel() {
    return `
      <section class="sidebar-block">
        <h2>${escapeHtml(t(state.locale, "ui.issuesTitle"))}</h2>
        <ul class="issues-list">
          ${state.validation.issues.length === 0
            ? `<li class="issue issue-ok"><strong>${escapeHtml(t(state.locale, "severity.ok"))}</strong><span>${escapeHtml(t(state.locale, "ui.noIssues"))}</span></li>`
            : state.validation.issues.map(renderIssue).join("")}
        </ul>
      </section>
    `;
  }

  function renderValidationPanel() {
    return `
      <section class="editor-section validation-section">
        <div class="section-header">
          <div>
            <h2>${escapeHtml(t(state.locale, "ui.validationExportTitle"))}</h2>
            <p>${escapeHtml(t(state.locale, "ui.validationExportDescription"))}</p>
          </div>
        </div>
        <div class="bottom-grid">
          ${renderStatusPanel()}
          ${renderIssuePanel()}
        </div>
      </section>
    `;
  }

  function renderImportPanel() {
    const result = state.importResult;
    return `
      <section class="import-section">
        <div class="section-header">
          <div>
            <p>${escapeHtml(t(state.locale, "ui.import.description"))}</p>
          </div>
          <button type="button" data-action="import-scenario-package">${escapeHtml(t(state.locale, "ui.import.button"))}</button>
        </div>
        <div class="preview-grid import-grid">
          <label class="field">
            <span>${escapeHtml(t(state.locale, "ui.import.scenarioYaml"))}</span>
            <textarea
              rows="14"
              data-import-field="scenarioYaml"
              placeholder="${escapeHtml(t(state.locale, "ui.import.scenarioPlaceholder"))}">${escapeHtml(state.importInputs.scenarioYaml)}</textarea>
          </label>
          <label class="field">
            <span>${escapeHtml(t(state.locale, "ui.import.intentionsYaml"))}</span>
            <textarea
              rows="14"
              data-import-field="intentionsYaml"
              placeholder="${escapeHtml(t(state.locale, "ui.import.intentionsPlaceholder"))}">${escapeHtml(state.importInputs.intentionsYaml)}</textarea>
          </label>
          <label class="field">
            <span>${escapeHtml(t(state.locale, "ui.import.ftl"))}</span>
            <textarea
              rows="14"
              data-import-field="ftlText"
              placeholder="${escapeHtml(t(state.locale, "ui.import.ftlPlaceholder"))}">${escapeHtml(state.importInputs.ftlText)}</textarea>
          </label>
        </div>
        ${result ? `
          <div class="import-result import-result-${escapeHtml(result.tone)}">
            <strong>${escapeHtml(result.tone === "ok" ? t(state.locale, "ui.import.resultOk") : t(state.locale, "ui.import.resultError"))}</strong>
            <ul>
              ${result.messages.map(message => `<li>${escapeHtml(message)}</li>`).join("")}
            </ul>
          </div>
        ` : ""}
      </section>
    `;
  }

  function renderTextField({
    entity,
    field,
    value,
    label,
    hint,
    placeholder = "",
    uid = "",
    maxLength = "",
    rows = 0,
    type = "text",
    valueType = "text",
    counterMax = 0,
    ownerKind = "",
    ownerUid = "",
    disabled = false,
    dataListId = "",
    help = ""
  }) {
    const counter = counterMax > 0 ? renderCounter(`${value ?? ""}`.length, counterMax) : "";
    const controlKey = getControlKeyFromParts({ entity, field, uid, ownerKind, ownerUid });
    const textareaHeight = rows > 0 ? state.textareaHeights[controlKey] : null;
    const commonAttrs = `
      data-entity="${entity}"
      data-field="${field}"
      data-control-key="${escapeHtml(controlKey)}"
      ${uid ? `data-uid="${uid}"` : ""}
      ${ownerKind ? `data-owner-kind="${ownerKind}"` : ""}
      ${ownerUid ? `data-owner-uid="${ownerUid}"` : ""}
      ${valueType !== "text" ? `data-value-type="${valueType}"` : ""}
      ${maxLength ? `maxlength="${maxLength}"` : ""}
      ${placeholder ? `placeholder="${escapeHtml(placeholder)}"` : ""}
      ${disabled ? "disabled" : ""}
      ${dataListId ? `list="${dataListId}"` : ""}
      ${type === "text" && valueType === "number" ? `inputmode="numeric" pattern="[0-9]*"` : ""}
    `;

    const control = rows > 0
      ? `<textarea rows="${rows}" ${textareaHeight ? `style="height:${textareaHeight}px"` : ""} ${commonAttrs}>${escapeHtml(value)}</textarea>`
      : `<input type="${type}" value="${escapeHtml(value)}" ${commonAttrs}>`;

    return `
      <label class="field">
        ${renderFieldLabel(label, help)}
        ${control}
        ${renderHint(hint, counter)}
      </label>
    `;
  }

  function renderColorField(entity, field, value, uid = "") {
    const swatch = nonEmpty(value) ? value : "#00000000";
    return `
      <label class="field">
        <span>${escapeHtml(fieldText(state.locale, "color"))}</span>
        <div class="color-field">
          <span class="color-swatch" style="background:${escapeHtml(swatch)}"></span>
          <input
            type="text"
            value="${escapeHtml(value)}"
            data-entity="${entity}"
            data-field="${field}"
            ${uid ? `data-uid="${uid}"` : ""}
            placeholder="${escapeHtml(placeholderText(state.locale, "color"))}">
        </div>
        ${renderHint(hintText(state.locale, "color"))}
      </label>
    `;
  }

  function renderSearchableDropdown({
    dropdownId,
    selectedValue,
    options,
    placeholder,
    mode,
    uid,
    ownerKind = "",
    ownerUid = ""
  }) {
    const isOpen = state.searchableDropdown.openId === dropdownId;
    const filteredOptions = filterSearchableOptions(options, isOpen ? state.searchableDropdown.filter : "");
    const selectedOption = options.find(option => option.id === selectedValue) ?? null;
    const selectedLabel = selectedOption ? getSearchableOptionLabel(selectedOption) : placeholder;

    return `
      <div class="searchable-dropdown" data-searchable-dropdown="true">
        <button
          type="button"
          class="searchable-trigger"
          data-action="toggle-searchable-dropdown"
          data-dropdown-id="${escapeHtml(dropdownId)}"
          aria-haspopup="listbox"
          aria-expanded="${isOpen ? "true" : "false"}">
          <span class="${selectedOption ? "is-selected" : "is-placeholder"}">${escapeHtml(selectedLabel)}</span>
          <span aria-hidden="true">v</span>
        </button>
        ${isOpen ? `
          <div class="searchable-menu" role="listbox">
            <input
              type="text"
              class="searchable-filter"
              value="${escapeHtml(state.searchableDropdown.filter)}"
              data-searchable-filter-id="${escapeHtml(dropdownId)}"
              placeholder="${escapeHtml(placeholderText(state.locale, "searchValue"))}"
              aria-label="${escapeHtml(t(state.locale, "ui.searchValueAria"))}">
            <button
              type="button"
              class="searchable-option searchable-option-clear"
              data-action="clear-searchable-value"
              data-dropdown-id="${escapeHtml(dropdownId)}"
              data-mode="${escapeHtml(mode)}"
              data-uid="${escapeHtml(uid)}"
              ${ownerKind ? `data-owner-kind="${escapeHtml(ownerKind)}"` : ""}
              ${ownerUid ? `data-owner-uid="${escapeHtml(ownerUid)}"` : ""}>
              ${escapeHtml(selectText(state.locale, "clearValue"))}
            </button>
            <div class="searchable-options">
              ${filteredOptions.length > 0 ? filteredOptions.map(option => `
                <button
                  type="button"
                  class="searchable-option ${option.id === selectedValue ? "is-active" : ""}"
                  data-action="select-searchable-value"
                  data-dropdown-id="${escapeHtml(dropdownId)}"
                  data-mode="${escapeHtml(mode)}"
                  data-uid="${escapeHtml(uid)}"
                  data-value="${escapeHtml(option.id)}"
                  ${ownerKind ? `data-owner-kind="${escapeHtml(ownerKind)}"` : ""}
                  ${ownerUid ? `data-owner-uid="${escapeHtml(ownerUid)}"` : ""}
                  role="option"
                  aria-selected="${option.id === selectedValue ? "true" : "false"}">
                  <strong>${escapeHtml(option.id)}</strong>
                  <span>${escapeHtml(getSearchableOptionLabel(option))}</span>
                </button>
              `).join("") : `<div class="searchable-empty">${escapeHtml(selectText(state.locale, "noMatches"))}</div>`}
            </div>
          </div>
        ` : ""}
      </div>
    `;
  }

  function renderPredicateValueList(predicate, ownerKind, ownerUid, fieldDefinition) {
    const dictionaryName = fieldDefinition.type === "string" || fieldDefinition.type === "list-string"
      ? fieldDefinition.dictionary
      : "";
    const values = dictionaryName ? getDictionaryOptions(dictionaryName) : [];
    const bufferedValue = state.predicateValueBuffers[predicate.uid] ?? "";
    const inputControl = dictionaryName
      ? renderSearchableDropdown({
        dropdownId: `predicate-values-${predicate.uid}`,
        selectedValue: bufferedValue,
        options: values,
        placeholder: placeholderText(state.locale, "selectValue"),
        mode: "buffer",
        uid: predicate.uid
      })
      : `
        <input
          type="text"
          ${fieldDefinition.type === "int" || fieldDefinition.type === "map-int" ? `inputmode="numeric" pattern="[0-9]*"` : ""}
          data-value-buffer="${predicate.uid}"
          placeholder="${escapeHtml(placeholderText(state.locale, "addValue"))}">
      `;

    return `
      <div class="field">
        ${renderFieldLabel(fieldText(state.locale, "values"), hintText(state.locale, "values"))}
        <div class="inline-editor inline-editor-wide">
          ${inputControl}
          <button
            type="button"
            data-action="add-predicate-value"
            data-owner-kind="${ownerKind}"
            data-owner-uid="${ownerUid}"
            data-uid="${predicate.uid}">
            ${escapeHtml(t(state.locale, "ui.add"))}
          </button>
        </div>
        <div class="chips">
          ${predicate.values.map((value, index) => `
            <span class="chip">
              ${escapeHtml(dictionaryName ? dictionaryLabel(state.locale, dictionaryName, value) : value)}
              <button
                type="button"
                class="chip-remove"
                aria-label="${escapeHtml(t(state.locale, "ui.delete"))}"
                data-action="remove-predicate-value"
                data-owner-kind="${ownerKind}"
                data-owner-uid="${ownerUid}"
                data-uid="${predicate.uid}"
                data-value-index="${index}">
                ×
              </button>
            </span>
          `).join("")}
        </div>
      </div>
    `;
  }

  function renderScalarEditor(predicate, ownerKind, ownerUid, fieldDefinition) {
    const dictionaryName = fieldDefinition.type === "string" || fieldDefinition.type === "list-string"
      ? fieldDefinition.dictionary
      : "";
    const dictionary = dictionaryName ? getDictionaryOptions(dictionaryName) : [];
    const commonAttrs = `
      data-entity="predicate"
      data-owner-kind="${ownerKind}"
      data-owner-uid="${ownerUid}"
      data-uid="${predicate.uid}"
      data-field="value"
    `;

    let valueControl = "";
    if (fieldDefinition.type === "bool") {
      valueControl = `
        <select ${commonAttrs}>
          ${renderSelectOptions(state.locale, BOOLEAN_OPTIONS, predicate.value, { allowEmpty: true })}
        </select>
      `;
    } else if (dictionary.length > 0) {
      valueControl = renderSearchableDropdown({
        dropdownId: `predicate-value-${predicate.uid}`,
        selectedValue: predicate.value,
        options: dictionary,
        placeholder: placeholderText(state.locale, "selectValue"),
        mode: "scalar",
        uid: predicate.uid,
        ownerKind,
        ownerUid
      });
    } else {
      const numericAttrs = fieldDefinition.type === "int" || fieldDefinition.type === "map-int"
        ? `inputmode="numeric" pattern="[0-9]*"`
        : "";
      valueControl = `<input type="text" value="${escapeHtml(predicate.value)}" ${commonAttrs} ${numericAttrs}>`;
    }

    return `
      <label class="field">
        ${renderFieldLabel(fieldText(state.locale, "value"), hintText(state.locale, "value"))}
        ${valueControl}
      </label>
    `;
  }

  function renderRangeEditor(predicate, ownerKind, ownerUid, fieldDefinition) {
    const numericAttrs = fieldDefinition.type === "int" ? `inputmode="numeric" pattern="[0-9]*"` : "";
    return `
      <div class="field-grid two">
        <label class="field">
          ${renderFieldLabel(fieldText(state.locale, "valueFrom"), hintText(state.locale, "valueFrom"))}
          <input
            type="text"
            value="${escapeHtml(predicate.valueFrom)}"
            data-entity="predicate"
            data-owner-kind="${ownerKind}"
            data-owner-uid="${ownerUid}"
            data-uid="${predicate.uid}"
            data-field="valueFrom"
            ${numericAttrs}>
        </label>
        <label class="field">
          ${renderFieldLabel(fieldText(state.locale, "valueTo"), hintText(state.locale, "valueTo"))}
          <input
            type="text"
            value="${escapeHtml(predicate.valueTo)}"
            data-entity="predicate"
            data-owner-kind="${ownerKind}"
            data-owner-uid="${ownerUid}"
            data-uid="${predicate.uid}"
            data-field="valueTo"
            ${numericAttrs}>
        </label>
      </div>
    `;
  }

  function renderMapKeyEditor(predicate, ownerKind, ownerUid, fieldDefinition) {
    const dictionary = fieldDefinition.dictionary ? getDictionaryOptions(fieldDefinition.dictionary) : [];
    const label = localized(state.locale, fieldDefinition.keyLabel) || fieldText(state.locale, "key");

    return `
      <label class="field">
        ${renderFieldLabel(label, hintText(state.locale, "key"))}
        ${renderSearchableDropdown({
          dropdownId: `predicate-key-${predicate.uid}`,
          selectedValue: predicate.key,
          options: dictionary,
          placeholder: placeholderText(state.locale, "selectValue"),
          mode: "key",
          uid: predicate.uid,
          ownerKind,
          ownerUid
        })}
      </label>
    `;
  }

  function renderPredicateValueEditor(predicate, ownerKind, ownerUid) {
    const fieldDefinition = getFieldDefinition(predicate.scope, predicate.field);
    if (!fieldDefinition) {
      return "";
    }

    if (predicate.operator === PREDICATE_OPERATORS.sameAs || predicate.operator === PREDICATE_OPERATORS.notSameAs) {
      const currentSlotId = ownerKind === "global" ? "" : (findSlot(ownerKind, ownerUid)?.slotId ?? "");
      const compareOptions = getSlotsForSelection(currentSlotId);
      return `
        <label class="field">
          ${renderFieldLabel(fieldText(state.locale, "compareSlot"), hintText(state.locale, "compareSlot"))}
          <select
            data-entity="predicate"
            data-owner-kind="${ownerKind}"
            data-owner-uid="${ownerUid}"
            data-uid="${predicate.uid}"
            data-field="compareSlotId">
            ${renderSelectOptions(state.locale, compareOptions, predicate.compareTo?.slotId ?? "", {
              allowEmpty: true,
              emptyLabel: selectText(state.locale, "none")
            })}
          </select>
        </label>
      `;
    }

    const keyEditor = fieldDefinition.type === "map-int"
      ? renderMapKeyEditor(predicate, ownerKind, ownerUid, fieldDefinition)
      : "";

    if (predicate.operator === PREDICATE_OPERATORS.in || predicate.operator === PREDICATE_OPERATORS.notIn) {
      return `${keyEditor}${renderPredicateValueList(predicate, ownerKind, ownerUid, fieldDefinition)}`;
    }

    if (predicate.operator === PREDICATE_OPERATORS.between) {
      return `${keyEditor}${renderRangeEditor(predicate, ownerKind, ownerUid, fieldDefinition)}`;
    }

    return `${keyEditor}${renderScalarEditor(predicate, ownerKind, ownerUid, fieldDefinition)}`;
  }

  function renderPredicateCard(predicate, ownerKind, ownerUid, title) {
    const fieldOptions = getFieldOptions(predicate.scope).map(item => ({
      id: item.id,
      label: localized(state.locale, item.label)
    }));
    const operatorOptions = getAllowedOperators(predicate.scope, predicate.field, {
      allowCompareOperators: ownerKind === "global"
        ? false
        : getSlotsForSelection(findSlot(ownerKind, ownerUid)?.slotId ?? "").length > 0
    }).map(operator => ({
      id: operator,
      label: operatorLabel(state.locale, operator)
    }));
    const fieldDefinition = getFieldDefinition(predicate.scope, predicate.field);

    return `
      <section class="predicate-card">
        <div class="subsection-header tight">
          <div>
            <strong>${escapeHtml(title)}</strong>
          </div>
          <button
            type="button"
            data-action="${ownerKind === "global" ? "delete-global-predicate" : "delete-predicate"}"
            data-owner-kind="${ownerKind}"
            data-owner-uid="${ownerUid}"
            data-uid="${predicate.uid}">
            ${escapeHtml(t(state.locale, "ui.delete"))}
          </button>
        </div>

        <div class="field-grid two">
          <label class="field">
            ${renderFieldLabel(fieldText(state.locale, "field"), hintText(state.locale, "field"))}
            <select
              data-entity="predicate"
              data-owner-kind="${ownerKind}"
              data-owner-uid="${ownerUid}"
              data-uid="${predicate.uid}"
              data-field="field">
              ${renderSelectOptions(state.locale, fieldOptions, predicate.field)}
            </select>
          </label>
          <label class="field">
            ${renderFieldLabel(t(state.locale, "ui.fields.operator"), hintText(state.locale, "operator"))}
            <select
              data-entity="predicate"
              data-owner-kind="${ownerKind}"
              data-owner-uid="${ownerUid}"
              data-uid="${predicate.uid}"
              data-field="operator">
              ${renderSelectOptions(state.locale, operatorOptions, predicate.operator)}
            </select>
          </label>
        </div>

        ${fieldDefinition ? renderPredicateValueEditor(predicate, ownerKind, ownerUid) : ""}
      </section>
    `;
  }

  function renderBindingCard(binding, ownerKind, ownerUid, index) {
    const slotOptions = getSlotsForSelection(findSlot(ownerKind, ownerUid)?.slotId ?? "");
    const sourceOptions = Object.values(TEXT_BINDING_SOURCES).map(source => ({
      id: source,
      label: localized(state.locale, SOURCE_LABELS[source])
    }));
    const fieldOptions = binding.source === TEXT_BINDING_SOURCES.round
      ? ROUND_TEXT_BINDING_FIELDS.map(field => ({ id: field.id, label: localized(state.locale, field.label) }))
      : TEXT_BINDING_FIELDS.map(field => ({ id: field.id, label: localized(state.locale, field.label) }));

    const token = nonEmpty(binding.parameter) ? `{$${nonEmpty(binding.parameter)}}` : "";

    return `
      <section class="subcard text-binding-card">
        <div class="subsection-header tight">
          <div>
            <strong>${escapeHtml(t(state.locale, "ui.textParameterTitle", { index: index + 1 }))}</strong>
            ${token ? `<code>${escapeHtml(token)}</code>` : ""}
          </div>
          <div class="button-row">
            <button
              type="button"
              data-action="copy-binding-token"
              data-owner-kind="${ownerKind}"
              data-owner-uid="${ownerUid}"
              data-uid="${binding.uid}"
              title="${escapeHtml(token || t(state.locale, "ui.copyPaste.bindingTokenEmpty"))}"
              ${token ? "" : "disabled"}>
              ${escapeHtml(t(state.locale, "ui.copyPaste.copyBindingToken"))}
            </button>
            <button
              type="button"
              data-action="delete-binding"
              data-owner-kind="${ownerKind}"
              data-owner-uid="${ownerUid}"
              data-uid="${binding.uid}">
              ${escapeHtml(t(state.locale, "ui.delete"))}
            </button>
          </div>
        </div>

        <div class="field-grid four">
          <label class="field">
            ${renderFieldLabel(fieldText(state.locale, "parameter"), hintText(state.locale, "parameter"))}
            <input
              type="text"
              value="${escapeHtml(binding.parameter)}"
              data-entity="binding"
              data-owner-kind="${ownerKind}"
              data-owner-uid="${ownerUid}"
              data-uid="${binding.uid}"
              data-field="parameter"
              placeholder="${escapeHtml(placeholderText(state.locale, "bindingParam"))}">
          </label>
            <label class="field">
              ${renderFieldLabel(fieldText(state.locale, "source"), hintText(state.locale, "source"))}
              <select
                data-entity="binding"
                data-owner-kind="${ownerKind}"
              data-owner-uid="${ownerUid}"
              data-uid="${binding.uid}"
              data-field="source">
              ${renderSelectOptions(state.locale, sourceOptions, binding.source)}
            </select>
          </label>
          ${binding.source === TEXT_BINDING_SOURCES.slot ? `
            <label class="field">
              ${renderFieldLabel(fieldText(state.locale, "slot"), hintText(state.locale, "slot"))}
              <select
                data-entity="binding"
                data-owner-kind="${ownerKind}"
                data-owner-uid="${ownerUid}"
                data-uid="${binding.uid}"
                data-field="slotId">
                ${renderSelectOptions(state.locale, slotOptions, binding.slotId, {
                  allowEmpty: true,
                  emptyLabel: placeholderText(state.locale, "selectSlot")
                })}
              </select>
            </label>
          ` : ""}
          ${binding.source === TEXT_BINDING_SOURCES.literal ? `
            <label class="field">
              ${renderFieldLabel(fieldText(state.locale, "value"), hintText(state.locale, "value"))}
              <input
                type="text"
                value="${escapeHtml(binding.value)}"
                data-entity="binding"
                data-owner-kind="${ownerKind}"
                data-owner-uid="${ownerUid}"
                data-uid="${binding.uid}"
                data-field="value"
                placeholder="${escapeHtml(placeholderText(state.locale, "literal"))}">
            </label>
          ` : `
            <label class="field">
              ${renderFieldLabel(fieldText(state.locale, "field"), hintText(state.locale, "field"))}
              <select
                data-entity="binding"
                data-owner-kind="${ownerKind}"
                data-owner-uid="${ownerUid}"
                data-uid="${binding.uid}"
                data-field="field">
                ${renderSelectOptions(state.locale, fieldOptions, binding.field)}
              </select>
            </label>
          `}
        </div>
      </section>
    `;
  }

function renderIntentionEditor(intention, entity, title, description, {
    canDelete = false,
    slot = null,
    slotOwnerKind = ""
  } = {}) {
    const locale = state.locale;
    const uid = entity === "secondary-intention" ? intention.uid : "";
    const sectionClass = entity === "owner-intention"
      ? "editor-section intentions-section owner-intention-section"
      : "editor-section intentions-section secondary-intention-section";
    const visibilityOptions = [
      { id: VISIBILITY_TYPES.visible, label: localized(locale, VISIBILITY_LABELS.visible) },
      { id: VISIBILITY_TYPES.hidden, label: localized(locale, VISIBILITY_LABELS.hidden) }
    ];
    const revealOptions = [
      { id: REVEAL_TYPES.none, label: localized(locale, REVEAL_LABELS.none) },
      { id: REVEAL_TYPES.timer, label: localized(locale, REVEAL_LABELS.timer) }
    ];
    const slotUid = slot?.uid ?? "";

    return `
      <section class="${sectionClass}">
        <div class="section-header">
          <div>
            <h2>${escapeHtml(title)}</h2>
            <p>${escapeHtml(description)}</p>
          </div>
          <div class="button-row">
            <button
              type="button"
              data-action="copy-intention-content"
              data-entity="${entity}"
              data-uid="${uid}"
              data-slot-uid="${slotUid}">
              ${escapeHtml(t(locale, "ui.copyPaste.copy"))}
            </button>
            <button
              type="button"
              data-action="paste-intention-content"
              data-entity="${entity}"
              data-uid="${uid}"
              data-slot-uid="${slotUid}"
              ${state.intentionClipboard ? "" : "disabled"}>
              ${escapeHtml(t(locale, "ui.copyPaste.paste"))}
            </button>
            ${canDelete ? `
              <button type="button" data-action="delete-slot" data-uid="${slotUid}">
                ${escapeHtml(t(locale, "ui.delete"))}
              </button>
            ` : ""}
          </div>
        </div>

        <div class="intention-tabs" aria-label="${escapeHtml(t(locale, "ui.intentionTabs"))}">
          <button type="button" class="is-active">${escapeHtml(t(locale, "ui.intentionTabOne"))}</button>
          <button type="button" disabled>${escapeHtml(t(locale, "ui.intentionTabsFuture"))}</button>
        </div>

        <div class="field-grid two">
          ${renderTextField({
            entity,
            uid,
            field: "id",
            value: intention.id,
            label: fieldText(locale, "templateId"),
            hint: hintText(locale, "templateId"),
            help: hintText(locale, "templateIdTooltip"),
            placeholder: placeholderText(locale, "templateId")
          })}
          ${renderTextField({
            entity,
            uid,
            field: "author",
            value: intention.author,
            label: fieldText(locale, "author"),
            hint: hintText(locale, "author")
          })}
        </div>

        <div class="field-grid two">
          ${renderTextField({
            entity,
            uid,
            field: "name",
            value: intention.name,
            label: fieldText(locale, "title"),
            hint: hintText(locale, "title35"),
            maxLength: TEXT_LIMITS.name,
            counterMax: TEXT_LIMITS.name
          })}
          ${renderTextField({
            entity,
            uid,
            field: "summary",
            value: intention.summary,
            label: fieldText(locale, "summary"),
            hint: hintText(locale, "summary35"),
            help: hintText(locale, "summaryTooltip"),
            maxLength: TEXT_LIMITS.summary,
            counterMax: TEXT_LIMITS.summary
          })}
        </div>

        ${renderTextField({
          entity,
          uid,
          field: "description",
          value: intention.description,
          label: fieldText(locale, "description"),
          hint: hintText(locale, "description2000"),
          rows: 5,
          maxLength: TEXT_LIMITS.description,
          counterMax: TEXT_LIMITS.description
        })}
        ${renderTextField({
          entity,
          uid,
          field: "oocInfo",
          value: intention.oocInfo,
          label: fieldText(locale, "oocInfo"),
          hint: hintText(locale, "ooc500"),
          help: hintText(locale, "oocInfoTooltip"),
          rows: 3,
          maxLength: TEXT_LIMITS.oocInfo,
          counterMax: TEXT_LIMITS.oocInfo
        })}
        ${renderTextField({
          entity,
          uid,
          field: "copyableText",
          value: intention.copyableText,
          label: fieldText(locale, "copyableText"),
          hint: hintText(locale, "copy5000"),
          help: hintText(locale, "copyableTextTooltip"),
          rows: 8,
          maxLength: TEXT_LIMITS.copyableText,
          counterMax: TEXT_LIMITS.copyableText
        })}

        <div class="subsection visibility-combo">
          <div class="subsection-header tight">
            <strong>${escapeHtml(t(locale, "ui.visibilityAndReveal"))}</strong>
          </div>
          <div class="field-grid four">
            <label class="field">
              ${renderFieldLabel(fieldText(locale, "visibility"), hintText(locale, "defaultVisibility"))}
              <select data-entity="${entity}" data-uid="${uid}" data-field="defaultVisibility">
                ${renderSelectOptions(locale, visibilityOptions, intention.defaultVisibility)}
              </select>
            </label>
            ${renderTextField({
              entity,
              uid,
              field: "hiddenLabel",
              value: intention.hiddenLabel,
              label: fieldText(locale, "hiddenLabel"),
              hint: hintText(locale, "hidden45"),
              help: hintText(locale, "hiddenLabelTooltip"),
              maxLength: TEXT_LIMITS.hiddenLabel,
              counterMax: TEXT_LIMITS.hiddenLabel
            })}
            ${slot ? `
              <label class="check-row">
                <input
                  type="checkbox"
                  data-entity="${slotOwnerKind}"
                  data-uid="${slotUid}"
                  data-field="visibilityEnabled"
                  data-value-type="checkbox"
                  ${slot.visibilityEnabled ? "checked" : ""}>
                <span>${escapeHtml(fieldText(locale, "visibilityOverride"))}</span>
              </label>
              <label class="field">
                ${renderFieldLabel(fieldText(locale, "visibilityOverride"), hintText(locale, "visibilityOverride"))}
                <select
                  data-entity="${slotOwnerKind}"
                  data-uid="${slotUid}"
                  data-field="visibilityType"
                  ${slot.visibilityEnabled ? "" : "disabled"}>
                  ${renderSelectOptions(locale, visibilityOptions, slot.visibilityType)}
                </select>
              </label>
              <label class="field">
                <span>${escapeHtml(fieldText(locale, "reveal"))} ${renderHelpIcon(hintText(locale, "reveal"))}</span>
                <select
                  data-entity="${slotOwnerKind}"
                  data-uid="${slotUid}"
                  data-field="revealType"
                  ${slot.visibilityEnabled && slot.visibilityType === VISIBILITY_TYPES.hidden ? "" : "disabled"}>
                  ${renderSelectOptions(locale, revealOptions, slot.revealType)}
                </select>
              </label>
          ${renderTextField({
            entity: slotOwnerKind,
            uid: slotUid,
            field: "revealMinutes",
            value: slot.revealMinutes,
                label: fieldText(locale, "revealMinutes"),
                hint: hintText(locale, "revealMinutes"),
                type: "text",
                valueType: "number",
                disabled: !(slot.visibilityEnabled && slot.visibilityType === VISIBILITY_TYPES.hidden && slot.revealType === REVEAL_TYPES.timer)
              })}
            ` : ""}
          </div>
        </div>

        <div class="field-grid two">
          ${renderTextField({
            entity,
            uid,
            field: "tagsInput",
            value: intention.tagsInput ?? "",
            label: fieldText(locale, "tags"),
            hint: hintText(locale, "tags"),
            help: "",
            placeholder: placeholderText(locale, "tags")
          })}
          ${renderColorField(entity, "color", intention.color, uid)}
        </div>

        ${renderTextField({
          entity,
          uid,
          field: "creationDate",
          value: intention.creationDate,
          label: fieldText(locale, "creationDate"),
          hint: hintText(locale, "date"),
          placeholder: "2026-04-30"
        })}

        <div class="subsection">
          <label class="check-row">
            <input
              type="checkbox"
              data-entity="${entity}"
              data-uid="${uid}"
              data-field="iconEnabled"
              data-value-type="checkbox"
              ${intention.iconEnabled ? "checked" : ""}>
            <span>${escapeHtml(fieldText(locale, "addIcon"))}</span>
          </label>
          <div class="field-grid two">
            ${renderTextField({
              entity,
              uid,
              field: "iconSprite",
              value: intention.iconSprite,
              label: fieldText(locale, "iconSprite"),
              help: hintText(locale, "iconSprite"),
              disabled: !intention.iconEnabled,
              placeholder: placeholderText(locale, "iconSprite")
            })}
            ${renderTextField({
              entity,
              uid,
              field: "iconState",
              value: intention.iconState,
              label: fieldText(locale, "iconState"),
              help: hintText(locale, "iconState"),
              disabled: !intention.iconEnabled,
              placeholder: placeholderText(locale, "iconState")
            })}
          </div>
        </div>
      </section>
    `;
  }

  function renderVisibilityEditor(slot, ownerKind) {
    const locale = state.locale;
    const uid = ownerKind === "owner-slot" ? slot.uid : slot.uid;
    const visibilityOptions = [
      { id: VISIBILITY_TYPES.visible, label: localized(locale, VISIBILITY_LABELS.visible) },
      { id: VISIBILITY_TYPES.hidden, label: localized(locale, VISIBILITY_LABELS.hidden) }
    ];
    const revealOptions = [
      { id: REVEAL_TYPES.none, label: localized(locale, REVEAL_LABELS.none) },
      { id: REVEAL_TYPES.timer, label: localized(locale, REVEAL_LABELS.timer) }
    ];

    return `
      <div class="subsection">
        <div class="subsection-header tight">
          <strong>
            ${escapeHtml(fieldText(locale, "visibilityOverride"))}
            ${renderHelpIcon(hintText(locale, "visibilityOverride"))}
          </strong>
        </div>
        <div class="field-grid three">
          <label class="check-row check-row-centered">
            <input
              type="checkbox"
              data-entity="${ownerKind}"
              data-uid="${uid}"
              data-field="visibilityEnabled"
              data-value-type="checkbox"
              ${slot.visibilityEnabled ? "checked" : ""}>
            <span>${escapeHtml(fieldText(locale, "visibilityOverride"))}</span>
          </label>
          <label class="field">
            <span>${escapeHtml(fieldText(locale, "visibility"))}</span>
            <select
              data-entity="${ownerKind}"
              data-uid="${uid}"
              data-field="visibilityType"
              ${slot.visibilityEnabled ? "" : "disabled"}>
              ${renderSelectOptions(locale, visibilityOptions, slot.visibilityType)}
            </select>
          </label>
          <label class="field">
            <span>${escapeHtml(fieldText(locale, "reveal"))} ${renderHelpIcon(hintText(locale, "reveal"))}</span>
            <select
              data-entity="${ownerKind}"
              data-uid="${uid}"
              data-field="revealType"
              ${slot.visibilityEnabled && slot.visibilityType === VISIBILITY_TYPES.hidden ? "" : "disabled"}>
              ${renderSelectOptions(locale, revealOptions, slot.revealType)}
            </select>
          </label>
        </div>
        ${renderTextField({
          entity: ownerKind,
          uid,
          field: "revealMinutes",
          value: slot.revealMinutes,
          label: fieldText(locale, "revealMinutes"),
          hint: locale === "ru" ? "Минимум 1 минута." : "Minimum 1 minute.",
          type: "text",
          valueType: "number",
          disabled: !(slot.visibilityEnabled && slot.visibilityType === VISIBILITY_TYPES.hidden && slot.revealType === REVEAL_TYPES.timer)
        })}
      </div>
    `;
  }

function renderSlotEditor(slot, ownerKind, title, description, canDelete = false) {
    const locale = state.locale;
    const uid = slot.uid ?? "";
    const isOwnerSlot = ownerKind === "owner-slot";
    const sectionClass = isOwnerSlot
      ? "editor-section slots-section owner-slot-section"
      : "editor-section slots-section secondary-slot-section";
    const bindOptions = isOwnerSlot ? [] : getSlotsForSelection(slot.slotId);
    const allowOptions = isOwnerSlot ? [] : getSlotsForSelection(slot.slotId);
    const slotDisabledByBind = nonEmpty(slot.bindToSlot);

    return `
      <section class="${sectionClass}">
        <div class="section-header">
          <div>
            <h2>${escapeHtml(title)}</h2>
            <p>${escapeHtml(description)}</p>
          </div>
          ${canDelete ? `
            <button type="button" data-action="delete-slot" data-uid="${uid}">
              ${escapeHtml(t(locale, "ui.delete"))}
            </button>
          ` : ""}
        </div>

        <div class="field-grid three">
          ${renderTextField({
            entity: ownerKind,
            uid,
            field: "slotId",
            value: slot.slotId,
            label: fieldText(locale, "slotId"),
            hint: hintText(locale, "slotId"),
            help: "",
            disabled: isOwnerSlot
          })}
          ${isOwnerSlot ? "" : `
            <label class="field">
              ${renderFieldLabel(fieldText(locale, "bindToSlot"), hintText(locale, "bindToSlot"))}
              <select
                data-entity="${ownerKind}"
                data-uid="${uid}"
                data-field="bindToSlot">
                ${renderSelectOptions(locale, bindOptions, slot.bindToSlot, {
                  allowEmpty: true,
                  emptyLabel: selectText(locale, "noBind")
                })}
              </select>
            </label>
          `}
          <label class="check-row check-row-centered">
            <input
              type="checkbox"
              data-entity="${ownerKind}"
              data-uid="${uid}"
              data-field="required"
              data-value-type="checkbox"
              ${slot.required ? "checked" : ""}
              ${isOwnerSlot ? "disabled" : ""}>
            ${renderFieldLabel(fieldText(locale, "required"), hintText(locale, "required"))}
          </label>
        </div>

        ${isOwnerSlot ? "" : `<div class="subsection">
          <div class="subsection-header tight">
            <strong>${escapeHtml(fieldText(locale, "allowSameActorAs"))} ${renderHelpIcon(hintText(locale, "allowSameActorAs"))}</strong>
          </div>
          <div class="checkbox-stack ${slotDisabledByBind ? "is-disabled" : ""}">
            ${allowOptions.length === 0
              ? `<span class="muted-text">${escapeHtml(t(locale, "ui.choose"))}</span>`
              : allowOptions.map(option => `
                <label class="check-row ${slotDisabledByBind ? "is-disabled" : ""}">
                  <input
                    type="checkbox"
                    data-action="toggle-allow-same-actor"
                    data-owner-kind="${ownerKind}"
                    data-owner-uid="${uid}"
                    data-target-slot-id="${option.id}"
                    ${slot.allowSameActorAs.includes(option.id) ? "checked" : ""}
                    ${slotDisabledByBind ? "disabled" : ""}>
                  <span>${escapeHtml(localized(locale, option.label))}</span>
                </label>
              `).join("")}
          </div>
        </div>`}

        <div class="subsection">
          <div class="subsection-header">
            <strong>${escapeHtml(fieldText(locale, "candidatePredicates"))} ${renderHelpIcon(hintText(locale, "candidatePredicates"))}</strong>
            <button
              type="button"
              data-action="add-slot-predicate"
              data-owner-kind="${ownerKind}"
              data-owner-uid="${uid}"
              ${slotDisabledByBind ? "disabled" : ""}>
              ${escapeHtml(buttonText(locale, "addCandidatePredicate"))}
            </button>
          </div>
          ${slotDisabledByBind
            ? `<p class="muted-text">${escapeHtml(hintText(locale, "bindToSlot"))}</p>`
            : slot.candidatePredicates.length === 0
              ? `<p class="muted-text">${escapeHtml(t(locale, "ui.emptySection"))}</p>`
              : slot.candidatePredicates.map((predicate, index) =>
                renderPredicateCard(predicate, ownerKind, uid, predicateTitle(locale, index + 1))).join("")}
        </div>

        <div class="subsection">
          <div class="subsection-header">
            <strong>${escapeHtml(fieldText(locale, "textBindings"))} ${renderHelpIcon(hintText(locale, "textBindings"))}</strong>
            <button
              type="button"
              data-action="add-binding"
              data-owner-kind="${ownerKind}"
              data-owner-uid="${uid}">
              ${escapeHtml(buttonText(locale, "addBinding"))}
            </button>
          </div>
          ${slot.textParameterBindings.length === 0
            ? `<p class="muted-text">${escapeHtml(t(locale, "ui.emptySection"))}</p>`
            : slot.textParameterBindings.map((binding, index) => renderBindingCard(binding, ownerKind, uid, index)).join("")}
        </div>
      </section>
    `;
  }

  function renderScenarioSection() {
    const locale = state.locale;

    return `
      <section class="editor-section scenario-section">
        <div class="section-header">
          <div>
            <h2>${escapeHtml(t(locale, "ui.sections.scenario"))}</h2>
            <p>${escapeHtml(t(locale, "ui.sectionDescriptions.scenario"))}</p>
          </div>
        </div>

        <div class="scenario-grid">
          <div class="subsection flat">
            <div class="subsection-header tight">
              <strong>${escapeHtml(t(locale, "ui.scenarioCommon"))}</strong>
            </div>
            <div class="field-grid four">
              ${renderTextField({
                entity: "scenario",
                field: "id",
                value: state.draft.scenario.id,
                label: fieldText(locale, "scenarioId"),
                hint: hintText(locale, "scenarioId"),
                help: hintText(locale, "scenarioIdTooltip"),
                placeholder: placeholderText(locale, "scenarioId")
              })}
              ${renderTextField({
                entity: "scenario",
                field: "name",
                value: state.draft.scenario.name,
                label: fieldText(locale, "humanName"),
                hint: hintText(locale, "humanName"),
                placeholder: placeholderText(locale, "scenarioName")
              })}
              ${renderCategoryPicker()}
              <label class="field">
                <span>${escapeHtml(fieldText(locale, "weight"))}</span>
                <input
                  type="text"
                  inputmode="numeric"
                  pattern="[0-9]*"
                  value="${escapeHtml(state.draft.scenario.weight)}"
                  data-entity="scenario"
                  data-field="weight"
                  data-value-type="number">
                ${renderHint(hintText(locale, "weight"))}
              </label>
            </div>

            <label class="check-row">
              <input
                type="checkbox"
                data-entity="scenario"
                data-field="enabled"
                data-value-type="checkbox"
                ${state.draft.scenario.enabled ? "checked" : ""}>
              ${renderFieldLabel(fieldText(locale, "enabled"), hintText(locale, "enabled"))}
            </label>
          </div>

          <div class="subsection">
            <div class="subsection-header">
              <strong>${escapeHtml(fieldText(locale, "globalPredicates"))} ${renderHelpIcon(hintText(locale, "globalPredicates"))}</strong>
              <button type="button" data-action="add-global-predicate">${escapeHtml(buttonText(locale, "addGlobalPredicate"))}</button>
            </div>
            ${state.draft.globalPredicates.length === 0
              ? `<p class="muted-text">${escapeHtml(t(locale, "ui.emptySection"))}</p>`
              : state.draft.globalPredicates.map((predicate, index) =>
                renderPredicateCard(predicate, "global", "", predicateTitle(locale, index + 1))).join("")}
          </div>
        </div>
      </section>
    `;
  }

  function renderExportPanel() {
    const locale = state.locale;
    const locKeys = getLocKeysForIntentions(state.draft);
    const artifacts = state.artifacts;
    const exportBlocked = state.validation.errors.length > 0;

    return `
      <section class="editor-section export-section">
        <div class="section-header">
          <div>
            <h2>${escapeHtml(t(locale, "ui.sections.export"))}</h2>
            <p>${escapeHtml(t(locale, "ui.sectionDescriptions.export"))}</p>
          </div>
        </div>

        <div class="export-summary">
          <div class="summary-box">
            <span>${escapeHtml(exportText(locale, "derivedCrew"))}</span>
            <strong>${artifacts.meta.derivedCrewCount}</strong>
          </div>
          <div class="summary-box">
            <span>${escapeHtml(exportText(locale, "slotBuildOrder"))}</span>
            <div class="pill-row">
              ${artifacts.meta.slotBuildOrder.length === 0
                ? `<span class="pill pill-muted">${escapeHtml(selectText(locale, "none"))}</span>`
                : artifacts.meta.slotBuildOrder.map(item => `<span class="pill">${escapeHtml(item)}</span>`).join("")}
            </div>
          </div>
          <div class="summary-box ${artifacts.meta.syntheticCrewPredicateAdded ? "summary-box-derivation" : ""}">
            <span>${escapeHtml(artifacts.meta.syntheticCrewPredicateAdded
              ? exportText(locale, "syntheticCrewAdded")
              : exportText(locale, "syntheticCrewSkipped"))}</span>
          </div>
        </div>

        <div class="export-actions">
          <button type="button" data-action="download-artifact" data-kind="scenario" ${exportBlocked ? "disabled" : ""}>${escapeHtml(buttonText(locale, "downloadScenario"))}</button>
          <button type="button" data-action="download-artifact" data-kind="intentions" ${exportBlocked ? "disabled" : ""}>${escapeHtml(buttonText(locale, "downloadIntentions"))}</button>
          <button type="button" data-action="download-artifact" data-kind="ftl" ${exportBlocked ? "disabled" : ""}>${escapeHtml(buttonText(locale, "downloadFtl"))}</button>
          <button type="button" data-action="copy-artifact" data-kind="scenario" ${exportBlocked ? "disabled" : ""}>${escapeHtml(buttonText(locale, "copyScenario"))}</button>
          <button type="button" data-action="copy-artifact" data-kind="intentions" ${exportBlocked ? "disabled" : ""}>${escapeHtml(buttonText(locale, "copyIntentions"))}</button>
          <button type="button" data-action="copy-artifact" data-kind="ftl" ${exportBlocked ? "disabled" : ""}>${escapeHtml(buttonText(locale, "copyFtl"))}</button>
        </div>

        <div class="subsection">
          <div class="subsection-header">
            <strong>${escapeHtml(exportText(locale, "generatedLocKeys"))}</strong>
          </div>
          <div class="loc-grid">
            ${locKeys.map(item => `
              <div class="loc-card">
                <strong>${escapeHtml(item.intentionId || "—")}</strong>
                <code>${escapeHtml(item.nameLoc)}</code>
                <code>${escapeHtml(item.summaryLoc)}</code>
                <code>${escapeHtml(item.descriptionLoc)}</code>
                <code>${escapeHtml(item.oocInfoLoc)}</code>
                <code>${escapeHtml(item.copyableTextLoc)}</code>
                <code>${escapeHtml(item.hiddenLabelLoc)}</code>
              </div>
            `).join("")}
          </div>
        </div>

        <div class="preview-grid">
          <label class="field">
            <span>${escapeHtml(artifacts.scenario.filename)}</span>
            <textarea rows="18" readonly>${escapeHtml(artifacts.scenario.content)}</textarea>
          </label>
          <label class="field">
            <span>${escapeHtml(artifacts.intentions.filename)}</span>
            <textarea rows="18" readonly>${escapeHtml(artifacts.intentions.content)}</textarea>
          </label>
          <label class="field">
            <span>${escapeHtml(artifacts.ftl.filename)}</span>
            <textarea rows="18" readonly>${escapeHtml(artifacts.ftl.content)}</textarea>
          </label>
        </div>
      </section>
    `;
  }

  function renderModal() {
    if (!state.modal) {
      return "";
    }

    if (state.modal === MODAL_TYPES.rules) {
      return `
        <div class="modal-backdrop">
          <div class="modal-card" data-modal-card="true" role="dialog" aria-modal="true">
            <div class="modal-header">
              <h2>${escapeHtml(t(state.locale, "ui.modalRulesTitle"))}</h2>
              <button type="button" data-action="close-modal">${escapeHtml(t(state.locale, "ui.close"))}</button>
            </div>
            <ul class="compact-list">
              ${t(state.locale, "ui.ruleModal").map(item => `<li>${escapeHtml(item)}</li>`).join("")}
            </ul>
          </div>
        </div>
      `;
    }

    if (state.modal === MODAL_TYPES.categories) {
      return `
        <div class="modal-backdrop">
          <div class="modal-card modal-card-wide" data-modal-card="true" role="dialog" aria-modal="true">
            <div class="modal-header">
              <h2>${escapeHtml(t(state.locale, "ui.modalCategoriesTitle"))}</h2>
              <button type="button" data-action="close-modal">${escapeHtml(t(state.locale, "ui.close"))}</button>
            </div>
            <div class="category-grid">
              ${CATEGORY_CATALOG.map(category => `
                <section class="category-card">
                  <h3>${escapeHtml(localized(state.locale, category.title))}</h3>
                  <code>${escapeHtml(category.id)}</code>
                  <p>${escapeHtml(localized(state.locale, category.description))}</p>
                  <ul>
                    ${(category.examples[state.locale] ?? category.examples.ru ?? []).map(example => `<li>${escapeHtml(example)}</li>`).join("")}
                  </ul>
                </section>
              `).join("")}
            </div>
          </div>
        </div>
      `;
    }

    if (state.modal === MODAL_TYPES.import) {
      return `
        <div class="modal-backdrop">
          <div class="modal-card modal-card-wide import-modal-card" data-modal-card="true" role="dialog" aria-modal="true">
            <div class="modal-header">
              <h2>${escapeHtml(t(state.locale, "ui.import.title"))}</h2>
              <div class="button-row">
                <button type="button" data-action="clear-import-fields">${escapeHtml(t(state.locale, "ui.import.clear"))}</button>
                <button type="button" data-action="close-modal">${escapeHtml(t(state.locale, "ui.close"))}</button>
              </div>
            </div>
            ${renderImportPanel()}
          </div>
        </div>
      `;
    }

    return "";
  }

  function renderDataLists() {
    const dictionaries = new Set();
    const lists = [];
    for (const fieldSet of Object.values(FIELD_DEFINITIONS)) {
      for (const definition of Object.values(fieldSet)) {
        if (definition.dictionary && !dictionaries.has(definition.dictionary)) {
          dictionaries.add(definition.dictionary);
          lists.push(renderDatalist(`dict-${definition.dictionary}`, getDictionaryValues(definition.dictionary)));
        }
      }
    }
    return lists.join("");
  }

  function renderCategoryPicker() {
    const selectedCategory = CATEGORY_CATALOG.find(category => category.id === state.draft.scenario.category) ?? CATEGORY_CATALOG[0];
    const selectedTitle = selectedCategory ? localized(state.locale, selectedCategory.title) : "";

    return `
      <div class="field category-field" data-category-picker="true">
        ${renderFieldLabel(fieldText(state.locale, "category"), hintText(state.locale, "categoryTooltip"))}
        <button
          type="button"
          class="category-trigger"
          data-action="toggle-category-dropdown"
          aria-haspopup="listbox"
          aria-expanded="${state.categoryDropdownOpen ? "true" : "false"}">
          <strong>${escapeHtml(selectedTitle)}</strong>
          <span aria-hidden="true">v</span>
        </button>
        ${state.categoryDropdownOpen ? `
          <div class="category-menu" role="listbox">
            ${CATEGORY_CATALOG.map(category => `
              <button
                type="button"
                class="category-option ${category.id === state.draft.scenario.category ? "is-active" : ""}"
                data-action="set-category"
                data-category-id="${escapeHtml(category.id)}"
                role="option"
                aria-selected="${category.id === state.draft.scenario.category ? "true" : "false"}">
                <strong>${escapeHtml(localized(state.locale, category.title))}</strong>
                <span>${escapeHtml(localized(state.locale, category.description))}</span>
              </button>
            `).join("")}
          </div>
        ` : ""}
        ${renderHint(selectedCategory ? localized(state.locale, selectedCategory.description) : hintText(state.locale, "category"))}
      </div>
    `;
  }

  function renderOwnerPair() {
    return `
      <section class="slot-intention-pair owner-pair">
        ${renderSlotEditor(
          state.draft.ownerSlot,
          "owner-slot",
          t(state.locale, "ui.sections.ownerSlot"),
          t(state.locale, "ui.sectionDescriptions.ownerSlot")
        )}
        ${renderIntentionEditor(
          state.draft.ownerIntention,
          "owner-intention",
          t(state.locale, "ui.sections.ownerIntention"),
          t(state.locale, "ui.sectionDescriptions.ownerIntention"),
          {
            slot: state.draft.ownerSlot,
            slotOwnerKind: "owner-slot"
          }
        )}
      </section>
    `;
  }

  function renderSecondaryPairs() {
    return `
      <section class="section-group secondary-pairs-section">
        <div class="section-header">
          <div>
            <h2>${escapeHtml(t(state.locale, "ui.sections.secondarySlots"))}</h2>
            <p>${escapeHtml(t(state.locale, "ui.sectionDescriptions.secondarySlots"))}</p>
          </div>
          <button type="button" class="button-prominent" data-action="add-slot">${escapeHtml(buttonText(state.locale, "addSecondarySlot"))}</button>
        </div>
        ${state.draft.secondarySlots.length === 0
          ? `<p class="muted-text">${escapeHtml(t(state.locale, "ui.noSecondaryPairs"))}</p>`
          : state.draft.secondarySlots.map((slot, index) => {
            const intention = findLinkedIntention(slot);
            if (!intention) {
              return "";
            }
            return `
              <div class="slot-intention-pair">
                ${renderSlotEditor(
                  slot,
                  "slot",
                  secondarySlotTitle(state.locale, index + 1),
                  t(state.locale, "ui.sectionDescriptions.secondarySlotPair"),
                  false
                )}
                ${renderIntentionEditor(
                  intention,
                  "secondary-intention",
                  secondaryTemplateTitle(state.locale, index + 1),
                  t(state.locale, "ui.kinds.secondaryDescription"),
                  {
                    canDelete: true,
                    slot,
                    slotOwnerKind: "slot"
                  }
                )}
              </div>
            `;
          }).join("")}
      </section>
    `;
  }

  function render() {
    document.documentElement.lang = state.locale;
    document.documentElement.dataset.theme = state.theme;
    document.title = `${APP_TITLE} - ${getLocaleLabel(state.locale)}`;

    root.innerHTML = `
      <div class="shell">
        ${renderTopBar()}
        <main class="layout">
          ${renderScenarioSection()}
          ${renderOwnerPair()}
          ${renderSecondaryPairs()}
          ${renderValidationPanel()}
          ${renderExportPanel()}
        </main>
        ${renderDataLists()}
        ${renderModal()}
      </div>
    `;
    applyPendingFocus();
  }

  function isUndoEvent(event) {
    const key = `${event.key ?? ""}`.toLocaleLowerCase();
    return (event.ctrlKey || event.metaKey)
      && !event.altKey
      && !event.shiftKey
      && (key === "z" || event.code === "KeyZ");
  }

  function isRedoEvent(event) {
    const key = `${event.key ?? ""}`.toLocaleLowerCase();
    return (event.ctrlKey || event.metaKey)
      && !event.altKey
      && (
        key === "y"
        || event.code === "KeyY"
        || ((key === "z" || event.code === "KeyZ") && event.shiftKey)
      );
  }

  function handleUndoRedoShortcut(event) {
    if (isUndoEvent(event)) {
      event.preventDefault();
      undoHistory();
      return true;
    }
    if (isRedoEvent(event)) {
      event.preventDefault();
      redoHistory();
      return true;
    }

    return false;
  }

  root.addEventListener("click", handleClick);
  root.addEventListener("input", handleInput);
  root.addEventListener("change", handleInput);
  root.addEventListener("focusout", handleFocusOut);
  root.addEventListener("beforeinput", event => {
    if (event.inputType === "historyUndo") {
      event.preventDefault();
      undoHistory();
      return;
    }
    if (event.inputType === "historyRedo") {
      event.preventDefault();
      redoHistory();
    }
  });
  document.addEventListener("keydown", event => {
    if (handleUndoRedoShortcut(event)) {
      return;
    }

    if (event.key === "Escape" && state.searchableDropdown.openId) {
      closeSearchableDropdown();
      render();
      return;
    }
    if (event.key === "Escape" && state.modal) {
      state.modal = null;
      render();
    }
  });

  recalculate({ save: false });
}


/* main.js */
const root = document.getElementById("app");
mountApp(root);

})();