@rogatio/cli 5.8.3 → 5.9.0

package/dist/editor/index.js

@@ -27,6 +27,7 @@ var LIMITS = Object.freeze({
   maxMockDelayMs: 3e4,
   maxMockFilePathLength: 2048,
   maxResponseBodyReplacements: 64,
+  maxResponseBodyBytes: 4 * 1024 * 1024,
   maxResponseBodyPatternLength: 2048,
   maxResponseBodyReplacementLength: 4096,
   maxRequestBodyBytes: 4 * 1024 * 1024,
@@ -213,6 +214,21 @@ var HTTP_METHODS = Object.freeze([
   "CONNECT",
   "TRACE"
 ]);
+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;
+}
 
 // packages/editor/src/ai-assist-panel.ts
 function createAIAssistPanel(_container, _editor, onApply, onClose) {
@@ -561,307 +577,261 @@ function createAIAssistPanel(_container, _editor, onApply, onClose) {
   };
 }
 
-// packages/editor/src/rule-types/mock.ts
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+// packages/editor/src/rule-types/dom.ts
+function normalizeOption(option) {
+  if (typeof option === "string") {
+    return { value: option, label: option };
+  }
+  return option;
 }
-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;
+function createSelect(document2, options, value, onChange) {
+  const select = document2.createElement("select");
+  for (const option of options) {
+    const { value: optionValue, label } = normalizeOption(option);
+    const opt = document2.createElement("option");
+    opt.value = optionValue;
+    opt.textContent = label;
+    if (optionValue === value) opt.selected = true;
+    select.append(opt);
   }
-  return action;
+  select.addEventListener("change", () => onChange(select.value));
+  return select;
 }
-function stable(diagnostics) {
-  return [...diagnostics].sort(
-    (a, b) => a.path === b.path ? a.code.localeCompare(b.code) : a.path.localeCompare(b.path)
+function createTextInput(document2, value, onChange, maxLength) {
+  const input = document2.createElement("input");
+  input.type = "text";
+  input.value = value;
+  if (maxLength !== void 0) input.maxLength = maxLength;
+  input.addEventListener("input", () => onChange(input.value));
+  return input;
+}
+
+// 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)
   );
 }
-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;
+var HEADER_DIRECTIONS = [
+  "request",
+  "response"
+];
+var HEADER_OPERATIONS = [
+  "set",
+  "append",
+  "remove"
+];
+var HEADER_EDITOR_OPERATIONS = Object.freeze(["set", "remove"]);
+function operationOptions(current) {
+  if (current === "append") {
+    return ["set", "append", "remove"];
   }
-  return false;
+  return HEADER_EDITOR_OPERATIONS;
 }
-function createMockRuleType() {
+function createHeaderRuleType() {
   return {
-    id: "mock",
-    label: "Mock response",
-    actionField: "mock",
+    id: "header",
+    label: "Header",
     matches(rule) {
-      const type = rule.type;
-      if (type === "mock") return true;
-      if (type !== void 0) return false;
-      return asMockAction(rule.mock) !== void 0;
+      return rule.type === "header";
+    },
+    defaultFields() {
+      return {
+        headerDirection: "request",
+        headerOperation: "set",
+        headerName: "",
+        headerValue: ""
+      };
+    },
+    mount(context) {
+      const document2 = context.document;
+      const fieldset = document2.createElement("fieldset");
+      const legend = document2.createElement("legend");
+      legend.textContent = "Header rule";
+      fieldset.append(legend);
+      const directionLabel = document2.createElement("label");
+      directionLabel.textContent = "Direction";
+      const directionValue = context.getField("headerDirection") ?? "request";
+      const directionSelect = createSelect(
+        document2,
+        HEADER_DIRECTIONS,
+        directionValue,
+        (value) => {
+          context.setField("headerDirection", value);
+        }
+      );
+      context.registerControl("/headerDirection", directionSelect);
+      directionLabel.append(directionSelect);
+      fieldset.append(directionLabel);
+      const operationLabel = document2.createElement("label");
+      operationLabel.textContent = "Operation";
+      let operationValue = context.getField("headerOperation") ?? "set";
+      const valueLabel = document2.createElement("label");
+      valueLabel.textContent = "Header value";
+      const syncValueVisibility = () => {
+        const showValue = operationValue === "set" || operationValue === "append";
+        valueLabel.hidden = !showValue;
+      };
+      const operationSelect = createSelect(
+        document2,
+        operationOptions(operationValue),
+        operationValue,
+        (value) => {
+          operationValue = value;
+          context.setField("headerOperation", value);
+          if (value === "remove") {
+            context.deleteField("headerValue");
+          }
+          syncValueVisibility();
+        }
+      );
+      context.registerControl("/headerOperation", operationSelect);
+      operationLabel.append(operationSelect);
+      fieldset.append(operationLabel);
+      const nameLabel = document2.createElement("label");
+      nameLabel.textContent = "Header name";
+      const nameValue = context.getField("headerName") ?? "";
+      const nameInput = createTextInput(
+        document2,
+        nameValue,
+        (value) => {
+          context.setField("headerName", value);
+        },
+        256
+      );
+      context.registerControl("/headerName", nameInput);
+      nameLabel.append(nameInput);
+      fieldset.append(nameLabel);
+      const valueValue = context.getField("headerValue") ?? "";
+      const valueInput = createTextInput(
+        document2,
+        valueValue,
+        (value) => {
+          context.setField("headerValue", value);
+        },
+        4096
+      );
+      context.registerControl("/headerValue", valueInput);
+      valueLabel.append(valueInput);
+      fieldset.append(valueLabel);
+      syncValueVisibility();
+      context.container.append(fieldset);
+      return {
+        destroy() {
+          directionSelect.removeEventListener("change", () => {
+          });
+          operationSelect.removeEventListener("change", () => {
+          });
+          nameInput.removeEventListener("input", () => {
+          });
+          valueInput.removeEventListener("input", () => {
+          });
+        }
+      };
     },
     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) {
+      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: "editor.mock-status-range",
+          code: "schema.invalid-value",
           severity: "error",
-          path: `${rulePath}/mock/status`,
-          message: `Mock status must be an integer between ${LIMITS.minMockStatus} and ${LIMITS.maxMockStatus}.`
+          path: `${rulePath}/headerDirection`,
+          message: 'Direction must be "request" or "response".'
         });
       }
-      const hasBody = typeof mock.body === "string";
-      const hasFile = typeof mock.file === "string";
-      if (hasBody === hasFile) {
+      if (!operation || !HEADER_OPERATIONS.includes(operation)) {
         diagnostics.push({
-          code: "editor.mock-body-source",
+          code: "schema.invalid-value",
           severity: "error",
-          path: `${rulePath}/mock`,
-          message: "A mock rule must set exactly one of body or file."
+          path: `${rulePath}/headerOperation`,
+          message: 'Operation must be "set", "append", or "remove".'
         });
-      } 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)) {
+      if (typeof headerName !== "string" || headerName.length === 0 || headerName.length > 256) {
         diagnostics.push({
-          code: "editor.mock-delay-range",
+          code: "schema.out-of-range",
           severity: "error",
-          path: `${rulePath}/mock/delayMs`,
-          message: `Mock delay must be an integer between 0 and ${LIMITS.maxMockDelayMs} milliseconds.`
+          path: `${rulePath}/headerName`,
+          message: "Header name must be 1-256 characters."
         });
-      }
-      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.`
-            });
-          }
+      } 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.`
         });
       }
