@rogatio/cli 6.13.0 → 6.14.1

package/dist/node/index.js

@@ -2,7 +2,7 @@
 
 // packages/cli/src/index.ts
 import { realpathSync } from "node:fs";
-import { basename as basename3, dirname as dirname8, resolve as resolve9 } from "node:path";
+import { basename as basename3, dirname as dirname10, resolve as resolve9 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // packages/runtime/dist/node/index.js
@@ -701,7 +701,8 @@ var projectSchemaDefinition = {
             "query",
             "header",
             "response-body",
-            "request-body"
+            "request-body",
+            "mock"
           ]
         },
         redirect: {
@@ -726,6 +727,7 @@ var projectSchemaDefinition = {
         },
         responseBody: { $ref: "#/$defs/responseBodyAction" },
         requestBody: { $ref: "#/$defs/requestBodyAction" },
+        mock: { $ref: "#/$defs/mockAction" },
         redactSensitiveInLogs: { type: "boolean" }
       },
       allOf: [
@@ -808,9 +810,66 @@ var projectSchemaDefinition = {
           then: {
             required: ["requestBody", "method", "resourceTypes"]
           }
+        },
+        {
+          if: {
+            required: ["type"],
+            properties: { type: { const: "mock" } }
+          },
+          // biome-ignore lint/suspicious/noThenProperty: AJV conditional schema keyword
+          then: {
+            required: ["mock"]
+          }
         }
       ]
     },
+    mockHeader: {
+      type: "object",
+      additionalProperties: false,
+      required: ["name", "value"],
+      properties: {
+        name: {
+          type: "string",
+          minLength: 1,
+          maxLength: LIMITS.maxMockHeaderNameLength
+        },
+        value: {
+          type: "string",
+          maxLength: LIMITS.maxMockHeaderValueLength
+        }
+      }
+    },
+    mockAction: {
+      type: "object",
+      additionalProperties: false,
+      required: ["status"],
+      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
+        },
+        body: {
+          type: "string",
+          maxLength: LIMITS.maxMockInlineBodyLength
+        },
+        file: {
+          type: "string",
+          minLength: 1,
+          maxLength: LIMITS.maxMockFilePathLength
+        }
+      }
+    },
     queryParam: {
       type: "object",
       additionalProperties: false,
@@ -1178,18 +1237,19 @@ function semanticIssues(project) {
         ids.set(rule.id, `${rulePath}/id`);
       }
       claimName(rule.name, `${rulePath}/name`);
-      if (rule.type !== void 0 && rule.type !== "redirect" && rule.type !== "query" && rule.type !== "header" && rule.type !== "response-body" && rule.type !== "request-body") {
+      if (rule.type !== void 0 && rule.type !== "redirect" && rule.type !== "query" && rule.type !== "header" && rule.type !== "response-body" && rule.type !== "request-body" && rule.type !== "mock") {
         issues.push({
           instancePath: `${rulePath}/type`,
           keyword: "enum",
-          message: 'must be "redirect", "query", "header", "response-body", or "request-body"',
+          message: 'must be "redirect", "query", "header", "response-body", "request-body", or "mock"',
           params: {
             allowedValues: [
               "redirect",
               "query",
               "header",
               "response-body",
-              "request-body"
+              "request-body",
+              "mock"
             ]
           }
         });
@@ -1481,6 +1541,86 @@ function semanticIssues(project) {
           });
         }
       }
+      if (rule.type === "mock") {
+        const mock = rule.mock;
+        const mockPath = `${rulePath}/mock`;
+        if (mock !== void 0) {
+          const forbiddenMockStatuses = /* @__PURE__ */ new Set([204, 205, 304]);
+          if (forbiddenMockStatuses.has(mock.status)) {
+            issues.push({
+              instancePath: `${mockPath}/status`,
+              keyword: "mock-status",
+              message: "Mock status must not be 204, 205, or 304 because those responses require special body handling.",
+              params: { status: mock.status }
+            });
+          }
+          const bodySet = mock.body !== void 0;
+          const fileSet = mock.file !== void 0;
+          if (bodySet === fileSet) {
+            issues.push({
+              instancePath: mockPath,
+              keyword: "mock-body-source",
+              message: "Mock rules require exactly one of body or file.",
+              params: {}
+            });
+          } else if (fileSet && typeof mock.file === "string" && !isValidMockLogicalPath(mock.file)) {
+            issues.push({
+              instancePath: `${mockPath}/file`,
+              keyword: "mock-file-path",
+              message: "Mock file must be a relative logical path without absolute segments, backslashes, percent escapes, control characters, dot segments, colons, or glob characters.",
+              params: {}
+            });
+          }
+          if (mock.headers !== void 0) {
+            const seenHeaderNames = /* @__PURE__ */ new Set();
+            for (let index = 0; index < mock.headers.length; index += 1) {
+              const header = mock.headers[index];
+              if (header === void 0) continue;
+              const namePath = `${mockPath}/headers/${index}/name`;
+              const valuePath = `${mockPath}/headers/${index}/value`;
+              if (hasControl(header.name)) {
+                issues.push({
+                  instancePath: namePath,
+                  keyword: "mock-header-control",
+                  message: "Mock header names must not contain control characters.",
+                  params: {}
+                });
+              }
+              if (hasControl(header.value)) {
+                issues.push({
+                  instancePath: valuePath,
+                  keyword: "mock-header-control",
+                  message: "Mock header values must not contain control characters.",
+                  params: {}
+                });
+              }
+              const comparableName = header.name.trim();
+              if (isForbiddenHeader(comparableName, "response")) {
+                issues.push({
+                  instancePath: namePath,
+                  keyword: "forbiddenHeader",
+                  message: `Header "${header.name}" is forbidden for response headers.`,
+                  params: {
+                    headerName: header.name,
+                    headerDirection: "response"
+                  }
+                });
+              }
+              const normalizedName = comparableName.toLowerCase();
+              if (seenHeaderNames.has(normalizedName)) {
+                issues.push({
+                  instancePath: namePath,
+                  keyword: "uniqueMockHeaderName",
+                  message: `mock header name must be unique; duplicate "${header.name}"`,
+                  params: { name: header.name }
+                });
+              } else {
+                seenHeaderNames.add(normalizedName);
+              }
+            }
+          }
+        }
+      }
     }
   }
   if (project.requestBodyPolicy !== void 0) {
@@ -1546,6 +1686,22 @@ function semanticIssues(project) {
   }
   return issues;
 }
