@rogatio/cli 5.8.2 → 5.9.0

package/dist/node/index.js

@@ -2,7 +2,7 @@
 
 // packages/cli/src/index.ts
 import { realpathSync } from "node:fs";
-import { basename as basename4, dirname as dirname8, resolve as resolve8 } from "node:path";
+import { basename as basename3, dirname as dirname8, resolve as resolve8 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // packages/runtime/dist/node/index.js
@@ -99,6 +99,7 @@ var LIMITS = Object.freeze({
   maxMockDelayMs: 3e4,
   maxMockFilePathLength: 2048,
   maxResponseBodyReplacements: 64,
+  maxResponseBodyBytes: 4 * 1024 * 1024,
   maxResponseBodyPatternLength: 2048,
   maxResponseBodyReplacementLength: 4096,
   maxRequestBodyBytes: 4 * 1024 * 1024,
@@ -266,7 +267,6 @@ var projectSchemaDefinition = {
             "redirect",
             "query",
             "header",
-            "mock",
             "response-body",
             "request-body"
           ]
@@ -291,9 +291,9 @@ var projectSchemaDefinition = {
           type: "string",
           maxLength: LIMITS.maxHeaderValueLength
         },
-        mock: { $ref: "#/$defs/mockAction" },
         responseBody: { $ref: "#/$defs/responseBodyAction" },
-        requestBody: { $ref: "#/$defs/requestBodyAction" }
+        requestBody: { $ref: "#/$defs/requestBodyAction" },
+        redactSensitiveInLogs: { type: "boolean" }
       },
       allOf: [
         {
@@ -326,16 +326,6 @@ var projectSchemaDefinition = {
             required: ["headerDirection", "headerOperation", "headerName"]
           }
         },
-        {
-          if: {
-            required: ["type"],
-            properties: { type: { const: "mock" } }
-          },
-          // biome-ignore lint/suspicious/noThenProperty: AJV conditional schema keyword
-          then: {
-            required: ["mock"]
-          }
-        },
         {
           if: {
             required: ["type"],
@@ -391,19 +381,51 @@ var projectSchemaDefinition = {
     queryParam: {
       type: "object",
       additionalProperties: false,
-      required: ["name", "value"],
+      required: ["name"],
       properties: {
         name: {
           type: "string",
           minLength: 1,
           maxLength: LIMITS.maxQueryNameLength
         },
+        operation: {
+          enum: ["set", "remove"]
+        },
         value: {
           type: "string",
           minLength: 1,
           maxLength: LIMITS.maxQueryValueLength
         }
-      }
+      },
+      allOf: [
+        {
+          if: {
+            anyOf: [
+              { not: { required: ["operation"] } },
+              {
+                properties: { operation: { const: "set" } },
+                required: ["operation"]
+              }
+            ]
+          },
+          // biome-ignore lint/suspicious/noThenProperty: AJV conditional schema keyword
+          then: {
+            required: ["value"]
+          }
+        },
+        {
+          if: {
+            properties: { operation: { const: "remove" } },
+            required: ["operation"]
+          },
+          // biome-ignore lint/suspicious/noThenProperty: AJV conditional schema keyword
+          then: {
+            properties: {
+              value: false
+            }
+          }
+        }
+      ]
     },
     queryAction: {
       type: "object",
@@ -419,71 +441,50 @@ var projectSchemaDefinition = {
         }
       }
     },
-    mockHeader: {
+    responseBodyReplacement: {
       type: "object",
       additionalProperties: false,
-      required: ["name", "value"],
+      required: ["pattern", "replacement"],
       properties: {
-        name: {
+        pattern: {
           type: "string",
           minLength: 1,
-          maxLength: LIMITS.maxMockHeaderNameLength
+          maxLength: LIMITS.maxResponseBodyPatternLength,
+          format: "rogatio-url-regex"
         },
-        value: {
+        replacement: {
           type: "string",
-          maxLength: LIMITS.maxMockHeaderValueLength
+          maxLength: LIMITS.maxResponseBodyReplacementLength
         }
       }
     },
-    mockAction: {
+    responseBodyReplaceAction: {
       type: "object",
       additionalProperties: false,
-      required: ["status"],
+      required: ["mode", "body"],
       properties: {
-        status: {
-          type: "integer",
-          minimum: LIMITS.minMockStatus,
-          maximum: LIMITS.maxMockStatus
-        },
-        headers: {
-          type: "array",
-          maxItems: LIMITS.maxMockHeadersPerRule,
-          items: { $ref: "#/$defs/mockHeader" }
-        },
-        delayMs: {
-          type: "integer",
-          minimum: 0,
-          maximum: LIMITS.maxMockDelayMs
-        },
+        mode: { const: "replace" },
         body: {
           type: "string",
-          maxLength: LIMITS.maxMockInlineBodyLength
-        },
-        file: {
-          type: "string",
-          minLength: 1,
-          maxLength: LIMITS.maxMockFilePathLength
+          maxLength: LIMITS.maxResponseBodyBytes
         }
       }
     },
-    responseBodyReplacement: {
+    responseBodyRegexAction: {
       type: "object",
       additionalProperties: false,
-      required: ["pattern", "replacement"],
+      required: ["mode", "replacements"],
       properties: {
-        pattern: {
-          type: "string",
-          minLength: 1,
-          maxLength: LIMITS.maxResponseBodyPatternLength,
-          format: "rogatio-url-regex"
-        },
-        replacement: {
-          type: "string",
-          maxLength: LIMITS.maxResponseBodyReplacementLength
+        mode: { const: "regex" },
+        replacements: {
+          type: "array",
+          minItems: 1,
+          maxItems: LIMITS.maxResponseBodyReplacements,
+          items: { $ref: "#/$defs/responseBodyReplacement" }
         }
       }
     },
-    responseBodyAction: {
+    responseBodyUntaggedRegexAction: {
       type: "object",
       additionalProperties: false,
       required: ["replacements"],
@@ -496,6 +497,13 @@ var projectSchemaDefinition = {
         }
       }
     },
+    responseBodyAction: {
+      oneOf: [
+        { $ref: "#/$defs/responseBodyReplaceAction" },
+        { $ref: "#/$defs/responseBodyRegexAction" },
+        { $ref: "#/$defs/responseBodyUntaggedRegexAction" }
+      ]
+    },
     requestBodyReplaceAction: {
       type: "object",
       additionalProperties: false,
@@ -547,6 +555,21 @@ var projectSchemaDefinition = {
   }
 };
 var projectSchema = projectSchemaDefinition;
+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;
+}
 var ajv = new Ajv2020({
   allErrors: true,
   coerceTypes: false,
@@ -678,22 +701,6 @@ function semanticIssues(project) {
       ids.set(group.id, `${groupPath}/id`);
     }
     for (let ruleIndex = 0; ruleIndex < group.rules.length; ruleIndex += 1) {
-      let hasLoneSurrogate2 = function(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;
-      };
-      var hasLoneSurrogate = hasLoneSurrogate2;
       const rule = group.rules[ruleIndex];
       ruleCount += 1;
       const rulePath = `${groupPath}/rules/${ruleIndex}`;
@@ -708,17 +715,16 @@ function semanticIssues(project) {
       } else {
         ids.set(rule.id, `${rulePath}/id`);
       }
-      if (rule.type !== void 0 && rule.type !== "redirect" && rule.type !== "query" && rule.type !== "header" && rule.type !== "mock" && rule.type !== "response-body" && rule.type !== "request-body") {
+      if (rule.type !== void 0 && rule.type !== "redirect" && rule.type !== "query" && rule.type !== "header" && rule.type !== "response-body" && rule.type !== "request-body") {
         issues.push({
           instancePath: `${rulePath}/type`,
           keyword: "enum",
-          message: 'must be "redirect", "query", "header", "mock", "response-body", or "request-body"',
+          message: 'must be "redirect", "query", "header", "response-body", or "request-body"',
           params: {
             allowedValues: [
               "redirect",
               "query",
               "header",
-              "mock",
               "response-body",
               "request-body"
             ]
@@ -782,6 +788,24 @@ function semanticIssues(project) {
           } else {
             seenNames.add(paramName);
           }
+          const operation = param.operation ?? "set";
+          if (operation === "set") {
+            if (typeof param.value !== "string" || param.value.length === 0 || param.value.length > LIMITS.maxQueryValueLength) {
+              issues.push({
+                instancePath: `${rulePath}/action/params/${p}/value`,
+                keyword: "queryParamValue",
+                message: "query param value is required for set",
+                params: {}
+              });
+            }
+          } else if (param.value !== void 0) {
+            issues.push({
+              instancePath: `${rulePath}/action/params/${p}/value`,
+              keyword: "queryParamValue",
+              message: "query param value must be omitted for remove",
+              params: {}
+            });
+          }
         }
       }
       if (rule.type === "header" && rule.headerName !== void 0) {
@@ -801,25 +825,64 @@ function semanticIssues(project) {
       if (rule.type === "response-body") {
         const action2 = rule.responseBody;
         const actionPath = `${rulePath}/responseBody`;
-        if (!action2 || !Array.isArray(action2.replacements) || action2.replacements.length === 0) {
+        if (!action2) {
           issues.push({
-            instancePath: `${actionPath}/replacements`,
-            keyword: "response-body-replacements",
-            message: "A response-body rule must define at least one replacement.",
+            instancePath: actionPath,
+            keyword: "response-body-action",
+            message: "A response-body rule must define a responseBody action.",
             params: {}
           });
-        } else {
-          for (let index = 0; index < action2.replacements.length; index += 1) {
-            const replacement = action2.replacements[index];
-            if (compileUrlRegex(replacement.pattern) === null) {
-              issues.push({
-                instancePath: `${actionPath}/replacements/${index}/pattern`,
-                keyword: "response-body-pattern",
-                message: "Response-body replacement patterns must be valid regular expressions.",
-                params: {}
-              });
+        } else if ("mode" in action2 && action2.mode === "replace") {
+          if (typeof action2.body !== "string") {
+            issues.push({
+              instancePath: `${actionPath}/body`,
+              keyword: "response-body-replace-body",
+              message: "Replace mode requires a body string.",
+              params: {}
+            });
+          } else if (action2.body.length > LIMITS.maxResponseBodyBytes) {
+            issues.push({
+              instancePath: `${actionPath}/body`,
+              keyword: "response-body-replace-body",
+              message: `Replace body exceeds the maximum size of ${LIMITS.maxResponseBodyBytes} bytes.`,
+              params: { limit: LIMITS.maxResponseBodyBytes }
+            });
+          } else if (hasLoneSurrogate(action2.body)) {
+            issues.push({
+              instancePath: `${actionPath}/body`,
+              keyword: "response-body-lone-surrogate",
+              message: "Replace body must not contain lone UTF-16 surrogates.",
+              params: {}
+            });
+          }
+        } else if ("replacements" in action2 && Array.isArray(action2.replacements)) {
+          if (action2.replacements.length === 0) {
+            issues.push({
+              instancePath: `${actionPath}/replacements`,
+              keyword: "response-body-replacements",
+              message: "A response-body rule must define at least one replacement.",
+              params: {}
+            });
+          } else {
+            for (let index = 0; index < action2.replacements.length; index += 1) {
+              const replacement = action2.replacements[index];
+              if (compileUrlRegex(replacement.pattern) === null) {
+                issues.push({
+                  instancePath: `${actionPath}/replacements/${index}/pattern`,
+                  keyword: "response-body-pattern",
+                  message: "Response-body replacement patterns must be valid regular expressions.",
+                  params: {}
+                });
+              }
             }
           }
+        } else {
+          issues.push({
+            instancePath: actionPath,
+            keyword: "response-body-mode",
+            message: "responseBody must be replace mode, regex mode, or untagged replacements.",
+            params: {}
+          });
         }
       }
       if (rule.type === "request-body") {
@@ -857,7 +920,7 @@ function semanticIssues(project) {
                 message: `Replace body exceeds the maximum size of ${LIMITS.maxRequestBodyBytes} bytes.`,
                 params: { limit: LIMITS.maxRequestBodyBytes }
               });
-            } else if (hasLoneSurrogate2(action2.body)) {
+            } else if (hasLoneSurrogate(action2.body)) {
               issues.push({
                 instancePath: `${actionPath}/body`,
                 keyword: "request-body-lone-surrogate",
@@ -896,14 +959,14 @@ function semanticIssues(project) {
                 message: `Regex replacement exceeds the maximum length of ${LIMITS.maxRequestBodyReplacementLength} characters.`,
                 params: { limit: LIMITS.maxRequestBodyReplacementLength }
               });
-            } else if (hasLoneSurrogate2(action2.pattern)) {
+            } else if (hasLoneSurrogate(action2.pattern)) {
               issues.push({
                 instancePath: `${actionPath}/pattern`,
                 keyword: "request-body-lone-surrogate",
                 message: "Regex pattern must not contain lone UTF-16 surrogates.",
                 params: {}
               });
-            } else if (hasLoneSurrogate2(action2.replacement)) {
+            } else if (hasLoneSurrogate(action2.replacement)) {
               issues.push({
                 instancePath: `${actionPath}/replacement`,
                 keyword: "request-body-lone-surrogate",
@@ -931,42 +994,6 @@ function semanticIssues(project) {
           });
         }
       }
-      if (rule.type === "mock") {
-        const mock = rule.mock;
-        const mockPath = `${rulePath}/mock`;
-        const bodySet = mock?.body !== void 0;
-        const fileSet = mock?.file !== void 0;
-        if (bodySet === fileSet) {
-          issues.push({
-            instancePath: mockPath,
-            keyword: "mock-body-source",
-            message: "A mock rule must set exactly one of body or file.",
-            params: {}
-          });
-        }
-        if (mock?.headers !== void 0) {
-          for (let h = 0; h < mock.headers.length; h += 1) {
-            const header = mock.headers[h];
-            if (header === void 0) continue;
-            if (hasControl(header.name) || header.name.includes(":")) {
-              issues.push({
-                instancePath: `${mockPath}/headers/${h}/name`,
-                keyword: "mock-header-name",
-                message: "Mock header names must not contain control characters or ':'.",
-                params: {}
-              });
-            }
-          }
-        }
-        if (mock?.file !== void 0 && hasControl(mock.file)) {
-          issues.push({
-            instancePath: `${mockPath}/file`,
-            keyword: "mock-file-path",
-            message: "Mock file paths must not contain control characters.",
-            params: {}
-          });
-        }
-      }
     }
   }
   if (project.requestBodyPolicy !== void 0) {
@@ -1376,6 +1403,9 @@ function canonicalResourceTypes(resourceTypes) {
   }
   return ordered;
 }
+function resolveRedactSensitiveInLogs(rule) {
+  return rule.redactSensitiveInLogs === true;
+}
 function compileMatcher(group, rule, groupIndex, ruleIndex) {
   const matcher = {
     urlRegex: { source: rule.urlRegex, flags: "" },
@@ -1393,11 +1423,14 @@ function compileOperations(project) {
     for (let ruleIndex = 0; ruleIndex < group.rules.length; ruleIndex += 1) {
       const rule = group.rules[ruleIndex];
       const matcher = compileMatcher(group, rule, groupIndex, ruleIndex);
+      const redactSensitiveInLogs = resolveRedactSensitiveInLogs(rule);
       if (rule.type === "redirect") {
         const operation = {
           kind: "redirect",
           groupId: group.id,
           ruleId: rule.id,
+          name: rule.name,
+          redactSensitiveInLogs,
           matcher,
           redirect: { destination: rule.redirect?.destination ?? "" }
         };
@@ -1408,6 +1441,8 @@ function compileOperations(project) {
           kind: "query",
           groupId: group.id,
           ruleId: rule.id,
+          name: rule.name,
+          redactSensitiveInLogs,
           matcher,
           action
         };
@@ -1417,6 +1452,8 @@ function compileOperations(project) {
           kind: "header",
           groupId: group.id,
           ruleId: rule.id,
+          name: rule.name,
+          redactSensitiveInLogs,
           matcher,
           header: {
             direction: rule.headerDirection ?? "request",
@@ -1426,20 +1463,13 @@ function compileOperations(project) {
           }
         };
         operations.push(operation);
-      } else if (rule.type === "mock") {
-        const operation = {
-          kind: "mock",
-          groupId: group.id,
-          ruleId: rule.id,
-          matcher,
-          mock: rule.mock ?? { status: 200, body: "" }
-        };
-        operations.push(operation);
       } else if (rule.type === "response-body") {
         const operation = {
           kind: "response-body",
           groupId: group.id,
           ruleId: rule.id,
+          name: rule.name,
+          redactSensitiveInLogs,
           matcher,
           responseBody: rule.responseBody ?? { replacements: [] }
         };
@@ -1449,6 +1479,8 @@ function compileOperations(project) {
           kind: "request-body",
           groupId: group.id,
           ruleId: rule.id,
+          name: rule.name,
+          redactSensitiveInLogs,
           matcher,
           requestBody: rule.requestBody ?? { mode: "replace", body: "" }
         };
@@ -1458,6 +1490,8 @@ function compileOperations(project) {
           kind: "matcher",
           groupId: group.id,
           ruleId: rule.id,
+          name: rule.name,
+          redactSensitiveInLogs,
           matcher
         };
         operations.push(operation);
@@ -21209,15 +21243,21 @@ function freezeMatcher(operation) {
     kind: "matcher",
     groupId: operation.groupId,
     ruleId: operation.ruleId,
+    name: operation.name,
+    redactSensitiveInLogs: operation.redactSensitiveInLogs,
     matcher
   });
 }
+function resolveMatcherName(ruleId, value) {
+  if (typeof value === "string" && value.length > 0) return value;
+  return ruleId;
+}
 function normalizeMatcher(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value))
     return null;
   const requiredKeys = ["kind", "groupId", "ruleId", "matcher"];
   if (!requiredKeys.every((key) => hasOwn(value, key)) || Object.keys(value).some(
-    (key) => key !== "kind" && key !== "groupId" && key !== "ruleId" && key !== "matcher" && key !== "action"
+    (key) => key !== "kind" && key !== "groupId" && key !== "ruleId" && key !== "name" && key !== "matcher" && key !== "action" && key !== "redactSensitiveInLogs"
   ))
     return null;
   const record = value;
@@ -21272,10 +21312,16 @@ function normalizeMatcher(value) {
     if (!validMethod2(matcher.method)) return null;
     method = matcher.method;
   }
+  const redactValue = record.redactSensitiveInLogs;
+  if (redactValue !== void 0 && typeof redactValue !== "boolean")
+    return null;
+  const redactSensitiveInLogs = redactValue === true;
   return freezeMatcher({
     kind: "matcher",
     groupId: record.groupId,
     ruleId: record.ruleId,
+    name: resolveMatcherName(record.ruleId, record.name),
+    redactSensitiveInLogs,
     matcher: {
       urlRegex: { source: regex.source, flags: "" },
       origins,
@@ -21561,28 +21607,13 @@ function createNativeRuntimeController(options) {
           };
         }
         const matcherOps = [];
-        const mockConfigs = [];
         for (const op of compileResult.operations) {
-          if (op.kind === "mock") {
-            const mock = op.mock;
-            let file;
-            if (mock.file !== void 0) {
-              file = mock.file;
-            }
-            mockConfigs.push({
-              ruleId: op.ruleId,
-              status: mock.status,
-              ...mock.headers !== void 0 ? { headers: mock.headers } : {},
-              ...mock.delayMs !== void 0 ? { delayMs: mock.delayMs } : {},
-              ...mock.body !== void 0 ? { body: mock.body } : {},
-              ...file !== void 0 ? { file } : {}
-            });
-          }
           if ("matcher" in op) {
             matcherOps.push({
               kind: "matcher",
               groupId: op.groupId,
               ruleId: op.ruleId,
+              redactSensitiveInLogs: op.redactSensitiveInLogs,
               matcher: op.matcher
             });
           }
@@ -21591,14 +21622,11 @@ function createNativeRuntimeController(options) {
           version: 1,
           limits: RUNTIME_LIMITS,
           matchers: matcherOps,
-          grants: [],
-          ...mockConfigs.length > 0 ? { mocks: mockConfigs } : {}
+          grants: []
         };
         console.error(
           "[rogatio-host] normalizeRuntimePreset input: matchers=",
           matcherOps.length,
-          "mocks=",
-          mockConfigs.length,
           "grants=0"
         );
         const normalized = normalizeRuntimePreset(presetInput);
@@ -22878,7 +22906,7 @@ Start/Stop controls, not the CLI. Run 'rogatio runtime install --extension-id
 
 Options:
   --extension-id  Extension ID for native messaging manifest (required for install)
-  --root <dir>    Root for confined file mocks (default: project directory)
+  --root <dir>    Root for confined runtime file access (default: project directory)
   --help, -h      Show this help
 
 Exit codes:
@@ -23506,36 +23534,6 @@ function dryRunProject(operations, cases, options) {
   };
 }
 
-// packages/cli/src/utils/mock-preview.ts
-import { basename as basename2 } from "node:path";
-function createMockPreviewAction(operations) {
-  const mockByRuleId = /* @__PURE__ */ new Map();
-  for (const operation of operations) {
-    if (operation.kind === "mock") {
-      mockByRuleId.set(operation.ruleId, operation);
-    }
-  }
-  return (operation, _url, _testCase) => {
-    const mock = mockByRuleId.get(operation.ruleId);
-    if (mock === void 0) return null;
-    if (mock.mock.body !== void 0) {
-      return {
-        kind: "mock",
-        summary: `Mock ${mock.mock.status} (inline body, ${Buffer.byteLength(
-          mock.mock.body,
-          "utf8"
-        )} bytes)`
-      };
-    }
-    return {
-      kind: "mock",
-      summary: `Mock ${mock.mock.status} (file snapshot: ${basename2(
-        mock.mock.file ?? ""
-      )})`
-    };
-  };
-}
-
 // packages/cli/src/server/routes.ts
 function generateCsrfToken() {
   return randomBytes3(16).toString("hex");
@@ -23606,12 +23604,16 @@ function bodyErrorResponse(error) {
   };
 }
 function toMatcherOperations(operations) {
-  return operations.map(({ groupId, ruleId, matcher }) => ({
-    kind: "matcher",
-    groupId,
-    ruleId,
-    matcher
-  }));
+  return operations.map(
+    ({ groupId, ruleId, name, matcher, redactSensitiveInLogs }) => ({
+      kind: "matcher",
+      groupId,
+      ruleId,
+      name,
+      matcher,
+      redactSensitiveInLogs
+    })
+  );
 }
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -23909,10 +23911,7 @@ function createRoutes(context) {
       const result = dryRunProject(
         toMatcherOperations(compileResult.operations),
         body.cases,
-        {
-          ...body.options ?? {},
-          previewAction: createMockPreviewAction(compileResult.operations)
-        }
+        body.options ?? {}
       );
       res.writeHead(200, { "Content-Type": "application/json" });
       res.end(JSON.stringify(result));
@@ -24143,7 +24142,7 @@ import {
   unlink as unlink2,
   writeFile as writeFile3
 } from "node:fs/promises";
-import { basename as basename3, dirname as dirname6, join as join5 } from "node:path";
+import { basename as basename2, dirname as dirname6, join as join5 } from "node:path";
 var ProjectStorageError = class extends Error {
   code;
   id;
@@ -24241,7 +24240,7 @@ async function isDirectoryPath(id2) {
   }
 }
 async function writeDocument(id2, data) {
-  const tempName = `.${basename3(dirname6(id2))}.${randomBytes4(8).toString("hex")}.tmp`;
+  const tempName = `.${basename2(dirname6(id2))}.${randomBytes4(8).toString("hex")}.tmp`;
   const tempPath = join5(dirname6(id2), tempName);
   try {
     if (await isDirectoryPath(id2)) {
@@ -24629,7 +24628,7 @@ function generateEditorHtml(apiBase, csrfToken, filePath, aiConfigured) {
      { "imports": { "@rogatio/editor": "/vendor/editor.js" } }
    </script>
    <script type="module">
-      import { createEditor, createMockRuleType, createRedirectRuleType, createResponseBodyRuleType } from '@rogatio/editor';
+      import { createEditor } from '@rogatio/editor';
     
     const root = document.getElementById('editor-root');
     const apiBase = '${apiBase}';
@@ -24678,8 +24677,8 @@ function generateEditorHtml(apiBase, csrfToken, filePath, aiConfigured) {
     
     const project = await fetchProject();
     
-    const editor = createEditor(root, {
-      ruleTypes: [createRedirectRuleType(), createMockRuleType(), createResponseBodyRuleType()],
+    const editor = createEditor({
+      root,
       initialProject: project,
       validate: async (value) => {
         const result = await validateProject(value);
@@ -24720,49 +24719,18 @@ function generateEditorHtml(apiBase, csrfToken, filePath, aiConfigured) {
 
 // packages/cli/src/commands/runtime.ts
 import { chmod, mkdir as mkdir4, rm as rm2, writeFile as writeFile4 } from "node:fs/promises";
-import { dirname as dirname7, isAbsolute, join as join6, relative, resolve as resolve5, sep as sep2 } from "node:path";
+import { dirname as dirname7, join as join6, resolve as resolve5 } from "node:path";
 function toMatcherOperations2(operations) {
-  return operations.map(({ groupId, ruleId, matcher }) => ({
-    kind: "matcher",
-    groupId,
-    ruleId,
-    matcher
-  }));
-}
-function resolveMockFile(root, filePath) {
-  if (filePath.includes("\0")) return null;
-  const absolute = isAbsolute(filePath) ? filePath : resolve5(root, filePath);
-  const rel = relative(root, absolute);
-  if (rel.startsWith("..") || isAbsolute(rel)) return null;
-  const logical = rel.split(sep2).join("/");
-  return logical.length === 0 ? null : logical;
-}
-function buildMockConfigs(operations, root) {
-  const configs = [];
-  for (const operation of operations) {
-    if (operation.kind !== "mock") continue;
-    const mock = operation.mock;
-    let file;
-    if (mock.file !== void 0) {
-      const resolved = resolveMockFile(root, mock.file);
-      if (resolved === null) {
-        return {
-          ok: false,
-          message: `Mock rule "${operation.ruleId}" file "${mock.file}" resolves outside the configured root (${root}).`
-        };
-      }
-      file = resolved;
-    }
-    configs.push({
-      ruleId: operation.ruleId,
-      status: mock.status,
-      ...mock.headers !== void 0 ? { headers: mock.headers } : {},
-      ...mock.delayMs !== void 0 ? { delayMs: mock.delayMs } : {},
-      ...mock.body !== void 0 ? { body: mock.body } : {},
-      ...file !== void 0 ? { file } : {}
-    });
-  }
-  return { ok: true, value: configs };
+  return operations.map(
+    ({ groupId, ruleId, name, matcher, redactSensitiveInLogs }) => ({
+      kind: "matcher",
+      groupId,
+      ruleId,
+      name,
+      matcher,
+      redactSensitiveInLogs
+    })
+  );
 }
 function generateHostWrapper(rogatioCommand, logPath) {
   const parts = rogatioCommand.split(" ");
@@ -25016,17 +24984,11 @@ async function runtimeHostCommand(args, options = {}) {
     return 1;
   }
   const rootDir = root ?? (inputPath === "-" ? process.cwd() : dirname7(filePath));
-  const mocksResult = buildMockConfigs(compileResult.operations, rootDir);
-  if (!mocksResult.ok) {
-    console.error(`Error: ${mocksResult.message}`);
-    return 1;
-  }
   const normalized = normalizeRuntimePreset({
     version: 1,
     limits: RUNTIME_LIMITS,
     matchers: toMatcherOperations2(compileResult.operations),
-    grants: [],
-    ...mocksResult.value.length > 0 ? { mocks: mocksResult.value } : {}
+    grants: []
   });
   if (!normalized.ok) {
     console.error("Error: Failed to build runtime preset");
@@ -25070,12 +25032,16 @@ function usageError(message) {
 `;
 }
 function toMatcherOperations3(operations) {
-  return operations.map(({ groupId, ruleId, matcher }) => ({
-    kind: "matcher",
-    groupId,
-    ruleId,
-    matcher
-  }));
+  return operations.map(
+    ({ groupId, ruleId, name, matcher, redactSensitiveInLogs }) => ({
+      kind: "matcher",
+      groupId,
+      ruleId,
+      name,
+      matcher,
+      redactSensitiveInLogs
+    })
+  );
 }
 function isUrl(value) {
   return parseTestUrl(value).ok;
@@ -25130,10 +25096,9 @@ function addDefaults(cases, defaultMethod, defaultResourceType) {
     (raw) => applyDefaults(raw, defaultMethod, defaultResourceType)
   );
 }
-function resultOptions(maxCases, operations) {
+function resultOptions(maxCases) {
   const options = {};
   if (maxCases !== void 0) options.maxCases = maxCases;
-  options.previewAction = createMockPreviewAction(operations);
   return options;
 }
 function diagnosticsFromSchema(projectData) {
@@ -25330,7 +25295,7 @@ async function testCommandImpl(args, stdinInput, captureOutput, options = {}) {
   const dryRunResult = dryRunProject(
     toMatcherOperations3(compileResult.operations),
     testCases,
-    resultOptions(maxCases, compileResult.operations)
+    resultOptions(maxCases)
   );
   if (jsonMode) {
     const output = jsonOutput(dryRunResult);
@@ -25600,7 +25565,7 @@ Run 'rogatio <command> --help' for command-specific help.`);
   return 0;
 }
 if (process.argv[1] !== void 0 && realpathSync.native(fileURLToPath2(import.meta.url)) === realpathSync.native(resolve8(process.argv[1]))) {
-  if (basename4(process.argv[1]) === "runtime-host") {
+  if (basename3(process.argv[1]) === "runtime-host") {
     runRuntimeHostEntry().catch((err) => {
       console.error(err);
       process.exit(1);