-      return stable(diagnostics);
-    },
-    mount(context) {
-      const { document: document2, 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 = document2.createElement("label");
-        statusLabel.textContent = "Status";
-        const statusInput = document2.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) });
+      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."
         });
-        context.registerControl("/mock/status", statusInput);
-        statusLabel.append(statusInput);
-        const delayLabel = document2.createElement("label");
-        delayLabel.textContent = "Delay (ms)";
-        const delayInput = document2.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);
+      } 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."
         });
-        context.registerControl("/mock/delayMs", delayInput);
-        delayLabel.append(delayInput);
-        const sourceLabel = document2.createElement("label");
-        sourceLabel.textContent = "Body source";
-        const sourceSelect = document2.createElement("select");
-        sourceSelect.dataset.editorField = "true";
-        const bodyOption = document2.createElement("option");
-        bodyOption.value = "body";
-        bodyOption.textContent = "Inline body";
-        const fileOption = document2.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 = document2.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 });
+      }
+      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."
         });
-        context.registerControl("/mock/body", bodyArea);
-        const fileLabel = document2.createElement("label");
-        fileLabel.textContent = "File path";
-        const fileInput = document2.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 = document2.createElement("fieldset");
-        const headersLegend = document2.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 = document2.createElement("div");
-            row.dataset.mockHeaderRow = String(index);
-            const nameLabel = document2.createElement("label");
-            nameLabel.textContent = "Name";
-            const nameInput = document2.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 = document2.createElement("label");
-            valueLabel.textContent = "Value";
-            const valueInput = document2.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 = document2.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 = document2.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: "" };
+      }
+      return diagnostics;
     }
   };
 }