+function isValidMockLogicalPath(value) {
+  if (value.length === 0) return false;
+  if (value.includes("\\") || value.includes("%") || hasControl(value)) {
+    return false;
+  }
+  if (value.startsWith("/") || value.endsWith("/") || value.includes("//")) {
+    return false;
+  }
+  const parts = value.split("/");
+  if (parts.some(
+    (part) => part.length === 0 || part === "." || part === ".." || part.includes(":") || /[*?[\]]/.test(part)
+  )) {
+    return false;
+  }
+  return true;
+}
 function captureValidationIssues(value, urlRegex, instancePath) {
   return validateCaptureTemplate(value, urlRegex).map((issue) => ({
     instancePath,
@@ -1739,7 +1895,9 @@ var MESSAGES = {
   "compiler.header-value-required": "Header value is required for set and append operations.",
   "compiler.header-value-unexpected": "Header value must not be provided for remove operation.",
   "compiler.invalid-header-direction": "Invalid header direction.",
-  "compiler.invalid-header-operation": "Invalid header operation."
+  "compiler.invalid-header-operation": "Invalid header operation.",
+  "compiler.mock-body-source": "Mock rules require exactly one of body or file.",
+  "compiler.mock-forbidden-header": "The header name is forbidden for mock response headers."
 };
 function copySafeParams(params) {
   const safe = {};
@@ -1777,9 +1935,22 @@ function stableParams(params) {
   const keys = Object.keys(params).sort(compareCodeUnits);
   return keys.map((key) => `${JSON.stringify(key)}:${JSON.stringify(params[key])}`).join(",");
 }
+var MOCK_HEADER_NAME_PATH = /^\/groups\/\d+\/rules\/\d+\/mock\/headers\/\d+\/name$/;
+function validationIssueCode(issue) {
+  if (issue.keyword === "mock-body-source") {
+    return "compiler.mock-body-source";
+  }
+  if (issue.keyword === "forbiddenHeader" && MOCK_HEADER_NAME_PATH.test(issue.instancePath)) {
+    return "compiler.mock-forbidden-header";
+  }
+  if (Object.hasOwn(ISSUE_CODES, issue.keyword)) {
+    return ISSUE_CODES[issue.keyword];
+  }
+  return "schema.invalid-value";
+}
 function mapValidationIssues(issues) {
   return issues.map((issue) => {
-    const code = Object.hasOwn(ISSUE_CODES, issue.keyword) ? ISSUE_CODES[issue.keyword] : "schema.invalid-value";
+    const code = validationIssueCode(issue);
     return {
       code,
       severity: "error",
@@ -1953,6 +2124,21 @@ function compileOperations(project) {
           requestBody: rule.requestBody ?? { mode: "replace", body: "" }
         };
         operations.push(operation);
+      } else if (rule.type === "mock") {
+        const mock = rule.mock;
+        if (mock === void 0) {
+          throw new Error("validated mock rule missing mock payload");
+        }
+        const operation = {
+          kind: "mock",
+          groupId: group.id,
+          ruleId: rule.id,
+          name: rule.name,
+          redactSensitiveInLogs,
+          matcher,
+          mock
+        };
+        operations.push(operation);
       } else {
         const operation = {
           kind: "matcher",
@@ -2070,9 +2256,16 @@ function sameOrigin(a, b) {
 
 // packages/runtime/dist/node/index.js
 import { isIP as isIP2 } from "node:net";
+import { constants, existsSync } from "node:fs";
+import { open, readlink, realpath } from "node:fs/promises";
+import { isAbsolute, relative } from "node:path";
+import { close, fstat, read } from "node:fs";
+import { createRequire } from "node:module";
+import { constants as constants2 } from "node:fs";
+import { open as open2, realpath as realpath2 } from "node:fs/promises";
+import { isAbsolute as isAbsolute2 } from "node:path";
 import { Buffer as Buffer2 } from "node:buffer";
-import { existsSync } from "node:fs";
-import { createServer as createServer2 } from "node:http";
+import { existsSync as existsSync2 } from "node:fs";
 import { join as join3 } from "node:path";
 import {
   createServer
@@ -2083,24 +2276,24 @@ import { lookup as dnsLookup } from "node:dns/promises";
 import { request as httpRequest } from "node:http";
 import { request as httpsRequest } from "node:https";
 import { createHash as createHash2, randomBytes, timingSafeEqual } from "node:crypto";
+import { spawn } from "node:child_process";
 import { randomBytes as randomBytes2 } from "node:crypto";
-import { readFile as readFile2, realpath as realpath2, stat } from "node:fs/promises";
-import { isAbsolute as isAbsolute2, relative as relative2, resolve, sep } from "node:path";
 import { createHash as createHash3 } from "node:crypto";
-import { mkdir as mkdir2, readFile as readFile3, rename, rm, stat as stat2, writeFile as writeFile2 } from "node:fs/promises";
-import { basename, dirname as dirname2, isAbsolute as isAbsolute3, join as join2, relative as relative3 } from "node:path";
+import { createHash as createHash4 } from "node:crypto";
+import { mkdir as mkdir2, readFile as readFile2, rename, rm, stat, writeFile as writeFile2 } from "node:fs/promises";
+import { basename, dirname as dirname2, isAbsolute as isAbsolute3, join as join2, relative as relative2 } from "node:path";
 import { generateKeyPairSync, webcrypto } from "node:crypto";
-import { spawn, spawnSync } from "node:child_process";
-import { accessSync, constants as constants2, unlinkSync, writeFileSync } from "node:fs";
+import { spawn as spawn2, spawnSync } from "node:child_process";
+import { accessSync, constants as constants3, unlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname as dirname3, join as join4 } from "node:path";
 import { join as posixJoin } from "node:path/posix";
-import { spawn as spawn2, spawnSync as spawnSync2 } from "node:child_process";
-import { accessSync as accessSync2, constants as constants3, mkdirSync, unlinkSync as unlinkSync2 } from "node:fs";
+import { spawn as spawn3, spawnSync as spawnSync2 } from "node:child_process";
+import { accessSync as accessSync2, constants as constants4, mkdirSync, unlinkSync as unlinkSync2 } from "node:fs";
 import { dirname as dirname4 } from "node:path";
 import { join as posixJoin2 } from "node:path/posix";
-import { spawn as spawn3, spawnSync as spawnSync3 } from "node:child_process";
-import { accessSync as accessSync3, constants as constants4, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { spawn as spawn4, spawnSync as spawnSync3 } from "node:child_process";
+import { accessSync as accessSync3, constants as constants5, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
 import { join as join5 } from "node:path";
 import { join as posixJoin3 } from "node:path/posix";
@@ -3347,11 +3540,11 @@ function __metadata(metadataKey, metadataValue) {
 }
 function __awaiter(thisArg, _arguments, P, generator) {
   function adopt(value) {
-    return value instanceof P ? value : new P(function(resolve22) {
-      resolve22(value);
+    return value instanceof P ? value : new P(function(resolve10) {
+      resolve10(value);
     });
   }
-  return new (P || (P = Promise))(function(resolve22, reject) {
+  return new (P || (P = Promise))(function(resolve10, reject) {
     function fulfilled(value) {
       try {
         step(generator.next(value));
@@ -3367,7 +3560,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
       }
     }
     function step(result) {
-      result.done ? resolve22(result.value) : adopt(result.value).then(fulfilled, rejected);
+      result.done ? resolve10(result.value) : adopt(result.value).then(fulfilled, rejected);
     }
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
@@ -3558,14 +3751,14 @@ function __asyncValues(o) {
   }, i);
   function verb(n) {
     i[n] = o[n] && function(v) {
-      return new Promise(function(resolve22, reject) {
-        v = o[n](v), settle(resolve22, reject, v.done, v.value);
+      return new Promise(function(resolve10, reject) {
+        v = o[n](v), settle(resolve10, reject, v.done, v.value);
       });
     };
   }
-  function settle(resolve22, reject, d, v) {
+  function settle(resolve10, reject, d, v) {
     Promise.resolve(v).then(function(v2) {
-      resolve22({ value: v2, done: d });
+      resolve10({ value: v2, done: d });
     }, reject);
   }
 }
@@ -3950,8 +4143,8 @@ var require_build = __commonJS({
           return Buffer.from(buf).toString("base64");
         }
       }
-      static FromBase64(base642) {
-        const formatted = this.formatString(base642);
+      static FromBase64(base64) {
+        const formatted = this.formatString(base64);
         if (!formatted) {
           return new ArrayBuffer(0);
         }
@@ -4062,14 +4255,14 @@ var require_build = __commonJS({
       static FromUtf16String(text, littleEndian = false) {
         return Utf16Converter.fromString(text, littleEndian);
       }
-      static Base64Padding(base642) {
-        const padCount = 4 - base642.length % 4;
+      static Base64Padding(base64) {
+        const padCount = 4 - base64.length % 4;
         if (padCount < 4) {
           for (let i = 0; i < padCount; i++) {
-            base642 += "=";
+            base64 += "=";
           }
         }
-        return base642;
+        return base64;
       }
       static formatString(data) {
         return (data === null || data === void 0 ? void 0 : data.replace(/[\n\r\t ]/g, "")) || "";
@@ -9054,8 +9247,8 @@ var require_convert2 = __commonJS({
       static ToBase64(buffer) {
         return index_js_1.convert.toBase64(buffer);
       }
-      static FromBase64(base642) {
-        return index_js_1.convert.fromBase64(base642);
+      static FromBase64(base64) {
+        return index_js_1.convert.fromBase64(base64);
       }
       static FromBase64Url(base64url) {
         return index_js_1.convert.fromBase64Url(base64url);
@@ -9087,9 +9280,9 @@ var require_convert2 = __commonJS({
       static FromUtf16String(text, littleEndian = false) {
         return index_js_1.convert.fromUtf16String(text, littleEndian);
       }
-      static Base64Padding(base642) {
-        const padCount = 4 - base642.length % 4;
-        return padCount < 4 ? base642 + "=".repeat(padCount) : base642;
+      static Base64Padding(base64) {
+        const padCount = 4 - base64.length % 4;
+        return padCount < 4 ? base64 + "=".repeat(padCount) : base64;
       }
       static formatString(data) {
         return index_js_1.convert.formatString(data);
@@ -15043,11 +15236,11 @@ function __metadata2(metadataKey, metadataValue) {
 }
 function __awaiter2(thisArg, _arguments, P, generator) {
   function adopt(value) {
-    return value instanceof P ? value : new P(function(resolve22) {
-      resolve22(value);
+    return value instanceof P ? value : new P(function(resolve10) {
+      resolve10(value);
     });
   }
-  return new (P || (P = Promise))(function(resolve22, reject) {
+  return new (P || (P = Promise))(function(resolve10, reject) {
     function fulfilled(value) {
       try {
         step(generator.next(value));
@@ -15063,7 +15256,7 @@ function __awaiter2(thisArg, _arguments, P, generator) {
       }
     }
     function step(result) {
-      result.done ? resolve22(result.value) : adopt(result.value).then(fulfilled, rejected);
+      result.done ? resolve10(result.value) : adopt(result.value).then(fulfilled, rejected);
     }
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
@@ -15241,14 +15434,14 @@ function __asyncValues2(o) {
   }, i);
   function verb(n) {
     i[n] = o[n] && function(v) {
-      return new Promise(function(resolve22, reject) {
-        v = o[n](v), settle(resolve22, reject, v.done, v.value);
+      return new Promise(function(resolve10, reject) {
+        v = o[n](v), settle(resolve10, reject, v.done, v.value);
       });
     };
   }
-  function settle(resolve22, reject, d, v) {
+  function settle(resolve10, reject, d, v) {
     Promise.resolve(v).then(function(v2) {
-      resolve22({ value: v2, done: d });
+      resolve10({ value: v2, done: d });
     }, reject);
   }
 }
@@ -15433,13 +15626,13 @@ var require_lazy_helpers = __commonJS({
       }
     };
     exports.DelayedConstructor = DelayedConstructor;
-    function delay2(wrappedConstructor) {
+    function delay(wrappedConstructor) {
       if (typeof wrappedConstructor === "undefined") {
         throw new Error("Attempt to `delay` undefined. Constructor must be wrapped in a callback");
       }
       return new DelayedConstructor(wrappedConstructor);
     }
-    exports.delay = delay2;
+    exports.delay = delay;
   }
 });
 var require_injection_token = __commonJS({
@@ -18445,11 +18638,11 @@ var require_x509_cjs = __commonJS({
         const res = [];
         let matches = null;
         while (matches = pattern.exec(pem)) {
-          const base642 = matches[3].replace(rEolPattern, "");
+          const base64 = matches[3].replace(rEolPattern, "");
           const pemStruct = {
             type: matches[1],
             headers: [],
-            rawData: pvtsutils.Convert.FromBase64(base642)
+            rawData: pvtsutils.Convert.FromBase64(base64)
           };
           const headersString = matches[2];
           if (headersString) {
@@ -18534,9 +18727,9 @@ var require_x509_cjs = __commonJS({
           }
           res.push("");
         }
-        const base642 = pvtsutils.Convert.ToBase64(pem.rawData);
-        for (let i = 0; i < base642.length; i += 64) {
-          res.push(base642.substring(i, i + 64));
+        const base64 = pvtsutils.Convert.ToBase64(pem.rawData);
+        for (let i = 0; i < base64.length; i += 64) {
+          res.push(base64.substring(i, i + 64));
         }
         res.push(`-----END ${upperCaseType}-----`);
         return res.join("\n");
@@ -20915,7 +21108,7 @@ var RETRY_DELAY_BASE = 1e3;
 var COMPLETE_TIMEOUT = 6e4;
 var STREAM_TIMEOUT = 12e4;
 function sleep(ms) {
-  return new Promise((resolve22) => setTimeout(resolve22, ms));
+  return new Promise((resolve10) => setTimeout(resolve10, ms));
 }
 function calculateRetryDelay(attempt) {
   return RETRY_DELAY_BASE * 2 ** attempt + Math.random() * 100;
@@ -20943,8 +21136,8 @@ async function fetchWithRetry(url, init, signal) {
       const shouldRetry = response.status === 429 || response.status >= 500;
       if (shouldRetry && attempt < MAX_RETRIES) {
         const retryAfter = response.headers.get("Retry-After");
-        const delay2 = retryAfter ? parseInt(retryAfter, 10) * 1e3 : calculateRetryDelay(attempt);
-        await sleep(Math.min(delay2, 1e4));
+        const delay = retryAfter ? parseInt(retryAfter, 10) * 1e3 : calculateRetryDelay(attempt);
+        await sleep(Math.min(delay, 1e4));
         continue;
       }
       const errorText = await response.text().catch(() => "");
@@ -20986,8 +21179,8 @@ async function fetchStreamWithRetry(url, init, signal) {
       const shouldRetry = response.status === 429 || response.status >= 500;
       if (shouldRetry && attempt < MAX_RETRIES) {
         const retryAfter = response.headers.get("Retry-After");
-        const delay2 = retryAfter ? parseInt(retryAfter, 10) * 1e3 : calculateRetryDelay(attempt);
-        await sleep(Math.min(delay2, 1e4));
+        const delay = retryAfter ? parseInt(retryAfter, 10) * 1e3 : calculateRetryDelay(attempt);
+        await sleep(Math.min(delay, 1e4));
         continue;
       }
       const errorText = await response.text().catch(() => "");
@@ -21939,12 +22132,299 @@ var RUNTIME_LIMITS = Object.freeze({
   maxRegexDeadlineMs: 250,
   maxLocalOrigins: 32
 });
+var F_GETPATH = 50;
+var MAXPATHLEN = 1024;
+var O_CLOEXEC = 16777216;
+var LIB_SYSTEM = "/usr/lib/libSystem.B.dylib";
+var binding;
+function loadKoffi() {
+  const require2 = createRequire(import.meta.url);
+  const loaded = require2("koffi");
+  if (typeof loaded.load === "function") {
+    return loaded;
+  }
+  return loaded.default;
+}
+function decodePath(value) {
+  if (typeof value !== "string" || value.length === 0 || value.length >= MAXPATHLEN) {
+    return null;
+  }
+  const end = value.indexOf("\0");
+  const path2 = end === -1 ? value : value.slice(0, end);
+  return path2.length > 0 ? path2 : null;
+}
+function loadDarwinConfined() {
+  if (binding) return binding;
+  const koffi = loadKoffi();
+  const lib = koffi.load(LIB_SYSTEM);
+  const openat = lib.func(
+    "int openat(int dirfd, const char *pathname, int flags, ...)"
+  );
+  const fcntl = lib.func("int fcntl(int fd, int cmd, ...)");
+  binding = {
+    openat(dirfd, path2, flags) {
+      const fd = openat(dirfd, path2, flags | O_CLOEXEC);
+      if (typeof fd !== "number" || fd < 0) {
+        throw new Error("openat failed");
+      }
+      return fd;
+    },
+    pathOf(fd) {
+      try {
+        const out = ["\0".repeat(MAXPATHLEN)];
+        const result = fcntl(fd, F_GETPATH, "_Out_ char *", out);
+        if (typeof result !== "number" || result < 0) return null;
+        return decodePath(out[0]);
+      } catch {
+        return null;
+      }
+    }
+  };
+  return binding;
+}
+function darwinConfinedAvailable() {
+  if (process.platform !== "darwin") return false;
+  try {
+    loadDarwinConfined();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isSingleComponent(component) {
+  return component.length > 0 && component !== "." && component !== ".." && !component.includes("/") && !component.includes("\\") && !component.includes("\0");
+}
+function handleFromFd(fd) {
+  let closed = false;
+  return {
+    fd,
+    read(buffer, offset, length, position) {
+      return new Promise((resolve10, reject) => {
+        read(fd, buffer, offset, length, position, (error, bytesRead) => {
+          if (error) reject(error);
+          else resolve10({ bytesRead });
+        });
+      });
+    },
+    stat() {
+      return new Promise((resolve10, reject) => {
+        fstat(fd, (error, stats) => {
+          if (error) reject(error);
+          else resolve10(stats);
+        });
+      });
+    },
+    async close() {
+      if (closed) return;
+      closed = true;
+      await new Promise((resolve10, reject) => {
+        close(fd, (error) => {
+          if (error) reject(error);
+          else resolve10();
+        });
+      });
+    }
+  };
+}
+async function openDarwinRelative(dirFd, component, flags) {
+  if (!isSingleComponent(component)) throw new Error("openat rejected");
+  const fd = loadDarwinConfined().openat(dirFd, component, flags);
+  return handleFromFd(fd);
+}
+async function darwinPathOf(fd) {
+  return loadDarwinConfined().pathOf(fd);
+}
+function isConfinedFileSupported() {
+  if (process.platform === "linux") {
+    return typeof constants.O_NOFOLLOW === "number" && typeof constants.O_DIRECTORY === "number" && typeof constants.O_NONBLOCK === "number" && existsSync("/proc/self/fd");
+  }
+  return darwinConfinedAvailable();
+}
+function fdRelativePath(dirFd, component) {
+  return `/proc/self/fd/${dirFd}/${component}`;
+}
+function withinRoot(root, candidate) {
+  const rest = relative(root, candidate);
+  return rest.length > 0 && rest !== ".." && !rest.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) && !isAbsolute(rest);
+}
+function fromNodeHandle(file) {
+  return {
+    fd: file.fd,
+    read: (buffer, offset, length, position) => file.read(buffer, offset, length, position),
+    stat: () => file.stat(),
+    close: () => file.close()
+  };
+}
+var linuxOps = {
+  async openRelative(dirFd, component, flags) {
+    return fromNodeHandle(await open(fdRelativePath(dirFd, component), flags));
+  },
+  async pathOf(fd) {
+    try {
+      return await readlink(`/proc/self/fd/${fd}`);
+    } catch {
+      return null;
+    }
+  }
+};
+function platformOps() {
+  if (process.platform === "linux" && isConfinedFileSupported())
+    return linuxOps;
+  if (process.platform === "darwin" && darwinConfinedAvailable()) {
+    return { openRelative: openDarwinRelative, pathOf: darwinPathOf };
+  }
+  return void 0;
+}
+async function closeQuietly(file) {
+  try {
+    await file.close();
+  } catch {
+  }
+}
+async function proveDescriptorWithinRoot(file, canonicalRoot, pathOf) {
+  const resolved = await pathOf(file.fd);
+  if (resolved === null || !withinRoot(canonicalRoot, resolved)) {
+    return failure("runtime.file-race-rejected");
+  }
+  return { ok: true, value: void 0 };
+}
+function openFlags(directory) {
+  if (directory) {
+    return constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW;
+  }
+  return constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK;
+}
+async function openConfinedUsing(root, logicalPath, ops) {
+  const normalized = normalizeLogicalPath(logicalPath);
+  if (normalized === null) return failure("runtime.file-denied");
+  const components = normalized.split("/");
+  let parent;
+  try {
+    const canonicalRoot = await realpath(root);
+    parent = fromNodeHandle(
+      await open(canonicalRoot, constants.O_RDONLY | constants.O_DIRECTORY)
+    );
+    for (let index = 0; index < components.length - 1; index += 1) {
+      const component = components[index] ?? "";
+      const next = await ops.openRelative(
+        parent.fd,
+        component,
+        openFlags(true)
+      );
+      await closeQuietly(parent);
+      parent = next;
+    }
+    const leaf = components[components.length - 1] ?? "";
+    const file = await ops.openRelative(parent.fd, leaf, openFlags(false));
+    await closeQuietly(parent);
+    parent = void 0;
+    try {
+      const containment = await proveDescriptorWithinRoot(
+        file,
+        canonicalRoot,
+        ops.pathOf
+      );
+      if (!containment.ok) {
+        await closeQuietly(file);
+        return containment;
+      }
+      const stat22 = await file.stat();
+      if (!stat22.isFile()) {
+        await closeQuietly(file);
+        return failure("runtime.file-denied");
+      }
+      if (stat22.nlink !== 1) {
+        await closeQuietly(file);
+        return failure("runtime.file-race-rejected");
+      }
+      if (stat22.size > RUNTIME_LIMITS.maxFileBytes) {
+        await closeQuietly(file);
+        return failure("runtime.size-limit");
+      }
+      return { ok: true, value: file };
+    } catch {
+      await closeQuietly(file);
+      return failure("runtime.file-denied");
+    }
+  } catch {
+    return failure("runtime.file-denied");
+  } finally {
+    if (parent !== void 0) await closeQuietly(parent);
+  }
+}
+async function openConfinedFile(root, logicalPath) {
+  if (normalizeLogicalPath(logicalPath) === null) {
+    return failure("runtime.file-denied");
+  }
+  const ops = platformOps();
+  if (ops === void 0) return failure("runtime.platform-unsupported");
+  return openConfinedUsing(root, logicalPath, ops);
+}
+async function closeQuietly2(file) {
+  try {
+    await file.close();
+  } catch {
+  }
+}
+async function readOpenedConfinedFile(file, signal) {
+  try {
+    const chunks = [];
+    let total = 0;
+    let position = 0;
+    while (true) {
+      if (signal?.aborted) return failure("runtime.timeout");
+      const buffer = Buffer.allocUnsafe(
+        Math.min(64 * 1024, RUNTIME_LIMITS.maxFileBytes - total + 1)
+      );
+      const read2 = await file.read(buffer, 0, buffer.byteLength, position);
+      if (read2.bytesRead === 0) break;
+      total += read2.bytesRead;
+      if (total > RUNTIME_LIMITS.maxFileBytes)
+        return failure("runtime.size-limit");
+      chunks.push(Uint8Array.from(buffer.subarray(0, read2.bytesRead)));
+      position += read2.bytesRead;
+    }
+    const finalStat = await file.stat();
+    if (!finalStat.isFile() || finalStat.nlink !== 1 || finalStat.size > RUNTIME_LIMITS.maxFileBytes || finalStat.size !== total) {
+      return failure(
+        finalStat.size > RUNTIME_LIMITS.maxFileBytes ? "runtime.size-limit" : "runtime.file-race-rejected"
+      );
+    }
+    const output = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+      output.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return { ok: true, value: output };
+  } catch {
+    return signal?.aborted ? failure("runtime.timeout") : failure("runtime.file-denied");
+  }
+}
+async function readConfinedPathBytes(root, logicalPath, signal) {
+  const normalized = normalizeLogicalPath(logicalPath);
+  if (normalized === null) return failure("runtime.file-denied");
+  if (!isConfinedFileSupported())
+    return failure("runtime.platform-unsupported");
+  if (signal?.aborted) return failure("runtime.timeout");
+  const opened = await openConfinedFile(root, normalized);
+  if (!opened.ok) return opened;
+  const file = opened.value;
+  try {
+    return await readOpenedConfinedFile(file, signal);
+  } finally {
+    await closeQuietly2(file);
+  }
+}
 var PROTOCOL = "v1";
 var ENVELOPE_MAX_BYTES = 64 * 1024;
 var MAX_PAC_ROUTES = 256;
-var FORBIDDEN_BODY_KEYS = /* @__PURE__ */ new Set(["body", "requestBody", "responseBody"]);
-var MOCK_BODY_KEY = "mockBody";
-var MOCK_BODY_ALLOWED_TYPES = /* @__PURE__ */ new Set(["mock.response"]);
+var FORBIDDEN_BODY_KEYS = /* @__PURE__ */ new Set([
+  "body",
+  "requestBody",
+  "responseBody",
+  "mockBody"
+]);
 var BODY_CHECK_EXEMPT_TYPES = /* @__PURE__ */ new Set(["runtime.project.set"]);
 var ENVELOPE_MESSAGE_TYPES = /* @__PURE__ */ new Set([
   "runtime.start",
@@ -21962,12 +22442,13 @@ var ENVELOPE_MESSAGE_TYPES = /* @__PURE__ */ new Set([
   "authorize.request",
   "authorize.response",
   "mock.connect",
-  "mock.request",
-  "mock.response",
   "ai.complete",
   "ai.stream.chunk",
   "ai.error",
-  "ai.status"
+  "ai.status",
+  "runtime.pick-directory",
+  "runtime.check-directory",
+  "runtime.set-file-root"
 ]);
 var EnvelopeError = class extends Error {
   constructor(message) {
@@ -21996,11 +22477,6 @@ function assertNoBodyContent(type, metadata) {
       "envelope must not carry request or response body content"
     );
   }
-  if (MOCK_BODY_KEY in metadata && !MOCK_BODY_ALLOWED_TYPES.has(type)) {
-    throw new EnvelopeError(
-      "mockBody is only permitted on the mock.response envelope"
-    );
-  }
 }
 function utf8ByteLength(value) {
   return Buffer.byteLength(value, "utf8");
@@ -22080,6 +22556,45 @@ function describeExtensionIdMismatch(expectedExtensionId, allowedOrigins) {
     `Run: ${command}`
   ].join("\n");
 }
+async function resolveConfinedRoot(value) {
+  if (typeof value !== "string" || value.length === 0 || !isAbsolute2(value)) {
+    return failure("runtime.root-invalid");
+  }
+  let directory;
+  try {
+    directory = await open2(value, constants2.O_RDONLY | constants2.O_DIRECTORY);
+    const info = await directory.stat();
+    if (!info.isDirectory()) return failure("runtime.root-invalid");
+    return { ok: true, value: await realpath2(value) };
+  } catch {
+    return failure("runtime.root-invalid");
+  } finally {
+    await directory?.close().catch(() => void 0);
+  }
+}
+var MOCK_LISTENER_PREFIX = "/.rogatio/mock/";
+function isSingleSegment(value) {
+  return value.length > 0 && value.length <= 2048 && value !== "." && value !== ".." && !value.includes("/") && !value.includes("\\") && !value.includes("?") && !hasControl(value);
+}
+function parseMockRedirect(rawUrl) {
+  const queryAt = rawUrl.indexOf("?");
+  const path2 = queryAt === -1 ? rawUrl : rawUrl.slice(0, queryAt);
+  if (!path2.startsWith(MOCK_LISTENER_PREFIX)) return null;
+  const rest = path2.slice(MOCK_LISTENER_PREFIX.length);
+  const slash = rest.indexOf("/");
+  if (slash <= 0) return null;
+  if (rest.indexOf("/", slash + 1) !== -1) return null;
+  let token;
+  let digest;
+  try {
+    token = decodeURIComponent(rest.slice(0, slash));
+    digest = decodeURIComponent(rest.slice(slash + 1));
+  } catch {
+    return null;
+  }
+  if (!isSingleSegment(token) || !isSingleSegment(digest)) return null;
+  return { token, digest };
+}
 function supportedContentType(value) {
   if (value === void 0) return false;
   const mediaType = value.split(";", 1)[0]?.trim().toLowerCase() ?? "";
@@ -22124,7 +22639,7 @@ function discardRegexWorker(worker) {
 function bootRegexWorker() {
   if (regexWorker !== null) return Promise.resolve(regexWorker);
   if (regexWorkerBoot !== null) return regexWorkerBoot;
-  const boot = new Promise((resolve22, reject) => {
+  const boot = new Promise((resolve10, reject) => {
     const start = () => {
       let worker;
       try {
@@ -22158,7 +22673,7 @@ function bootRegexWorker() {
           }
         });
         regexWorker = worker;
-        resolve22(worker);
+        resolve10(worker);
       });
       worker.once("error", (error) => {
         if (settled) return;
@@ -22176,9 +22691,9 @@ function bootRegexWorker() {
       });
     };
     if (regexWorkerBootDelayForTestsMs > 0) {
-      const delay2 = regexWorkerBootDelayForTestsMs;
+      const delay = regexWorkerBootDelayForTestsMs;
       regexWorkerBootDelayForTestsMs = 0;
-      setTimeout(start, delay2).unref();
+      setTimeout(start, delay).unref();
     } else {
       start();
     }
@@ -22190,7 +22705,7 @@ function bootRegexWorker() {
   return boot;
 }
 function runOnRegexWorker(worker, id2, text, pattern, replacement, deadlineMs) {
-  return new Promise((resolve22, reject) => {
+  return new Promise((resolve10, reject) => {
     let timer = null;
     const cleanup = () => {
       if (timer !== null) clearTimeout(timer);
@@ -22210,7 +22725,7 @@ function runOnRegexWorker(worker, id2, text, pattern, replacement, deadlineMs) {
       }
       if (msg.type === "result") {
         cleanup();
-        if (msg.ok && typeof msg.out === "string") resolve22(msg.out);
+        if (msg.ok && typeof msg.out === "string") resolve10(msg.out);
         else reject(new Error(msg.error || "regex-invalid"));
       }
     };
@@ -22336,7 +22851,7 @@ function responseHeaders(response) {
 }
 var defaultTransport = {
   request(options) {
-    return new Promise((resolve22, reject) => {
+    return new Promise((resolve10, reject) => {
       const lookup = (_hostname, _options, callback) => {
         callback(null, options.address, options.address.includes(":") ? 6 : 4);
       };
@@ -22355,14 +22870,14 @@ var defaultTransport = {
       const request = options.protocol === "https:" ? httpsRequest(
         { ...requestOptions, servername: options.servername },
         (response) => {
-          resolve22({
+          resolve10({
             status: response.statusCode ?? 0,
             headers: responseHeaders(response),
             body: response
           });
         }
       ) : httpRequest(requestOptions, (response) => {
-        resolve22({
+        resolve10({
           status: response.statusCode ?? 0,
           headers: responseHeaders(response),
           body: response
@@ -22374,7 +22889,7 @@ var defaultTransport = {
   }
 };
 function headerValue(headers, name) {
-  return headers.find(([headerName]) => headerName.toLowerCase() === name)?.[1];
+  return headers.find(([headerName2]) => headerName2.toLowerCase() === name)?.[1];
 }
 function responseHeaderBytes(headers) {
   let bytes = 0;
@@ -22714,14 +23229,14 @@ function headerValue2(headers, name) {
   return raw;
 }
 function readBoundedBody(req, maxBytes) {
-  return new Promise((resolve22) => {
+  return new Promise((resolve10) => {
     const chunks = [];
     let total = 0;
     let settled = false;
     const finish2 = (result) => {
       if (settled) return;
       settled = true;
-      resolve22(result);
+      resolve10(result);
     };
     req.on("data", (chunk) => {
       total += chunk.byteLength;
@@ -22785,7 +23300,7 @@ function pipeSockets(a, b) {
 async function upstreamHttp(method, target, headers, body) {
   const port = target.port ? Number(target.port) : 80;
   const path2 = `${target.pathname}${target.search}`;
-  return new Promise((resolve22, reject) => {
+  return new Promise((resolve10, reject) => {
     const socket = connect(port, target.hostname);
     let buf = Buffer.alloc(0);
     let settled = false;
@@ -22809,9 +23324,9 @@ ${lines}\r
     socket.on("data", (chunk) => {
       const piece = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
       buf = Buffer.concat([buf, piece]);
-      const sep2 = buf.indexOf("\r\n\r\n");
-      if (sep2 < 0) return;
-      const head = buf.subarray(0, sep2).toString("latin1");
+      const sep = buf.indexOf("\r\n\r\n");
+      if (sep < 0) return;
+      const head = buf.subarray(0, sep).toString("latin1");
       const statusMatch = /^HTTP\/1\.[01] (\d+)(?: (.*))?/.exec(
         head.split("\r\n")[0] ?? ""
       );
@@ -22835,13 +23350,13 @@ ${lines}\r
       const clRaw = headerMap["content-length"];
       const hasContentLength = clRaw !== void 0;
       const cl = typeof clRaw === "string" ? Number(clRaw) : Array.isArray(clRaw) ? Number(clRaw[0]) : Number.NaN;
-      const bodyStart = sep2 + 4;
+      const bodyStart = sep + 4;
       if (hasContentLength && Number.isFinite(cl) && cl >= 0) {
         if (buf.length - bodyStart < cl) return;
         if (settled) return;
         settled = true;
         socket.destroy();
-        resolve22({
+        resolve10({
           status,
           statusMessage,
           headers: headerMap,
@@ -22852,12 +23367,12 @@ ${lines}\r
     });
     socket.on("end", () => {
       if (settled) return;
-      const sep2 = buf.indexOf("\r\n\r\n");
-      if (sep2 < 0) {
+      const sep = buf.indexOf("\r\n\r\n");
+      if (sep < 0) {
         fail(new Error("upstream closed early"));
         return;
       }
-      const head = buf.subarray(0, sep2).toString("latin1");
+      const head = buf.subarray(0, sep).toString("latin1");
       const statusMatch = /^HTTP\/1\.[01] (\d+)(?: (.*))?/.exec(
         head.split("\r\n")[0] ?? ""
       );
@@ -22871,7 +23386,7 @@ ${lines}\r
         if (i <= 0) continue;
         headerMap[line.slice(0, i).trim().toLowerCase()] = line.slice(i + 1).trim();
       }
-      let body2 = Buffer.from(buf.subarray(sep2 + 4));
+      let body2 = Buffer.from(buf.subarray(sep + 4));
       const te = headerMap["transfer-encoding"];
       const teValue = Array.isArray(te) ? te[0] : te;
       if (typeof teValue === "string" && teValue.toLowerCase().includes("chunked")) {
@@ -22880,7 +23395,7 @@ ${lines}\r
         headerMap["content-length"] = String(body2.byteLength);
       }
       settled = true;
-      resolve22({
+      resolve10({
         status: Number(statusMatch[1]),
         statusMessage: statusMatch[2]?.trim() ?? "",
         headers: headerMap,
@@ -22955,6 +23470,10 @@ function authorizeOp(policy, op, url, method, headers) {
 }
 async function startInterceptProxy(options = {}) {
   let policy = options.policy ?? null;
+  const serveMock = options.serveMock;
+  let activeMocks = 0;
+  const mockAborts = /* @__PURE__ */ new Set();
+  let stopped = false;
   const server = createServer((req, res) => {
     void handleHttp(req, res);
   });
@@ -22968,6 +23487,10 @@ async function startInterceptProxy(options = {}) {
         await handleResponseBodyRedirect(req, res, targetUrl);
         return;
       }
+      if (targetUrl.startsWith(MOCK_LISTENER_PREFIX.slice(0, -1))) {
+        await handleMockRedirect(req, res, targetUrl);
+        return;
+      }
       if (!/^https?:\/\//i.test(targetUrl)) {
         res.writeHead(400);
         res.end();
@@ -23083,6 +23606,71 @@ async function startInterceptProxy(options = {}) {
       }
     }
   }
+  function endEmpty(res, status) {
+    if (res.writableEnded) return;
+    res.writeHead(status, {
+      "cache-control": "no-store",
+      "content-length": "0"
+    });
+    res.end();
+  }
+  function discardRequestBody(req) {
+    req.on("data", () => {
+    });
+    req.resume();
+  }
+  async function handleMockRedirect(req, res, rawUrl) {
+    discardRequestBody(req);
+    const parsed = parseMockRedirect(rawUrl);
+    if (parsed === null) {
+      endEmpty(res, 400);
+      return;
+    }
+    const active = policy;
+    if (serveMock === void 0 || active === null || active.presetDigest === void 0 || active.presetDigest.length === 0) {
+      endEmpty(res, 403);
+      return;
+    }
+    if (parsed.digest !== active.presetDigest) {
+      endEmpty(res, 403);
+      return;
+    }
+    if (activeMocks >= RUNTIME_LIMITS.maxConcurrentOperations) {
+      endEmpty(res, 429);
+      return;
+    }
+    activeMocks += 1;
+    const abort = new AbortController();
+    mockAborts.add(abort);
+    const cancel = () => {
+      if (!res.writableFinished) abort.abort();
+    };
+    req.on("aborted", cancel);
+    res.on("close", cancel);
+    try {
+      const rendered = await serveMock({
+        token: parsed.token,
+        method: (req.method ?? "GET").toUpperCase(),
+        signal: abort.signal
+      });
+      if (abort.signal.aborted || res.writableEnded) return;
+      if (!rendered.ok) {
+        const status = rendered.error.code === "runtime.unsupported-method" ? 405 : rendered.error.code === "runtime.mock-unknown" ? 404 : 502;
+        endEmpty(res, status);
+        return;
+      }
+      res.writeHead(
+        rendered.value.status,
+        rendered.value.headers.map(([name, value]) => [name, value])
+      );
+      res.end(Buffer.from(rendered.value.bodyBytes));
+    } catch {
+      endEmpty(res, 502);
+    } finally {
+      mockAborts.delete(abort);
+      activeMocks = Math.max(0, activeMocks - 1);
+    }
+  }
   async function handleResponseBodyRedirect(req, res, rawUrl) {
     const method = (req.method ?? "GET").toUpperCase();
     if (method !== "GET") {
@@ -23194,7 +23782,7 @@ async function startInterceptProxy(options = {}) {
     });
     clientSocket.on("error", () => upstream.destroy());
   }
-  const endpoint = await new Promise((resolve22, reject) => {
+  const endpoint = await new Promise((resolve10, reject) => {
     server.once("error", reject);
     server.listen(0, "127.0.0.1", () => {
       const addr = server.address();
@@ -23202,7 +23790,7 @@ async function startInterceptProxy(options = {}) {
         reject(new Error("intercept-proxy bind failed"));
         return;
       }
-      resolve22({ host: "127.0.0.1", port: addr.port });
+      resolve10({ host: "127.0.0.1", port: addr.port });
     });
   });
   return {
@@ -23211,8 +23799,12 @@ async function startInterceptProxy(options = {}) {
       policy = next;
     },
     async stop() {
-      await new Promise((resolve22, reject) => {
-        server.close((err) => err ? reject(err) : resolve22());
+      if (stopped) return;
+      stopped = true;
+      for (const abort of mockAborts) abort.abort();
+      server.closeAllConnections();
+      await new Promise((resolve10, reject) => {
+        server.close((err) => err ? reject(err) : resolve10());
       });
     }
   };
@@ -23315,7 +23907,7 @@ async function startInterception(activation, policyDigest, extensionId, pacRoute
     return { kind: "unsupported", reasons: ["no-interception-provider"] };
   }
   const capabilities = registeredProvider.detect();
-  if (!capabilities.supported) {
+  if (pacRoutes.length > 0 && !capabilities.supported) {
     return { kind: "unsupported", reasons: capabilities.reasons };
   }
   if (currentSession !== null) {
@@ -23546,68 +24138,194 @@ function closeCapabilityState(state) {
   state.sessions.length = 0;
   state.bootstrapDigest.fill(0);
 }
-function withinRoot2(root, candidate) {
-  const rest = relative2(root, candidate);
-  return rest.length > 0 && rest !== ".." && !rest.startsWith(`..${sep}`) && !isAbsolute2(rest);
-}
-async function readMockFile(root, logicalPath) {
-  const normalized = normalizeLogicalPath(logicalPath);
-  if (normalized === null) return failure("runtime.file-denied");
-  try {
-    const canonicalRoot = await realpath2(root);
-    const candidate = resolve(canonicalRoot, ...normalized.split("/"));
-    const actualPath = await realpath2(candidate);
-    if (!withinRoot2(canonicalRoot, actualPath))
-      return failure("runtime.file-denied");
-    const metadata = await stat(actualPath);
-    if (!metadata.isFile()) return failure("runtime.file-denied");
-    if (metadata.size > RUNTIME_LIMITS.maxFileBytes)
-      return failure("runtime.size-limit");
-    const bytes = await readFile2(actualPath);
-    if (bytes.byteLength > RUNTIME_LIMITS.maxFileBytes)
-      return failure("runtime.size-limit");
-    new TextDecoder("utf-8", { fatal: true }).decode(bytes);
-    return { ok: true, value: bytes };
-  } catch {
-    return failure("runtime.file-denied");
+var WINDOWS_FOLDER_SCRIPT = [
+  "Add-Type -AssemblyName System.Windows.Forms",
+  "$dialog = New-Object System.Windows.Forms.FolderBrowserDialog",
+  "$dialog.Description = 'Mock files folder'",
+  "if ($dialog.ShowDialog() -eq 'OK') { $dialog.SelectedPath }"
+].join("; ");
+function directoryDialogCommands(platform = process.platform) {
+  if (platform === "darwin") {
+    return [
+      {
+        command: "osascript",
+        args: [
+          "-e",
+          'POSIX path of (choose folder with prompt "Choose the mock files folder")'
+        ]
+      }
+    ];
+  }
+  if (platform === "win32") {
+    return [
+      {
+        command: "powershell.exe",
+        args: ["-NoProfile", "-STA", "-Command", WINDOWS_FOLDER_SCRIPT]
+      }
+    ];
   }
+  if (platform === "linux") {
+    return [
+      {
+        command: "zenity",
+        args: ["--file-selection", "--directory", "--title=Mock files folder"]
+      },
+      {
+        command: "kdialog",
+        args: ["--getexistingdirectory", "--title", "Mock files folder"]
+      }
+    ];
+  }
+  return [];
+}
+var MAX_PICK_STDOUT = 4096;
+function runDialog(command, args) {
+  return new Promise((resolve10) => {
+    let settled = false;
+    const finish2 = (result) => {
+      if (settled) return;
+      settled = true;
+      resolve10(result);
+    };
+    const options = {
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: false
+    };
+    const child = spawn(command, [...args], options);
+    const chunks = [];
+    let size = 0;
+    child.stdout?.on("data", (chunk) => {
+      size += chunk.length;
+      if (size <= MAX_PICK_STDOUT) chunks.push(chunk);
+    });
+    child.on("error", (error) => {
+      finish2({ code: null, stdout: "", errorCode: error.code });
+    });
+    child.on("close", (code) => {
+      finish2({
+        code,
+        stdout: Buffer.concat(chunks).toString("utf8"),
+        ...size > MAX_PICK_STDOUT ? { errorCode: "too-large" } : {}
+      });
+    });
+  });
+}
+async function pickDirectory(run = runDialog, platform = process.platform) {
+  const commands = directoryDialogCommands(platform);
+  if (commands.length === 0) {
+    return { ok: false, code: "runtime.picker-unavailable" };
+  }
+  for (const dialog of commands) {
+    const result = await run(dialog.command, dialog.args);
+    if (result.errorCode === "ENOENT") continue;
+    if (result.errorCode !== void 0) {
+      return { ok: false, code: "runtime.picker-unavailable" };
+    }
+    if (result.code === 0) {
+      const path2 = result.stdout.trim();
+      return { ok: true, path: path2.length === 0 ? null : path2 };
+    }
+    if (result.code === 1) return { ok: true, path: null };
+    return { ok: false, code: "runtime.picker-unavailable" };
+  }
+  return { ok: false, code: "runtime.picker-unavailable" };
+}
+async function readMockFile(root, logicalPath, signal) {
+  return readConfinedPathBytes(root, logicalPath, signal);
 }
 function mintToken() {
   return randomBytes2(32).toString("hex");
 }
+function headerName(name) {
+  return name.toLowerCase();
+}
+function waitForDelay(delayMs, signal) {
+  if (signal?.aborted) return Promise.resolve(failure("runtime.timeout"));
+  if (delayMs === void 0 || delayMs <= 0) {
+    return Promise.resolve({ ok: true, value: void 0 });
+  }
+  return new Promise((resolve10) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve10(failure("runtime.timeout"));
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve10({ ok: true, value: void 0 });
+    }, delayMs);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
 async function renderMockResponse(options) {
-  const { mock, fileRoot } = options;
-  let bodyBytes;
+  const { mock, fileRoot, method, signal } = options;
+  const waited = await waitForDelay(mock.delayMs, signal);
+  if (!waited.ok) return waited;
+  let fullBytes;
   if (mock.body !== void 0) {
-    bodyBytes = new TextEncoder().encode(mock.body);
+    fullBytes = new TextEncoder().encode(mock.body);
   } else if (mock.file !== void 0) {
     if (fileRoot === void 0) return failure("runtime.file-denied");
-    const read = await readMockFile(fileRoot, mock.file);
-    if (!read.ok) return failure("runtime.file-denied");
-    bodyBytes = read.value;
+    if (!isConfinedFileSupported()) {
+      return failure("runtime.platform-unsupported");
+    }
+    const read2 = await readMockFile(fileRoot, mock.file, signal);
+    if (!read2.ok) return read2;
+    fullBytes = read2.value;
   } else {
     return failure("runtime.file-denied");
   }
   const headers = [];
   let hasContentType = false;
+  let hasCacheControl = false;
   for (const header of mock.headers ?? []) {
+    const name = headerName(header.name);
+    if (name === "content-length") continue;
+    if (name === "content-type") hasContentType = true;
+    if (name === "cache-control") hasCacheControl = true;
     headers.push([header.name, header.value]);
-    if (header.name.toLowerCase() === "content-type") hasContentType = true;
   }
   if (!hasContentType) {
-    headers.push(["Content-Type", "text/plain; charset=UTF-8"]);
+    headers.push(["Content-Type", "application/octet-stream"]);
   }
-  headers.push(["Content-Length", String(bodyBytes.byteLength)]);
-  headers.push(["Cache-Control", "no-store"]);
+  headers.push(["Content-Length", String(fullBytes.byteLength)]);
+  if (!hasCacheControl) headers.push(["Cache-Control", "no-store"]);
   return {
     ok: true,
     value: {
       status: mock.status,
       headers,
-      bodyBytes
+      bodyBytes: method === "HEAD" ? new Uint8Array() : fullBytes
     }
   };
 }
+var MAX_MOCK_FILE_ERRORS = 64;
+var FILE_ERROR_CODES = /* @__PURE__ */ new Set([
+  "runtime.file-denied",
+  "runtime.file-race-rejected",
+  "runtime.size-limit",
+  "runtime.platform-unsupported"
+]);
+function isMockFileError(code) {
+  return FILE_ERROR_CODES.has(code);
+}
+function recordMockFileError(errors, ruleId, code) {
+  if (!isMockFileError(code)) return;
+  if (errors.has(ruleId)) errors.delete(ruleId);
+  errors.set(ruleId, code);
+  while (errors.size > MAX_MOCK_FILE_ERRORS) {
+    const oldest = errors.keys().next().value;
+    if (oldest === void 0) break;
+    errors.delete(oldest);
+  }
+}
+function clearMockFileError(errors, ruleId) {
+  errors.delete(ruleId);
+}
+function listMockFileErrors(errors) {
+  return [...errors.entries()].map(([ruleId, code]) => ({ ruleId, code })).sort(
+    (left, right) => left.ruleId < right.ruleId ? -1 : left.ruleId > right.ruleId ? 1 : 0
+  );
+}
 function stringValue(value) {
   const encoded = JSON.stringify(value);
   if (encoded === void 0) throw new Error("invalid string");
@@ -23654,10 +24372,10 @@ function mockHeaderValue(header) {
 }
 function mockValue(mock) {
   const headers = mock.headers === void 0 ? "" : `,"headers":[${mock.headers.map(mockHeaderValue).join(",")}]`;
-  const delay2 = mock.delayMs === void 0 ? "" : `,"delayMs":${String(mock.delayMs)}`;
+  const delay = mock.delayMs === void 0 ? "" : `,"delayMs":${String(mock.delayMs)}`;
   const body = mock.body !== void 0 ? `,"body":${stringValue(mock.body)}` : "";
   const file = mock.file !== void 0 ? `,"file":${stringValue(mock.file)}` : "";
-  return `{"ruleId":${stringValue(mock.ruleId)},"status":${String(mock.status)}${headers}${delay2}${body}${file}}`;
+  return `{"ruleId":${stringValue(mock.ruleId)},"status":${String(mock.status)}${headers}${delay}${body}${file}}`;
 }
 function sortMocks(mocks) {
   return [...mocks].sort(
@@ -23701,7 +24419,7 @@ function normalizeMockHeader(value) {
   const record = value;
   if (typeof record.name !== "string" || record.name.length === 0 || record.name.length > LIMITS.maxMockHeaderNameLength || hasControl(record.name) || record.name.includes(":"))
     return null;
-  if (typeof record.value !== "string" || record.value.length > LIMITS.maxMockHeaderValueLength)
+  if (typeof record.value !== "string" || record.value.length > LIMITS.maxMockHeaderValueLength || hasControl(record.value))
     return null;
   return { name: record.name, value: record.value };
 }
@@ -23905,6 +24623,26 @@ function makeGrant(value, matcherById) {
     method: record.method
   });
 }
+function parseEnabledGroupIds(metadata, groupIds) {
+  if (!hasOwn(metadata, "enabledGroupIds")) {
+    return { ok: true, value: void 0 };
+  }
+  const value = metadata.enabledGroupIds;
+  if (!Array.isArray(value) || value.length > LIMITS.maxGroups) {
+    return failure("runtime.groups-invalid");
+  }
+  const known = new Set(groupIds);
+  const enabled = /* @__PURE__ */ new Set();
+  for (let index = 0; index < value.length; index += 1) {
+    if (!Object.hasOwn(value, index)) return failure("runtime.groups-invalid");
+    const id2 = value[index];
+    if (typeof id2 !== "string" || !ID_PATTERN2.test(id2) || !known.has(id2) || enabled.has(id2)) {
+      return failure("runtime.groups-invalid");
+    }
+    enabled.add(id2);
+  }
+  return { ok: true, value: enabled };
+}
 function normalizeRuntimePreset(value) {
   const snapshot2 = snapshotOwnData3(value);
   if (!snapshot2.valid || snapshot2.value === null || typeof snapshot2.value !== "object" || Array.isArray(snapshot2.value)) {
@@ -23991,18 +24729,41 @@ function normalizeRuntimePreset(value) {
   });
   return { ok: true, value: normalized };
 }
-function base64(bytes) {
-  return Buffer.from(bytes).toString("base64");
+function matchersFromOperations(operations) {
+  return operations.map((operation) => ({
+    kind: "matcher",
+    groupId: operation.groupId,
+    ruleId: operation.ruleId,
+    name: operation.name,
+    redactSensitiveInLogs: operation.redactSensitiveInLogs,
+    matcher: operation.matcher
+  }));
 }
-async function delay(ms) {
-  if (ms <= 0) return;
-  await new Promise((resolve22) => setTimeout(resolve22, ms));
+function mocksFromOperations(operations, enabledGroupIds) {
+  const mocks = [];
+  for (const operation of operations) {
+    if (operation.kind !== "mock") continue;
+    if (enabledGroupIds !== void 0 && !enabledGroupIds.has(operation.groupId)) {
+      continue;
+    }
+    const mock = operation.mock;
+    mocks.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 },
+      ...mock.file === void 0 ? {} : { file: mock.file }
+    });
+  }
+  return mocks;
 }
 function createNativeRuntimeController(options) {
   let preset = options.preset;
-  const fileRoot = options.fileRoot;
-  const mockPort = options.mockPort;
+  let fileRoot = options.fileRoot;
   const clock = options.clock ?? (() => Date.now());
+  const directoryPicker = options.directoryPicker ?? pickDirectory;
+  const mockFileErrors = /* @__PURE__ */ new Map();
   let state = "idle";
   let activation;
   let capability;
@@ -24028,8 +24789,8 @@ function createNativeRuntimeController(options) {
     if (!reader) return aiConfigInForce;
     let next = null;
     try {
-      const read = await reader();
-      next = isUsableAIProviderConfig(read) ? read : null;
+      const read2 = await reader();
+      next = isUsableAIProviderConfig(read2) ? read2 : null;
     } catch {
       next = null;
     }
@@ -24107,6 +24868,7 @@ function createNativeRuntimeController(options) {
       }
       const startedAt = clock();
       capability = createCapabilityState(preset, startedAt);
+      mockFileErrors.clear();
       mockTokens.clear();
       for (const mock of preset.mocks ?? []) {
         mockTokens.set(mintToken(), mock);
@@ -24136,6 +24898,7 @@ function createNativeRuntimeController(options) {
         return { state: "stopped" };
       }
       state = "stopping";
+      mockFileErrors.clear();
       if (options.onStop) await options.onStop();
       await stopInterception();
       if (capability) closeCapabilityState(capability);
@@ -24154,15 +24917,35 @@ function createNativeRuntimeController(options) {
     getActivePolicy() {
       return activePolicy;
     },
-    async serveMock(token) {
+    async serveMock(token, options2) {
       const mock = mockTokens.get(token);
-      if (mock === void 0) return failure("runtime.mock-unknown");
-      if (!preset) throw new Error("runtime not started");
-      return renderMockResponse({
+      if (mock === void 0 || state !== "running" || preset === void 0) {
+        return failure("runtime.mock-unknown");
+      }
+      const method = options2?.method?.toUpperCase();
+      const matcher = preset.matchers.find(
+        (candidate) => candidate.ruleId === mock.ruleId
+      );
+      if (method !== void 0) {
+        if (matcher === void 0) return failure("runtime.mock-unknown");
+        if (matcher.matcher.method !== void 0 && matcher.matcher.method !== method) {
+          return failure("runtime.unsupported-method");
+        }
+      }
+      const rendered = await renderMockResponse({
         mock,
         fileRoot,
-        presetDigest: preset.digest
+        presetDigest: preset.digest,
+        ...method !== void 0 ? { method } : {},
+        ...options2?.signal !== void 0 ? { signal: options2.signal } : {}
       });
+      if (!rendered.ok) {
+        recordMockFileError(mockFileErrors, mock.ruleId, rendered.error.code);
+        return rendered;
+      }
+      if (mock.file !== void 0)
+        clearMockFileError(mockFileErrors, mock.ruleId);
+      return rendered;
     },
     getBootstrapCapability() {
       if (capability === void 0 || capability.consumed || capability.closed) {
@@ -24209,23 +24992,55 @@ function createNativeRuntimeController(options) {
             }
           };
         }
-        const matcherOps = [];
-        for (const op of compileResult.operations) {
-          if ("matcher" in op) {
-            matcherOps.push({
-              kind: "matcher",
-              groupId: op.groupId,
-              ruleId: op.ruleId,
-              redactSensitiveInLogs: op.redactSensitiveInLogs,
-              matcher: op.matcher
-            });
+        const metadata = input.metadata;
+        if (metadata === null || typeof metadata !== "object") {
+          return {
+            protocol: "v1",
+            type: "runtime.project.set",
+            ...requestId !== void 0 ? { requestId } : {},
+            timestamp,
+            metadata: { ok: false, error: "runtime.project-missing" }
+          };
+        }
+        const enabledGroups = parseEnabledGroupIds(
+          metadata,
+          schemaResult.data.groups.map((group) => group.id)
+        );
+        if (!enabledGroups.ok) {
+          return {
+            protocol: "v1",
+            type: "runtime.project.set",
+            ...requestId !== void 0 ? { requestId } : {},
+            timestamp,
+            metadata: { ok: false, error: enabledGroups.error.code }
+          };
+        }
+        if (Object.hasOwn(metadata, "fileRoot")) {
+          const resolvedRoot = await resolveConfinedRoot(
+            metadata.fileRoot
+          );
+          if (!resolvedRoot.ok) {
+            return {
+              protocol: "v1",
+              type: "runtime.project.set",
+              ...requestId !== void 0 ? { requestId } : {},
+              timestamp,
+              metadata: { ok: false, error: resolvedRoot.error.code }
+            };
           }
+          fileRoot = resolvedRoot.value;
         }
+        const matcherOps = matchersFromOperations(compileResult.operations);
+        const mocks = mocksFromOperations(
+          compileResult.operations,
+          enabledGroups.value
+        );
         const presetInput = {
           version: 1,
           limits: RUNTIME_LIMITS,
           matchers: matcherOps,
-          grants: []
+          grants: [],
+          ...mocks.length > 0 ? { mocks } : {}
         };
         console.error(
           "[rogatio-host] normalizeRuntimePreset input: matchers=",
@@ -24329,6 +25144,88 @@ function createNativeRuntimeController(options) {
           metadata: { ok: true, state: "stopped" }
         };
       }
+      if (input.type === "runtime.pick-directory") {
+        const picked = await directoryPicker();
+        if (!picked.ok) {
+          return {
+            protocol: "v1",
+            type: "runtime.pick-directory",
+            ...requestId !== void 0 ? { requestId } : {},
+            timestamp,
+            metadata: { ok: false, error: picked.code }
+          };
+        }
+        if (picked.path === null) {
+          return {
+            protocol: "v1",
+            type: "runtime.pick-directory",
+            ...requestId !== void 0 ? { requestId } : {},
+            timestamp,
+            metadata: { ok: true, cancelled: true }
+          };
+        }
+        const resolved = await resolveConfinedRoot(picked.path);
+        return {
+          protocol: "v1",
+          type: "runtime.pick-directory",
+          ...requestId !== void 0 ? { requestId } : {},
+          timestamp,
+          metadata: resolved.ok ? { ok: true, path: resolved.value } : { ok: false, error: resolved.error.code }
+        };
+      }
+      if (input.type === "runtime.set-file-root") {
+        if (state !== "running") {
+          return {
+            protocol: "v1",
+            type: "runtime.set-file-root",
+            ...requestId !== void 0 ? { requestId } : {},
+            timestamp,
+            metadata: { ok: false, error: "runtime.not-started" }
+          };
+        }
+        const candidate = input.metadata.path;
+        if (candidate === void 0 || candidate === null || candidate === "") {
+          fileRoot = void 0;
+          mockFileErrors.clear();
+          return {
+            protocol: "v1",
+            type: "runtime.set-file-root",
+            ...requestId !== void 0 ? { requestId } : {},
+            timestamp,
+            metadata: { ok: true, cleared: true }
+          };
+        }
+        const resolved = await resolveConfinedRoot(candidate);
+        if (!resolved.ok) {
+          return {
+            protocol: "v1",
+            type: "runtime.set-file-root",
+            ...requestId !== void 0 ? { requestId } : {},
+            timestamp,
+            metadata: { ok: false, error: resolved.error.code }
+          };
+        }
+        fileRoot = resolved.value;
+        mockFileErrors.clear();
+        return {
+          protocol: "v1",
+          type: "runtime.set-file-root",
+          ...requestId !== void 0 ? { requestId } : {},
+          timestamp,
+          metadata: { ok: true, path: resolved.value }
+        };
+      }
+      if (input.type === "runtime.check-directory") {
+        const candidate = input.metadata.path;
+        const resolved = await resolveConfinedRoot(candidate);
+        return {
+          protocol: "v1",
+          type: "runtime.check-directory",
+          ...requestId !== void 0 ? { requestId } : {},
+          timestamp,
+          metadata: resolved.ok ? { ok: true, path: resolved.value } : { ok: false, error: resolved.error.code }
+        };
+      }
       if (state !== "running" || capability === void 0) {
         throw new Error("runtime not started");
       }
@@ -24427,8 +25324,7 @@ function createNativeRuntimeController(options) {
           const metadata = {
             protocol: "v1",
             presetDigest: preset.digest,
-            mocks,
-            ...mockPort !== void 0 ? { port: mockPort } : {}
+            mocks
           };
           return {
             protocol: "v1",
@@ -24438,29 +25334,6 @@ function createNativeRuntimeController(options) {
             metadata
           };
         }
-        case "mock.request": {
-          const meta = input.metadata;
-          const mock = mockTokens.get(meta.token);
-          if (mock === void 0) {
-            const body = JSON.stringify({
-              ok: false,
-              error: { code: "runtime.mock-unknown" }
-            });
-            const metadata = {
-              status: 404,
-              headers: [["Content-Type", "application/json"]],
-              mockBody: base64(new TextEncoder().encode(body))
-            };
-            return {
-              protocol: "v1",
-              type: "mock.response",
-              ...requestId !== void 0 ? { requestId } : {},
-              timestamp,
-              metadata
-            };
-          }
-          return renderMock(mock, requestId, timestamp);
-        }
         case "runtime.status": {
           if (!preset) throw new Error("runtime not started");
           return {
@@ -24468,7 +25341,11 @@ function createNativeRuntimeController(options) {
             type: "runtime.status",
             ...requestId !== void 0 ? { requestId } : {},
             timestamp,
-            metadata: { state, presetDigest: preset.digest }
+            metadata: {
+              state,
+              presetDigest: preset.digest,
+              mockFileErrors: listMockFileErrors(mockFileErrors)
+            }
           };
         }
         case "ai.status": {
@@ -24604,49 +25481,127 @@ function createNativeRuntimeController(options) {
       }
     }
   };
-  async function renderMock(mock, requestId, timestamp) {
-    if (mock.delayMs !== void 0) await delay(mock.delayMs);
-    if (!preset) throw new Error("runtime not started");
-    const rendered = await renderMockResponse({
-      mock,
-      fileRoot,
-      presetDigest: preset.digest
-    });
-    if (!rendered.ok) {
-      const body = JSON.stringify({
-        ok: false,
-        error: { code: rendered.error.code }
-      });
-      const metadata2 = {
-        status: 500,
-        headers: [["Content-Type", "application/json"]],
-        mockBody: base64(new TextEncoder().encode(body))
-      };
-      return {
-        protocol: "v1",
-        type: "mock.response",
-        ...requestId !== void 0 ? { requestId } : {},
-        timestamp,
-        metadata: metadata2
-      };
+}
+var NATIVE_FRAME_MAX_BYTES = 64 * 1024;
+var NATIVE_POLICY_MAX_BYTES = 256 * 1024;
+var NATIVE_POLICY_MAX_FRAMES = 32;
+var NATIVE_POLICY_STAGE_TIMEOUT_MS = 5e3;
+function encodeNativeFrame(frame) {
+  const json = JSON.stringify(frame);
+  const bytes = new TextEncoder().encode(json);
+  if (bytes.byteLength > NATIVE_FRAME_MAX_BYTES) {
+    throw new Error("Frame exceeds maximum size");
+  }
+  const result = new Uint8Array(4 + bytes.byteLength);
+  new DataView(result.buffer).setUint32(0, bytes.byteLength, true);
+  result.set(bytes, 4);
+  return result;
+}
+function decodeNativeFrame(buffer) {
+  if (buffer.byteLength < 4) {
+    return failure("runtime.native-frame-too-small");
+  }
+  const length = new DataView(buffer.buffer, buffer.byteOffset, 4).getUint32(
+    0,
+    true
+  );
+  if (length > NATIVE_FRAME_MAX_BYTES) {
+    return failure("runtime.native-frame-too-large");
+  }
+  if (buffer.byteLength !== 4 + length) {
+    return failure("runtime.native-frame-length-mismatch");
+  }
+  try {
+    const json = new TextDecoder("utf-8", { fatal: true }).decode(
+      buffer.slice(4)
+    );
+    const frame = JSON.parse(json);
+    if (frame.protocol !== "v1") {
+      return failure("runtime.native-frame-invalid-protocol");
     }
-    const headers = [];
-    for (const header of rendered.value.headers) {
-      headers.push([header[0], header[1]]);
+    return { ok: true, value: frame };
+  } catch {
+    return failure("runtime.native-frame-invalid-json");
+  }
+}
+function createPolicyStageState(totalBytes, partCount, expectedDigest) {
+  return {
+    totalBytes,
+    partCount,
+    receivedParts: /* @__PURE__ */ new Map(),
+    expectedDigest,
+    startTime: Date.now()
+  };
+}
+function addPolicyPart(state, index, data) {
+  if (Date.now() - state.startTime > NATIVE_POLICY_STAGE_TIMEOUT_MS) {
+    return failure("runtime.request-body-policy-stage-timeout");
+  }
+  if (index < 0 || index >= state.partCount) {
+    return failure("runtime.request-body-policy-invalid-part-index");
+  }
+  if (state.receivedParts.has(index)) {
+    return failure("runtime.request-body-policy-duplicate-part");
+  }
+  state.receivedParts.set(index, data);
+  return { ok: true, value: void 0 };
+}
+function commitPolicyStage(state) {
+  if (state.receivedParts.size !== state.partCount) {
+    return failure("runtime.request-body-policy-incomplete");
+  }
+  let totalReceived = 0;
+  for (let i = 0; i < state.partCount; i += 1) {
+    const part = state.receivedParts.get(i);
+    if (!part) {
+      return failure("runtime.request-body-policy-missing-part");
     }
-    const metadata = {
-      status: rendered.value.status,
-      headers,
-      mockBody: base64(rendered.value.bodyBytes)
-    };
-    return {
-      protocol: "v1",
-      type: "mock.response",
-      ...requestId !== void 0 ? { requestId } : {},
-      timestamp,
-      metadata
-    };
+    totalReceived += part.byteLength;
+  }
+  if (totalReceived !== state.totalBytes) {
+    return failure("runtime.request-body-policy-byte-count-mismatch");
+  }
+  const assembled = new Uint8Array(totalReceived);
+  let offset = 0;
+  for (let i = 0; i < state.partCount; i += 1) {
+    const part = state.receivedParts.get(i);
+    if (!part) {
+      return failure("runtime.request-body-policy-missing-part");
+    }
+    assembled.set(part, offset);
+    offset += part.byteLength;
+  }
+  return { ok: true, value: assembled };
+}
+var DIGEST_PATTERN = /^sha256:[0-9a-f]{64}$/;
+function isProjectStageType(type) {
+  return type === "policy-begin" || type === "policy-part" || type === "policy-commit";
+}
+function beginProjectStage(frame) {
+  const { totalBytes, partCount, policyDigest } = frame;
+  if (typeof totalBytes !== "number" || !Number.isSafeInteger(totalBytes) || totalBytes < 1 || totalBytes > NATIVE_POLICY_MAX_BYTES || typeof partCount !== "number" || !Number.isSafeInteger(partCount) || partCount < 1 || partCount > NATIVE_POLICY_MAX_FRAMES || typeof policyDigest !== "string" || !DIGEST_PATTERN.test(policyDigest)) {
+    return failure("runtime.project-stage-invalid");
+  }
+  return {
+    ok: true,
+    value: createPolicyStageState(totalBytes, partCount, policyDigest)
+  };
+}
+function acceptProjectPart(state, frame) {
+  if (typeof frame.index !== "number" || !Number.isSafeInteger(frame.index) || typeof frame.data !== "string") {
+    return failure("runtime.project-stage-invalid");
+  }
+  const bytes = Buffer.from(frame.data, "base64");
+  return addPolicyPart(state, frame.index, bytes);
+}
+function finishProjectStage(state) {
+  const assembled = commitPolicyStage(state);
+  if (!assembled.ok) return assembled;
+  const digest = `sha256:${createHash4("sha256").update(assembled.value).digest("hex")}`;
+  if (digest !== state.expectedDigest) {
+    return failure("runtime.project-stage-invalid");
   }
+  return assembled;
 }
 var import_reflect_metadata = __toESM(require_Reflect(), 1);
 var import_x509 = __toESM(require_x509_cjs(), 1);
@@ -24714,7 +25669,7 @@ function generateNativeMessagingManifest(hostPath, name, allowedOrigins, install
       "host path must be an absolute path"
     );
   }
-  const rel = relative3(installRoot, hostPath);
+  const rel = relative2(installRoot, hostPath);
   if (rel === "" || rel.startsWith("..") || isAbsolute3(rel)) {
     throw new TrustError(
       "trust.invalid-host-path",
@@ -24779,7 +25734,7 @@ async function writeFileAtomic(path2, data) {
 }
 async function existsFile(path2) {
   try {
-    return (await stat2(path2)).isFile();
+    return (await stat(path2)).isFile();
   } catch {
     return false;
   }
@@ -24904,7 +25859,7 @@ function createRequestBodyTrustController(options = {}) {
       await writeFileAtomic(caCertFile, certPem);
     }
     if (caTrustInstaller && !installerCalled) {
-      await caTrustInstaller(await readFile3(caCertFile, "utf8"));
+      await caTrustInstaller(await readFile2(caCertFile, "utf8"));
       installerCalled = true;
     }
   }
@@ -24946,7 +25901,7 @@ function createRequestBodyTrustController(options = {}) {
   async function status() {
     let installed = false;
     try {
-      const raw = await readFile3(manifestPath(), "utf8");
+      const raw = await readFile2(manifestPath(), "utf8");
       installed = isWellFormedManifest(JSON.parse(raw));
     } catch {
       installed = false;
@@ -24968,14 +25923,14 @@ function createRequestBodyTrustController(options = {}) {
     let binaryExecutable = false;
     let allowedOrigins = [];
     try {
-      const raw = await readFile3(manifestPath(), "utf8");
+      const raw = await readFile2(manifestPath(), "utf8");
       manifestExists = true;
       const parsed = JSON.parse(raw);
       if (isWellFormedManifest(parsed)) {
         manifestValid = true;
         allowedOrigins = [...parsed.allowed_origins];
         try {
-          const fileStat = await stat2(parsed.path);
+          const fileStat = await stat(parsed.path);
           binaryExists = fileStat.isFile();
           binaryExecutable = (fileStat.mode & 73) !== 0;
           if (!binaryExists) reasons.push("binary-not-found");
@@ -25008,6 +25963,17 @@ function createRequestBodyTrustController(options = {}) {
   }
   return { install, uninstall, status, verify };
 }
+function stageAck(type, requestId, ok, error) {
+  return encodeNativeFrame({
+    protocol: "v1",
+    type,
+    ...requestId !== void 0 ? { requestId } : {},
+    data: JSON.stringify({
+      ok,
+      ...error !== void 0 ? { error } : {}
+    })
+  });
+}
 function encodeEnvelopeFrame(envelope) {
   const json = new TextEncoder().encode(serializeEnvelope(envelope));
   const out = new Uint8Array(4 + json.byteLength);
@@ -25028,41 +25994,6 @@ function decodeEnvelopeFrame(buffer) {
   );
   return parseEnvelope(json);
 }
-function startMockFaucet(port, controller) {
-  const server = createServer2((req, res) => {
-    void (async () => {
-      try {
-        const url = new URL(req.url ?? "", "http://localhost");
-        const match = /^\/mock\/([a-f0-9]+)$/.exec(url.pathname);
-        if (!match || req.method !== "GET") {
-          res.writeHead(404);
-          res.end();
-          return;
-        }
-        const result = await controller.serveMock(match[1]);
-        if (!result.ok) {
-          res.writeHead(404);
-          res.end();
-          return;
-        }
-        const { status, headers, bodyBytes } = result.value;
-        res.writeHead(
-          status,
-          Object.fromEntries(
-            headers.map((h) => [h[0], h[1]])
-          )
-        );
-        res.end(Buffer2.from(bodyBytes));
-      } catch {
-        if (!res.headersSent) res.writeHead(500);
-        res.end();
-      }
-    })();
-  });
-  return new Promise(
-    (resolve22) => server.listen(port, () => resolve22(server))
-  );
-}
 function defaultTrustRoot() {
   return defaultTrustInstallRoot(process.platform);
 }
@@ -25070,12 +26001,10 @@ function createNativeHost(options) {
   const controller = createNativeRuntimeController({
     preset: options.preset,
     fileRoot: options.fileRoot,
-    ...options.mockPort !== void 0 ? { mockPort: options.mockPort } : {},
     ...options.aiProviderConfig !== void 0 ? { aiProviderConfig: options.aiProviderConfig } : {},
     ...options.aiConfigReader !== void 0 ? { aiConfigReader: options.aiConfigReader } : {},
     ...options.clock ? { clock: options.clock } : {}
   });
-  let faucet = null;
   let interceptProxy = null;
   let outboundWrite = null;
   let hostRequestCounter = 0;
@@ -25089,12 +26018,12 @@ function createNativeHost(options) {
       timestamp: Date.now(),
       metadata
     };
-    return new Promise((resolve22, reject) => {
+    return new Promise((resolve10, reject) => {
       if (!outboundWrite) {
         reject(new Error("host stdout not attached"));
         return;
       }
-      pendingHost.set(requestId, { resolve: resolve22, reject });
+      pendingHost.set(requestId, { resolve: resolve10, reject });
       try {
         outboundWrite(encodeEnvelopeFrame(envelope));
       } catch (error) {
@@ -25116,7 +26045,7 @@ function createNativeHost(options) {
   const platformAdapter = {
     platform: process.platform,
     detect() {
-      const trusted = existsSync(caKeyFile) && existsSync(caCertFile);
+      const trusted = existsSync2(caKeyFile) && existsSync2(caCertFile);
       return {
         supported: true,
         reasons: [],
@@ -25128,7 +26057,7 @@ function createNativeHost(options) {
       };
     },
     async provisionOrVerifyCa() {
-      return existsSync(caKeyFile) && existsSync(caCertFile);
+      return existsSync2(caKeyFile) && existsSync2(caCertFile);
     },
     async installPac(script) {
       const response = await sendHostRequest("runtime.pac.install", {
@@ -25156,7 +26085,11 @@ function createNativeHost(options) {
           project: policy.project,
           operations: policy.operations,
           presetDigest: policy.presetDigest
-        } : null
+        } : null,
+        serveMock: (request) => controller.serveMock(request.token, {
+          method: request.method,
+          signal: request.signal
+        })
       });
       return interceptProxy.endpoint;
     },
@@ -25189,20 +26122,93 @@ function createNativeHost(options) {
       await platformProvider.stop();
     }
   });
+  let projectStage;
+  async function handleProjectStage(frame) {
+    const requestId = frame.requestId;
+    if (frame.type === "policy-begin") {
+      const begun = beginProjectStage(frame);
+      if (!begun.ok) {
+        projectStage = void 0;
+        return stageAck(
+          "policy-begin",
+          requestId,
+          false,
+          begun.error.code
+        );
+      }
+      projectStage = begun.value;
+      return stageAck("policy-begin", requestId, true);
+    }
+    if (frame.type === "policy-part") {
+      if (projectStage === void 0) {
+        return stageAck(
+          "policy-part",
+          requestId,
+          false,
+          "runtime.project-stage-invalid"
+        );
+      }
+      const accepted = acceptProjectPart(projectStage, frame);
+      if (!accepted.ok) {
+        projectStage = void 0;
+        return stageAck(
+          "policy-part",
+          requestId,
+          false,
+          accepted.error.code
+        );
+      }
+      return stageAck("policy-part", requestId, true);
+    }
+    if (projectStage === void 0) {
+      return stageAck(
+        "policy-commit",
+        requestId,
+        false,
+        "runtime.project-stage-invalid"
+      );
+    }
+    const finished = finishProjectStage(projectStage);
+    projectStage = void 0;
+    if (!finished.ok) {
+      return stageAck(
+        "policy-commit",
+        requestId,
+        false,
+        finished.error.code
+      );
+    }
+    try {
+      const json = new TextDecoder("utf-8", { fatal: true }).decode(
+        finished.value
+      );
+      const envelope = parseEnvelope(json);
+      if (envelope.type !== "runtime.project.set") {
+        return stageAck(
+          "policy-commit",
+          requestId,
+          false,
+          "runtime.project-stage-invalid"
+        );
+      }
+      const response = await controller.handleEnvelope(envelope);
+      return encodeEnvelopeFrame(response);
+    } catch {
+      return stageAck(
+        "policy-commit",
+        requestId,
+        false,
+        "runtime.project-stage-invalid"
+      );
+    }
+  }
   const handle = {
     controller,
-    mockPort: options.mockPort ?? null,
     async start() {
       await controller.start();
-      if (options.mockPort !== void 0) {
-        faucet = await startMockFaucet(options.mockPort, controller);
-      }
     },
     async stop() {
-      if (faucet) {
-        await new Promise((resolve22) => faucet?.close(() => resolve22()));
-        faucet = null;
-      }
+      projectStage = void 0;
       await controller.stop();
       clearSession();
       if (interceptProxy) {
@@ -25211,6 +26217,10 @@ function createNativeHost(options) {
       }
     },
     async processFrame(frame) {
+      const native = decodeNativeFrame(frame);
+      if (native.ok && isProjectStageType(native.value.type)) {
+        return handleProjectStage(native.value);
+      }
       let envelope;
       try {
         envelope = decodeEnvelopeFrame(frame);
@@ -25348,16 +26358,14 @@ async function runNativeHost(options) {
     buffer = Buffer2.concat([buffer, buf]);
     pump();
   });
-  await new Promise((resolve22) => {
+  await new Promise((resolve10) => {
     stdin.on("end", () => {
-      void commandChain.finally(() => host.stop()).then(() => resolve22());
+      void commandChain.finally(() => host.stop()).then(() => resolve10());
     });
     if (options.onReady) options.onReady();
     pump();
   });
 }
-var NATIVE_FRAME_MAX_BYTES = 64 * 1024;
-var NATIVE_POLICY_MAX_BYTES = 256 * 1024;
 var PRIVATE_RANGES = [
   { start: ipToInt("10.0.0.0"), end: ipToInt("10.255.255.255") },
   { start: ipToInt("172.16.0.0"), end: ipToInt("172.31.255.255") },
@@ -25394,12 +26402,12 @@ var darwinAdapter = {
       reasons.push("tooling-missing");
     }
     try {
-      accessSync(manifestDir, constants2.W_OK);
+      accessSync(manifestDir, constants3.W_OK);
     } catch {
       reasons.push("manifest-dir-unwritable");
     }
     try {
-      accessSync(caDir, constants2.W_OK);
+      accessSync(caDir, constants3.W_OK);
     } catch {
       reasons.push("keychain-unwritable");
     }
@@ -25422,8 +26430,8 @@ var darwinAdapter = {
       ]);
     }
     const result = await new Promise(
-      (resolve22) => {
-        const child = spawn("security", [
+      (resolve10) => {
+        const child = spawn2("security", [
           "add-trusted-cert",
           "-d",
           "-r",
@@ -25436,8 +26444,8 @@ var darwinAdapter = {
         child.stderr?.on("data", (data) => {
           stderr += data.toString();
         });
-        child.on("close", (code) => resolve22({ code: code ?? 1, stderr }));
-        child.on("error", (err) => resolve22({ code: 1, stderr: err.message }));
+        child.on("close", (code) => resolve10({ code: code ?? 1, stderr }));
+        child.on("error", (err) => resolve10({ code: 1, stderr: err.message }));
       }
     );
     try {
@@ -25456,8 +26464,8 @@ var darwinAdapter = {
   async caTrustRemover() {
     const keychain = this.defaultCaInstallPath();
     const result = await new Promise(
-      (resolve22) => {
-        const child = spawn("security", [
+      (resolve10) => {
+        const child = spawn2("security", [
           "delete-certificate",
           "-c",
           "CN=Rogatio Request-Body CA",
@@ -25467,8 +26475,8 @@ var darwinAdapter = {
         child.stderr?.on("data", (data) => {
           stderr += data.toString();
         });
-        child.on("close", (code) => resolve22({ code: code ?? 1, stderr }));
-        child.on("error", (err) => resolve22({ code: 1, stderr: err.message }));
+        child.on("close", (code) => resolve10({ code: code ?? 1, stderr }));
+        child.on("error", (err) => resolve10({ code: 1, stderr: err.message }));
       }
     );
     if (result.code !== 0) {
@@ -25505,16 +26513,16 @@ var linuxAdapter = {
       reasons.push("tooling-missing");
     }
     try {
-      accessSync2(manifestDir, constants3.W_OK);
+      accessSync2(manifestDir, constants4.W_OK);
     } catch {
       reasons.push("manifest-dir-unwritable");
     }
     try {
-      accessSync2(CA_DIR, constants3.W_OK);
+      accessSync2(CA_DIR, constants4.W_OK);
     } catch (err) {
       if (err?.code === "ENOENT") {
         try {
-          accessSync2(dirname4(CA_DIR), constants3.W_OK);
+          accessSync2(dirname4(CA_DIR), constants4.W_OK);
         } catch {
           if (!hasSudo()) {
             reasons.push("elevation-required");
@@ -25541,8 +26549,8 @@ var linuxAdapter = {
       ]);
     }
     const certResult = await new Promise(
-      (resolve22) => {
-        const child = spawn2("sudo", [
+      (resolve10) => {
+        const child = spawn3("sudo", [
           "sh",
           "-c",
           `cat > "${CERT_PATH}" << 'EOF'
@@ -25553,8 +26561,8 @@ EOF`
         child.stderr?.on("data", (data) => {
           stderr += data.toString();
         });
-        child.on("close", (code) => resolve22({ code: code ?? 1, stderr }));
-        child.on("error", (err) => resolve22({ code: 1, stderr: err.message }));
+        child.on("close", (code) => resolve10({ code: code ?? 1, stderr }));
+        child.on("error", (err) => resolve10({ code: 1, stderr: err.message }));
       }
     );
     if (certResult.code !== 0) {
@@ -25566,14 +26574,14 @@ EOF`
       throw new TrustError("trust.internal", reason, [reason]);
     }
     const result = await new Promise(
-      (resolve22) => {
-        const child = spawn2("sudo", ["update-ca-certificates"]);
+      (resolve10) => {
+        const child = spawn3("sudo", ["update-ca-certificates"]);
         let stderr = "";
         child.stderr?.on("data", (data) => {
           stderr += data.toString();
         });
-        child.on("close", (code) => resolve22({ code: code ?? 1, stderr }));
-        child.on("error", (err) => resolve22({ code: 1, stderr: err.message }));
+        child.on("close", (code) => resolve10({ code: code ?? 1, stderr }));
+        child.on("error", (err) => resolve10({ code: 1, stderr: err.message }));
       }
     );
     if (result.code !== 0) {
@@ -25632,7 +26640,7 @@ var win32Adapter = {
       reasons.push("tooling-missing");
     }
     try {
-      accessSync3(manifestDir, constants4.W_OK);
+      accessSync3(manifestDir, constants5.W_OK);
     } catch {
       reasons.push("manifest-dir-unwritable");
     }
@@ -25654,14 +26662,14 @@ var win32Adapter = {
       ]);
     }
     const result = await new Promise(
-      (resolve22) => {
-        const child = spawn3("certutil", ["-addstore", "-f", "Root", tmpPath]);
+      (resolve10) => {
+        const child = spawn4("certutil", ["-addstore", "-f", "Root", tmpPath]);
         let stderr = "";
         child.stderr?.on("data", (data) => {
           stderr += data.toString();
         });
-        child.on("close", (code) => resolve22({ code: code ?? 1, stderr }));
-        child.on("error", (err) => resolve22({ code: 1, stderr: err.message }));
+        child.on("close", (code) => resolve10({ code: code ?? 1, stderr }));
+        child.on("error", (err) => resolve10({ code: 1, stderr: err.message }));
       }
     );
     try {
@@ -25679,8 +26687,8 @@ var win32Adapter = {
   },
   async caTrustRemover() {
     const result = await new Promise(
-      (resolve22) => {
-        const child = spawn3("certutil", [
+      (resolve10) => {
+        const child = spawn4("certutil", [
           "-delstore",
           "Root",
           "CN=Rogatio Request-Body CA"
@@ -25689,8 +26697,8 @@ var win32Adapter = {
         child.stderr?.on("data", (data) => {
           stderr += data.toString();
         });
-        child.on("close", (code) => resolve22({ code: code ?? 1, stderr }));
-        child.on("error", (err) => resolve22({ code: 1, stderr: err.message }));
+        child.on("close", (code) => resolve10({ code: code ?? 1, stderr }));
+        child.on("error", (err) => resolve10({ code: 1, stderr: err.message }));
       }
     );
     if (result.code !== 0) {
@@ -25786,8 +26794,10 @@ Options:
   --extension-id  Extension ID for the native messaging manifest. Release users
                   never need this. It is only for development (a local unpacked
                   build without the release key) and for forks.
-  --root <dir>    Root for confined runtime file access (host only; default: project directory)
-  --mock-port <n> Bind the loopback mock-response faucet to this port (host only, 1-65535)
+  --root <dir>    Root for confined runtime file access (host only). Default: the
+                  saved device-local root for that project file, otherwise the
+                  project directory. Required when the host reads a stdin
+                  project that contains a file mock.
   --help, -h      Show this help
 
 Exit codes:
@@ -26103,7 +27113,7 @@ var HttpServerError = class extends Error {
     this.code = code;
   }
 };
-function createServer3(handler, options = {}) {
+function createServer2(handler, options = {}) {
   const server = createHttpServer(handler);
   const preferredPort = options.port;
   let port = null;
@@ -26175,7 +27185,7 @@ function createServer3(handler, options = {}) {
 // packages/cli/src/server/routes.ts
 import { randomBytes as randomBytes3 } from "node:crypto";
 import { readFile as readFile4 } from "node:fs/promises";
-import { resolve as resolve2 } from "node:path";
+import { dirname as dirname6, isAbsolute as isAbsolute5, resolve as resolve2 } from "node:path";
 
 // packages/dry-run/dist/node/index.js
 function parseTestUrl(input) {
@@ -26470,6 +27480,18 @@ function dryRunProject(operations, cases, options) {
     }
   };
 }
+function mockPreviewSummary(mock) {
+  const parts = [];
+  parts.push(mock.body !== void 0 ? "inline body" : "file-backed body");
+  const headerCount = mock.headers?.length ?? 0;
+  if (headerCount > 0) {
+    parts.push(headerCount === 1 ? "1 header" : `${headerCount} headers`);
+  }
+  if (mock.delayMs !== void 0) {
+    parts.push(`${mock.delayMs} ms delay`);
+  }
+  return `Mock ${mock.status} (${parts.join(", ")})`;
+}
 function captureSubject(matcher, url) {
   if (matcher.source.key === "url") return url;
   try {
@@ -26517,9 +27539,82 @@ function previewRuleAction(operation, url) {
       summary: expand(operation.responseBody.body)
     };
   }
+  if (operation.kind === "mock") {
+    return {
+      kind: "mock",
+      summary: mockPreviewSummary(operation.mock)
+    };
+  }
   return null;
 }
 
+// packages/cli/src/mock-root-config.ts
+import { mkdir as mkdir3, readFile as readFile3, realpath as realpath3, rename as rename2, writeFile as writeFile3 } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname as dirname5, isAbsolute as isAbsolute4, join as join6, resolve } from "node:path";
+function mockRootConfigPath(env = process.env) {
+  const base = env.ROGATIO_CONFIG_DIR ?? join6(homedir(), ".config", "rogatio");
+  return join6(base, "mock-roots.json");
+}
+async function canonicalProjectPath(filePath) {
+  const absolute = resolve(filePath);
+  try {
+    return await realpath3(absolute);
+  } catch {
+    return absolute;
+  }
+}
+async function readMap(env) {
+  let raw;
+  try {
+    raw = await readFile3(mockRootConfigPath(env), "utf8");
+  } catch {
+    return {};
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return {};
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return {};
+  }
+  const projects = parsed.projects;
+  if (typeof projects !== "object" || projects === null || Array.isArray(projects)) {
+    return {};
+  }
+  const map = {};
+  for (const key of Object.keys(projects)) {
+    const value = projects[key];
+    if (typeof value === "string" && isAbsolute4(value)) map[key] = value;
+  }
+  return map;
+}
+async function writeMap(map, env) {
+  const path2 = mockRootConfigPath(env);
+  await mkdir3(dirname5(path2), { recursive: true });
+  const temporary = `${path2}.${process.pid}.tmp`;
+  await writeFile3(
+    temporary,
+    `${JSON.stringify({ projects: map }, null, 2)}
+`,
+    "utf8"
+  );
+  await rename2(temporary, path2);
+}
+async function readSavedMockRoot(filePath, env = process.env) {
+  const key = await canonicalProjectPath(filePath);
+  return (await readMap(env))[key];
+}
+async function writeSavedMockRoot(filePath, root, env = process.env) {
+  const key = await canonicalProjectPath(filePath);
+  const map = await readMap(env);
+  if (root === null || root.length === 0) delete map[key];
+  else map[key] = root;
+  await writeMap(map, env);
+}
+
 // packages/cli/src/server/routes.ts
 function generateCsrfToken() {
   return randomBytes3(16).toString("hex");
@@ -26758,6 +27853,60 @@ function createRoutes(context) {
       res.end(JSON.stringify({ diagnostics }));
       return;
     }
+    if (pathname === "/api/mock-root" && method === "GET") {
+      const saved = await readSavedMockRoot(context.filePath);
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          root: saved ?? dirname6(context.filePath),
+          saved: saved !== void 0
+        })
+      );
+      return;
+    }
+    if (pathname === "/api/mock-root" && method === "POST") {
+      if (!validateCsrf(req, context.csrfToken)) {
+        res.writeHead(403, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            code: "csrf-invalid",
+            message: "Invalid CSRF token"
+          })
+        );
+        return;
+      }
+      let body;
+      try {
+        body = JSON.parse(await getRequestBody(req));
+      } catch (error) {
+        const failure2 = bodyErrorResponse(error);
+        res.writeHead(failure2.status, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(failure2.body));
+        return;
+      }
+      const root = typeof body === "object" && body !== null && "root" in body ? body.root : void 0;
+      if (root !== null && (typeof root !== "string" || root !== "" && !isAbsolute5(root))) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            code: "invalid-root",
+            message: "Mock file root must be an absolute path or null"
+          })
+        );
+        return;
+      }
+      await writeSavedMockRoot(context.filePath, root);
+      const saved = await readSavedMockRoot(context.filePath);
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          ok: true,
+          root: saved ?? dirname6(context.filePath),
+          saved: saved !== void 0
+        })
+      );
+      return;
+    }
     if (pathname === "/api/save" && method === "POST") {
       if (!validateCsrf(req, context.csrfToken)) {
         res.writeHead(403, { "Content-Type": "application/json" });
@@ -27119,12 +28268,12 @@ function createRoutes(context) {
 }
 
 // packages/cli/src/utils/asset-paths.ts
-import { dirname as dirname5, resolve as resolve3 } from "node:path";
+import { dirname as dirname7, resolve as resolve3 } from "node:path";
 import { fileURLToPath } from "node:url";
-function isDistBuild(here = dirname5(fileURLToPath(import.meta.url))) {
+function isDistBuild(here = dirname7(fileURLToPath(import.meta.url))) {
   return here.includes("/dist/") || here.includes("\\dist\\");
 }
-function editorAssetPaths(here = dirname5(fileURLToPath(import.meta.url))) {
+function editorAssetPaths(here = dirname7(fileURLToPath(import.meta.url))) {
   const editorRoot = isDistBuild(here) ? resolve3(here, "..", "editor") : resolve3(here, "..", "..", "..", "editor", "dist", "browser");
   return {
     bundle: resolve3(editorRoot, "index.js"),
@@ -27134,7 +28283,7 @@ function editorAssetPaths(here = dirname5(fileURLToPath(import.meta.url))) {
 }
 
 // packages/cli/src/utils/browser.ts
-import { spawn as spawn4 } from "node:child_process";
+import { spawn as spawn5 } from "node:child_process";
 var BrowserLaunchError = class extends Error {
   platform;
   constructor(platform, message) {
@@ -27170,7 +28319,7 @@ async function launchBrowser(url) {
       );
   }
   return new Promise((resolve10) => {
-    const child = spawn4(command, args, {
+    const child = spawn5(command, args, {
       detached: true,
       stdio: "ignore"
     });
@@ -27192,15 +28341,15 @@ async function launchBrowser(url) {
 import { randomBytes as randomBytes4 } from "node:crypto";
 import {
   access,
-  mkdir as mkdir3,
+  mkdir as mkdir4,
   readdir,
   readFile as readFile5,
-  rename as rename2,
-  stat as stat3,
+  rename as rename3,
+  stat as stat2,
   unlink as unlink2,
-  writeFile as writeFile3
+  writeFile as writeFile4
 } from "node:fs/promises";
-import { basename as basename2, dirname as dirname6, join as join6 } from "node:path";
+import { basename as basename2, dirname as dirname8, join as join7 } from "node:path";
 var ProjectStorageError = class extends Error {
   code;
   id;
@@ -27398,14 +28547,14 @@ async function readDocument(id2) {
 }
 async function isDirectoryPath(id2) {
   try {
-    return (await stat3(id2)).isDirectory();
+    return (await stat2(id2)).isDirectory();
   } catch {
     return false;
   }
 }
 async function writeDocument(id2, data) {
-  const tempName = `.${basename2(dirname6(id2))}.${randomBytes4(8).toString("hex")}.tmp`;
-  const tempPath = join6(dirname6(id2), tempName);
+  const tempName = `.${basename2(dirname8(id2))}.${randomBytes4(8).toString("hex")}.tmp`;
+  const tempPath = join7(dirname8(id2), tempName);
   try {
     if (await isDirectoryPath(id2)) {
       throw new ProjectFileError(
@@ -27414,9 +28563,9 @@ async function writeDocument(id2, data) {
         "Target path is a directory"
       );
     }
-    await mkdir3(dirname6(id2), { recursive: true });
-    await writeFile3(tempPath, JSON.stringify(data, null, 2), "utf-8");
-    await rename2(tempPath, id2);
+    await mkdir4(dirname8(id2), { recursive: true });
+    await writeFile4(tempPath, JSON.stringify(data, null, 2), "utf-8");
+    await rename3(tempPath, id2);
   } catch (e) {
     if (e instanceof ProjectFileError) throw e;
     try {
@@ -27464,7 +28613,7 @@ function createJsonFileProjectStorage() {
         if (entry.isDirectory()) continue;
         const named = isRogatioProjectFilename(entry.name);
         if (!named && !isJsonFilename(entry.name)) continue;
-        const id2 = join6(scope, entry.name);
+        const id2 = join7(scope, entry.name);
         if (!named && !await isDiscoverableProjectFile(id2)) continue;
         let name = "";
         try {
@@ -27597,10 +28746,10 @@ async function editCommand(args, options = {}) {
     filePath = resolve4(process.cwd(), ".rogatio.json");
   }
   try {
-    const stat4 = await import("node:fs/promises").then(
+    const stat3 = await import("node:fs/promises").then(
       (fs2) => fs2.stat(filePath)
     );
-    if (stat4.isDirectory()) {
+    if (stat3.isDirectory()) {
       console.error("Error: Path is a directory");
       return { exitCode: Promise.resolve(2), shutdown: () => {
       } };
@@ -27665,7 +28814,7 @@ async function editCommand(args, options = {}) {
   };
   let server;
   try {
-    server = createServer3(
+    server = createServer2(
       createRoutes(context),
       port !== void 0 ? { port } : {}
     );
@@ -27951,8 +29100,30 @@ function generateEditorHtml(apiBase, csrfToken, filePath, aiConfigured) {
         onCancel: () => {
           cancel();
         },
+        projectActions: [
+          { command: 'set-mock-root', label: 'Set mock file root' },
+          { command: 'clear-mock-root', label: 'Clear mock file root' },
+        ],
         ${aiAssistHandler}
       });
+      document.addEventListener('click', (event) => {
+        const target = event.target;
+        if (!(target instanceof Element)) return;
+        const command = target.closest('[data-command]')?.getAttribute('data-command');
+        if (command !== 'set-mock-root' && command !== 'clear-mock-root') return;
+        const root = command === 'clear-mock-root'
+          ? null
+          : window.prompt('Mock file root');
+        if (command === 'set-mock-root' && root === null) return;
+        void fetch(apiBase + '/api/mock-root', {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'X-CSRF-Token': csrfToken,
+          },
+          body: JSON.stringify({ root }),
+        });
+      });
       void editor;
     } catch (error) {
       const parts = [];
@@ -28064,16 +29235,16 @@ function readFilters(source) {
       };
     }
     if (Object.hasOwn(entry, "resourceType")) {
-      const read = readResourceTypes(entry.resourceType);
-      if (!read.ok) return read;
-      resourceTypes = intersect(resourceTypes, read.values);
-      changes.push(...read.changes);
+      const read2 = readResourceTypes(entry.resourceType);
+      if (!read2.ok) return read2;
+      resourceTypes = intersect(resourceTypes, read2.values);
+      changes.push(...read2.changes);
     }
     if (Object.hasOwn(entry, "requestMethod")) {
-      const read = readMethods(entry.requestMethod);
-      if (!read.ok) return read;
-      methods = intersect(methods, read.values);
-      changes.push(...read.changes);
+      const read2 = readMethods(entry.requestMethod);
+      if (!read2.ok) return read2;
+      methods = intersect(methods, read2.values);
+      changes.push(...read2.changes);
     }
   }
   if (resourceTypes !== void 0 && resourceTypes.length === 0) {
@@ -30019,20 +31190,8 @@ function errorMessage(error) {
 }
 
 // packages/cli/src/commands/runtime.ts
-import { chmod, mkdir as mkdir4, rm as rm2, writeFile as writeFile4 } from "node:fs/promises";
-import { dirname as dirname7, join as join7, resolve as resolve6 } from "node:path";
-function toMatcherOperations(operations) {
-  return operations.map(
-    ({ groupId, ruleId, name, matcher, redactSensitiveInLogs }) => ({
-      kind: "matcher",
-      groupId,
-      ruleId,
-      name,
-      matcher,
-      redactSensitiveInLogs
-    })
-  );
-}
+import { chmod, mkdir as mkdir5, rm as rm2, writeFile as writeFile5 } from "node:fs/promises";
+import { dirname as dirname9, join as join8, resolve as resolve6 } from "node:path";
 function generateHostWrapper(rogatioCommand, logPath) {
   const parts = rogatioCommand.split(" ");
   const nodeBin = parts[0] ?? "node";
@@ -30046,13 +31205,13 @@ exec "${nodeBin}" "${cliScript}" runtime host 2>>"${logPath}"
 `;
 }
 async function writeHostWrapper(hostPath, installRoot) {
-  await mkdir4(installRoot, { recursive: true });
-  const logPath = join7(installRoot, "runtime-host.log");
+  await mkdir5(installRoot, { recursive: true });
+  const logPath = join8(installRoot, "runtime-host.log");
   const script = generateHostWrapper(
     `${process.execPath} ${process.argv[1] ?? "rogatio"}`,
     logPath
   );
-  await writeFile4(hostPath, script, "utf8");
+  await writeFile5(hostPath, script, "utf8");
   await chmod(hostPath, 493);
 }
 function makeTrustController() {
@@ -30062,7 +31221,7 @@ function makeTrustController() {
   return createRequestBodyTrustController({
     platform,
     installRoot,
-    hostPath: join7(installRoot, "runtime-host"),
+    hostPath: join8(installRoot, "runtime-host"),
     hostName: "com.rogatio.runtime",
     allowedOrigins: [],
     manifestDir: adapter.defaultManifestDir(),
@@ -30131,7 +31290,7 @@ async function trustRuntimeCommand(args) {
   }
   const controller = makeTrustController();
   const installRoot = defaultTrustInstallRoot(process.platform);
-  const hostPath = join7(installRoot, "runtime-host");
+  const hostPath = join8(installRoot, "runtime-host");
   switch (subcommand) {
     case "install": {
       const installResult = await controller.install(extensionId);
@@ -30159,7 +31318,7 @@ Note: reload the extension at chrome://extensions for the native host to be dete
       } catch {
       }
       try {
-        await rm2(join7(installRoot, "runtime-host.log"), { force: true });
+        await rm2(join8(installRoot, "runtime-host.log"), { force: true });
       } catch {
       }
       return reportTrust(
@@ -30229,7 +31388,6 @@ allowed_origins includes chrome-extension://${extensionId}/`
 }
 async function runtimeHostCommand(args, options = {}) {
   let root;
-  let mockPort;
   const positional = [];
   let argumentError;
   for (let index = 0; index < args.length; index += 1) {
@@ -30238,15 +31396,6 @@ async function runtimeHostCommand(args, options = {}) {
       root = resolve6(args[++index]);
     } else if (arg === "--root") {
       argumentError = "--root requires a value";
-    } else if (arg === "--mock-port" && index + 1 < args.length) {
-      const parsed = Number(args[++index]);
-      if (!Number.isInteger(parsed) || parsed <= 0 || parsed > 65535) {
-        argumentError = "--mock-port must be an integer port in 1..65535";
-      } else {
-        mockPort = parsed;
-      }
-    } else if (arg === "--mock-port") {
-      argumentError = "--mock-port requires a value";
     } else if (arg === "-" || !arg.startsWith("-")) {
       positional.push(arg);
     } else {
@@ -30262,7 +31411,6 @@ async function runtimeHostCommand(args, options = {}) {
     const aiProviderConfig2 = await readProviderConfig();
     await runNativeHost({
       fileRoot: root,
-      ...mockPort !== void 0 ? { mockPort } : {},
       ...aiProviderConfig2 !== null ? { aiProviderConfig: aiProviderConfig2 } : {},
       aiConfigReader: readProviderConfig,
       onReady: () => console.error(
@@ -30276,12 +31424,18 @@ async function runtimeHostCommand(args, options = {}) {
   const storage = options.storage ?? createJsonFileProjectStorage();
   try {
     if (inputPath === "-") {
-      const chunks = [];
-      for await (const chunk of process.stdin) {
-        chunks.push(typeof chunk === "string" ? chunk : chunk.toString("utf8"));
-      }
       filePath = "<stdin>";
-      projectData = JSON.parse(chunks.join(""));
+      if (options.stdinInput !== void 0) {
+        projectData = JSON.parse(options.stdinInput);
+      } else {
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+          chunks.push(
+            typeof chunk === "string" ? chunk : chunk.toString("utf8")
+          );
+        }
+        projectData = JSON.parse(chunks.join(""));
+      }
     } else {
       filePath = resolve6(inputPath);
       projectData = await storage.get(filePath);
@@ -30309,12 +31463,22 @@ async function runtimeHostCommand(args, options = {}) {
     }
     return 1;
   }
-  const rootDir = root ?? (inputPath === "-" ? process.cwd() : dirname7(filePath));
+  const fileMock = compileResult.operations.some(
+    (operation) => operation.kind === "mock" && operation.mock.file !== void 0
+  );
+  if (inputPath === "-" && fileMock && root === void 0) {
+    console.error("Error: runtime.root-required");
+    return 2;
+  }
+  const savedRoot = root === void 0 && inputPath !== "-" ? await readSavedMockRoot(filePath) : void 0;
+  const rootDir = root ?? savedRoot ?? (inputPath === "-" ? void 0 : dirname9(filePath));
+  const mocks = mocksFromOperations(compileResult.operations, void 0);
   const normalized = normalizeRuntimePreset({
     version: 1,
     limits: RUNTIME_LIMITS,
-    matchers: toMatcherOperations(compileResult.operations),
-    grants: []
+    matchers: matchersFromOperations(compileResult.operations),
+    grants: [],
+    ...mocks.length > 0 ? { mocks } : {}
   });
   if (!normalized.ok) {
     console.error("Error: Failed to build runtime preset");
@@ -30323,8 +31487,7 @@ async function runtimeHostCommand(args, options = {}) {
   const aiProviderConfig = await readProviderConfig();
   await runNativeHost({
     preset: normalized.value,
-    fileRoot: rootDir,
-    ...mockPort !== void 0 ? { mockPort } : {},
+    ...rootDir !== void 0 ? { fileRoot: rootDir } : {},
     ...aiProviderConfig !== null ? { aiProviderConfig } : {},
     aiConfigReader: readProviderConfig,
     onReady: () => console.error("rogatio runtime-host active")
@@ -30754,7 +31917,7 @@ async function verifyCommand(args, stdinInput, captureOutput = false, options =
 }
 
 // packages/cli/src/index.ts
-var __dirname = dirname8(fileURLToPath2(import.meta.url));
+var __dirname = dirname10(fileURLToPath2(import.meta.url));
 var packageJsonPath = resolve9(
   __dirname,
   isDistBuild(__dirname) ? "../../package.json" : "../package.json"