@rogatio/cli 5.18.0 → 5.20.0

package/dist/node/index.js

@@ -1351,7 +1351,14 @@ function validateProjectDetailed(value) {
 // packages/runtime/dist/node/index.js
 import { isIP as isIP2 } from "node:net";
 import { Buffer as Buffer2 } from "node:buffer";
-import { createServer } from "node:http";
+import { existsSync } from "node:fs";
+import { createServer as createServer2 } from "node:http";
+import { join as join3 } from "node:path";
+import {
+  createServer
+} from "node:http";
+import { connect } from "node:net";
+import { Worker } from "node:worker_threads";
 
 // packages/compiler/dist/node/index.js
 var ISSUE_CODES = {
@@ -1717,11 +1724,11 @@ import { isAbsolute as isAbsolute2, relative as relative2, resolve, sep } from "
 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 { generateKeyPairSync, 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 { dirname as dirname3, join as join4 } from "node:path";
 import { join as posixJoin } from "node:path/posix";
 import { spawn as spawn2, spawnSync as spawnSync2 } from "node:child_process";
 import { accessSync as accessSync2, constants as constants3, mkdirSync, unlinkSync as unlinkSync2 } from "node:fs";
@@ -1730,7 +1737,7 @@ 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 join5 } from "node:path";
 import { join as posixJoin3 } from "node:path/posix";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -20878,6 +20885,115 @@ function mergeProposalIntoProject(project, proposal) {
   }
   return { ...project, groups };
 }
+var RULE_PATH_PATTERN = /^\/groups\/(0|[1-9][0-9]*)\/rules\/(0|[1-9][0-9]*)(?:\/|$)/;
+function repairTargetsFromDiagnostics(diagnostics) {
+  if (!Array.isArray(diagnostics)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const targets = [];
+  for (const diagnostic of diagnostics) {
+    if (!isRecord(diagnostic) || typeof diagnostic.path !== "string") continue;
+    const match = RULE_PATH_PATTERN.exec(diagnostic.path);
+    if (!match) continue;
+    const groupIndex = Number(match[1]);
+    const ruleIndex = Number(match[2]);
+    if (!Number.isSafeInteger(groupIndex) || !Number.isSafeInteger(ruleIndex)) {
+      continue;
+    }
+    const key = `${groupIndex}/${ruleIndex}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    targets.push({ groupIndex, ruleIndex });
+  }
+  targets.sort(
+    (left, right) => left.groupIndex - right.groupIndex || left.ruleIndex - right.ruleIndex
+  );
+  return targets;
+}
+var RULE_KINDS = /* @__PURE__ */ new Set([
+  "redirect",
+  "query",
+  "header",
+  "response-body",
+  "request-body"
+]);
+function stringArray(value) {
+  if (!Array.isArray(value)) return void 0;
+  const items = value.filter(
+    (item) => typeof item === "string"
+  );
+  return items.length === value.length ? items : void 0;
+}
+function parseProposalRule(value) {
+  if (!isRecord(value)) return null;
+  const kind = value.kind;
+  if (typeof kind !== "string" || !RULE_KINDS.has(kind) || typeof value.groupId !== "string" || typeof value.name !== "string" || typeof value.urlRegex !== "string" || !Object.hasOwn(value, "action")) {
+    return null;
+  }
+  return {
+    kind,
+    groupId: value.groupId,
+    name: value.name,
+    urlRegex: value.urlRegex,
+    origins: stringArray(value.origins),
+    resourceTypes: stringArray(value.resourceTypes),
+    priority: typeof value.priority === "number" ? value.priority : void 0,
+    method: typeof value.method === "string" ? value.method : void 0,
+    action: value.action
+  };
+}
+function repairProposalIntoProject(project, diagnostics, proposal) {
+  const groups = Array.isArray(project.groups) ? project.groups.map((group) => {
+    if (!isRecord(group)) {
+      return { id: "invalid", name: "invalid", origins: [], rules: [] };
+    }
+    return {
+      ...group,
+      rules: Array.isArray(group.rules) ? [...group.rules] : []
+    };
+  }) : [];
+  const queues = /* @__PURE__ */ new Map();
+  for (const target of repairTargetsFromDiagnostics(diagnostics)) {
+    const group = groups[target.groupIndex];
+    if (!group) continue;
+    const rules = group.rules;
+    if (target.ruleIndex >= rules.length) continue;
+    if (!isRecord(rules[target.ruleIndex])) continue;
+    const queue = queues.get(target.groupIndex) ?? [];
+    queue.push(target.ruleIndex);
+    queues.set(target.groupIndex, queue);
+  }
+  let seq = 0;
+  const newId = () => `ai-${Date.now()}-${seq++}`;
+  const proposed = Array.isArray(proposal.rules) ? proposal.rules : [];
+  for (const entry of proposed) {
+    const ruleProposal = parseProposalRule(entry);
+    if (!ruleProposal) continue;
+    const groupIndex = groups.findIndex(
+      (candidate) => candidate.id === ruleProposal.groupId
+    );
+    const queue = groupIndex >= 0 ? queues.get(groupIndex) : void 0;
+    const targetIndex = queue?.shift();
+    if (groupIndex >= 0 && targetIndex !== void 0) {
+      const rules = groups[groupIndex].rules;
+      const existing = rules[targetIndex];
+      const keptId = typeof existing.id === "string" ? existing.id : newId();
+      rules[targetIndex] = ruleFromProposal(ruleProposal, keptId);
+      continue;
+    }
+    let group = groupIndex >= 0 ? groups[groupIndex] : void 0;
+    if (!group) {
+      group = {
+        id: ruleProposal.groupId,
+        name: "AI Group",
+        origins: [],
+        rules: []
+      };
+      groups.push(group);
+    }
+    group.rules.push(ruleFromProposal(ruleProposal, newId()));
+  }
+  return { ...project, groups };
+}
 function parseProposal(content) {
   try {
     const parsed = JSON.parse(content);
@@ -20943,6 +21059,11 @@ async function runStream(client, options) {
 async function runAIAssist(request, config, validate, dryRun, client) {
   const aiClient = client ?? createAIClient(config);
   const systemPrompt = buildSystemPrompt(request.context.project);
+  const merge = (project, proposal) => request.kind === "fix" ? repairProposalIntoProject(
+    project,
+    request.context.diagnostics,
+    proposal
+  ) : mergeProposalIntoProject(project, proposal);
   let currentProposal = null;
   let attempts = 0;
   while (attempts < MAX_FIX_ATTEMPTS) {
@@ -20950,9 +21071,7 @@ async function runAIAssist(request, config, validate, dryRun, client) {
     const isFixAttempt = attempts > 1 || request.kind === "fix";
     const validationErrors = (() => {
       if (!isFixAttempt || !currentProposal) return [];
-      return validate(
-        mergeProposalIntoProject(request.context.project, currentProposal)
-      );
+      return validate(merge(request.context.project, currentProposal));
     })();
     const messages = buildMessages(
       systemPrompt,
@@ -20983,10 +21102,7 @@ async function runAIAssist(request, config, validate, dryRun, client) {
       throw new Error("AI returned invalid proposal format");
     }
     currentProposal = proposal;
-    const testProject = mergeProposalIntoProject(
-      request.context.project,
-      proposal
-    );
+    const testProject = merge(request.context.project, proposal);
     const diagnostics = validate(testProject);
     if (diagnostics.length === 0) {
       if (dryRun && request.context.dryRunCases && request.context.dryRunCases.length > 0) {
@@ -21316,6 +21432,7 @@ var RUNTIME_LIMITS = Object.freeze({
 });
 var PROTOCOL = "v1";
 var ENVELOPE_MAX_BYTES = 64 * 1024;
+var MAX_PAC_ORIGINS = 256;
 var FORBIDDEN_BODY_KEYS = /* @__PURE__ */ new Set(["body", "requestBody", "responseBody"]);
 var MOCK_BODY_KEY = "mockBody";
 var MOCK_BODY_ALLOWED_TYPES = /* @__PURE__ */ new Set(["mock.response"]);
@@ -21325,6 +21442,8 @@ var ENVELOPE_MESSAGE_TYPES = /* @__PURE__ */ new Set([
   "runtime.stop",
   "runtime.status",
   "runtime.project.set",
+  "runtime.pac.install",
+  "runtime.pac.remove",
   "authority.grant",
   "authority.revoke",
   "transform.request",
@@ -21430,166 +21549,1054 @@ function parseEnvelope(json) {
   };
   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 digestToken(value) {
-  return createHash("sha256").update(value, "utf8").digest();
-}
-function isToken(value) {
-  if (typeof value !== "string" || value.length !== TOKEN_LENGTH) return false;
-  if (!/^[A-Za-z0-9_-]+$/.test(value)) return false;
+function supportedContentType(value) {
+  if (value === void 0) return false;
+  const mediaType = value.split(";", 1)[0]?.trim().toLowerCase() ?? "";
+  return mediaType === "application/json" || mediaType.startsWith("application/") && mediaType.endsWith("+json") || mediaType === "application/x-www-form-urlencoded" || mediaType.startsWith("text/");
+}
+var REGEX_WORKER_SOURCE = `
+const workerThreads =
+  typeof process.getBuiltinModule === "function"
+    ? process.getBuiltinModule("worker_threads")
+    : require("worker_threads");
+const { parentPort } = workerThreads;
+parentPort.postMessage({ type: "ready" });
+parentPort.on("message", (msg) => {
+  if (msg.type !== "replace") return;
+  parentPort.postMessage({ id: msg.id, type: "ack" });
   try {
-    return Buffer.from(value, "base64url").length === TOKEN_BYTES;
-  } catch {
-    return false;
+    const out = msg.text.replace(new RegExp(msg.pattern, "gu"), msg.replacement);
+    parentPort.postMessage({ id: msg.id, type: "result", ok: true, out });
+  } catch (err) {
+    parentPort.postMessage({
+      id: msg.id,
+      type: "result",
+      ok: false,
+      error: String((err && err.message) || err),
+    });
   }
+});
+`;
+var REGEX_WORKER_BOOT_TIMEOUT_MS = 5e3;
+var regexWorker = null;
+var regexWorkerBoot = null;
+var nextRegexJobId = 1;
+var regexWorkerBootDelayForTestsMs = 0;
+function discardRegexWorker(worker) {
+  if (regexWorker === worker) {
+    regexWorker = null;
+    regexWorkerBoot = null;
+  }
+  worker.terminate().catch(() => {
+  });
 }
-function sameToken(value, expectedDigest) {
-  const actual = digestToken(value);
-  return actual.length === expectedDigest.length && timingSafeEqual(actual, expectedDigest);
+function bootRegexWorker() {
+  if (regexWorker !== null) return Promise.resolve(regexWorker);
+  if (regexWorkerBoot !== null) return regexWorkerBoot;
+  const boot = new Promise((resolve22, reject) => {
+    const start = () => {
+      let worker;
+      try {
+        worker = new Worker(REGEX_WORKER_SOURCE, { eval: true });
+      } catch (error) {
+        reject(
+          error instanceof Error ? error : new Error("regex-worker-boot-failed")
+        );
+        return;
+      }
+      let settled = false;
+      const bootTimer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        regexWorkerBoot = null;
+        worker.terminate().catch(() => {
+        });
+        reject(new Error("regex-worker-boot-timeout"));
+      }, REGEX_WORKER_BOOT_TIMEOUT_MS);
+      worker.once("message", () => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(bootTimer);
+        worker.unref();
+        worker.on("error", () => {
+        });
+        worker.once("exit", () => {
+          if (regexWorker === worker) {
+            regexWorker = null;
+            regexWorkerBoot = null;
+          }
+        });
+        regexWorker = worker;
+        resolve22(worker);
+      });
+      worker.once("error", (error) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(bootTimer);
+        regexWorkerBoot = null;
+        reject(error);
+      });
+      worker.once("exit", () => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(bootTimer);
+        regexWorkerBoot = null;
+        reject(new Error("regex-worker-exit-during-boot"));
+      });
+    };
+    if (regexWorkerBootDelayForTestsMs > 0) {
+      const delay2 = regexWorkerBootDelayForTestsMs;
+      regexWorkerBootDelayForTestsMs = 0;
+      setTimeout(start, delay2).unref();
+    } else {
+      start();
+    }
+  });
+  regexWorkerBoot = boot;
+  void boot.catch(() => {
+    if (regexWorkerBoot === boot) regexWorkerBoot = null;
+  });
+  return boot;
+}
+function runOnRegexWorker(worker, id2, text, pattern, replacement, deadlineMs) {
+  return new Promise((resolve22, reject) => {
+    let timer = null;
+    const cleanup = () => {
+      if (timer !== null) clearTimeout(timer);
+      worker.off("message", onMessage);
+      worker.off("error", onError);
+      worker.off("exit", onExit);
+    };
+    const onMessage = (msg) => {
+      if (msg.id !== id2) return;
+      if (msg.type === "ack") {
+        timer = setTimeout(() => {
+          cleanup();
+          discardRegexWorker(worker);
+          reject(new Error("deadline"));
+        }, deadlineMs);
+        return;
+      }
+      if (msg.type === "result") {
+        cleanup();
+        if (msg.ok && typeof msg.out === "string") resolve22(msg.out);
+        else reject(new Error(msg.error || "regex-invalid"));
+      }
+    };
+    const onError = (error) => {
+      cleanup();
+      reject(error);
+    };
+    const onExit = () => {
+      cleanup();
+      reject(new Error("regex-worker-exited"));
+    };
+    worker.on("message", onMessage);
+    worker.once("error", onError);
+    worker.once("exit", onExit);
+    worker.postMessage({ id: id2, type: "replace", text, pattern, replacement });
+  });
 }
-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 runRegexReplace(text, pattern, replacement, deadlineMs) {
+  const id2 = nextRegexJobId;
+  nextRegexJobId += 1;
+  return bootRegexWorker().then(
+    (worker) => runOnRegexWorker(worker, id2, text, pattern, replacement, deadlineMs),
+    () => {
+      try {
+        return text.replace(new RegExp(pattern, "gu"), replacement);
+      } catch {
+        throw new Error("regex-invalid");
+      }
+    }
+  );
 }
-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);
+async function rewriteRequestBody(input, action, captureContext) {
+  if (!supportedContentType(input.contentType)) {
+    return failure("runtime.request-body-unsupported-mime-type");
   }
-}
-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 (input.contentEncoding !== void 0 && input.contentEncoding !== "identity") {
+    return failure("runtime.request-body-unsupported-content-encoding");
   }
-  if (state.sessions.length >= RUNTIME_LIMITS.maxConcurrentSessions) {
-    return failure("runtime.overloaded");
+  if (input.body.byteLength > RUNTIME_LIMITS.maxRequestBodyBytes) {
+    return failure("runtime.body-too-large");
+  }
+  let text;
+  try {
+    text = new TextDecoder("utf-8", { fatal: true }).decode(input.body);
+  } catch {
+    return failure("runtime.request-body-invalid-utf8");
+  }
+  if (hasLoneSurrogate(text)) {
+    return failure("runtime.request-body-lone-surrogate");
+  }
+  let outputText;
+  if (action.mode === "replace") {
+    if (hasLoneSurrogate(action.body)) {
+      return failure("runtime.request-body-lone-surrogate");
+    }
+    outputText = action.body;
+    if (captureContext !== void 0) {
+      const captures = matchUrlCaptures(
+        captureContext.urlRegex,
+        captureContext.url
+      );
+      if (captures === null) return failure("runtime.url-capture-mismatch");
+      outputText = substituteUrlCaptures(outputText, captures);
+    }
+  } else {
+    if (action.pattern.length === 0) {
+      return failure("runtime.request-body-regex-missing-pattern");
+    }
+    if (action.pattern.length > LIMITS.maxRequestBodyPatternLength) {
+      return failure("runtime.request-body-regex-pattern-too-large");
+    }
+    if (action.replacement.length > LIMITS.maxRequestBodyReplacementLength) {
+      return failure("runtime.request-body-regex-replacement-too-large");
+    }
+    if (hasLoneSurrogate(action.replacement)) {
+      return failure("runtime.request-body-lone-surrogate");
+    }
+    try {
+      outputText = await runRegexReplace(
+        text,
+        action.pattern,
+        action.replacement,
+        RUNTIME_LIMITS.maxRegexDeadlineMs
+      );
+    } catch (error) {
+      if (error instanceof Error && error.message === "deadline") {
+        return failure("runtime.request-body-regex-deadline-exceeded");
+      }
+      return failure("runtime.request-body-regex-invalid");
+    }
+  }
+  const outputBytes = new TextEncoder().encode(outputText);
+  if (outputBytes.byteLength > RUNTIME_LIMITS.maxRequestBodyBytes) {
+    return failure("runtime.request-body-replace-too-large");
   }
-  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
+      body: outputBytes,
+      contentType: input.contentType?.split(";", 1)[0]?.trim() ?? "application/octet-stream"
     }
   };
 }
-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 supportedContentType2(value) {
+  if (value === void 0) return false;
+  const mediaType = value.split(";", 1)[0]?.trim().toLowerCase() ?? "";
+  return mediaType.startsWith("text/") || mediaType === "application/json" || mediaType === "application/javascript" || mediaType === "text/javascript" || mediaType === "text/css" || mediaType === "application/xml" || mediaType === "text/xml";
+}
+async function rewriteResponseBody(input, replacements, replaceAction, captureContext) {
+  if (!supportedContentType2(input.contentType) || input.contentType === void 0)
+    return failure("runtime.size-limit");
+  if (input.contentEncoding !== void 0 && input.contentEncoding !== "identity")
+    return failure("runtime.size-limit");
+  if (input.body.byteLength > RUNTIME_LIMITS.maxResponseBodyBytes || replaceAction === void 0 && replacements.length === 0 || replacements.length > LIMITS.maxResponseBodyReplacements)
+    return failure("runtime.size-limit");
+  let text;
+  try {
+    text = new TextDecoder("utf-8", { fatal: true }).decode(input.body);
+  } catch {
+    return failure("runtime.size-limit");
+  }
+  if (replaceAction !== void 0) {
+    if (captureContext === void 0) {
+      text = replaceAction.body;
+    } else {
+      const captures = matchUrlCaptures(
+        captureContext.urlRegex,
+        captureContext.url
+      );
+      if (captures === null) return failure("runtime.url-capture-mismatch");
+      text = substituteUrlCaptures(replaceAction.body, captures);
     }
   }
-  return null;
-}
-function acquireOperation(_state, session) {
-  if (session.activeOperations >= RUNTIME_LIMITS.maxOperationsPerSession) {
-    return failure("runtime.overloaded");
+  try {
+    for (const entry of replacements) {
+      if (entry.pattern.length === 0 || entry.pattern.length > LIMITS.maxResponseBodyPatternLength || entry.replacement.length > LIMITS.maxResponseBodyReplacementLength)
+        return failure("runtime.size-limit");
+      const regex = new RegExp(entry.pattern, "gu");
+      text = text.replace(regex, entry.replacement);
+      if (new TextEncoder().encode(text).byteLength > RUNTIME_LIMITS.maxResponseBodyBytes)
+        return failure("runtime.size-limit");
+    }
+  } catch {
+    return failure("runtime.invalid-canonical-value");
   }
-  session.activeOperations += 1;
   return {
     ok: true,
-    value: () => {
-      session.activeOperations = Math.max(0, session.activeOperations - 1);
+    value: {
+      body: new TextEncoder().encode(text),
+      contentType: input.contentType.split(";", 1)[0]?.trim() ?? input.contentType
     }
   };
 }
-function closeCapabilityState(state) {
-  state.closed = true;
-  state.consumed = true;
-  state.sessions.length = 0;
-  state.bootstrapDigest.fill(0);
+function originOf(value) {
+  const direct = normalizeSiteOrigin(value);
+  if (direct !== null) return direct;
+  try {
+    return normalizeSiteOrigin(new URL(value).origin);
+  } catch {
+    return null;
+  }
 }
-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 projectHasRule(project, groupId, ruleId) {
+  if (!Array.isArray(project.groups)) return false;
+  const group = project.groups.find((candidate) => candidate.id === groupId);
+  if (group === void 0 || !Array.isArray(group.rules)) return false;
+  return group.rules.some((rule) => rule.id === ruleId);
+}
+function revalidateAuthority(project, operations, request) {
+  const projectSnap = snapshotOwnData3(project);
+  if (!projectSnap.valid) return { allowed: false, reason: "project-invalid" };
+  const opsSnap = snapshotOwnData3(operations);
+  if (!opsSnap.valid) return { allowed: false, reason: "project-invalid" };
+  const reqSnap = snapshotOwnData3(request);
+  if (!reqSnap.valid) return { allowed: false, reason: "project-invalid" };
+  const operation = operations.find(
+    (candidate) => candidate.groupId === request.groupId && candidate.ruleId === request.ruleId && "matcher" in candidate
+  );
+  if (operation === void 0 || !("matcher" in operation)) {
+    return { allowed: false, reason: "operation-unknown" };
   }
-  const capabilities = registeredProvider.detect();
-  if (!capabilities.supported) {
-    return { kind: "unsupported", reasons: capabilities.reasons };
+  if (!projectHasRule(
+    projectSnap.value,
+    request.groupId,
+    request.ruleId
+  )) {
+    return { allowed: false, reason: "project-inconsistent" };
   }
-  if (currentSession !== null) {
-    return { kind: "unsupported", reasons: ["session-collision"] };
+  const matcher = operation.matcher;
+  const regex = compileUrlRegex(matcher.urlRegex.source);
+  if (regex === null || !regex.test(request.url)) {
+    return { allowed: false, reason: "url-mismatch" };
   }
-  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)]
-    };
+  const targetOrigin2 = request.target ? originOf(request.target) : originOf(request.url);
+  if (targetOrigin2 === null || !matcher.origins.includes(targetOrigin2)) {
+    return { allowed: false, reason: "target-unauthorized" };
   }
-  currentSession = {
-    sessionId,
-    provider: registeredProvider,
-    activation,
-    policyDigest,
-    extensionId,
-    pacOrigins,
-    targetPolicy,
-    startedAt: activation.startedAt
+  if (request.initiator !== void 0) {
+    const initiatorOrigin = originOf(request.initiator);
+    if (initiatorOrigin === null || !matcher.origins.includes(initiatorOrigin)) {
+      return { allowed: false, reason: "initiator-unauthorized" };
+    }
+  }
+  if (matcher.method !== void 0) {
+    const method = typeof request.method === "string" ? request.method.toUpperCase() : void 0;
+    if (method !== matcher.method) {
+      return { allowed: false, reason: "method-mismatch" };
+    }
+  }
+  if (matcher.resourceTypes.length > 0) {
+    const resourceType = typeof request.resourceType === "string" ? request.resourceType : void 0;
+    if (resourceType === void 0 || !matcher.resourceTypes.includes(resourceType)) {
+      return { allowed: false, reason: "resource-type-unauthorized" };
+    }
+  }
+  return {
+    allowed: true,
+    groupId: request.groupId,
+    ruleId: request.ruleId,
+    operation
   };
-  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 {
-    }
+function originOf2(url) {
+  try {
+    return normalizeSiteOrigin(new URL(url).origin);
+  } catch {
+    return null;
   }
 }
-function hasActiveSession() {
-  return currentSession !== null;
+function isBodyOp(op) {
+  return op.kind === "request-body" || op.kind === "response-body";
 }
-function withinRoot2(root, candidate) {
-  const rest = relative2(root, candidate);
-  return rest.length > 0 && rest !== ".." && !rest.startsWith(`..${sep}`) && !isAbsolute2(rest);
+function matcherMatches(op, url, method) {
+  const regex = compileUrlRegex(op.matcher.urlRegex.source);
+  if (regex === null || !regex.test(url)) return false;
+  const origin = originOf2(url);
+  if (origin === null || !op.matcher.origins.includes(origin)) return false;
+  if (op.matcher.method !== void 0 && op.matcher.method !== method.toUpperCase()) {
+    return false;
+  }
+  return true;
 }
-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);
+function pickHighest(operations, kind, url, method) {
+  let best = null;
+  for (const op of operations) {
+    if (!isBodyOp(op) || op.kind !== kind) continue;
+    if (!matcherMatches(op, url, method)) continue;
+    if (best === null || op.matcher.priority > best.matcher.priority || op.matcher.priority === best.matcher.priority && op.ruleId.localeCompare(best.ruleId) < 0) {
+      best = op;
+    }
+  }
+  return best;
+}
+function headerValue2(headers, name) {
+  const raw = headers[name];
+  if (Array.isArray(raw)) return raw[0];
+  return raw;
+}
+function readBoundedBody(req, maxBytes) {
+  return new Promise((resolve22) => {
+    const chunks = [];
+    let total = 0;
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      resolve22(result);
+    };
+    req.on("data", (chunk) => {
+      total += chunk.byteLength;
+      if (total > maxBytes) {
+        req.destroy();
+        finish({ ok: false, reason: "oversized" });
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => {
+      finish({ ok: true, body: Buffer.concat(chunks) });
+    });
+    req.on("error", () => {
+      finish({ ok: true, body: Buffer.concat(chunks) });
+    });
+  });
+}
+function hopByHop() {
+  return /* @__PURE__ */ new Set([
+    "connection",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "proxy-connection",
+    "te",
+    "trailer",
+    "transfer-encoding",
+    "upgrade",
+    "content-length"
+  ]);
+}
+function forwardRequestHeaders(headers, host, contentLength) {
+  const skip = hopByHop();
+  const out = {
+    host,
+    "content-length": String(contentLength),
+    connection: "close"
+  };
+  for (const [key, value] of Object.entries(headers)) {
+    if (value === void 0) continue;
+    const lower = key.toLowerCase();
+    if (skip.has(lower) || lower.startsWith("proxy-")) continue;
+    if (lower.startsWith("x-rogatio-dispatch-")) continue;
+    out[key] = Array.isArray(value) ? value.join(", ") : value;
+  }
+  return out;
+}
+function pipeSockets(a, b) {
+  a.pipe(b);
+  b.pipe(a);
+  const closeBoth = () => {
+    a.destroy();
+    b.destroy();
+  };
+  a.on("error", closeBoth);
+  b.on("error", closeBoth);
+  a.on("close", () => b.destroy());
+  b.on("close", () => a.destroy());
+}
+async function upstreamHttp(method, target, headers, body) {
+  const port = target.port ? Number(target.port) : 80;
+  const path2 = `${target.pathname}${target.search}`;
+  return new Promise((resolve22, reject) => {
+    const socket = connect(port, target.hostname);
+    let buf = Buffer.alloc(0);
+    let settled = false;
+    const fail = (err) => {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      reject(err);
+    };
+    socket.setTimeout(RUNTIME_LIMITS.operationTimeoutMs);
+    socket.on("timeout", () => fail(new Error("upstream timeout")));
+    socket.on("error", (err) => fail(err));
+    socket.on("connect", () => {
+      const lines = Object.entries(headers).map(([k, v]) => `${k}: ${v}`).join("\r\n");
+      socket.write(`${method} ${path2} HTTP/1.1\r
+${lines}\r
+\r
+`);
+      if (body.byteLength > 0) socket.write(body);
+    });
+    socket.on("data", (chunk) => {
+      const piece = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      buf = Buffer.concat([buf, piece]);
+      const sep2 = buf.indexOf("\r\n\r\n");
+      if (sep2 < 0) return;
+      const head = buf.subarray(0, sep2).toString("latin1");
+      const statusMatch = /^HTTP\/1\.[01] (\d+)(?: (.*))?/.exec(
+        head.split("\r\n")[0] ?? ""
+      );
+      if (!statusMatch) {
+        fail(new Error("bad upstream status"));
+        return;
+      }
+      const status = Number(statusMatch[1]);
+      const statusMessage = statusMatch[2]?.trim() ?? "";
+      const headerMap = {};
+      for (const line of head.split("\r\n").slice(1)) {
+        const i = line.indexOf(":");
+        if (i <= 0) continue;
+        const name = line.slice(0, i).trim().toLowerCase();
+        const value = line.slice(i + 1).trim();
+        const existing = headerMap[name];
+        if (existing === void 0) headerMap[name] = value;
+        else if (Array.isArray(existing)) existing.push(value);
+        else headerMap[name] = [existing, value];
+      }
+      const clRaw = headerMap["content-length"];
+      const hasContentLength = clRaw !== void 0;
+      const cl = typeof clRaw === "string" ? Number(clRaw) : Array.isArray(clRaw) ? Number(clRaw[0]) : Number.NaN;
+      const bodyStart = sep2 + 4;
+      if (hasContentLength && Number.isFinite(cl) && cl >= 0) {
+        if (buf.length - bodyStart < cl) return;
+        if (settled) return;
+        settled = true;
+        socket.destroy();
+        resolve22({
+          status,
+          statusMessage,
+          headers: headerMap,
+          body: buf.subarray(bodyStart, bodyStart + cl)
+        });
+        return;
+      }
+    });
+    socket.on("end", () => {
+      if (settled) return;
+      const sep2 = buf.indexOf("\r\n\r\n");
+      if (sep2 < 0) {
+        fail(new Error("upstream closed early"));
+        return;
+      }
+      const head = buf.subarray(0, sep2).toString("latin1");
+      const statusMatch = /^HTTP\/1\.[01] (\d+)(?: (.*))?/.exec(
+        head.split("\r\n")[0] ?? ""
+      );
+      if (!statusMatch) {
+        fail(new Error("bad upstream status"));
+        return;
+      }
+      const headerMap = {};
+      for (const line of head.split("\r\n").slice(1)) {
+        const i = line.indexOf(":");
+        if (i <= 0) continue;
+        headerMap[line.slice(0, i).trim().toLowerCase()] = line.slice(i + 1).trim();
+      }
+      let body2 = Buffer.from(buf.subarray(sep2 + 4));
+      const te = headerMap["transfer-encoding"];
+      const teValue = Array.isArray(te) ? te[0] : te;
+      if (typeof teValue === "string" && teValue.toLowerCase().includes("chunked")) {
+        body2 = Buffer.from(decodeChunkedBody(body2));
+        delete headerMap["transfer-encoding"];
+        headerMap["content-length"] = String(body2.byteLength);
+      }
+      settled = true;
+      resolve22({
+        status: Number(statusMatch[1]),
+        statusMessage: statusMatch[2]?.trim() ?? "",
+        headers: headerMap,
+        body: body2
+      });
+    });
+  });
+}
+function decodeChunkedBody(buf) {
+  const parts = [];
+  let offset = 0;
+  while (offset < buf.length) {
+    const lineEnd = buf.indexOf("\r\n", offset);
+    if (lineEnd < 0) break;
+    const size = Number.parseInt(
+      buf.subarray(offset, lineEnd).toString("ascii"),
+      16
+    );
+    if (!Number.isFinite(size) || size < 0) break;
+    offset = lineEnd + 2;
+    if (size === 0) break;
+    parts.push(buf.subarray(offset, offset + size));
+    offset += size + 2;
+  }
+  return Buffer.from(Buffer.concat(parts));
+}
+function writeResponse(res, status, statusMessage, headers, body) {
+  const skip = hopByHop();
+  const out = {
+    "content-length": body.byteLength
+  };
+  for (const [key, value] of Object.entries(headers)) {
+    if (skip.has(key) || key.startsWith("proxy-")) continue;
+    out[key] = value;
+  }
+  res.writeHead(status, statusMessage, out);
+  res.end(body);
+}
+function authorizeOp(policy, op, url, method) {
+  const resourceType = op.matcher.resourceTypes[0];
+  const decision = revalidateAuthority(policy.project, policy.operations, {
+    groupId: op.groupId,
+    ruleId: op.ruleId,
+    url,
+    method,
+    ...resourceType !== void 0 ? { resourceType } : {}
+  });
+  return decision.allowed;
+}
+async function startInterceptProxy(options = {}) {
+  let policy = options.policy ?? null;
+  const server = createServer((req, res) => {
+    void handleHttp(req, res);
+  });
+  server.on("connect", (req, clientSocket, head) => {
+    handleConnect(req, clientSocket, head);
+  });
+  async function handleHttp(req, res) {
+    try {
+      const targetUrl = req.url ?? "";
+      if (!/^https?:\/\//i.test(targetUrl)) {
+        res.writeHead(400);
+        res.end();
+        return;
+      }
+      let target;
+      try {
+        target = new URL(targetUrl);
+      } catch {
+        res.writeHead(400);
+        res.end();
+        return;
+      }
+      if (target.protocol !== "http:") {
+        res.writeHead(501);
+        res.end();
+        return;
+      }
+      const method = (req.method ?? "GET").toUpperCase();
+      const active = policy;
+      const requestOp = active === null ? null : pickHighest(
+        active.operations,
+        "request-body",
+        targetUrl,
+        method
+      );
+      const responseOp = active === null ? null : pickHighest(
+        active.operations,
+        "response-body",
+        targetUrl,
+        method
+      );
+      const needsRequestBody = requestOp !== null;
+      const bodyResult = await readBoundedBody(
+        req,
+        RUNTIME_LIMITS.maxRequestBodyBytes
+      );
+      if (!bodyResult.ok) {
+        if (!res.headersSent) {
+          res.writeHead(413);
+          res.end();
+        }
+        return;
+      }
+      let requestBody = bodyResult.body;
+      if (needsRequestBody && requestOp !== null && active !== null) {
+        if (!authorizeOp(active, requestOp, targetUrl, method)) {
+        } else {
+          const rewritten = await rewriteRequestBody(
+            {
+              contentType: headerValue2(req.headers, "content-type"),
+              contentEncoding: headerValue2(req.headers, "content-encoding") ?? "identity",
+              body: new Uint8Array(requestBody)
+            },
+            requestOp.requestBody,
+            {
+              url: targetUrl,
+              urlRegex: requestOp.matcher.urlRegex.source
+            }
+          );
+          if (rewritten.ok) {
+            requestBody = Buffer.from(rewritten.value.body);
+          }
+        }
+      }
+      const forwardHeaders = forwardRequestHeaders(
+        req.headers,
+        target.host,
+        requestBody.byteLength
+      );
+      const upstream = await upstreamHttp(
+        method,
+        target,
+        forwardHeaders,
+        requestBody
+      );
+      let responseBody = upstream.body;
+      if (responseOp !== null && active !== null) {
+        if (responseBody.byteLength > RUNTIME_LIMITS.maxResponseBodyBytes) {
+        } else if (!authorizeOp(active, responseOp, targetUrl, method)) {
+        } else {
+          const action = responseOp.responseBody;
+          const isReplace = "mode" in action && action.mode === "replace";
+          const rewritten = await rewriteResponseBody(
+            {
+              contentType: typeof upstream.headers["content-type"] === "string" ? upstream.headers["content-type"] : Array.isArray(upstream.headers["content-type"]) ? upstream.headers["content-type"][0] : void 0,
+              contentEncoding: typeof upstream.headers["content-encoding"] === "string" ? upstream.headers["content-encoding"] : "identity",
+              body: new Uint8Array(responseBody)
+            },
+            "replacements" in action && Array.isArray(action.replacements) ? action.replacements : [],
+            isReplace ? action : void 0,
+            {
+              url: targetUrl,
+              urlRegex: responseOp.matcher.urlRegex.source
+            }
+          );
+          if (rewritten.ok) {
+            responseBody = Buffer.from(rewritten.value.body);
+          }
+        }
+      }
+      writeResponse(
+        res,
+        upstream.status,
+        upstream.statusMessage,
+        upstream.headers,
+        responseBody
+      );
+    } catch {
+      if (!res.headersSent) {
+        res.writeHead(502);
+        res.end();
+      }
+    }
+  }
+  function handleConnect(req, clientSocket, head) {
+    const authority = req.url ?? "";
+    const [host, portText] = authority.split(":");
+    const port = Number(portText);
+    if (!host || !Number.isInteger(port) || port <= 0) {
+      clientSocket.write("HTTP/1.1 400 Bad Request\r\n\r\n");
+      clientSocket.destroy();
+      return;
+    }
+    const upstream = connect(port, host);
+    upstream.on("connect", () => {
+      clientSocket.write("HTTP/1.1 200 Connection Established\r\n\r\n");
+      if (head.byteLength > 0) upstream.write(head);
+      pipeSockets(clientSocket, upstream);
+    });
+    upstream.on("error", () => {
+      clientSocket.write("HTTP/1.1 502 Bad Gateway\r\n\r\n");
+      clientSocket.destroy();
+    });
+    clientSocket.on("error", () => upstream.destroy());
+  }
+  const endpoint = await new Promise((resolve22, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (!addr || typeof addr === "string") {
+        reject(new Error("intercept-proxy bind failed"));
+        return;
+      }
+      resolve22({ host: "127.0.0.1", port: addr.port });
+    });
+  });
+  return {
+    endpoint,
+    setPolicy(next) {
+      policy = next;
+    },
+    async stop() {
+      await new Promise((resolve22, reject) => {
+        server.close((err) => err ? reject(err) : resolve22());
+      });
+    }
+  };
+}
+function generatePacScript(origins, endpoint, options) {
+  if (!Array.isArray(origins)) {
+    throw new Error("pac origins must be an array");
+  }
+  const valid = [];
+  for (const origin of origins) {
+    const normalized = normalizeSiteOrigin(origin);
+    if (normalized !== null) valid.push(normalized);
+  }
+  const unique = Array.from(new Set(valid)).sort();
+  if (unique.length > MAX_PAC_ORIGINS) {
+    throw new Error("pac origin count exceeds maximum");
+  }
+  const proxyType = options?.proxyType ?? "PROXY";
+  const proxy = `${proxyType} ${endpoint.host}:${endpoint.port}`;
+  const originsLiteral = JSON.stringify(unique);
+  const proxyLiteral = JSON.stringify(proxy);
+  return [
+    "function FindProxyForURL(url, host) {",
+    `  var origins = ${originsLiteral};`,
+    "  var origin = null;",
+    "  try { origin = new URL(url).origin; } catch (e) { origin = null; }",
+    "  if (origin !== null && origins.indexOf(origin) !== -1) {",
+    `    return ${proxyLiteral};`,
+    "  }",
+    "  return 'DIRECT';",
+    "}"
+  ].join("\n");
+}
+var registeredProvider = null;
+var currentSession = null;
+function registerInterceptionProvider(provider) {
+  registeredProvider = provider;
+}
+function getCurrentSession() {
+  return currentSession;
+}
+async function startInterception(activation, policyDigest, extensionId, pacOrigins, targetPolicy) {
+  if (registeredProvider === null) {
+    return { kind: "unsupported", reasons: ["no-interception-provider"] };
+  }
+  const capabilities = registeredProvider.detect();
+  if (!capabilities.supported) {
+    return { kind: "unsupported", reasons: capabilities.reasons };
+  }
+  if (currentSession !== null) {
+    return { kind: "unsupported", reasons: ["session-collision"] };
+  }
+  const sessionId = `session-${activation.startedAt}-${Math.random().toString(36).slice(2)}`;
+  let proxy;
+  try {
+    const started = await registeredProvider.start(activation);
+    if (started && typeof started === "object" && typeof started.host === "string" && typeof started.port === "number") {
+      proxy = started;
+    } else if (activation.proxy) {
+      proxy = activation.proxy;
+    } else {
+      return {
+        kind: "unsupported",
+        reasons: ["provider-start-failed", "missing-proxy-endpoint"]
+      };
+    }
+  } catch (error) {
+    return {
+      kind: "unsupported",
+      reasons: ["provider-start-failed", String(error)]
+    };
+  }
+  currentSession = {
+    sessionId,
+    provider: registeredProvider,
+    activation: { ...activation, proxy, pacOrigins },
+    policyDigest,
+    extensionId,
+    pacOrigins,
+    targetPolicy,
+    startedAt: activation.startedAt
+  };
+  return { kind: "active", provider: registeredProvider.platform, proxy };
+}
+async function stopInterception() {
+  if (currentSession === null && registeredProvider === null) return;
+  const session = currentSession;
+  currentSession = null;
+  if (session?.provider) {
+    try {
+      await session.provider.stop();
+    } catch {
+    }
+  }
+}
+function hasActiveSession() {
+  return currentSession !== null;
+}
+function clearSession() {
+  currentSession = null;
+}
+function unsupportedReasons(capabilities) {
+  const reasons = [...capabilities.reasons];
+  if (!capabilities.trustedDeviceLocalCa)
+    reasons.push("device-local-ca-untrusted");
+  if (capabilities.controllingProxy) reasons.push("controlling-proxy");
+  if (capabilities.controllingPac) reasons.push("controlling-pac");
+  if (capabilities.controllingExtension) reasons.push("controlling-extension");
+  if (capabilities.enterprisePolicy) reasons.push("enterprise-policy");
+  return [...new Set(reasons)].sort();
+}
+function createPlatformInterceptionProvider(adapter) {
+  let state = "stopped";
+  let active = false;
+  return {
+    platform: adapter.platform,
+    detect() {
+      const capabilities = adapter.detect();
+      const reasons = unsupportedReasons(capabilities);
+      return {
+        supported: capabilities.supported && reasons.length === 0,
+        reasons
+      };
+    },
+    async start(activation, origins) {
+      const capabilities = adapter.detect();
+      const reasons = unsupportedReasons(capabilities);
+      if (!capabilities.supported || reasons.length > 0) {
+        state = "unsupported";
+        throw new Error("runtime.platform-unsupported");
+      }
+      if (!await adapter.provisionOrVerifyCa()) {
+        state = "unsupported";
+        throw new Error("runtime.platform-unsupported");
+      }
+      const endpoint = await adapter.startTlsProxy(activation);
+      const pac = generatePacScript(origins, endpoint);
+      try {
+        await adapter.installPac(pac);
+        active = true;
+        state = "running";
+        return endpoint;
+      } catch (error) {
+        await adapter.stopTlsProxy();
+        active = false;
+        state = "stopped";
+        throw error;
+      }
+    },
+    async stop() {
+      if (!active && state !== "running") {
+        state = state === "unsupported" ? "unsupported" : "stopped";
+        return;
+      }
+      await adapter.removePac();
+      await adapter.stopTlsProxy();
+      active = false;
+      state = "stopped";
+    },
+    status() {
+      return state;
+    }
+  };
+}
+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 digestToken(value) {
+  return createHash("sha256").update(value, "utf8").digest();
+}
+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;
+  }
+}
+function sameToken(value, expectedDigest) {
+  const actual = digestToken(value);
+  return actual.length === expectedDigest.length && timingSafeEqual(actual, expectedDigest);
+}
+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 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 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 (state.sessions.length >= RUNTIME_LIMITS.maxConcurrentSessions) {
+    return failure("runtime.overloaded");
+  }
+  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 null;
+}
+function acquireOperation(_state, session) {
+  if (session.activeOperations >= RUNTIME_LIMITS.maxOperationsPerSession) {
+    return failure("runtime.overloaded");
+  }
+  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);
+}
+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");
@@ -21756,8 +22763,8 @@ function normalizeMockConfig(value, matcherById) {
     if (!Array.isArray(record.headers) || record.headers.length > LIMITS.maxMockHeadersPerRule)
       return null;
     const normalizedHeaders = [];
-    for (const headerValue2 of record.headers) {
-      const header = normalizeMockHeader(headerValue2);
+    for (const headerValue3 of record.headers) {
+      const header = normalizeMockHeader(headerValue3);
       if (header === null) return null;
       normalizedHeaders.push(header);
     }
@@ -22046,14 +23053,72 @@ function createNativeRuntimeController(options) {
   let state = "idle";
   let activation;
   let capability;
+  let activePolicy = null;
   const mockTokens = /* @__PURE__ */ new Map();
   let aiClient;
   if (options.aiProviderConfig) {
     aiClient = createAIClient(options.aiProviderConfig);
   }
+  async function bindInterception(current, sessionConfig) {
+    if (sessionConfig.pacOrigins.length === 0) {
+      return {
+        activation: { ...current, pacOrigins: [] },
+        session: null,
+        interception: { active: false, reasons: ["no-pac-origins"] }
+      };
+    }
+    if (hasActiveSession()) {
+      const session2 = getCurrentSession();
+      return {
+        activation: current,
+        session: session2,
+        interception: {
+          active: session2 !== null,
+          reasons: session2 !== null ? [] : ["session-missing"]
+        }
+      };
+    }
+    const result = await startInterception(
+      current,
+      sessionConfig.policyDigest,
+      sessionConfig.extensionId,
+      sessionConfig.pacOrigins,
+      {
+        public: sessionConfig.targetPolicy.public,
+        localOrigins: sessionConfig.targetPolicy.localOrigins
+      }
+    );
+    if (result.kind === "unsupported") {
+      return {
+        activation: current,
+        session: null,
+        interception: { active: false, reasons: [...result.reasons] }
+      };
+    }
+    const session = getCurrentSession();
+    const next = {
+      ...current,
+      pacOrigins: sessionConfig.pacOrigins,
+      proxy: result.proxy
+    };
+    return {
+      activation: next,
+      session,
+      interception: { active: true, reasons: [] }
+    };
+  }
   return {
     async start(sessionConfig) {
       if (state === "running" || state === "starting") {
+        if (sessionConfig && activation) {
+          const bound = await bindInterception(activation, sessionConfig);
+          activation = bound.activation;
+          return {
+            state: "running",
+            activation,
+            session: bound.session
+          };
+        }
         if (activation) return { state: "running", activation };
         return { state };
       }
@@ -22070,22 +23135,13 @@ function createNativeRuntimeController(options) {
         state: "running",
         startedAt,
         presetDigest: preset.digest,
-        pacOrigins: []
+        pacOrigins: sessionConfig?.pacOrigins ?? []
       };
       let session = null;
       if (sessionConfig) {
-        const result = await startInterception(
-          activation,
-          sessionConfig.policyDigest,
-          sessionConfig.extensionId,
-          sessionConfig.pacOrigins,
-          sessionConfig.targetPolicy
-        );
-        if (result.kind !== "unsupported") {
-          session = hasActiveSession() ? getCurrentSession2() : null;
-          if (session)
-            activation = { ...activation, pacOrigins: session.pacOrigins };
-        }
+        const bound = await bindInterception(activation, sessionConfig);
+        activation = bound.activation;
+        session = bound.session;
       }
       if (options.onStart) await options.onStart(activation, session);
       state = "running";
@@ -22105,6 +23161,7 @@ function createNativeRuntimeController(options) {
       if (capability) closeCapabilityState(capability);
       mockTokens.clear();
       activation = void 0;
+      activePolicy = null;
       state = "stopped";
       return { state: "stopped" };
     },
@@ -22112,7 +23169,10 @@ function createNativeRuntimeController(options) {
       return { state };
     },
     getSession() {
-      return hasActiveSession() ? getCurrentSession2() : null;
+      return hasActiveSession() ? getCurrentSession() : null;
+    },
+    getActivePolicy() {
+      return activePolicy;
     },
     async serveMock(token) {
       const mock = mockTokens.get(token);
@@ -22207,6 +23267,10 @@ function createNativeRuntimeController(options) {
           };
         }
         preset = normalized.value;
+        activePolicy = {
+          project: schemaResult.data,
+          operations: compileResult.operations
+        };
         const startResult = await this.start();
         if (startResult.state !== "running") {
           return {
@@ -22225,6 +23289,64 @@ function createNativeRuntimeController(options) {
           metadata: { ok: true, presetDigest: preset.digest }
         };
       }
+      if (input.type === "runtime.project.set" && state === "running") {
+        return {
+          protocol: "v1",
+          type: "runtime.project.set",
+          ...requestId !== void 0 ? { requestId } : {},
+          timestamp,
+          metadata: { ok: false, error: "runtime.already-started" }
+        };
+      }
+      if (input.type === "runtime.start") {
+        if (state === "idle" || !preset || activation === void 0) {
+          return {
+            protocol: "v1",
+            type: "runtime.start",
+            ...requestId !== void 0 ? { requestId } : {},
+            timestamp,
+            metadata: {
+              ok: false,
+              error: "runtime.not-ready",
+              interception: { active: false, reasons: ["not-ready"] }
+            }
+          };
+        }
+        const meta = input.metadata;
+        const sessionConfig = {
+          policyDigest: typeof meta.policyDigest === "string" ? meta.policyDigest : "",
+          extensionId: typeof meta.extensionId === "string" ? meta.extensionId : "",
+          pacOrigins: Array.isArray(meta.pacOrigins) ? meta.pacOrigins : [],
+          targetPolicy: {
+            public: meta.targetPolicy?.public === true || meta.targetPolicy?.publicAllowed === true,
+            localOrigins: Array.isArray(meta.targetPolicy?.localOrigins) ? meta.targetPolicy.localOrigins : []
+          }
+        };
+        const bound = await bindInterception(activation, sessionConfig);
+        activation = bound.activation;
+        return {
+          protocol: "v1",
+          type: "runtime.start",
+          ...requestId !== void 0 ? { requestId } : {},
+          timestamp,
+          metadata: {
+            ok: bound.interception.active,
+            interception: bound.interception,
+            ...activation.proxy !== void 0 ? { proxy: activation.proxy } : {},
+            pacOrigins: activation.pacOrigins
+          }
+        };
+      }
+      if (input.type === "runtime.stop") {
+        await this.stop();
+        return {
+          protocol: "v1",
+          type: "runtime.stop",
+          ...requestId !== void 0 ? { requestId } : {},
+          timestamp,
+          metadata: { ok: true, state: "stopped" }
+        };
+      }
       if (state !== "running" || capability === void 0) {
         throw new Error("runtime not started");
       }
@@ -22512,200 +23634,18 @@ function createNativeRuntimeController(options) {
       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.aiProviderConfig !== void 0 ? { aiProviderConfig: options.aiProviderConfig } : {},
-    ...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;
-      }
-    }
-  };
-}
-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");
-        }
-      }
-    })();
-  });
-  await new Promise((resolve22) => {
-    stdin.on("end", () => {
-      void host.stop().then(resolve22);
-    });
-  });
-}
-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") },
-  { start: ipToInt("192.168.0.0"), end: ipToInt("192.168.255.255") },
-  { start: ipToInt("127.0.0.0"), end: ipToInt("127.255.255.255") },
-  { start: ipToInt("169.254.0.0"), end: ipToInt("169.254.255.255") },
-  { start: ipToInt("0.0.0.0"), end: ipToInt("0.255.255.255") },
-  { start: ipToInt("224.0.0.0"), end: ipToInt("239.255.255.255") },
-  { start: ipToInt("240.0.0.0"), end: ipToInt("255.255.255.255") }
-];
-function ipToInt(ip) {
-  const parts = ip.split(".").map(Number);
-  return parts[0] << 24 | parts[1] << 16 | parts[2] << 8 | parts[3];
+      status: rendered.value.status,
+      headers,
+      mockBody: base64(rendered.value.bodyBytes)
+    };
+    return {
+      protocol: "v1",
+      type: "mock.response",
+      ...requestId !== void 0 ? { requestId } : {},
+      timestamp,
+      metadata
+    };
+  }
 }
 var import_reflect_metadata = __toESM(require_Reflect(), 1);
 var import_x509 = __toESM(require_x509_cjs(), 1);
@@ -22742,7 +23682,7 @@ async function createCertificate(subjectName, _privateKey, validityDays) {
   return { certPem, keyPem };
 }
 function generateCaKeyPair(bits = 2048) {
-  return generateKeyPairSync2("rsa", { modulusLength: bits });
+  return generateKeyPairSync("rsa", { modulusLength: bits });
 }
 var TRUST_LIMITS = {
   manifestMaxBytes: 4096,
@@ -23067,6 +24007,323 @@ function createRequestBodyTrustController(options = {}) {
   }
   return { install, uninstall, status, verify };
 }
+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 = createServer2((req, res) => {
+    void (async () => {
+      try {
+        const url = new URL(req.url ?? "", "http://localhost");
+        const match = /^\/mock\/([a-f0-9]+)$/.exec(url.pathname);
+        if (!match || req.method !== "GET") {
+          res.writeHead(404);
+          res.end();
+          return;
+        }
+        const result = await controller.serveMock(match[1]);
+        if (!result.ok) {
+          res.writeHead(404);
+          res.end();
+          return;
+        }
+        const { status, headers, bodyBytes } = result.value;
+        res.writeHead(
+          status,
+          Object.fromEntries(
+            headers.map((h) => [h[0], h[1]])
+          )
+        );
+        res.end(Buffer2.from(bodyBytes));
+      } catch {
+        if (!res.headersSent) res.writeHead(500);
+        res.end();
+      }
+    })();
+  });
+  return new Promise(
+    (resolve22) => server.listen(port, () => resolve22(server))
+  );
+}
+function defaultTrustRoot() {
+  return defaultTrustInstallRoot(process.platform);
+}
+function createNativeHost(options) {
+  const controller = createNativeRuntimeController({
+    preset: options.preset,
+    fileRoot: options.fileRoot,
+    ...options.mockPort !== void 0 ? { mockPort: options.mockPort } : {},
+    ...options.aiProviderConfig !== void 0 ? { aiProviderConfig: options.aiProviderConfig } : {},
+    ...options.clock ? { clock: options.clock } : {}
+  });
+  let faucet = null;
+  let interceptProxy = null;
+  let outboundWrite = null;
+  let hostRequestCounter = 0;
+  const pendingHost = /* @__PURE__ */ new Map();
+  function sendHostRequest(type, metadata) {
+    const requestId = `host-${++hostRequestCounter}`;
+    const envelope = {
+      protocol: "v1",
+      type,
+      requestId,
+      timestamp: Date.now(),
+      metadata
+    };
+    return new Promise((resolve22, reject) => {
+      if (!outboundWrite) {
+        reject(new Error("host stdout not attached"));
+        return;
+      }
+      pendingHost.set(requestId, { resolve: resolve22, reject });
+      try {
+        outboundWrite(encodeEnvelopeFrame(envelope));
+      } catch (error) {
+        pendingHost.delete(requestId);
+        reject(error instanceof Error ? error : new Error(String(error)));
+        return;
+      }
+      setTimeout(() => {
+        if (pendingHost.has(requestId)) {
+          pendingHost.delete(requestId);
+          reject(new Error("host pac request timed out"));
+        }
+      }, 1e4);
+    });
+  }
+  const trustRoot = options.trustRoot ?? defaultTrustRoot();
+  const caKeyFile = join3(trustRoot, ".rogatio-ca.key");
+  const caCertFile = join3(trustRoot, ".rogatio-ca.crt");
+  const platformAdapter = {
+    platform: process.platform,
+    detect() {
+      const trusted = existsSync(caKeyFile) && existsSync(caCertFile);
+      return {
+        supported: true,
+        reasons: [],
+        trustedDeviceLocalCa: trusted,
+        controllingProxy: false,
+        controllingPac: false,
+        controllingExtension: false,
+        enterprisePolicy: false
+      };
+    },
+    async provisionOrVerifyCa() {
+      return existsSync(caKeyFile) && existsSync(caCertFile);
+    },
+    async installPac(script) {
+      const response = await sendHostRequest("runtime.pac.install", {
+        script
+      });
+      if (response.metadata.ok !== true) {
+        const error = typeof response.metadata.error === "string" ? response.metadata.error : "pac-install-failed";
+        throw new Error(error);
+      }
+    },
+    async removePac() {
+      try {
+        await sendHostRequest("runtime.pac.remove", {});
+      } catch {
+      }
+    },
+    async startTlsProxy() {
+      if (interceptProxy) {
+        await interceptProxy.stop();
+        interceptProxy = null;
+      }
+      const policy = controller.getActivePolicy();
+      interceptProxy = await startInterceptProxy({
+        policy: policy ? { project: policy.project, operations: policy.operations } : null
+      });
+      return interceptProxy.endpoint;
+    },
+    async stopTlsProxy() {
+      if (interceptProxy) {
+        await interceptProxy.stop();
+        interceptProxy = null;
+      }
+    }
+  };
+  const platformProvider = createPlatformInterceptionProvider(platformAdapter);
+  let pendingOrigins = [];
+  registerInterceptionProvider({
+    platform: platformProvider.platform,
+    detect: () => platformProvider.detect(),
+    async start(activation) {
+      const origins = pendingOrigins.length > 0 ? pendingOrigins : activation.pacOrigins;
+      const endpoint = await platformProvider.start(activation, origins);
+      const policy = controller.getActivePolicy();
+      interceptProxy?.setPolicy(
+        policy ? { project: policy.project, operations: policy.operations } : null
+      );
+      return endpoint;
+    },
+    async stop() {
+      await platformProvider.stop();
+    }
+  });
+  const handle = {
+    controller,
+    mockPort: options.mockPort ?? null,
+    async start() {
+      await controller.start();
+      if (options.mockPort !== void 0) {
+        faucet = await startMockFaucet(options.mockPort, controller);
+      }
+    },
+    async stop() {
+      if (faucet) {
+        await new Promise((resolve22) => faucet?.close(() => resolve22()));
+        faucet = null;
+      }
+      await controller.stop();
+      clearSession();
+      if (interceptProxy) {
+        await interceptProxy.stop();
+        interceptProxy = null;
+      }
+    },
+    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;
+      }
+      if (typeof envelope.requestId === "string" && envelope.requestId.startsWith("host-")) {
+        const pending = pendingHost.get(envelope.requestId);
+        if (pending) {
+          pendingHost.delete(envelope.requestId);
+          pending.resolve(envelope);
+          return null;
+        }
+      }
+      if (envelope.type === "runtime.start") {
+        const origins = envelope.metadata.pacOrigins;
+        pendingOrigins = Array.isArray(origins) ? origins.filter((o) => typeof o === "string") : [];
+      }
+      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;
+      }
+    }
+  };
+  Object.defineProperty(handle, "__setOutboundWrite", {
+    value(write) {
+      outboundWrite = write;
+    },
+    enumerable: false
+  });
+  return handle;
+}
+async function runNativeHost(options) {
+  const host = createNativeHost(options);
+  const setOutbound = host.__setOutboundWrite;
+  const stdout = options.stdout ?? process.stdout;
+  if (setOutbound) {
+    setOutbound((frame) => {
+      if (stdout.writable) stdout.write(Buffer2.from(frame));
+    });
+  }
+  await host.start();
+  const stdin = options.stdin ?? process.stdin;
+  if (options.onReady) options.onReady();
+  let buffer = Buffer2.alloc(0);
+  stdin.on("data", (chunk) => {
+    const buf = Buffer2.isBuffer(chunk) ? Buffer2.from(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");
+        }
+      }
+    })();
+  });
+  await new Promise((resolve22) => {
+    stdin.on("end", () => {
+      void host.stop().then(resolve22);
+    });
+  });
+}
+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") },
+  { start: ipToInt("192.168.0.0"), end: ipToInt("192.168.255.255") },
+  { start: ipToInt("127.0.0.0"), end: ipToInt("127.255.255.255") },
+  { start: ipToInt("169.254.0.0"), end: ipToInt("169.254.255.255") },
+  { start: ipToInt("0.0.0.0"), end: ipToInt("0.255.255.255") },
+  { start: ipToInt("224.0.0.0"), end: ipToInt("239.255.255.255") },
+  { start: ipToInt("240.0.0.0"), end: ipToInt("255.255.255.255") }
+];
+function ipToInt(ip) {
+  const parts = ip.split(".").map(Number);
+  return parts[0] << 24 | parts[1] << 16 | parts[2] << 8 | parts[3];
+}
 var darwinAdapter = {
   platform: "darwin",
   defaultManifestDir: () => {
@@ -23108,7 +24365,7 @@ var darwinAdapter = {
   },
   async caTrustInstaller(certPem) {
     const keychain = this.defaultCaInstallPath();
-    const tmpPath = join3(tmpdir(), `rogatio-ca-${Date.now()}.crt`);
+    const tmpPath = join4(tmpdir(), `rogatio-ca-${Date.now()}.crt`);
     try {
       writeFileSync(tmpPath, certPem, "utf8");
     } catch {
@@ -23340,7 +24597,7 @@ var win32Adapter = {
     };
   },
   async caTrustInstaller(certPem) {
-    const tmpPath = join4(tmpdir2(), `rogatio-ca-${Date.now()}.crt`);
+    const tmpPath = join5(tmpdir2(), `rogatio-ca-${Date.now()}.crt`);
     try {
       writeFileSync2(tmpPath, certPem, "utf8");
     } catch {
@@ -23526,36 +24783,78 @@ Options:
 }
 
 // packages/cli/src/commands/ai.ts
+var pendingInput = "";
+function readLine() {
+  return new Promise((resolve9) => {
+    const take = () => {
+      const newline = pendingInput.search(/[\r\n]/u);
+      if (newline === -1) return false;
+      const line = pendingInput.slice(0, newline);
+      pendingInput = pendingInput.slice(newline + 1);
+      resolve9(line);
+      return true;
+    };
+    if (take()) return;
+    const onData = (chunk) => {
+      pendingInput += chunk.toString();
+      if (!take()) return;
+      process.stdin.off("data", onData);
+      process.stdin.pause();
+    };
+    process.stdin.on("data", onData);
+    process.stdin.resume();
+  });
+}
 async function promptInput(prompt) {
   process.stdout.write(prompt);
-  for await (const chunk of process.stdin) {
-    return chunk.toString().trim();
-  }
-  return "";
+  return (await readLine()).trim();
 }
 async function promptSecret(prompt) {
   process.stdout.write(prompt);
   process.stdin.setRawMode(true);
-  let input = "";
-  for await (const chunk of process.stdin) {
-    const char = chunk.toString();
-    if (char === "\n" || char === "\r") {
-      process.stdout.write("\n");
-      break;
-    } else if (char === "") {
-      process.exit(1);
-    } else if (char === "\x7F" || char === "\b") {
-      if (input.length > 0) {
-        input = input.slice(0, -1);
-        process.stdout.write("\b \b");
-      }
-    } else {
-      input += char;
-      process.stdout.write("*");
-    }
+  try {
+    return await new Promise((resolve9) => {
+      let input = "";
+      let settled = false;
+      const finish = () => {
+        settled = true;
+        process.stdin.off("data", onData);
+        process.stdin.pause();
+        resolve9(input.trim());
+      };
+      const consume = (text) => {
+        if (settled) return;
+        for (let index = 0; index < text.length; index += 1) {
+          const char = text[index];
+          if (char === "\n" || char === "\r") {
+            process.stdout.write("\n");
+            pendingInput = text.slice(index + 1);
+            finish();
+            return;
+          }
+          if (char === "") {
+            process.exit(1);
+          } else if (char === "\x7F" || char === "\b") {
+            if (input.length > 0) {
+              input = input.slice(0, -1);
+              process.stdout.write("\b \b");
+            }
+          } else {
+            input += char;
+            process.stdout.write("*");
+          }
+        }
+      };
+      const onData = (chunk) => consume(chunk.toString());
+      consume(pendingInput);
+      if (settled) return;
+      pendingInput = "";
+      process.stdin.on("data", onData);
+      process.stdin.resume();
+    });
+  } finally {
+    process.stdin.setRawMode(false);
   }
-  process.stdin.setRawMode(false);
-  return input.trim();
 }
 async function aiCommand(args) {
   if (args.includes("--help") || args.includes("-h")) {
@@ -23718,7 +25017,7 @@ var HttpServerError = class extends Error {
     this.code = code;
   }
 };
-function createServer2(handler, options = {}) {
+function createServer3(handler, options = {}) {
   const server = createHttpServer(handler);
   const preferredPort = options.port;
   let port = null;
@@ -24786,7 +26085,7 @@ import {
   unlink as unlink2,
   writeFile as writeFile3
 } from "node:fs/promises";
-import { basename as basename2, dirname as dirname6, join as join5 } from "node:path";
+import { basename as basename2, dirname as dirname6, join as join6 } from "node:path";
 var ProjectStorageError = class extends Error {
   code;
   id;
@@ -24949,7 +26248,7 @@ async function isDirectoryPath(id2) {
 }
 async function writeDocument(id2, data) {
   const tempName = `.${basename2(dirname6(id2))}.${randomBytes4(8).toString("hex")}.tmp`;
-  const tempPath = join5(dirname6(id2), tempName);
+  const tempPath = join6(dirname6(id2), tempName);
   try {
     if (await isDirectoryPath(id2)) {
       throw new ProjectFileError(
@@ -25008,7 +26307,7 @@ function createJsonFileProjectStorage() {
         if (entry.isDirectory() || !isRogatioProjectFilename(entry.name)) {
           continue;
         }
-        const id2 = join5(scope, entry.name);
+        const id2 = join6(scope, entry.name);
         let name = "";
         try {
           const data = await readDocument(id2);
@@ -25197,7 +26496,7 @@ async function editCommand(args, options = {}) {
   };
   let server;
   try {
-    server = createServer2(
+    server = createServer3(
       createRoutes(context),
       port !== void 0 ? { port } : {}
     );
@@ -25477,7 +26776,7 @@ 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, join as join6, resolve as resolve5 } from "node:path";
+import { dirname as dirname7, join as join7, resolve as resolve5 } from "node:path";
 function toMatcherOperations2(operations) {
   return operations.map(
     ({ groupId, ruleId, name, matcher, redactSensitiveInLogs }) => ({
@@ -25504,7 +26803,7 @@ 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 logPath = join7(installRoot, "runtime-host.log");
   const script = generateHostWrapper(
     `${process.execPath} ${process.argv[1] ?? "rogatio"}`,
     logPath
@@ -25519,7 +26818,7 @@ function makeTrustController() {
   return createRequestBodyTrustController({
     platform,
     installRoot,
-    hostPath: join6(installRoot, "runtime-host"),
+    hostPath: join7(installRoot, "runtime-host"),
     hostName: "com.rogatio.runtime",
     allowedOrigins: [],
     manifestDir: adapter.defaultManifestDir(),
@@ -25576,7 +26875,7 @@ async function trustRuntimeCommand(args) {
   }
   const controller = makeTrustController();
   const installRoot = defaultTrustInstallRoot(process.platform);
-  const hostPath = join6(installRoot, "runtime-host");
+  const hostPath = join7(installRoot, "runtime-host");
   switch (subcommand) {
     case "install": {
       const installResult = await controller.install(extensionId ?? "");
@@ -25602,7 +26901,7 @@ async function trustRuntimeCommand(args) {
       } catch {
       }
       try {
-        await rm2(join6(installRoot, "runtime-host.log"), { force: true });
+        await rm2(join7(installRoot, "runtime-host.log"), { force: true });
       } catch {
       }
       return reportTrust(