@rogatio/cli 6.8.0 → 6.9.1

package/dist/editor/index.css

@@ -729,6 +729,10 @@
   .rogatio-editor :focus-visible {
     outline-color: Highlight;
   }
+  .rogatio-editor [data-test-rule-link] {
+    color: LinkText;
+    background: transparent;
+  }
   .rogatio-editor [data-desktop-route-rail] {
     border-bottom-color: ButtonText;
   }
@@ -741,10 +745,40 @@
     transition: none;
   }
 }
-.rogatio-editor [data-test-description] {
+.rogatio-editor [data-test-description],
+.rogatio-editor [data-test-checking] {
   color: var(--rogatio-muted);
   margin-block: 0 1rem;
 }
+.rogatio-editor [data-test-samples] {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.5rem;
+  margin-top: 0.75rem;
+}
+.rogatio-editor [data-test-outcome] {
+  margin: 0;
+}
+.rogatio-editor [data-test-rule-link] {
+  display: inline;
+  margin: 0;
+  padding: 0;
+  border: 0;
+  background: none;
+  color: var(--rogatio-primary);
+  font: inherit;
+  text-decoration: underline;
+  cursor: pointer;
+}
+.rogatio-editor [data-test-misses] {
+  margin-top: 0.5rem;
+}
+.rogatio-editor [data-test-misses] summary {
+  cursor: pointer;
+}
+.rogatio-editor [data-test-miss-reason] {
+  color: var(--rogatio-muted);
+}
 .rogatio-editor [data-test-panel] {
   display: grid;
   gap: 1rem;

package/dist/editor/index.js

@@ -1742,6 +1742,31 @@ var HTTP_METHODS2 = [
   "CONNECT",
   "TRACE"
 ];
+var RESOURCE_TYPE_LABELS = {
+  main_frame: "Page",
+  sub_frame: "Frame",
+  stylesheet: "Stylesheet",
+  script: "Script",
+  image: "Image",
+  font: "Font",
+  object: "Plugin",
+  media: "Media",
+  xmlhttprequest: "Fetch",
+  ping: "Ping",
+  csp_report: "CSP report",
+  websocket: "WebSocket",
+  webtransport: "WebTransport",
+  webbundle: "Web Bundle",
+  other: "Other"
+};
+var TEST_CASE_LIMIT = 256;
+var RULE_TYPE_LABELS = {
+  redirect: "Redirect",
+  query: "Query parameters",
+  header: "Header",
+  "response-body": "Response body",
+  "request-body": "Request body"
+};
 var COMMON_RULE_FIELDS = /* @__PURE__ */ new Set([
   "id",
   "name",
@@ -2033,6 +2058,80 @@ function displayName(value, fallback) {
   const text = safeText(value, fallback);
   return text.length > 0 ? text : fallback;
 }
+function checkingCopy(method, resourceType) {
+  if (method === "GET" && resourceType === "main_frame") {
+    return "Checking these as page loads (GET).";
+  }
+  if (method === "" && resourceType === "") {
+    return "The method and the resource type are not tested.";
+  }
+  const resourceLabel = resourceType === "" ? "" : RESOURCE_TYPE_LABELS[resourceType];
+  if (method === "") {
+    const subject = resourceType === "main_frame" ? "page loads" : `${resourceLabel} requests`;
+    return `Checking these as ${subject}. The method is not tested.`;
+  }
+  if (resourceType === "") {
+    return `Checking these as ${method} requests. The resource type is not tested.`;
+  }
+  if (resourceType === "main_frame") {
+    return `Checking these as page loads (${method}).`;
+  }
+  return `Checking these as ${resourceLabel} requests (${method}).`;
+}
+function exactUrlFromSource(source) {
+  if (source?.key !== "url" || source.operator !== "regex") {
+    return null;
+  }
+  if (typeof source.value !== "string") return null;
+  const value = source.value;
+  if (!value.startsWith("^") || !value.endsWith("$") || value.length < 2) {
+    return null;
+  }
+  let decoded = "";
+  for (let index = 1; index < value.length - 1; index += 1) {
+    const char = value[index];
+    if (char === "\\") {
+      index += 1;
+      const escaped = value[index];
+      if (escaped === void 0 || index >= value.length - 1) return null;
+      decoded += escaped;
+      continue;
+    }
+    if ("^$\\.*+?()[]{}|".includes(char)) return null;
+    decoded += char;
+  }
+  const converted = urlToExactRegex(decoded);
+  if (!converted.ok || converted.source !== value) return null;
+  return decoded;
+}
+function isDryRunResult(value) {
+  if (!isRecord4(value)) return false;
+  const summary = value.summary;
+  return Array.isArray(value.results) && Array.isArray(value.errors) && isRecord4(summary) && typeof summary.matchedUrlCount === "number" && typeof summary.urlCount === "number";
+}
+function previewSentence(preview) {
+  if (!preview || preview.summary.length === 0) return null;
+  switch (preview.kind) {
+    case "redirect":
+      return `The browser would go to ${preview.summary}.`;
+    case "query":
+      return `The query would be ${preview.summary}.`;
+    case "header":
+      return `The header would be ${preview.summary}.`;
+    case "request-body":
+      return `The request body would be ${preview.summary}.`;
+    case "response-body":
+      return `The response body would be ${preview.summary}.`;
+    default:
+      return null;
+  }
+}
+function missReason(rule) {
+  if (rule.source.state === "unmatched") return "URL pattern";
+  if (rule.method.state === "unmatched") return "method";
+  if (rule.resourceType.state === "unmatched") return "resource type";
+  return "URL pattern";
+}
 function isHTMLElement(value) {
   return value !== null && typeof value === "object" && value.nodeType === 1 && typeof value.appendChild === "function";
 }
@@ -2171,9 +2270,8 @@ var EditorControllerImpl = class {
   controlNumber = 0;
   previousFocus;
   testUrls = "";
-  testMethod = "";
-  testResourceType = "";
-  testMaxCases = "256";
+  testMethod = "GET";
+  testResourceType = "main_frame";
   testResult = void 0;
   testRunning = false;
   testRequestId = 0;
@@ -2349,10 +2447,6 @@ var EditorControllerImpl = class {
       this.testUrls = target.value;
       return;
     }
-    if (target.dataset.testMaxCases !== void 0) {
-      this.testMaxCases = target.value;
-      return;
-    }
     const path = target.dataset.path;
     if (!path || target.type === "checkbox" || this.extensionControls.has(path))
       return;
@@ -2387,10 +2481,12 @@ var EditorControllerImpl = class {
     }
     if (target instanceof HTMLSelectElement && target.dataset.testMethod !== void 0) {
       this.testMethod = target.value || "";
+      this.render();
       return;
     }
     if (target instanceof HTMLSelectElement && target.dataset.testResourceType !== void 0) {
       this.testResourceType = target.value || "";
+      this.render();
       return;
     }
     const path = target.dataset.path;
@@ -2571,6 +2667,17 @@ var EditorControllerImpl = class {
       void this.runTest();
       return;
     }
+    if (command === "test:open-rule") {
+      this.navigateToRule(element.dataset.groupId, element.dataset.ruleId);
+      return;
+    }
+    if (command === "test:try-url") {
+      const url = element.dataset.url;
+      if (!url) return;
+      this.testUrls = url;
+      this.statusMessage = "";
+      this.render();
+    }
   }
   collectDiagnostics(value) {
     let hostDiagnostics;
@@ -3282,65 +3389,111 @@ var EditorControllerImpl = class {
     this.focusRequest = path;
     this.render();
   }
+  ruleCount() {
+    let count = 0;
+    for (const group of this.draft.groups) count += group.rules.length;
+    return count;
+  }
+  testLines() {
+    const entries = [];
+    const rawLines = this.testUrls.split(/\r?\n/);
+    for (let index = 0; index < rawLines.length; index += 1) {
+      const url = rawLines[index]?.trim() ?? "";
+      if (url.length > 0) entries.push({ url, line: index + 1 });
+    }
+    return entries;
+  }
+  showDryRunDiagnostics(diagnostics) {
+    this.testResult = void 0;
+    this.testRunning = false;
+    this.errors = [...diagnostics];
+    const count = diagnostics.length;
+    this.statusMessage = count === 0 ? "The project could not be tested." : `${count} validation error${count === 1 ? "" : "s"} found.`;
+    const first = diagnostics[0];
+    if (first) {
+      this.navigateToPath(first.path);
+      return;
+    }
+    this.render();
+  }
   async runTest() {
     if (!this.options.dryRun) {
       this.statusMessage = "Dry-run is not configured for this editor instance.";
       this.render();
       return;
     }
-    const urlsText = this.testUrls.trim();
-    if (!urlsText) {
+    if (this.ruleCount() === 0) {
+      this.testResult = void 0;
+      this.testRunning = false;
+      this.statusMessage = "This project has no rules to test.";
+      this.render();
+      return;
+    }
+    const lines = this.testLines();
+    if (lines.length === 0) {
       this.statusMessage = "Please enter at least one URL to test.";
       this.render();
       return;
     }
-    const lines = urlsText.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
-    const cases = lines.map((url) => ({
-      url,
-      method: this.testMethod === "" ? void 0 : this.testMethod,
-      resourceType: this.testResourceType === "" ? void 0 : this.testResourceType
-    }));
-    const maxCasesRaw = Number.parseInt(this.testMaxCases, 10);
-    const maxCases = Number.isSafeInteger(maxCasesRaw) && maxCasesRaw > 0 ? maxCasesRaw : void 0;
+    if (lines.length > TEST_CASE_LIMIT) {
+      this.testResult = void 0;
+      this.testRunning = false;
+      this.statusMessage = "Only 256 URLs can be checked at once.";
+      this.render();
+      return;
+    }
+    const cases = lines.map((entry) => {
+      const testCase = { url: entry.url };
+      if (this.testMethod !== "") testCase.method = this.testMethod;
+      if (this.testResourceType !== "") {
+        testCase.resourceType = this.testResourceType;
+      }
+      return testCase;
+    });
     const requestId = ++this.testRequestId;
     this.testRunning = true;
-    this.statusMessage = "Running dry-run...";
+    this.statusMessage = "Checking URLs...";
     this.render();
     try {
-      const result = await this.options.dryRun(
-        this.getDraft(),
-        cases,
-        maxCases === void 0 ? void 0 : { maxCases }
-      );
+      const outcome = await this.options.dryRun(this.getDraft(), cases);
       if (requestId !== this.testRequestId) return;
-      this.testResult = result;
       this.testRunning = false;
-      const matched = result.summary.matchedUrlCount;
-      const total = result.summary.urlCount;
-      this.statusMessage = `Test complete: ${matched}/${total} URLs matched at least one rule.`;
+      if (isDryRunResult(outcome)) {
+        this.testResult = outcome;
+        const checked = outcome.summary.urlCount;
+        this.statusMessage = outcome.errors.length > 0 ? `Checked ${checked} URL${checked === 1 ? "" : "s"}. Some lines are not http(s) URLs.` : `Checked ${checked} URL${checked === 1 ? "" : "s"}.`;
+        this.render();
+        return;
+      }
+      const diagnostics = normalizeDiagnostics(
+        isRecord4(outcome) ? outcome.diagnostics : void 0
+      );
+      this.showDryRunDiagnostics(diagnostics);
     } catch (e) {
       if (requestId !== this.testRequestId) return;
+      this.testResult = void 0;
       this.testRunning = false;
       const message = e instanceof Error ? e.message : "Test failed";
       this.statusMessage = `Test error: ${message}`;
+      this.render();
     }
-    this.render();
   }
   renderTestResults(result) {
     const resultsSection = this.host.querySelector(
       "[data-test-results]"
     );
-    if (!resultsSection) return;
+    if (!resultsSection || !isDryRunResult(result)) return;
     resultsSection.replaceChildren();
     const heading = this.document.createElement("h3");
     heading.textContent = "Results";
     resultsSection.append(heading);
+    const lines = this.testLines();
     if (result.errors.length > 0) {
       const errorsList = this.document.createElement("ul");
       errorsList.dataset.testErrors = "true";
       for (const err of result.errors) {
         const item = this.document.createElement("li");
-        item.textContent = `${err.code}: ${err.message}${err.index !== void 0 ? ` (case ${err.index})` : ""}`;
+        item.textContent = this.testErrorText(err, lines);
         errorsList.append(item);
       }
       resultsSection.append(errorsList);
@@ -3355,73 +3508,135 @@ var EditorControllerImpl = class {
     for (const urlResult of result.results) {
       const card = this.document.createElement("article");
       card.dataset.testResultCard = "true";
-      const matched = urlResult.matchedRuleCount > 0;
-      card.dataset.matched = matched ? "true" : "false";
-      const urlHeader = this.document.createElement("div");
-      urlHeader.dataset.testResultHeader = "true";
-      const urlText = this.document.createElement("strong");
-      urlText.textContent = urlResult.url;
-      const urlBadge = this.document.createElement("span");
-      urlBadge.dataset.testBadge = "true";
-      urlBadge.dataset.variant = matched ? "matched" : "unmatched";
-      urlBadge.textContent = matched ? "MATCHED" : "NO MATCH";
-      urlHeader.append(urlText, urlBadge);
-      card.append(urlHeader);
-      for (const rule of urlResult.rules) {
-        const ruleDiv = this.document.createElement("div");
-        ruleDiv.dataset.testRule = "true";
-        const ruleHeader = this.document.createElement("div");
-        ruleHeader.dataset.testRuleHeader = "true";
-        const ruleName = this.document.createElement("strong");
-        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";
-        ruleBadge.textContent = rule.matched ? "\u2713 MATCHED" : "\u2717 NOT MATCHED";
-        ruleHeader.append(ruleName, ruleBadge);
-        ruleDiv.append(ruleHeader);
-        const dims = [
-          { label: "source", dim: rule.source },
-          { label: "method", dim: rule.method },
-          { label: "resourceType", dim: rule.resourceType }
-        ];
-        for (const { label, dim } of dims) {
-          const dimDiv = this.document.createElement("div");
-          dimDiv.dataset.testDimension = "true";
-          const badge = this.document.createElement("span");
-          badge.dataset.testBadge = "true";
-          badge.dataset.variant = dim.state === "matched" ? "matched" : dim.state === "unmatched" ? "unmatched" : "na";
-          badge.textContent = dim.state.toUpperCase();
-          dimDiv.append(
-            badge,
-            this.document.createTextNode(`${label}: ${dim.detail}`)
-          );
-          ruleDiv.append(dimDiv);
-        }
-        if (rule.actionPreview) {
-          const apDiv = this.document.createElement("div");
-          apDiv.dataset.testActionPreview = "true";
-          apDiv.textContent = `Action preview: ${rule.actionPreview.kind} - ${rule.actionPreview.summary}`;
-          ruleDiv.append(apDiv);
-        }
-        card.append(ruleDiv);
+      const matches = urlResult.rules.filter((rule) => rule.matched);
+      const misses = urlResult.rules.filter((rule) => !rule.matched);
+      card.dataset.matched = matches.length > 0 ? "true" : "false";
+      for (const rule of matches) {
+        card.append(this.renderTestOutcome(urlResult.url, rule));
+      }
+      if (misses.length > 0) {
+        card.append(this.renderTestMisses(misses));
       }
       resultsSection.append(card);
     }
   }
+  testErrorText(err, lines) {
+    if (err.code === "dryrun.batch-limit") {
+      return "Only 256 URLs can be checked at once.";
+    }
+    const entry = err.index === void 0 ? void 0 : lines[err.index];
+    if (err.code === "dryrun.invalid-url" && entry) {
+      return `Line ${entry.line} is not an http(s) URL: ${entry.url}`;
+    }
+    if (entry) {
+      return `Line ${entry.line} could not be checked: ${entry.url}`;
+    }
+    return err.message;
+  }
+  renderTestOutcome(url, rule) {
+    const names = this.testRuleNames(rule.groupId, rule.ruleId);
+    const typeLabel = this.testRuleTypeLabel(rule.groupId, rule.ruleId);
+    const outcome = this.document.createElement("p");
+    outcome.dataset.testOutcome = "true";
+    const lead = this.document.createElement("span");
+    lead.textContent = names.groupKnown ? `${url} matches ${typeLabel} in ${names.groupName} / ` : `${url} matches ${typeLabel} in `;
+    const ruleButton = this.createCommandButton(
+      names.ruleLabel,
+      "test:open-rule",
+      false,
+      { groupId: rule.groupId, ruleId: rule.ruleId }
+    );
+    ruleButton.dataset.testRuleLink = "true";
+    ruleButton.removeAttribute("data-btn");
+    const tailParts = ["."];
+    const preview = previewSentence(rule.actionPreview);
+    if (preview) tailParts.push(` ${preview}`);
+    if (rule.method.state === "not-applicable") {
+      tailParts.push(" The method was not tested.");
+    }
+    if (rule.resourceType.state === "not-applicable") {
+      tailParts.push(" The resource type was not tested.");
+    }
+    if (this.groupIsOffInBrowser(rule.groupId)) {
+      tailParts.push(
+        " This group is off in Chrome, so the browser will not apply this rule."
+      );
+    }
+    const tail = this.document.createElement("span");
+    tail.textContent = tailParts.join("");
+    outcome.append(lead, ruleButton, tail);
+    return outcome;
+  }
+  renderTestMisses(misses) {
+    const details = this.document.createElement("details");
+    details.dataset.testMisses = "true";
+    const summary = this.document.createElement("summary");
+    summary.textContent = misses.length === 1 ? "1 rule did not match" : `${misses.length} rules did not match`;
+    const list = this.document.createElement("ul");
+    for (const rule of misses) {
+      const names = this.testRuleNames(rule.groupId, rule.ruleId);
+      const item = this.document.createElement("li");
+      const ruleButton = this.createCommandButton(
+        names.ruleLabel,
+        "test:open-rule",
+        false,
+        { groupId: rule.groupId, ruleId: rule.ruleId }
+      );
+      ruleButton.dataset.testRuleLink = "true";
+      ruleButton.removeAttribute("data-btn");
+      const reason = this.document.createElement("span");
+      reason.dataset.testMissReason = "true";
+      reason.textContent = missReason(rule);
+      item.append(ruleButton, this.document.createTextNode(" \u2014 "), reason);
+      list.append(item);
+    }
+    details.append(summary, list);
+    return details;
+  }
   /**
    * 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.
+   * of truth for both. A rule that is no longer in the draft falls back to its id.
    */
-  testRuleLabel(groupId, ruleId) {
+  testRuleNames(groupId, ruleId) {
     const group = this.groupById(groupId);
-    if (!group) return `${groupId}/${ruleId}`;
+    if (!group) {
+      return {
+        groupKnown: false,
+        ruleKnown: false,
+        groupName: groupId,
+        ruleLabel: `${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")}`;
+    if (!rule) {
+      return {
+        groupKnown: true,
+        ruleKnown: false,
+        groupName,
+        ruleLabel: ruleId
+      };
+    }
+    return {
+      groupKnown: true,
+      ruleKnown: true,
+      groupName,
+      ruleLabel: displayName(rule.name, "Unnamed rule")
+    };
+  }
+  testRuleTypeLabel(groupId, ruleId) {
+    const rule = this.ruleById(groupId, ruleId);
+    const type = rule && typeof rule.type === "string" ? rule.type : "";
+    return RULE_TYPE_LABELS[type] ?? "the rule";
+  }
+  groupIsOffInBrowser(groupId) {
+    const enablement = this.options.groupEnablement;
+    if (!enablement) return false;
+    const group = this.groupById(groupId);
+    const saved = group ? this.savedGroupId(group) : void 0;
+    const id = saved && saved.length > 0 ? saved : groupId;
+    return enablement.isEnabled(id) !== true;
   }
   navigate(route, groupId) {
     if (route === "project") {
@@ -3732,17 +3947,6 @@ var EditorControllerImpl = class {
       );
     }
     tools.append(this.createCommandButton("Validate", "validate", this.saving));
-    if (this.route.kind === "test") {
-      tools.append(
-        this.createCommandButton(
-          "Run test",
-          "test:run",
-          this.saving || this.testRunning,
-          {},
-          "primary"
-        )
-      );
-    }
     const commit = this.document.createElement("div");
     commit.dataset.actionCluster = "commit";
     commit.append(
@@ -3890,19 +4094,6 @@ var EditorControllerImpl = class {
           this.createGroupActionClusters(groupId, groupName)
         );
       }
-    } else {
-      const run = this.document.createElement("div");
-      run.dataset.actionCluster = "safe";
-      run.append(
-        this.createCommandButton(
-          "Run test",
-          "test:run",
-          this.saving || this.testRunning,
-          {},
-          "primary"
-        )
-      );
-      this.appendDockRow(dock, "Test", run);
     }
     this.appendDockRow(dock, "Project", this.createProjectActionRow());
     this.form.append(dock);
@@ -4055,7 +4246,7 @@ var EditorControllerImpl = class {
     this.form.append(heading);
     const description = this.document.createElement("p");
     description.dataset.testDescription = "true";
-    description.textContent = "Run offline dry-run tests against the current project. Enter test cases (one URL per line) and optional method/resource type defaults. No network requests are made.";
+    description.textContent = "Check whether these URLs match your rules. Nothing is contacted, and nothing is saved.";
     this.form.append(description);
     const panel = this.document.createElement("div");
     panel.dataset.testPanel = "true";
@@ -4072,90 +4263,127 @@ var EditorControllerImpl = class {
     urlsTextarea.placeholder = "https://example.com/page\nhttps://example.com/script.js\nhttps://other.com/";
     urlsTextarea.value = this.testUrls;
     urlsTextarea.dataset.testUrls = "true";
+    urlsTextarea.dataset.editorKey = "test-urls";
     urlsLabel.append(urlsTextarea);
     urlsField.append(urlsLabel);
     urlsFieldset.append(urlsField);
+    const samples = this.renderSampleUrlButtons();
+    if (samples) urlsFieldset.append(samples);
     panel.append(urlsFieldset);
-    const defaultsFieldset = this.document.createElement("fieldset");
-    const defaultsLegend = this.document.createElement("legend");
-    defaultsLegend.textContent = "Defaults (applied to all URLs without explicit values)";
-    defaultsFieldset.append(defaultsLegend);
+    const checking = this.document.createElement("p");
+    checking.dataset.testChecking = "true";
+    checking.textContent = checkingCopy(this.testMethod, this.testResourceType);
+    panel.append(checking);
     const defaultsGrid = this.document.createElement("div");
     defaultsGrid.dataset.testDefaults = "true";
     const methodField = this.document.createElement("div");
     methodField.dataset.editorField = "true";
     const methodLabel = this.document.createElement("label");
-    methodLabel.textContent = "Default HTTP method";
+    methodLabel.textContent = "Method";
     const methodSelect = this.document.createElement("select");
     methodSelect.dataset.testMethod = "true";
+    methodSelect.dataset.editorKey = "test-method";
+    for (const method of HTTP_METHODS2) {
+      const option = this.document.createElement("option");
+      option.value = method;
+      option.textContent = method;
+      methodSelect.append(option);
+    }
+    const methodAny = this.document.createElement("option");
+    methodAny.value = "";
+    methodAny.textContent = "Any method";
+    methodSelect.append(methodAny);
     methodSelect.value = this.testMethod;
-    const methodEmpty = this.document.createElement("option");
-    methodEmpty.value = "";
-    methodEmpty.textContent = "(none \u2014 not-applicable)";
-    methodSelect.append(methodEmpty);
-    for (const m of HTTP_METHODS2) {
-      const opt = this.document.createElement("option");
-      opt.value = m;
-      opt.textContent = m;
-      methodSelect.append(opt);
-    }
     methodLabel.append(methodSelect);
     methodField.append(methodLabel);
     const rtField = this.document.createElement("div");
     rtField.dataset.editorField = "true";
     const rtLabel = this.document.createElement("label");
-    rtLabel.textContent = "Default resource type";
+    rtLabel.textContent = "Resource type";
     const rtSelect = this.document.createElement("select");
     rtSelect.dataset.testResourceType = "true";
+    rtSelect.dataset.editorKey = "test-resource-type";
+    for (const resourceType of RESOURCE_TYPES2) {
+      const option = this.document.createElement("option");
+      option.value = resourceType;
+      option.textContent = RESOURCE_TYPE_LABELS[resourceType];
+      rtSelect.append(option);
+    }
+    const rtAny = this.document.createElement("option");
+    rtAny.value = "";
+    rtAny.textContent = "Any resource type";
+    rtSelect.append(rtAny);
     rtSelect.value = this.testResourceType;
-    const rtEmpty = this.document.createElement("option");
-    rtEmpty.value = "";
-    rtEmpty.textContent = "(none \u2014 not-applicable)";
-    rtSelect.append(rtEmpty);
-    for (const rt of RESOURCE_TYPES2) {
-      const opt = this.document.createElement("option");
-      opt.value = rt;
-      opt.textContent = rt;
-      rtSelect.append(opt);
-    }
     rtLabel.append(rtSelect);
     rtField.append(rtLabel);
     defaultsGrid.append(methodField, rtField);
-    defaultsFieldset.append(defaultsGrid);
-    panel.append(defaultsFieldset);
-    const maxCasesField = this.document.createElement("div");
-    maxCasesField.dataset.editorField = "true";
-    const maxCasesLabel = this.document.createElement("label");
-    maxCasesLabel.textContent = "Max test cases";
-    const maxCasesInput = this.document.createElement("input");
-    maxCasesInput.type = "number";
-    maxCasesInput.min = "1";
-    maxCasesInput.max = "10000";
-    maxCasesInput.value = this.testMaxCases;
-    maxCasesInput.style.width = "8rem";
-    maxCasesInput.dataset.testMaxCases = "true";
-    maxCasesLabel.append(maxCasesInput);
-    maxCasesField.append(maxCasesLabel);
-    panel.append(maxCasesField);
-    const runBtn = this.createButton("Run test", "test:run");
-    runBtn.type = "button";
+    panel.append(defaultsGrid);
+    const runBtn = this.createCommandButton(
+      "Run test",
+      "test:run",
+      this.saving || this.testRunning,
+      {},
+      "primary"
+    );
     runBtn.dataset.testRun = "true";
-    runBtn.dataset.command = "test:run";
-    runBtn.dataset.btn = "primary";
-    runBtn.disabled = this.saving || this.testRunning;
     panel.append(runBtn);
     this.form.append(panel);
     const resultsSection = this.document.createElement("section");
     resultsSection.dataset.testResults = "true";
     this.form.append(resultsSection);
-    if (this.testResult) {
+    if (this.ruleCount() === 0) {
+      const empty = this.document.createElement("p");
+      empty.dataset.testEmpty = "true";
+      empty.textContent = "This project has no rules to test.";
+      resultsSection.append(empty);
+    } else if (this.testResult) {
       this.renderTestResults(this.testResult);
     } else if (this.testRunning) {
       const pending = this.document.createElement("p");
       pending.dataset.testPending = "true";
-      pending.textContent = "Running dry-run...";
+      pending.textContent = "Checking URLs...";
       resultsSection.append(pending);
+    } else if (this.statusMessage === "Only 256 URLs can be checked at once.") {
+      const limit = this.document.createElement("p");
+      limit.dataset.testLimit = "true";
+      limit.textContent = this.statusMessage;
+      resultsSection.append(limit);
+    }
+  }
+  renderSampleUrlButtons() {
+    const samples = [];
+    for (const group of this.draft.groups) {
+      const groupId = safeText(group.id);
+      for (const rule of group.rules) {
+        const url = exactUrlFromSource(rule.source);
+        if (!url) continue;
+        samples.push({
+          groupId,
+          ruleId: safeText(rule.id),
+          url,
+          name: displayName(rule.name, "Unnamed rule")
+        });
+      }
+    }
+    if (samples.length === 0) return void 0;
+    const row = this.document.createElement("div");
+    row.dataset.testSamples = "true";
+    for (const sample of samples) {
+      const button = this.createCommandButton(
+        "Try a URL from this rule",
+        "test:try-url",
+        false,
+        { groupId: sample.groupId, ruleId: sample.ruleId, url: sample.url }
+      );
+      if (samples.length > 1) {
+        button.setAttribute(
+          "aria-label",
+          `Try a URL from this rule, ${sample.name}`
+        );
+      }
+      row.append(button);
     }
+    return row;
   }
   renderRule(group, rule, groupIndex, ruleIndex) {
     const groupId = safeText(group.id);

package/dist/node/index.js

@@ -26335,14 +26335,14 @@ function normalizeOptions(raw) {
     }
     maxCases = maxCasesProperty.value;
   }
-  let previewAction2;
+  let previewAction;
   if (previewProperty.present) {
     if (previewProperty.value !== void 0 && typeof previewProperty.value !== "function") {
       return { ok: false };
     }
-    previewAction2 = previewProperty.value;
+    previewAction = previewProperty.value;
   }
-  return { ok: true, maxCases, previewAction: previewAction2 };
+  return { ok: true, maxCases, previewAction };
 }
 function dryRunProject(operations, cases, options) {
   const normalizedOptions = normalizeOptions(options);
@@ -26470,6 +26470,55 @@ function dryRunProject(operations, cases, options) {
     }
   };
 }
+function captureSubject(matcher, url) {
+  if (matcher.source.key === "url") return url;
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return null;
+  }
+}
+function previewRuleAction(operation, url) {
+  const subject = captureSubject(operation.matcher, url);
+  if (subject === null) return null;
+  const captures = matchUrlCaptures(operation.matcher.source.value, subject);
+  if (captures === null) return null;
+  const expand = (value) => substituteUrlCaptures(value, captures);
+  if (operation.kind === "redirect") {
+    return {
+      kind: "redirect",
+      summary: expand(operation.redirect.destination)
+    };
+  }
+  if (operation.kind === "query") {
+    const values = operation.action.params.map(
+      (param) => param.operation === "remove" ? `${param.name}=<removed>` : `${param.name}=${expand(param.value ?? "")}`
+    ).join(", ");
+    return { kind: "query", summary: values };
+  }
+  if (operation.kind === "header") {
+    if (operation.header.operation === "remove") {
+      return { kind: "header", summary: `${operation.header.name}=<removed>` };
+    }
+    return {
+      kind: "header",
+      summary: `${operation.header.name}=${expand(operation.header.value ?? "")}`
+    };
+  }
+  if (operation.kind === "request-body" && operation.requestBody.mode === "replace") {
+    return {
+      kind: operation.kind,
+      summary: expand(operation.requestBody.body)
+    };
+  }
+  if (operation.kind === "response-body" && "mode" in operation.responseBody && operation.responseBody.mode === "replace") {
+    return {
+      kind: operation.kind,
+      summary: expand(operation.responseBody.body)
+    };
+  }
+  return null;
+}
 
 // packages/cli/src/server/routes.ts
 function generateCsrfToken() {
@@ -26540,18 +26589,6 @@ function bodyErrorResponse(error) {
     body: { code: "invalid-json", message: "Invalid JSON body" }
   };
 }
-function toMatcherOperations(operations) {
-  return operations.map(
-    ({ groupId, ruleId, name, matcher, redactSensitiveInLogs }) => ({
-      kind: "matcher",
-      groupId,
-      ruleId,
-      name,
-      matcher,
-      redactSensitiveInLogs
-    })
-  );
-}
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -26864,10 +26901,13 @@ function createRoutes(context) {
         );
         return;
       }
+      const requested = isRecord2(body.options) && typeof body.options.maxCases === "number" && Number.isSafeInteger(body.options.maxCases) && body.options.maxCases > 0 ? body.options.maxCases : void 0;
+      const options = { previewAction: previewRuleAction };
+      if (requested !== void 0) options.maxCases = requested;
       const result = dryRunProject(
-        toMatcherOperations(compileResult.operations),
+        compileResult.operations,
         body.cases,
-        body.options ?? {}
+        options
       );
       res.writeHead(200, { "Content-Type": "application/json" });
       res.end(JSON.stringify(result));
@@ -27872,7 +27912,41 @@ function generateEditorHtml(apiBase, csrfToken, filePath, aiConfigured) {
             },
             body: JSON.stringify({ project: currentProject, cases, options }),
           });
-          return res.json();
+          let payload = null;
+          try {
+            payload = await res.json();
+          } catch (error) {
+            payload = null;
+          }
+          if (!res.ok) {
+            const diagnostics = payload && Array.isArray(payload.diagnostics)
+              ? payload.diagnostics.map(function (diagnostic) {
+                  return {
+                    code: diagnostic && typeof diagnostic.code === 'string'
+                      ? diagnostic.code
+                      : 'editor.validation-failed',
+                    severity: 'error',
+                    path: diagnostic && typeof diagnostic.path === 'string'
+                      ? diagnostic.path
+                      : '',
+                    message: diagnostic && typeof diagnostic.message === 'string'
+                      ? diagnostic.message
+                      : 'The project could not be tested.',
+                  };
+                })
+              : [{
+                  code: payload && typeof payload.code === 'string'
+                    ? payload.code
+                    : 'editor.validation-failed',
+                  severity: 'error',
+                  path: '',
+                  message: payload && typeof payload.message === 'string'
+                    ? payload.message
+                    : 'The project could not be tested.',
+                }];
+            return { ok: false, diagnostics: diagnostics };
+          }
+          return payload;
         },
         onCancel: () => {
           cancel();
@@ -29947,7 +30021,7 @@ function errorMessage(error) {
 // packages/cli/src/commands/runtime.ts
 import { chmod, mkdir as mkdir4, rm as rm2, writeFile as writeFile4 } from "node:fs/promises";
 import { dirname as dirname7, join as join7, resolve as resolve6 } from "node:path";
-function toMatcherOperations2(operations) {
+function toMatcherOperations(operations) {
   return operations.map(
     ({ groupId, ruleId, name, matcher, redactSensitiveInLogs }) => ({
       kind: "matcher",
@@ -30239,7 +30313,7 @@ async function runtimeHostCommand(args, options = {}) {
   const normalized = normalizeRuntimePreset({
     version: 1,
     limits: RUNTIME_LIMITS,
-    matchers: toMatcherOperations2(compileResult.operations),
+    matchers: toMatcherOperations(compileResult.operations),
     grants: []
   });
   if (!normalized.ok) {
@@ -30284,55 +30358,6 @@ function usageError(message) {
   return `Error: ${message}
 `;
 }
-function captureSubject(matcher, url) {
-  if (matcher.source.key === "url") return url;
-  try {
-    return new URL(url).hostname;
-  } catch {
-    return null;
-  }
-}
-function previewAction(operation, url) {
-  const subject = captureSubject(operation.matcher, url);
-  if (subject === null) return null;
-  const captures = matchUrlCaptures(operation.matcher.source.value, subject);
-  if (captures === null) return null;
-  const expand = (value) => substituteUrlCaptures(value, captures);
-  if (operation.kind === "redirect") {
-    return {
-      kind: "redirect",
-      summary: expand(operation.redirect.destination)
-    };
-  }
-  if (operation.kind === "query") {
-    const values = operation.action.params.map(
-      (param) => param.operation === "remove" ? `${param.name}=<removed>` : `${param.name}=${expand(param.value ?? "")}`
-    ).join(", ");
-    return { kind: "query", summary: values };
-  }
-  if (operation.kind === "header") {
-    if (operation.header.operation === "remove") {
-      return { kind: "header", summary: `${operation.header.name}=<removed>` };
-    }
-    return {
-      kind: "header",
-      summary: `${operation.header.name}=${expand(operation.header.value ?? "")}`
-    };
-  }
-  if (operation.kind === "request-body" && operation.requestBody.mode === "replace") {
-    return {
-      kind: operation.kind,
-      summary: expand(operation.requestBody.body)
-    };
-  }
-  if (operation.kind === "response-body" && "mode" in operation.responseBody && operation.responseBody.mode === "replace") {
-    return {
-      kind: operation.kind,
-      summary: expand(operation.responseBody.body)
-    };
-  }
-  return null;
-}
 function isUrl(value) {
   return parseTestUrl(value).ok;
 }
@@ -30387,7 +30412,7 @@ function addDefaults(cases, defaultMethod, defaultResourceType) {
   );
 }
 function resultOptions(maxCases) {
-  const options = { previewAction };
+  const options = { previewAction: previewRuleAction };
   if (maxCases !== void 0) options.maxCases = maxCases;
   return options;
 }

package/package.json

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