@rogatio/cli 6.3.0 → 6.4.1

package/dist/editor/index.css

@@ -395,6 +395,28 @@
   margin: 0;
   min-width: 0;
 }
+.rogatio-editor [data-rename-controls] {
+  display: flex;
+  flex: 1 1 16rem;
+  align-items: center;
+  gap: 0.35rem;
+  min-width: 0;
+}
+.rogatio-editor [data-rename-controls] input {
+  flex: 1 1 auto;
+  width: auto;
+  min-width: 0;
+  max-width: 32rem;
+}
+.rogatio-editor button[data-icon] {
+  flex: none;
+  width: 1.8rem;
+  min-height: 1.8rem;
+  padding: 0.15rem;
+  font-family: var(--rogatio-font-mono);
+  font-size: 0.9rem;
+  line-height: 1;
+}
 .rogatio-editor [data-group-list] {
   list-style: none;
   margin: 0;
@@ -413,10 +435,6 @@
   background: var(--rogatio-card-group);
   padding: 0.65rem 0.85rem;
 }
-.rogatio-editor [data-group-card] {
-  background: var(--rogatio-card-group);
-  border-color: rgba(148, 163, 184, 0.2);
-}
 .rogatio-editor [data-rules-section] {
   display: grid;
   gap: 0.85rem;

package/dist/editor/index.js

@@ -185,6 +185,56 @@ var FORBIDDEN_RESPONSE_HEADERS = Object.freeze([
   "via"
 ]);
 var FORBIDDEN_REQUEST_PREFIXES = Object.freeze(["proxy-", "sec-"]);
+var NON_ALPHANUMERIC = /[^a-z0-9]+/u;
+var WHITESPACE_RUN = /\s+/gu;
+var FALLBACK_PREFIX = Object.freeze({
+  group: "Group",
+  rule: "Rule"
+});
+function normalizeNameKey(name) {
+  if (typeof name !== "string") return "";
+  return name.trim().replace(WHITESPACE_RUN, " ").toLowerCase();
+}
+function pascalCase(value) {
+  const tokens = value.toLowerCase().split(NON_ALPHANUMERIC);
+  let result = "";
+  for (const token of tokens) {
+    const first = token.charAt(0);
+    if (first.length === 0) continue;
+    result += first.toUpperCase() + token.slice(1);
+  }
+  return result;
+}
+function allocate(stem, reserved, maxLength) {
+  for (let suffix = 1; ; suffix += 1) {
+    const suffixText = suffix === 1 ? "" : String(suffix);
+    const room = Math.max(1, maxLength - suffixText.length);
+    const candidate = `${stem.slice(0, room)}${suffixText}`;
+    if (reserved.has(candidate)) continue;
+    reserved.add(candidate);
+    return candidate;
+  }
+}
+function deriveEntityId(name, kind, reserved) {
+  const derived = pascalCase(typeof name === "string" ? name : "");
+  return allocate(
+    derived.length > 0 ? derived : FALLBACK_PREFIX[kind],
+    reserved,
+    LIMITS.maxIdLength
+  );
+}
+function uniqueName(base, reserved) {
+  const label = typeof base === "string" ? base : "";
+  for (let suffix = 1; ; suffix += 1) {
+    const suffixText = suffix === 1 ? "" : ` ${suffix}`;
+    const room = Math.max(1, LIMITS.maxLabelLength - suffixText.length);
+    const candidate = `${label.slice(0, room)}${suffixText}`;
+    const key = normalizeNameKey(candidate);
+    if (reserved.has(key)) continue;
+    reserved.add(key);
+    return candidate;
+  }
+}
 var RESOURCE_TYPES = Object.freeze([
   "main_frame",
   "sub_frame",
@@ -2131,6 +2181,14 @@ var EditorControllerImpl = class {
   aiAssistInFlight = false;
   aiRepairTargets = [];
   migrationNoticesDismissed = false;
+  /**
+   * The entity whose name is being edited in place, if any. The buffer lives
+   * here rather than in the DOM because every render rebuilds the heading, and
+   * the draft is deliberately untouched until an explicit commit.
+   */
+  renameTarget;
+  /** Re-entrancy guard: committing a rename renders, which asks again. */
+  renamingInProgress = false;
   constructor(options, initial, extensions) {
     this.root = options.root;
     this.document = options.root.ownerDocument;
@@ -2278,6 +2336,10 @@ var EditorControllerImpl = class {
     if (!(target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement)) {
       return;
     }
+    if (target.dataset.renameInput !== void 0) {
+      if (this.renameTarget) this.renameTarget.value = target.value;
+      return;
+    }
     if (target.dataset.search !== void 0) {
       this.searchQuery = target.value;
       this.render();
@@ -2345,14 +2407,36 @@ var EditorControllerImpl = class {
   };
   handleSubmit = (event) => {
     event.preventDefault();
+    if (this.renameTarget && this.renameInputFocused()) {
+      this.commitRename();
+      return;
+    }
     this.dispatchCommand("save", this.form);
   };
+  renameInputFocused() {
+    const active = this.document.activeElement;
+    return active instanceof HTMLElement && active.dataset.renameInput !== void 0;
+  }
   handleKeydown = (event) => {
     if (event.key === "Escape" && this.confirmation) {
       event.preventDefault();
       this.confirmation = void 0;
       this.statusMessage = "No changes were discarded.";
       this.render();
+      return;
+    }
+    const target = event.target;
+    const inRenameInput = target instanceof HTMLElement && target.dataset.renameInput !== void 0;
+    if (!inRenameInput) return;
+    if (this.composing || event.isComposing) return;
+    if (event.key === "Enter") {
+      event.preventDefault();
+      this.commitRename();
+      return;
+    }
+    if (event.key === "Escape") {
+      event.preventDefault();
+      this.cancelRename();
     }
   };
   handleCompositionStart = () => {
@@ -2449,6 +2533,31 @@ var EditorControllerImpl = class {
       if (groupId && ruleId) this.copyRule(groupId, ruleId);
       return;
     }
+    if (command === "rename-entity") {
+      const groupId = element.dataset.groupId;
+      if (!groupId) return;
+      const ruleId = element.dataset.ruleId;
+      this.openRename(
+        element.dataset.renameKind === "rule" ? "rule" : "group",
+        groupId,
+        ruleId
+      );
+      return;
+    }
+    if (command === "commit-rename") {
+      this.commitRename();
+      return;
+    }
+    if (command === "cancel-rename") {
+      this.cancelRename();
+      return;
+    }
+    if (command === "repair-id") {
+      const path = element.dataset.repairPath;
+      if (!path) return;
+      this.repairEntityId(path);
+      return;
+    }
     if (command === "dismiss-migration-notices") {
       void this.dismissMigrationNotices();
       return;
@@ -2683,15 +2792,24 @@ var EditorControllerImpl = class {
     }
     return ids;
   }
-  allocateId(prefix, reserved) {
-    let candidate = prefix;
-    let suffix = 2;
-    while (reserved.has(candidate)) candidate = `${prefix}-${suffix++}`;
-    reserved.add(candidate);
-    return candidate;
-  }
-  nextId(prefix) {
-    return this.allocateId(prefix, this.allIds());
+  /**
+   * Every name currently in the project, keyed for uniqueness comparison. Names
+   * are unique per project across groups and rules together, so a new entity
+   * must claim a free one or the project it produces is invalid.
+   */
+  allNameKeys() {
+    const reserved = /* @__PURE__ */ new Set();
+    for (const group of this.draft.groups) {
+      if (typeof group.name === "string") {
+        reserved.add(normalizeNameKey(group.name));
+      }
+      for (const rule of group.rules) {
+        if (typeof rule.name === "string") {
+          reserved.add(normalizeNameKey(rule.name));
+        }
+      }
+    }
+    return reserved;
   }
   copyLabel(name) {
     const base = typeof name === "string" ? name : "";
@@ -2703,42 +2821,35 @@ var EditorControllerImpl = class {
   }
   addGroup() {
     if (this.saving) return;
-    const groupId = this.nextId("group-new");
+    const name = uniqueName("New group", this.allNameKeys());
+    const groupId = deriveEntityId(name, "group", this.allIds());
     this.draft.groups.push({
       id: groupId,
-      name: "New group",
+      name,
       rules: []
     });
     this.markChanged();
     this.route = { kind: "group", groupId };
-    this.focusRequest = pointer("groups", this.draft.groups.length - 1, "name");
     this.statusMessage = "Group added.";
-    this.render();
+    this.openRename("group", groupId);
   }
   addRule(groupId) {
     if (this.saving) return;
     const group = this.groupById(groupId);
     if (!group) return;
-    const ruleId = this.nextId("rule-new");
+    const name = uniqueName("New rule", this.allNameKeys());
+    const ruleId = deriveEntityId(name, "rule", this.allIds());
     group.rules.push({
       id: ruleId,
-      name: "New rule",
+      name,
       source: { key: "url", operator: "regex", value: "" },
       resourceTypes: ["main_frame"],
       priority: 100
     });
     this.markChanged();
     this.route = { kind: "group", groupId };
-    const groupIndex = this.groupIndex(groupId);
-    this.focusRequest = pointer(
-      "groups",
-      groupIndex,
-      "rules",
-      group.rules.length - 1,
-      "name"
-    );
     this.statusMessage = "Rule added.";
-    this.render();
+    this.openRename("rule", groupId, ruleId);
   }
   copyRule(groupId, ruleId) {
     if (this.saving) return;
@@ -2753,21 +2864,16 @@ var EditorControllerImpl = class {
       return;
     }
     const copied = snapshot.value;
-    copied.id = this.nextId("rule-new");
-    copied.name = this.copyLabel(group.rules[sourceIndex].name);
+    copied.name = uniqueName(
+      this.copyLabel(group.rules[sourceIndex].name),
+      this.allNameKeys()
+    );
+    copied.id = deriveEntityId(copied.name, "rule", this.allIds());
     group.rules.splice(sourceIndex + 1, 0, copied);
     this.markChanged();
     this.route = { kind: "group", groupId };
-    const groupIndex = this.groupIndex(groupId);
-    this.focusRequest = pointer(
-      "groups",
-      groupIndex,
-      "rules",
-      sourceIndex + 1,
-      "name"
-    );
     this.statusMessage = "Rule copied.";
-    this.render();
+    this.openRename("rule", groupId, String(copied.id));
   }
   copyGroup(groupId) {
     if (this.saving) return;
@@ -2786,18 +2892,20 @@ var EditorControllerImpl = class {
       this.render();
       return;
     }
-    const reserved = this.allIds();
-    copied.id = this.allocateId("group-new", reserved);
-    copied.name = this.copyLabel(source.name);
+    const names = this.allNameKeys();
+    const ids = this.allIds();
+    copied.name = uniqueName(this.copyLabel(source.name), names);
+    copied.id = deriveEntityId(copied.name, "group", ids);
     for (const rule of copied.rules) {
-      rule.id = this.allocateId("rule-new", reserved);
+      if (typeof rule.name === "string") {
+        rule.name = uniqueName(rule.name, names);
+      }
+      rule.id = deriveEntityId(rule.name, "rule", ids);
     }
     this.draft.groups.splice(sourceIndex + 1, 0, copied);
     this.markChanged();
-    this.route = { kind: "group", groupId: String(copied.id) };
-    this.focusRequest = pointer("groups", sourceIndex + 1, "name");
     this.statusMessage = "Group copied.";
-    this.render();
+    this.openRename("group", String(copied.id));
   }
   moveGroup(groupId, delta) {
     if (this.saving) return;
@@ -2855,6 +2963,9 @@ var EditorControllerImpl = class {
     if (!this.confirmation || this.confirmation.kind === "cancel") return;
     const confirmation = this.confirmation;
     this.confirmation = void 0;
+    this.closeRenameFor(
+      confirmation.kind === "remove-group" ? { groupId: confirmation.groupId, ruleId: void 0 } : { groupId: confirmation.groupId, ruleId: confirmation.ruleId }
+    );
     if (confirmation.kind === "remove-group") {
       const index = this.groupIndex(confirmation.groupId);
       if (index < 0) return;
@@ -2901,6 +3012,7 @@ var EditorControllerImpl = class {
     this.errors = [];
     this.conversionDiagnostics.clear();
     this.confirmation = void 0;
+    this.renameTarget = void 0;
     this.statusMessage = "Changes discarded.";
     try {
       this.options.onCancel?.();
@@ -2960,13 +3072,14 @@ var EditorControllerImpl = class {
   applyAIProposal(proposal) {
     const repairs = [...this.aiRepairTargets];
     this.aiRepairTargets = [];
+    let lastApplied;
     for (const ruleProposal of proposal.rules) {
       let group = this.groupById(ruleProposal.groupId);
       if (!group) {
         const groupId = ruleProposal.groupId;
         this.draft.groups.push({
           id: groupId,
-          name: "AI Group",
+          name: uniqueName("AI Group", this.allNameKeys()),
           rules: []
         });
         group = this.groupById(groupId);
@@ -2977,7 +3090,11 @@ var EditorControllerImpl = class {
         (target) => target.groupId === ruleProposal.groupId && rules.some((existing) => String(existing.id) === target.ruleId)
       );
       let repairIndex = -1;
-      let ruleId = this.nextId("rule-ai");
+      const proposedName = uniqueName(
+        ruleProposal.name,
+        repair === void 0 ? this.allNameKeys() : this.reservedNameKeys(repair)
+      );
+      let ruleId = repair === void 0 ? deriveEntityId(proposedName, "rule", this.allIds()) : repair.ruleId;
       if (repair) {
         repairs.splice(repairs.indexOf(repair), 1);
         ruleId = repair.ruleId;
@@ -2987,7 +3104,7 @@ var EditorControllerImpl = class {
       }
       const rule = {
         id: ruleId,
-        name: ruleProposal.name,
+        name: proposedName,
         source: {
           key: ruleProposal.source.key,
           operator: "regex",
@@ -3006,16 +3123,13 @@ var EditorControllerImpl = class {
         rules.push(rule);
       }
       this.markChanged();
-      const groupIdStr = String(group.id);
-      this.focusRequest = pointer(
-        "groups",
-        this.groupIndex(groupIdStr),
-        "rules",
-        repairIndex >= 0 ? repairIndex : rules.length - 1,
-        "name"
-      );
+      lastApplied = { groupId: String(group.id), ruleId: String(rule.id) };
     }
     this.statusMessage = `Applied ${proposal.rules.length} rule${proposal.rules.length === 1 ? "" : "s"} from AI.`;
+    if (lastApplied) {
+      this.openRename("rule", lastApplied.groupId, lastApplied.ruleId);
+      return;
+    }
     this.render();
   }
   /**
@@ -3259,7 +3373,7 @@ var EditorControllerImpl = class {
         const ruleHeader = this.document.createElement("div");
         ruleHeader.dataset.testRuleHeader = "true";
         const ruleName = this.document.createElement("strong");
-        ruleName.textContent = `${rule.groupId}/${rule.ruleId}`;
+        ruleName.textContent = this.testRuleLabel(rule.groupId, rule.ruleId);
         const ruleBadge = this.document.createElement("span");
         ruleBadge.dataset.testBadge = "true";
         ruleBadge.dataset.variant = rule.matched ? "matched" : "unmatched";
@@ -3295,6 +3409,20 @@ var EditorControllerImpl = class {
       resultsSection.append(card);
     }
   }
+  /**
+   * A test-result row is identified by the names the user actually sees. The dry
+   * result carries ids only, and the draft the editor handed over is the source
+   * of truth for both, so no contract changes. A rule that is no longer in the
+   * draft falls back to its id rather than rendering a blank row.
+   */
+  testRuleLabel(groupId, ruleId) {
+    const group = this.groupById(groupId);
+    if (!group) return `${groupId}/${ruleId}`;
+    const groupName = displayName(group.name, "Unnamed group");
+    const rule = this.ruleById(groupId, ruleId);
+    if (!rule) return `${groupName} / ${ruleId}`;
+    return `${groupName} / ${displayName(rule.name, "Unnamed rule")}`;
+  }
   navigate(route, groupId) {
     if (route === "project") {
       this.route = { kind: "project" };
@@ -3305,10 +3433,30 @@ var EditorControllerImpl = class {
     } else {
       return;
     }
+    this.closeRenameOnLeave();
     this.testRequestId += 1;
     this.statusMessage = "";
     this.render();
   }
+  /**
+   * An uncommitted rename belongs to the entity it was started on. Leaving that
+   * entity, removing it, or discarding the draft closes the editor, so no buffer
+   * survives against a heading that is no longer on screen.
+   */
+  closeRenameOnLeave() {
+    const target = this.renameTarget;
+    if (!target) return;
+    const onGroup = this.route.kind === "group" && this.route.groupId === target.groupId;
+    if (!onGroup) this.renameTarget = void 0;
+  }
+  /** Close an open rename when the entity it belongs to goes away. */
+  closeRenameFor(entity) {
+    const target = this.renameTarget;
+    if (!target) return;
+    if (target.groupId === entity.groupId && target.ruleId === entity.ruleId) {
+      this.renameTarget = void 0;
+    }
+  }
   navigateToGroup(groupId) {
     const groupIds = new Set(
       this.draft.groups.map((group) => typeof group.id === "string" ? group.id : "").filter((id) => id.length > 0)
@@ -3334,11 +3482,22 @@ var EditorControllerImpl = class {
     );
     for (const button of buttons) {
       const groupId = button.dataset.groupId ?? "";
-      const headingName = button.parentElement?.querySelector("h2")?.textContent?.trim();
-      const groupName = headingName && headingName.length > 0 ? headingName : displayName(this.groupById(groupId)?.name, "Unnamed group");
+      const draftGroup = this.draftGroupForSavedId(groupId);
+      const groupName = displayName(
+        draftGroup?.name,
+        button.parentElement?.querySelector("h2")?.textContent?.trim() ?? ""
+      );
       this.applyGroupEnablementLabel(button, enabled.has(groupId), groupName);
     }
   }
+  /** The draft group bound to a committed id, through the index-based binding. */
+  draftGroupForSavedId(savedId) {
+    if (savedId.length === 0) return void 0;
+    for (const group of this.draft.groups) {
+      if (this.savedGroupId(group) === savedId) return group;
+    }
+    return void 0;
+  }
   /**
    * Scroll a rendered rule card into view and focus it. Explicit `behavior`
    * overrides the stylesheet's `scroll-behavior`, so the reduced-motion
@@ -3400,10 +3559,14 @@ var EditorControllerImpl = class {
       return;
     }
     const groupIndex = arrayIndex(segments[1] ?? "");
-    const group = groupIndex === void 0 ? void 0 : this.draft.groups[groupIndex];
+    if (groupIndex === void 0) return;
+    const group = this.draft.groups[groupIndex];
     if (!group || typeof group.id !== "string") return;
     this.route = { kind: "group", groupId: group.id };
-    this.focusRequest = path;
+    const last = segments[segments.length - 1];
+    const ruleIndex = arrayIndex(segments[3] ?? "");
+    const entityPath = last === "name" ? path : segments.length === 2 ? pointer("groups", groupIndex, "name") : segments.length === 4 && ruleIndex !== void 0 ? pointer("groups", groupIndex, "rules", ruleIndex, "name") : path;
+    this.focusRequest = entityPath;
     this.render();
   }
   currentGroupId() {
@@ -3433,6 +3596,7 @@ var EditorControllerImpl = class {
   }
   render() {
     if (this.destroyed) return;
+    this.composing = false;
     this.previousFocus = this.captureFocus();
     this.cleanupExtensions();
     this.controlNumber = 0;
@@ -3678,7 +3842,6 @@ var EditorControllerImpl = class {
     const headingRow = this.document.createElement("div");
     headingRow.dataset.groupHeading = "true";
     const heading = this.document.createElement("h2");
-    heading.textContent = groupName;
     const copyGroup = this.createCommandButton(
       "Copy group",
       "copy-group",
@@ -3694,6 +3857,7 @@ var EditorControllerImpl = class {
     );
     const savedGroupId = this.savedGroupId(group);
     const enablement = this.options.groupEnablement;
+    const commands = [];
     if (enablement && savedGroupId) {
       const enableButton = this.document.createElement("button");
       enableButton.type = "button";
@@ -3717,40 +3881,21 @@ var EditorControllerImpl = class {
           }
         );
       });
-      headingRow.append(heading, enableButton, copyGroup, removeGroup);
-    } else {
-      headingRow.append(heading, copyGroup, removeGroup);
+      commands.push(enableButton);
     }
+    commands.push(copyGroup, removeGroup);
+    this.renderNameHeading({
+      row: headingRow,
+      heading,
+      headingId: `${this.instanceId}-group-title-${groupIndex}`,
+      kind: "group",
+      groupId,
+      namePath: pointer("groups", groupIndex, "name"),
+      name: group.name,
+      fallback: "Unnamed group",
+      commands
+    });
     this.form.append(headingRow);
-    const settings = this.document.createElement("fieldset");
-    settings.dataset.groupCard = "true";
-    const legend = this.document.createElement("legend");
-    legend.textContent = "Group details";
-    settings.append(legend);
-    const fields = this.document.createElement("div");
-    fields.dataset.editorFields = "true";
-    const id = this.document.createElement("input");
-    id.type = "text";
-    id.maxLength = 64;
-    id.value = safeText(group.id);
-    this.renderField(
-      fields,
-      "Group ID",
-      pointer("groups", groupIndex, "id"),
-      id
-    );
-    const name = this.document.createElement("input");
-    name.type = "text";
-    name.maxLength = 100;
-    name.value = safeText(group.name);
-    this.renderField(
-      fields,
-      "Group name",
-      pointer("groups", groupIndex, "name"),
-      name
-    );
-    settings.append(fields);
-    this.form.append(settings);
     const rulesSection = this.document.createElement("section");
     rulesSection.dataset.rulesSection = "true";
     const rulesHeadingRow = this.document.createElement("div");
@@ -3893,7 +4038,6 @@ var EditorControllerImpl = class {
   renderRule(group, rule, groupIndex, ruleIndex) {
     const groupId = safeText(group.id);
     const ruleId = safeText(rule.id);
-    const ruleName = displayName(rule.name, "Unnamed rule");
     const rulePath = pointer("groups", groupIndex, "rules", ruleIndex);
     const card = this.document.createElement("article");
     card.dataset.ruleCard = "true";
@@ -3903,9 +4047,8 @@ var EditorControllerImpl = class {
     const headingRow = this.document.createElement("div");
     headingRow.dataset.ruleHeading = "true";
     const heading = this.document.createElement("h3");
-    heading.id = `${this.instanceId}-rule-title-${groupIndex}-${ruleIndex}`;
-    heading.textContent = ruleName;
-    card.setAttribute("aria-labelledby", heading.id);
+    const headingId = `${this.instanceId}-rule-title-${groupIndex}-${ruleIndex}`;
+    card.setAttribute("aria-labelledby", headingId);
     const actions = this.document.createElement("div");
     actions.dataset.ruleActions = "true";
     actions.append(
@@ -3933,27 +4076,20 @@ var EditorControllerImpl = class {
         "danger"
       )
     );
-    headingRow.append(heading, actions);
+    this.renderNameHeading({
+      row: headingRow,
+      heading,
+      headingId,
+      kind: "rule",
+      groupId,
+      ruleId,
+      namePath: `${rulePath}/name`,
+      name: rule.name,
+      fallback: "Unnamed rule",
+      commands: [actions]
+    });
     card.append(headingRow);
-    const fields = this.document.createElement("fieldset");
-    const legend = this.document.createElement("legend");
-    legend.textContent = "Common rule matcher";
-    fields.append(legend);
-    const grid = this.document.createElement("div");
-    grid.dataset.editorFields = "true";
-    const id = this.document.createElement("input");
-    id.type = "text";
-    id.maxLength = 64;
-    id.value = safeText(rule.id);
-    this.renderField(grid, "Rule ID", `${rulePath}/id`, id);
-    const name = this.document.createElement("input");
-    name.type = "text";
-    name.maxLength = 100;
-    name.value = safeText(rule.name);
-    this.renderField(grid, "Rule name", `${rulePath}/name`, name);
-    fields.append(grid);
-    this.renderSource(fields, rule, rulePath, groupId, ruleId);
-    card.append(fields);
+    this.renderSource(card, rule, rulePath, groupId, ruleId);
     this.renderResourceTypes(card, rule, rulePath);
     const matcherFields = this.document.createElement("fieldset");
     const matcherLegend = this.document.createElement("legend");
@@ -4359,6 +4495,299 @@ var EditorControllerImpl = class {
     this.controls.set(path, control);
     parent.append(field);
   }
+  /**
+   * Attach a control's diagnostics the same way `renderField` does, for a control
+   * that is not wrapped in a labelled field — the inline name editor.
+   */
+  decorateWithErrors(control, path) {
+    const errors = this.errors.filter((value) => value.path === path);
+    if (errors.length === 0) {
+      control.removeAttribute("aria-invalid");
+      control.removeAttribute("aria-describedby");
+      return;
+    }
+    control.setAttribute("aria-invalid", "true");
+    const error = this.document.createElement("div");
+    error.id = `${control.id}-error`;
+    error.dataset.editorFieldError = "true";
+    error.textContent = errors.map((value) => value.message).join(" ");
+    control.setAttribute("aria-describedby", error.id);
+    control.insertAdjacentElement("afterend", error);
+  }
+  /**
+   * Render a group or rule heading together with its inline rename control.
+   *
+   * The heading element is always present, even while the inline editor is open,
+   * because a rule card names itself through `aria-labelledby` and an `<input>`
+   * has no text content to name it with. While editing, the heading is moved
+   * into the visually-hidden state rather than removed, so the card keeps its
+   * accessible name and the shared action buttons keep their per-entity context.
+   */
+  renderNameHeading(options) {
+    const { row, heading, headingId, kind, namePath } = options;
+    const entityName = displayName(options.name, options.fallback);
+    const target = this.renameTargetFor(options);
+    const editing = target !== void 0;
+    const label = kind === "group" ? "group" : "rule";
+    const entityLabel = `${label} ${entityName}`;
+    heading.id = headingId;
+    heading.textContent = entityName;
+    if (editing) {
+      heading.dataset.editorVisuallyHidden = "true";
+    }
+    row.append(heading);
+    if (editing && target) {
+      const wrap = this.document.createElement("div");
+      wrap.dataset.renameControls = "true";
+      const input = this.document.createElement("input");
+      input.type = "text";
+      input.maxLength = LIMITS.maxLabelLength;
+      input.value = target.value;
+      input.id = this.controlId(namePath);
+      input.dataset.renameInput = "true";
+      input.dataset.editorKey = namePath;
+      input.disabled = this.saving;
+      input.setAttribute(
+        "aria-label",
+        // Named for the action and the entity. The removed field labels must
+        // not reappear as an accessible name.
+        `Rename ${entityLabel}`
+      );
+      const save = this.createCommandButton(
+        "Save name",
+        "commit-rename",
+        this.saving,
+        { renameKind: kind, groupId: options.groupId, ruleId: options.ruleId },
+        "primary"
+      );
+      save.setAttribute("aria-label", `Save ${entityLabel} name`);
+      save.textContent = "\u2713";
+      save.dataset.icon = "true";
+      const cancel = this.createCommandButton(
+        "Cancel rename",
+        "cancel-rename",
+        this.saving,
+        { renameKind: kind, groupId: options.groupId, ruleId: options.ruleId }
+      );
+      cancel.setAttribute("aria-label", `Cancel renaming ${entityLabel}`);
+      cancel.textContent = "\xD7";
+      cancel.dataset.icon = "true";
+      wrap.append(input, save, cancel);
+      row.append(wrap);
+      this.decorateWithErrors(input, namePath);
+      this.controls.set(namePath, input);
+    } else {
+      const pencil = this.createCommandButton(
+        `Rename ${label}`,
+        "rename-entity",
+        this.saving,
+        { renameKind: kind, groupId: options.groupId, ruleId: options.ruleId }
+      );
+      pencil.setAttribute("aria-label", `Rename ${entityLabel}`);
+      pencil.title = `Rename ${entityLabel}`;
+      pencil.textContent = "\u270E";
+      pencil.dataset.icon = "true";
+      row.append(pencil);
+    }
+    for (const command of options.commands) row.append(command);
+  }
+  /**
+   * The rename target for an entity, when it should be open.
+   *
+   * It is open when the entity is already being renamed, or when a focus request
+   * names its `/name` path. The second case is what makes add, copy, move, AI
+   * apply, and a name diagnostic all land in the inline editor with one
+   * mechanism.
+   */
+  renameTargetFor(options) {
+    const open = this.renameTarget;
+    if (open && open.groupId === options.groupId && open.ruleId === options.ruleId) {
+      open.namePath = options.namePath;
+      return open;
+    }
+    if (this.focusRequest !== options.namePath) return void 0;
+    if (open && !this.renamingInProgress) {
+      this.renamingInProgress = true;
+      try {
+        this.commitRename();
+      } finally {
+        this.renamingInProgress = false;
+      }
+      if (this.renameTarget) return void 0;
+    }
+    const value = this.currentName(options.groupId, options.ruleId);
+    if (value === void 0) return void 0;
+    const target = {
+      kind: options.kind,
+      groupId: options.groupId,
+      ruleId: options.ruleId,
+      namePath: options.namePath,
+      value
+    };
+    this.renameTarget = target;
+    return target;
+  }
+  currentName(groupId, ruleId) {
+    const group = this.groupById(groupId);
+    if (!group) return void 0;
+    if (ruleId === void 0) return safeText(group.name);
+    const rule = this.ruleById(groupId, ruleId);
+    return rule ? safeText(rule.name) : void 0;
+  }
+  /**
+   * Every group and rule name in the project, except the entity being renamed.
+   * Compared through the shared normalized key, so a rename is refused for a name
+   * that differs only by case or internal spacing.
+   */
+  reservedNameKeys(exclude) {
+    const reserved = /* @__PURE__ */ new Set();
+    for (const group of this.draft.groups) {
+      const isTargetGroup = group.id === exclude.groupId;
+      if (!isTargetGroup && typeof group.name === "string") {
+        reserved.add(normalizeNameKey(group.name));
+      }
+      for (const rule of group.rules) {
+        if (isTargetGroup && rule.id === exclude.ruleId) continue;
+        if (typeof rule.name === "string") {
+          reserved.add(normalizeNameKey(rule.name));
+        }
+      }
+    }
+    return reserved;
+  }
+  /**
+   * A human description of whichever entity already holds a normalized name, so
+   * a refused rename can name the conflict instead of only reporting that one
+   * exists.
+   */
+  nameHolderFor(key, exclude) {
+    for (const group of this.draft.groups) {
+      if (typeof group.name === "string" && normalizeNameKey(group.name) === key) {
+        if (group.id === exclude.groupId && exclude.ruleId === void 0)
+          continue;
+        return `group \u201C${displayName(group.name, "Unnamed group")}\u201D`;
+      }
+      for (const rule of group.rules) {
+        if (typeof rule.name !== "string") continue;
+        if (normalizeNameKey(rule.name) !== key) continue;
+        if (group.id === exclude.groupId && rule.id === exclude.ruleId)
+          continue;
+        return `rule \u201C${displayName(rule.name, "Unnamed rule")}\u201D`;
+      }
+    }
+    return void 0;
+  }
+  openRename(kind, groupId, ruleId) {
+    if (this.saving) return;
+    const groupIndex = this.groupIndex(groupId);
+    if (groupIndex === -1) return;
+    const group = this.draft.groups[groupIndex];
+    if (!group) return;
+    const namePath = ruleId === void 0 ? pointer("groups", groupIndex, "name") : pointer(
+      "groups",
+      groupIndex,
+      "rules",
+      this.ruleIndex(group, ruleId),
+      "name"
+    );
+    const value = this.currentName(groupId, ruleId);
+    if (value === void 0) return;
+    this.route = { kind: "group", groupId };
+    this.renameTarget = { kind, groupId, ruleId, namePath, value };
+    this.composing = false;
+    this.focusRequest = namePath;
+    this.render();
+  }
+  cancelRename() {
+    const target = this.renameTarget;
+    if (!target) return;
+    this.renameTarget = void 0;
+    this.statusMessage = "Name change discarded.";
+    this.render();
+    this.focusRenameControl(target.groupId, target.ruleId);
+  }
+  focusRenameControl(groupId, ruleId) {
+    for (const button of this.host.querySelectorAll(
+      '[data-command="rename-entity"]'
+    )) {
+      if (button.dataset.groupId !== groupId) continue;
+      if ((button.dataset.ruleId ?? void 0) !== ruleId) continue;
+      button.focus();
+      return;
+    }
+  }
+  /** Refuse a commit, keep the editor open, and say why. */
+  rejectRename(target, message) {
+    this.statusMessage = message;
+    this.focusRequest = target.namePath;
+    this.render();
+  }
+  /**
+   * Write a name onto the entity the rename targets, resolved by identity.
+   *
+   * `setValueAtPath` refuses to create a property that is not already there,
+   * because its allowlist exists to stop a field input inventing arbitrary keys.
+   * A `name` is different: a hand-authored project can legitimately arrive with
+   * the property *absent*, and the diagnostic that reports it is exactly the one
+   * the inline editor exists to repair. So the name is written here, onto a
+   * record resolved by id, which also means a stale index cannot land the value
+   * on a different entity.
+   */
+  writeEntityName(groupId, ruleId, value) {
+    const group = this.groupById(groupId);
+    if (!group) return false;
+    const rule = ruleId === void 0 ? void 0 : this.ruleById(groupId, ruleId);
+    if (ruleId !== void 0 && !rule) return false;
+    const target = rule ?? group;
+    if (target === void 0) return false;
+    if (target.name === value) return false;
+    Object.defineProperty(target, "name", {
+      configurable: true,
+      enumerable: true,
+      value,
+      writable: true
+    });
+    return true;
+  }
+  commitRename() {
+    const target = this.renameTarget;
+    if (!target || this.saving) return;
+    const trimmed = target.value.trim();
+    if (trimmed.length === 0) {
+      this.rejectRename(target, "A name cannot be empty.");
+      return;
+    }
+    if (trimmed.length > LIMITS.maxLabelLength) {
+      this.rejectRename(
+        target,
+        `A name cannot be longer than ${LIMITS.maxLabelLength} characters.`
+      );
+      return;
+    }
+    const key = normalizeNameKey(trimmed);
+    if (this.reservedNameKeys(target).has(key)) {
+      const holder = this.nameHolderFor(key, target);
+      this.rejectRename(
+        target,
+        holder ? `The ${holder} already uses that name. Pick a different name.` : "That name is already used in this project."
+      );
+      return;
+    }
+    const changed = this.writeEntityName(
+      target.groupId,
+      target.ruleId,
+      trimmed
+    );
+    this.renameTarget = void 0;
+    if (!changed) {
+      this.statusMessage = "Name unchanged.";
+      this.render();
+      return;
+    }
+    this.markChanged();
+    this.statusMessage = "Name updated.";
+    this.render();
+  }
   renderSummary() {
     this.summary.replaceChildren();
     this.summary.hidden = this.errors.length === 0;
@@ -4373,10 +4802,89 @@ var EditorControllerImpl = class {
       button.dataset.errorPath = error.path;
       button.textContent = `${error.message} (${error.path || "project"})`;
       item.append(button);
+      const repair = this.idRepairFor(error.path);
+      if (repair) {
+        const fix = this.createCommandButton(
+          "Assign a new ID",
+          "repair-id",
+          this.saving,
+          { repairPath: error.path },
+          "secondary"
+        );
+        fix.setAttribute("aria-label", repair.label);
+        item.append(fix);
+      }
       list.append(item);
     }
     this.summary.append(heading, list);
   }
+  /** A label for the entity an id diagnostic names, when it names one. */
+  idRepairFor(path) {
+    const segments = decodePointer(path);
+    if (segments?.[0] !== "groups" || segments[segments.length - 1] !== "id") {
+      return void 0;
+    }
+    const entity = this.entityAtIdPath(segments);
+    if (!entity) return void 0;
+    return { label: entity.label };
+  }
+  /**
+   * Resolve the entity an id path names.
+   *
+   * By index, not by id: the whole point of this path is that the id is wrong,
+   * and two entities can share it, so an id lookup would be ambiguous and could
+   * repair the wrong one.
+   */
+  entityAtIdPath(segments) {
+    if (!segments) return void 0;
+    const groupIndex = arrayIndex(segments[1] ?? "");
+    if (groupIndex === void 0) return void 0;
+    const group = this.draft.groups[groupIndex];
+    if (!group) return void 0;
+    if (segments.length === 3) {
+      return {
+        group,
+        label: `Assign a new ID to group ${displayName(group.name, "Unnamed group")}`
+      };
+    }
+    if (segments.length === 5) {
+      const ruleIndex = arrayIndex(segments[3] ?? "");
+      if (ruleIndex === void 0) return void 0;
+      const rule = group.rules[ruleIndex];
+      if (!rule) return void 0;
+      return {
+        group,
+        rule,
+        label: `Assign a new ID to rule ${displayName(rule.name, "Unnamed rule")}`
+      };
+    }
+    return void 0;
+  }
+  repairEntityId(path) {
+    if (this.saving) return;
+    const entity = this.entityAtIdPath(decodePointer(path));
+    if (!entity) return;
+    const { group, rule } = entity;
+    const openIndex = this.route.kind === "group" ? this.groupIndex(this.route.groupId) : -1;
+    const repairedIndex = this.draft.groups.indexOf(group);
+    const name = rule === void 0 ? group.name : rule.name;
+    const next = deriveEntityId(
+      name,
+      rule === void 0 ? "group" : "rule",
+      this.allIds()
+    );
+    if (!setValueAtPath(this.draft, path, next)) {
+      this.statusMessage = "ID unchanged.";
+      this.render();
+      return;
+    }
+    this.markChanged();
+    this.statusMessage = `Assigned the ID ${next}.`;
+    if (openIndex === repairedIndex) {
+      this.route = { kind: "group", groupId: String(group.id) };
+    }
+    this.validate();
+  }
   renderSearchResults() {
     const root = this.searchResults;
     root.replaceChildren();

package/dist/node/index.js

@@ -218,6 +218,15 @@ var LIMITS = Object.freeze({
   maxRequestBodyOperations: 32,
   maxLocalOrigins: 32
 });
+var WHITESPACE_RUN = /\s+/gu;
+var FALLBACK_PREFIX = Object.freeze({
+  group: "Group",
+  rule: "Rule"
+});
+function normalizeNameKey(name) {
+  if (typeof name !== "string") return "";
+  return name.trim().replace(WHITESPACE_RUN, " ").toLowerCase();
+}
 function normalizeSiteOrigin(value) {
   if (typeof value !== "string" || value.length === 0 || value.trim() !== value)
     return null;
@@ -972,12 +981,24 @@ ajv.addFormat("rogatio-url-regex", {
 });
 function ajvIssues(errors) {
   return (errors ?? []).map((error) => ({
-    instancePath: error.instancePath,
+    // Ajv reports a `required` violation against the object that lacks the
+    // property, with the property named in `params.missingProperty`. Left alone,
+    // that parent path names a location no field or entity owns, so the missing
+    // property's own path is reconstructed here — once, for every Ajv consumer.
+    instancePath: missingPropertyPath(error),
     keyword: error.keyword,
     message: error.message ?? "validation failed",
     params: error.params
   }));
 }
+function missingPropertyPath(error) {
+  if (error.keyword !== "required") return error.instancePath;
+  const missing = error.params?.missingProperty;
+  if (typeof missing !== "string" || missing.length === 0) {
+    return error.instancePath;
+  }
+  return `${error.instancePath}/${missing}`;
+}
 function snapshotOwnData(value, ancestors = /* @__PURE__ */ new WeakSet()) {
   if (value === null || typeof value !== "object") {
     return { valid: true, value };
@@ -1067,7 +1088,23 @@ var projectValidator = guardedProjectValidator;
 function semanticIssues(project) {
   const issues = [];
   const ids = /* @__PURE__ */ new Map();
+  const names = /* @__PURE__ */ new Map();
   let ruleCount = 0;
+  const claimName = (name, namePath) => {
+    if (typeof name !== "string" || name.length === 0) return;
+    const key = normalizeNameKey(name);
+    const previous = names.get(key);
+    if (previous === void 0) {
+      names.set(key, namePath);
+      return;
+    }
+    issues.push({
+      instancePath: namePath,
+      keyword: "uniqueName",
+      message: `must be unique; already used at ${previous}`,
+      params: { previousPath: previous }
+    });
+  };
   for (let groupIndex = 0; groupIndex < project.groups.length; groupIndex += 1) {
     const group = project.groups[groupIndex];
     const groupPath = `/groups/${groupIndex}`;
@@ -1082,6 +1119,7 @@ function semanticIssues(project) {
     } else {
       ids.set(group.id, `${groupPath}/id`);
     }
+    claimName(group.name, `${groupPath}/name`);
     for (let ruleIndex = 0; ruleIndex < group.rules.length; ruleIndex += 1) {
       const rule = group.rules[ruleIndex];
       ruleCount += 1;
@@ -1097,6 +1135,7 @@ function semanticIssues(project) {
       } else {
         ids.set(rule.id, `${rulePath}/id`);
       }
+      claimName(rule.name, `${rulePath}/name`);
       if (rule.type !== void 0 && rule.type !== "redirect" && rule.type !== "query" && rule.type !== "header" && rule.type !== "response-body" && rule.type !== "request-body") {
         issues.push({
           instancePath: `${rulePath}/type`,
@@ -1620,6 +1659,7 @@ var ISSUE_CODES = {
   uniqueItems: "schema.out-of-range",
   ownProperties: "schema.invalid-structure",
   uniqueId: "schema.duplicate-id",
+  uniqueName: "schema.duplicate-name",
   maxRulesPerProject: "schema.rule-limit"
 };
 var SAFE_PARAM_KEYS = /* @__PURE__ */ new Set([
@@ -1647,6 +1687,7 @@ var MESSAGES = {
   "schema.out-of-range": "The project contains a value outside its allowed bounds.",
   "schema.invalid-structure": "The project contains invalid structure.",
   "schema.duplicate-id": "Project and rule IDs must be unique.",
+  "schema.duplicate-name": "Group and rule names must be unique within a project.",
   "schema.rule-limit": "The project contains too many rules.",
   "compiler.invariant": "The compiler could not normalize validated project data.",
   "compiler.forbidden-header": "The header name is forbidden for this direction.",
@@ -20972,12 +21013,22 @@ Replace-mode body may use URL captures. Regex-mode replacement strings use captu
 Replace-mode body may use URL captures. Regex-mode replacement strings use captures from the body pattern, not the source pattern.
 
 ## Compiler Diagnostic Codes (stable)
-- schema.invalid-regex - Invalid regex syntax
-- schema.duplicate-id - Duplicate group/rule ID
-- schema.invalid-resource-type - Unknown resource type
-- schema.invalid-method - Unknown HTTP method
-- schema.regex-too-long - Regex exceeds 2048 chars
-- compiler.unsupported-operation - Operation kind not supported
+- schema.required - Required project data is missing
+- schema.unknown-property - The project contains an unknown property
+- schema.invalid-type - A value has an invalid type
+- schema.invalid-format - A value has an invalid format
+- schema.invalid-value - A value is invalid
+- schema.out-of-range - A value is outside its allowed bounds
+- schema.invalid-structure - A value has invalid structure
+- schema.duplicate-id - Duplicate group or rule ID
+- schema.duplicate-name - Duplicate group or rule name; every group and rule name must be unique in the project
+- schema.rule-limit - The project contains too many rules
+- compiler.invariant - The compiler could not normalize the project
+- compiler.forbidden-header - The header is forbidden for this direction
+- compiler.header-value-required - A header value is required for set and append
+- compiler.header-value-unexpected - A header value is not allowed for remove
+- compiler.invalid-header-direction - Invalid header direction
+- compiler.invalid-header-operation - Invalid header operation
 
 ## Current Project
 ${projectJson}
@@ -22595,12 +22646,42 @@ async function startInterceptProxy(options = {}) {
     }
   };
 }
+function pacCheck(route) {
+  if (typeof route.url === "string" && isExactHttpUrl(route.url)) {
+    return {
+      key: `url:${route.url}`,
+      line: `url === ${JSON.stringify(route.url)}`
+    };
+  }
+  if (typeof route.hostname === "string" && route.hostname.length > 0 && !route.hostname.includes("://")) {
+    return {
+      key: `host:${route.hostname}`,
+      line: `host === ${JSON.stringify(route.hostname)}`
+    };
+  }
+  return null;
+}
+function isExactHttpUrl(value) {
+  try {
+    const url = new URL(value);
+    return (url.protocol === "http:" || url.protocol === "https:") && url.username === "" && url.password === "" && url.href === value;
+  } catch {
+    return false;
+  }
+}
 function generatePacScript(routes, endpoint, options) {
   if (!Array.isArray(routes)) {
     throw new Error("runtime.pac-route-limit");
   }
-  const unique = routes.map((route) => route.hostname).filter((hostname) => typeof hostname === "string" && hostname.length > 0);
-  const sorted = [...new Set(unique)].sort();
+  const checksByKey = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const check = pacCheck(route);
+    if (check === null) continue;
+    checksByKey.set(check.key, check.line);
+  }
+  const sorted = [...checksByKey.entries()].sort(
+    ([left], [right]) => left.localeCompare(right)
+  );
   if (sorted.length > MAX_PAC_ROUTES) {
     throw new Error("runtime.pac-route-limit");
   }
@@ -22608,7 +22689,7 @@ function generatePacScript(routes, endpoint, options) {
   const proxy = `${proxyType} ${endpoint.host}:${endpoint.port}`;
   const proxyLiteral = JSON.stringify(proxy);
   const checks = sorted.map(
-    (hostname) => `  if (host === ${JSON.stringify(hostname)}) {
+    ([, predicate]) => `  if (${predicate}) {
     return ${proxyLiteral};
   }`
   );
@@ -22724,7 +22805,9 @@ function createPlatformInterceptionProvider(adapter) {
       }
       const endpoint = await adapter.startTlsProxy(activation);
       const pac = generatePacScript(
-        pacRoutes.map((hostname) => ({ hostname })),
+        pacRoutes.map(
+          (entry) => entry.includes("://") ? { url: entry } : { hostname: entry }
+        ),
         endpoint
       );
       try {
@@ -27710,6 +27793,20 @@ async function testCommandImpl(args, stdinInput, captureOutput, options = {}) {
     if (captureOutput) return output;
     console.log(output.trim());
   } else {
+    const groupNames = /* @__PURE__ */ new Map();
+    if (schemaResult.valid) {
+      for (const group of schemaResult.data.groups) {
+        groupNames.set(group.id, group.name);
+      }
+    }
+    const labels = /* @__PURE__ */ new Map();
+    for (const operation of compileResult.operations) {
+      const groupName = groupNames.get(operation.groupId);
+      labels.set(
+        `${operation.groupId}/${operation.ruleId}`,
+        groupName === void 0 ? operation.name : `${groupName} / ${operation.name}`
+      );
+    }
     let output = "";
     for (const urlResult of dryRunResult.results) {
       output += `
@@ -27718,7 +27815,9 @@ URL: ${urlResult.url}
       output += `  Matched rules: ${urlResult.matchedRuleCount}
 `;
       for (const rule of urlResult.rules) {
-        output += `  ${rule.groupId}/${rule.ruleId}: ${rule.matched ? "MATCHED" : "NOT MATCHED"}
+        const key = `${rule.groupId}/${rule.ruleId}`;
+        const label2 = labels.get(key) ?? key;
+        output += `  ${label2}: ${rule.matched ? "MATCHED" : "NOT MATCHED"}
 `;
         output += `    source: ${rule.source.state} - ${rule.source.detail}
 `;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rogatio/cli",
-  "version": "6.3.0",
+  "version": "6.4.1",
   "private": false,
   "type": "module",
   "description": "Local-first browser request and response rules — editor host, file verification, test runner, and runtime dispatch.",