@rogatio/cli 5.2.3 → 5.3.0

package/dist/node/index.js

@@ -1161,123 +1161,474 @@ function validateProjectDetailed(value) {
 import { isIP as isIP2 } from "node:net";
 import { Buffer as Buffer2 } from "node:buffer";
 import { createServer } from "node:http";
-import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
-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 { generateKeyPairSync as generateKeyPairSync2, webcrypto } from "node:crypto";
-import { spawn, spawnSync } from "node:child_process";
-import { accessSync, constants as constants2, unlinkSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname as dirname3, join as join3 } 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 { 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 { tmpdir as tmpdir2 } from "node:os";
-import { join as join4 } from "node:path";
-import { join as posixJoin3 } from "node:path/posix";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res, err) => function __init() {
-  if (err) throw err[0];
-  try {
-    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-  } catch (e) {
-    throw err = [e], e;
-  }
-};
-var __commonJS = (cb, mod) => function __require() {
-  try {
-    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-  } catch (e) {
-    throw mod = 0, e;
-  }
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+
+// packages/compiler/dist/node/index.js
+var ISSUE_CODES = {
+  required: "schema.required",
+  additionalProperties: "schema.unknown-property",
+  type: "schema.invalid-type",
+  format: "schema.invalid-format",
+  const: "schema.invalid-value",
+  enum: "schema.invalid-value",
+  pattern: "schema.invalid-value",
+  minLength: "schema.out-of-range",
+  maxLength: "schema.out-of-range",
+  minItems: "schema.out-of-range",
+  maxItems: "schema.out-of-range",
+  minimum: "schema.out-of-range",
+  maximum: "schema.out-of-range",
+  uniqueItems: "schema.out-of-range",
+  ownProperties: "schema.invalid-structure",
+  uniqueId: "schema.duplicate-id",
+  effectiveOrigin: "schema.no-effective-origin",
+  maxRulesPerProject: "schema.rule-limit"
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+var SAFE_PARAM_KEYS = /* @__PURE__ */ new Set([
+  "additionalProperty",
+  "actual",
+  "allowedValue",
+  "allowedValues",
+  "format",
+  "i",
+  "j",
+  "limit",
+  "missingProperty",
+  "previousPath",
+  "type",
+  "headerName",
+  "headerOperation",
+  "headerDirection"
+]);
+var MESSAGES = {
+  "schema.required": "Required project data is missing.",
+  "schema.unknown-property": "The project contains an unknown property.",
+  "schema.invalid-type": "The project contains a value with an invalid type.",
+  "schema.invalid-format": "The project contains a value with an invalid format.",
+  "schema.invalid-value": "The project contains an invalid value.",
+  "schema.out-of-range": "The project contains a value outside its allowed bounds.",
+  "schema.invalid-structure": "The project contains invalid structure.",
+  "schema.duplicate-id": "Project and rule IDs must be unique.",
+  "schema.no-effective-origin": "Each rule must have at least one effective origin.",
+  "schema.rule-limit": "The project contains too many rules.",
+  "compiler.invariant": "The compiler could not normalize validated project data.",
+  "compiler.forbidden-header": "The header name is forbidden for this direction.",
+  "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."
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var require_Reflect = __commonJS({
-  "node_modules/.pnpm/reflect-metadata@0.2.2/node_modules/reflect-metadata/Reflect.js"() {
-    var Reflect2;
-    (function(Reflect3) {
-      (function(factory) {
-        var root = typeof globalThis === "object" ? globalThis : typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : sloppyModeThis();
-        var exporter = makeExporter(Reflect3);
-        if (typeof root.Reflect !== "undefined") {
-          exporter = makeExporter(root.Reflect, exporter);
-        }
-        factory(exporter, root);
-        if (typeof root.Reflect === "undefined") {
-          root.Reflect = Reflect3;
-        }
-        function makeExporter(target, previous) {
-          return function(key, value) {
-            Object.defineProperty(target, key, { configurable: true, writable: true, value });
-            if (previous)
-              previous(key, value);
-          };
-        }
-        function functionThis() {
-          try {
-            return Function("return this;")();
-          } catch (_) {
-          }
+function copySafeParams(params) {
+  const safe = {};
+  for (const key of Object.keys(params)) {
+    if (!SAFE_PARAM_KEYS.has(key)) continue;
+    const value = params[key];
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null) {
+      safe[key] = value;
+      continue;
+    }
+    if (Array.isArray(value)) {
+      const values = [];
+      for (let index = 0; index < value.length; index += 1) {
+        const item = value[index];
+        if (typeof item === "string" || typeof item === "number" || typeof item === "boolean" || item === null) {
+          values.push(item);
         }
-        function indirectEvalThis() {
-          try {
-            return (void 0, eval)("(function() { return this; })()");
-          } catch (_) {
-          }
+      }
+      safe[key] = values;
+    }
+  }
+  return safe;
+}
+function compareCodeUnits(left, right) {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+}
+function compareDiagnostics(left, right) {
+  const leftParams = stableParams(left.params);
+  const rightParams = stableParams(right.params);
+  return compareCodeUnits(left.path, right.path) || compareCodeUnits(left.code, right.code) || compareCodeUnits(left.message, right.message) || compareCodeUnits(leftParams, rightParams);
+}
+function stableParams(params) {
+  const keys = Object.keys(params).sort(compareCodeUnits);
+  return keys.map((key) => `${JSON.stringify(key)}:${JSON.stringify(params[key])}`).join(",");
+}
+function mapValidationIssues(issues) {
+  return issues.map((issue) => {
+    const code = Object.hasOwn(ISSUE_CODES, issue.keyword) ? ISSUE_CODES[issue.keyword] : "schema.invalid-value";
+    return {
+      code,
+      severity: "error",
+      path: issue.instancePath,
+      message: MESSAGES[code],
+      params: copySafeParams(issue.params)
+    };
+  }).sort(compareDiagnostics);
+}
+function invariantDiagnostic(path2 = "") {
+  return {
+    code: "compiler.invariant",
+    severity: "error",
+    path: path2,
+    message: MESSAGES["compiler.invariant"],
+    params: {}
+  };
+}
+function compareCodeUnits2(left, right) {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+}
+function snapshotOwnData2(value, ancestors = /* @__PURE__ */ new WeakSet()) {
+  if (value === null || typeof value !== "object") {
+    return { valid: true, value };
+  }
+  if (ancestors.has(value)) return { valid: false };
+  ancestors.add(value);
+  try {
+    if (Object.getOwnPropertySymbols(value).length > 0) {
+      return { valid: false };
+    }
+    if (Array.isArray(value)) {
+      const lengthDescriptor = Object.getOwnPropertyDescriptor(value, "length");
+      if (lengthDescriptor === void 0 || !("value" in lengthDescriptor) || !Number.isSafeInteger(lengthDescriptor.value) || lengthDescriptor.value < 0 || lengthDescriptor.value > LIMITS.maxRulesPerProject) {
+        return { valid: false };
+      }
+      const length = lengthDescriptor.value;
+      for (const propertyName of Object.getOwnPropertyNames(value)) {
+        if (propertyName === "length") continue;
+        const index = Number(propertyName);
+        if (!Number.isInteger(index) || index < 0 || index >= length || String(index) !== propertyName) {
+          return { valid: false };
         }
-        function sloppyModeThis() {
-          return functionThis() || indirectEvalThis();
+      }
+      const snapshot2 = new Array(length);
+      for (let index = 0; index < length; index += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(
+          value,
+          String(index)
+        );
+        if (descriptor === void 0 || !("value" in descriptor) || !descriptor.enumerable) {
+          return { valid: false };
         }
-      })(function(exporter, root) {
-        var hasOwn2 = Object.prototype.hasOwnProperty;
-        var supportsSymbol = typeof Symbol === "function";
-        var toPrimitiveSymbol = supportsSymbol && typeof Symbol.toPrimitive !== "undefined" ? Symbol.toPrimitive : "@@toPrimitive";
-        var iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== "undefined" ? Symbol.iterator : "@@iterator";
-        var supportsCreate = typeof Object.create === "function";
-        var supportsProto = { __proto__: [] } instanceof Array;
-        var downLevel = !supportsCreate && !supportsProto;
-        var HashMap = {
-          // create an object in dictionary mode (a.k.a. "slow" mode in v8)
-          create: supportsCreate ? function() {
-            return MakeDictionary(/* @__PURE__ */ Object.create(null));
-          } : supportsProto ? function() {
-            return MakeDictionary({ __proto__: null });
-          } : function() {
-            return MakeDictionary({});
-          },
+        const child = snapshotOwnData2(descriptor.value, ancestors);
+        if (!child.valid) return child;
+        snapshot2[index] = child.value;
+      }
+      return { valid: true, value: snapshot2 };
+    }
+    const snapshot = /* @__PURE__ */ Object.create(null);
+    for (const key of Object.getOwnPropertyNames(value)) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (descriptor === void 0 || !("value" in descriptor) || !descriptor.enumerable) {
+        return { valid: false };
+      }
+      const child = snapshotOwnData2(descriptor.value, ancestors);
+      if (!child.valid) return child;
+      Object.defineProperty(snapshot, key, {
+        configurable: true,
+        enumerable: true,
+        value: child.value,
+        writable: true
+      });
+    }
+    return { valid: true, value: snapshot };
+  } catch {
+    return { valid: false };
+  } finally {
+    ancestors.delete(value);
+  }
+}
+var CompilerInvariantError = class extends Error {
+  constructor(path2) {
+    super("invalid normalized origin");
+    this.path = path2;
+    this.name = "CompilerInvariantError";
+  }
+  path;
+};
+function normalizeOrigins(group, rule, groupIndex, ruleIndex) {
+  const origins = /* @__PURE__ */ new Set();
+  const sourceArrays = [group.origins, rule.origins];
+  for (let sourceIndex = 0; sourceIndex < sourceArrays.length; sourceIndex += 1) {
+    const source = sourceArrays[sourceIndex];
+    for (let originIndex = 0; originIndex < source.length; originIndex += 1) {
+      const normalized = normalizeSiteOrigin(source[originIndex]);
+      if (normalized === null) {
+        const path2 = sourceIndex === 0 ? `/groups/${groupIndex}/origins/${originIndex}` : `/groups/${groupIndex}/rules/${ruleIndex}/origins/${originIndex}`;
+        throw new CompilerInvariantError(path2);
+      }
+      origins.add(normalized);
+    }
+  }
+  const normalizedOrigins = [];
+  for (const origin of origins) normalizedOrigins.push(origin);
+  normalizedOrigins.sort(compareCodeUnits2);
+  return normalizedOrigins;
+}
+function canonicalResourceTypes(resourceTypes) {
+  const ordered = [];
+  for (let canonicalIndex = 0; canonicalIndex < RESOURCE_TYPES.length; canonicalIndex += 1) {
+    const canonical = RESOURCE_TYPES[canonicalIndex];
+    for (let sourceIndex = 0; sourceIndex < resourceTypes.length; sourceIndex += 1) {
+      if (resourceTypes[sourceIndex] === canonical) ordered.push(canonical);
+    }
+  }
+  return ordered;
+}
+function compileMatcher(group, rule, groupIndex, ruleIndex) {
+  const matcher = {
+    urlRegex: { source: rule.urlRegex, flags: "" },
+    origins: normalizeOrigins(group, rule, groupIndex, ruleIndex),
+    resourceTypes: canonicalResourceTypes(rule.resourceTypes),
+    priority: rule.priority
+  };
+  if (rule.method !== void 0) matcher.method = rule.method;
+  return matcher;
+}
+function compileOperations(project) {
+  const operations = [];
+  for (let groupIndex = 0; groupIndex < project.groups.length; groupIndex += 1) {
+    const group = project.groups[groupIndex];
+    for (let ruleIndex = 0; ruleIndex < group.rules.length; ruleIndex += 1) {
+      const rule = group.rules[ruleIndex];
+      const matcher = compileMatcher(group, rule, groupIndex, ruleIndex);
+      if (rule.type === "redirect") {
+        const operation = {
+          kind: "redirect",
+          groupId: group.id,
+          ruleId: rule.id,
+          matcher,
+          redirect: { destination: rule.redirect?.destination ?? "" }
+        };
+        operations.push(operation);
+      } else if (rule.type === "query" && rule.action && "type" in rule.action && rule.action.type === "query") {
+        const action = rule.action;
+        const operation = {
+          kind: "query",
+          groupId: group.id,
+          ruleId: rule.id,
+          matcher,
+          action
+        };
+        operations.push(operation);
+      } else if (rule.type === "header") {
+        const operation = {
+          kind: "header",
+          groupId: group.id,
+          ruleId: rule.id,
+          matcher,
+          header: {
+            direction: rule.headerDirection ?? "request",
+            operation: rule.headerOperation ?? "set",
+            name: rule.headerName ?? "",
+            ...rule.headerValue !== void 0 ? { value: rule.headerValue } : {}
+          }
+        };
+        operations.push(operation);
+      } else if (rule.type === "mock") {
+        const operation = {
+          kind: "mock",
+          groupId: group.id,
+          ruleId: rule.id,
+          matcher,
+          mock: rule.mock ?? { status: 200, body: "" }
+        };
+        operations.push(operation);
+      } else if (rule.type === "response-body") {
+        const operation = {
+          kind: "response-body",
+          groupId: group.id,
+          ruleId: rule.id,
+          matcher,
+          responseBody: rule.responseBody ?? { replacements: [] }
+        };
+        operations.push(operation);
+      } else if (rule.type === "request-body") {
+        const operation = {
+          kind: "request-body",
+          groupId: group.id,
+          ruleId: rule.id,
+          matcher,
+          requestBody: rule.requestBody ?? { mode: "replace", body: "" }
+        };
+        operations.push(operation);
+      } else {
+        const operation = {
+          kind: "matcher",
+          groupId: group.id,
+          ruleId: rule.id,
+          matcher
+        };
+        operations.push(operation);
+      }
+    }
+  }
+  return operations;
+}
+function compileProject(value) {
+  const snapshot = snapshotOwnData2(value);
+  if (!snapshot.valid) {
+    return {
+      ok: false,
+      operations: [],
+      diagnostics: mapValidationIssues([
+        {
+          instancePath: "",
+          keyword: "ownProperties",
+          message: "must contain only own data properties",
+          params: {}
+        }
+      ])
+    };
+  }
+  let validation;
+  try {
+    validation = validateProjectDetailed(snapshot.value);
+  } catch {
+    return { ok: false, operations: [], diagnostics: [invariantDiagnostic()] };
+  }
+  if (!validation.valid) {
+    return {
+      ok: false,
+      operations: [],
+      diagnostics: mapValidationIssues(validation.errors)
+    };
+  }
+  try {
+    return {
+      ok: true,
+      operations: compileOperations(validation.data),
+      diagnostics: []
+    };
+  } catch (error) {
+    const path2 = error instanceof CompilerInvariantError ? error.path : "";
+    return {
+      ok: false,
+      operations: [],
+      diagnostics: [invariantDiagnostic(path2)]
+    };
+  }
+}
+
+// packages/runtime/dist/node/index.js
+import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
+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 createHash2 } 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 { generateKeyPairSync as generateKeyPairSync2, webcrypto } from "node:crypto";
+import { spawn, spawnSync } from "node:child_process";
+import { accessSync, constants as constants2, unlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname as dirname3, join as join3 } 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 { 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 { tmpdir as tmpdir2 } from "node:os";
+import { join as join4 } from "node:path";
+import { join as posixJoin3 } from "node:path/posix";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var require_Reflect = __commonJS({
+  "node_modules/.pnpm/reflect-metadata@0.2.2/node_modules/reflect-metadata/Reflect.js"() {
+    var Reflect2;
+    (function(Reflect3) {
+      (function(factory) {
+        var root = typeof globalThis === "object" ? globalThis : typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : sloppyModeThis();
+        var exporter = makeExporter(Reflect3);
+        if (typeof root.Reflect !== "undefined") {
+          exporter = makeExporter(root.Reflect, exporter);
+        }
+        factory(exporter, root);
+        if (typeof root.Reflect === "undefined") {
+          root.Reflect = Reflect3;
+        }
+        function makeExporter(target, previous) {
+          return function(key, value) {
+            Object.defineProperty(target, key, { configurable: true, writable: true, value });
+            if (previous)
+              previous(key, value);
+          };
+        }
+        function functionThis() {
+          try {
+            return Function("return this;")();
+          } catch (_) {
+          }
+        }
+        function indirectEvalThis() {
+          try {
+            return (void 0, eval)("(function() { return this; })()");
+          } catch (_) {
+          }
+        }
+        function sloppyModeThis() {
+          return functionThis() || indirectEvalThis();
+        }
+      })(function(exporter, root) {
+        var hasOwn2 = Object.prototype.hasOwnProperty;
+        var supportsSymbol = typeof Symbol === "function";
+        var toPrimitiveSymbol = supportsSymbol && typeof Symbol.toPrimitive !== "undefined" ? Symbol.toPrimitive : "@@toPrimitive";
+        var iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== "undefined" ? Symbol.iterator : "@@iterator";
+        var supportsCreate = typeof Object.create === "function";
+        var supportsProto = { __proto__: [] } instanceof Array;
+        var downLevel = !supportsCreate && !supportsProto;
+        var HashMap = {
+          // create an object in dictionary mode (a.k.a. "slow" mode in v8)
+          create: supportsCreate ? function() {
+            return MakeDictionary(/* @__PURE__ */ Object.create(null));
+          } : supportsProto ? function() {
+            return MakeDictionary({ __proto__: null });
+          } : function() {
+            return MakeDictionary({});
+          },
           has: downLevel ? function(map, key) {
             return hasOwn2.call(map, key);
           } : function(map, key) {
@@ -19894,798 +20245,1182 @@ async function fetchWithRetry(url, init, signal) {
       if (response.ok) {
         return response;
       }
-      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));
-        continue;
+      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));
+        continue;
+      }
+      const errorText = await response.text().catch(() => "");
+      throw new Error(`HTTP ${response.status}: ${errorText}`);
+    } catch (e) {
+      lastError = e;
+      if (e instanceof DOMException && e.name === "AbortError") {
+        throw e;
+      }
+      if (attempt < MAX_RETRIES && e.name !== "AbortError") {
+        await sleep(calculateRetryDelay(attempt));
+        continue;
+      }
+      throw e;
+    }
+  }
+  throw lastError;
+}
+async function fetchStreamWithRetry(url, init, signal) {
+  let lastError;
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    if (signal?.aborted) {
+      throw new DOMException("Aborted", "AbortError");
+    }
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), STREAM_TIMEOUT);
+      if (signal) {
+        signal.addEventListener("abort", () => controller.abort());
+      }
+      const response = await fetch(url, {
+        ...init,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (response.ok) {
+        return response;
+      }
+      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));
+        continue;
+      }
+      const errorText = await response.text().catch(() => "");
+      throw new Error(`HTTP ${response.status}: ${errorText}`);
+    } catch (e) {
+      lastError = e;
+      if (e instanceof DOMException && e.name === "AbortError") {
+        throw e;
+      }
+      if (attempt < MAX_RETRIES && e.name !== "AbortError") {
+        await sleep(calculateRetryDelay(attempt));
+        continue;
+      }
+      throw e;
+    }
+  }
+  throw lastError;
+}
+function sanitizeResponse(text) {
+  return text;
+}
+function createAIClient(config) {
+  const baseUrl = config.providerUrl.replace(/\/$/, "");
+  const chatUrl = `${baseUrl}/chat/completions`;
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${config.apiKey}`
+  };
+  return {
+    async complete(options) {
+      const body = JSON.stringify({
+        model: options.model,
+        messages: options.messages,
+        temperature: options.temperature ?? 0.7,
+        stream: false,
+        response_format: options.responseFormat
+      });
+      const response = await fetchWithRetry(
+        chatUrl,
+        {
+          method: "POST",
+          headers,
+          body
+        },
+        options.signal
+      );
+      const data = await response.json();
+      const content = data.choices[0]?.message?.content ?? "";
+      const usage = data.usage ? {
+        promptTokens: data.usage.prompt_tokens,
+        completionTokens: data.usage.completion_tokens
+      } : void 0;
+      return { content: sanitizeResponse(content), usage };
+    },
+    async *stream(options) {
+      const body = JSON.stringify({
+        model: options.model,
+        messages: options.messages,
+        temperature: options.temperature ?? 0.7,
+        stream: true,
+        stream_options: { include_usage: true }
+      });
+      const response = await fetchStreamWithRetry(
+        chatUrl,
+        {
+          method: "POST",
+          headers,
+          body
+        },
+        options.signal
+      );
+      if (!response.body) {
+        throw new Error("No response body");
+      }
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      try {
+        while (true) {
+          if (options.signal?.aborted) {
+            throw new DOMException("Aborted", "AbortError");
+          }
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
+          for (const line of lines) {
+            if (!line.startsWith("data: ")) continue;
+            const data = line.slice(6).trim();
+            if (data === "[DONE]") continue;
+            try {
+              const parsed = JSON.parse(data);
+              const delta = parsed.choices[0]?.delta?.content ?? "";
+              const finishReason = parsed.choices[0]?.finish_reason;
+              const usage = parsed.usage ? {
+                promptTokens: parsed.usage.prompt_tokens,
+                completionTokens: parsed.usage.completion_tokens
+              } : void 0;
+              if (delta) {
+                yield { delta, done: false };
+              }
+              if (finishReason === "stop") {
+                yield { delta: "", done: true, usage };
+                return;
+              }
+            } catch {
+            }
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+      yield { delta: "", done: true };
+    }
+  };
+}
+function getConfigDir() {
+  const platform = process.platform;
+  if (platform === "win32") {
+    const localAppData = process.env.LOCALAPPDATA;
+    if (localAppData) {
+      return path.join(localAppData, "rogatio");
+    }
+    const userProfile = process.env.USERPROFILE;
+    if (userProfile) {
+      return path.join(userProfile, "AppData", "Local", "rogatio");
+    }
+    throw new Error("Unable to determine Windows config directory");
+  }
+  if (platform === "darwin") {
+    const home2 = process.env.HOME;
+    if (!home2) throw new Error("HOME not set");
+    return path.join(home2, "Library", "Application Support", "rogatio");
+  }
+  const xdgConfigHome = process.env.XDG_CONFIG_HOME;
+  if (xdgConfigHome) {
+    return path.join(xdgConfigHome, "rogatio");
+  }
+  const home = process.env.HOME;
+  if (!home) throw new Error("HOME not set");
+  return path.join(home, ".config", "rogatio");
+}
+function getProviderConfigPath() {
+  return path.join(getConfigDir(), "provider.json");
+}
+async function readProviderConfig() {
+  const configPath = getProviderConfigPath();
+  try {
+    const content = await fs.readFile(configPath, "utf8");
+    return JSON.parse(content);
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      return null;
+    }
+    throw e;
+  }
+}
+async function writeProviderConfig(config) {
+  const configPath = getProviderConfigPath();
+  const configDir = path.dirname(configPath);
+  await fs.mkdir(configDir, { recursive: true });
+  const content = JSON.stringify(config, null, 2);
+  await fs.writeFile(configPath, content, { mode: 384 });
+}
+async function deleteProviderConfig() {
+  const configPath = getProviderConfigPath();
+  try {
+    await fs.unlink(configPath);
+  } catch (e) {
+    if (e.code !== "ENOENT") {
+      throw e;
+    }
+  }
+}
+function runtimeError(code) {
+  return { code };
+}
+function failure(code) {
+  return { ok: false, error: runtimeError(code) };
+}
+function normalizeLogicalPath(value) {
+  if (typeof value !== "string" || value.length === 0) return null;
+  if (value.includes("\\") || value.includes("%") || hasControl(value)) {
+    return null;
+  }
+  if (value.startsWith("/") || value.endsWith("/") || value.includes("//")) {
+    return null;
+  }
+  const parts = value.split("/");
+  if (parts.some(
+    (part) => part.length === 0 || part === "." || part === ".." || part.includes(":") || /[*?[\]]/.test(part)
+  )) {
+    return null;
+  }
+  return parts.join("/");
+}
+var MAX_ARRAY_LENGTH = 4096;
+var MAX_OBJECT_PROPERTIES = 256;
+function snapshotOwnData3(value, ancestors = /* @__PURE__ */ new WeakSet()) {
+  if (value === null || typeof value !== "object") {
+    return { valid: true, value };
+  }
+  if (ancestors.has(value)) return { valid: false };
+  ancestors.add(value);
+  try {
+    if (Object.getOwnPropertySymbols(value).length > 0) {
+      return { valid: false };
+    }
+    if (Array.isArray(value)) {
+      const lengthDescriptor = Object.getOwnPropertyDescriptor(value, "length");
+      if (lengthDescriptor === void 0 || !("value" in lengthDescriptor) || !Number.isSafeInteger(lengthDescriptor.value) || lengthDescriptor.value < 0 || lengthDescriptor.value > MAX_ARRAY_LENGTH) {
+        return { valid: false };
+      }
+      const length = lengthDescriptor.value;
+      for (const propertyName of Object.getOwnPropertyNames(value)) {
+        if (propertyName === "length") continue;
+        const index = Number(propertyName);
+        if (!Number.isInteger(index) || index < 0 || index >= length || String(index) !== propertyName) {
+          return { valid: false };
+        }
       }
-      const errorText = await response.text().catch(() => "");
-      throw new Error(`HTTP ${response.status}: ${errorText}`);
-    } catch (e) {
-      lastError = e;
-      if (e instanceof DOMException && e.name === "AbortError") {
-        throw e;
+      const snapshot2 = new Array(length);
+      for (let index = 0; index < length; index += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(
+          value,
+          String(index)
+        );
+        if (descriptor === void 0 || !("value" in descriptor) || !descriptor.enumerable) {
+          return { valid: false };
+        }
+        const child = snapshotOwnData3(descriptor.value, ancestors);
+        if (!child.valid) return child;
+        snapshot2[index] = child.value;
       }
-      if (attempt < MAX_RETRIES && e.name !== "AbortError") {
-        await sleep(calculateRetryDelay(attempt));
-        continue;
+      return { valid: true, value: snapshot2 };
+    }
+    const names = Object.getOwnPropertyNames(value);
+    if (names.length > MAX_OBJECT_PROPERTIES) return { valid: false };
+    const snapshot = /* @__PURE__ */ Object.create(null);
+    for (const key of names) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (descriptor === void 0 || !("value" in descriptor) || !descriptor.enumerable) {
+        return { valid: false };
       }
-      throw e;
+      const child = snapshotOwnData3(descriptor.value, ancestors);
+      if (!child.valid) return child;
+      Object.defineProperty(snapshot, key, {
+        configurable: true,
+        enumerable: true,
+        value: child.value,
+        writable: true
+      });
+    }
+    return { valid: true, value: snapshot };
+  } catch {
+    return { valid: false };
+  } finally {
+    ancestors.delete(value);
+  }
+}
+function hasOwn(value, key) {
+  return Object.hasOwn(value, key);
+}
+var ID_PATTERN = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+function hasValidPercentEncoding(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    if (value[index] !== "%") continue;
+    if (!/^[0-9a-fA-F]{2}$/.test(value.slice(index + 1, index + 3))) {
+      return false;
+    }
+    index += 2;
+  }
+  return true;
+}
+function rawAuthority(value) {
+  const separator = value.indexOf("://");
+  if (separator < 0) return null;
+  const afterScheme = separator + 3;
+  let end = value.length;
+  for (const marker of ["/", "?", "#"]) {
+    const index = value.indexOf(marker, afterScheme);
+    if (index >= 0 && index < end) end = index;
+  }
+  return value.slice(afterScheme, end);
+}
+function hasNonAscii(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    if (value.charCodeAt(index) > 127) return true;
+  }
+  return false;
+}
+function validHostname(hostname) {
+  const unbracketed = hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
+  if (unbracketed.includes("%") || unbracketed.endsWith(".")) return false;
+  if (isIP2(unbracketed) !== 0) return true;
+  if (unbracketed.length === 0 || unbracketed.length > 253) return false;
+  return unbracketed.split(".").every((label2) => ID_PATTERN.test(label2));
+}
+function canonicalizeOutboundTarget(value) {
+  if (typeof value !== "string" || value.length === 0) return null;
+  if (value.trim() !== value || hasControl(value)) return null;
+  if (value.includes("\\") || value.includes("#")) return null;
+  if (!hasValidPercentEncoding(value)) return null;
+  if (/%(?:2f|2F|5c|5C)/.test(value)) return null;
+  const authority = rawAuthority(value);
+  if (authority === null || authority.length === 0) return null;
+  if (authority.includes("@") || authority.includes("*") || hasNonAscii(authority)) {
+    return null;
+  }
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return null;
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") return null;
+  if (url.username.length > 0 || url.password.length > 0) return null;
+  if (url.hash.length > 0 || url.hostname.length === 0) return null;
+  if (!validHostname(url.hostname)) return null;
+  const defaultPort = url.protocol === "https:" ? 443 : 80;
+  const port = url.port.length === 0 ? defaultPort : Number(url.port);
+  if (!Number.isInteger(port) || port !== 80 && port !== 443) return null;
+  if (url.protocol === "http:" && port !== 80) return null;
+  if (url.protocol === "https:" && port !== 443) return null;
+  const canonical = url.href;
+  if (canonical.includes("#") || canonical.includes("@")) return null;
+  return canonical;
+}
+function targetOrigin(value) {
+  const origin = normalizeSiteOrigin(new URL(value).origin);
+  return origin;
+}
+function isOriginAllowed(target, origins) {
+  const origin = targetOrigin(target);
+  return origin !== null && origins.includes(origin);
+}
+function validMethod(value) {
+  return typeof value === "string" && HTTP_METHODS.includes(value);
+}
+function validId(value) {
+  return typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(value);
+}
+function exactDescriptor(value) {
+  const snapshot = snapshotOwnData3(value);
+  if (!snapshot.valid || snapshot.value === null || typeof snapshot.value !== "object" || Array.isArray(snapshot.value))
+    return null;
+  const record = snapshot.value;
+  const keys = ["groupId", "ruleId", "operationId", "kind", "target", "method"];
+  if (Object.keys(record).length !== keys.length || !keys.every((key) => hasOwn(record, key)))
+    return null;
+  if (!validId(record.groupId) || !validId(record.ruleId) || !validId(record.operationId) || record.kind !== "outbound-http" && record.kind !== "confined-file" || typeof record.target !== "string" || !validMethod(record.method))
+    return null;
+  return {
+    groupId: record.groupId,
+    ruleId: record.ruleId,
+    operationId: record.operationId,
+    kind: record.kind,
+    target: record.target,
+    method: record.method
+  };
+}
+function canonicalTarget(kind, target) {
+  return kind === "outbound-http" ? canonicalizeOutboundTarget(target) : normalizeLogicalPath(target);
+}
+function matchesGrant(descriptor, grant) {
+  return descriptor.groupId === grant.groupId && descriptor.ruleId === grant.ruleId && descriptor.operationId === grant.operationId && descriptor.kind === grant.kind && descriptor.target === grant.target && descriptor.method === grant.method;
+}
+function authorizeExact(preset, value) {
+  const descriptor = exactDescriptor(value);
+  if (descriptor === null) return failure("runtime.authorization-denied");
+  const target = canonicalTarget(descriptor.kind, descriptor.target);
+  if (target === null) return failure("runtime.authorization-denied");
+  for (const grant of preset.grants) {
+    if (!matchesGrant({ ...descriptor, target }, grant)) continue;
+    const matcher = preset.matchers.find(
+      (candidate) => candidate.groupId === grant.groupId && candidate.ruleId === grant.ruleId
+    );
+    if (matcher === void 0 || grant.kind === "outbound-http" && !isOriginAllowed(grant.target, matcher.matcher.origins)) {
+      return failure("runtime.authorization-denied");
+    }
+    return {
+      ok: true,
+      value: Object.freeze({
+        groupId: grant.groupId,
+        ruleId: grant.ruleId,
+        operationId: grant.operationId,
+        kind: grant.kind,
+        target: grant.target,
+        method: grant.method,
+        presetDigest: preset.digest
+      })
+    };
+  }
+  return failure("runtime.authorization-denied");
+}
+var RUNTIME_LIMITS = Object.freeze({
+  maxPresetBytes: 262144,
+  maxRequestLineBytes: 8192,
+  maxHeaderCount: 64,
+  maxRequestHeaderBytes: 32768,
+  maxControlBodyBytes: 65536,
+  maxResponseHeaderBytes: 32768,
+  maxResponseBodyBytes: 4194304,
+  maxFileBytes: 4194304,
+  maxConcurrentSessions: 16,
+  maxConcurrentOperations: 32,
+  maxOperationsPerSession: 4,
+  maxDnsAddresses: 32,
+  bootstrapLifetimeMs: 6e4,
+  sessionLifetimeMs: 6e5,
+  connectTimeoutMs: 2e3,
+  responseHeaderTimeoutMs: 5e3,
+  bodyIdleTimeoutMs: 1e4,
+  operationTimeoutMs: 3e4,
+  maxRedirects: 0,
+  maxRequestBodyBytes: 4194304,
+  maxRequestBodyPatternLength: 2048,
+  maxRequestBodyReplacementLength: 4096,
+  maxRequestBodyOperations: 32,
+  maxRequestBodyTransforms: 32,
+  maxRegexDeadlineMs: 250,
+  maxLocalOrigins: 32
+});
+var PROTOCOL = "v1";
+var ENVELOPE_MAX_BYTES = 64 * 1024;
+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 BODY_CHECK_EXEMPT_TYPES = /* @__PURE__ */ new Set(["runtime.project.set"]);
+var ENVELOPE_MESSAGE_TYPES = /* @__PURE__ */ new Set([
+  "runtime.start",
+  "runtime.stop",
+  "runtime.status",
+  "runtime.project.set",
+  "authority.grant",
+  "authority.revoke",
+  "transform.request",
+  "transform.result",
+  "pair.request",
+  "pair.response",
+  "authorize.request",
+  "authorize.response",
+  "mock.connect",
+  "mock.request",
+  "mock.response",
+  "ai.complete",
+  "ai.stream.chunk",
+  "ai.error"
+]);
+var EnvelopeError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "EnvelopeError";
+  }
+};
+function containsBodyKey(value) {
+  if (value === null || typeof value !== "object") return false;
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      if (containsBodyKey(item)) return true;
     }
+    return false;
   }
-  throw lastError;
+  for (const key of Object.keys(value)) {
+    if (FORBIDDEN_BODY_KEYS.has(key)) return true;
+    if (containsBodyKey(value[key])) return true;
+  }
+  return false;
 }
-async function fetchStreamWithRetry(url, init, signal) {
-  let lastError;
-  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-    if (signal?.aborted) {
-      throw new DOMException("Aborted", "AbortError");
-    }
-    try {
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), STREAM_TIMEOUT);
-      if (signal) {
-        signal.addEventListener("abort", () => controller.abort());
-      }
-      const response = await fetch(url, {
-        ...init,
-        signal: controller.signal
-      });
-      clearTimeout(timeoutId);
-      if (response.ok) {
-        return response;
-      }
-      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));
-        continue;
-      }
-      const errorText = await response.text().catch(() => "");
-      throw new Error(`HTTP ${response.status}: ${errorText}`);
-    } catch (e) {
-      lastError = e;
-      if (e instanceof DOMException && e.name === "AbortError") {
-        throw e;
-      }
-      if (attempt < MAX_RETRIES && e.name !== "AbortError") {
-        await sleep(calculateRetryDelay(attempt));
-        continue;
-      }
-      throw e;
-    }
+function assertNoBodyContent(type, metadata) {
+  if (BODY_CHECK_EXEMPT_TYPES.has(type)) return;
+  if (containsBodyKey(metadata)) {
+    throw new EnvelopeError(
+      "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"
+    );
   }
-  throw lastError;
 }
-function sanitizeResponse(text) {
-  return text;
+function utf8ByteLength(value) {
+  return Buffer.byteLength(value, "utf8");
 }
-function createAIClient(config) {
-  const baseUrl = config.providerUrl.replace(/\/$/, "");
-  const chatUrl = `${baseUrl}/chat/completions`;
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config.apiKey}`
-  };
-  return {
-    async complete(options) {
-      const body = JSON.stringify({
-        model: options.model,
-        messages: options.messages,
-        temperature: options.temperature ?? 0.7,
-        stream: false,
-        response_format: options.responseFormat
-      });
-      const response = await fetchWithRetry(
-        chatUrl,
-        {
-          method: "POST",
-          headers,
-          body
-        },
-        options.signal
-      );
-      const data = await response.json();
-      const content = data.choices[0]?.message?.content ?? "";
-      const usage = data.usage ? {
-        promptTokens: data.usage.prompt_tokens,
-        completionTokens: data.usage.completion_tokens
-      } : void 0;
-      return { content: sanitizeResponse(content), usage };
-    },
-    async *stream(options) {
-      const body = JSON.stringify({
-        model: options.model,
-        messages: options.messages,
-        temperature: options.temperature ?? 0.7,
-        stream: true,
-        stream_options: { include_usage: true }
-      });
-      const response = await fetchStreamWithRetry(
-        chatUrl,
-        {
-          method: "POST",
-          headers,
-          body
-        },
-        options.signal
-      );
-      if (!response.body) {
-        throw new Error("No response body");
-      }
-      const reader = response.body.getReader();
-      const decoder = new TextDecoder();
-      let buffer = "";
-      try {
-        while (true) {
-          if (options.signal?.aborted) {
-            throw new DOMException("Aborted", "AbortError");
-          }
-          const { done, value } = await reader.read();
-          if (done) break;
-          buffer += decoder.decode(value, { stream: true });
-          const lines = buffer.split("\n");
-          buffer = lines.pop() ?? "";
-          for (const line of lines) {
-            if (!line.startsWith("data: ")) continue;
-            const data = line.slice(6).trim();
-            if (data === "[DONE]") continue;
-            try {
-              const parsed = JSON.parse(data);
-              const delta = parsed.choices[0]?.delta?.content ?? "";
-              const finishReason = parsed.choices[0]?.finish_reason;
-              const usage = parsed.usage ? {
-                promptTokens: parsed.usage.prompt_tokens,
-                completionTokens: parsed.usage.completion_tokens
-              } : void 0;
-              if (delta) {
-                yield { delta, done: false };
-              }
-              if (finishReason === "stop") {
-                yield { delta: "", done: true, usage };
-                return;
-              }
-            } catch {
-            }
-          }
-        }
-      } finally {
-        reader.releaseLock();
-      }
-      yield { delta: "", done: true };
-    }
+function serializeEnvelope(input) {
+  if (!ENVELOPE_MESSAGE_TYPES.has(input.type)) {
+    throw new EnvelopeError(`unknown envelope type: ${String(input.type)}`);
+  }
+  if (input.metadata === void 0 || typeof input.metadata !== "object") {
+    throw new EnvelopeError("envelope metadata is required");
+  }
+  assertNoBodyContent(input.type, input.metadata);
+  const envelope = {
+    protocol: PROTOCOL,
+    type: input.type,
+    metadata: input.metadata,
+    ...input.requestId !== void 0 ? { requestId: input.requestId } : {},
+    ...input.timestamp !== void 0 ? { timestamp: input.timestamp } : {}
   };
+  const serialized = JSON.stringify(envelope);
+  if (utf8ByteLength(serialized) > ENVELOPE_MAX_BYTES) {
+    throw new EnvelopeError("envelope exceeds maximum size");
+  }
+  return serialized;
 }
-function getConfigDir() {
-  const platform = process.platform;
-  if (platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA;
-    if (localAppData) {
-      return path.join(localAppData, "rogatio");
-    }
-    const userProfile = process.env.USERPROFILE;
-    if (userProfile) {
-      return path.join(userProfile, "AppData", "Local", "rogatio");
-    }
-    throw new Error("Unable to determine Windows config directory");
+function parseEnvelope(json) {
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    throw new EnvelopeError("envelope is not valid JSON");
   }
-  if (platform === "darwin") {
-    const home2 = process.env.HOME;
-    if (!home2) throw new Error("HOME not set");
-    return path.join(home2, "Library", "Application Support", "rogatio");
+  if (parsed === null || typeof parsed !== "object") {
+    throw new EnvelopeError("envelope must be an object");
   }
-  const xdgConfigHome = process.env.XDG_CONFIG_HOME;
-  if (xdgConfigHome) {
-    return path.join(xdgConfigHome, "rogatio");
+  const record = parsed;
+  if (record.protocol !== PROTOCOL) {
+    throw new EnvelopeError("envelope protocol mismatch");
   }
-  const home = process.env.HOME;
-  if (!home) throw new Error("HOME not set");
-  return path.join(home, ".config", "rogatio");
+  if (typeof record.type !== "string" || !ENVELOPE_MESSAGE_TYPES.has(record.type)) {
+    throw new EnvelopeError("envelope type invalid");
+  }
+  if (typeof record.metadata !== "object" || record.metadata === null) {
+    throw new EnvelopeError("envelope metadata missing");
+  }
+  assertNoBodyContent(
+    record.type,
+    record.metadata
+  );
+  const envelope = {
+    protocol: PROTOCOL,
+    type: record.type,
+    metadata: record.metadata,
+    ...typeof record.requestId === "string" ? { requestId: record.requestId } : {},
+    ...typeof record.timestamp === "number" ? { timestamp: record.timestamp } : {}
+  };
+  return envelope;
+}
+var TOKEN_BYTES = 32;
+var TOKEN_LENGTH = 43;
+function createCapabilityState(preset, now) {
+  const bootstrap = randomBytes(TOKEN_BYTES).toString("base64url");
+  return {
+    presetDigest: preset.digest,
+    bootstrap,
+    bootstrapDigest: digestToken(bootstrap),
+    bootstrapExpiresAt: now + RUNTIME_LIMITS.bootstrapLifetimeMs,
+    sessions: [],
+    consumed: false,
+    closed: false
+  };
 }
-function getProviderConfigPath() {
-  return path.join(getConfigDir(), "provider.json");
+function digestToken(value) {
+  return createHash("sha256").update(value, "utf8").digest();
 }
-async function readProviderConfig() {
-  const configPath = getProviderConfigPath();
+function isToken(value) {
+  if (typeof value !== "string" || value.length !== TOKEN_LENGTH) return false;
+  if (!/^[A-Za-z0-9_-]+$/.test(value)) return false;
   try {
-    const content = await fs.readFile(configPath, "utf8");
-    return JSON.parse(content);
-  } catch (e) {
-    if (e.code === "ENOENT") {
-      return null;
-    }
-    throw e;
+    return Buffer.from(value, "base64url").length === TOKEN_BYTES;
+  } catch {
+    return false;
   }
 }
-async function writeProviderConfig(config) {
-  const configPath = getProviderConfigPath();
-  const configDir = path.dirname(configPath);
-  await fs.mkdir(configDir, { recursive: true });
-  const content = JSON.stringify(config, null, 2);
-  await fs.writeFile(configPath, content, { mode: 384 });
-}
-async function deleteProviderConfig() {
-  const configPath = getProviderConfigPath();
-  try {
-    await fs.unlink(configPath);
-  } catch (e) {
-    if (e.code !== "ENOENT") {
-      throw e;
-    }
-  }
+function sameToken(value, expectedDigest) {
+  const actual = digestToken(value);
+  return actual.length === expectedDigest.length && timingSafeEqual(actual, expectedDigest);
 }
-function runtimeError(code) {
-  return { code };
+function sameDigest(value, expected) {
+  if (!isSha256Digest(value) || value.length !== expected.length) return false;
+  const actual = Buffer.from(value, "ascii");
+  const wanted = Buffer.from(expected, "ascii");
+  return timingSafeEqual(actual, wanted);
 }
-function failure(code) {
-  return { ok: false, error: runtimeError(code) };
+function cleanSessions(state, now) {
+  for (let index = state.sessions.length - 1; index >= 0; index -= 1) {
+    if (state.sessions[index]?.expiresAt <= now)
+      state.sessions.splice(index, 1);
+  }
 }
-function normalizeLogicalPath(value) {
-  if (typeof value !== "string" || value.length === 0) return null;
-  if (value.includes("\\") || value.includes("%") || hasControl(value)) {
-    return null;
+function pairCapability(state, capability, digest, now) {
+  cleanSessions(state, now);
+  if (state.closed || state.consumed || !isToken(capability) || typeof digest !== "string" || !sameDigest(digest, state.presetDigest) || now >= state.bootstrapExpiresAt || !sameToken(capability, state.bootstrapDigest)) {
+    return failure("runtime.pairing-denied");
   }
-  if (value.startsWith("/") || value.endsWith("/") || value.includes("//")) {
-    return null;
+  if (state.sessions.length >= RUNTIME_LIMITS.maxConcurrentSessions) {
+    return failure("runtime.overloaded");
   }
-  const parts = value.split("/");
-  if (parts.some(
-    (part) => part.length === 0 || part === "." || part === ".." || part.includes(":") || /[*?[\]]/.test(part)
-  )) {
+  state.consumed = true;
+  const sessionCapability = randomBytes(TOKEN_BYTES).toString("base64url");
+  const expiresAt = now + RUNTIME_LIMITS.sessionLifetimeMs;
+  state.sessions.push({
+    digest: Buffer.from(state.presetDigest, "ascii"),
+    expiresAt,
+    tokenDigest: digestToken(sessionCapability),
+    activeOperations: 0
+  });
+  return {
+    ok: true,
+    value: {
+      sessionCapability,
+      expiresInMs: RUNTIME_LIMITS.sessionLifetimeMs
+    }
+  };
+}
+function findSession(state, capability, digest, now) {
+  cleanSessions(state, now);
+  if (state.closed || !isToken(capability) || typeof digest !== "string")
     return null;
+  if (!sameDigest(digest, state.presetDigest)) return null;
+  const candidate = digestToken(capability);
+  for (const session of state.sessions) {
+    if (candidate.length === session.tokenDigest.length && timingSafeEqual(candidate, session.tokenDigest) && sameDigest(digest, session.digest.toString("ascii"))) {
+      return session;
+    }
   }
-  return parts.join("/");
+  return null;
 }
-var MAX_ARRAY_LENGTH = 4096;
-var MAX_OBJECT_PROPERTIES = 256;
-function snapshotOwnData2(value, ancestors = /* @__PURE__ */ new WeakSet()) {
-  if (value === null || typeof value !== "object") {
-    return { valid: true, value };
+function acquireOperation(_state, session) {
+  if (session.activeOperations >= RUNTIME_LIMITS.maxOperationsPerSession) {
+    return failure("runtime.overloaded");
   }
-  if (ancestors.has(value)) return { valid: false };
-  ancestors.add(value);
-  try {
-    if (Object.getOwnPropertySymbols(value).length > 0) {
-      return { valid: false };
-    }
-    if (Array.isArray(value)) {
-      const lengthDescriptor = Object.getOwnPropertyDescriptor(value, "length");
-      if (lengthDescriptor === void 0 || !("value" in lengthDescriptor) || !Number.isSafeInteger(lengthDescriptor.value) || lengthDescriptor.value < 0 || lengthDescriptor.value > MAX_ARRAY_LENGTH) {
-        return { valid: false };
-      }
-      const length = lengthDescriptor.value;
-      for (const propertyName of Object.getOwnPropertyNames(value)) {
-        if (propertyName === "length") continue;
-        const index = Number(propertyName);
-        if (!Number.isInteger(index) || index < 0 || index >= length || String(index) !== propertyName) {
-          return { valid: false };
-        }
-      }
-      const snapshot2 = new Array(length);
-      for (let index = 0; index < length; index += 1) {
-        const descriptor = Object.getOwnPropertyDescriptor(
-          value,
-          String(index)
-        );
-        if (descriptor === void 0 || !("value" in descriptor) || !descriptor.enumerable) {
-          return { valid: false };
-        }
-        const child = snapshotOwnData2(descriptor.value, ancestors);
-        if (!child.valid) return child;
-        snapshot2[index] = child.value;
-      }
-      return { valid: true, value: snapshot2 };
-    }
-    const names = Object.getOwnPropertyNames(value);
-    if (names.length > MAX_OBJECT_PROPERTIES) return { valid: false };
-    const snapshot = /* @__PURE__ */ Object.create(null);
-    for (const key of names) {
-      const descriptor = Object.getOwnPropertyDescriptor(value, key);
-      if (descriptor === void 0 || !("value" in descriptor) || !descriptor.enumerable) {
-        return { valid: false };
-      }
-      const child = snapshotOwnData2(descriptor.value, ancestors);
-      if (!child.valid) return child;
-      Object.defineProperty(snapshot, key, {
-        configurable: true,
-        enumerable: true,
-        value: child.value,
-        writable: true
-      });
+  session.activeOperations += 1;
+  return {
+    ok: true,
+    value: () => {
+      session.activeOperations = Math.max(0, session.activeOperations - 1);
     }
-    return { valid: true, value: snapshot };
-  } catch {
-    return { valid: false };
-  } finally {
-    ancestors.delete(value);
-  }
-}
-function hasOwn(value, key) {
-  return Object.hasOwn(value, key);
+  };
 }
-var ID_PATTERN = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
-function hasValidPercentEncoding(value) {
-  for (let index = 0; index < value.length; index += 1) {
-    if (value[index] !== "%") continue;
-    if (!/^[0-9a-fA-F]{2}$/.test(value.slice(index + 1, index + 3))) {
-      return false;
-    }
-    index += 2;
-  }
-  return true;
+function closeCapabilityState(state) {
+  state.closed = true;
+  state.consumed = true;
+  state.sessions.length = 0;
+  state.bootstrapDigest.fill(0);
 }
-function rawAuthority(value) {
-  const separator = value.indexOf("://");
-  if (separator < 0) return null;
-  const afterScheme = separator + 3;
-  let end = value.length;
-  for (const marker of ["/", "?", "#"]) {
-    const index = value.indexOf(marker, afterScheme);
-    if (index >= 0 && index < end) end = index;
+var registeredProvider = null;
+var currentSession = null;
+async function startInterception(activation, policyDigest, extensionId, pacOrigins, targetPolicy) {
+  if (registeredProvider === null) {
+    return { kind: "unsupported", reasons: ["no-interception-provider"] };
   }
-  return value.slice(afterScheme, end);
-}
-function hasNonAscii(value) {
-  for (let index = 0; index < value.length; index += 1) {
-    if (value.charCodeAt(index) > 127) return true;
+  const capabilities = registeredProvider.detect();
+  if (!capabilities.supported) {
+    return { kind: "unsupported", reasons: capabilities.reasons };
   }
-  return false;
-}
-function validHostname(hostname) {
-  const unbracketed = hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
-  if (unbracketed.includes("%") || unbracketed.endsWith(".")) return false;
-  if (isIP2(unbracketed) !== 0) return true;
-  if (unbracketed.length === 0 || unbracketed.length > 253) return false;
-  return unbracketed.split(".").every((label2) => ID_PATTERN.test(label2));
-}
-function canonicalizeOutboundTarget(value) {
-  if (typeof value !== "string" || value.length === 0) return null;
-  if (value.trim() !== value || hasControl(value)) return null;
-  if (value.includes("\\") || value.includes("#")) return null;
-  if (!hasValidPercentEncoding(value)) return null;
-  if (/%(?:2f|2F|5c|5C)/.test(value)) return null;
-  const authority = rawAuthority(value);
-  if (authority === null || authority.length === 0) return null;
-  if (authority.includes("@") || authority.includes("*") || hasNonAscii(authority)) {
-    return null;
+  if (currentSession !== null) {
+    return { kind: "unsupported", reasons: ["session-collision"] };
   }
-  let url;
+  const sessionId = `session-${activation.startedAt}-${Math.random().toString(36).slice(2)}`;
   try {
-    url = new URL(value);
-  } catch {
-    return null;
+    await registeredProvider.start(activation);
+  } catch (error) {
+    return {
+      kind: "unsupported",
+      reasons: ["provider-start-failed", String(error)]
+    };
+  }
+  currentSession = {
+    sessionId,
+    provider: registeredProvider,
+    activation,
+    policyDigest,
+    extensionId,
+    pacOrigins,
+    targetPolicy,
+    startedAt: activation.startedAt
+  };
+  return { kind: "active", provider: registeredProvider.platform };
+}
+async function stopInterception() {
+  if (currentSession === null && registeredProvider === null) return;
+  const session = currentSession;
+  currentSession = null;
+  if (session?.provider) {
+    try {
+      await session.provider.stop();
+    } catch {
+    }
   }
-  if (url.protocol !== "http:" && url.protocol !== "https:") return null;
-  if (url.username.length > 0 || url.password.length > 0) return null;
-  if (url.hash.length > 0 || url.hostname.length === 0) return null;
-  if (!validHostname(url.hostname)) return null;
-  const defaultPort = url.protocol === "https:" ? 443 : 80;
-  const port = url.port.length === 0 ? defaultPort : Number(url.port);
-  if (!Number.isInteger(port) || port !== 80 && port !== 443) return null;
-  if (url.protocol === "http:" && port !== 80) return null;
-  if (url.protocol === "https:" && port !== 443) return null;
-  const canonical = url.href;
-  if (canonical.includes("#") || canonical.includes("@")) return null;
-  return canonical;
 }
-function targetOrigin(value) {
-  const origin = normalizeSiteOrigin(new URL(value).origin);
-  return origin;
+function hasActiveSession() {
+  return currentSession !== null;
 }
-function isOriginAllowed(target, origins) {
-  const origin = targetOrigin(target);
-  return origin !== null && origins.includes(origin);
+function withinRoot2(root, candidate) {
+  const rest = relative2(root, candidate);
+  return rest.length > 0 && rest !== ".." && !rest.startsWith(`..${sep}`) && !isAbsolute2(rest);
 }
-function validMethod(value) {
-  return typeof value === "string" && HTTP_METHODS.includes(value);
+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");
+  }
 }
-function validId(value) {
-  return typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(value);
+function mintToken() {
+  return randomBytes2(32).toString("hex");
 }
-function exactDescriptor(value) {
-  const snapshot = snapshotOwnData2(value);
-  if (!snapshot.valid || snapshot.value === null || typeof snapshot.value !== "object" || Array.isArray(snapshot.value))
-    return null;
-  const record = snapshot.value;
-  const keys = ["groupId", "ruleId", "operationId", "kind", "target", "method"];
-  if (Object.keys(record).length !== keys.length || !keys.every((key) => hasOwn(record, key)))
-    return null;
-  if (!validId(record.groupId) || !validId(record.ruleId) || !validId(record.operationId) || record.kind !== "outbound-http" && record.kind !== "confined-file" || typeof record.target !== "string" || !validMethod(record.method))
-    return null;
+async function renderMockResponse(options) {
+  const { mock, fileRoot } = options;
+  let bodyBytes;
+  if (mock.body !== void 0) {
+    bodyBytes = 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;
+  } else {
+    return failure("runtime.file-denied");
+  }
+  const headers = [];
+  let hasContentType = false;
+  for (const header of mock.headers ?? []) {
+    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-Length", String(bodyBytes.byteLength)]);
+  headers.push(["Cache-Control", "no-store"]);
   return {
-    groupId: record.groupId,
-    ruleId: record.ruleId,
-    operationId: record.operationId,
-    kind: record.kind,
-    target: record.target,
-    method: record.method
+    ok: true,
+    value: {
+      status: mock.status,
+      headers,
+      bodyBytes
+    }
   };
 }
-function canonicalTarget(kind, target) {
-  return kind === "outbound-http" ? canonicalizeOutboundTarget(target) : normalizeLogicalPath(target);
+function stringValue(value) {
+  const encoded = JSON.stringify(value);
+  if (encoded === void 0) throw new Error("invalid string");
+  return encoded;
 }
-function matchesGrant(descriptor, grant) {
-  return descriptor.groupId === grant.groupId && descriptor.ruleId === grant.ruleId && descriptor.operationId === grant.operationId && descriptor.kind === grant.kind && descriptor.target === grant.target && descriptor.method === grant.method;
+function arrayValue(values) {
+  return `[${values.map(stringValue).join(",")}]`;
 }
-function authorizeExact(preset, value) {
-  const descriptor = exactDescriptor(value);
-  if (descriptor === null) return failure("runtime.authorization-denied");
-  const target = canonicalTarget(descriptor.kind, descriptor.target);
-  if (target === null) return failure("runtime.authorization-denied");
-  for (const grant of preset.grants) {
-    if (!matchesGrant({ ...descriptor, target }, grant)) continue;
-    const matcher = preset.matchers.find(
-      (candidate) => candidate.groupId === grant.groupId && candidate.ruleId === grant.ruleId
-    );
-    if (matcher === void 0 || grant.kind === "outbound-http" && !isOriginAllowed(grant.target, matcher.matcher.origins)) {
-      return failure("runtime.authorization-denied");
-    }
-    return {
-      ok: true,
-      value: Object.freeze({
-        groupId: grant.groupId,
-        ruleId: grant.ruleId,
-        operationId: grant.operationId,
-        kind: grant.kind,
-        target: grant.target,
-        method: grant.method,
-        presetDigest: preset.digest
-      })
-    };
-  }
-  return failure("runtime.authorization-denied");
+function matcherValue(operation) {
+  const matcher = operation.matcher;
+  const method = matcher.method === void 0 ? "" : `,"method":${stringValue(matcher.method)}`;
+  return `{"kind":"matcher","groupId":${stringValue(operation.groupId)},"ruleId":${stringValue(operation.ruleId)},"matcher":{"urlRegex":{"source":${stringValue(matcher.urlRegex.source)},"flags":""},"origins":${arrayValue(matcher.origins)},"resourceTypes":${arrayValue(matcher.resourceTypes)},"priority":${String(matcher.priority)}${method}}}`;
 }
-var RUNTIME_LIMITS = Object.freeze({
-  maxPresetBytes: 262144,
-  maxRequestLineBytes: 8192,
-  maxHeaderCount: 64,
-  maxRequestHeaderBytes: 32768,
-  maxControlBodyBytes: 65536,
-  maxResponseHeaderBytes: 32768,
-  maxResponseBodyBytes: 4194304,
-  maxFileBytes: 4194304,
-  maxConcurrentSessions: 16,
-  maxConcurrentOperations: 32,
-  maxOperationsPerSession: 4,
-  maxDnsAddresses: 32,
-  bootstrapLifetimeMs: 6e4,
-  sessionLifetimeMs: 6e5,
-  connectTimeoutMs: 2e3,
-  responseHeaderTimeoutMs: 5e3,
-  bodyIdleTimeoutMs: 1e4,
-  operationTimeoutMs: 3e4,
-  maxRedirects: 0,
-  maxRequestBodyBytes: 4194304,
-  maxRequestBodyPatternLength: 2048,
-  maxRequestBodyReplacementLength: 4096,
-  maxRequestBodyOperations: 32,
-  maxRequestBodyTransforms: 32,
-  maxRegexDeadlineMs: 250,
-  maxLocalOrigins: 32
-});
-var PROTOCOL = "v1";
-var ENVELOPE_MAX_BYTES = 64 * 1024;
-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 ENVELOPE_MESSAGE_TYPES = /* @__PURE__ */ new Set([
-  "runtime.start",
-  "runtime.stop",
-  "runtime.status",
-  "authority.grant",
-  "authority.revoke",
-  "transform.request",
-  "transform.result",
-  "pair.request",
-  "pair.response",
-  "authorize.request",
-  "authorize.response",
-  "mock.connect",
-  "mock.request",
-  "mock.response",
-  "ai.complete",
-  "ai.stream.chunk",
-  "ai.error"
-]);
-var EnvelopeError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "EnvelopeError";
-  }
-};
-function containsBodyKey(value) {
-  if (value === null || typeof value !== "object") return false;
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      if (containsBodyKey(item)) return true;
-    }
-    return false;
-  }
-  for (const key of Object.keys(value)) {
-    if (FORBIDDEN_BODY_KEYS.has(key)) return true;
-    if (containsBodyKey(value[key])) return true;
-  }
-  return false;
+function limitsValue(limits) {
+  const fields = [
+    ["maxPresetBytes", limits.maxPresetBytes],
+    ["maxRequestLineBytes", limits.maxRequestLineBytes],
+    ["maxHeaderCount", limits.maxHeaderCount],
+    ["maxRequestHeaderBytes", limits.maxRequestHeaderBytes],
+    ["maxControlBodyBytes", limits.maxControlBodyBytes],
+    ["maxResponseHeaderBytes", limits.maxResponseHeaderBytes],
+    ["maxResponseBodyBytes", limits.maxResponseBodyBytes],
+    ["maxFileBytes", limits.maxFileBytes],
+    ["maxConcurrentSessions", limits.maxConcurrentSessions],
+    ["maxConcurrentOperations", limits.maxConcurrentOperations],
+    ["maxOperationsPerSession", limits.maxOperationsPerSession],
+    ["maxDnsAddresses", limits.maxDnsAddresses],
+    ["bootstrapLifetimeMs", limits.bootstrapLifetimeMs],
+    ["sessionLifetimeMs", limits.sessionLifetimeMs],
+    ["connectTimeoutMs", limits.connectTimeoutMs],
+    ["responseHeaderTimeoutMs", limits.responseHeaderTimeoutMs],
+    ["bodyIdleTimeoutMs", limits.bodyIdleTimeoutMs],
+    ["operationTimeoutMs", limits.operationTimeoutMs],
+    ["maxRedirects", limits.maxRedirects]
+  ];
+  return `{${fields.map(([key, value]) => `${stringValue(key)}:${String(value)}`).join(",")}}`;
 }
-function assertNoBodyContent(type, metadata) {
-  if (containsBodyKey(metadata)) {
-    throw new EnvelopeError(
-      "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 grantValue(grant) {
+  return `{"groupId":${stringValue(grant.groupId)},"ruleId":${stringValue(grant.ruleId)},"operationId":${stringValue(grant.operationId)},"kind":${stringValue(grant.kind)},"target":${stringValue(grant.target)},"method":${stringValue(grant.method)}}`;
+}
+function mockHeaderValue(header) {
+  return `{"name":${stringValue(header.name)},"value":${stringValue(header.value)}}`;
+}
+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 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}}`;
 }
-function utf8ByteLength(value) {
-  return Buffer.byteLength(value, "utf8");
+function sortMocks(mocks) {
+  return [...mocks].sort(
+    (left, right) => compareStrings(left.ruleId, right.ruleId)
+  );
 }
-function serializeEnvelope(input) {
-  if (!ENVELOPE_MESSAGE_TYPES.has(input.type)) {
-    throw new EnvelopeError(`unknown envelope type: ${String(input.type)}`);
-  }
-  if (input.metadata === void 0 || typeof input.metadata !== "object") {
-    throw new EnvelopeError("envelope metadata is required");
-  }
-  assertNoBodyContent(input.type, input.metadata);
-  const envelope = {
-    protocol: PROTOCOL,
-    type: input.type,
-    metadata: input.metadata,
-    ...input.requestId !== void 0 ? { requestId: input.requestId } : {},
-    ...input.timestamp !== void 0 ? { timestamp: input.timestamp } : {}
-  };
-  const serialized = JSON.stringify(envelope);
-  if (utf8ByteLength(serialized) > ENVELOPE_MAX_BYTES) {
-    throw new EnvelopeError("envelope exceeds maximum size");
-  }
-  return serialized;
+function compareStrings(left, right) {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
 }
-function parseEnvelope(json) {
-  let parsed;
-  try {
-    parsed = JSON.parse(json);
-  } catch {
-    throw new EnvelopeError("envelope is not valid JSON");
-  }
-  if (parsed === null || typeof parsed !== "object") {
-    throw new EnvelopeError("envelope must be an object");
-  }
-  const record = parsed;
-  if (record.protocol !== PROTOCOL) {
-    throw new EnvelopeError("envelope protocol mismatch");
-  }
-  if (typeof record.type !== "string" || !ENVELOPE_MESSAGE_TYPES.has(record.type)) {
-    throw new EnvelopeError("envelope type invalid");
-  }
-  if (typeof record.metadata !== "object" || record.metadata === null) {
-    throw new EnvelopeError("envelope metadata missing");
-  }
-  assertNoBodyContent(
-    record.type,
-    record.metadata
+function sortGrants(grants) {
+  return [...grants].sort(
+    (left, right) => compareStrings(left.groupId, right.groupId) || compareStrings(left.ruleId, right.ruleId) || compareStrings(left.operationId, right.operationId) || compareStrings(left.kind, right.kind) || compareStrings(left.target, right.target) || compareStrings(left.method, right.method)
   );
-  const envelope = {
-    protocol: PROTOCOL,
-    type: record.type,
-    metadata: record.metadata,
-    ...typeof record.requestId === "string" ? { requestId: record.requestId } : {},
-    ...typeof record.timestamp === "number" ? { timestamp: record.timestamp } : {}
-  };
-  return envelope;
 }
-var TOKEN_BYTES = 32;
-var TOKEN_LENGTH = 43;
-function createCapabilityState(preset, now) {
-  const bootstrap = randomBytes(TOKEN_BYTES).toString("base64url");
-  return {
-    presetDigest: preset.digest,
-    bootstrap,
-    bootstrapDigest: digestToken(bootstrap),
-    bootstrapExpiresAt: now + RUNTIME_LIMITS.bootstrapLifetimeMs,
-    sessions: [],
-    consumed: false,
-    closed: false
-  };
+function canonicalPresetBytes(preset, grants = preset.grants) {
+  const matchers = preset.matchers.map(matcherValue).join(",");
+  const mocks = preset.mocks === void 0 || preset.mocks.length === 0 ? "" : `,"mocks":[${sortMocks(preset.mocks).map(mockValue).join(",")}]`;
+  const canonical = `{"version":1,"limits":${limitsValue(preset.limits)},"matchers":[${matchers}],"grants":[${sortGrants(grants).map(grantValue).join(",")}]${mocks}}`;
+  return new TextEncoder().encode(canonical);
 }
-function digestToken(value) {
-  return createHash("sha256").update(value, "utf8").digest();
+function digestBytes(bytes) {
+  return formatSha256(createHash2("sha256").update(bytes).digest("hex"));
 }
-function isToken(value) {
-  if (typeof value !== "string" || value.length !== TOKEN_LENGTH) return false;
-  if (!/^[A-Za-z0-9_-]+$/.test(value)) return false;
-  try {
-    return Buffer.from(value, "base64url").length === TOKEN_BYTES;
-  } catch {
-    return false;
-  }
+var ID_PATTERN2 = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+function exactKeys(value, required) {
+  const keys = Object.keys(value);
+  return keys.length === required.length && required.every((key) => hasOwn(value, key));
 }
-function sameToken(value, expectedDigest) {
-  const actual = digestToken(value);
-  return actual.length === expectedDigest.length && timingSafeEqual(actual, expectedDigest);
+function validId2(value) {
+  return typeof value === "string" && ID_PATTERN2.test(value);
 }
-function sameDigest(value, expected) {
-  if (!isSha256Digest(value) || value.length !== expected.length) return false;
-  const actual = Buffer.from(value, "ascii");
-  const wanted = Buffer.from(expected, "ascii");
-  return timingSafeEqual(actual, wanted);
+function validMethod2(value) {
+  return typeof value === "string" && HTTP_METHODS.includes(value);
 }
-function cleanSessions(state, now) {
-  for (let index = state.sessions.length - 1; index >= 0; index -= 1) {
-    if (state.sessions[index]?.expiresAt <= now)
-      state.sessions.splice(index, 1);
+function normalizeMockHeader(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    return null;
+  if (!exactKeys(value, ["name", "value"])) return null;
+  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)
+    return null;
+  return { name: record.name, value: record.value };
+}
+function normalizeMockConfig(value, matcherById) {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    return null;
+  const record = value;
+  const allowedKeys = [
+    "ruleId",
+    "status",
+    "headers",
+    "delayMs",
+    "body",
+    "file"
+  ];
+  if (Object.keys(record).some((key) => !allowedKeys.includes(key)))
+    return null;
+  if (!validId2(record.ruleId) || !matcherById.has(record.ruleId)) return null;
+  if (typeof record.status !== "number" || !Number.isSafeInteger(record.status) || record.status < LIMITS.minMockStatus || record.status > LIMITS.maxMockStatus)
+    return null;
+  let headers;
+  if (hasOwn(record, "headers")) {
+    if (!Array.isArray(record.headers) || record.headers.length > LIMITS.maxMockHeadersPerRule)
+      return null;
+    const normalizedHeaders = [];
+    for (const headerValue2 of record.headers) {
+      const header = normalizeMockHeader(headerValue2);
+      if (header === null) return null;
+      normalizedHeaders.push(header);
+    }
+    headers = Object.freeze(normalizedHeaders);
+  }
+  let delayMs;
+  if (hasOwn(record, "delayMs")) {
+    if (typeof record.delayMs !== "number" || !Number.isSafeInteger(record.delayMs) || record.delayMs < 0 || record.delayMs > LIMITS.maxMockDelayMs)
+      return null;
+    delayMs = record.delayMs;
+  }
+  const body = record.body;
+  const file = record.file;
+  const bodySet = typeof body === "string";
+  const fileSet = typeof file === "string";
+  if (bodySet === fileSet) return null;
+  if (bodySet && body.length > LIMITS.maxMockInlineBodyLength) return null;
+  if (fileSet) {
+    if (file.length === 0 || file.length > LIMITS.maxMockFilePathLength || hasControl(file))
+      return null;
   }
+  return Object.freeze({
+    ruleId: record.ruleId,
+    status: record.status,
+    ...headers === void 0 ? {} : { headers },
+    ...delayMs === void 0 ? {} : { delayMs },
+    ...bodySet ? { body } : {},
+    ...fileSet ? { file } : {}
+  });
 }
-function pairCapability(state, capability, digest, now) {
-  cleanSessions(state, now);
-  if (state.closed || state.consumed || !isToken(capability) || typeof digest !== "string" || !sameDigest(digest, state.presetDigest) || now >= state.bootstrapExpiresAt || !sameToken(capability, state.bootstrapDigest)) {
-    return failure("runtime.pairing-denied");
+function validResourceType(value) {
+  return typeof value === "string" && RESOURCE_TYPES.includes(value);
+}
+function freezeMatcher(operation) {
+  const matcher = Object.freeze({
+    urlRegex: Object.freeze({
+      source: operation.matcher.urlRegex.source,
+      flags: ""
+    }),
+    origins: Object.freeze([...operation.matcher.origins]),
+    resourceTypes: Object.freeze([...operation.matcher.resourceTypes]),
+    priority: operation.matcher.priority,
+    ...operation.matcher.method === void 0 ? {} : { method: operation.matcher.method }
+  });
+  return Object.freeze({
+    kind: "matcher",
+    groupId: operation.groupId,
+    ruleId: operation.ruleId,
+    matcher
+  });
+}
+function normalizeMatcher(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    return null;
+  const requiredKeys = ["kind", "groupId", "ruleId", "matcher"];
+  if (!requiredKeys.every((key) => hasOwn(value, key)) || Object.keys(value).some(
+    (key) => key !== "kind" && key !== "groupId" && key !== "ruleId" && key !== "matcher" && key !== "action"
+  ))
+    return null;
+  const record = value;
+  if (record.kind !== "matcher" || !validId2(record.groupId) || !validId2(record.ruleId))
+    return null;
+  const matcherValue2 = record.matcher;
+  if (matcherValue2 === null || typeof matcherValue2 !== "object" || Array.isArray(matcherValue2) || !exactKeys(matcherValue2, [
+    "urlRegex",
+    "origins",
+    "resourceTypes",
+    "priority"
+  ]) && !exactKeys(matcherValue2, [
+    "urlRegex",
+    "origins",
+    "resourceTypes",
+    "priority",
+    "method"
+  ])) {
+    return null;
   }
-  if (state.sessions.length >= RUNTIME_LIMITS.maxConcurrentSessions) {
-    return failure("runtime.overloaded");
+  const matcher = matcherValue2;
+  const regexValue = matcher.urlRegex;
+  if (regexValue === null || typeof regexValue !== "object" || Array.isArray(regexValue) || !exactKeys(regexValue, ["source", "flags"])) {
+    return null;
+  }
+  const regex = regexValue;
+  if (typeof regex.source !== "string" || regex.source.length > LIMITS.maxUrlRegexLength || regex.flags !== "" || compileUrlRegex(regex.source) === null) {
+    return null;
+  }
+  if (!Array.isArray(matcher.origins) || matcher.origins.length === 0 || matcher.origins.length > LIMITS.maxOriginsPerScope)
+    return null;
+  const origins = [];
+  for (const value2 of matcher.origins) {
+    const normalized = normalizeSiteOrigin(value2);
+    if (normalized === null || origins.includes(normalized)) return null;
+    origins.push(normalized);
+  }
+  if (!Array.isArray(matcher.resourceTypes) || matcher.resourceTypes.length === 0 || matcher.resourceTypes.length > LIMITS.maxResourceTypesPerRule)
+    return null;
+  const resourceTypes = [];
+  for (const value2 of matcher.resourceTypes) {
+    if (!validResourceType(value2) || resourceTypes.includes(value2)) return null;
+    resourceTypes.push(value2);
+  }
+  resourceTypes.sort(
+    (left, right) => RESOURCE_TYPES.indexOf(left) - RESOURCE_TYPES.indexOf(right)
+  );
+  if (typeof matcher.priority !== "number" || !Number.isSafeInteger(matcher.priority) || matcher.priority < LIMITS.minPriority || matcher.priority > LIMITS.maxPriority)
+    return null;
+  let method;
+  if (hasOwn(matcher, "method")) {
+    if (!validMethod2(matcher.method)) return null;
+    method = matcher.method;
   }
-  state.consumed = true;
-  const sessionCapability = randomBytes(TOKEN_BYTES).toString("base64url");
-  const expiresAt = now + RUNTIME_LIMITS.sessionLifetimeMs;
-  state.sessions.push({
-    digest: Buffer.from(state.presetDigest, "ascii"),
-    expiresAt,
-    tokenDigest: digestToken(sessionCapability),
-    activeOperations: 0
-  });
-  return {
-    ok: true,
-    value: {
-      sessionCapability,
-      expiresInMs: RUNTIME_LIMITS.sessionLifetimeMs
+  return freezeMatcher({
+    kind: "matcher",
+    groupId: record.groupId,
+    ruleId: record.ruleId,
+    matcher: {
+      urlRegex: { source: regex.source, flags: "" },
+      origins,
+      resourceTypes,
+      priority: matcher.priority,
+      ...method === void 0 ? {} : { method }
     }
-  };
+  });
 }
-function findSession(state, capability, digest, now) {
-  cleanSessions(state, now);
-  if (state.closed || !isToken(capability) || typeof digest !== "string")
-    return null;
-  if (!sameDigest(digest, state.presetDigest)) return null;
-  const candidate = digestToken(capability);
-  for (const session of state.sessions) {
-    if (candidate.length === session.tokenDigest.length && timingSafeEqual(candidate, session.tokenDigest) && sameDigest(digest, session.digest.toString("ascii"))) {
-      return session;
-    }
+function sameLimits(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const keys = Object.keys(value);
+  const expected = Object.keys(RUNTIME_LIMITS);
+  if (keys.length !== expected.length || !expected.every((key) => hasOwn(value, key)))
+    return false;
+  for (const key of expected) {
+    if (value[key] !== RUNTIME_LIMITS[key])
+      return false;
   }
-  return null;
+  return true;
 }
-function acquireOperation(_state, session) {
-  if (session.activeOperations >= RUNTIME_LIMITS.maxOperationsPerSession) {
-    return failure("runtime.overloaded");
+function makeGrant(value, matcherById) {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    return null;
+  if (!exactKeys(value, [
+    "groupId",
+    "ruleId",
+    "operationId",
+    "kind",
+    "target",
+    "method"
+  ]))
+    return null;
+  const record = value;
+  if (!validId2(record.groupId) || !validId2(record.ruleId) || !validId2(record.operationId) || record.kind !== "outbound-http" && record.kind !== "confined-file" || !validMethod2(record.method) || typeof record.target !== "string")
+    return null;
+  const matcher = matcherById.get(record.ruleId);
+  if (matcher === void 0 || matcher.groupId !== record.groupId) return null;
+  if (matcher.matcher.method !== void 0 && matcher.matcher.method !== record.method)
+    return null;
+  let target;
+  if (record.kind === "outbound-http") {
+    if (record.method !== "GET" && record.method !== "HEAD") return null;
+    target = canonicalizeOutboundTarget(record.target);
+    if (target === null || !isOriginAllowed(target, matcher.matcher.origins))
+      return null;
+  } else {
+    target = normalizeLogicalPath(record.target);
   }
-  session.activeOperations += 1;
-  return {
-    ok: true,
-    value: () => {
-      session.activeOperations = Math.max(0, session.activeOperations - 1);
-    }
-  };
-}
-function closeCapabilityState(state) {
-  state.closed = true;
-  state.consumed = true;
-  state.sessions.length = 0;
-  state.bootstrapDigest.fill(0);
+  if (target === null) return null;
+  return Object.freeze({
+    groupId: record.groupId,
+    ruleId: record.ruleId,
+    operationId: record.operationId,
+    kind: record.kind,
+    target,
+    method: record.method
+  });
 }
-var registeredProvider = null;
-var currentSession = null;
-async function startInterception(activation, policyDigest, extensionId, pacOrigins, targetPolicy) {
-  if (registeredProvider === null) {
-    return { kind: "unsupported", reasons: ["no-interception-provider"] };
+function normalizeRuntimePreset(value) {
+  const snapshot = snapshotOwnData3(value);
+  if (!snapshot.valid || snapshot.value === null || typeof snapshot.value !== "object" || Array.isArray(snapshot.value)) {
+    console.error("[rogatio-host] preset: snapshot invalid");
+    return failure("runtime.invalid-preset");
   }
-  const capabilities = registeredProvider.detect();
-  if (!capabilities.supported) {
-    return { kind: "unsupported", reasons: capabilities.reasons };
+  const record = snapshot.value;
+  const allowedKeys = ["version", "limits", "matchers", "grants", "mocks"];
+  const requiredKeys = ["version", "limits", "matchers", "grants"];
+  const keyCount = Object.keys(record).length;
+  if (Object.keys(record).some((key) => !allowedKeys.includes(key)) || !requiredKeys.every((key) => hasOwn(record, key)) || keyCount !== 4 && keyCount !== 5) {
+    console.error(
+      "[rogatio-host] preset: key check failed, keys=",
+      Object.keys(record)
+    );
+    return failure("runtime.invalid-preset");
   }
-  if (currentSession !== null) {
-    return { kind: "unsupported", reasons: ["session-collision"] };
+  if (record.version !== 1 || !sameLimits(record.limits)) {
+    console.error(
+      "[rogatio-host] preset: version/limits mismatch, version=",
+      record.version,
+      "limitsOk=",
+      sameLimits(record.limits)
+    );
+    return failure("runtime.invalid-preset");
   }
-  const sessionId = `session-${activation.startedAt}-${Math.random().toString(36).slice(2)}`;
-  try {
-    await registeredProvider.start(activation);
-  } catch (error) {
-    return {
-      kind: "unsupported",
-      reasons: ["provider-start-failed", String(error)]
-    };
+  if (!Array.isArray(record.matchers) || !Array.isArray(record.grants)) {
+    console.error("[rogatio-host] preset: matchers/grants not arrays");
+    return failure("runtime.invalid-preset");
   }
-  currentSession = {
-    sessionId,
-    provider: registeredProvider,
-    activation,
-    policyDigest,
-    extensionId,
-    pacOrigins,
-    targetPolicy,
-    startedAt: activation.startedAt
-  };
-  return { kind: "active", provider: registeredProvider.platform };
-}
-async function stopInterception() {
-  if (currentSession === null && registeredProvider === null) return;
-  const session = currentSession;
-  currentSession = null;
-  if (session?.provider) {
-    try {
-      await session.provider.stop();
-    } catch {
+  const matchers = [];
+  const matcherById = /* @__PURE__ */ new Map();
+  for (const value2 of record.matchers) {
+    const matcher = normalizeMatcher(value2);
+    if (matcher === null || matcherById.has(matcher.ruleId)) {
+      console.error(
+        "[rogatio-host] preset: matcher normalize failed, ruleId=",
+        value2?.ruleId
+      );
+      return failure("runtime.invalid-preset");
     }
+    matcherById.set(matcher.ruleId, matcher);
+    matchers.push(matcher);
   }
-}
-function hasActiveSession() {
-  return currentSession !== null;
-}
-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");
-  }
-}
-function mintToken() {
-  return randomBytes2(32).toString("hex");
-}
-async function renderMockResponse(options) {
-  const { mock, fileRoot } = options;
-  let bodyBytes;
-  if (mock.body !== void 0) {
-    bodyBytes = 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;
-  } else {
-    return failure("runtime.file-denied");
-  }
-  const headers = [];
-  let hasContentType = false;
-  for (const header of mock.headers ?? []) {
-    headers.push([header.name, header.value]);
-    if (header.name.toLowerCase() === "content-type") hasContentType = true;
+  const grants = [];
+  const operationIds = /* @__PURE__ */ new Set();
+  for (const value2 of record.grants) {
+    const grant = makeGrant(value2, matcherById);
+    if (grant === null || operationIds.has(grant.operationId))
+      return failure("runtime.invalid-preset");
+    operationIds.add(grant.operationId);
+    grants.push(grant);
   }
-  if (!hasContentType) {
-    headers.push(["Content-Type", "text/plain; charset=UTF-8"]);
+  const mocks = [];
+  if (hasOwn(record, "mocks")) {
+    if (!Array.isArray(record.mocks)) return failure("runtime.invalid-preset");
+    const seenRuleIds = /* @__PURE__ */ new Set();
+    for (const value2 of record.mocks) {
+      const mock = normalizeMockConfig(value2, matcherById);
+      if (mock === null || seenRuleIds.has(mock.ruleId))
+        return failure("runtime.invalid-preset");
+      seenRuleIds.add(mock.ruleId);
+      mocks.push(mock);
+    }
   }
-  headers.push(["Content-Length", String(bodyBytes.byteLength)]);
-  headers.push(["Cache-Control", "no-store"]);
-  return {
-    ok: true,
-    value: {
-      status: mock.status,
-      headers,
-      bodyBytes
+  const normalizedPreset = Object.freeze({
+    version: 1,
+    limits: RUNTIME_LIMITS,
+    matchers: Object.freeze(matchers),
+    grants: Object.freeze(grants),
+    ...mocks.length > 0 ? { mocks: Object.freeze(mocks) } : {}
+  });
+  const bytes = canonicalPresetBytes(normalizedPreset);
+  if (bytes.byteLength > RUNTIME_LIMITS.maxPresetBytes)
+    return failure("runtime.invalid-preset");
+  const digest = digestBytes(bytes);
+  const exposedBytes = bytes.slice();
+  const normalized = Object.freeze({
+    ...normalizedPreset,
+    digest,
+    get canonicalBytes() {
+      return exposedBytes.slice();
     }
-  };
+  });
+  return { ok: true, value: normalized };
 }
 function base64(bytes) {
   return Buffer.from(bytes).toString("base64");
@@ -20695,7 +21430,7 @@ async function delay(ms) {
   await new Promise((resolve22) => setTimeout(resolve22, ms));
 }
 function createNativeRuntimeController(options) {
-  const preset = options.preset;
+  let preset = options.preset;
   const fileRoot = options.fileRoot;
   const mockPort = options.mockPort;
   const clock = options.clock ?? (() => Date.now());
@@ -20713,6 +21448,9 @@ function createNativeRuntimeController(options) {
         if (activation) return { state: "running", activation };
         return { state };
       }
+      if (!preset) {
+        return { state: "idle" };
+      }
       const startedAt = clock();
       capability = createCapabilityState(preset, startedAt);
       mockTokens.clear();
@@ -20770,6 +21508,7 @@ function createNativeRuntimeController(options) {
     async serveMock(token) {
       const mock = mockTokens.get(token);
       if (mock === void 0) return failure("runtime.mock-unknown");
+      if (!preset) throw new Error("runtime not started");
       return renderMockResponse({
         mock,
         fileRoot,
@@ -20783,12 +21522,121 @@ function createNativeRuntimeController(options) {
       return capability.bootstrap;
     },
     async handleEnvelope(input) {
-      if (state !== "running" || capability === void 0) {
-        throw new Error("runtime not started");
-      }
       const now = clock();
       const requestId = input.requestId;
       const timestamp = now;
+      if (input.type === "runtime.project.set" && state === "idle") {
+        const projectData = input.metadata.project;
+        if (!projectData || typeof projectData !== "object") {
+          return {
+            protocol: "v1",
+            type: "runtime.project.set",
+            ...requestId !== void 0 ? { requestId } : {},
+            timestamp,
+            metadata: { ok: false, error: "runtime.project-missing" }
+          };
+        }
+        const schemaResult = validateProjectDetailed(projectData);
+        if (!schemaResult.valid) {
+          return {
+            protocol: "v1",
+            type: "runtime.project.set",
+            ...requestId !== void 0 ? { requestId } : {},
+            timestamp,
+            metadata: { ok: false, error: "runtime.project-invalid" }
+          };
+        }
+        const compileResult = compileProject(schemaResult.data);
+        if (!compileResult.ok) {
+          return {
+            protocol: "v1",
+            type: "runtime.project.set",
+            ...requestId !== void 0 ? { requestId } : {},
+            timestamp,
+            metadata: {
+              ok: false,
+              error: "runtime.compile-failed",
+              diagnostics: compileResult.diagnostics
+            }
+          };
+        }
+        const matcherOps = [];
+        const mockConfigs = [];
+        for (const op of compileResult.operations) {
+          if (op.kind === "mock") {
+            const mock = op.mock;
+            let file;
+            if (mock.file !== void 0) {
+              file = mock.file;
+            }
+            mockConfigs.push({
+              ruleId: op.ruleId,
+              status: mock.status,
+              ...mock.headers !== void 0 ? { headers: mock.headers } : {},
+              ...mock.delayMs !== void 0 ? { delayMs: mock.delayMs } : {},
+              ...mock.body !== void 0 ? { body: mock.body } : {},
+              ...file !== void 0 ? { file } : {}
+            });
+          }
+          if ("matcher" in op) {
+            matcherOps.push({
+              kind: "matcher",
+              groupId: op.groupId,
+              ruleId: op.ruleId,
+              matcher: op.matcher
+            });
+          }
+        }
+        const presetInput = {
+          version: 1,
+          limits: RUNTIME_LIMITS,
+          matchers: matcherOps,
+          grants: [],
+          ...mockConfigs.length > 0 ? { mocks: mockConfigs } : {}
+        };
+        console.error(
+          "[rogatio-host] normalizeRuntimePreset input: matchers=",
+          matcherOps.length,
+          "mocks=",
+          mockConfigs.length,
+          "grants=0"
+        );
+        const normalized = normalizeRuntimePreset(presetInput);
+        console.error(
+          "[rogatio-host] normalizeRuntimePreset result: ok=",
+          normalized.ok
+        );
+        if (!normalized.ok) {
+          return {
+            protocol: "v1",
+            type: "runtime.project.set",
+            ...requestId !== void 0 ? { requestId } : {},
+            timestamp,
+            metadata: { ok: false, error: "runtime.preset-invalid" }
+          };
+        }
+        preset = normalized.value;
+        const startResult = await this.start();
+        if (startResult.state !== "running") {
+          return {
+            protocol: "v1",
+            type: "runtime.project.set",
+            ...requestId !== void 0 ? { requestId } : {},
+            timestamp,
+            metadata: { ok: false, error: "runtime.start-failed" }
+          };
+        }
+        return {
+          protocol: "v1",
+          type: "runtime.project.set",
+          ...requestId !== void 0 ? { requestId } : {},
+          timestamp,
+          metadata: { ok: true, presetDigest: preset.digest }
+        };
+      }
+      if (state !== "running" || capability === void 0) {
+        throw new Error("runtime not started");
+      }
       switch (input.type) {
         case "pair.request": {
           const meta = input.metadata;
@@ -20844,6 +21692,7 @@ function createNativeRuntimeController(options) {
               metadata: { authorized: false, error: op.error.code }
             };
           }
+          if (!preset) throw new Error("runtime not started");
           const result = authorizeExact(preset, meta.descriptor);
           op.value();
           if (!result.ok) {
@@ -20873,6 +21722,7 @@ function createNativeRuntimeController(options) {
           };
         }
         case "mock.connect": {
+          if (!preset) throw new Error("runtime not started");
           const mocks = [...mockTokens.entries()].map(([token, mock]) => ({
             ruleId: mock.ruleId,
             token
@@ -20915,6 +21765,7 @@ function createNativeRuntimeController(options) {
           return renderMock(mock, requestId, timestamp);
         }
         case "runtime.status": {
+          if (!preset) throw new Error("runtime not started");
           return {
             protocol: "v1",
             type: "runtime.status",
@@ -20988,602 +21839,268 @@ function createNativeRuntimeController(options) {
             for await (const chunk of aiClient.stream({
               messages: [...meta.messages],
               model: meta.model,
-              temperature: meta.temperature
-            })) {
-              return {
-                protocol: "v1",
-                type: "ai.stream.chunk",
-                ...requestId !== void 0 ? { requestId } : {},
-                timestamp,
-                metadata: {
-                  delta: chunk.delta,
-                  done: chunk.done,
-                  usage: chunk.usage
-                }
-              };
-            }
-            return {
-              protocol: "v1",
-              type: "ai.stream.chunk",
-              ...requestId !== void 0 ? { requestId } : {},
-              timestamp,
-              metadata: {
-                delta: "",
-                done: true,
-                usage: void 0
-              }
-            };
-          } catch (e) {
-            return {
-              protocol: "v1",
-              type: "ai.error",
-              ...requestId !== void 0 ? { requestId } : {},
-              timestamp,
-              metadata: {
-                code: "ai.error",
-                message: e instanceof Error ? e.message : "AI streaming failed",
-                retryable: true
-              }
-            };
-          }
-        }
-        default: {
-          return {
-            protocol: "v1",
-            type: input.type,
-            ...requestId !== void 0 ? { requestId } : {},
-            timestamp,
-            metadata: { error: "runtime.request-malformed" }
-          };
-        }
-      }
-    }
-  };
-  async function renderMock(mock, requestId, timestamp) {
-    if (mock.delayMs !== void 0) await delay(mock.delayMs);
-    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
-      };
-    }
-    const headers = [];
-    for (const header of rendered.value.headers) {
-      headers.push([header[0], header[1]]);
-    }
-    const metadata = {
-      status: rendered.value.status,
-      headers,
-      mockBody: base64(rendered.value.bodyBytes)
-    };
-    return {
-      protocol: "v1",
-      type: "mock.response",
-      ...requestId !== void 0 ? { requestId } : {},
-      timestamp,
-      metadata
-    };
-  }
-}
-function getCurrentSession2() {
-  return null;
-}
-function encodeEnvelopeFrame(envelope) {
-  const json = new TextEncoder().encode(serializeEnvelope(envelope));
-  const out = new Uint8Array(4 + json.byteLength);
-  new DataView(out.buffer).setUint32(0, json.byteLength, true);
-  out.set(json, 4);
-  return out;
-}
-function decodeEnvelopeFrame(buffer) {
-  if (buffer.byteLength < 4) throw new Error("frame too small");
-  const length = new DataView(buffer.buffer, buffer.byteOffset, 4).getUint32(
-    0,
-    true
-  );
-  if (buffer.byteLength !== 4 + length)
-    throw new Error("frame length mismatch");
-  const json = new TextDecoder("utf-8", { fatal: true }).decode(
-    buffer.slice(4)
-  );
-  return parseEnvelope(json);
-}
-function startMockFaucet(port, controller) {
-  const server = createServer((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 createNativeHost(options) {
-  const controller = createNativeRuntimeController({
-    preset: options.preset,
-    fileRoot: options.fileRoot,
-    ...options.mockPort !== void 0 ? { mockPort: options.mockPort } : {},
-    ...options.clock ? { clock: options.clock } : {}
-  });
-  let faucet = null;
-  return {
-    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;
-      }
-      await controller.stop();
-    },
-    async processFrame(frame) {
-      let envelope;
-      try {
-        envelope = decodeEnvelopeFrame(frame);
-      } catch {
-        return null;
-      }
-      let response;
-      try {
-        response = await controller.handleEnvelope(envelope);
-      } catch {
-        return null;
-      }
-      try {
-        return encodeEnvelopeFrame(response);
-      } catch {
-        return null;
+              temperature: meta.temperature
+            })) {
+              return {
+                protocol: "v1",
+                type: "ai.stream.chunk",
+                ...requestId !== void 0 ? { requestId } : {},
+                timestamp,
+                metadata: {
+                  delta: chunk.delta,
+                  done: chunk.done,
+                  usage: chunk.usage
+                }
+              };
+            }
+            return {
+              protocol: "v1",
+              type: "ai.stream.chunk",
+              ...requestId !== void 0 ? { requestId } : {},
+              timestamp,
+              metadata: {
+                delta: "",
+                done: true,
+                usage: void 0
+              }
+            };
+          } catch (e) {
+            return {
+              protocol: "v1",
+              type: "ai.error",
+              ...requestId !== void 0 ? { requestId } : {},
+              timestamp,
+              metadata: {
+                code: "ai.error",
+                message: e instanceof Error ? e.message : "AI streaming failed",
+                retryable: true
+              }
+            };
+          }
+        }
+        default: {
+          return {
+            protocol: "v1",
+            type: input.type,
+            ...requestId !== void 0 ? { requestId } : {},
+            timestamp,
+            metadata: { error: "runtime.request-malformed" }
+          };
+        }
       }
     }
   };
-}
-async function runNativeHost(options) {
-  const host = createNativeHost(options);
-  await host.start();
-  const stdin = options.stdin ?? process.stdin;
-  const stdout = options.stdout ?? process.stdout;
-  if (options.onReady) options.onReady();
-  let buffer = Buffer2.alloc(0);
-  stdin.on("data", (chunk) => {
-    buffer = Buffer2.concat([
-      buffer,
-      Buffer2.isBuffer(chunk) ? chunk : Buffer2.from(chunk)
-    ]);
-    void (async () => {
-      for (; ; ) {
-        if (buffer.length < 4) break;
-        const length = buffer.readUInt32LE(0);
-        if (buffer.length < 4 + length) break;
-        const frame = new Uint8Array(
-          buffer.buffer,
-          buffer.byteOffset + 4,
-          length
-        );
-        const response = await host.processFrame(frame);
-        buffer = buffer.subarray(4 + length);
-        if (response && stdout.writable) {
-          stdout.write(Buffer2.from(response));
-        }
-      }
-    })();
-  });
-  await new Promise((resolve22) => {
-    stdin.on("end", () => {
-      void host.stop().then(resolve22);
+  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
     });
-  });
-}
-var NATIVE_FRAME_MAX_BYTES = 64 * 1024;
-var NATIVE_POLICY_MAX_BYTES = 256 * 1024;
-function stringValue(value) {
-  const encoded = JSON.stringify(value);
-  if (encoded === void 0) throw new Error("invalid string");
-  return encoded;
-}
-function arrayValue(values) {
-  return `[${values.map(stringValue).join(",")}]`;
-}
-function matcherValue(operation) {
-  const matcher = operation.matcher;
-  const method = matcher.method === void 0 ? "" : `,"method":${stringValue(matcher.method)}`;
-  return `{"kind":"matcher","groupId":${stringValue(operation.groupId)},"ruleId":${stringValue(operation.ruleId)},"matcher":{"urlRegex":{"source":${stringValue(matcher.urlRegex.source)},"flags":""},"origins":${arrayValue(matcher.origins)},"resourceTypes":${arrayValue(matcher.resourceTypes)},"priority":${String(matcher.priority)}${method}}}`;
-}
-function limitsValue(limits) {
-  const fields = [
-    ["maxPresetBytes", limits.maxPresetBytes],
-    ["maxRequestLineBytes", limits.maxRequestLineBytes],
-    ["maxHeaderCount", limits.maxHeaderCount],
-    ["maxRequestHeaderBytes", limits.maxRequestHeaderBytes],
-    ["maxControlBodyBytes", limits.maxControlBodyBytes],
-    ["maxResponseHeaderBytes", limits.maxResponseHeaderBytes],
-    ["maxResponseBodyBytes", limits.maxResponseBodyBytes],
-    ["maxFileBytes", limits.maxFileBytes],
-    ["maxConcurrentSessions", limits.maxConcurrentSessions],
-    ["maxConcurrentOperations", limits.maxConcurrentOperations],
-    ["maxOperationsPerSession", limits.maxOperationsPerSession],
-    ["maxDnsAddresses", limits.maxDnsAddresses],
-    ["bootstrapLifetimeMs", limits.bootstrapLifetimeMs],
-    ["sessionLifetimeMs", limits.sessionLifetimeMs],
-    ["connectTimeoutMs", limits.connectTimeoutMs],
-    ["responseHeaderTimeoutMs", limits.responseHeaderTimeoutMs],
-    ["bodyIdleTimeoutMs", limits.bodyIdleTimeoutMs],
-    ["operationTimeoutMs", limits.operationTimeoutMs],
-    ["maxRedirects", limits.maxRedirects]
-  ];
-  return `{${fields.map(([key, value]) => `${stringValue(key)}:${String(value)}`).join(",")}}`;
-}
-function grantValue(grant) {
-  return `{"groupId":${stringValue(grant.groupId)},"ruleId":${stringValue(grant.ruleId)},"operationId":${stringValue(grant.operationId)},"kind":${stringValue(grant.kind)},"target":${stringValue(grant.target)},"method":${stringValue(grant.method)}}`;
-}
-function mockHeaderValue(header) {
-  return `{"name":${stringValue(header.name)},"value":${stringValue(header.value)}}`;
-}
-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 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}}`;
-}
-function sortMocks(mocks) {
-  return [...mocks].sort(
-    (left, right) => compareStrings(left.ruleId, right.ruleId)
-  );
-}
-function compareStrings(left, right) {
-  if (left < right) return -1;
-  if (left > right) return 1;
-  return 0;
-}
-function sortGrants(grants) {
-  return [...grants].sort(
-    (left, right) => compareStrings(left.groupId, right.groupId) || compareStrings(left.ruleId, right.ruleId) || compareStrings(left.operationId, right.operationId) || compareStrings(left.kind, right.kind) || compareStrings(left.target, right.target) || compareStrings(left.method, right.method)
-  );
-}
-function canonicalPresetBytes(preset, grants = preset.grants) {
-  const matchers = preset.matchers.map(matcherValue).join(",");
-  const mocks = preset.mocks === void 0 || preset.mocks.length === 0 ? "" : `,"mocks":[${sortMocks(preset.mocks).map(mockValue).join(",")}]`;
-  const canonical = `{"version":1,"limits":${limitsValue(preset.limits)},"matchers":[${matchers}],"grants":[${sortGrants(grants).map(grantValue).join(",")}]${mocks}}`;
-  return new TextEncoder().encode(canonical);
-}
-function digestBytes(bytes) {
-  return formatSha256(createHash3("sha256").update(bytes).digest("hex"));
-}
-var ID_PATTERN2 = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
-function exactKeys(value, required) {
-  const keys = Object.keys(value);
-  return keys.length === required.length && required.every((key) => hasOwn(value, key));
-}
-function validId2(value) {
-  return typeof value === "string" && ID_PATTERN2.test(value);
-}
-function validMethod2(value) {
-  return typeof value === "string" && HTTP_METHODS.includes(value);
-}
-function normalizeMockHeader(value) {
-  if (value === null || typeof value !== "object" || Array.isArray(value))
-    return null;
-  if (!exactKeys(value, ["name", "value"])) return null;
-  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)
-    return null;
-  return { name: record.name, value: record.value };
-}
-function normalizeMockConfig(value, matcherById) {
-  if (value === null || typeof value !== "object" || Array.isArray(value))
-    return null;
-  const record = value;
-  const allowedKeys = [
-    "ruleId",
-    "status",
-    "headers",
-    "delayMs",
-    "body",
-    "file"
-  ];
-  if (Object.keys(record).some((key) => !allowedKeys.includes(key)))
-    return null;
-  if (!validId2(record.ruleId) || !matcherById.has(record.ruleId)) return null;
-  if (typeof record.status !== "number" || !Number.isSafeInteger(record.status) || record.status < LIMITS.minMockStatus || record.status > LIMITS.maxMockStatus)
-    return null;
-  let headers;
-  if (hasOwn(record, "headers")) {
-    if (!Array.isArray(record.headers) || record.headers.length > LIMITS.maxMockHeadersPerRule)
-      return null;
-    const normalizedHeaders = [];
-    for (const headerValue2 of record.headers) {
-      const header = normalizeMockHeader(headerValue2);
-      if (header === null) return null;
-      normalizedHeaders.push(header);
+    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
+      };
     }
-    headers = Object.freeze(normalizedHeaders);
-  }
-  let delayMs;
-  if (hasOwn(record, "delayMs")) {
-    if (typeof record.delayMs !== "number" || !Number.isSafeInteger(record.delayMs) || record.delayMs < 0 || record.delayMs > LIMITS.maxMockDelayMs)
-      return null;
-    delayMs = record.delayMs;
-  }
-  const body = record.body;
-  const file = record.file;
-  const bodySet = typeof body === "string";
-  const fileSet = typeof file === "string";
-  if (bodySet === fileSet) return null;
-  if (bodySet && body.length > LIMITS.maxMockInlineBodyLength) return null;
-  if (fileSet) {
-    if (file.length === 0 || file.length > LIMITS.maxMockFilePathLength || hasControl(file))
-      return null;
+    const headers = [];
+    for (const header of rendered.value.headers) {
+      headers.push([header[0], header[1]]);
+    }
+    const metadata = {
+      status: rendered.value.status,
+      headers,
+      mockBody: base64(rendered.value.bodyBytes)
+    };
+    return {
+      protocol: "v1",
+      type: "mock.response",
+      ...requestId !== void 0 ? { requestId } : {},
+      timestamp,
+      metadata
+    };
   }
-  return Object.freeze({
-    ruleId: record.ruleId,
-    status: record.status,
-    ...headers === void 0 ? {} : { headers },
-    ...delayMs === void 0 ? {} : { delayMs },
-    ...bodySet ? { body } : {},
-    ...fileSet ? { file } : {}
-  });
 }
-function validResourceType(value) {
-  return typeof value === "string" && RESOURCE_TYPES.includes(value);
+function getCurrentSession2() {
+  return null;
 }
-function freezeMatcher(operation) {
-  const matcher = Object.freeze({
-    urlRegex: Object.freeze({
-      source: operation.matcher.urlRegex.source,
-      flags: ""
-    }),
-    origins: Object.freeze([...operation.matcher.origins]),
-    resourceTypes: Object.freeze([...operation.matcher.resourceTypes]),
-    priority: operation.matcher.priority,
-    ...operation.matcher.method === void 0 ? {} : { method: operation.matcher.method }
-  });
-  return Object.freeze({
-    kind: "matcher",
-    groupId: operation.groupId,
-    ruleId: operation.ruleId,
-    matcher
-  });
+function encodeEnvelopeFrame(envelope) {
+  const json = new TextEncoder().encode(serializeEnvelope(envelope));
+  const out = new Uint8Array(4 + json.byteLength);
+  new DataView(out.buffer).setUint32(0, json.byteLength, true);
+  out.set(json, 4);
+  return out;
 }
-function normalizeMatcher(value) {
-  if (value === null || typeof value !== "object" || Array.isArray(value))
-    return null;
-  const requiredKeys = ["kind", "groupId", "ruleId", "matcher"];
-  if (!requiredKeys.every((key) => hasOwn(value, key)) || Object.keys(value).some(
-    (key) => key !== "kind" && key !== "groupId" && key !== "ruleId" && key !== "matcher" && key !== "action"
-  ))
-    return null;
-  const record = value;
-  if (record.kind !== "matcher" || !validId2(record.groupId) || !validId2(record.ruleId))
-    return null;
-  const matcherValue2 = record.matcher;
-  if (matcherValue2 === null || typeof matcherValue2 !== "object" || Array.isArray(matcherValue2) || !exactKeys(matcherValue2, [
-    "urlRegex",
-    "origins",
-    "resourceTypes",
-    "priority"
-  ]) && !exactKeys(matcherValue2, [
-    "urlRegex",
-    "origins",
-    "resourceTypes",
-    "priority",
-    "method"
-  ])) {
-    return null;
-  }
-  const matcher = matcherValue2;
-  const regexValue = matcher.urlRegex;
-  if (regexValue === null || typeof regexValue !== "object" || Array.isArray(regexValue) || !exactKeys(regexValue, ["source", "flags"])) {
-    return null;
-  }
-  const regex = regexValue;
-  if (typeof regex.source !== "string" || regex.source.length > LIMITS.maxUrlRegexLength || regex.flags !== "" || compileUrlRegex(regex.source) === null) {
-    return null;
-  }
-  if (!Array.isArray(matcher.origins) || matcher.origins.length === 0 || matcher.origins.length > LIMITS.maxOriginsPerScope)
-    return null;
-  const origins = [];
-  for (const value2 of matcher.origins) {
-    const normalized = normalizeSiteOrigin(value2);
-    if (normalized === null || origins.includes(normalized)) return null;
-    origins.push(normalized);
-  }
-  if (!Array.isArray(matcher.resourceTypes) || matcher.resourceTypes.length === 0 || matcher.resourceTypes.length > LIMITS.maxResourceTypesPerRule)
-    return null;
-  const resourceTypes = [];
-  for (const value2 of matcher.resourceTypes) {
-    if (!validResourceType(value2) || resourceTypes.includes(value2)) return null;
-    resourceTypes.push(value2);
-  }
-  resourceTypes.sort(
-    (left, right) => RESOURCE_TYPES.indexOf(left) - RESOURCE_TYPES.indexOf(right)
+function decodeEnvelopeFrame(buffer) {
+  if (buffer.byteLength < 4) throw new Error("frame too small");
+  const length = new DataView(buffer.buffer, buffer.byteOffset, 4).getUint32(
+    0,
+    true
   );
-  if (typeof matcher.priority !== "number" || !Number.isSafeInteger(matcher.priority) || matcher.priority < LIMITS.minPriority || matcher.priority > LIMITS.maxPriority)
-    return null;
-  let method;
-  if (hasOwn(matcher, "method")) {
-    if (!validMethod2(matcher.method)) return null;
-    method = matcher.method;
-  }
-  return freezeMatcher({
-    kind: "matcher",
-    groupId: record.groupId,
-    ruleId: record.ruleId,
-    matcher: {
-      urlRegex: { source: regex.source, flags: "" },
-      origins,
-      resourceTypes,
-      priority: matcher.priority,
-      ...method === void 0 ? {} : { method }
-    }
-  });
-}
-function sameLimits(value) {
-  if (value === null || typeof value !== "object" || Array.isArray(value))
-    return false;
-  const keys = Object.keys(value);
-  const expected = Object.keys(RUNTIME_LIMITS);
-  if (keys.length !== expected.length || !expected.every((key) => hasOwn(value, key)))
-    return false;
-  for (const key of expected) {
-    if (value[key] !== RUNTIME_LIMITS[key])
-      return false;
-  }
-  return true;
+  if (buffer.byteLength !== 4 + length)
+    throw new Error("frame length mismatch");
+  const json = new TextDecoder("utf-8", { fatal: true }).decode(
+    buffer.slice(4)
+  );
+  return parseEnvelope(json);
 }
-function makeGrant(value, matcherById) {
-  if (value === null || typeof value !== "object" || Array.isArray(value))
-    return null;
-  if (!exactKeys(value, [
-    "groupId",
-    "ruleId",
-    "operationId",
-    "kind",
-    "target",
-    "method"
-  ]))
-    return null;
-  const record = value;
-  if (!validId2(record.groupId) || !validId2(record.ruleId) || !validId2(record.operationId) || record.kind !== "outbound-http" && record.kind !== "confined-file" || !validMethod2(record.method) || typeof record.target !== "string")
-    return null;
-  const matcher = matcherById.get(record.ruleId);
-  if (matcher === void 0 || matcher.groupId !== record.groupId) return null;
-  if (matcher.matcher.method !== void 0 && matcher.matcher.method !== record.method)
-    return null;
-  let target;
-  if (record.kind === "outbound-http") {
-    if (record.method !== "GET" && record.method !== "HEAD") return null;
-    target = canonicalizeOutboundTarget(record.target);
-    if (target === null || !isOriginAllowed(target, matcher.matcher.origins))
-      return null;
-  } else {
-    target = normalizeLogicalPath(record.target);
-  }
-  if (target === null) return null;
-  return Object.freeze({
-    groupId: record.groupId,
-    ruleId: record.ruleId,
-    operationId: record.operationId,
-    kind: record.kind,
-    target,
-    method: record.method
+function startMockFaucet(port, controller) {
+  const server = createServer((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 normalizeRuntimePreset(value) {
-  const snapshot = snapshotOwnData2(value);
-  if (!snapshot.valid || snapshot.value === null || typeof snapshot.value !== "object" || Array.isArray(snapshot.value)) {
-    return failure("runtime.invalid-preset");
-  }
-  const record = snapshot.value;
-  const allowedKeys = ["version", "limits", "matchers", "grants", "mocks"];
-  const requiredKeys = ["version", "limits", "matchers", "grants"];
-  const keyCount = Object.keys(record).length;
-  if (Object.keys(record).some((key) => !allowedKeys.includes(key)) || !requiredKeys.every((key) => hasOwn(record, key)) || keyCount !== 4 && keyCount !== 5)
-    return failure("runtime.invalid-preset");
-  if (record.version !== 1 || !sameLimits(record.limits))
-    return failure("runtime.invalid-preset");
-  if (!Array.isArray(record.matchers) || !Array.isArray(record.grants))
-    return failure("runtime.invalid-preset");
-  const matchers = [];
-  const matcherById = /* @__PURE__ */ new Map();
-  for (const value2 of record.matchers) {
-    const matcher = normalizeMatcher(value2);
-    if (matcher === null || matcherById.has(matcher.ruleId))
-      return failure("runtime.invalid-preset");
-    matcherById.set(matcher.ruleId, matcher);
-    matchers.push(matcher);
-  }
-  const grants = [];
-  const operationIds = /* @__PURE__ */ new Set();
-  for (const value2 of record.grants) {
-    const grant = makeGrant(value2, matcherById);
-    if (grant === null || operationIds.has(grant.operationId))
-      return failure("runtime.invalid-preset");
-    operationIds.add(grant.operationId);
-    grants.push(grant);
-  }
-  const mocks = [];
-  if (hasOwn(record, "mocks")) {
-    if (!Array.isArray(record.mocks)) return failure("runtime.invalid-preset");
-    const seenRuleIds = /* @__PURE__ */ new Set();
-    for (const value2 of record.mocks) {
-      const mock = normalizeMockConfig(value2, matcherById);
-      if (mock === null || seenRuleIds.has(mock.ruleId))
-        return failure("runtime.invalid-preset");
-      seenRuleIds.add(mock.ruleId);
-      mocks.push(mock);
+function createNativeHost(options) {
+  const controller = createNativeRuntimeController({
+    preset: options.preset,
+    fileRoot: options.fileRoot,
+    ...options.mockPort !== void 0 ? { mockPort: options.mockPort } : {},
+    ...options.clock ? { clock: options.clock } : {}
+  });
+  let faucet = null;
+  return {
+    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;
+      }
+      await controller.stop();
+    },
+    async processFrame(frame) {
+      let envelope;
+      try {
+        envelope = decodeEnvelopeFrame(frame);
+      } catch (error) {
+        console.error(
+          "[rogatio-host] decodeEnvelopeFrame failed:",
+          error instanceof Error ? error.message : String(error)
+        );
+        return null;
+      }
+      console.error(
+        "[rogatio-host] received envelope:",
+        envelope.type,
+        "requestId:",
+        envelope.requestId
+      );
+      let response;
+      try {
+        response = await controller.handleEnvelope(envelope);
+      } catch (error) {
+        console.error(
+          "[rogatio-host] handleEnvelope failed:",
+          error instanceof Error ? error.message : String(error)
+        );
+        return null;
+      }
+      try {
+        return encodeEnvelopeFrame(response);
+      } catch {
+        return null;
+      }
     }
-  }
-  const normalizedPreset = Object.freeze({
-    version: 1,
-    limits: RUNTIME_LIMITS,
-    matchers: Object.freeze(matchers),
-    grants: Object.freeze(grants),
-    ...mocks.length > 0 ? { mocks: Object.freeze(mocks) } : {}
+  };
+}
+async function runNativeHost(options) {
+  const host = createNativeHost(options);
+  await host.start();
+  const stdin = options.stdin ?? process.stdin;
+  const stdout = options.stdout ?? process.stdout;
+  if (options.onReady) options.onReady();
+  let buffer = Buffer2.alloc(0);
+  stdin.on("data", (chunk) => {
+    const buf = Buffer2.isBuffer(chunk) ? chunk : Buffer2.from(chunk);
+    console.error(
+      "[rogatio-host] stdin data:",
+      buf.length,
+      "bytes, buffer:",
+      buffer.length
+    );
+    buffer = Buffer2.concat([buffer, buf]);
+    void (async () => {
+      for (; ; ) {
+        if (buffer.length < 4) break;
+        const length = buffer.readUInt32LE(0);
+        if (buffer.length < 4 + length) break;
+        const frame = new Uint8Array(
+          buffer.buffer,
+          buffer.byteOffset,
+          4 + length
+        );
+        console.error("[rogatio-host] processing frame:", 4 + length, "bytes");
+        const response = await host.processFrame(frame);
+        buffer = buffer.subarray(4 + length);
+        if (response && stdout.writable) {
+          console.error(
+            "[rogatio-host] writing response:",
+            response.length,
+            "bytes"
+          );
+          stdout.write(Buffer2.from(response));
+        } else {
+          console.error("[rogatio-host] no response to write");
+        }
+      }
+    })();
   });
-  const bytes = canonicalPresetBytes(normalizedPreset);
-  if (bytes.byteLength > RUNTIME_LIMITS.maxPresetBytes)
-    return failure("runtime.invalid-preset");
-  const digest = digestBytes(bytes);
-  const exposedBytes = bytes.slice();
-  const normalized = Object.freeze({
-    ...normalizedPreset,
-    digest,
-    get canonicalBytes() {
-      return exposedBytes.slice();
-    }
+  await new Promise((resolve22) => {
+    stdin.on("end", () => {
+      void host.stop().then(resolve22);
+    });
   });
-  return { ok: true, value: normalized };
 }
+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") },
@@ -21910,7 +22427,53 @@ function createRequestBodyTrustController(options = {}) {
       capabilityReasons: caps.reasons
     };
   }
-  return { install, uninstall, status };
+  async function verify() {
+    const reasons = [];
+    let manifestExists = false;
+    let manifestValid = false;
+    let binaryExists = false;
+    let binaryExecutable = false;
+    let allowedOriginsCount = 0;
+    try {
+      const raw = await readFile3(manifestPath(), "utf8");
+      manifestExists = true;
+      const parsed = JSON.parse(raw);
+      if (isWellFormedManifest(parsed)) {
+        manifestValid = true;
+        const manifest = parsed;
+        allowedOriginsCount = manifest.allowed_origins.length;
+        try {
+          const fileStat = await stat2(manifest.path);
+          binaryExists = fileStat.isFile();
+          binaryExecutable = (fileStat.mode & 73) !== 0;
+          if (!binaryExists) reasons.push("binary-not-found");
+          if (!binaryExecutable) reasons.push("binary-not-executable");
+        } catch {
+          binaryExists = false;
+          reasons.push("binary-not-found");
+        }
+        if (allowedOriginsCount === 0) reasons.push("no-allowed-origins");
+      } else {
+        reasons.push("manifest-invalid");
+      }
+    } catch {
+      reasons.push("manifest-not-found");
+    }
+    const caTrusted = await existsFile(caKeyFile) && await existsFile(caCertFile);
+    if (!caTrusted) reasons.push("ca-not-trusted");
+    const ok = manifestExists && manifestValid && binaryExists && binaryExecutable && caTrusted && allowedOriginsCount > 0;
+    return {
+      ok,
+      manifestExists,
+      manifestValid,
+      binaryExists,
+      binaryExecutable,
+      caTrusted,
+      allowedOriginsCount,
+      reasons
+    };
+  }
+  return { install, uninstall, status, verify };
 }
 var darwinAdapter = {
   platform: "darwin",
@@ -22257,7 +22820,102 @@ function selectTrustPlatformAdapter(platform) {
   }
 }
 
-// packages/cli/src/commands/ai.ts
+// packages/cli/src/help.ts
+function showEditHelp() {
+  console.log(`Usage: rogatio edit [options] [path]
+
+Launch browser-based editor for .rogatio.json project file.
+
+Arguments:
+  path            Path to .rogatio.json (default: .rogatio.json in current directory)
+
+Options:
+  --port <n>      Fixed port for editor server (default: random)
+  --help, -h      Show this help
+
+The editor runs in your default browser and communicates with a local server
+bound to 127.0.0.1. Changes are saved atomically to the project file.`);
+}
+function showVerifyHelp() {
+  console.log(`Usage: rogatio verify [options] [path]
+
+Validate a .rogatio.json project file using schema and compiler.
+
+Arguments:
+  path            Path to .rogatio.json (default: .rogatio.json in current directory)
+                  Use '-' to read from stdin
+
+Options:
+  --json          Output diagnostics as JSON
+  --help, -h      Show this help
+
+Exit codes:
+  0  Valid (no diagnostics)
+  1  Invalid (diagnostics present)
+  2  Error (IO, parse, or unexpected failure)`);
+}
+function showRuntimeHelp() {
+  console.log(`Usage: rogatio runtime <command> [options]
+       rogatio runtime host [path]
+
+Native messaging runtime control for response-body and request-body rules.
+
+Commands:
+  install   Install the native-messaging host manifest and (on capable
+            platforms) provision the device-local CA (requires --extension-id).
+            CA trust requires root/admin privileges (Linux: sudo, macOS: keychain
+            password, Windows: Administrator).
+  uninstall Remove the native-messaging host manifest and device-local CA trust
+            (idempotent).
+  host [path]  Run the native-messaging runtime host. The browser launches this
+               process via the native-messaging manifest to handle rule matching.
+
+The lifecycle of the runtime (start/stop) is driven from the extension's
+Start/Stop controls, not the CLI. Run 'rogatio runtime install --extension-id
+<id>' once to register the host, then use the extension.
+
+Options:
+  --extension-id  Extension ID for native messaging manifest (required for install)
+  --root <dir>    Root for confined file mocks (default: project directory)
+  --help, -h      Show this help
+
+Exit codes:
+  0  Stopped cleanly / success
+  1  Invalid project (diagnostics present) or file outside the root
+  2  Error (IO or usage)`);
+}
+function showTestHelp() {
+  console.log(`Usage: rogatio test [options] [path] [url...]
+
+Run offline dry-run tests against a .rogatio.json project file.
+
+Arguments:
+  path            Path to .rogatio.json (default: .rogatio.json in current directory)
+                   Use '-' to read project JSON from stdin
+  url...          URLs to test; when path is omitted, first URL is detected automatically
+
+Options:
+  --urls <list>        Comma-separated list of URLs to test
+  --urls-file <path>   Path to JSON file containing array of test cases
+                        Each case: { "url": "...", "method"?: "...", "resourceType"?: "..." }
+                        Use '-' to read from stdin
+  --method <m>         Default HTTP method for all test cases (GET, POST, etc.)
+  --resource-type <t>  Default resource type for all test cases
+  --max-cases <n>      Maximum number of test cases (default: 256)
+  --json               Output results as JSON
+  --help, -h           Show this help
+
+Test case format (JSON):
+  [
+    { "url": "https://example.com/", "method": "GET", "resourceType": "main_frame" },
+    { "url": "https://example.com/script.js" }
+  ]
+
+Exit codes:
+  0  Success (all valid, results may include non-matches)
+  1  Validation/compile/test errors
+  2  Usage error (invalid arguments, missing input)`);
+}
 function showAIHelp() {
   console.log(`Usage: rogatio ai <command> [options]
 
@@ -22273,6 +22931,8 @@ Commands:
 Options:
   --help, -h  Show this help`);
 }
+
+// packages/cli/src/commands/ai.ts
 async function promptInput(prompt) {
   process.stdout.write(prompt);
   for await (const chunk of process.stdin) {
@@ -22349,550 +23009,201 @@ async function aiSetup() {
   }
   const apiKey = await promptSecret("API Key: ");
   if (!apiKey) {
-    console.error("Error: API Key is required");
-    return 1;
-  }
-  const config = { providerUrl, model, apiKey };
-  try {
-    await writeProviderConfig(config);
-    console.log("AI provider configured successfully");
-    return 0;
-  } catch (e) {
-    console.error(`Error writing config: ${e}`);
-    return 1;
-  }
-}
-async function aiList() {
-  const config = await readProviderConfig();
-  if (!config) {
-    console.log("No AI provider configured");
-    return 0;
-  }
-  console.log(`Provider: ${config.providerUrl}`);
-  console.log(`Model: ${config.model}`);
-  console.log(`API Key: ${redactKey(config.apiKey)}`);
-  return 0;
-}
-async function aiShow() {
-  const config = await readProviderConfig();
-  if (!config) {
-    console.log("No AI provider configured");
-    return 0;
-  }
-  console.log(
-    JSON.stringify(
-      {
-        providerUrl: config.providerUrl,
-        model: config.model,
-        apiKey: redactKey(config.apiKey)
-      },
-      null,
-      2
-    )
-  );
-  return 0;
-}
-async function aiDelete() {
-  const config = await readProviderConfig();
-  if (!config) {
-    console.log("No AI provider configured");
-    return 0;
-  }
-  const confirm = await promptInput(
-    "Delete AI provider configuration? [y/N]: "
-  );
-  if (confirm.toLowerCase() !== "y") {
-    console.log("Cancelled");
-    return 0;
-  }
-  try {
-    await deleteProviderConfig();
-    console.log("AI provider configuration deleted");
-    return 0;
-  } catch (e) {
-    console.error(`Error deleting config: ${e}`);
-    return 1;
-  }
-}
-async function aiTest() {
-  const config = await readProviderConfig();
-  if (!config) {
-    console.error("No AI provider configured. Run 'rogatio ai setup' first.");
+    console.error("Error: API Key is required");
     return 1;
   }
-  console.log("Testing connection to AI provider...");
-  const client = createAIClient(config);
+  const config = { providerUrl, model, apiKey };
   try {
-    const start = Date.now();
-    const result = await client.complete({
-      messages: [{ role: "user", content: "Hello" }],
-      model: config.model,
-      temperature: 0
-    });
-    const elapsed = Date.now() - start;
-    console.log(`Connection successful (${elapsed}ms)`);
-    console.log(
-      `Response: ${result.content.slice(0, 100)}${result.content.length > 100 ? "..." : ""}`
-    );
-    if (result.usage) {
-      console.log(
-        `Usage: ${result.usage.promptTokens} prompt + ${result.usage.completionTokens} completion tokens`
-      );
-    }
+    await writeProviderConfig(config);
+    console.log("AI provider configured successfully");
     return 0;
   } catch (e) {
-    console.error(`Connection failed: ${e}`);
+    console.error(`Error writing config: ${e}`);
     return 1;
   }
 }
-function redactKey(key) {
-  if (key.length <= 8) return "****";
-  return `${key.slice(0, 4)}****${key.slice(-4)}`;
-}
-
-// packages/cli/src/commands/edit.ts
-import { resolve as resolve4 } from "node:path";
-
-// packages/cli/src/server/http.ts
-import { randomInt } from "node:crypto";
-import {
-  createServer as createHttpServer
-} from "node:http";
-var HttpServerError = class extends Error {
-  code;
-  constructor(code, message, cause) {
-    super(message, { cause });
-    this.name = "HttpServerError";
-    this.code = code;
-  }
-};
-function createServer2(handler, options = {}) {
-  const server = createHttpServer(handler);
-  const preferredPort = options.port;
-  let port = null;
-  let started = false;
-  async function listenOn(candidatePort) {
-    await new Promise((resolve9, reject) => {
-      server.once("error", reject);
-      server.listen(candidatePort, "127.0.0.1", () => {
-        server.off("error", reject);
-        resolve9();
-      });
-    });
-  }
-  return {
-    get port() {
-      if (port === null)
-        throw new HttpServerError("not-started", "Server not started");
-      return port;
-    },
-    async start() {
-      if (started) return;
-      if (preferredPort !== void 0) {
-        try {
-          await listenOn(preferredPort);
-          port = preferredPort;
-          started = true;
-          return;
-        } catch (e) {
-          throw new HttpServerError(
-            "listen-failed",
-            `Failed to start server on port ${preferredPort}: ${e}`,
-            e
-          );
-        }
-      }
-      const maxRetries = 8;
-      let lastError = null;
-      for (let attempt = 0; attempt < maxRetries; attempt++) {
-        const candidatePort = randomInt(1024, 65535);
-        try {
-          await listenOn(candidatePort);
-          port = candidatePort;
-          started = true;
-          return;
-        } catch (e) {
-          lastError = e;
-          const code = e.code;
-          if (code !== "EADDRINUSE" && code !== "EACCES") {
-            throw new HttpServerError(
-              "listen-failed",
-              `Failed to start server: ${e}`,
-              e
-            );
-          }
-        }
-      }
-      throw new HttpServerError(
-        "port-exhausted",
-        `Failed to bind to port after ${maxRetries} attempts`,
-        lastError ?? void 0
-      );
-    },
-    async stop() {
-      if (!started) return;
-      await new Promise((resolve9) => {
-        server.close(() => resolve9());
-      });
-      started = false;
-    }
-  };
-}
-
-// 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";
-
-// packages/compiler/dist/node/index.js
-var ISSUE_CODES = {
-  required: "schema.required",
-  additionalProperties: "schema.unknown-property",
-  type: "schema.invalid-type",
-  format: "schema.invalid-format",
-  const: "schema.invalid-value",
-  enum: "schema.invalid-value",
-  pattern: "schema.invalid-value",
-  minLength: "schema.out-of-range",
-  maxLength: "schema.out-of-range",
-  minItems: "schema.out-of-range",
-  maxItems: "schema.out-of-range",
-  minimum: "schema.out-of-range",
-  maximum: "schema.out-of-range",
-  uniqueItems: "schema.out-of-range",
-  ownProperties: "schema.invalid-structure",
-  uniqueId: "schema.duplicate-id",
-  effectiveOrigin: "schema.no-effective-origin",
-  maxRulesPerProject: "schema.rule-limit"
-};
-var SAFE_PARAM_KEYS = /* @__PURE__ */ new Set([
-  "additionalProperty",
-  "actual",
-  "allowedValue",
-  "allowedValues",
-  "format",
-  "i",
-  "j",
-  "limit",
-  "missingProperty",
-  "previousPath",
-  "type",
-  "headerName",
-  "headerOperation",
-  "headerDirection"
-]);
-var MESSAGES = {
-  "schema.required": "Required project data is missing.",
-  "schema.unknown-property": "The project contains an unknown property.",
-  "schema.invalid-type": "The project contains a value with an invalid type.",
-  "schema.invalid-format": "The project contains a value with an invalid format.",
-  "schema.invalid-value": "The project contains an invalid value.",
-  "schema.out-of-range": "The project contains a value outside its allowed bounds.",
-  "schema.invalid-structure": "The project contains invalid structure.",
-  "schema.duplicate-id": "Project and rule IDs must be unique.",
-  "schema.no-effective-origin": "Each rule must have at least one effective origin.",
-  "schema.rule-limit": "The project contains too many rules.",
-  "compiler.invariant": "The compiler could not normalize validated project data.",
-  "compiler.forbidden-header": "The header name is forbidden for this direction.",
-  "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."
-};
-function copySafeParams(params) {
-  const safe = {};
-  for (const key of Object.keys(params)) {
-    if (!SAFE_PARAM_KEYS.has(key)) continue;
-    const value = params[key];
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null) {
-      safe[key] = value;
-      continue;
-    }
-    if (Array.isArray(value)) {
-      const values = [];
-      for (let index = 0; index < value.length; index += 1) {
-        const item = value[index];
-        if (typeof item === "string" || typeof item === "number" || typeof item === "boolean" || item === null) {
-          values.push(item);
-        }
-      }
-      safe[key] = values;
-    }
+async function aiList() {
+  const config = await readProviderConfig();
+  if (!config) {
+    console.log("No AI provider configured");
+    return 0;
   }
-  return safe;
-}
-function compareCodeUnits(left, right) {
-  if (left < right) return -1;
-  if (left > right) return 1;
+  console.log(`Provider: ${config.providerUrl}`);
+  console.log(`Model: ${config.model}`);
+  console.log(`API Key: ${redactKey(config.apiKey)}`);
   return 0;
 }
-function compareDiagnostics(left, right) {
-  const leftParams = stableParams(left.params);
-  const rightParams = stableParams(right.params);
-  return compareCodeUnits(left.path, right.path) || compareCodeUnits(left.code, right.code) || compareCodeUnits(left.message, right.message) || compareCodeUnits(leftParams, rightParams);
-}
-function stableParams(params) {
-  const keys = Object.keys(params).sort(compareCodeUnits);
-  return keys.map((key) => `${JSON.stringify(key)}:${JSON.stringify(params[key])}`).join(",");
-}
-function mapValidationIssues(issues) {
-  return issues.map((issue) => {
-    const code = Object.hasOwn(ISSUE_CODES, issue.keyword) ? ISSUE_CODES[issue.keyword] : "schema.invalid-value";
-    return {
-      code,
-      severity: "error",
-      path: issue.instancePath,
-      message: MESSAGES[code],
-      params: copySafeParams(issue.params)
-    };
-  }).sort(compareDiagnostics);
-}
-function invariantDiagnostic(path2 = "") {
-  return {
-    code: "compiler.invariant",
-    severity: "error",
-    path: path2,
-    message: MESSAGES["compiler.invariant"],
-    params: {}
-  };
-}
-function compareCodeUnits2(left, right) {
-  if (left < right) return -1;
-  if (left > right) return 1;
+async function aiShow() {
+  const config = await readProviderConfig();
+  if (!config) {
+    console.log("No AI provider configured");
+    return 0;
+  }
+  console.log(
+    JSON.stringify(
+      {
+        providerUrl: config.providerUrl,
+        model: config.model,
+        apiKey: redactKey(config.apiKey)
+      },
+      null,
+      2
+    )
+  );
   return 0;
 }
-function snapshotOwnData3(value, ancestors = /* @__PURE__ */ new WeakSet()) {
-  if (value === null || typeof value !== "object") {
-    return { valid: true, value };
+async function aiDelete() {
+  const config = await readProviderConfig();
+  if (!config) {
+    console.log("No AI provider configured");
+    return 0;
+  }
+  const confirm = await promptInput(
+    "Delete AI provider configuration? [y/N]: "
+  );
+  if (confirm.toLowerCase() !== "y") {
+    console.log("Cancelled");
+    return 0;
   }
-  if (ancestors.has(value)) return { valid: false };
-  ancestors.add(value);
   try {
-    if (Object.getOwnPropertySymbols(value).length > 0) {
-      return { valid: false };
-    }
-    if (Array.isArray(value)) {
-      const lengthDescriptor = Object.getOwnPropertyDescriptor(value, "length");
-      if (lengthDescriptor === void 0 || !("value" in lengthDescriptor) || !Number.isSafeInteger(lengthDescriptor.value) || lengthDescriptor.value < 0 || lengthDescriptor.value > LIMITS.maxRulesPerProject) {
-        return { valid: false };
-      }
-      const length = lengthDescriptor.value;
-      for (const propertyName of Object.getOwnPropertyNames(value)) {
-        if (propertyName === "length") continue;
-        const index = Number(propertyName);
-        if (!Number.isInteger(index) || index < 0 || index >= length || String(index) !== propertyName) {
-          return { valid: false };
-        }
-      }
-      const snapshot2 = new Array(length);
-      for (let index = 0; index < length; index += 1) {
-        const descriptor = Object.getOwnPropertyDescriptor(
-          value,
-          String(index)
-        );
-        if (descriptor === void 0 || !("value" in descriptor) || !descriptor.enumerable) {
-          return { valid: false };
-        }
-        const child = snapshotOwnData3(descriptor.value, ancestors);
-        if (!child.valid) return child;
-        snapshot2[index] = child.value;
-      }
-      return { valid: true, value: snapshot2 };
-    }
-    const snapshot = /* @__PURE__ */ Object.create(null);
-    for (const key of Object.getOwnPropertyNames(value)) {
-      const descriptor = Object.getOwnPropertyDescriptor(value, key);
-      if (descriptor === void 0 || !("value" in descriptor) || !descriptor.enumerable) {
-        return { valid: false };
-      }
-      const child = snapshotOwnData3(descriptor.value, ancestors);
-      if (!child.valid) return child;
-      Object.defineProperty(snapshot, key, {
-        configurable: true,
-        enumerable: true,
-        value: child.value,
-        writable: true
-      });
-    }
-    return { valid: true, value: snapshot };
-  } catch {
-    return { valid: false };
-  } finally {
-    ancestors.delete(value);
+    await deleteProviderConfig();
+    console.log("AI provider configuration deleted");
+    return 0;
+  } catch (e) {
+    console.error(`Error deleting config: ${e}`);
+    return 1;
   }
 }
-var CompilerInvariantError = class extends Error {
-  constructor(path2) {
-    super("invalid normalized origin");
-    this.path = path2;
-    this.name = "CompilerInvariantError";
-  }
-  path;
-};
-function normalizeOrigins(group, rule, groupIndex, ruleIndex) {
-  const origins = /* @__PURE__ */ new Set();
-  const sourceArrays = [group.origins, rule.origins];
-  for (let sourceIndex = 0; sourceIndex < sourceArrays.length; sourceIndex += 1) {
-    const source = sourceArrays[sourceIndex];
-    for (let originIndex = 0; originIndex < source.length; originIndex += 1) {
-      const normalized = normalizeSiteOrigin(source[originIndex]);
-      if (normalized === null) {
-        const path2 = sourceIndex === 0 ? `/groups/${groupIndex}/origins/${originIndex}` : `/groups/${groupIndex}/rules/${ruleIndex}/origins/${originIndex}`;
-        throw new CompilerInvariantError(path2);
-      }
-      origins.add(normalized);
-    }
+async function aiTest() {
+  const config = await readProviderConfig();
+  if (!config) {
+    console.error("No AI provider configured. Run 'rogatio ai setup' first.");
+    return 1;
   }
-  const normalizedOrigins = [];
-  for (const origin of origins) normalizedOrigins.push(origin);
-  normalizedOrigins.sort(compareCodeUnits2);
-  return normalizedOrigins;
-}
-function canonicalResourceTypes(resourceTypes) {
-  const ordered = [];
-  for (let canonicalIndex = 0; canonicalIndex < RESOURCE_TYPES.length; canonicalIndex += 1) {
-    const canonical = RESOURCE_TYPES[canonicalIndex];
-    for (let sourceIndex = 0; sourceIndex < resourceTypes.length; sourceIndex += 1) {
-      if (resourceTypes[sourceIndex] === canonical) ordered.push(canonical);
+  console.log("Testing connection to AI provider...");
+  const client = createAIClient(config);
+  try {
+    const start = Date.now();
+    const result = await client.complete({
+      messages: [{ role: "user", content: "Hello" }],
+      model: config.model,
+      temperature: 0
+    });
+    const elapsed = Date.now() - start;
+    console.log(`Connection successful (${elapsed}ms)`);
+    console.log(
+      `Response: ${result.content.slice(0, 100)}${result.content.length > 100 ? "..." : ""}`
+    );
+    if (result.usage) {
+      console.log(
+        `Usage: ${result.usage.promptTokens} prompt + ${result.usage.completionTokens} completion tokens`
+      );
     }
+    return 0;
+  } catch (e) {
+    console.error(`Connection failed: ${e}`);
+    return 1;
   }
-  return ordered;
 }
-function compileMatcher(group, rule, groupIndex, ruleIndex) {
-  const matcher = {
-    urlRegex: { source: rule.urlRegex, flags: "" },
-    origins: normalizeOrigins(group, rule, groupIndex, ruleIndex),
-    resourceTypes: canonicalResourceTypes(rule.resourceTypes),
-    priority: rule.priority
-  };
-  if (rule.method !== void 0) matcher.method = rule.method;
-  return matcher;
+function redactKey(key) {
+  if (key.length <= 8) return "****";
+  return `${key.slice(0, 4)}****${key.slice(-4)}`;
 }
-function compileOperations(project) {
-  const operations = [];
-  for (let groupIndex = 0; groupIndex < project.groups.length; groupIndex += 1) {
-    const group = project.groups[groupIndex];
-    for (let ruleIndex = 0; ruleIndex < group.rules.length; ruleIndex += 1) {
-      const rule = group.rules[ruleIndex];
-      const matcher = compileMatcher(group, rule, groupIndex, ruleIndex);
-      if (rule.type === "redirect") {
-        const operation = {
-          kind: "redirect",
-          groupId: group.id,
-          ruleId: rule.id,
-          matcher,
-          redirect: { destination: rule.redirect?.destination ?? "" }
-        };
-        operations.push(operation);
-      } else if (rule.type === "query" && rule.action && "type" in rule.action && rule.action.type === "query") {
-        const action = rule.action;
-        const operation = {
-          kind: "query",
-          groupId: group.id,
-          ruleId: rule.id,
-          matcher,
-          action
-        };
-        operations.push(operation);
-      } else if (rule.type === "header") {
-        const operation = {
-          kind: "header",
-          groupId: group.id,
-          ruleId: rule.id,
-          matcher,
-          header: {
-            direction: rule.headerDirection ?? "request",
-            operation: rule.headerOperation ?? "set",
-            name: rule.headerName ?? "",
-            ...rule.headerValue !== void 0 ? { value: rule.headerValue } : {}
+
+// packages/cli/src/commands/edit.ts
+import { resolve as resolve4 } from "node:path";
+
+// packages/cli/src/server/http.ts
+import { randomInt } from "node:crypto";
+import {
+  createServer as createHttpServer
+} from "node:http";
+var HttpServerError = class extends Error {
+  code;
+  constructor(code, message, cause) {
+    super(message, { cause });
+    this.name = "HttpServerError";
+    this.code = code;
+  }
+};
+function createServer2(handler, options = {}) {
+  const server = createHttpServer(handler);
+  const preferredPort = options.port;
+  let port = null;
+  let started = false;
+  async function listenOn(candidatePort) {
+    await new Promise((resolve9, reject) => {
+      server.once("error", reject);
+      server.listen(candidatePort, "127.0.0.1", () => {
+        server.off("error", reject);
+        resolve9();
+      });
+    });
+  }
+  return {
+    get port() {
+      if (port === null)
+        throw new HttpServerError("not-started", "Server not started");
+      return port;
+    },
+    async start() {
+      if (started) return;
+      if (preferredPort !== void 0) {
+        try {
+          await listenOn(preferredPort);
+          port = preferredPort;
+          started = true;
+          return;
+        } catch (e) {
+          throw new HttpServerError(
+            "listen-failed",
+            `Failed to start server on port ${preferredPort}: ${e}`,
+            e
+          );
+        }
+      }
+      const maxRetries = 8;
+      let lastError = null;
+      for (let attempt = 0; attempt < maxRetries; attempt++) {
+        const candidatePort = randomInt(1024, 65535);
+        try {
+          await listenOn(candidatePort);
+          port = candidatePort;
+          started = true;
+          return;
+        } catch (e) {
+          lastError = e;
+          const code = e.code;
+          if (code !== "EADDRINUSE" && code !== "EACCES") {
+            throw new HttpServerError(
+              "listen-failed",
+              `Failed to start server: ${e}`,
+              e
+            );
           }
-        };
-        operations.push(operation);
-      } else if (rule.type === "mock") {
-        const operation = {
-          kind: "mock",
-          groupId: group.id,
-          ruleId: rule.id,
-          matcher,
-          mock: rule.mock ?? { status: 200, body: "" }
-        };
-        operations.push(operation);
-      } else if (rule.type === "response-body") {
-        const operation = {
-          kind: "response-body",
-          groupId: group.id,
-          ruleId: rule.id,
-          matcher,
-          responseBody: rule.responseBody ?? { replacements: [] }
-        };
-        operations.push(operation);
-      } else if (rule.type === "request-body") {
-        const operation = {
-          kind: "request-body",
-          groupId: group.id,
-          ruleId: rule.id,
-          matcher,
-          requestBody: rule.requestBody ?? { mode: "replace", body: "" }
-        };
-        operations.push(operation);
-      } else {
-        const operation = {
-          kind: "matcher",
-          groupId: group.id,
-          ruleId: rule.id,
-          matcher
-        };
-        operations.push(operation);
+        }
       }
+      throw new HttpServerError(
+        "port-exhausted",
+        `Failed to bind to port after ${maxRetries} attempts`,
+        lastError ?? void 0
+      );
+    },
+    async stop() {
+      if (!started) return;
+      await new Promise((resolve9) => {
+        server.close(() => resolve9());
+      });
+      started = false;
     }
-  }
-  return operations;
-}
-function compileProject(value) {
-  const snapshot = snapshotOwnData3(value);
-  if (!snapshot.valid) {
-    return {
-      ok: false,
-      operations: [],
-      diagnostics: mapValidationIssues([
-        {
-          instancePath: "",
-          keyword: "ownProperties",
-          message: "must contain only own data properties",
-          params: {}
-        }
-      ])
-    };
-  }
-  let validation;
-  try {
-    validation = validateProjectDetailed(snapshot.value);
-  } catch {
-    return { ok: false, operations: [], diagnostics: [invariantDiagnostic()] };
-  }
-  if (!validation.valid) {
-    return {
-      ok: false,
-      operations: [],
-      diagnostics: mapValidationIssues(validation.errors)
-    };
-  }
-  try {
-    return {
-      ok: true,
-      operations: compileOperations(validation.data),
-      diagnostics: []
-    };
-  } catch (error) {
-    const path2 = error instanceof CompilerInvariantError ? error.path : "";
-    return {
-      ok: false,
-      operations: [],
-      diagnostics: [invariantDiagnostic(path2)]
-    };
-  }
+  };
 }
 
+// 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";
+
 // packages/dry-run/dist/node/index.js
 function parseTestUrl(input) {
   if (typeof input !== "string" || input.length === 0) {
@@ -23921,10 +24232,7 @@ async function editCommand(args, options = {}) {
     } else if (!arg.startsWith("-")) {
       positionalArgs.push(arg);
     } else if (arg === "--help") {
-      console.log(`Usage: rogatio edit [options] [path]
-Options:
-  --port <n>    Fixed port (default: random)
-  --help        Show help`);
+      showEditHelp();
       return { exitCode: Promise.resolve(0), shutdown: () => {
       } };
     } else {
@@ -24242,40 +24550,8 @@ function generateEditorHtml(apiBase, csrfToken, filePath, aiConfigured) {
 }
 
 // packages/cli/src/commands/runtime.ts
+import { chmod, mkdir as mkdir4, rm as rm2, writeFile as writeFile4 } from "node:fs/promises";
 import { dirname as dirname7, isAbsolute, join as join6, relative, resolve as resolve5, sep as sep2 } from "node:path";
-function showRuntimeHelp() {
-  console.log(`Usage: rogatio runtime <command> [options]
-       rogatio runtime host [path]
-
-Native messaging runtime control for response-body and request-body rules. The
-runtime no longer serves an HTTP mock server; mock delivery happens in the
-consolidated native-messaging host (spec REQ-001..REQ-005).
-
-Request-body trust commands:
-  install   Install the native-messaging host manifest and (on capable
-            platforms) provision the device-local CA (requires --extension-id).
-            CA trust requires root/admin: Linux (sudo), macOS (keychain
-            password), Windows (Administrator).
-  uninstall Remove the native-messaging host manifest and the device-local CA trust (idempotent)
-
-Native host command:
-  host [path]  Run the consolidated native-messaging runtime host. The browser
-               launches this process via the native-messaging manifest; it reads
-               pairing/authorization/mock envelopes from stdin and writes
-               responses to stdout.
-
-The lifecycle of the runtime (start/stop) is driven from the extension's
-Start/Stop controls, not the CLI. Run 'rogatio runtime install --extension-id
-<id>' once to register the host, then use the extension.
-
-Options:
-  --extension-id    Extension ID for native messaging manifest (required for install)
-  --root <dir>      Root for confined file mocks (default: project directory)
-  --help, -h        Show this help
-
-The device-local CA / PAC routing capability is invoked from the unified
-install command on capable platforms; it does not have a separate verb.`);
-}
 function toMatcherOperations2(operations) {
   return operations.map(({ groupId, ruleId, matcher }) => ({
     kind: "matcher",
@@ -24319,6 +24595,28 @@ function buildMockConfigs(operations, root) {
   }
   return { ok: true, value: configs };
 }
+function generateHostWrapper(rogatioCommand, logPath) {
+  const parts = rogatioCommand.split(" ");
+  const nodeBin = parts[0] ?? "node";
+  const cliScript = parts.slice(1).join(" ");
+  return `#!/bin/sh
+# Rogatio native messaging host wrapper \u2014 generated by \`rogatio runtime install\`
+# Chrome launches this script when the extension connects via connectNative().
+# The extension sends the project data as the first envelope after launch.
+# stderr is redirected to a log file for debugging.
+exec "${nodeBin}" "${cliScript}" runtime host 2>>"${logPath}"
+`;
+}
+async function writeHostWrapper(hostPath, installRoot) {
+  await mkdir4(installRoot, { recursive: true });
+  const logPath = join6(installRoot, "runtime-host.log");
+  const script = generateHostWrapper(
+    `${process.execPath} ${process.argv[1] ?? "rogatio"}`,
+    logPath
+  );
+  await writeFile4(hostPath, script, "utf8");
+  await chmod(hostPath, 493);
+}
 function makeTrustController() {
   const platform = process.platform;
   const adapter = selectTrustPlatformAdapter(platform);
@@ -24356,7 +24654,7 @@ function reportTrust(subcommand, result, okMessage) {
         console.error(hint);
       }
     }
-    return 0;
+    return 1;
   }
   console.error(
     `runtime ${subcommand} failed: ${(result.reasons ?? ["unknown"]).join(", ")}`
@@ -24382,19 +24680,85 @@ async function trustRuntimeCommand(args) {
     }
   }
   const controller = makeTrustController();
+  const installRoot = defaultTrustInstallRoot(process.platform);
+  const hostPath = join6(installRoot, "runtime-host");
   switch (subcommand) {
-    case "install":
+    case "install": {
+      const installResult = await controller.install(extensionId ?? "");
+      if (installResult.ok) {
+        try {
+          await writeHostWrapper(hostPath, installRoot);
+        } catch (error) {
+          console.error(
+            `Warning: manifest and CA trusted, but failed to create runtime-host wrapper: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
       return reportTrust(
         "install",
-        await controller.install(extensionId ?? ""),
-        "runtime install complete: manifest + device-local CA trusted"
+        installResult,
+        "runtime install complete: manifest + device-local CA trusted + runtime-host wrapper created\nNote: reload the extension at chrome://extensions for the native host to be detected."
       );
-    case "uninstall":
+    }
+    case "uninstall": {
+      const uninstallResult = await controller.uninstall();
+      try {
+        await rm2(hostPath, { force: true });
+      } catch {
+      }
+      try {
+        await rm2(join6(installRoot, "runtime-host.log"), { force: true });
+      } catch {
+      }
       return reportTrust(
         "uninstall",
-        await controller.uninstall(),
+        uninstallResult,
         "runtime uninstall complete: manifest + device-local CA removed"
       );
+    }
+    case "verify": {
+      const result = await controller.verify();
+      if (result.ok) {
+        console.log(
+          "runtime verification passed: manifest, binary, and CA trust all OK"
+        );
+        return 0;
+      }
+      console.error("runtime verification failed:");
+      if (!result.manifestExists) console.error("  manifest not found");
+      if (result.manifestExists && !result.manifestValid)
+        console.error("  manifest invalid");
+      if (!result.binaryExists)
+        console.error("  runtime-host binary not found");
+      if (result.binaryExists && !result.binaryExecutable)
+        console.error("  runtime-host binary not executable");
+      if (result.allowedOriginsCount === 0)
+        console.error("  no allowed_origins in manifest");
+      if (!result.caTrusted) console.error("  device-local CA not trusted");
+      for (const reason of result.reasons) {
+        if (reason === "manifest-not-found")
+          console.error(
+            "  Hint: run 'rogatio runtime install --extension-id <id>' to register the host manifest"
+          );
+        if (reason === "binary-not-found")
+          console.error(
+            `  Hint: ensure the runtime-host binary exists at the path specified in the manifest`
+          );
+        if (reason === "binary-not-executable")
+          console.error(
+            "  Hint: ensure the runtime-host binary has execute permission (chmod +x)"
+          );
+        if (reason === "no-allowed-origins")
+          console.error(
+            "  Hint: re-run 'rogatio runtime install --extension-id <id>' to pin your extension ID"
+          );
+        if (reason === "ca-not-trusted")
+          console.error(
+            "  Hint: re-run 'rogatio runtime install --extension-id <id>' with elevated privileges to trust the CA"
+          );
+      }
+      return 1;
+    }
     default:
       console.error(`Error: unknown runtime subcommand: ${subcommand ?? ""}`);
       showRuntimeHelp();
@@ -24432,6 +24796,16 @@ async function runtimeHostCommand(args) {
     return 2;
   }
   const inputPath = positional[0];
+  if (!inputPath) {
+    await runNativeHost({
+      fileRoot: root,
+      ...mockPort !== void 0 ? { mockPort } : {},
+      onReady: () => console.error(
+        "rogatio runtime-host active (deferred, waiting for project)"
+      )
+    });
+    return 0;
+  }
   let filePath;
   let projectData;
   try {
@@ -24443,7 +24817,7 @@ async function runtimeHostCommand(args) {
       filePath = "<stdin>";
       projectData = JSON.parse(chunks.join(""));
     } else {
-      filePath = inputPath ? resolve5(inputPath) : resolve5(process.cwd(), ".rogatio.json");
+      filePath = resolve5(inputPath);
       projectData = await readProject(filePath);
     }
   } catch (error) {
@@ -24500,7 +24874,7 @@ async function runtimeCommand(args, _options = {}) {
     return 0;
   }
   const first = args[0];
-  if (first === "install" || first === "trust" || first === "uninstall")
+  if (first === "install" || first === "trust" || first === "uninstall" || first === "verify")
     return trustRuntimeCommand(args);
   if (first === "host") return runtimeHostCommand(args.slice(1));
   console.error(
@@ -24994,7 +25368,7 @@ async function handleVerify(args) {
 }
 async function handleRuntime(args) {
   if (args.includes("--help") || args.includes("-h")) {
-    showRuntimeHelp2();
+    showRuntimeHelp();
     return 0;
   }
   const result = await runtimeCommand(args);
@@ -25002,7 +25376,7 @@ async function handleRuntime(args) {
 }
 async function handleAI(args) {
   if (args.includes("--help") || args.includes("-h")) {
-    showAIHelp2();
+    showAIHelp();
     return 0;
   }
   return await aiCommand(args);
@@ -25039,8 +25413,8 @@ Commands:
   edit [path]     Launch browser editor for .rogatio.json
   test [path] [url...]  Run offline dry-run tests against .rogatio.json
   verify [path]   Validate .rogatio.json file
-  runtime <install|uninstall|host>  Native messaging runtime control and request-body trust management
-  runtime host [path]  Run the consolidated native-messaging runtime host
+  runtime <install|uninstall|host>  Native messaging runtime control
+  runtime host [path]  Run the native-messaging runtime host
 
 Global Options:
   --help, -h      Show help
@@ -25049,122 +25423,6 @@ Global Options:
 Run 'rogatio <command> --help' for command-specific help.`);
   return 0;
 }
-function showEditHelp() {
-  console.log(`Usage: rogatio edit [options] [path]
-
-Launch browser-based editor for .rogatio.json project file.
-
-Arguments:
-  path            Path to .rogatio.json (default: .rogatio.json in current directory)
-
-Options:
-  --port <n>      Fixed port for editor server (default: random)
-  --help, -h      Show this help
-
-The editor runs in your default browser and communicates with a local server
-bound to 127.0.0.1. Changes are saved atomically to the project file.`);
-}
-function showVerifyHelp() {
-  console.log(`Usage: rogatio verify [options] [path]
-
-Validate a .rogatio.json project file using schema and compiler.
-
-Arguments:
-  path            Path to .rogatio.json (default: .rogatio.json in current directory)
-                  Use '-' to read from stdin
-
-Options:
-  --json          Output diagnostics as JSON
-  --help, -h      Show this help
-
-Exit codes:
-  0  Valid (no diagnostics)
-  1  Invalid (diagnostics present)
-  2  Error (IO, parse, or unexpected failure)`);
-}
-function showRuntimeHelp2() {
-  console.log(`Usage: rogatio runtime <command> [options]
-       rogatio runtime host [path]
-
-Native messaging runtime control for response-body and request-body rules. The
-runtime no longer serves an HTTP mock server; mock delivery happens in the
-consolidated native-messaging host (spec REQ-001..REQ-005).
-
-Request-body trust commands:
-  install   Install the native-messaging host manifest and (on capable
-            platforms) provision the device-local CA (requires --extension-id)
-  uninstall Remove the native-messaging host manifest and the device-local CA trust (idempotent)
-
-Native host command:
-  host [path]  Run the consolidated native-messaging runtime host. The browser
-               launches this process via the native-messaging manifest; it reads
-               pairing/authorization/mock envelopes from stdin and writes
-               responses to stdout.
-
-The lifecycle of the runtime (start/stop) is driven from the extension's
-Start/Stop controls, not the CLI. Run 'rogatio runtime install --extension-id
-<id>' once to register the host, then use the extension.
-
-Options:
-  --root <dir>    Root for confined file mocks (default: project directory)
-  --extension-id  Extension ID for native messaging manifest (required for install)
-  --help, -h      Show this help
-
-The device-local CA / PAC routing capability is invoked from the unified
-install command on capable platforms; it does not have a separate verb.
-
-Exit codes:
-  0  Stopped cleanly / success
-  1  Invalid project (diagnostics present) or file outside the root
-  2  Error (IO or usage)`);
-}
-function showTestHelp() {
-  console.log(`Usage: rogatio test [options] [path] [url...]
-
-Run offline dry-run tests against a .rogatio.json project file.
-
-Arguments:
-  path            Path to .rogatio.json (default: .rogatio.json in current directory)
-                   Use '-' to read project JSON from stdin
-  url...          URLs to test; when path is omitted, first URL is detected automatically
-
-Options:
-  --urls <list>        Comma-separated list of URLs to test
-  --urls-file <path>   Path to JSON file containing array of test cases
-                        Each case: { "url": "...", "method"?: "...", "resourceType"?: "..." }
-                        Use '-' to read from stdin
-  --method <m>         Default HTTP method for all test cases (GET, POST, etc.)
-  --resource-type <t>  Default resource type for all test cases
-  --max-cases <n>      Maximum number of test cases (default: 256)
-  --json               Output results as JSON
-  --help, -h           Show this help
-
-Test case format (JSON):
-  [
-    { "url": "https://example.com/", "method": "GET", "resourceType": "main_frame" },
-    { "url": "https://example.com/script.js" }
-  ]
-
-Exit codes:
-  0  Success (all valid, results may include non-matches)
-  1  Validation/compile/test errors
-  2  Usage error (invalid arguments, missing input)`);
-}
-function showAIHelp2() {
-  console.log(`Usage: rogatio ai <command> [options]
-
-AI provider configuration commands.
-
-Commands:
-  setup      Interactively configure AI provider (URL, model, API key)
-  ls         List configured AI provider
-  show       Show current AI provider configuration (key redacted)
-  delete     Delete AI provider configuration
-  test       Test connection to AI provider
-
-Options:
-  --help, -h  Show this help`);
-}
 if (process.argv[1] !== void 0 && realpathSync.native(fileURLToPath2(import.meta.url)) === realpathSync.native(resolve8(process.argv[1]))) {
   if (basename4(process.argv[1]) === "runtime-host") {
     runRuntimeHostEntry().catch((err) => {