@@ -870,17 +840,33 @@ function createMockRuleType() {
 var MAX_QUERY_NAME_LENGTH = 256;
 var MAX_QUERY_VALUE_LENGTH = 2048;
 var MAX_QUERY_PARAMS = 64;
-function isRecord2(value) {
+var QUERY_OPERATIONS = Object.freeze(["set", "remove"]);
+function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function asQueryAction(value) {
-  if (!isRecord2(value)) return void 0;
+  if (!isRecord(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) {
+function paramOperation(param) {
+  return param.operation ?? "set";
+}
+function buildSetParam(name, value) {
+  return { name, operation: "set", value };
+}
+function buildRemoveParam(name) {
+  return { name, operation: "remove" };
+}
+function normalizeParam(param) {
+  if (paramOperation(param) === "remove") {
+    return buildRemoveParam(param.name);
+  }
+  return buildSetParam(param.name, param.value ?? "");
+}
+function stable(diagnostics) {
   return [...diagnostics].sort(
     (a, b) => a.path === b.path ? a.code.localeCompare(b.code) : a.path.localeCompare(b.path)
   );
@@ -889,7 +875,7 @@ var queryRuleType = {
   id: "query",
   label: "Query parameters",
   matches(rule) {
-    return asQueryAction(rule.action) !== void 0;
+    return rule.type === "query";
   },
   validate(rule, rulePath) {
     const action = asQueryAction(rule.action);
@@ -902,7 +888,7 @@ var queryRuleType = {
         path: `${rulePath}/action/params`,
         message: "Query rules need at least one parameter."
       });
-      return stable2(diagnostics);
+      return stable(diagnostics);
     }
     if (action.params.length > MAX_QUERY_PARAMS) {
       diagnostics.push({
@@ -916,6 +902,7 @@ var queryRuleType = {
     action.params.forEach((param, index) => {
       const namePath = `${rulePath}/action/params/${index}/name`;
       const valuePath = `${rulePath}/action/params/${index}/value`;
+      const operation = paramOperation(param);
       if (typeof param?.name !== "string" || param.name.length === 0) {
         diagnostics.push({
           code: "editor.query-param-name-required",
@@ -931,19 +918,28 @@ var queryRuleType = {
           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) {
+      if (operation === "set") {
+        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."
+          });
+        }
+      } else if (param?.value !== void 0) {
         diagnostics.push({
-          code: "editor.query-param-value-too-long",
+          code: "schema.unexpected",
           severity: "error",
           path: valuePath,
-          message: "Query parameter value is too long."
+          message: "Query parameter value must not be provided for remove operation."
         });
       }
       if (typeof param?.name === "string" && seen.has(param.name)) {
@@ -956,7 +952,7 @@ var queryRuleType = {
       }
       if (typeof param?.name === "string") seen.add(param.name);
     });
-    return stable2(diagnostics);
+    return stable(diagnostics);
   },
   mount(context) {
     const { document: document2, container } = context;
@@ -971,6 +967,7 @@ var queryRuleType = {
       current.params.forEach((param, index) => {
         const row = document2.createElement("div");
         row.dataset.queryParamRow = String(index);
+        const operation = paramOperation(param);
         const nameLabel = document2.createElement("label");
         nameLabel.textContent = "Name";
         const nameInput = document2.createElement("input");
@@ -980,29 +977,57 @@ var queryRuleType = {
         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
-          );
+          const params = c.params.map((p, i) => {
+            if (i !== index) return p;
+            return normalizeParam({ ...p, name: nameInput.value });
+          });
           setAction({ type: "query", params });
         });
         context.registerControl(`/action/params/${index}/name`, nameInput);
         nameLabel.append(nameInput);
+        const operationLabel = document2.createElement("label");
+        operationLabel.textContent = "Operation";
+        const operationSelect = createSelect(
+          document2,
+          QUERY_OPERATIONS,
+          operation,
+          (value) => {
+            const c = getCurrent();
+            if (c === void 0) return;
+            const params = c.params.map((p, i) => {
+              if (i !== index) return p;
+              if (value === "remove") {
+                return buildRemoveParam(p.name);
+              }
+              return buildSetParam(p.name, p.value ?? "");
+            });
+            setAction({ type: "query", params });
+            render();
+          }
+        );
+        operationSelect.dataset.queryParamOperation = String(index);
+        context.registerControl(
+          `/action/params/${index}/operation`,
+          operationSelect
+        );
+        operationLabel.append(operationSelect);
         const valueLabel = document2.createElement("label");
         valueLabel.textContent = "Value";
         const valueInput = document2.createElement("input");
         valueInput.type = "text";
-        valueInput.value = param.value;
+        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
+            (p, i) => i === index ? buildSetParam(p.name, valueInput.value) : p
           );
           setAction({ type: "query", params });
         });
         context.registerControl(`/action/params/${index}/value`, valueInput);
         valueLabel.append(valueInput);
+        valueLabel.hidden = operation === "remove";
         const remove = document2.createElement("button");
         remove.type = "button";
         remove.textContent = "Remove";
@@ -1012,8 +1037,9 @@ var queryRuleType = {
           if (c === void 0) return;
           const params = c.params.filter((_, i) => i !== index);
           setAction({ type: "query", params });
+          render();
         });
-        row.append(nameLabel, valueLabel, remove);
+        row.append(nameLabel, operationLabel, valueLabel, remove);
         container.append(row);
       });
       const add = document2.createElement("button");
@@ -1025,8 +1051,9 @@ var queryRuleType = {
         if (c === void 0) return;
         setAction({
           type: "query",
-          params: [...c.params, { name: "", value: "" }]
+          params: [...c.params, buildSetParam("", "")]
         });
+        render();
       });
       container.append(add);
     };
@@ -1035,34 +1062,71 @@ var queryRuleType = {
     } };
   },
   defaultAction() {
-    return { type: "query", params: [{ name: "", value: "" }] };
+    return {
+      type: "query",
+      params: [buildSetParam("", "")]
+    };
   }
 };
 
+// packages/editor/src/rule-types/redirect.ts
+function createRedirectRuleType() {
+  return {
+    id: "redirect",
+    label: "Redirect",
+    actionField: "redirect",
+    matches(rule) {
+      return rule.type === "redirect";
+    },
+    defaultAction() {
+      return { destination: "" };
+    },
+    mount(context) {
+      const document2 = context.document;
+      const label = document2.createElement("label");
+      label.textContent = "Redirect destination URL";
+      const input = document2.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
+      }));
+    }
+  };
+}
+
 // packages/editor/src/rule-types/request-body.ts
