@rogatio/cli 1.9.0 → 2.0.0

package/dist/editor/index.js

@@ -0,0 +1,3822 @@
+// packages/schema/dist/browser/index.js
+var LIMITS = Object.freeze({
+  maxGroups: 64,
+  maxRulesPerGroup: 256,
+  maxRulesPerProject: 4096,
+  maxOriginsPerScope: 32,
+  maxIdLength: 64,
+  maxLabelLength: 100,
+  maxDescriptionLength: 1e3,
+  maxUrlRegexLength: 2048,
+  maxResourceTypesPerRule: 16,
+  minPriority: 1,
+  maxPriority: 1e3,
+  maxRedirectDestinationLength: 2048,
+  maxCaptureGroups: 9,
+  maxQueryParamsPerRule: 64,
+  maxQueryNameLength: 256,
+  maxQueryValueLength: 2048,
+  maxHeaderNameLength: 256,
+  maxHeaderValueLength: 4096,
+  minMockStatus: 200,
+  maxMockStatus: 599,
+  maxMockHeadersPerRule: 32,
+  maxMockHeaderNameLength: 256,
+  maxMockHeaderValueLength: 4096,
+  maxMockInlineBodyLength: 65536,
+  maxMockDelayMs: 3e4,
+  maxMockFilePathLength: 2048,
+  maxResponseBodyReplacements: 64,
+  maxResponseBodyPatternLength: 2048,
+  maxResponseBodyReplacementLength: 4096,
+  maxRequestBodyBytes: 4 * 1024 * 1024,
+  maxRequestBodyPatternLength: 2048,
+  maxRequestBodyReplacementLength: 4096,
+  maxRequestBodyOperations: 32,
+  maxLocalOrigins: 32
+});
+function countCapturingGroups(urlRegex) {
+  let count = 0;
+  let index = 0;
+  const length = urlRegex.length;
+  while (index < length) {
+    const char = urlRegex[index];
+    if (char === "\\") {
+      index += 2;
+      continue;
+    }
+    if (char === "(") {
+      if (urlRegex[index + 1] === "?") {
+        index = skipBalancedGroup(urlRegex, index);
+        continue;
+      }
+      count += 1;
+    }
+    index += 1;
+  }
+  return count;
+}
+function skipBalancedGroup(source, start) {
+  let depth = 0;
+  let index = start;
+  const length = source.length;
+  while (index < length) {
+    const char = source[index];
+    if (char === "\\") {
+      index += 2;
+      continue;
+    }
+    if (char === "(") {
+      depth += 1;
+    } else if (char === ")") {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+    index += 1;
+  }
+  return length;
+}
+function validateRedirectDestination(destination, urlRegex) {
+  const issues = [];
+  if (typeof destination !== "string" || destination.length === 0) {
+    issues.push({
+      code: "schema.required",
+      message: "Redirect destination must be a non-empty string."
+    });
+    return issues;
+  }
+  if (destination.length > LIMITS.maxRedirectDestinationLength) {
+    issues.push({
+      code: "schema.out-of-range",
+      message: `Redirect destination must be at most ${LIMITS.maxRedirectDestinationLength} characters.`
+    });
+    return issues;
+  }
+  let url;
+  try {
+    url = new URL(destination);
+  } catch {
+    issues.push({
+      code: "schema.invalid-format",
+      message: "Redirect destination must be an absolute URL."
+    });
+    return issues;
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    issues.push({
+      code: "schema.invalid-value",
+      message: "Redirect destination must use the http or https scheme."
+    });
+    return issues;
+  }
+  if (url.username.length > 0 || url.password.length > 0) {
+    issues.push({
+      code: "schema.invalid-value",
+      message: "Redirect destination must not contain credentials."
+    });
+    return issues;
+  }
+  if (url.hostname.length === 0 || url.hostname.includes("*")) {
+    issues.push({
+      code: "schema.invalid-format",
+      message: "Redirect destination must have a valid host."
+    });
+    return issues;
+  }
+  const groups = countCapturingGroups(urlRegex);
+  const backreference = /\\([1-9])/g;
+  let match = backreference.exec(destination);
+  while (match !== null) {
+    const referenced = Number(match[1]);
+    if (referenced > groups) {
+      issues.push({
+        code: "schema.invalid-value",
+        message: `Redirect destination references capture group ${referenced} but the URL pattern defines ${groups}.`
+      });
+    }
+    match = backreference.exec(destination);
+  }
+  return issues;
+}
+function hasControl(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code <= 31 || code === 127) return true;
+  }
+  return false;
+}
+var FORBIDDEN_REQUEST_HEADERS = Object.freeze([
+  "accept-charset",
+  "accept-encoding",
+  "access-control-request-headers",
+  "access-control-request-method",
+  "connection",
+  "content-length",
+  "cookie",
+  "cookie2",
+  "date",
+  "dnt",
+  "expect",
+  "host",
+  "keep-alive",
+  "origin",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade",
+  "via"
+]);
+var FORBIDDEN_RESPONSE_HEADERS = Object.freeze([
+  "connection",
+  "content-encoding",
+  "content-length",
+  "date",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "set-cookie",
+  "set-cookie2",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade",
+  "via"
+]);
+var FORBIDDEN_REQUEST_PREFIXES = Object.freeze(["proxy-", "sec-"]);
+var RESOURCE_TYPES = Object.freeze([
+  "main_frame",
+  "sub_frame",
+  "stylesheet",
+  "script",
+  "image",
+  "font",
+  "object",
+  "media",
+  "xmlhttprequest",
+  "ping",
+  "csp_report",
+  "websocket",
+  "webtransport",
+  "webbundle",
+  "other"
+]);
+var HTTP_METHODS = Object.freeze([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS",
+  "CONNECT",
+  "TRACE"
+]);
+
+// packages/editor/src/rule-types/mock.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asMockAction(value) {
+  if (!isRecord(value) || typeof value.status !== "number") return void 0;
+  const action = value;
+  if (action.headers !== void 0 && !Array.isArray(action.headers)) {
+    return void 0;
+  }
+  return action;
+}
+function stable(diagnostics) {
+  return [...diagnostics].sort(
+    (a, b) => a.path === b.path ? a.code.localeCompare(b.code) : a.path.localeCompare(b.path)
+  );
+}
+function hasControlOrColon(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code <= 31 || code === 127 || code === 58) return true;
+  }
+  return false;
+}
+function createMockRuleType() {
+  return {
+    id: "mock",
+    label: "Mock response",
+    actionField: "mock",
+    matches(rule) {
+      const type = rule.type;
+      if (type === "mock") return true;
+      if (type !== void 0) return false;
+      return asMockAction(rule.mock) !== void 0;
+    },
+    validate(rule, rulePath) {
+      const mock = asMockAction(rule.mock);
+      if (mock === void 0) return [];
+      const diagnostics = [];
+      const status = mock.status;
+      if (!Number.isInteger(status) || status < LIMITS.minMockStatus || status > LIMITS.maxMockStatus) {
+        diagnostics.push({
+          code: "editor.mock-status-range",
+          severity: "error",
+          path: `${rulePath}/mock/status`,
+          message: `Mock status must be an integer between ${LIMITS.minMockStatus} and ${LIMITS.maxMockStatus}.`
+        });
+      }
+      const hasBody = typeof mock.body === "string";
+      const hasFile = typeof mock.file === "string";
+      if (hasBody === hasFile) {
+        diagnostics.push({
+          code: "editor.mock-body-source",
+          severity: "error",
+          path: `${rulePath}/mock`,
+          message: "A mock rule must set exactly one of body or file."
+        });
+      } else if (hasBody) {
+        const body = mock.body;
+        if (body.length > LIMITS.maxMockInlineBodyLength) {
+          diagnostics.push({
+            code: "editor.mock-body-too-long",
+            severity: "error",
+            path: `${rulePath}/mock/body`,
+            message: `Mock inline body must be at most ${LIMITS.maxMockInlineBodyLength} characters.`
+          });
+        }
+      } else if (hasFile) {
+        const file = mock.file;
+        if (file.length === 0 || file.length > LIMITS.maxMockFilePathLength) {
+          diagnostics.push({
+            code: "editor.mock-file-path",
+            severity: "error",
+            path: `${rulePath}/mock/file`,
+            message: `Mock file path must be 1-${LIMITS.maxMockFilePathLength} characters.`
+          });
+        }
+      }
+      if (mock.delayMs !== void 0 && (!Number.isInteger(mock.delayMs) || mock.delayMs < 0 || mock.delayMs > LIMITS.maxMockDelayMs)) {
+        diagnostics.push({
+          code: "editor.mock-delay-range",
+          severity: "error",
+          path: `${rulePath}/mock/delayMs`,
+          message: `Mock delay must be an integer between 0 and ${LIMITS.maxMockDelayMs} milliseconds.`
+        });
+      }
+      if (mock.headers !== void 0) {
+        if (mock.headers.length > LIMITS.maxMockHeadersPerRule) {
+          diagnostics.push({
+            code: "editor.mock-too-many-headers",
+            severity: "error",
+            path: `${rulePath}/mock/headers`,
+            message: `A mock rule may define at most ${LIMITS.maxMockHeadersPerRule} headers.`
+          });
+        }
+        mock.headers.forEach((header, index) => {
+          const namePath = `${rulePath}/mock/headers/${index}/name`;
+          const valuePath = `${rulePath}/mock/headers/${index}/value`;
+          if (typeof header?.name !== "string" || header.name.length === 0 || header.name.length > LIMITS.maxMockHeaderNameLength) {
+            diagnostics.push({
+              code: "editor.mock-header-name",
+              severity: "error",
+              path: namePath,
+              message: `Mock header name must be 1-${LIMITS.maxMockHeaderNameLength} characters.`
+            });
+          } else if (hasControlOrColon(header.name)) {
+            diagnostics.push({
+              code: "editor.mock-header-name",
+              severity: "error",
+              path: namePath,
+              message: "Mock header name must not contain control characters or a colon."
+            });
+          }
+          if (typeof header?.value !== "string" || header.value.length > LIMITS.maxMockHeaderValueLength) {
+            diagnostics.push({
+              code: "editor.mock-header-value",
+              severity: "error",
+              path: valuePath,
+              message: `Mock header value must be at most ${LIMITS.maxMockHeaderValueLength} characters.`
+            });
+          }
+        });
+      }
+      return stable(diagnostics);
+    },
+    mount(context) {
+      const { document, container } = context;
+      const getCurrent = () => asMockAction(context.getField("mock"));
+      const setAction = (next) => {
+        context.setField("mock", next);
+      };
+      const render = () => {
+        const current = getCurrent();
+        container.replaceChildren();
+        if (current === void 0) return;
+        const statusLabel = document.createElement("label");
+        statusLabel.textContent = "Status";
+        const statusInput = document.createElement("input");
+        statusInput.type = "number";
+        statusInput.min = String(LIMITS.minMockStatus);
+        statusInput.max = String(LIMITS.maxMockStatus);
+        statusInput.step = "1";
+        statusInput.value = String(current.status);
+        statusInput.dataset.editorField = "true";
+        statusInput.addEventListener("input", () => {
+          const c = getCurrent();
+          if (c === void 0) return;
+          setAction({ ...c, status: Number(statusInput.value) });
+        });
+        context.registerControl("/mock/status", statusInput);
+        statusLabel.append(statusInput);
+        const delayLabel = document.createElement("label");
+        delayLabel.textContent = "Delay (ms)";
+        const delayInput = document.createElement("input");
+        delayInput.type = "number";
+        delayInput.min = "0";
+        delayInput.max = String(LIMITS.maxMockDelayMs);
+        delayInput.step = "1";
+        delayInput.value = current.delayMs === void 0 ? "" : String(current.delayMs);
+        delayInput.dataset.editorField = "true";
+        delayInput.addEventListener("input", () => {
+          const c = getCurrent();
+          if (c === void 0) return;
+          const raw = delayInput.value;
+          const next = raw === "" ? { ...c, delayMs: void 0 } : { ...c, delayMs: Number(raw) };
+          setAction(next);
+        });
+        context.registerControl("/mock/delayMs", delayInput);
+        delayLabel.append(delayInput);
+        const sourceLabel = document.createElement("label");
+        sourceLabel.textContent = "Body source";
+        const sourceSelect = document.createElement("select");
+        sourceSelect.dataset.editorField = "true";
+        const bodyOption = document.createElement("option");
+        bodyOption.value = "body";
+        bodyOption.textContent = "Inline body";
+        const fileOption = document.createElement("option");
+        fileOption.value = "file";
+        fileOption.textContent = "File snapshot";
+        sourceSelect.append(bodyOption, fileOption);
+        sourceSelect.value = typeof current.file === "string" ? "file" : "body";
+        context.registerControl("/mock/body-source", sourceSelect);
+        const bodyArea = document.createElement("textarea");
+        bodyArea.value = typeof current.body === "string" ? current.body : "";
+        bodyArea.dataset.editorField = "true";
+        bodyArea.addEventListener("input", () => {
+          const c = getCurrent();
+          if (c === void 0) return;
+          setAction({ ...c, body: bodyArea.value, file: void 0 });
+        });
+        context.registerControl("/mock/body", bodyArea);
+        const fileLabel = document.createElement("label");
+        fileLabel.textContent = "File path";
+        const fileInput = document.createElement("input");
+        fileInput.type = "text";
+        fileInput.value = typeof current.file === "string" ? current.file : "";
+        fileInput.dataset.editorField = "true";
+        fileInput.addEventListener("input", () => {
+          const c = getCurrent();
+          if (c === void 0) return;
+          setAction({ ...c, body: void 0, file: fileInput.value });
+        });
+        context.registerControl("/mock/file", fileInput);
+        fileLabel.append(fileInput);
+        const syncSource = () => {
+          const useFile = sourceSelect.value === "file";
+          bodyArea.style.display = useFile ? "none" : "";
+          fileLabel.style.display = useFile ? "" : "none";
+        };
+        sourceSelect.addEventListener("change", syncSource);
+        syncSource();
+        const headersFieldset = document.createElement("fieldset");
+        const headersLegend = document.createElement("legend");
+        headersLegend.textContent = "Response headers";
+        headersFieldset.append(headersLegend);
+        const renderHeaders = () => {
+          const c = getCurrent();
+          if (c === void 0) return;
+          headersFieldset.querySelectorAll("[data-mock-header-row]").forEach((row) => {
+            row.remove();
+          });
+          const headers = c.headers ?? [];
+          headers.forEach((header, index) => {
+            const row = document.createElement("div");
+            row.dataset.mockHeaderRow = String(index);
+            const nameLabel = document.createElement("label");
+            nameLabel.textContent = "Name";
+            const nameInput = document.createElement("input");
+            nameInput.type = "text";
+            nameInput.value = header.name;
+            nameInput.dataset.editorField = "true";
+            nameInput.addEventListener("input", () => {
+              const cc = getCurrent();
+              if (cc === void 0) return;
+              const next = (cc.headers ?? []).map(
+                (h, i) => i === index ? { ...h, name: nameInput.value } : h
+              );
+              setAction({ ...cc, headers: next });
+            });
+            context.registerControl(`/mock/headers/${index}/name`, nameInput);
+            nameLabel.append(nameInput);
+            const valueLabel = document.createElement("label");
+            valueLabel.textContent = "Value";
+            const valueInput = document.createElement("input");
+            valueInput.type = "text";
+            valueInput.value = header.value;
+            valueInput.dataset.editorField = "true";
+            valueInput.addEventListener("input", () => {
+              const cc = getCurrent();
+              if (cc === void 0) return;
+              const next = (cc.headers ?? []).map(
+                (h, i) => i === index ? { ...h, value: valueInput.value } : h
+              );
+              setAction({ ...cc, headers: next });
+            });
+            context.registerControl(`/mock/headers/${index}/value`, valueInput);
+            valueLabel.append(valueInput);
+            const remove = document.createElement("button");
+            remove.type = "button";
+            remove.textContent = "Remove";
+            remove.dataset.editorField = "true";
+            remove.addEventListener("click", () => {
+              const cc = getCurrent();
+              if (cc === void 0) return;
+              const next = (cc.headers ?? []).filter((_, i) => i !== index);
+              setAction({ ...cc, headers: next });
+            });
+            row.append(nameLabel, valueLabel, remove);
+            headersFieldset.append(row);
+          });
+          const add = document.createElement("button");
+          add.type = "button";
+          add.textContent = "Add header";
+          add.dataset.editorField = "true";
+          add.dataset.mockAddHeader = "true";
+          add.addEventListener("click", () => {
+            const cc = getCurrent();
+            if (cc === void 0) return;
+            setAction({
+              ...cc,
+              headers: [...cc.headers ?? [], { name: "", value: "" }]
+            });
+          });
+          headersFieldset.append(add);
+        };
+        renderHeaders();
+        container.append(
+          statusLabel,
+          delayLabel,
+          sourceLabel,
+          bodyArea,
+          fileLabel,
+          headersFieldset
+        );
+      };
+      render();
+      return { destroy() {
+      } };
+    },
+    defaultAction() {
+      return { status: 200, body: "" };
+    }
+  };
+}
+
+// packages/editor/src/rule-types/query.ts
+var MAX_QUERY_NAME_LENGTH = 256;
+var MAX_QUERY_VALUE_LENGTH = 2048;
+var MAX_QUERY_PARAMS = 64;
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asQueryAction(value) {
+  if (!isRecord2(value)) return void 0;
+  if (value.type !== "query") return void 0;
+  const params = value.params;
+  if (!Array.isArray(params)) return void 0;
+  return value;
+}
+function stable2(diagnostics) {
+  return [...diagnostics].sort(
+    (a, b) => a.path === b.path ? a.code.localeCompare(b.code) : a.path.localeCompare(b.path)
+  );
+}
+var queryRuleType = {
+  id: "query",
+  label: "Query parameters",
+  matches(rule) {
+    return asQueryAction(rule.action) !== void 0;
+  },
+  validate(rule, rulePath) {
+    const action = asQueryAction(rule.action);
+    if (action === void 0) return [];
+    const diagnostics = [];
+    if (!Array.isArray(action.params) || action.params.length === 0) {
+      diagnostics.push({
+        code: "editor.query-params-required",
+        severity: "error",
+        path: `${rulePath}/action/params`,
+        message: "Query rules need at least one parameter."
+      });
+      return stable2(diagnostics);
+    }
+    if (action.params.length > MAX_QUERY_PARAMS) {
+      diagnostics.push({
+        code: "editor.query-too-many-params",
+        severity: "error",
+        path: `${rulePath}/action/params`,
+        message: `A query rule may define at most ${MAX_QUERY_PARAMS} parameters.`
+      });
+    }
+    const seen = /* @__PURE__ */ new Set();
+    action.params.forEach((param, index) => {
+      const namePath = `${rulePath}/action/params/${index}/name`;
+      const valuePath = `${rulePath}/action/params/${index}/value`;
+      if (typeof param?.name !== "string" || param.name.length === 0) {
+        diagnostics.push({
+          code: "editor.query-param-name-required",
+          severity: "error",
+          path: namePath,
+          message: "Query parameter name is required."
+        });
+      } else if (param.name.length > MAX_QUERY_NAME_LENGTH) {
+        diagnostics.push({
+          code: "editor.query-param-name-too-long",
+          severity: "error",
+          path: namePath,
+          message: "Query parameter name is too long."
+        });
+      }
+      if (typeof param?.value !== "string" || param.value.length === 0) {
+        diagnostics.push({
+          code: "editor.query-param-value-required",
+          severity: "error",
+          path: valuePath,
+          message: "Query parameter value is required."
+        });
+      } else if (param.value.length > MAX_QUERY_VALUE_LENGTH) {
+        diagnostics.push({
+          code: "editor.query-param-value-too-long",
+          severity: "error",
+          path: valuePath,
+          message: "Query parameter value is too long."
+        });
+      }
+      if (typeof param?.name === "string" && seen.has(param.name)) {
+        diagnostics.push({
+          code: "editor.query-duplicate-param",
+          severity: "error",
+          path: namePath,
+          message: "Query parameter names must be unique within a rule."
+        });
+      }
+      if (typeof param?.name === "string") seen.add(param.name);
+    });
+    return stable2(diagnostics);
+  },
+  mount(context) {
+    const { document, container } = context;
+    const getCurrent = () => asQueryAction(context.getField("action"));
+    const setAction = (next) => {
+      context.setField("action", next);
+    };
+    const render = () => {
+      const current = getCurrent();
+      container.replaceChildren();
+      if (current === void 0) return;
+      current.params.forEach((param, index) => {
+        const row = document.createElement("div");
+        row.dataset.queryParamRow = String(index);
+        const nameLabel = document.createElement("label");
+        nameLabel.textContent = "Name";
+        const nameInput = document.createElement("input");
+        nameInput.type = "text";
+        nameInput.value = param.name;
+        nameInput.dataset.editorField = "true";
+        nameInput.addEventListener("input", () => {
+          const c = getCurrent();
+          if (c === void 0) return;
+          const params = c.params.map(
+            (p, i) => i === index ? { ...p, name: nameInput.value } : p
+          );
+          setAction({ type: "query", params });
+        });
+        context.registerControl(`/action/params/${index}/name`, nameInput);
+        nameLabel.append(nameInput);
+        const valueLabel = document.createElement("label");
+        valueLabel.textContent = "Value";
+        const valueInput = document.createElement("input");
+        valueInput.type = "text";
+        valueInput.value = param.value;
+        valueInput.dataset.editorField = "true";
+        valueInput.addEventListener("input", () => {
+          const c = getCurrent();
+          if (c === void 0) return;
+          const params = c.params.map(
+            (p, i) => i === index ? { ...p, value: valueInput.value } : p
+          );
+          setAction({ type: "query", params });
+        });
+        context.registerControl(`/action/params/${index}/value`, valueInput);
+        valueLabel.append(valueInput);
+        const remove = document.createElement("button");
+        remove.type = "button";
+        remove.textContent = "Remove";
+        remove.dataset.editorField = "true";
+        remove.addEventListener("click", () => {
+          const c = getCurrent();
+          if (c === void 0) return;
+          const params = c.params.filter((_, i) => i !== index);
+          setAction({ type: "query", params });
+        });
+        row.append(nameLabel, valueLabel, remove);
+        container.append(row);
+      });
+      const add = document.createElement("button");
+      add.type = "button";
+      add.textContent = "Add parameter";
+      add.dataset.editorField = "true";
+      add.addEventListener("click", () => {
+        const c = getCurrent();
+        if (c === void 0) return;
+        setAction({
+          type: "query",
+          params: [...c.params, { name: "", value: "" }]
+        });
+      });
+      container.append(add);
+    };
+    render();
+    return { destroy() {
+    } };
+  },
+  defaultAction() {
+    return { type: "query", params: [{ name: "", value: "" }] };
+  }
+};
+
+// packages/editor/src/rule-types/request-body.ts
+function isRecord3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function requestBodyOf(value) {
+  if (!isRecord3(value) || !("mode" in value)) return void 0;
+  return value;
+}
+function hasLoneSurrogate(value) {
+  for (let i = 0; i < value.length; i += 1) {
+    const code = value.charCodeAt(i);
+    if (code >= 55296 && code <= 56319) {
+      if (i + 1 >= value.length) return true;
+      const next = value.charCodeAt(i + 1);
+      if (next < 56320 || next > 57343) return true;
+    } else if (code >= 56320 && code <= 57343) {
+      if (i === 0) return true;
+      const prev = value.charCodeAt(i - 1);
+      if (prev < 55296 || prev > 56319) return true;
+    }
+  }
+  return false;
+}
+function stable3(values) {
+  return [...values].sort(
+    (left, right) => left.path.localeCompare(right.path) || left.code.localeCompare(right.code)
+  );
+}
+function createRequestBodyRuleType() {
+  return {
+    id: "request-body",
+    label: "Request body",
+    actionField: "requestBody",
+    matches(rule) {
+      return rule.type === "request-body" || requestBodyOf(rule.requestBody) !== void 0;
+    },
+    validate(rule, rulePath) {
+      const action = requestBodyOf(rule.requestBody);
+      if (action === void 0) return [];
+      const diagnostics = [];
+      if (action.mode !== "replace" && action.mode !== "regex") {
+        diagnostics.push({
+          code: "editor.request-body-mode",
+          severity: "error",
+          path: `${rulePath}/requestBody/mode`,
+          message: 'requestBody.mode must be "replace" or "regex"'
+        });
+      }
+      if (action.mode === "replace") {
+        if (typeof action.body !== "string") {
+          diagnostics.push({
+            code: "editor.request-body-replace-body",
+            severity: "error",
+            path: `${rulePath}/requestBody/body`,
+            message: "Replace mode requires a body string."
+          });
+        } else if (action.body.length > LIMITS.maxRequestBodyBytes) {
+          diagnostics.push({
+            code: "editor.request-body-replace-body",
+            severity: "error",
+            path: `${rulePath}/requestBody/body`,
+            message: `Replace body exceeds the maximum size of ${LIMITS.maxRequestBodyBytes} bytes.`
+          });
+        } else if (hasLoneSurrogate(action.body)) {
+          diagnostics.push({
+            code: "editor.request-body-lone-surrogate",
+            severity: "error",
+            path: `${rulePath}/requestBody/body`,
+            message: "Replace body must not contain lone UTF-16 surrogates."
+          });
+        }
+      }
+      if (action.mode === "regex") {
+        if (typeof action.pattern !== "string" || action.pattern.length === 0) {
+          diagnostics.push({
+            code: "editor.request-body-pattern",
+            severity: "error",
+            path: `${rulePath}/requestBody/pattern`,
+            message: "Regex mode requires a non-empty pattern string."
+          });
+        } else if (action.pattern.length > LIMITS.maxRequestBodyPatternLength) {
+          diagnostics.push({
+            code: "editor.request-body-pattern",
+            severity: "error",
+            path: `${rulePath}/requestBody/pattern`,
+            message: `Regex pattern exceeds the maximum length of ${LIMITS.maxRequestBodyPatternLength} characters.`
+          });
+        } else if (hasLoneSurrogate(action.pattern)) {
+          diagnostics.push({
+            code: "editor.request-body-lone-surrogate",
+            severity: "error",
+            path: `${rulePath}/requestBody/pattern`,
+            message: "Regex pattern must not contain lone UTF-16 surrogates."
+          });
+        } else {
+          try {
+            new RegExp(action.pattern, "u");
+          } catch {
+            diagnostics.push({
+              code: "editor.request-body-pattern",
+              severity: "error",
+              path: `${rulePath}/requestBody/pattern`,
+              message: "Regex pattern must be a valid regular expression."
+            });
+          }
+        }
+        if (typeof action.replacement !== "string" || action.replacement.length > LIMITS.maxRequestBodyReplacementLength) {
+          diagnostics.push({
+            code: "editor.request-body-replacement",
+            severity: "error",
+            path: `${rulePath}/requestBody/replacement`,
+            message: `Regex replacement exceeds the maximum length of ${LIMITS.maxRequestBodyReplacementLength} characters.`
+          });
+        } else if (hasLoneSurrogate(action.replacement)) {
+          diagnostics.push({
+            code: "editor.request-body-lone-surrogate",
+            severity: "error",
+            path: `${rulePath}/requestBody/replacement`,
+            message: "Regex replacement must not contain lone UTF-16 surrogates."
+          });
+        }
+      }
+      if (rule.method !== "POST" && rule.method !== "PUT" && rule.method !== "PATCH") {
+        diagnostics.push({
+          code: "editor.request-body-method",
+          severity: "error",
+          path: `${rulePath}/method`,
+          message: 'Request-body rules require method "POST", "PUT", or "PATCH".'
+        });
+      }
+      const resourceTypes = rule.resourceTypes;
+      if (!Array.isArray(resourceTypes) || resourceTypes.length !== 1 || resourceTypes[0] !== "xmlhttprequest") {
+        diagnostics.push({
+          code: "editor.request-body-resource-types",
+          severity: "error",
+          path: `${rulePath}/resourceTypes`,
+          message: 'Request-body rules require exactly one resource type: "xmlhttprequest".'
+        });
+      }
+      return stable3(diagnostics);
+    },
+    mount(context) {
+      const { document, container } = context;
+      const render = () => {
+        const current = requestBodyOf(context.getField("requestBody"));
+        container.replaceChildren();
+        if (current === void 0) return;
+        const modeSelect = document.createElement("select");
+        modeSelect.value = current.mode;
+        const replaceOption = document.createElement("option");
+        replaceOption.value = "replace";
+        replaceOption.textContent = "Replace body";
+        const regexOption = document.createElement("option");
+        regexOption.value = "regex";
+        regexOption.textContent = "Regex replace";
+        modeSelect.append(replaceOption, regexOption);
+        modeSelect.addEventListener("change", () => {
+          const next = { ...current, mode: modeSelect.value };
+          if (modeSelect.value === "replace") {
+            delete next.pattern;
+            delete next.replacement;
+          } else {
+            delete next.body;
+          }
+          context.setField("requestBody", next);
+          render();
+        });
+        context.registerControl("/requestBody/mode", modeSelect);
+        container.append(modeSelect);
+        if (current.mode === "replace") {
+          const bodyInput = document.createElement("textarea");
+          bodyInput.value = current.body ?? "";
+          bodyInput.placeholder = "Replacement body";
+          bodyInput.addEventListener("input", () => {
+            const next = { ...current, body: bodyInput.value };
+            context.setField("requestBody", next);
+          });
+          context.registerControl("/requestBody/body", bodyInput);
+          container.append(bodyInput);
+        } else {
+          const patternInput = document.createElement("input");
+          patternInput.type = "text";
+          patternInput.value = current.pattern ?? "";
+          patternInput.placeholder = "Regex pattern";
+          patternInput.addEventListener("input", () => {
+            const next = { ...current, pattern: patternInput.value };
+            context.setField("requestBody", next);
+          });
+          context.registerControl("/requestBody/pattern", patternInput);
+          container.append(patternInput);
+          const replacementInput = document.createElement("input");
+          replacementInput.type = "text";
+          replacementInput.value = current.replacement ?? "";
+          replacementInput.placeholder = "Replacement";
+          replacementInput.addEventListener("input", () => {
+            const next = { ...current, replacement: replacementInput.value };
+            context.setField("requestBody", next);
+          });
+          context.registerControl("/requestBody/replacement", replacementInput);
+          container.append(replacementInput);
+        }
+      };
+      render();
+      return { destroy() {
+      } };
+    },
+    defaultAction() {
+      return { mode: "replace", body: "" };
+    }
+  };
+}
+
+// packages/editor/src/rule-types/response-body.ts
+function isRecord4(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function replacementsOf(value) {
+  if (!isRecord4(value) || !Array.isArray(value.replacements)) return void 0;
+  return value.replacements;
+}
+function stable4(values) {
+  return [...values].sort(
+    (left, right) => left.path.localeCompare(right.path) || left.code.localeCompare(right.code)
+  );
+}
+function createResponseBodyRuleType() {
+  return {
+    id: "response-body",
+    label: "Response body rewrite",
+    actionField: "responseBody",
+    matches(rule) {
+      return rule.type === "response-body" || replacementsOf(rule.responseBody) !== void 0;
+    },
+    validate(rule, rulePath) {
+      const replacements = replacementsOf(rule.responseBody);
+      if (replacements === void 0) return [];
+      const diagnostics = [];
+      if (replacements.length === 0 || replacements.length > LIMITS.maxResponseBodyReplacements) {
+        diagnostics.push({
+          code: "editor.response-body-replacements",
+          severity: "error",
+          path: `${rulePath}/responseBody/replacements`,
+          message: `Response-body rules need 1-${LIMITS.maxResponseBodyReplacements} replacements.`
+        });
+      }
+      replacements.forEach((entry, index) => {
+        const patternPath = `${rulePath}/responseBody/replacements/${index}/pattern`;
+        const replacementPath = `${rulePath}/responseBody/replacements/${index}/replacement`;
+        try {
+          if (typeof entry?.pattern !== "string" || entry.pattern.length === 0 || entry.pattern.length > LIMITS.maxResponseBodyPatternLength)
+            throw new Error();
+          new RegExp(entry.pattern, "u");
+        } catch {
+          diagnostics.push({
+            code: "editor.response-body-pattern",
+            severity: "error",
+            path: patternPath,
+            message: "Replacement pattern must be a valid bounded regular expression."
+          });
+        }
+        if (typeof entry?.replacement !== "string" || entry.replacement.length > LIMITS.maxResponseBodyReplacementLength) {
+          diagnostics.push({
+            code: "editor.response-body-replacement",
+            severity: "error",
+            path: replacementPath,
+            message: "Replacement text exceeds the permitted size."
+          });
+        }
+      });
+      return stable4(diagnostics);
+    },
+    mount(context) {
+      const { document, container } = context;
+      const render = () => {
+        const current = replacementsOf(context.getField("responseBody"));
+        container.replaceChildren();
+        if (current === void 0) return;
+        current.forEach((entry, index) => {
+          const row = document.createElement("div");
+          row.dataset.responseBodyReplacement = String(index);
+          const pattern = document.createElement("input");
+          pattern.type = "text";
+          pattern.value = entry.pattern;
+          pattern.placeholder = "Pattern";
+          pattern.addEventListener("input", () => {
+            const next = [
+              ...replacementsOf(context.getField("responseBody")) ?? []
+            ];
+            next[index] = { ...next[index], pattern: pattern.value };
+            context.setField("responseBody", { replacements: next });
+          });
+          context.registerControl(
+            `/responseBody/replacements/${index}/pattern`,
+            pattern
+          );
+          const replacement = document.createElement("input");
+          replacement.type = "text";
+          replacement.value = entry.replacement;
+          replacement.placeholder = "Replacement";
+          replacement.addEventListener("input", () => {
+            const next = [
+              ...replacementsOf(context.getField("responseBody")) ?? []
+            ];
+            next[index] = { ...next[index], replacement: replacement.value };
+            context.setField("responseBody", { replacements: next });
+          });
+          context.registerControl(
+            `/responseBody/replacements/${index}/replacement`,
+            replacement
+          );
+          const remove = document.createElement("button");
+          remove.type = "button";
+          remove.textContent = "Remove replacement";
+          remove.addEventListener("click", () => {
+            const next = (replacementsOf(context.getField("responseBody")) ?? []).filter((_, itemIndex) => itemIndex !== index);
+            context.setField("responseBody", { replacements: next });
+            render();
+          });
+          row.append(pattern, replacement, remove);
+          container.append(row);
+        });
+        const add = document.createElement("button");
+        add.type = "button";
+        add.textContent = "Add replacement";
+        add.addEventListener("click", () => {
+          const next = [
+            ...replacementsOf(context.getField("responseBody")) ?? [],
+            { pattern: "", replacement: "" }
+          ];
+          context.setField("responseBody", { replacements: next });
+          render();
+        });
+        container.append(add);
+      };
+      render();
+      return { destroy() {
+      } };
+    },
+    defaultAction() {
+      return { replacements: [{ pattern: "", replacement: "" }] };
+    }
+  };
+}
+
+// packages/editor/src/rule-types/index.ts
+var builtInRuleTypes = Object.freeze([
+  queryRuleType,
+  createMockRuleType(),
+  createResponseBodyRuleType(),
+  createRequestBodyRuleType()
+]);
+
+// packages/editor/src/types.ts
+var EditorInitializationError = class extends Error {
+  diagnostics;
+  constructor(diagnostics) {
+    super("Rogatio editor could not initialize");
+    this.name = "EditorInitializationError";
+    this.diagnostics = diagnostics.map((diagnostic2) => ({ ...diagnostic2 }));
+  }
+};
+
+// packages/editor/src/url.ts
+var F2_MAX_URL_REGEX_LENGTH = 2048;
+var REGEX_META_CHARACTERS = /[.*+?^${}()|[\]\\]/g;
+function urlToExactRegex(value) {
+  if (typeof value !== "string" || value.length === 0 || value.trim() !== value || hasControl(value)) {
+    return { ok: false, code: "editor.invalid-url" };
+  }
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return { ok: false, code: "editor.invalid-url" };
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:" || url.origin === "null" || url.username.length > 0 || url.password.length > 0 || url.hash.length > 0) {
+    return { ok: false, code: "editor.invalid-url" };
+  }
+  const escaped = url.href.replace(REGEX_META_CHARACTERS, "\\$&");
+  const source = `^${escaped}$`;
+  if (source.length > F2_MAX_URL_REGEX_LENGTH) {
+    return { ok: false, code: "editor.url-too-long" };
+  }
+  return { ok: true, source };
+}
+
+// packages/editor/src/editor.ts
+var RESOURCE_TYPES2 = [
+  "main_frame",
+  "sub_frame",
+  "stylesheet",
+  "script",
+  "image",
+  "font",
+  "object",
+  "media",
+  "xmlhttprequest",
+  "ping",
+  "csp_report",
+  "websocket",
+  "webtransport",
+  "webbundle",
+  "other"
+];
+var HTTP_METHODS2 = [
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS",
+  "CONNECT",
+  "TRACE"
+];
+var COMMON_RULE_FIELDS = /* @__PURE__ */ new Set([
+  "id",
+  "name",
+  "urlRegex",
+  "origins",
+  "resourceTypes",
+  "priority",
+  "method",
+  "type"
+]);
+var FORBIDDEN_EXTENSION_FIELDS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
+var MAX_SNAPSHOT_ARRAY_LENGTH = 4096;
+var F2_MAX_URL_REGEX_LENGTH2 = 2048;
+var editorInstanceCount = 0;
+function isRecord5(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function snapshotOwnData(value, ancestors = /* @__PURE__ */ new WeakSet()) {
+  if (value === null || typeof value !== "object") {
+    return { valid: true, value };
+  }
+  if (ancestors.has(value)) return { valid: false };
+  ancestors.add(value);
+  try {
+    if (Object.getOwnPropertySymbols(value).length > 0) {
+      return { valid: false };
+    }
+    if (Array.isArray(value)) {
+      const lengthDescriptor = Object.getOwnPropertyDescriptor(value, "length");
+      if (lengthDescriptor === void 0 || !("value" in lengthDescriptor) || !Number.isSafeInteger(lengthDescriptor.value) || lengthDescriptor.value < 0 || lengthDescriptor.value > MAX_SNAPSHOT_ARRAY_LENGTH) {
+        return { valid: false };
+      }
+      const length = lengthDescriptor.value;
+      for (const propertyName of Object.getOwnPropertyNames(value)) {
+        if (propertyName === "length") continue;
+        const index = Number(propertyName);
+        if (!Number.isInteger(index) || index < 0 || index >= length || String(index) !== propertyName) {
+          return { valid: false };
+        }
+      }
+      const snapshot2 = new Array(length);
+      for (let index = 0; index < length; index += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(
+          value,
+          String(index)
+        );
+        if (descriptor === void 0 || !("value" in descriptor) || !descriptor.enumerable) {
+          return { valid: false };
+        }
+        const child = snapshotOwnData(descriptor.value, ancestors);
+        if (!child.valid) return child;
+        snapshot2[index] = child.value;
+      }
+      return { valid: true, value: snapshot2 };
+    }
+    const snapshot = {};
+    for (const key of Object.getOwnPropertyNames(value)) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (descriptor === void 0 || !("value" in descriptor) || !descriptor.enumerable) {
+        return { valid: false };
+      }
+      const child = snapshotOwnData(descriptor.value, ancestors);
+      if (!child.valid) return child;
+      Object.defineProperty(snapshot, key, {
+        configurable: true,
+        enumerable: true,
+        value: child.value,
+        writable: true
+      });
+    }
+    return { valid: true, value: snapshot };
+  } catch {
+    return { valid: false };
+  } finally {
+    ancestors.delete(value);
+  }
+}
+function cloneSnapshot(value) {
+  const result = snapshotOwnData(value);
+  if (!result.valid) throw new Error("editor snapshot invariant failed");
+  return result.value;
+}
+function freezeSnapshot(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null || typeof value !== "object") return value;
+  if (seen.has(value)) return value;
+  seen.add(value);
+  Object.freeze(value);
+  for (const key of Object.keys(value)) {
+    freezeSnapshot(value[key], seen);
+  }
+  return value;
+}
+function asDraftProject(value) {
+  if (!isRecord5(value) || !Array.isArray(value.groups)) return void 0;
+  for (const group of value.groups) {
+    if (!isRecord5(group) || !Array.isArray(group.rules)) return void 0;
+    for (const rule of group.rules) {
+      if (!isRecord5(rule)) return void 0;
+    }
+  }
+  return value;
+}
+function encodePointerSegment(value) {
+  return value.replaceAll("~", "~0").replaceAll("/", "~1");
+}
+function decodePointer(path) {
+  if (path === "") return [];
+  if (!path.startsWith("/")) return void 0;
+  return path.slice(1).split("/").map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~"));
+}
+function pointer(...segments) {
+  return segments.length === 0 ? "" : `/${segments.map((segment) => encodePointerSegment(String(segment))).join("/")}`;
+}
+function arrayIndex(value) {
+  if (!/^(0|[1-9][0-9]*)$/u.test(value)) return void 0;
+  const index = Number(value);
+  return Number.isSafeInteger(index) ? index : void 0;
+}
+function valueAtPath(root, path) {
+  const segments = decodePointer(path);
+  if (!segments) return void 0;
+  let current = root;
+  for (const segment of segments) {
+    if (Array.isArray(current)) {
+      const index = arrayIndex(segment);
+      if (index === void 0 || !Object.hasOwn(current, index))
+        return void 0;
+      current = current[index];
+    } else if (isRecord5(current) && Object.hasOwn(current, segment)) {
+      current = current[segment];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function setValueAtPath(root, path, value) {
+  const segments = decodePointer(path);
+  if (!segments || segments.length === 0) return false;
+  let current = root;
+  for (let index = 0; index < segments.length - 1; index += 1) {
+    const segment = segments[index];
+    if (Array.isArray(current)) {
+      const childIndex = arrayIndex(segment);
+      if (childIndex === void 0 || !Object.hasOwn(current, childIndex)) {
+        return false;
+      }
+      current = current[childIndex];
+    } else if (isRecord5(current) && Object.hasOwn(current, segment)) {
+      current = current[segment];
+    } else {
+      return false;
+    }
+  }
+  const finalSegment = segments[segments.length - 1];
+  if (Array.isArray(current)) {
+    const index = arrayIndex(finalSegment);
+    if (index === void 0 || !Object.hasOwn(current, index)) return false;
+    if (Object.is(current[index], value)) return false;
+    current[index] = value;
+    return true;
+  }
+  if (!isRecord5(current)) return false;
+  if (!Object.hasOwn(current, finalSegment) && finalSegment !== "description" && finalSegment !== "method" && finalSegment !== "type" && finalSegment !== "action" && finalSegment !== "redirect" && finalSegment !== "mock") {
+    return false;
+  }
+  if (Object.is(current[finalSegment], value)) return false;
+  Object.defineProperty(current, finalSegment, {
+    configurable: true,
+    enumerable: true,
+    value,
+    writable: true
+  });
+  return true;
+}
+function deleteValueAtPath(root, path) {
+  const segments = decodePointer(path);
+  if (!segments || segments.length === 0) return false;
+  const parentPath = pointer(...segments.slice(0, -1));
+  const parent = valueAtPath(root, parentPath);
+  const key = segments[segments.length - 1];
+  if (!isRecord5(parent) || !Object.hasOwn(parent, key)) return false;
+  return delete parent[key];
+}
+function safeText(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function diagnostic(code, path, message) {
+  return { code, severity: "error", path, message };
+}
+function stableDiagnostics(diagnostics) {
+  const compareCodeUnits = (left, right) => {
+    if (left < right) return -1;
+    if (left > right) return 1;
+    return 0;
+  };
+  return diagnostics.map((value) => ({
+    code: value.code,
+    severity: "error",
+    path: value.path,
+    message: value.message
+  })).sort(
+    (left, right) => compareCodeUnits(left.path, right.path) || compareCodeUnits(left.code, right.code) || compareCodeUnits(left.message, right.message)
+  );
+}
+function normalizeDiagnostics(value) {
+  if (!Array.isArray(value)) {
+    return [
+      diagnostic(
+        "editor.validation-failed",
+        "",
+        "Project validation could not be completed."
+      )
+    ];
+  }
+  const diagnostics = [];
+  for (const item of value) {
+    if (!isRecord5(item)) continue;
+    const code = item.code;
+    const path = item.path;
+    const message = item.message;
+    if (typeof code === "string" && typeof path === "string" && typeof message === "string") {
+      diagnostics.push(diagnostic(code, path, message));
+    }
+  }
+  return stableDiagnostics(diagnostics);
+}
+function isValidExtensionName(name) {
+  return name.length > 0 && !COMMON_RULE_FIELDS.has(name) && !FORBIDDEN_EXTENSION_FIELDS.has(name) && !hasControl(name);
+}
+var ACTION_FIELDS = ["redirect", "action", "mock"];
+function clearActionFields(rule, keep) {
+  if (!isRecord5(rule)) return false;
+  let changed = false;
+  for (const field of ACTION_FIELDS) {
+    if (field === keep) continue;
+    if (Object.hasOwn(rule, field)) {
+      delete rule[field];
+      changed = true;
+    }
+  }
+  return changed;
+}
+function extensionFieldParent(rule, name) {
+  const segments = name.split(".");
+  if (segments.length === 0) return void 0;
+  let current = rule;
+  for (let index = 0; index < segments.length - 1; index += 1) {
+    if (!isRecord5(current)) return void 0;
+    const next = current[segments[index]];
+    if (!isRecord5(next)) {
+      const created = {};
+      Object.defineProperty(current, segments[index], {
+        configurable: true,
+        enumerable: true,
+        value: created,
+        writable: true
+      });
+      current = created;
+    } else {
+      current = next;
+    }
+  }
+  if (!isRecord5(current)) return void 0;
+  return { parent: current, key: segments[segments.length - 1] };
+}
+function toSearchText(value) {
+  return typeof value === "string" || typeof value === "number" ? String(value).normalize("NFKC").toLowerCase() : "";
+}
+function displayName(value, fallback) {
+  const text = safeText(value, fallback);
+  return text.length > 0 ? text : fallback;
+}
+function isHTMLElement(value) {
+  return value !== null && typeof value === "object" && value.nodeType === 1 && typeof value.appendChild === "function";
+}
+function normalizeExtensions(value) {
+  const ids = /* @__PURE__ */ new Set();
+  const merged = [...builtInRuleTypes];
+  for (const extension of builtInRuleTypes) ids.add(extension.id);
+  if (value === void 0) return Object.freeze(merged);
+  if (!Array.isArray(value)) {
+    throw new EditorInitializationError([
+      diagnostic(
+        "editor.extension-registration",
+        "",
+        "Rule-type extensions are invalid."
+      )
+    ]);
+  }
+  const passedIds = /* @__PURE__ */ new Set();
+  for (let index = 0; index < value.length; index += 1) {
+    const extension = value[index];
+    if (!extension || typeof extension.id !== "string" || extension.id.length === 0 || typeof extension.label !== "string" || extension.label.length === 0 || typeof extension.matches !== "function" || typeof extension.mount !== "function" || typeof extension.validate !== "function" || passedIds.has(extension.id)) {
+      throw new EditorInitializationError([
+        diagnostic(
+          "editor.extension-registration",
+          `/ruleTypes/${index}`,
+          "Rule-type extension registration is invalid or duplicated."
+        )
+      ]);
+    }
+    passedIds.add(extension.id);
+    const existing = merged.findIndex((e) => e.id === extension.id);
+    if (existing >= 0) merged[existing] = extension;
+    else merged.push(extension);
+    ids.add(extension.id);
+  }
+  return Object.freeze(merged);
+}
+var EditorControllerImpl = class {
+  root;
+  document;
+  options;
+  extensions;
+  instanceId;
+  host;
+  rail;
+  main;
+  header;
+  status;
+  summary;
+  commandBar;
+  form;
+  searchResults;
+  draft;
+  committed;
+  revision = 0;
+  route = { kind: "project" };
+  searchQuery = "";
+  errors = [];
+  conversionDiagnostics = /* @__PURE__ */ new Map();
+  extensionErrors = /* @__PURE__ */ new Map();
+  urlInputs = /* @__PURE__ */ new Map();
+  controls = /* @__PURE__ */ new Map();
+  extensionControls = /* @__PURE__ */ new Map();
+  extensionCleanups = [];
+  confirmation;
+  focusRequest;
+  saving = false;
+  destroyed = false;
+  composing = false;
+  statusMessage = "";
+  controlNumber = 0;
+  previousFocus;
+  testUrls = "";
+  testMethod = "";
+  testResourceType = "";
+  testMaxCases = "256";
+  testResult = void 0;
+  testRunning = false;
+  testRequestId = 0;
+  constructor(options, initial, extensions) {
+    this.root = options.root;
+    this.document = options.root.ownerDocument;
+    this.options = options;
+    this.extensions = extensions;
+    this.instanceId = `rogatio-editor-${++editorInstanceCount}`;
+    this.draft = initial;
+    this.committed = cloneSnapshot(initial);
+    const initialDiagnostics = this.collectDiagnostics(this.draft);
+    if (initialDiagnostics.length > 0) {
+      throw new EditorInitializationError(initialDiagnostics);
+    }
+    this.host = this.document.createElement("div");
+    this.host.className = "rogatio-editor";
+    this.host.dataset.rogatioEditor = "true";
+    const layout = this.document.createElement("div");
+    layout.dataset.editorLayout = "true";
+    this.rail = this.document.createElement("nav");
+    this.rail.dataset.desktopRouteRail = "true";
+    this.rail.setAttribute("aria-label", "Project sections");
+    this.main = this.document.createElement("main");
+    this.main.dataset.editorMain = "true";
+    this.header = this.document.createElement("header");
+    this.header.dataset.editorHeader = "true";
+    this.status = this.document.createElement("p");
+    this.status.dataset.editorStatus = "true";
+    this.status.setAttribute("role", "status");
+    this.status.setAttribute("aria-live", "polite");
+    this.summary = this.document.createElement("section");
+    this.summary.dataset.editorSummary = "true";
+    this.summary.setAttribute("role", "alert");
+    this.commandBar = this.document.createElement("div");
+    this.commandBar.dataset.editorCommandBar = "true";
+    this.commandBar.setAttribute("role", "toolbar");
+    this.commandBar.setAttribute("aria-label", "Editor commands");
+    this.form = this.document.createElement("form");
+    this.form.dataset.editorForm = "true";
+    this.form.noValidate = true;
+    this.searchResults = this.document.createElement("section");
+    this.searchResults.id = "rogatio-search-results";
+    this.searchResults.dataset.searchResults = "true";
+    this.host.addEventListener("click", (event) => {
+      if (!this.searchQuery) return;
+      const target = event.target;
+      if (target instanceof Element && target.closest("[data-search-wrap]"))
+        return;
+      this.searchQuery = "";
+      this.render();
+    });
+    this.main.append(
+      this.header,
+      this.status,
+      this.summary,
+      this.commandBar,
+      this.form
+    );
+    layout.append(this.rail, this.main);
+    this.host.append(layout);
+    this.root.append(this.host);
+    this.host.addEventListener("click", this.handleClick);
+    this.host.addEventListener("input", this.handleInput);
+    this.host.addEventListener("change", this.handleChange);
+    this.host.addEventListener("submit", this.handleSubmit);
+    this.host.addEventListener("keydown", this.handleKeydown);
+    this.host.addEventListener("compositionstart", this.handleCompositionStart);
+    this.host.addEventListener("compositionend", this.handleCompositionEnd);
+    this.render();
+  }
+  getDraft() {
+    return cloneSnapshot(this.draft);
+  }
+  isDirty() {
+    return JSON.stringify(this.draft) !== JSON.stringify(this.committed);
+  }
+  validate() {
+    if (this.destroyed) return [];
+    this.errors = this.validateCurrent();
+    this.statusMessage = this.errors.length === 0 ? "Project is valid." : `${this.errors.length} validation error${this.errors.length === 1 ? "" : "s"} found.`;
+    this.focusRequest = this.errors[0]?.path;
+    this.render();
+    return this.errors.map((value) => ({ ...value }));
+  }
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    this.cleanupExtensions();
+    this.host.removeEventListener("click", this.handleClick);
+    this.host.removeEventListener("input", this.handleInput);
+    this.host.removeEventListener("change", this.handleChange);
+    this.host.removeEventListener("submit", this.handleSubmit);
+    this.host.removeEventListener("keydown", this.handleKeydown);
+    this.host.removeEventListener(
+      "compositionstart",
+      this.handleCompositionStart
+    );
+    this.host.removeEventListener("compositionend", this.handleCompositionEnd);
+    this.host.remove();
+  }
+  handleClick = (event) => {
+    if (this.destroyed) return;
+    const target = event.target;
+    if (!(target instanceof Element)) return;
+    const element = target.closest(
+      "[data-command], [data-route], [data-search-result], [data-error-path]"
+    );
+    if (!element) return;
+    if (element.dataset.route !== void 0) {
+      this.navigate(element.dataset.route, element.dataset.groupId);
+      return;
+    }
+    if (element.dataset.searchResult !== void 0) {
+      this.navigateToSearchResult(element.dataset.searchResult);
+      return;
+    }
+    if (element.dataset.errorPath !== void 0) {
+      this.navigateToPath(element.dataset.errorPath);
+      return;
+    }
+    const command = element.dataset.command;
+    if (!command) return;
+    this.dispatchCommand(command, element);
+  };
+  handleInput = (event) => {
+    if (this.destroyed || this.saving) return;
+    const target = event.target;
+    if (!(target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement)) {
+      return;
+    }
+    if (target.dataset.urlSource !== void 0) {
+      const ruleId = target.dataset.ruleId;
+      if (ruleId) this.urlInputs.set(ruleId, target.value);
+      return;
+    }
+    if (target.dataset.search !== void 0) {
+      this.searchQuery = target.value;
+      this.render();
+      return;
+    }
+    if (target.dataset.testUrls !== void 0) {
+      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;
+    if (this.updateCommonField(path, target.value)) {
+      if (!this.composing) this.render();
+    }
+  };
+  handleChange = (event) => {
+    if (this.destroyed || this.saving) return;
+    const target = event.target;
+    if (!(target instanceof HTMLInputElement || target instanceof HTMLSelectElement)) {
+      return;
+    }
+    if (target.dataset.mobileRoute !== void 0 && target instanceof HTMLSelectElement) {
+      const selectedOption = target.options[target.selectedIndex];
+      const groupId = selectedOption?.dataset.groupId;
+      this.navigate(target.value, groupId);
+      return;
+    }
+    if (target instanceof HTMLInputElement && target.dataset.resourcePath !== void 0) {
+      this.updateResourceTypes(
+        target.dataset.resourcePath,
+        target.dataset.resourceType ?? "",
+        target.checked
+      );
+      return;
+    }
+    if (target instanceof HTMLSelectElement && target.dataset.ruleTypeSelect !== void 0) {
+      const ruleTypePath = target.dataset.ruleTypePath ?? "";
+      if (ruleTypePath) this.setRuleType(ruleTypePath, target.value);
+      return;
+    }
+    if (target instanceof HTMLSelectElement && target.dataset.testMethod !== void 0) {
+      this.testMethod = target.value || "";
+      return;
+    }
+    if (target instanceof HTMLSelectElement && target.dataset.testResourceType !== void 0) {
+      this.testResourceType = target.value || "";
+      return;
+    }
+    const path = target.dataset.path;
+    if (!path || this.extensionControls.has(path)) return;
+    if (this.updateCommonField(path, target.value)) this.render();
+  };
+  handleSubmit = (event) => {
+    event.preventDefault();
+    this.dispatchCommand("save", this.form);
+  };
+  handleKeydown = (event) => {
+    if (event.key === "Escape" && this.confirmation) {
+      event.preventDefault();
+      this.confirmation = void 0;
+      this.statusMessage = "No changes were discarded.";
+      this.render();
+    }
+  };
+  handleCompositionStart = () => {
+    this.composing = true;
+  };
+  handleCompositionEnd = (event) => {
+    this.composing = false;
+    const target = event.target;
+    if (target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement) {
+      const path = target.dataset.path;
+      if (path && this.updateCommonField(path, target.value)) this.render();
+    }
+  };
+  dispatchCommand(command, element) {
+    if (command === "validate") {
+      this.validate();
+      return;
+    }
+    if (command === "save") {
+      void this.saveDraft();
+      return;
+    }
+    if (command === "cancel") {
+      this.requestCancel();
+      return;
+    }
+    if (command === "confirm-cancel") {
+      this.discardChanges();
+      return;
+    }
+    if (command === "cancel-confirmation") {
+      this.confirmation = void 0;
+      this.statusMessage = "No changes were discarded.";
+      this.render();
+      return;
+    }
+    if (command === "confirm-remove") {
+      this.confirmRemoval();
+      return;
+    }
+    if (command === "remove-confirmation") {
+      this.confirmation = void 0;
+      this.statusMessage = "Removal cancelled.";
+      this.render();
+      return;
+    }
+    if (command === "add-group") {
+      this.addGroup();
+      return;
+    }
+    if (command === "add-rule") {
+      const groupId = element.dataset.groupId ?? this.currentGroupId();
+      if (groupId) this.addRule(groupId);
+      return;
+    }
+    if (command === "move-group-up" || command === "move-group-down") {
+      const groupId = element.dataset.groupId;
+      if (groupId) this.moveGroup(groupId, command.endsWith("up") ? -1 : 1);
+      return;
+    }
+    if (command === "move-rule-up" || command === "move-rule-down") {
+      const groupId = element.dataset.groupId;
+      const ruleId = element.dataset.ruleId;
+      if (groupId && ruleId) {
+        this.moveRule(groupId, ruleId, command.endsWith("up") ? -1 : 1);
+      }
+      return;
+    }
+    if (command === "remove-group") {
+      const groupId = element.dataset.groupId;
+      if (groupId) this.requestRemoveGroup(groupId);
+      return;
+    }
+    if (command === "remove-rule") {
+      const groupId = element.dataset.groupId;
+      const ruleId = element.dataset.ruleId;
+      if (groupId && ruleId) this.requestRemoveRule(groupId, ruleId);
+      return;
+    }
+    if (command === "add-group-origin") {
+      const groupId = element.dataset.groupId;
+      if (groupId) this.addGroupOrigin(groupId);
+      return;
+    }
+    if (command === "remove-group-origin") {
+      const groupId = element.dataset.groupId;
+      const index = Number(element.dataset.index);
+      if (groupId && Number.isSafeInteger(index))
+        this.removeGroupOrigin(groupId, index);
+      return;
+    }
+    if (command === "add-rule-origin") {
+      const groupId = element.dataset.groupId;
+      const ruleId = element.dataset.ruleId;
+      if (groupId && ruleId) this.addRuleOrigin(groupId, ruleId);
+      return;
+    }
+    if (command === "remove-rule-origin") {
+      const groupId = element.dataset.groupId;
+      const ruleId = element.dataset.ruleId;
+      const index = Number(element.dataset.index);
+      if (groupId && ruleId && Number.isSafeInteger(index)) {
+        this.removeRuleOrigin(groupId, ruleId, index);
+      }
+      return;
+    }
+    if (command === "convert-url") {
+      const groupId = element.dataset.groupId;
+      const ruleId = element.dataset.ruleId;
+      if (groupId && ruleId) this.convertUrl(groupId, ruleId);
+    }
+    if (command === "test:run") {
+      void this.runTest();
+      return;
+    }
+  }
+  collectDiagnostics(value) {
+    let hostDiagnostics;
+    try {
+      const input = cloneSnapshot(value);
+      hostDiagnostics = this.options.validate(input);
+    } catch {
+      return [
+        diagnostic(
+          "editor.validation-failed",
+          "",
+          "Project validation could not be completed."
+        )
+      ];
+    }
+    const diagnostics = normalizeDiagnostics(hostDiagnostics);
+    const project = asDraftProject(value);
+    if (!project) return diagnostics;
+    this.extensionErrors.clear();
+    for (let groupIndex = 0; groupIndex < project.groups.length; groupIndex += 1) {
+      const group = project.groups[groupIndex];
+      for (let ruleIndex = 0; ruleIndex < group.rules.length; ruleIndex += 1) {
+        const rule = group.rules[ruleIndex];
+        const rulePath = pointer("groups", groupIndex, "rules", ruleIndex);
+        const match = this.findExtension(rule, rulePath);
+        if (match.error) {
+          diagnostics.push(match.error);
+          continue;
+        }
+        if (!match.extension) continue;
+        try {
+          const ruleSnapshot = freezeSnapshot(
+            cloneSnapshot(rule)
+          );
+          const extensionDiagnostics = normalizeDiagnostics(
+            match.extension.validate(ruleSnapshot, rulePath)
+          );
+          for (const extensionDiagnostic of extensionDiagnostics) {
+            diagnostics.push({
+              ...extensionDiagnostic,
+              path: this.extensionDiagnosticPath(
+                extensionDiagnostic.path,
+                rulePath
+              )
+            });
+          }
+        } catch {
+          diagnostics.push(
+            diagnostic(
+              "editor.extension-failed",
+              rulePath,
+              "An additional rule field could not be validated."
+            )
+          );
+        }
+      }
+    }
+    return stableDiagnostics(diagnostics);
+  }
+  validateCurrent() {
+    const diagnostics = this.collectDiagnostics(this.draft);
+    diagnostics.push(...this.conversionDiagnostics.values());
+    return stableDiagnostics(diagnostics);
+  }
+  findExtension(rule, rulePath) {
+    const matches = [];
+    let snapshot;
+    try {
+      snapshot = freezeSnapshot(
+        cloneSnapshot(rule)
+      );
+    } catch {
+      return {
+        error: diagnostic(
+          "editor.extension-failed",
+          rulePath,
+          "An additional rule field could not be read safely."
+        )
+      };
+    }
+    for (const extension of this.extensions) {
+      try {
+        if (extension.matches(snapshot)) matches.push(extension);
+      } catch {
+        return {
+          error: diagnostic(
+            "editor.extension-failed",
+            rulePath,
+            "An additional rule field could not be identified."
+          )
+        };
+      }
+    }
+    if (matches.length > 1) {
+      return {
+        error: diagnostic(
+          "editor.extension-ambiguous",
+          rulePath,
+          "More than one additional rule field set matches this rule."
+        )
+      };
+    }
+    return { extension: matches[0] };
+  }
+  extensionDiagnosticPath(path, rulePath) {
+    if (path === "") return rulePath;
+    return path.startsWith(rulePath) ? path : `${rulePath}${path.startsWith("/") ? path : `/${path}`}`;
+  }
+  updateCommonField(path, rawValue) {
+    if (this.saving) return false;
+    let value = rawValue;
+    const segments = decodePointer(path);
+    const finalSegment = segments?.at(-1);
+    if (finalSegment === "priority") {
+      value = rawValue === "" ? "" : Number(rawValue);
+    } else if (finalSegment === "method") {
+      if (rawValue === "") {
+        const changed2 = deleteValueAtPath(this.draft, path);
+        if (changed2) this.markChanged();
+        return changed2;
+      }
+      value = rawValue;
+    } else if (finalSegment === "description" && rawValue === "") {
+      const changed2 = deleteValueAtPath(this.draft, path);
+      if (changed2) this.markChanged();
+      return changed2;
+    } else if (finalSegment === "type") {
+      const ruleContainerPath = pointer(...segments?.slice(0, -1) ?? []);
+      if (rawValue === "") {
+        const changedType = deleteValueAtPath(this.draft, path);
+        const ruleContainer = valueAtPath(this.draft, ruleContainerPath);
+        const cleared = clearActionFields(ruleContainer);
+        if (changedType || cleared) this.markChanged();
+        return changedType || cleared;
+      }
+      const changed2 = setValueAtPath(this.draft, path, rawValue);
+      if (changed2) {
+        const ruleContainer = valueAtPath(this.draft, ruleContainerPath);
+        clearActionFields(
+          ruleContainer,
+          rawValue === "redirect" || rawValue === "mock" ? rawValue : void 0
+        );
+        this.markChanged();
+      }
+      return changed2;
+    }
+    const changed = setValueAtPath(this.draft, path, value);
+    if (changed) this.markChanged();
+    return changed;
+  }
+  updateResourceTypes(path, resourceType, checked) {
+    const values = valueAtPath(this.draft, path);
+    if (!Array.isArray(values) || !RESOURCE_TYPES2.includes(resourceType)) {
+      return;
+    }
+    const index = values.indexOf(resourceType);
+    if (checked && index === -1) values.push(resourceType);
+    if (!checked && index !== -1) values.splice(index, 1);
+    if (checked && index === -1 || !checked && index !== -1) {
+      this.markChanged();
+      this.render();
+    }
+  }
+  setRuleType(rulePath, typeId) {
+    if (this.saving) return;
+    const ruleContainer = valueAtPath(this.draft, rulePath);
+    if (typeId === "") {
+      const changedType2 = deleteValueAtPath(this.draft, `${rulePath}/type`);
+      const cleared2 = clearActionFields(ruleContainer);
+      if (changedType2 || cleared2) {
+        this.markChanged();
+        this.render();
+      }
+      return;
+    }
+    const extension = this.extensions.find((entry) => entry.id === typeId);
+    if (!extension?.defaultAction) return;
+    const actionField = extension.actionField ?? "action";
+    const changedType = setValueAtPath(this.draft, `${rulePath}/type`, typeId);
+    const changedAction = setValueAtPath(
+      this.draft,
+      `${rulePath}/${actionField}`,
+      extension.defaultAction()
+    );
+    const cleared = clearActionFields(ruleContainer, actionField);
+    if (changedType || changedAction || cleared) {
+      this.markChanged();
+      this.render();
+    }
+  }
+  markChanged() {
+    this.revision += 1;
+    this.errors = [];
+    this.conversionDiagnostics.clear();
+    this.extensionErrors.clear();
+    this.statusMessage = "";
+  }
+  allIds() {
+    const ids = /* @__PURE__ */ new Set();
+    for (const group of this.draft.groups) {
+      if (typeof group.id === "string") ids.add(group.id);
+      for (const rule of group.rules) {
+        if (typeof rule.id === "string") ids.add(rule.id);
+      }
+    }
+    return ids;
+  }
+  nextId(prefix) {
+    const ids = this.allIds();
+    let candidate = prefix;
+    let suffix = 2;
+    while (ids.has(candidate)) candidate = `${prefix}-${suffix++}`;
+    return candidate;
+  }
+  addGroup() {
+    if (this.saving) return;
+    const groupId = this.nextId("group-new");
+    this.draft.groups.push({
+      id: groupId,
+      name: "New group",
+      origins: [],
+      rules: []
+    });
+    this.markChanged();
+    this.route = { kind: "group", groupId };
+    this.focusRequest = pointer("groups", this.draft.groups.length - 1, "name");
+    this.statusMessage = "Group added.";
+    this.render();
+  }
+  addRule(groupId) {
+    if (this.saving) return;
+    const group = this.groupById(groupId);
+    if (!group) return;
+    const ruleId = this.nextId("rule-new");
+    group.rules.push({
+      id: ruleId,
+      name: "New rule",
+      urlRegex: "",
+      origins: [],
+      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();
+  }
+  moveGroup(groupId, delta) {
+    if (this.saving) return;
+    const index = this.groupIndex(groupId);
+    const next = index + delta;
+    if (index < 0 || next < 0 || next >= this.draft.groups.length) return;
+    const [group] = this.draft.groups.splice(index, 1);
+    this.draft.groups.splice(next, 0, group);
+    this.markChanged();
+    this.focusRequest = pointer("groups", next, "name");
+    this.statusMessage = `Group moved to position ${next + 1} of ${this.draft.groups.length}.`;
+    this.render();
+  }
+  moveRule(groupId, ruleId, delta) {
+    if (this.saving) return;
+    const group = this.groupById(groupId);
+    if (!group) return;
+    const index = this.ruleIndex(group, ruleId);
+    const next = index + delta;
+    if (index < 0 || next < 0 || next >= group.rules.length) return;
+    const [rule] = group.rules.splice(index, 1);
+    group.rules.splice(next, 0, rule);
+    this.markChanged();
+    const groupIndex = this.groupIndex(groupId);
+    this.focusRequest = pointer("groups", groupIndex, "rules", next, "name");
+    this.statusMessage = `Rule moved to position ${next + 1} of ${group.rules.length}.`;
+    this.render();
+  }
+  requestRemoveGroup(groupId) {
+    if (this.saving) return;
+    const group = this.groupById(groupId);
+    if (!group) return;
+    this.confirmation = {
+      kind: "remove-group",
+      groupId,
+      name: displayName(group.name, "Unnamed group")
+    };
+    this.focusRequest = "confirm-cancel";
+    this.render();
+  }
+  requestRemoveRule(groupId, ruleId) {
+    if (this.saving) return;
+    const rule = this.ruleById(groupId, ruleId);
+    if (!rule) return;
+    this.confirmation = {
+      kind: "remove-rule",
+      groupId,
+      ruleId,
+      name: displayName(rule.name, "Unnamed rule")
+    };
+    this.focusRequest = "confirm-cancel";
+    this.render();
+  }
+  confirmRemoval() {
+    if (!this.confirmation || this.confirmation.kind === "cancel") return;
+    const confirmation = this.confirmation;
+    this.confirmation = void 0;
+    if (confirmation.kind === "remove-group") {
+      const index = this.groupIndex(confirmation.groupId);
+      if (index < 0) return;
+      this.draft.groups.splice(index, 1);
+      this.markChanged();
+      if (this.route.kind === "group" && this.route.groupId === confirmation.groupId) {
+        this.route = { kind: "project" };
+      }
+      this.statusMessage = `Group ${confirmation.name} removed.`;
+    } else {
+      const group = this.groupById(confirmation.groupId);
+      if (!group) return;
+      const index = this.ruleIndex(group, confirmation.ruleId);
+      if (index < 0) return;
+      group.rules.splice(index, 1);
+      this.markChanged();
+      this.statusMessage = `Rule ${confirmation.name} removed.`;
+    }
+    this.render();
+  }
+  requestCancel() {
+    if (this.saving) return;
+    if (!this.isDirty()) {
+      this.statusMessage = "No changes to discard.";
+      try {
+        this.options.onCancel?.();
+      } catch {
+        this.statusMessage = "The host could not complete cancel.";
+      }
+      this.render();
+      return;
+    }
+    this.confirmation = { kind: "cancel" };
+    this.focusRequest = "confirm-cancel";
+    this.render();
+  }
+  discardChanges() {
+    if (this.saving || !this.confirmation || this.confirmation.kind !== "cancel") {
+      return;
+    }
+    this.draft = cloneSnapshot(this.committed);
+    this.revision += 1;
+    this.errors = [];
+    this.conversionDiagnostics.clear();
+    this.confirmation = void 0;
+    this.statusMessage = "Changes discarded.";
+    try {
+      this.options.onCancel?.();
+    } catch {
+      this.statusMessage = "The host could not complete cancel.";
+    }
+    this.render();
+  }
+  async saveDraft() {
+    if (this.destroyed || this.saving || !this.isDirty()) return;
+    const validation = this.validateCurrent();
+    if (validation.length > 0) {
+      this.errors = validation;
+      this.statusMessage = `${validation.length} validation error${validation.length === 1 ? "" : "s"} found.`;
+      this.focusRequest = validation[0]?.path;
+      this.render();
+      return;
+    }
+    const revision = this.revision;
+    const snapshot = cloneSnapshot(this.draft);
+    this.saving = true;
+    this.statusMessage = "Saving...";
+    this.render();
+    let result;
+    try {
+      result = await this.options.save(
+        cloneSnapshot(snapshot)
+      );
+    } catch {
+      result = {
+        ok: false,
+        code: "editor.save-failed",
+        message: "The host could not save the project."
+      };
+    }
+    if (this.destroyed) return;
+    this.saving = false;
+    if (revision !== this.revision) {
+      this.statusMessage = "The save result was stale; current edits were kept.";
+      this.render();
+      return;
+    }
+    if (isSaveSuccess(result)) {
+      this.committed = cloneSnapshot(snapshot);
+      this.errors = [];
+      this.statusMessage = "Saved";
+      this.render();
+      return;
+    }
+    const failure = saveFailureDiagnostic(result);
+    this.errors = [failure];
+    this.statusMessage = failure.message;
+    this.focusRequest = failure.path;
+    this.render();
+  }
+  addGroupOrigin(groupId) {
+    const group = this.groupById(groupId);
+    if (!group || this.saving) return;
+    group.origins.push("");
+    this.markChanged();
+    this.focusRequest = pointer(
+      "groups",
+      this.groupIndex(groupId),
+      "origins",
+      group.origins.length - 1
+    );
+    this.render();
+  }
+  removeGroupOrigin(groupId, index) {
+    const group = this.groupById(groupId);
+    if (!group || this.saving || index < 0 || index >= group.origins.length)
+      return;
+    group.origins.splice(index, 1);
+    this.markChanged();
+    this.render();
+  }
+  addRuleOrigin(groupId, ruleId) {
+    const rule = this.ruleById(groupId, ruleId);
+    if (!rule || this.saving) return;
+    rule.origins.push("");
+    this.markChanged();
+    this.focusRequest = pointer(
+      "groups",
+      this.groupIndex(groupId),
+      "rules",
+      this.ruleIndex(this.groupById(groupId), ruleId),
+      "origins",
+      rule.origins.length - 1
+    );
+    this.render();
+  }
+  removeRuleOrigin(groupId, ruleId, index) {
+    const rule = this.ruleById(groupId, ruleId);
+    if (!rule || this.saving || index < 0 || index >= rule.origins.length)
+      return;
+    rule.origins.splice(index, 1);
+    this.markChanged();
+    this.render();
+  }
+  convertUrl(groupId, ruleId) {
+    const rule = this.ruleById(groupId, ruleId);
+    if (!rule || this.saving) return;
+    const input = this.host.querySelector(
+      `[data-url-source][data-rule-id="${CSS.escape(ruleId)}"]`
+    );
+    const value = input?.value ?? this.urlInputs.get(ruleId) ?? "";
+    this.urlInputs.set(ruleId, value);
+    const result = urlToExactRegex(value);
+    const rulePath = pointer(
+      "groups",
+      this.groupIndex(groupId),
+      "rules",
+      this.ruleIndex(this.groupById(groupId), ruleId)
+    );
+    const path = `${rulePath}/urlRegex`;
+    if (!result.ok) {
+      this.conversionDiagnostics.set(
+        ruleId,
+        diagnostic(
+          result.code,
+          path,
+          result.code === "editor.url-too-long" ? "The exact URL regular expression is too long." : "Enter a valid request URL without credentials or fragments."
+        )
+      );
+      this.errors = [...this.conversionDiagnostics.values()];
+      this.statusMessage = "The URL could not be converted.";
+      this.focusRequest = path;
+      this.render();
+      return;
+    }
+    if (setValueAtPath(this.draft, path, result.source)) this.markChanged();
+    this.statusMessage = "Exact URL regular expression created.";
+    this.focusRequest = path;
+    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) {
+      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;
+    const requestId = ++this.testRequestId;
+    this.testRunning = true;
+    this.statusMessage = "Running dry-run...";
+    this.render();
+    try {
+      const result = await this.options.dryRun(
+        this.getDraft(),
+        cases,
+        maxCases === void 0 ? void 0 : { maxCases }
+      );
+      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.`;
+    } catch (e) {
+      if (requestId !== this.testRequestId) return;
+      this.testRunning = false;
+      const message = e instanceof Error ? e.message : "Test failed";
+      this.statusMessage = `Test error: ${message}`;
+    }
+    this.render();
+  }
+  renderTestResults(result) {
+    const resultsSection = this.host.querySelector(
+      "[data-test-results]"
+    );
+    if (!resultsSection) return;
+    resultsSection.replaceChildren();
+    const heading = this.document.createElement("h3");
+    heading.textContent = "Results";
+    resultsSection.append(heading);
+    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})` : ""}`;
+        errorsList.append(item);
+      }
+      resultsSection.append(errorsList);
+    }
+    if (result.results.length === 0 && result.errors.length === 0) {
+      const empty = this.document.createElement("p");
+      empty.dataset.testEmpty = "true";
+      empty.textContent = "No valid URLs to test.";
+      resultsSection.append(empty);
+      return;
+    }
+    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 = `${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: "urlRegex", dim: rule.urlRegex },
+          { label: "effectiveOrigin", dim: rule.effectiveOrigin },
+          { 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);
+      }
+      resultsSection.append(card);
+    }
+  }
+  navigate(route, groupId) {
+    if (route === "project") {
+      this.route = { kind: "project" };
+    } else if (route === "test") {
+      this.route = { kind: "test" };
+    } else if (route === "group" && groupId && this.groupById(groupId)) {
+      this.route = { kind: "group", groupId };
+    } else {
+      return;
+    }
+    this.testRequestId += 1;
+    this.statusMessage = "";
+    this.render();
+  }
+  navigateToGroup(groupId) {
+    const groupIds = new Set(
+      this.draft.groups.map((group) => typeof group.id === "string" ? group.id : "").filter((id) => id.length > 0)
+    );
+    const resolved = resolveGroupRoute(groupId, groupIds);
+    if (resolved.kind === "group") {
+      this.route = { kind: "group", groupId: resolved.groupId };
+    } else {
+      this.route = { kind: "project" };
+    }
+    this.testRequestId += 1;
+    this.statusMessage = "";
+    this.render();
+  }
+  navigateToSearchResult(path) {
+    const segments = decodePointer(path);
+    if (segments?.[0] !== "groups") {
+      this.route = { kind: "project" };
+      this.searchQuery = "";
+      this.render();
+      return;
+    }
+    const groupIndex = arrayIndex(segments[1] ?? "");
+    const group = groupIndex === void 0 ? void 0 : this.draft.groups[groupIndex];
+    if (!group || typeof group.id !== "string") return;
+    const ruleIndex = arrayIndex(segments[3] ?? "");
+    const rule = ruleIndex === void 0 ? void 0 : group.rules[ruleIndex];
+    this.route = { kind: "group", groupId: group.id };
+    this.searchQuery = "";
+    this.statusMessage = "Jumped to rule.";
+    this.render();
+    if (rule && typeof rule.id === "string") {
+      const anchor = `rogatio-rule-${safeText(group.id)}-${safeText(rule.id)}`;
+      const card = this.document.getElementById(anchor);
+      if (card) {
+        card.scrollIntoView({ block: "start", behavior: "smooth" });
+        card.focus({ preventScroll: true });
+      }
+    }
+  }
+  navigateToPath(path) {
+    const segments = decodePointer(path);
+    if (segments?.[0] !== "groups") {
+      this.route = { kind: "project" };
+      this.focusRequest = path;
+      this.render();
+      return;
+    }
+    const groupIndex = arrayIndex(segments[1] ?? "");
+    const group = groupIndex === void 0 ? void 0 : this.draft.groups[groupIndex];
+    if (!group || typeof group.id !== "string") return;
+    this.route = { kind: "group", groupId: group.id };
+    this.focusRequest = path;
+    this.render();
+  }
+  currentGroupId() {
+    return this.route.kind === "group" ? this.route.groupId : void 0;
+  }
+  groupIndex(groupId) {
+    for (let index = 0; index < this.draft.groups.length; index += 1) {
+      if (this.draft.groups[index].id === groupId) return index;
+    }
+    return -1;
+  }
+  groupById(groupId) {
+    const index = this.groupIndex(groupId);
+    return index === -1 ? void 0 : this.draft.groups[index];
+  }
+  ruleIndex(group, ruleId) {
+    for (let index = 0; index < group.rules.length; index += 1) {
+      if (group.rules[index].id === ruleId) return index;
+    }
+    return -1;
+  }
+  ruleById(groupId, ruleId) {
+    const group = this.groupById(groupId);
+    if (!group) return void 0;
+    const index = this.ruleIndex(group, ruleId);
+    return index === -1 ? void 0 : group.rules[index];
+  }
+  render() {
+    if (this.destroyed) return;
+    this.previousFocus = this.captureFocus();
+    this.cleanupExtensions();
+    this.controlNumber = 0;
+    this.controls.clear();
+    this.extensionControls.clear();
+    if (this.route.kind === "group" && !this.groupById(this.route.groupId)) {
+      this.route = { kind: "project" };
+    }
+    this.renderHeader();
+    this.renderRail();
+    this.renderCommandBar();
+    this.form.replaceChildren();
+    if (this.route.kind === "project") {
+      this.renderProject();
+    } else if (this.route.kind === "test") {
+      this.renderTest();
+    } else {
+      this.renderGroup(this.route.groupId);
+    }
+    this.decorateExtensionControls();
+    this.renderSummary();
+    this.renderSearchResults();
+    this.renderConfirmation();
+    this.restoreFocus();
+    this.focusRequest = void 0;
+  }
+  renderHeader() {
+    this.header.replaceChildren();
+    const titleBlock = this.document.createElement("div");
+    const title = this.document.createElement("h1");
+    title.textContent = displayName(this.draft.name, "Project");
+    const dirty = this.document.createElement("p");
+    dirty.dataset.dirtyState = "true";
+    dirty.textContent = this.isDirty() ? "Unsaved changes" : "All changes saved";
+    titleBlock.append(title, dirty);
+    const mobileNav = this.document.createElement("label");
+    mobileNav.dataset.mobileRouteNav = "true";
+    mobileNav.textContent = "Project section";
+    const select = this.document.createElement("select");
+    select.dataset.mobileRoute = "true";
+    select.dataset.editorKey = "mobile-route";
+    const projectOption = this.document.createElement("option");
+    projectOption.value = "project";
+    projectOption.textContent = "Project";
+    select.append(projectOption);
+    for (const group of this.draft.groups) {
+      const option = this.document.createElement("option");
+      option.value = "group";
+      option.dataset.groupId = safeText(group.id);
+      option.textContent = displayName(group.name, "Unnamed group");
+      select.append(option);
+    }
+    const testOption = this.document.createElement("option");
+    testOption.value = "test";
+    testOption.textContent = "Test rules";
+    select.append(testOption);
+    if (this.route.kind === "project") {
+      select.value = "project";
+    } else if (this.route.kind === "test") {
+      select.value = "test";
+    } else {
+      const groupId = this.route.groupId;
+      const options = Array.from(select.options);
+      const option = options.find((value) => value.dataset.groupId === groupId);
+      if (option) select.value = "group";
+    }
+    mobileNav.append(select);
+    this.header.append(titleBlock, mobileNav);
+    this.status.textContent = this.statusMessage;
+    this.status.setAttribute("aria-busy", this.saving ? "true" : "false");
+  }
+  renderRail() {
+    this.rail.replaceChildren();
+    const heading = this.document.createElement("h2");
+    heading.dataset.editorVisuallyHidden = "true";
+    heading.textContent = "Project sections";
+    this.rail.append(heading);
+    const project = this.createButton("Project", "route:project");
+    project.dataset.route = "project";
+    project.dataset.editorKey = "route:project";
+    if (this.route.kind === "project")
+      project.setAttribute("aria-current", "page");
+    this.rail.append(project);
+    for (const group of this.draft.groups) {
+      const groupId = safeText(group.id);
+      const name = displayName(group.name, "Unnamed group");
+      const button = this.createButton(name, `route:group:${groupId}`);
+      button.dataset.route = "group";
+      button.dataset.groupId = groupId;
+      button.dataset.editorKey = `route:group:${groupId}`;
+      if (this.route.kind === "group" && this.route.groupId === groupId) {
+        button.setAttribute("aria-current", "page");
+      }
+      this.rail.append(button);
+    }
+    const testBtn = this.createButton("Test rules", "route:test");
+    testBtn.dataset.route = "test";
+    testBtn.dataset.editorKey = "route:test";
+    if (this.route.kind === "test")
+      testBtn.setAttribute("aria-current", "page");
+    this.rail.append(testBtn);
+    const searchWrap = this.document.createElement("div");
+    searchWrap.dataset.searchWrap = "true";
+    const searchLabel = this.document.createElement("label");
+    searchLabel.dataset.searchLabel = "true";
+    searchLabel.textContent = "Search project";
+    const search = this.document.createElement("input");
+    search.type = "search";
+    search.value = this.searchQuery;
+    search.dataset.search = "true";
+    search.dataset.editorKey = "search";
+    search.setAttribute("aria-label", "Search rules by name");
+    search.setAttribute(
+      "aria-expanded",
+      this.searchQuery.trim().length > 0 ? "true" : "false"
+    );
+    search.setAttribute("aria-controls", "rogatio-search-results");
+    searchLabel.append(search);
+    searchWrap.append(searchLabel, this.searchResults);
+    this.rail.append(searchWrap);
+  }
+  renderCommandBar() {
+    this.commandBar.replaceChildren();
+    this.commandBar.setAttribute("aria-busy", this.saving ? "true" : "false");
+    this.commandBar.append(
+      this.createCommandButton("Validate", "validate", this.saving),
+      this.createCommandButton("Save", "save", this.saving || !this.isDirty()),
+      this.createCommandButton("Cancel", "cancel", this.saving)
+    );
+    if (this.route.kind === "project") {
+      this.commandBar.append(
+        this.createCommandButton("Add group", "add-group", this.saving)
+      );
+      return;
+    }
+    if (this.route.kind === "test") {
+      this.commandBar.append(
+        this.createCommandButton("Run test", "test:run", this.saving)
+      );
+      return;
+    }
+    const group = this.groupById(this.route.groupId);
+    if (!group) return;
+    const index = this.groupIndex(this.route.groupId);
+    const name = displayName(group.name, "Unnamed group");
+    this.commandBar.append(
+      this.createCommandButton("Add rule", "add-rule", this.saving, {
+        groupId: this.route.groupId
+      }),
+      this.createCommandButton(
+        `Move group ${name} up`,
+        "move-group-up",
+        this.saving || index <= 0,
+        { groupId: this.route.groupId }
+      ),
+      this.createCommandButton(
+        `Move group ${name} down`,
+        "move-group-down",
+        this.saving || index >= this.draft.groups.length - 1,
+        { groupId: this.route.groupId }
+      ),
+      this.createCommandButton(
+        `Remove group ${name}`,
+        "remove-group",
+        this.saving,
+        {
+          groupId: this.route.groupId
+        }
+      )
+    );
+  }
+  renderProject() {
+    const heading = this.document.createElement("h2");
+    heading.textContent = "Project";
+    this.form.append(heading);
+    const fields = this.document.createElement("fieldset");
+    const legend = this.document.createElement("legend");
+    legend.textContent = "Project details";
+    fields.append(legend);
+    const fieldGrid = this.document.createElement("div");
+    fieldGrid.dataset.editorFields = "true";
+    const name = this.document.createElement("input");
+    name.type = "text";
+    name.maxLength = 100;
+    name.value = safeText(this.draft.name);
+    this.renderField(fieldGrid, "Project name", "/name", name);
+    const description = this.document.createElement("textarea");
+    description.maxLength = 1e3;
+    description.value = safeText(this.draft.description);
+    this.renderField(
+      fieldGrid,
+      "Project description",
+      "/description",
+      description
+    );
+    fields.append(fieldGrid);
+    this.form.append(fields);
+    const groups = this.document.createElement("section");
+    const groupsHeading = this.document.createElement("h2");
+    groupsHeading.textContent = "Groups";
+    groups.append(groupsHeading);
+    if (this.draft.groups.length === 0) {
+      const empty = this.document.createElement("p");
+      empty.textContent = "No groups yet.";
+      groups.append(empty);
+    } else {
+      const list = this.document.createElement("ul");
+      for (const group of this.draft.groups) {
+        const item = this.document.createElement("li");
+        const button = this.createButton(
+          `Edit group ${displayName(group.name, "Unnamed group")}`,
+          `route:group:${safeText(group.id)}`
+        );
+        button.dataset.route = "group";
+        button.dataset.groupId = safeText(group.id);
+        item.append(button);
+        list.append(item);
+      }
+      groups.append(list);
+    }
+    this.form.append(groups);
+  }
+  renderGroup(groupId) {
+    const group = this.groupById(groupId);
+    if (!group) return;
+    const groupIndex = this.groupIndex(groupId);
+    const heading = this.document.createElement("h2");
+    heading.textContent = displayName(group.name, "Unnamed group");
+    this.form.append(heading);
+    const settings = this.document.createElement("fieldset");
+    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);
+    this.renderOrigins(
+      this.form,
+      "Group origins",
+      group.origins,
+      "group",
+      groupId,
+      void 0,
+      groupIndex
+    );
+    const rulesSection = this.document.createElement("section");
+    const rulesHeading = this.document.createElement("h2");
+    rulesHeading.textContent = "Rules";
+    rulesSection.append(rulesHeading);
+    const list = this.document.createElement("div");
+    list.dataset.ruleList = groupId;
+    for (let ruleIndex = 0; ruleIndex < group.rules.length; ruleIndex += 1) {
+      list.append(
+        this.renderRule(group, group.rules[ruleIndex], groupIndex, ruleIndex)
+      );
+    }
+    if (group.rules.length === 0) {
+      const empty = this.document.createElement("p");
+      empty.textContent = "No rules yet.";
+      list.append(empty);
+    }
+    rulesSection.append(list);
+    this.form.append(rulesSection);
+  }
+  renderTest() {
+    const heading = this.document.createElement("h2");
+    heading.textContent = "Test rules (dry-run)";
+    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.";
+    this.form.append(description);
+    const panel = this.document.createElement("div");
+    panel.dataset.testPanel = "true";
+    const urlsFieldset = this.document.createElement("fieldset");
+    const urlsLegend = this.document.createElement("legend");
+    urlsLegend.textContent = "Test URLs";
+    urlsFieldset.append(urlsLegend);
+    const urlsField = this.document.createElement("div");
+    urlsField.dataset.editorField = "true";
+    const urlsLabel = this.document.createElement("label");
+    urlsLabel.textContent = "One test URL per line";
+    const urlsTextarea = this.document.createElement("textarea");
+    urlsTextarea.rows = 8;
+    urlsTextarea.placeholder = "https://example.com/page\nhttps://example.com/script.js\nhttps://other.com/";
+    urlsTextarea.value = this.testUrls;
+    urlsTextarea.dataset.testUrls = "true";
+    urlsLabel.append(urlsTextarea);
+    urlsField.append(urlsLabel);
+    urlsFieldset.append(urlsField);
+    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 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";
+    const methodSelect = this.document.createElement("select");
+    methodSelect.dataset.testMethod = "true";
+    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";
+    const rtSelect = this.document.createElement("select");
+    rtSelect.dataset.testResourceType = "true";
+    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";
+    runBtn.dataset.testRun = "true";
+    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) {
+      this.renderTestResults(this.testResult);
+    } else if (this.testRunning) {
+      const pending = this.document.createElement("p");
+      pending.dataset.testPending = "true";
+      pending.textContent = "Running dry-run...";
+      resultsSection.append(pending);
+    }
+  }
+  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";
+    card.dataset.ruleId = ruleId;
+    card.id = `rogatio-rule-${groupId}-${ruleId}`;
+    card.tabIndex = -1;
+    const heading = this.document.createElement("h3");
+    heading.textContent = ruleName;
+    card.append(heading);
+    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 for ${ruleName}`, `${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 for ${ruleName}`,
+      `${rulePath}/name`,
+      name
+    );
+    const regex = this.document.createElement("textarea");
+    regex.maxLength = F2_MAX_URL_REGEX_LENGTH2;
+    regex.value = safeText(rule.urlRegex);
+    this.renderField(
+      grid,
+      `URL regular expression for ${ruleName}`,
+      `${rulePath}/urlRegex`,
+      regex
+    );
+    const urlRow = this.document.createElement("div");
+    urlRow.dataset.editorUrlRow = "true";
+    const urlLabel = this.document.createElement("label");
+    urlLabel.textContent = `URL to match exactly for ${ruleName}`;
+    const urlInput = this.document.createElement("input");
+    urlInput.type = "url";
+    urlInput.dataset.urlSource = "true";
+    urlInput.dataset.ruleId = ruleId;
+    urlInput.dataset.editorKey = `url-source:${ruleId}`;
+    urlInput.value = this.urlInputs.get(ruleId) ?? "";
+    urlInput.disabled = this.saving;
+    urlLabel.append(urlInput);
+    const convert = this.createCommandButton(
+      `Convert URL to exact regex for ${ruleName}`,
+      "convert-url",
+      this.saving,
+      { groupId, ruleId }
+    );
+    urlRow.append(urlLabel, convert);
+    grid.append(urlRow);
+    fields.append(grid);
+    card.append(fields);
+    this.renderOrigins(
+      card,
+      "Rule origins",
+      rule.origins,
+      "rule",
+      groupId,
+      ruleId,
+      groupIndex,
+      ruleIndex
+    );
+    this.renderResourceTypes(card, rule, rulePath, ruleName);
+    const matcherFields = this.document.createElement("fieldset");
+    const matcherLegend = this.document.createElement("legend");
+    matcherLegend.textContent = "Request constraints";
+    matcherFields.append(matcherLegend);
+    const matcherGrid = this.document.createElement("div");
+    matcherGrid.dataset.editorFields = "true";
+    const priority = this.document.createElement("input");
+    priority.type = "number";
+    priority.min = "1";
+    priority.max = "1000";
+    priority.step = "1";
+    priority.value = typeof rule.priority === "number" && Number.isFinite(rule.priority) ? String(rule.priority) : safeText(rule.priority);
+    this.renderField(
+      matcherGrid,
+      `Priority for ${ruleName}`,
+      `${rulePath}/priority`,
+      priority
+    );
+    const method = this.document.createElement("select");
+    const anyMethod = this.document.createElement("option");
+    anyMethod.value = "";
+    anyMethod.textContent = "Any method";
+    method.append(anyMethod);
+    for (const value of HTTP_METHODS2) {
+      const option = this.document.createElement("option");
+      option.value = value;
+      option.textContent = value;
+      method.append(option);
+    }
+    method.value = safeText(rule.method);
+    this.renderField(
+      matcherGrid,
+      `Method for ${ruleName}`,
+      `${rulePath}/method`,
+      method
+    );
+    matcherFields.append(matcherGrid);
+    card.append(matcherFields);
+    if (this.extensions.length > 0) {
+      const currentType = this.extensions.find(
+        (e) => e.matches(rule)
+      )?.id ?? safeText(rule.type);
+      const typeFieldset = this.document.createElement("fieldset");
+      const typeLegend = this.document.createElement("legend");
+      typeLegend.textContent = `Rule type for ${ruleName}`;
+      const typeField = this.document.createElement("div");
+      typeField.dataset.editorField = "true";
+      const typeLabel = this.document.createElement("label");
+      typeLabel.textContent = "Rule type";
+      const typeSelect = this.document.createElement("select");
+      typeSelect.dataset.ruleTypeSelect = "true";
+      typeSelect.dataset.ruleTypePath = rulePath;
+      typeSelect.disabled = this.saving;
+      const noOption = this.document.createElement("option");
+      noOption.value = "";
+      noOption.textContent = "No action (choose a rule type)";
+      typeSelect.append(noOption);
+      for (const extension of this.extensions) {
+        const option = this.document.createElement("option");
+        option.value = extension.id;
+        option.textContent = extension.label;
+        typeSelect.append(option);
+      }
+      typeSelect.value = currentType ?? "";
+      typeLabel.append(typeSelect);
+      typeField.append(typeLabel);
+      typeFieldset.append(typeLegend, typeField);
+      card.append(typeFieldset);
+    }
+    const match = this.findExtension(rule, rulePath);
+    if (match.extension)
+      this.mountExtension(card, match.extension, groupId, ruleId, rulePath);
+    if (match.error) {
+      const extensionError = this.document.createElement("p");
+      extensionError.dataset.extensionError = "true";
+      extensionError.textContent = match.error.message;
+      card.append(extensionError);
+    }
+    const actions = this.document.createElement("div");
+    actions.dataset.ruleActions = "true";
+    actions.append(
+      this.createCommandButton(
+        `Move rule ${ruleName} up`,
+        "move-rule-up",
+        this.saving || ruleIndex <= 0,
+        { groupId, ruleId }
+      ),
+      this.createCommandButton(
+        `Move rule ${ruleName} down`,
+        "move-rule-down",
+        this.saving || ruleIndex >= group.rules.length - 1,
+        { groupId, ruleId }
+      ),
+      this.createCommandButton(
+        `Remove rule ${ruleName}`,
+        "remove-rule",
+        this.saving,
+        {
+          groupId,
+          ruleId
+        }
+      )
+    );
+    card.append(actions);
+    return card;
+  }
+  renderOrigins(parent, label, values, owner, groupId, ruleId, groupIndex, ruleIndex) {
+    const fieldset = this.document.createElement("fieldset");
+    const legend = this.document.createElement("legend");
+    legend.textContent = label;
+    fieldset.append(legend);
+    for (let index = 0; index < values.length; index += 1) {
+      const row = this.document.createElement("div");
+      row.dataset.editorOriginRow = "true";
+      const path = owner === "group" ? pointer("groups", groupIndex, "origins", index) : pointer(
+        "groups",
+        groupIndex,
+        "rules",
+        ruleIndex ?? 0,
+        "origins",
+        index
+      );
+      const input = this.document.createElement("input");
+      input.type = "text";
+      input.maxLength = 2048;
+      input.value = safeText(values[index]);
+      input.disabled = this.saving;
+      this.renderField(row, `Origin ${index + 1}`, path, input);
+      const remove = this.createCommandButton(
+        `Remove ${owner} origin ${index + 1}`,
+        owner === "group" ? "remove-group-origin" : "remove-rule-origin",
+        this.saving,
+        { groupId, ruleId, index: String(index) }
+      );
+      row.append(remove);
+      fieldset.append(row);
+    }
+    fieldset.append(
+      this.createCommandButton(
+        "Add origin",
+        owner === "group" ? "add-group-origin" : "add-rule-origin",
+        this.saving,
+        { groupId, ruleId }
+      )
+    );
+    parent.append(fieldset);
+  }
+  renderResourceTypes(parent, rule, rulePath, ruleName) {
+    const fieldset = this.document.createElement("fieldset");
+    const legend = this.document.createElement("legend");
+    legend.textContent = `Resource types for ${ruleName}`;
+    fieldset.append(legend);
+    const checks = this.document.createElement("div");
+    checks.dataset.editorChecks = "true";
+    for (const resourceType of RESOURCE_TYPES2) {
+      const label = this.document.createElement("label");
+      const input = this.document.createElement("input");
+      input.type = "checkbox";
+      input.dataset.resourcePath = `${rulePath}/resourceTypes`;
+      input.dataset.resourceType = resourceType;
+      input.checked = rule.resourceTypes.includes(resourceType);
+      input.disabled = this.saving;
+      label.append(input, this.document.createTextNode(resourceType));
+      checks.append(label);
+    }
+    fieldset.append(checks);
+    parent.append(fieldset);
+  }
+  mountExtension(parent, extension, groupId, ruleId, rulePath) {
+    const fieldset = this.document.createElement("fieldset");
+    const legend = this.document.createElement("legend");
+    legend.textContent = extension.label;
+    fieldset.append(legend);
+    const container = this.document.createElement("div");
+    container.dataset.extensionFields = extension.id;
+    fieldset.append(container);
+    parent.append(fieldset);
+    const context = {
+      document: this.document,
+      container,
+      rulePath,
+      getField: (name) => {
+        if (!isValidExtensionName(name)) return void 0;
+        const rule = this.ruleById(groupId, ruleId);
+        if (!rule) return void 0;
+        const resolved = extensionFieldParent(rule, name);
+        if (!resolved) return void 0;
+        const value = resolved.parent[resolved.key];
+        return value === void 0 ? void 0 : cloneSnapshot(value);
+      },
+      setField: (name, value) => {
+        if (!isValidExtensionName(name)) {
+          this.extensionErrors.set(
+            rulePath,
+            diagnostic(
+              "editor.extension-field",
+              rulePath,
+              "An additional rule field attempted to change a common field."
+            )
+          );
+          return;
+        }
+        const snapshot = snapshotOwnData(value);
+        if (!snapshot.valid) {
+          this.extensionErrors.set(
+            rulePath,
+            diagnostic(
+              "editor.extension-field",
+              rulePath,
+              "An additional rule field contained invalid data."
+            )
+          );
+          return;
+        }
+        const rule = this.ruleById(groupId, ruleId);
+        if (!rule || this.saving) return;
+        const resolved = extensionFieldParent(rule, name);
+        if (!resolved) {
+          this.extensionErrors.set(
+            rulePath,
+            diagnostic(
+              "editor.extension-field",
+              rulePath,
+              "An additional rule field could not be resolved."
+            )
+          );
+          return;
+        }
+        if (!Object.is(resolved.parent[resolved.key], snapshot.value)) {
+          Object.defineProperty(resolved.parent, resolved.key, {
+            configurable: true,
+            enumerable: true,
+            value: snapshot.value,
+            writable: true
+          });
+          this.markChanged();
+          this.render();
+        }
+      },
+      deleteField: (name) => {
+        if (!isValidExtensionName(name)) return;
+        const rule = this.ruleById(groupId, ruleId);
+        if (rule && Object.hasOwn(rule, name) && !this.saving) {
+          delete rule[name];
+          this.markChanged();
+          this.render();
+        }
+      },
+      registerControl: (fieldPath, control) => {
+        const firstSegment = decodePointer(fieldPath)?.[0] ?? "";
+        if (!fieldPath.startsWith("/") || !isHTMLElement(control) || control.ownerDocument !== this.document || !isValidExtensionName(firstSegment)) {
+          this.extensionErrors.set(
+            rulePath,
+            diagnostic(
+              "editor.extension-control",
+              rulePath,
+              "An additional rule field registered an invalid control."
+            )
+          );
+          return;
+        }
+        const absolutePath = `${rulePath}${fieldPath}`;
+        control.dataset.path = absolutePath;
+        this.extensionControls.set(absolutePath, control);
+      }
+    };
+    try {
+      const mount = extension.mount(context);
+      if (!mount || typeof mount.destroy !== "function") {
+        throw new Error("invalid extension mount");
+      }
+      this.extensionCleanups.push(() => {
+        try {
+          mount.destroy();
+        } catch {
+          this.extensionErrors.set(
+            rulePath,
+            diagnostic(
+              "editor.extension-failed",
+              rulePath,
+              "An additional rule field could not be cleaned up."
+            )
+          );
+        }
+      });
+    } catch {
+      this.extensionErrors.set(
+        rulePath,
+        diagnostic(
+          "editor.extension-failed",
+          rulePath,
+          "An additional rule field could not be rendered."
+        )
+      );
+      const message = this.document.createElement("p");
+      message.textContent = "Additional rule fields are unavailable.";
+      fieldset.append(message);
+    }
+  }
+  cleanupExtensions() {
+    const cleanups = this.extensionCleanups;
+    this.extensionCleanups = [];
+    for (const cleanup of cleanups) cleanup();
+  }
+  decorateExtensionControls() {
+    for (const [path, control] of this.extensionControls) {
+      const id = this.controlId(path);
+      control.id = id;
+      control.dataset.editorKey = path;
+      const fieldErrors = this.errors.filter((value) => value.path === path);
+      if (fieldErrors.length === 0) {
+        control.removeAttribute("aria-invalid");
+        continue;
+      }
+      control.setAttribute("aria-invalid", "true");
+      const error = this.document.createElement("div");
+      error.id = `${id}-error`;
+      error.dataset.editorFieldError = "true";
+      error.textContent = fieldErrors.map((value) => value.message).join(" ");
+      control.setAttribute("aria-describedby", error.id);
+      control.parentElement?.append(error);
+    }
+  }
+  renderField(parent, labelText, path, control) {
+    const field = this.document.createElement("div");
+    field.dataset.editorField = "true";
+    const label = this.document.createElement("label");
+    const id = this.controlId(path);
+    label.htmlFor = id;
+    label.textContent = labelText;
+    control.id = id;
+    control.dataset.path = path;
+    control.dataset.editorKey = path;
+    control.disabled = this.saving;
+    const errors = this.errors.filter((value) => value.path === path);
+    if (errors.length > 0) {
+      control.setAttribute("aria-invalid", "true");
+      const error = this.document.createElement("div");
+      error.id = `${id}-error`;
+      error.dataset.editorFieldError = "true";
+      error.textContent = errors.map((value) => value.message).join(" ");
+      control.setAttribute("aria-describedby", error.id);
+      field.append(label, control, error);
+    } else {
+      control.removeAttribute("aria-invalid");
+      field.append(label, control);
+    }
+    this.controls.set(path, control);
+    parent.append(field);
+  }
+  renderSummary() {
+    this.summary.replaceChildren();
+    this.summary.hidden = this.errors.length === 0;
+    if (this.errors.length === 0) return;
+    const heading = this.document.createElement("h2");
+    heading.textContent = "Fix these errors before saving";
+    const list = this.document.createElement("ul");
+    for (const error of this.errors) {
+      const item = this.document.createElement("li");
+      const button = this.document.createElement("button");
+      button.type = "button";
+      button.dataset.errorPath = error.path;
+      button.textContent = `${error.message} (${error.path || "project"})`;
+      item.append(button);
+      list.append(item);
+    }
+    this.summary.append(heading, list);
+  }
+  renderSearchResults() {
+    const root = this.searchResults;
+    root.replaceChildren();
+    root.hidden = this.searchQuery.trim().length === 0;
+    if (this.searchQuery.trim().length === 0) return;
+    root.setAttribute("role", "listbox");
+    root.setAttribute("aria-label", "Rule search results");
+    const results = this.searchResultsFor(this.searchQuery);
+    const count = this.document.createElement("p");
+    count.dataset.searchCount = "true";
+    count.textContent = `${results.length} rule${results.length === 1 ? "" : "s"} matching \u201C${this.searchQuery.trim()}\u201D.`;
+    const list = this.document.createElement("ul");
+    for (const result of results) {
+      const item = this.document.createElement("li");
+      item.setAttribute("role", "option");
+      const button = this.document.createElement("button");
+      button.type = "button";
+      button.dataset.searchResult = result.path;
+      button.textContent = result.label;
+      item.append(button);
+      list.append(item);
+    }
+    root.append(count, list);
+    if (results.length === 0) {
+      const empty = this.document.createElement("p");
+      empty.textContent = "No rules match that name.";
+      root.append(empty);
+    }
+  }
+  searchResultsFor(query) {
+    const needle = toSearchText(query);
+    if (!needle) return [];
+    const results = [];
+    for (let groupIndex = 0; groupIndex < this.draft.groups.length; groupIndex += 1) {
+      const group = this.draft.groups[groupIndex];
+      for (let ruleIndex = 0; ruleIndex < group.rules.length; ruleIndex += 1) {
+        const rule = group.rules[ruleIndex];
+        if (!toSearchText(rule.name).includes(needle)) continue;
+        results.push({
+          path: pointer("groups", groupIndex, "rules", ruleIndex),
+          label: `Rule: ${displayName(rule.name, "Unnamed rule")} \xB7 ${displayName(group.name, "Unnamed group")}`
+        });
+      }
+    }
+    return results;
+  }
+  renderConfirmation() {
+    const existing = this.host.querySelector("[data-editor-confirmation]");
+    existing?.remove();
+    if (!this.confirmation) return;
+    const overlay = this.document.createElement("div");
+    overlay.dataset.editorConfirmation = "true";
+    overlay.setAttribute("role", "presentation");
+    const dialog = this.document.createElement("section");
+    dialog.dataset.editorDialog = "true";
+    dialog.setAttribute("role", "alertdialog");
+    dialog.setAttribute("aria-modal", "true");
+    const title = this.document.createElement("h2");
+    title.id = `${this.instanceId}-confirmation-title`;
+    const message = this.document.createElement("p");
+    const actions = this.document.createElement("div");
+    actions.dataset.editorDialogActions = "true";
+    const cancel = this.document.createElement("button");
+    cancel.type = "button";
+    cancel.dataset.command = this.confirmation.kind === "cancel" ? "cancel-confirmation" : "remove-confirmation";
+    cancel.dataset.editorKey = "confirm-cancel";
+    cancel.textContent = this.confirmation.kind === "cancel" ? "Keep editing" : "Cancel removal";
+    const confirm = this.document.createElement("button");
+    confirm.type = "button";
+    confirm.dataset.command = this.confirmation.kind === "cancel" ? "confirm-cancel" : "confirm-remove";
+    confirm.dataset.editorKey = "confirm-action";
+    if (this.confirmation.kind === "cancel") {
+      title.textContent = "Discard unsaved changes?";
+      message.textContent = "Your current edits will be replaced by the last saved project.";
+      confirm.textContent = "Discard changes";
+    } else if (this.confirmation.kind === "remove-group") {
+      title.textContent = "Remove group?";
+      message.textContent = `Remove group ${this.confirmation.name} and its rules?`;
+      confirm.textContent = "Remove group";
+    } else {
+      title.textContent = "Remove rule?";
+      message.textContent = `Remove rule ${this.confirmation.name}?`;
+      confirm.textContent = "Remove rule";
+    }
+    dialog.setAttribute("aria-labelledby", title.id);
+    actions.append(cancel, confirm);
+    dialog.append(title, message, actions);
+    overlay.append(dialog);
+    this.host.append(overlay);
+  }
+  createButton(label, key) {
+    const button = this.document.createElement("button");
+    button.type = "button";
+    button.textContent = label;
+    button.dataset.editorKey = `button:${key}`;
+    return button;
+  }
+  createCommandButton(label, command, disabled, data = {}) {
+    const button = this.createButton(
+      label,
+      `command:${command}:${Object.values(data).join(":")}`
+    );
+    button.dataset.command = command;
+    button.disabled = disabled;
+    for (const [key, value] of Object.entries(data)) {
+      if (value !== void 0) button.dataset[key] = value;
+    }
+    return button;
+  }
+  controlId(path) {
+    const existing = Array.from(this.controls.entries()).find(
+      ([key]) => key === path
+    )?.[1].id;
+    if (existing) return existing;
+    return `${this.instanceId}-control-${++this.controlNumber}`;
+  }
+  captureFocus() {
+    const active = this.document.activeElement;
+    if (!(active instanceof HTMLElement) || !this.host.contains(active))
+      return void 0;
+    const key = active.dataset.editorKey;
+    if (!key) return void 0;
+    const selectionStart = active instanceof HTMLInputElement || active instanceof HTMLTextAreaElement ? active.selectionStart : void 0;
+    const selectionEnd = active instanceof HTMLInputElement || active instanceof HTMLTextAreaElement ? active.selectionEnd : void 0;
+    return { key, selectionStart, selectionEnd };
+  }
+  restoreFocus() {
+    const requested = this.focusRequest;
+    let key = requested;
+    if (requested && this.controls.has(requested)) key = requested;
+    if (!key && this.previousFocus) key = this.previousFocus.key;
+    if (!key) return;
+    let control = this.controls.get(key);
+    if (!control) {
+      const candidates = this.host.querySelectorAll("[data-editor-key]");
+      for (const candidate of candidates) {
+        if (candidate.dataset.editorKey === key) {
+          control = candidate;
+          break;
+        }
+      }
+    }
+    if (!control || control.hidden || control.getAttribute("aria-hidden") === "true")
+      return;
+    control.focus();
+    const focus = this.previousFocus;
+    if (focus && (control instanceof HTMLInputElement || control instanceof HTMLTextAreaElement)) {
+      if (focus.selectionStart !== void 0 && focus.selectionStart !== null) {
+        try {
+          control.setSelectionRange(
+            focus.selectionStart,
+            focus.selectionEnd ?? focus.selectionStart
+          );
+        } catch {
+        }
+      }
+    }
+  }
+};
+function isSaveSuccess(value) {
+  return isRecord5(value) && value.ok === true;
+}
+function saveFailureDiagnostic(value) {
+  if (!isRecord5(value)) {
+    return diagnostic(
+      "editor.save-failed",
+      "",
+      "The host could not save the project."
+    );
+  }
+  const code = typeof value.code === "string" ? value.code : "editor.save-failed";
+  const path = typeof value.path === "string" ? value.path : "";
+  const message = typeof value.message === "string" && value.message.length > 0 ? value.message : "The host could not save the project.";
+  return diagnostic(code, path, message);
+}
+function resolveGroupRoute(groupId, groupIds) {
+  if (typeof groupId === "string" && groupId.length > 0 && groupIds.has(groupId)) {
+    return { kind: "group", groupId };
+  }
+  return { kind: "project" };
+}
+function createEditor(options) {
+  if (!options || !isHTMLElement(options.root)) {
+    throw new EditorInitializationError([
+      diagnostic("editor.invalid-root", "", "The editor root is invalid.")
+    ]);
+  }
+  if (typeof options.validate !== "function" || typeof options.save !== "function") {
+    throw new EditorInitializationError([
+      diagnostic(
+        "editor.invalid-host",
+        "",
+        "The editor requires validation and save host functions."
+      )
+    ]);
+  }
+  const snapshot = snapshotOwnData(options.initialProject);
+  const project = snapshot.valid ? asDraftProject(snapshot.value) : void 0;
+  if (!snapshot.valid || !project) {
+    throw new EditorInitializationError([
+      diagnostic(
+        "editor.invalid-initial-project",
+        "",
+        "The initial project is invalid or unsafe."
+      )
+    ]);
+  }
+  const extensions = normalizeExtensions(options.ruleTypes);
+  return new EditorControllerImpl(options, project, extensions);
+}
+
+// packages/editor/src/rule-types/header.ts
+var FORBIDDEN_REQUEST_HEADERS2 = Object.freeze([
+  "accept-charset",
+  "accept-encoding",
+  "access-control-request-headers",
+  "access-control-request-method",
+  "connection",
+  "content-length",
+  "cookie",
+  "cookie2",
+  "date",
+  "dnt",
+  "expect",
+  "host",
+  "keep-alive",
+  "origin",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade",
+  "via"
+]);
+var FORBIDDEN_RESPONSE_HEADERS2 = Object.freeze([
+  "connection",
+  "content-encoding",
+  "content-length",
+  "date",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "set-cookie",
+  "set-cookie2",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade",
+  "via"
+]);
+var FORBIDDEN_REQUEST_PREFIXES2 = Object.freeze(["proxy-", "sec-"]);
+function isForbiddenHeader(name, direction) {
+  const normalized = name.toLowerCase();
+  const forbidden = direction === "request" ? FORBIDDEN_REQUEST_HEADERS2 : FORBIDDEN_RESPONSE_HEADERS2;
+  return forbidden.includes(normalized) || direction === "request" && FORBIDDEN_REQUEST_PREFIXES2.some(
+    (prefix) => normalized.startsWith(prefix)
+  );
+}
+var HEADER_DIRECTIONS = [
+  "request",
+  "response"
+];
+var HEADER_OPERATIONS = [
+  "set",
+  "append",
+  "remove"
+];
+function createSelect(document, options, value, onChange) {
+  const select = document.createElement("select");
+  for (const option of options) {
+    const opt = document.createElement("option");
+    opt.value = option;
+    opt.textContent = option;
+    if (option === value) opt.selected = true;
+    select.append(opt);
+  }
+  select.addEventListener("change", () => onChange(select.value));
+  return select;
+}
+function createInput(document, value, onChange, maxLength) {
+  const input = document.createElement("input");
+  input.type = "text";
+  input.value = value;
+  if (maxLength !== void 0) input.maxLength = maxLength;
+  input.addEventListener("input", () => onChange(input.value));
+  return input;
+}
+function createHeaderRuleType() {
+  return {
+    id: "header",
+    label: "Header",
+    matches(rule) {
+      return rule.type === "header";
+    },
+    mount(context) {
+      const document = context.document;
+      const fieldset = document.createElement("fieldset");
+      const legend = document.createElement("legend");
+      legend.textContent = "Header rule";
+      fieldset.append(legend);
+      const directionLabel = document.createElement("label");
+      directionLabel.textContent = "Direction";
+      const directionValue = context.getField("headerDirection") ?? "request";
+      const directionSelect = createSelect(
+        document,
+        HEADER_DIRECTIONS,
+        directionValue,
+        (value) => {
+          context.setField("headerDirection", value);
+        }
+      );
+      context.registerControl("/headerDirection", directionSelect);
+      directionLabel.append(directionSelect);
+      fieldset.append(directionLabel);
+      const operationLabel = document.createElement("label");
+      operationLabel.textContent = "Operation";
+      const operationValue = context.getField("headerOperation") ?? "set";
+      const operationSelect = createSelect(
+        document,
+        HEADER_OPERATIONS,
+        operationValue,
+        (value) => {
+          context.setField("headerOperation", value);
+        }
+      );
+      context.registerControl("/headerOperation", operationSelect);
+      operationLabel.append(operationSelect);
+      fieldset.append(operationLabel);
+      const nameLabel = document.createElement("label");
+      nameLabel.textContent = "Header name";
+      const nameValue = context.getField("headerName") ?? "";
+      const nameInput = createInput(
+        document,
+        nameValue,
+        (value) => {
+          context.setField("headerName", value);
+        },
+        256
+      );
+      context.registerControl("/headerName", nameInput);
+      nameLabel.append(nameInput);
+      fieldset.append(nameLabel);
+      const valueLabel = document.createElement("label");
+      valueLabel.textContent = "Header value";
+      const valueValue = context.getField("headerValue") ?? "";
+      const valueInput = createInput(
+        document,
+        valueValue,
+        (value) => {
+          context.setField("headerValue", value);
+        },
+        4096
+      );
+      context.registerControl("/headerValue", valueInput);
+      valueLabel.append(valueInput);
+      fieldset.append(valueLabel);
+      context.container.append(fieldset);
+      return {
+        destroy() {
+          directionSelect.removeEventListener("change", () => {
+          });
+          operationSelect.removeEventListener("change", () => {
+          });
+          nameInput.removeEventListener("input", () => {
+          });
+          valueInput.removeEventListener("input", () => {
+          });
+        }
+      };
+    },
+    validate(rule, rulePath) {
+      const diagnostics = [];
+      const direction = rule.headerDirection;
+      const operation = rule.headerOperation;
+      const headerName = rule.headerName;
+      const headerValue = rule.headerValue;
+      if (!direction || !HEADER_DIRECTIONS.includes(direction)) {
+        diagnostics.push({
+          code: "schema.invalid-value",
+          severity: "error",
+          path: `${rulePath}/headerDirection`,
+          message: 'Direction must be "request" or "response".'
+        });
+      }
+      if (!operation || !HEADER_OPERATIONS.includes(operation)) {
+        diagnostics.push({
+          code: "schema.invalid-value",
+          severity: "error",
+          path: `${rulePath}/headerOperation`,
+          message: 'Operation must be "set", "append", or "remove".'
+        });
+      }
+      if (typeof headerName !== "string" || headerName.length === 0 || headerName.length > 256) {
+        diagnostics.push({
+          code: "schema.out-of-range",
+          severity: "error",
+          path: `${rulePath}/headerName`,
+          message: "Header name must be 1-256 characters."
+        });
+      } else if (direction && isForbiddenHeader(headerName, direction)) {
+        diagnostics.push({
+          code: "extension.forbidden-header",
+          severity: "error",
+          path: `${rulePath}/headerName`,
+          message: `Header "${headerName}" is forbidden for ${direction} headers.`
+        });
+      }
+      if ((operation === "set" || operation === "append") && typeof headerValue !== "string") {
+        diagnostics.push({
+          code: "schema.required",
+          severity: "error",
+          path: `${rulePath}/headerValue`,
+          message: "Header value is required for set and append operations."
+        });
+      } else if ((operation === "set" || operation === "append") && typeof headerValue === "string" && headerValue.length > 4096) {
+        diagnostics.push({
+          code: "schema.out-of-range",
+          severity: "error",
+          path: `${rulePath}/headerValue`,
+          message: "Header value must be at most 4096 characters."
+        });
+      }
+      if (operation === "remove" && headerValue !== void 0) {
+        diagnostics.push({
+          code: "schema.unexpected",
+          severity: "error",
+          path: `${rulePath}/headerValue`,
+          message: "Header value must not be provided for remove operation."
+        });
+      }
+      return diagnostics;
+    }
+  };
+}
+
+// packages/editor/src/rule-types/redirect.ts
+function createRedirectRuleType() {
+  return {
+    id: "redirect",
+    label: "Redirect",
+    matches(rule) {
+      return rule.type === "redirect";
+    },
+    mount(context) {
+      const document = context.document;
+      const label = document.createElement("label");
+      label.textContent = "Redirect destination URL";
+      const input = document.createElement("input");
+      input.type = "text";
+      input.maxLength = 2048;
+      const existing = context.getField("redirect.destination");
+      input.value = typeof existing === "string" ? existing : "";
+      input.addEventListener("input", () => {
+        context.setField("redirect.destination", input.value);
+      });
+      context.registerControl("/redirect/destination", input);
+      label.append(input);
+      context.container.append(label);
+      return {
+        destroy() {
+          input.removeEventListener("input", () => {
+          });
+        }
+      };
+    },
+    validate(rule, rulePath) {
+      const redirect = rule.redirect;
+      const destination = redirect !== null && typeof redirect === "object" && typeof redirect.destination === "string" ? redirect.destination : "";
+      const urlRegex = typeof rule.urlRegex === "string" ? rule.urlRegex : "";
+      const issues = validateRedirectDestination(destination, urlRegex);
+      return issues.map((issue) => ({
+        code: `schema.${issue.code}`,
+        severity: "error",
+        path: `${rulePath}/redirect/destination`,
+        message: issue.message
+      }));
+    }
+  };
+}
+export {
+  EditorInitializationError,
+  builtInRuleTypes,
+  createEditor,
+  createHeaderRuleType,
+  createMockRuleType,
+  createRedirectRuleType,
+  createRequestBodyRuleType,
+  createResponseBodyRuleType,
+  queryRuleType,
+  urlToExactRegex
+};