-function isRecord3(value) {
+function isRecord2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function requestBodyOf(value) {
-  if (!isRecord3(value) || !("mode" in value)) return void 0;
+  if (!isRecord2(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) {
+function stable2(values) {
   return [...values].sort(
     (left, right) => left.path.localeCompare(right.path) || left.code.localeCompare(right.code)
   );
@@ -1178,7 +1242,7 @@ function createRequestBodyRuleType() {
           message: 'Request-body rules require exactly one resource type: "xmlhttprequest".'
         });
       }
-      return stable3(diagnostics);
+      return stable2(diagnostics);
     },
     mount(context) {
       const { document: document2, container } = context;
@@ -1186,26 +1250,25 @@ function createRequestBodyRuleType() {
         const current = requestBodyOf(context.getField("requestBody"));
         container.replaceChildren();
         if (current === void 0) return;
-        const modeSelect = document2.createElement("select");
-        modeSelect.value = current.mode;
-        const replaceOption = document2.createElement("option");
-        replaceOption.value = "replace";
-        replaceOption.textContent = "Replace body";
-        const regexOption = document2.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;
+        const modeSelect = createSelect(
+          document2,
+          [
+            { value: "replace", label: "Replace body" },
+            { value: "regex", label: "Regex replace" }
+          ],
+          current.mode,
+          (mode) => {
+            const next = { ...current, mode };
+            if (mode === "replace") {
+              delete next.pattern;
+              delete next.replacement;
+            } else {
+              delete next.body;
+            }
+            context.setField("requestBody", next);
+            render();
           }
-          context.setField("requestBody", next);
-          render();
-        });
+        );
         context.registerControl("/requestBody/mode", modeSelect);
         container.append(modeSelect);
         if (current.mode === "replace") {
@@ -1252,71 +1315,135 @@ function createRequestBodyRuleType() {
 }
 
 // packages/editor/src/rule-types/response-body.ts
-function isRecord4(value) {
+function isRecord3(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 responseBodyOf(value) {
+  if (!isRecord3(value)) return void 0;
+  if (value.mode === "replace") {
+    return { mode: "replace", body: value.body };
+  }
+  if (value.mode === "regex" && Array.isArray(value.replacements)) {
+    return {
+      mode: "regex",
+      replacements: value.replacements
+    };
+  }
+  if (Array.isArray(value.replacements)) {
+    return {
+      mode: "regex",
+      replacements: value.replacements
+    };
+  }
+  return void 0;
 }
-function stable4(values) {
+function stable3(values) {
   return [...values].sort(
     (left, right) => left.path.localeCompare(right.path) || left.code.localeCompare(right.code)
   );
 }
+function validateRegexReplacements(replacements, rulePath) {
+  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 diagnostics;
+}
 function createResponseBodyRuleType() {
   return {
     id: "response-body",
-    label: "Response body rewrite",
+    label: "Response body",
     actionField: "responseBody",
     matches(rule) {
-      return rule.type === "response-body" || replacementsOf(rule.responseBody) !== void 0;
+      return rule.type === "response-body" || responseBodyOf(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.`
-        });
+      const raw = rule.responseBody;
+      if (isRecord3(raw) && "mode" in raw && raw.mode !== "replace" && raw.mode !== "regex") {
+        return stable3([
+          {
+            code: "editor.response-body-mode",
+            severity: "error",
+            path: `${rulePath}/responseBody/mode`,
+            message: 'responseBody.mode must be "replace" or "regex"'
+          }
+        ]);
       }
-      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 {
+      const action = responseBodyOf(raw);
+      if (action === void 0) {
+        if (isRecord3(raw) && raw.mode === "regex") {
+          return stable3(validateRegexReplacements([], rulePath));
+        }
+        return [];
+      }
+      const diagnostics = [];
+      if (action.mode === "replace") {
+        if (typeof action.body !== "string") {
           diagnostics.push({
-            code: "editor.response-body-pattern",
+            code: "editor.response-body-replace-body",
             severity: "error",
-            path: patternPath,
-            message: "Replacement pattern must be a valid bounded regular expression."
+            path: `${rulePath}/responseBody/body`,
+            message: "Replace mode requires a body string."
           });
-        }
-        if (typeof entry?.replacement !== "string" || entry.replacement.length > LIMITS.maxResponseBodyReplacementLength) {
+        } else if (action.body.length > LIMITS.maxResponseBodyBytes) {
+          diagnostics.push({
+            code: "editor.response-body-replace-body",
+            severity: "error",
+            path: `${rulePath}/responseBody/body`,
+            message: `Replace body exceeds the maximum size of ${LIMITS.maxResponseBodyBytes} bytes.`
+          });
+        } else if (hasLoneSurrogate(action.body)) {
           diagnostics.push({
-            code: "editor.response-body-replacement",
+            code: "editor.response-body-lone-surrogate",
             severity: "error",
-            path: replacementPath,
-            message: "Replacement text exceeds the permitted size."
+            path: `${rulePath}/responseBody/body`,
+            message: "Replace body must not contain lone UTF-16 surrogates."
           });
         }
-      });
-      return stable4(diagnostics);
+      } else {
+        diagnostics.push(
+          ...validateRegexReplacements(action.replacements, rulePath)
+        );
+      }
+      return stable3(diagnostics);
     },
     mount(context) {
       const { document: document2, container } = context;
-      const render = () => {
-        const current = replacementsOf(context.getField("responseBody"));
-        container.replaceChildren();
-        if (current === void 0) return;
-        current.forEach((entry, index) => {
+      const currentReplacements = () => {
+        const action = responseBodyOf(context.getField("responseBody"));
+        return action?.mode === "regex" ? action.replacements : [];
+      };
+      const renderRegexRows = (onUpdate) => {
+        currentReplacements().forEach((entry, index) => {
           const row = document2.createElement("div");
           row.dataset.responseBodyReplacement = String(index);
           const pattern = document2.createElement("input");
@@ -1324,11 +1451,9 @@ function createResponseBodyRuleType() {
           pattern.value = entry.pattern;
           pattern.placeholder = "Pattern";
           pattern.addEventListener("input", () => {
-            const next = [
-              ...replacementsOf(context.getField("responseBody")) ?? []
-            ];
+            const next = [...currentReplacements()];
             next[index] = { ...next[index], pattern: pattern.value };
-            context.setField("responseBody", { replacements: next });
+            onUpdate(next);
           });
           context.registerControl(
             `/responseBody/replacements/${index}/pattern`,
@@ -1339,11 +1464,9 @@ function createResponseBodyRuleType() {
           replacement.value = entry.replacement;
           replacement.placeholder = "Replacement";
           replacement.addEventListener("input", () => {
-            const next = [
-              ...replacementsOf(context.getField("responseBody")) ?? []
-            ];
+            const next = [...currentReplacements()];
             next[index] = { ...next[index], replacement: replacement.value };
-            context.setField("responseBody", { replacements: next });
+            onUpdate(next);
           });
           context.registerControl(
             `/responseBody/replacements/${index}/replacement`,
@@ -1353,8 +1476,11 @@ function createResponseBodyRuleType() {
           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 });
+            onUpdate(
+              currentReplacements().filter(
+                (_, itemIndex) => itemIndex !== index
+              )
+            );
             render();
           });
           row.append(pattern, replacement, remove);
@@ -1364,29 +1490,81 @@ function createResponseBodyRuleType() {
         add.type = "button";
         add.textContent = "Add replacement";
         add.addEventListener("click", () => {
-          const next = [
-            ...replacementsOf(context.getField("responseBody")) ?? [],
+          onUpdate([
+            ...currentReplacements(),
             { pattern: "", replacement: "" }
-          ];
-          context.setField("responseBody", { replacements: next });
+          ]);
           render();
         });
         container.append(add);
       };
+      const render = () => {
+        const current = responseBodyOf(context.getField("responseBody"));
+        container.replaceChildren();
+        if (current === void 0) return;
+        const modeSelect = createSelect(
+          document2,
+          [
+            { value: "replace", label: "Replace body" },
+            { value: "regex", label: "Regex rewrite" }
+          ],
+          current.mode,
+          (mode) => {
+            if (mode === "replace") {
+              context.setField("responseBody", { mode: "replace", body: "" });
+            } else {
+              context.setField("responseBody", {
+                mode: "regex",
+                replacements: [{ pattern: "", replacement: "" }]
+              });
+            }
+            render();
+          }
+        );
+        context.registerControl("/responseBody/mode", modeSelect);
+        container.append(modeSelect);
+        if (current.mode === "replace") {
+          const bodyInput = document2.createElement("textarea");
+          bodyInput.value = current.body ?? "";
+          bodyInput.placeholder = "Replacement body";
+          bodyInput.addEventListener("input", () => {
+            context.setField("responseBody", {
+              mode: "replace",
+              body: bodyInput.value
+            });
+          });
+          context.registerControl("/responseBody/body", bodyInput);
+          container.append(bodyInput);
+        } else {
+          const stored = context.getField("responseBody");
+          const writeRegex = (replacements) => {
+            if (isRecord3(stored) && !("mode" in stored) && Array.isArray(stored.replacements)) {
+              context.setField("responseBody", { replacements });
+            } else {
+              context.setField("responseBody", {
+                mode: "regex",
+                replacements
+              });
+            }
+          };
+          renderRegexRows(writeRegex);
+        }
+      };
       render();
       return { destroy() {
       } };
     },
     defaultAction() {
-      return { replacements: [{ pattern: "", replacement: "" }] };
+      return { mode: "replace", body: "" };
     }
   };
 }
 
 // packages/editor/src/rule-types/index.ts
 var builtInRuleTypes = Object.freeze([
+  createHeaderRuleType(),
+  createRedirectRuleType(),
   queryRuleType,
-  createMockRuleType(),
   createResponseBodyRuleType(),
   createRequestBodyRuleType()
 ]);
@@ -1472,7 +1650,7 @@ var FORBIDDEN_EXTENSION_FIELDS = /* @__PURE__ */ new Set([
 var MAX_SNAPSHOT_ARRAY_LENGTH = 4096;
 var F2_MAX_URL_REGEX_LENGTH2 = 2048;
 var editorInstanceCount = 0;
-function isRecord5(value) {
+function isRecord4(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function snapshotOwnData(value, ancestors = /* @__PURE__ */ new WeakSet()) {
@@ -1551,11 +1729,11 @@ function freezeSnapshot(value, seen = /* @__PURE__ */ new WeakSet()) {
   return value;
 }
 function asDraftProject(value) {
-  if (!isRecord5(value) || !Array.isArray(value.groups)) return void 0;
+  if (!isRecord4(value) || !Array.isArray(value.groups)) return void 0;
   for (const group of value.groups) {
-    if (!isRecord5(group) || !Array.isArray(group.rules)) return void 0;
+    if (!isRecord4(group) || !Array.isArray(group.rules)) return void 0;
     for (const rule of group.rules) {
-      if (!isRecord5(rule)) return void 0;
+      if (!isRecord4(rule)) return void 0;
     }
   }
   return value;
@@ -1586,7 +1764,7 @@ function valueAtPath(root, path) {
       if (index === void 0 || !Object.hasOwn(current, index))
         return void 0;
       current = current[index];
-    } else if (isRecord5(current) && Object.hasOwn(current, segment)) {
+    } else if (isRecord4(current) && Object.hasOwn(current, segment)) {
       current = current[segment];
     } else {
       return void 0;
@@ -1594,6 +1772,25 @@ function valueAtPath(root, path) {
   }
   return current;
 }
+var MATCHER_CREATABLE_FIELDS = ["description", "method", "type"];
+var ACTION_PAYLOAD_FIELDS = [
+  "redirect",
+  "action",
+  "requestBody",
+  "responseBody",
+  "headerDirection",
+  "headerOperation",
+  "headerName",
+  "headerValue"
+];
+var CREATABLE_RULE_FIELDS = /* @__PURE__ */ new Set([
+  ...MATCHER_CREATABLE_FIELDS,
+  ...ACTION_PAYLOAD_FIELDS,
+  "redactSensitiveInLogs"
+]);
+function isBodyRuleType(type) {
+  return type === "request-body" || type === "response-body";
+}
 function setValueAtPath(root, path, value) {
   const segments = decodePointer(path);
   if (!segments || segments.length === 0) return false;
@@ -1606,7 +1803,7 @@ function setValueAtPath(root, path, value) {
         return false;
       }
       current = current[childIndex];
-    } else if (isRecord5(current) && Object.hasOwn(current, segment)) {
+    } else if (isRecord4(current) && Object.hasOwn(current, segment)) {
       current = current[segment];
     } else {
       return false;
@@ -1620,8 +1817,8 @@ function setValueAtPath(root, path, value) {
     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") {
+  if (!isRecord4(current)) return false;
+  if (!Object.hasOwn(current, finalSegment) && !CREATABLE_RULE_FIELDS.has(finalSegment)) {
     return false;
   }
   if (Object.is(current[finalSegment], value)) return false;
@@ -1639,7 +1836,7 @@ function deleteValueAtPath(root, path) {
   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;
+  if (!isRecord4(parent) || !Object.hasOwn(parent, key)) return false;
   return delete parent[key];
 }
 function safeText(value, fallback = "") {
@@ -1675,7 +1872,7 @@ function normalizeDiagnostics(value) {
   }
   const diagnostics = [];
   for (const item of value) {
-    if (!isRecord5(item)) continue;
+    if (!isRecord4(item)) continue;
     const code = item.code;
     const path = item.path;
     const message = item.message;
@@ -1688,12 +1885,11 @@ function normalizeDiagnostics(value) {
 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;
+function clearActionFields(rule, keep, keepFields) {
+  if (!isRecord4(rule)) return false;
   let changed = false;
-  for (const field of ACTION_FIELDS) {
-    if (field === keep) continue;
+  for (const field of ACTION_PAYLOAD_FIELDS) {
+    if (field === keep || keepFields?.has(field)) continue;
     if (Object.hasOwn(rule, field)) {
       delete rule[field];
       changed = true;
@@ -1706,9 +1902,9 @@ function extensionFieldParent(rule, name) {
   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;
+    if (!isRecord4(current)) return void 0;
     const next = current[segments[index]];
-    if (!isRecord5(next)) {
+    if (!isRecord4(next)) {
       const created = {};
       Object.defineProperty(current, segments[index], {
         configurable: true,
@@ -1721,7 +1917,7 @@ function extensionFieldParent(rule, name) {
       current = next;
     }
   }
-  if (!isRecord5(current)) return void 0;
+  if (!isRecord4(current)) return void 0;
   return { parent: current, key: segments[segments.length - 1] };
 }
 function toSearchText(value) {
@@ -2009,6 +2205,14 @@ var EditorControllerImpl = class {
       return;
     }
     const path = target.dataset.path;
+    if (path && target instanceof HTMLInputElement && target.type === "checkbox" && !this.extensionControls.has(path)) {
+      const changed = setValueAtPath(this.draft, path, target.checked);
+      if (changed) {
+        this.markChanged();
+        this.render();
+      }
+      return;
+    }
     if (!path || this.extensionControls.has(path)) return;
     if (this.updateCommonField(path, target.value)) this.render();
   };
@@ -2283,7 +2487,7 @@ var EditorControllerImpl = class {
         const ruleContainer = valueAtPath(this.draft, ruleContainerPath);
         clearActionFields(
           ruleContainer,
-          rawValue === "redirect" || rawValue === "mock" ? rawValue : void 0
+          rawValue === "redirect" ? rawValue : void 0
         );
         this.markChanged();
       }
@@ -2319,16 +2523,30 @@ var EditorControllerImpl = class {
       return;
     }
     const extension = this.extensions.find((entry) => entry.id === typeId);
-    if (!extension?.defaultAction) return;
-    const actionField = extension.actionField ?? "action";
+    if (!extension?.defaultAction && !extension?.defaultFields) return;
     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) {
+    let changedPayload = false;
+    let keep;
+    let keepFields;
+    if (extension.defaultFields) {
+      const fields = extension.defaultFields();
+      keepFields = new Set(Object.keys(fields));
+      for (const [key, value] of Object.entries(fields)) {
+        if (setValueAtPath(this.draft, `${rulePath}/${key}`, value)) {
+          changedPayload = true;
+        }
+      }
+    } else {
+      const defaultAction = extension.defaultAction;
+      if (defaultAction) {
+        keep = extension.actionField ?? "action";
+        if (setValueAtPath(this.draft, `${rulePath}/${keep}`, defaultAction())) {
+          changedPayload = true;
+        }
+      }
+    }
+    const cleared = clearActionFields(ruleContainer, keep, keepFields);
+    if (changedType || changedPayload || cleared) {
       this.markChanged();
       this.render();
     }
@@ -2580,7 +2798,7 @@ var EditorControllerImpl = class {
       if (ruleProposal.method) {
         rule.method = ruleProposal.method;
       }
-      const actionField = ruleProposal.kind === "redirect" || ruleProposal.kind === "mock" ? ruleProposal.kind : "action";
+      const actionField = ruleProposal.kind === "redirect" ? ruleProposal.kind : "action";
       rule[actionField] = ruleProposal.action;
       group.rules.push(rule);
       this.markChanged();
@@ -3377,6 +3595,25 @@ var EditorControllerImpl = class {
     this.renderField(matcherGrid, "Method", `${rulePath}/method`, method);
     matcherFields.append(matcherGrid);
     card.append(matcherFields);
+    if (!isBodyRuleType(rule.type)) {
+      const redactFieldset = this.document.createElement("fieldset");
+      const redactLegend = this.document.createElement("legend");
+      redactLegend.textContent = "Match logging";
+      redactFieldset.append(redactLegend);
+      const redactGrid = this.document.createElement("div");
+      redactGrid.dataset.editorFields = "true";
+      const redactCheckbox = this.document.createElement("input");
+      redactCheckbox.type = "checkbox";
+      redactCheckbox.checked = rule.redactSensitiveInLogs === true;
+      this.renderField(
+        redactGrid,
+        "Redact sensitive fields in logs",
+        `${rulePath}/redactSensitiveInLogs`,
+        redactCheckbox
+      );
+      redactFieldset.append(redactGrid);
+      card.append(redactFieldset);
+    }
     if (this.extensions.length > 0) {
       const currentType = this.extensions.find(
         (e) => e.matches(rule)
@@ -3862,10 +4099,10 @@ var EditorControllerImpl = class {
   }
 };
 function isSaveSuccess(value) {
-  return isRecord5(value) && value.ok === true;
+  return isRecord4(value) && value.ok === true;
 }
 function saveFailureDiagnostic(value) {
-  if (!isRecord5(value)) {
+  if (!isRecord4(value)) {
     return diagnostic(
       "editor.save-failed",
       "",
@@ -3912,282 +4149,11 @@ function createEditor(options) {
   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(document2, options, value, onChange) {
-  const select = document2.createElement("select");
-  for (const option of options) {
-    const opt = document2.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(document2, value, onChange, maxLength) {
-  const input = document2.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 document2 = context.document;
-      const fieldset = document2.createElement("fieldset");
-      const legend = document2.createElement("legend");
-      legend.textContent = "Header rule";
-      fieldset.append(legend);
-      const directionLabel = document2.createElement("label");
-      directionLabel.textContent = "Direction";
-      const directionValue = context.getField("headerDirection") ?? "request";
-      const directionSelect = createSelect(
-        document2,
-        HEADER_DIRECTIONS,
-        directionValue,
-        (value) => {
-          context.setField("headerDirection", value);
-        }
-      );
-      context.registerControl("/headerDirection", directionSelect);
-      directionLabel.append(directionSelect);
-      fieldset.append(directionLabel);
-      const operationLabel = document2.createElement("label");
-      operationLabel.textContent = "Operation";
-      const operationValue = context.getField("headerOperation") ?? "set";
-      const operationSelect = createSelect(
-        document2,
-        HEADER_OPERATIONS,
-        operationValue,
-        (value) => {
-          context.setField("headerOperation", value);
-        }
-      );
-      context.registerControl("/headerOperation", operationSelect);
-      operationLabel.append(operationSelect);
-      fieldset.append(operationLabel);
-      const nameLabel = document2.createElement("label");
-      nameLabel.textContent = "Header name";
-      const nameValue = context.getField("headerName") ?? "";
-      const nameInput = createInput(
-        document2,
-        nameValue,
-        (value) => {
-          context.setField("headerName", value);
-        },
-        256
-      );
-      context.registerControl("/headerName", nameInput);
-      nameLabel.append(nameInput);
-      fieldset.append(nameLabel);
-      const valueLabel = document2.createElement("label");
-      valueLabel.textContent = "Header value";
-      const valueValue = context.getField("headerValue") ?? "";
-      const valueInput = createInput(
-        document2,
-        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 document2 = context.document;
-      const label = document2.createElement("label");
-      label.textContent = "Redirect destination URL";
-      const input = document2.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,