tesseract-agent 0.9.31 → 0.9.33

package/dist-bundle/cli.js

@@ -1885,7 +1885,7 @@ var require_sender = __commonJS({
        * @param {Function} [cb] Callback
        * @private
        */
-      getBlobData(blob, compress, options, cb) {
+      getBlobData(blob, compress2, options, cb) {
         this._bufferedBytes += options[kByteLength];
         this._state = GET_BLOB_DATA;
         blob.arrayBuffer().then((arrayBuffer) => {
@@ -1898,12 +1898,12 @@ var require_sender = __commonJS({
           }
           this._bufferedBytes -= options[kByteLength];
           const data = toBuffer(arrayBuffer);
-          if (!compress) {
+          if (!compress2) {
             this._state = DEFAULT;
             this.sendFrame(_Sender.frame(data, options), cb);
             this.dequeue();
           } else {
-            this.dispatch(data, compress, options, cb);
+            this.dispatch(data, compress2, options, cb);
           }
         }).catch((err2) => {
           process.nextTick(onError, this, err2, cb);
@@ -1932,8 +1932,8 @@ var require_sender = __commonJS({
        * @param {Function} [cb] Callback
        * @private
        */
-      dispatch(data, compress, options, cb) {
-        if (!compress) {
+      dispatch(data, compress2, options, cb) {
+        if (!compress2) {
           this.sendFrame(_Sender.frame(data, options), cb);
           return;
         }
@@ -2249,7 +2249,7 @@ var require_extension = __commonJS({
       if (dest[name] === void 0) dest[name] = [elem];
       else dest[name].push(elem);
     }
-    function parse3(header2) {
+    function parse4(header2) {
       const offers = /* @__PURE__ */ Object.create(null);
       let params = /* @__PURE__ */ Object.create(null);
       let mustUnescape = false;
@@ -2389,7 +2389,7 @@ var require_extension = __commonJS({
         }).join(", ");
       }).join(", ");
     }
-    module.exports = { format, parse: parse3 };
+    module.exports = { format, parse: parse4 };
   }
 });
 
@@ -2423,7 +2423,7 @@ var require_websocket = __commonJS({
     var {
       EventTarget: { addEventListener, removeEventListener }
     } = require_event_target();
-    var { format, parse: parse3 } = require_extension();
+    var { format, parse: parse4 } = require_extension();
     var { toBuffer } = require_buffer_util();
     var kAborted = Symbol("kAborted");
     var protocolVersions = [8, 13];
@@ -2941,7 +2941,7 @@ var require_websocket = __commonJS({
       }
       const defaultPort = isSecure ? 443 : 80;
       const key2 = randomBytes12(16).toString("base64");
-      const request = isSecure ? https.request : http.request;
+      const request2 = isSecure ? https.request : http.request;
       const protocolSet = /* @__PURE__ */ new Set();
       let perMessageDeflate;
       opts.createConnection = opts.createConnection || (isSecure ? tlsConnect : netConnect);
@@ -3018,12 +3018,12 @@ var require_websocket = __commonJS({
         if (opts.auth && !options.headers.authorization) {
           options.headers.authorization = "Basic " + Buffer.from(opts.auth).toString("base64");
         }
-        req = websocket._req = request(opts);
+        req = websocket._req = request2(opts);
         if (websocket._redirects) {
           websocket.emit("redirect", websocket.url, req);
         }
       } else {
-        req = websocket._req = request(opts);
+        req = websocket._req = request2(opts);
       }
       if (opts.timeout) {
         req.on("timeout", () => {
@@ -3100,7 +3100,7 @@ var require_websocket = __commonJS({
           }
           let extensions;
           try {
-            extensions = parse3(secWebSocketExtensions);
+            extensions = parse4(secWebSocketExtensions);
           } catch (err2) {
             const message = "Invalid Sec-WebSocket-Extensions header";
             abortHandshake(websocket, socket2, message);
@@ -3392,7 +3392,7 @@ var require_subprotocol = __commonJS({
   "../../node_modules/ws/lib/subprotocol.js"(exports, module) {
     "use strict";
     var { tokenChars } = require_validation();
-    function parse3(header2) {
+    function parse4(header2) {
       const protocols = /* @__PURE__ */ new Set();
       let start3 = -1;
       let end2 = -1;
@@ -3428,7 +3428,7 @@ var require_subprotocol = __commonJS({
       protocols.add(protocol);
       return protocols;
     }
-    module.exports = { parse: parse3 };
+    module.exports = { parse: parse4 };
   }
 });
 
@@ -5580,11 +5580,11 @@ function parseEnginePathStore(raw) {
 function engineEnvKeySuffix(engineId) {
   return engineId.toUpperCase().replace(/[^A-Z0-9]/g, "_");
 }
-function pathSep(platform7) {
-  return platform7 === "win32" ? "\\" : "/";
+function pathSep(platform8) {
+  return platform8 === "win32" ? "\\" : "/";
 }
-function joinPath2(platform7, ...parts) {
-  const sep10 = pathSep(platform7);
+function joinPath2(platform8, ...parts) {
+  const sep10 = pathSep(platform8);
   return parts.filter((p) => p !== "").map((p, i) => i === 0 ? p.replace(/[\\/]+$/, "") : p.replace(/^[\\/]+|[\\/]+$/g, "")).join(sep10);
 }
 function dedupe(dirs) {
@@ -5600,10 +5600,10 @@ function dedupe(dirs) {
   return out;
 }
 function engineSearchDirs(opts) {
-  const { home, platform: platform7 } = opts;
+  const { home, platform: platform8 } = opts;
   const env = opts.env ?? {};
-  const j = (...parts) => joinPath2(platform7, ...parts);
-  if (platform7 === "win32") {
+  const j = (...parts) => joinPath2(platform8, ...parts);
+  if (platform8 === "win32") {
     const appData = env.APPDATA ?? j(home, "AppData", "Roaming");
     const localAppData = env.LOCALAPPDATA ?? j(home, "AppData", "Local");
     const programFiles = env.ProgramFiles ?? "C:\\Program Files";
@@ -5620,7 +5620,7 @@ function engineSearchDirs(opts) {
       j(programFiles, "nodejs")
     ]);
   }
-  const pnpmHome = env.PNPM_HOME ?? (platform7 === "darwin" ? j(home, "Library", "pnpm") : j(home, ".local", "share", "pnpm"));
+  const pnpmHome = env.PNPM_HOME ?? (platform8 === "darwin" ? j(home, "Library", "pnpm") : j(home, ".local", "share", "pnpm"));
   return dedupe([
     "/opt/homebrew/bin",
     "/usr/local/bin",
@@ -9225,8 +9225,8 @@ function base64urlToUint8Array(base64url3) {
 function uint8ArrayToBase64url(bytes2) {
   return uint8ArrayToBase64(bytes2).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
 }
-function hexToUint8Array(hex5) {
-  const cleanHex = hex5.replace(/^0x/, "");
+function hexToUint8Array(hex6) {
+  const cleanHex = hex6.replace(/^0x/, "");
   if (cleanHex.length % 2 !== 0) {
     throw new Error("Invalid hex string length");
   }
@@ -32377,8 +32377,8 @@ ${full.slice(-8e3)}`;
             return;
           }
           const todos = live.todos?.map((t) => ({ content: t.content, status: String(t.status) }));
-          const call2 = gate === "review" ? reviewGrade(rv.task, finalText) : completenessGrade(rv.task, finalText, todos);
-          const raw = await llm({ model: live.model, system: call2.system, prompt: call2.prompt, maxTokens: 16e3, schema: call2.schema });
+          const call3 = gate === "review" ? reviewGrade(rv.task, finalText) : completenessGrade(rv.task, finalText, todos);
+          const raw = await llm({ model: live.model, system: call3.system, prompt: call3.prompt, maxTokens: 16e3, schema: call3.schema });
           if (live.rv !== rv || live.reaped) {
             if (live.reaped || live.rv === void 0) {
               emitVerification({ action: "done", gate, cycle: rv.cycles, maxCycles: RV_MAX_CYCLES, unavailable: "This run ended before it could be verified." });
@@ -32632,19 +32632,19 @@ ${qText}`;
        *  reply (→ respondToUserDialog). Mirrors onElicitation: the CLI parks the flow until
        *  we answer; an unanswered/aborted dialog resolves 'cancelled' so the CLI applies the
        *  dialog's default behavior (e.g. the classic refusal message) rather than hanging. */
-      raiseUserDialog(live, request, signal) {
+      raiseUserDialog(live, request2, signal) {
         return new Promise((resolve16) => {
           const requestId = randomUUID6();
-          log("user_dialog raised:", request.dialogKind, "requestId=" + requestId, "payloadKeys=" + Object.keys(request.payload ?? {}).join(","));
+          log("user_dialog raised:", request2.dialogKind, "requestId=" + requestId, "payloadKeys=" + Object.keys(request2.payload ?? {}).join(","));
           const onAbort = () => {
             if (this.pendingUserDialogs.delete(requestId)) {
-              log("user_dialog aborted (cancelled):", request.dialogKind, requestId);
+              log("user_dialog aborted (cancelled):", request2.dialogKind, requestId);
               resolve16({ behavior: "cancelled" });
             }
           };
           const cleanup2 = () => signal.removeEventListener("abort", onAbort);
           if (signal.aborted) {
-            log("user_dialog pre-aborted (cancelled):", request.dialogKind);
+            log("user_dialog pre-aborted (cancelled):", request2.dialogKind);
             resolve16({ behavior: "cancelled" });
             return;
           }
@@ -32654,15 +32654,15 @@ ${qText}`;
             type: "agent:user_dialog_request",
             sessionId: live.sessionId,
             requestId,
-            dialogKind: request.dialogKind,
-            payload: request.payload ?? {},
-            ...request.toolUseID ? { toolUseId: request.toolUseID } : {}
+            dialogKind: request2.dialogKind,
+            payload: request2.payload ?? {},
+            ...request2.toolUseID ? { toolUseId: request2.toolUseID } : {}
           };
           if (live.clientRequestId)
             this.send({ ...evt, clientRequestId: live.clientRequestId }, live.origin);
           else
             this.send(evt, live.origin);
-          this.autoAnswerPrompt(live, requestId, { kind: "dialog", dialogKind: request.dialogKind }, (a) => {
+          this.autoAnswerPrompt(live, requestId, { kind: "dialog", dialogKind: request2.dialogKind }, (a) => {
             if (!this.pendingUserDialogs.has(requestId))
               return false;
             this.respondToUserDialog(requestId, a.dialogResult ? { behavior: "completed", result: a.dialogResult } : { behavior: "cancelled" });
@@ -34042,7 +34042,7 @@ CRITICAL RULES:
             // M5 H6 — an MCP server requesting user input (a form, or url-based OAuth).
             // Default is auto-cancel; we park a Promise and raise an inline card, then
             // resolve it from chat:elicitation (respondToElicitation). Mirrors canUseTool.
-            onElicitation: (request, opts) => new Promise((resolve16) => {
+            onElicitation: (request2, opts) => new Promise((resolve16) => {
               const requestId = randomUUID6();
               const onAbort = () => {
                 if (this.pendingElicitations.delete(requestId))
@@ -34059,19 +34059,19 @@ CRITICAL RULES:
                 type: "agent:elicitation_request",
                 sessionId: live.sessionId,
                 requestId,
-                serverName: request.serverName,
-                message: request.message,
-                ...request.mode ? { mode: request.mode } : {},
-                ...request.url ? { url: request.url } : {},
-                ...request.elicitationId ? { elicitationId: request.elicitationId } : {},
-                ...request.requestedSchema ? { requestedSchema: request.requestedSchema } : {},
-                ...request.title ? { title: request.title } : {}
+                serverName: request2.serverName,
+                message: request2.message,
+                ...request2.mode ? { mode: request2.mode } : {},
+                ...request2.url ? { url: request2.url } : {},
+                ...request2.elicitationId ? { elicitationId: request2.elicitationId } : {},
+                ...request2.requestedSchema ? { requestedSchema: request2.requestedSchema } : {},
+                ...request2.title ? { title: request2.title } : {}
               };
               if (live.clientRequestId)
                 this.send({ ...evt, clientRequestId: live.clientRequestId }, live.origin);
               else
                 this.send(evt, live.origin);
-              this.autoAnswerPrompt(live, requestId, { kind: "elicitation", serverName: request.serverName }, () => {
+              this.autoAnswerPrompt(live, requestId, { kind: "elicitation", serverName: request2.serverName }, () => {
                 if (!this.pendingElicitations.has(requestId))
                   return false;
                 this.respondToElicitation(requestId, { action: "decline" });
@@ -34082,7 +34082,7 @@ CRITICAL RULES:
             // asks the host to render. Without this the flow degrades to no-dialog (a model
             // refusal ends the turn with the classic error). We declare the kinds we render
             // (supportedDialogKinds); the CLI fails closed and never emits an undeclared kind.
-            onUserDialog: (request, opts) => this.raiseUserDialog(live, request, opts.signal),
+            onUserDialog: (request2, opts) => this.raiseUserDialog(live, request2, opts.signal),
             supportedDialogKinds: KNOWN_DIALOG_KINDS,
             // Capture file edits for the client's "Review changes" (see pendingEdits
             // above). Bash-driven writes aren't visible here — only the editing tools.
@@ -35859,7 +35859,7 @@ async function startTesseractMcpEndpoint() {
       }
       const id = msg.id ?? null;
       const reply3 = (result) => send2(res, 200, { jsonrpc: "2.0", id, result });
-      const fail3 = (code, message) => send2(res, 200, { jsonrpc: "2.0", id, error: { code, message } });
+      const fail4 = (code, message) => send2(res, 200, { jsonrpc: "2.0", id, error: { code, message } });
       switch (msg.method) {
         case "initialize":
           reply3({
@@ -35879,7 +35879,7 @@ async function startTesseractMcpEndpoint() {
           const name = String(msg.params?.name ?? "");
           const tool19 = byName.get(name);
           if (!tool19) {
-            fail3(-32602, `Unknown tool "${name}"`);
+            fail4(-32602, `Unknown tool "${name}"`);
             return;
           }
           try {
@@ -35891,7 +35891,7 @@ async function startTesseractMcpEndpoint() {
           return;
         }
         default:
-          fail3(-32601, `Method not found: ${String(msg.method)}`);
+          fail4(-32601, `Method not found: ${String(msg.method)}`);
       }
     } catch (e) {
       try {
@@ -44102,7 +44102,7 @@ var require_decoder = __commonJS({
           }).bind(this);
           xhr.send(null);
         },
-        parse: function parse3(data) {
+        parse: function parse4(data) {
           var maxResolutionInPixels = this.opts.maxResolutionInMP * 1e3 * 1e3;
           var offset = 0, length = data.length;
           function readUint16() {
@@ -46147,7 +46147,7 @@ function __addDisposableResource(env, value, async) {
   return value;
 }
 function __disposeResources(env) {
-  function fail3(e) {
+  function fail4(e) {
     env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
     env.hasError = true;
   }
@@ -46159,12 +46159,12 @@ function __disposeResources(env) {
         if (r.dispose) {
           var result = r.dispose.call(r.value);
           if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
-            fail3(e);
+            fail4(e);
             return next();
           });
         } else s |= 1;
       } catch (e) {
-        fail3(e);
+        fail4(e);
       }
     }
     if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
@@ -48583,8 +48583,8 @@ ${values.join("\n")}` : `${blockName} :`;
         assertBigInt();
         const bigIntValue = BigInt(value);
         const writer = new ViewWriter();
-        const hex5 = bigIntValue.toString(16).replace(/^-/, "");
-        const view = new Uint8Array(pvtsutils__namespace.Convert.FromHex(hex5));
+        const hex6 = bigIntValue.toString(16).replace(/^-/, "");
+        const view = new Uint8Array(pvtsutils__namespace.Convert.FromHex(hex6));
         if (bigIntValue < 0) {
           const first = new Uint8Array(view.length + (view[0] & 128 ? 1 : 0));
           first[0] |= 128;
@@ -51735,11 +51735,11 @@ var require_hex = __commonJS({
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.hex = exports.formats = void 0;
-    exports.normalize = normalize2;
+    exports.normalize = normalize3;
     exports.is = is;
     exports.encode = encode3;
     exports.decode = decode3;
-    exports.parse = parse3;
+    exports.parse = parse4;
     exports.format = format;
     var index_js_1 = require_bytes();
     var HEX_CHARACTER_REGEX = /^[0-9a-f]$/i;
@@ -51893,7 +51893,7 @@ var require_hex = __commonJS({
       }
       return chunks.join(group.separator);
     }
-    function normalize2(text9, options = {}) {
+    function normalize3(text9, options = {}) {
       return normalizeText(text9, options);
     }
     function is(text9, options = {}) {
@@ -51901,7 +51901,7 @@ var require_hex = __commonJS({
         return false;
       }
       try {
-        normalize2(text9, options);
+        normalize3(text9, options);
         return true;
       } catch {
         return false;
@@ -51932,15 +51932,15 @@ var require_hex = __commonJS({
       return `${options.prefix ?? ""}${body}`;
     }
     function decode3(text9, options = {}) {
-      const normalized = normalize2(text9, options);
+      const normalized = normalize3(text9, options);
       const result = new Uint8Array(normalized.length / 2);
       for (let i = 0; i < normalized.length; i += 2) {
         result[i / 2] = Number.parseInt(normalized.slice(i, i + 2), 16);
       }
       return result;
     }
-    function parse3(text9, options = {}) {
-      const normalized = normalize2(text9, options);
+    function parse4(text9, options = {}) {
+      const normalized = normalize3(text9, options);
       return {
         bytes: decode3(normalized),
         format: detectFormat(text9),
@@ -51958,7 +51958,7 @@ var require_hex = __commonJS({
       groupsOf4: Object.freeze({ group: { size: 4, separator: " " } }),
       prefixed: Object.freeze({ prefix: "0x" })
     };
-    exports.hex = { encode: encode3, decode: decode3, format, formats: exports.formats, is, normalize: normalize2, parse: parse3 };
+    exports.hex = { encode: encode3, decode: decode3, format, formats: exports.formats, is, normalize: normalize3, parse: parse4 };
   }
 });
 
@@ -52017,7 +52017,7 @@ var require_base64 = __commonJS({
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.base64 = void 0;
-    exports.normalize = normalize2;
+    exports.normalize = normalize3;
     exports.pad = pad2;
     exports.is = is;
     exports.encode = encode3;
@@ -52028,7 +52028,7 @@ var require_base64 = __commonJS({
     function nodeBuffer() {
       return globalThis.Buffer;
     }
-    function normalize2(text9) {
+    function normalize3(text9) {
       return text9.replace(/[\n\r\t ]/g, "");
     }
     function pad2(text9) {
@@ -52039,7 +52039,7 @@ var require_base64 = __commonJS({
       if (typeof text9 !== "string") {
         return false;
       }
-      const normalized = normalize2(text9);
+      const normalized = normalize3(text9);
       return normalized === "" || BASE64_REGEX.test(normalized);
     }
     function encode3(data, _options) {
@@ -52051,7 +52051,7 @@ var require_base64 = __commonJS({
       return btoa((0, binary_js_1.encode)(bytes2));
     }
     function decode3(text9, _options) {
-      const normalized = normalize2(text9);
+      const normalized = normalize3(text9);
       if (!is(normalized)) {
         throw new TypeError("Input is not valid Base64 text");
       }
@@ -52061,7 +52061,7 @@ var require_base64 = __commonJS({
       }
       return (0, binary_js_1.decode)(atob(normalized));
     }
-    exports.base64 = { encode: encode3, decode: decode3, is, normalize: normalize2, pad: pad2 };
+    exports.base64 = { encode: encode3, decode: decode3, is, normalize: normalize3, pad: pad2 };
   }
 });
 
@@ -52071,29 +52071,29 @@ var require_base64url = __commonJS({
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.base64url = void 0;
-    exports.normalize = normalize2;
+    exports.normalize = normalize3;
     exports.is = is;
     exports.encode = encode3;
     exports.decode = decode3;
     var base64_js_1 = require_base64();
     var BASE64URL_REGEX = /^[A-Za-z0-9_-]*$/;
-    function normalize2(text9) {
+    function normalize3(text9) {
       return text9.replace(/[\n\r\t ]/g, "");
     }
     function is(text9) {
-      return typeof text9 === "string" && BASE64URL_REGEX.test(normalize2(text9));
+      return typeof text9 === "string" && BASE64URL_REGEX.test(normalize3(text9));
     }
     function encode3(data, _options) {
       return base64_js_1.base64.encode(data).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
     }
     function decode3(text9, _options) {
-      const normalized = normalize2(text9);
+      const normalized = normalize3(text9);
       if (!is(normalized)) {
         throw new TypeError("Input is not valid Base64Url text");
       }
       return base64_js_1.base64.decode(base64_js_1.base64.pad(normalized.replace(/-/g, "+").replace(/_/g, "/")));
     }
-    exports.base64url = { encode: encode3, decode: decode3, is, normalize: normalize2 };
+    exports.base64url = { encode: encode3, decode: decode3, is, normalize: normalize3 };
   }
 });
 
@@ -59756,8 +59756,8 @@ var require_x509_cjs = __commonJS({
             if (j === 8) {
               row.push("");
             }
-            const hex5 = view[i++].toString(16).padStart(2, "0");
-            row.push(hex5);
+            const hex6 = view[i++].toString(16).padStart(2, "0");
+            row.push(hex6);
           }
           res.push(`${pad2}${row.join(" ")}`);
         }
@@ -60181,7 +60181,7 @@ var require_x509_cjs = __commonJS({
               if (!matches) {
                 throw new Error("Cannot parse GUID value. Value doesn't match to regular expression");
               }
-              const hex5 = matches.slice(1).map((o, i) => {
+              const hex6 = matches.slice(1).map((o, i) => {
                 if (i < 3) {
                   return pvtsutils.Convert.ToHex(new Uint8Array(pvtsutils.Convert.FromHex(o)).reverse());
                 }
@@ -60190,7 +60190,7 @@ var require_x509_cjs = __commonJS({
               name = new asn1X509__namespace.GeneralName({
                 otherName: new asn1X509__namespace.OtherName({
                   typeId: id_GUID,
-                  value: asn1Schema.AsnConvert.serialize(new asn1Schema.OctetString(pvtsutils.Convert.FromHex(hex5)))
+                  value: asn1Schema.AsnConvert.serialize(new asn1Schema.OctetString(pvtsutils.Convert.FromHex(hex6)))
                 })
               });
               break;
@@ -63139,9 +63139,9 @@ function socketPeerLink(socket2, peerHostId, path6, opts) {
   });
   const hsTimer = setTimeout(() => {
     if (!authed)
-      fail3(new Error("peer-link: token handshake timeout"));
+      fail4(new Error("peer-link: token handshake timeout"));
   }, TOKEN_HANDSHAKE_MS);
-  function fail3(err2) {
+  function fail4(err2) {
     if (closed)
       return;
     closed = true;
@@ -63167,7 +63167,7 @@ function socketPeerLink(socket2, peerHostId, path6, opts) {
     try {
       frames = dec.push(new Uint8Array(d.buffer, d.byteOffset, d.byteLength));
     } catch (e) {
-      fail3(e);
+      fail4(e);
       return;
     }
     for (const f of frames) {
@@ -63177,7 +63177,7 @@ function socketPeerLink(socket2, peerHostId, path6, opts) {
           clearTimeout(hsTimer);
           resolveReady();
         } else {
-          fail3(new Error("peer-link: bad/absent token (fail-closed)"));
+          fail4(new Error("peer-link: bad/absent token (fail-closed)"));
           return;
         }
         continue;
@@ -63186,7 +63186,7 @@ function socketPeerLink(socket2, peerHostId, path6, opts) {
         cb(f);
     }
   });
-  socket2.once("error", (e) => fail3(e instanceof Error ? e : new Error(String(e))));
+  socket2.once("error", (e) => fail4(e instanceof Error ? e : new Error(String(e))));
   socket2.once("close", () => closeOk());
   if (opts.sendToken) {
     try {
@@ -63194,7 +63194,7 @@ function socketPeerLink(socket2, peerHostId, path6, opts) {
       clearTimeout(hsTimer);
       resolveReady();
     } catch (e) {
-      fail3(e);
+      fail4(e);
     }
   }
   const link = {
@@ -63560,12 +63560,13 @@ function wrapConstructorWithOpts(hashCons) {
   hashC.create = (opts) => hashCons(opts);
   return hashC;
 }
-var u8, u32, isLE, byteSwap, byteSwapIfBE, Hash, toStr;
+var u8, u32, rotr, isLE, byteSwap, byteSwapIfBE, Hash, toStr;
 var init_utils = __esm({
   "../../node_modules/@noble/hashes/esm/utils.js"() {
     init_assert();
     u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
     u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+    rotr = (word, shift) => word << 32 - shift | word >>> shift;
     isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
     byteSwap = (word) => word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
     byteSwapIfBE = isLE ? (n) => n : (n) => byteSwap(n);
@@ -64820,7 +64821,7 @@ var require_cjs12 = __commonJS({
       out.publicSuffix = (_a4 = hostnameParts[hostnameParts.length - 1]) !== null && _a4 !== void 0 ? _a4 : null;
     }
     var RESULT = getEmptyResult();
-    function parse3(url2, options = {}) {
+    function parse4(url2, options = {}) {
       return parseImpl(url2, 5, suffixLookup, options, getEmptyResult());
     }
     function getHostname(url2, options = {}) {
@@ -64848,7 +64849,7 @@ var require_cjs12 = __commonJS({
     exports.getHostname = getHostname;
     exports.getPublicSuffix = getPublicSuffix;
     exports.getSubdomain = getSubdomain;
-    exports.parse = parse3;
+    exports.parse = parse4;
   }
 });
 
@@ -64863,6 +64864,9 @@ function compareUtf8(a, b) {
   }
   return ea.length === eb.length ? 0 : ea.length < eb.length ? -1 : 1;
 }
+function canonicalStrs(items) {
+  return [...new Set(items)].sort(compareUtf8);
+}
 var MeshCodecError, fail, LIMITS, Writer, Reader;
 var init_codec = __esm({
   "../../packages/mesh-pki/dist/codec.js"() {
@@ -65104,6 +65108,20 @@ function isMasked(addr, len) {
   }
   return true;
 }
+function mask(addr, len) {
+  const out = new Uint8Array(addr);
+  for (let i = 0; i < out.length; i++) {
+    const bitsBefore = i * 8;
+    if (bitsBefore >= len) {
+      out[i] = 0;
+      continue;
+    }
+    const keep = Math.min(8, len - bitsBefore);
+    if (keep < 8)
+      out[i] &= 255 << 8 - keep;
+  }
+  return out;
+}
 function makePrefix(afi, addr, len) {
   if (afi !== AFI_V4 && afi !== AFI_V6)
     throw new MeshCodecError("bad-value", `afi ${afi}`);
@@ -65140,6 +65158,10 @@ function comparePrefix(a, b) {
   }
   return a.len === b.len ? 0 : a.len < b.len ? -1 : 1;
 }
+function canonicalPrefixes(items) {
+  const sorted = [...items].sort(comparePrefix);
+  return sorted.filter((p, i) => i === 0 || comparePrefix(sorted[i - 1], p) !== 0);
+}
 function writePrefixes(w, items) {
   if (items.length > LIMITS.VEC)
     throw new MeshCodecError("too-long", `routes ${items.length}`);
@@ -65187,6 +65209,26 @@ function isValidMeshRange(p) {
     return (p.addr[0] & 254) === 252;
   return false;
 }
+function prefixContainsAddr(p, addr) {
+  if (addr.length !== widthOf(p.afi))
+    return false;
+  let bits = p.len;
+  for (let i = 0; i < addr.length && bits > 0; i++) {
+    const keep = Math.min(8, bits);
+    const m = keep === 8 ? 255 : 255 << 8 - keep & 255;
+    if ((addr[i] & m) !== (p.addr[i] & m))
+      return false;
+    bits -= keep;
+  }
+  return true;
+}
+function prefixContains(outer, inner) {
+  if (outer.afi !== inner.afi)
+    return false;
+  if (inner.len < outer.len)
+    return false;
+  return prefixContainsAddr(outer, inner.addr);
+}
 function formatPrefix(p) {
   return `${formatAddr(p.afi, p.addr)}/${p.len}`;
 }
@@ -65233,7 +65275,71 @@ function formatAddr(afi, addr) {
     s = s + ":";
   return s;
 }
-var AFI_V4, AFI_V6, widthOf, maxLenOf, MIN_MESH_PREFIX_LEN;
+function parsePrefix(text9) {
+  const slash = text9.lastIndexOf("/");
+  if (slash < 0)
+    throw new MeshCodecError("bad-value", `missing / in ${text9}`);
+  const host = text9.slice(0, slash);
+  const lenStr = text9.slice(slash + 1);
+  if (!/^\d{1,3}$/.test(lenStr))
+    throw new MeshCodecError("bad-value", `prefix len ${lenStr}`);
+  const len = Number(lenStr);
+  const { afi, addr } = parseAddr(host);
+  if (len > maxLenOf(afi))
+    throw new MeshCodecError("bad-value", `len ${len} for v${afi}`);
+  return makePrefix(afi, mask(addr, len), len);
+}
+function parseAddr(text9) {
+  if (text9.includes(":"))
+    return { afi: AFI_V6, addr: parseV6(text9) };
+  return { afi: AFI_V4, addr: parseV4(text9) };
+}
+function parseV4(text9) {
+  const parts = text9.split(".");
+  if (parts.length !== 4)
+    throw new MeshCodecError("bad-value", `bad IPv4 ${text9}`);
+  const out = new Uint8Array(4);
+  for (let i = 0; i < 4; i++) {
+    if (!/^(0|[1-9]\d{0,2})$/.test(parts[i]))
+      throw new MeshCodecError("bad-value", `bad IPv4 octet ${parts[i]}`);
+    const v = Number(parts[i]);
+    if (v > 255)
+      throw new MeshCodecError("bad-value", `bad IPv4 octet ${parts[i]}`);
+    out[i] = v;
+  }
+  return out;
+}
+function parseV6(text9) {
+  if (text9.includes("::")) {
+    const halves = text9.split("::");
+    if (halves.length !== 2)
+      throw new MeshCodecError("bad-value", `bad IPv6 ${text9}`);
+    const head = halves[0] ? halves[0].split(":") : [];
+    const tail3 = halves[1] ? halves[1].split(":") : [];
+    if (head.length + tail3.length > 7)
+      throw new MeshCodecError("bad-value", `bad IPv6 ${text9}`);
+    const zeros = new Array(8 - head.length - tail3.length).fill("0");
+    return groupsToBytes([...head, ...zeros, ...tail3], text9);
+  }
+  const g = text9.split(":");
+  if (g.length !== 8)
+    throw new MeshCodecError("bad-value", `bad IPv6 ${text9}`);
+  return groupsToBytes(g, text9);
+}
+function groupsToBytes(groups, orig) {
+  if (groups.length !== 8)
+    throw new MeshCodecError("bad-value", `bad IPv6 ${orig}`);
+  const out = new Uint8Array(16);
+  for (let i = 0; i < 8; i++) {
+    if (!/^[0-9a-fA-F]{1,4}$/.test(groups[i]))
+      throw new MeshCodecError("bad-value", `bad IPv6 group ${groups[i]}`);
+    const v = parseInt(groups[i], 16);
+    out[i * 2] = v >>> 8 & 255;
+    out[i * 2 + 1] = v & 255;
+  }
+  return out;
+}
+var AFI_V4, AFI_V6, widthOf, maxLenOf, prefixEqual, MIN_MESH_PREFIX_LEN;
 var init_prefix = __esm({
   "../../packages/mesh-pki/dist/prefix.js"() {
     "use strict";
@@ -65242,19 +65348,144 @@ var init_prefix = __esm({
     AFI_V6 = 6;
     widthOf = (afi) => afi === AFI_V4 ? 4 : 16;
     maxLenOf = (afi) => afi === AFI_V4 ? 32 : 128;
+    prefixEqual = (a, b) => comparePrefix(a, b) === 0;
     MIN_MESH_PREFIX_LEN = 8;
   }
 });
 
+// ../../node_modules/@noble/hashes/esm/blake2s.js
+function G1s(a, b, c, d, x) {
+  a = a + b + x | 0;
+  d = rotr(d ^ a, 16);
+  c = c + d | 0;
+  b = rotr(b ^ c, 12);
+  return { a, b, c, d };
+}
+function G2s(a, b, c, d, x) {
+  a = a + b + x | 0;
+  d = rotr(d ^ a, 8);
+  c = c + d | 0;
+  b = rotr(b ^ c, 7);
+  return { a, b, c, d };
+}
+function compress(s, offset, msg, rounds, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) {
+  let j = 0;
+  for (let i = 0; i < rounds; i++) {
+    ({ a: v0, b: v4, c: v8, d: v12 } = G1s(v0, v4, v8, v12, msg[offset + s[j++]]));
+    ({ a: v0, b: v4, c: v8, d: v12 } = G2s(v0, v4, v8, v12, msg[offset + s[j++]]));
+    ({ a: v1, b: v5, c: v9, d: v13 } = G1s(v1, v5, v9, v13, msg[offset + s[j++]]));
+    ({ a: v1, b: v5, c: v9, d: v13 } = G2s(v1, v5, v9, v13, msg[offset + s[j++]]));
+    ({ a: v2, b: v6, c: v10, d: v14 } = G1s(v2, v6, v10, v14, msg[offset + s[j++]]));
+    ({ a: v2, b: v6, c: v10, d: v14 } = G2s(v2, v6, v10, v14, msg[offset + s[j++]]));
+    ({ a: v3, b: v7, c: v11, d: v15 } = G1s(v3, v7, v11, v15, msg[offset + s[j++]]));
+    ({ a: v3, b: v7, c: v11, d: v15 } = G2s(v3, v7, v11, v15, msg[offset + s[j++]]));
+    ({ a: v0, b: v5, c: v10, d: v15 } = G1s(v0, v5, v10, v15, msg[offset + s[j++]]));
+    ({ a: v0, b: v5, c: v10, d: v15 } = G2s(v0, v5, v10, v15, msg[offset + s[j++]]));
+    ({ a: v1, b: v6, c: v11, d: v12 } = G1s(v1, v6, v11, v12, msg[offset + s[j++]]));
+    ({ a: v1, b: v6, c: v11, d: v12 } = G2s(v1, v6, v11, v12, msg[offset + s[j++]]));
+    ({ a: v2, b: v7, c: v8, d: v13 } = G1s(v2, v7, v8, v13, msg[offset + s[j++]]));
+    ({ a: v2, b: v7, c: v8, d: v13 } = G2s(v2, v7, v8, v13, msg[offset + s[j++]]));
+    ({ a: v3, b: v4, c: v9, d: v14 } = G1s(v3, v4, v9, v14, msg[offset + s[j++]]));
+    ({ a: v3, b: v4, c: v9, d: v14 } = G2s(v3, v4, v9, v14, msg[offset + s[j++]]));
+  }
+  return { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 };
+}
+var B2S_IV, BLAKE2s, blake2s;
+var init_blake2s = __esm({
+  "../../node_modules/@noble/hashes/esm/blake2s.js"() {
+    init_blake();
+    init_u64();
+    init_utils();
+    B2S_IV = /* @__PURE__ */ new Uint32Array([
+      1779033703,
+      3144134277,
+      1013904242,
+      2773480762,
+      1359893119,
+      2600822924,
+      528734635,
+      1541459225
+    ]);
+    BLAKE2s = class extends BLAKE {
+      constructor(opts = {}) {
+        super(64, opts.dkLen === void 0 ? 32 : opts.dkLen, opts, 32, 8, 8);
+        this.v0 = B2S_IV[0] | 0;
+        this.v1 = B2S_IV[1] | 0;
+        this.v2 = B2S_IV[2] | 0;
+        this.v3 = B2S_IV[3] | 0;
+        this.v4 = B2S_IV[4] | 0;
+        this.v5 = B2S_IV[5] | 0;
+        this.v6 = B2S_IV[6] | 0;
+        this.v7 = B2S_IV[7] | 0;
+        const keyLength = opts.key ? opts.key.length : 0;
+        this.v0 ^= this.outputLen | keyLength << 8 | 1 << 16 | 1 << 24;
+        if (opts.salt) {
+          const salt = u32(toBytes(opts.salt));
+          this.v4 ^= byteSwapIfBE(salt[0]);
+          this.v5 ^= byteSwapIfBE(salt[1]);
+        }
+        if (opts.personalization) {
+          const pers = u32(toBytes(opts.personalization));
+          this.v6 ^= byteSwapIfBE(pers[0]);
+          this.v7 ^= byteSwapIfBE(pers[1]);
+        }
+        if (opts.key) {
+          const tmp = new Uint8Array(this.blockLen);
+          tmp.set(toBytes(opts.key));
+          this.update(tmp);
+        }
+      }
+      get() {
+        const { v0, v1, v2, v3, v4, v5, v6, v7 } = this;
+        return [v0, v1, v2, v3, v4, v5, v6, v7];
+      }
+      // prettier-ignore
+      set(v0, v1, v2, v3, v4, v5, v6, v7) {
+        this.v0 = v0 | 0;
+        this.v1 = v1 | 0;
+        this.v2 = v2 | 0;
+        this.v3 = v3 | 0;
+        this.v4 = v4 | 0;
+        this.v5 = v5 | 0;
+        this.v6 = v6 | 0;
+        this.v7 = v7 | 0;
+      }
+      compress(msg, offset, isLast) {
+        const { h, l } = fromBig(BigInt(this.length));
+        const { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } = compress(SIGMA, offset, msg, 10, this.v0, this.v1, this.v2, this.v3, this.v4, this.v5, this.v6, this.v7, B2S_IV[0], B2S_IV[1], B2S_IV[2], B2S_IV[3], l ^ B2S_IV[4], h ^ B2S_IV[5], isLast ? ~B2S_IV[6] : B2S_IV[6], B2S_IV[7]);
+        this.v0 ^= v0 ^ v8;
+        this.v1 ^= v1 ^ v9;
+        this.v2 ^= v2 ^ v10;
+        this.v3 ^= v3 ^ v11;
+        this.v4 ^= v4 ^ v12;
+        this.v5 ^= v5 ^ v13;
+        this.v6 ^= v6 ^ v14;
+        this.v7 ^= v7 ^ v15;
+      }
+      destroy() {
+        this.destroyed = true;
+        this.buffer32.fill(0);
+        this.set(0, 0, 0, 0, 0, 0, 0, 0);
+      }
+    };
+    blake2s = /* @__PURE__ */ wrapConstructorWithOpts((opts) => new BLAKE2s(opts));
+  }
+});
+
 // ../../packages/mesh-pki/dist/crypto.js
-function randomBytes9(n) {
+function randomBytes7(n) {
   return globalThis.crypto.getRandomValues(new Uint8Array(n));
 }
 async function generateSigningKey(extractable = true) {
-  const kp = await subtle4.generateKey(ED25519, extractable, ["sign", "verify"]);
-  const publicRaw = new Uint8Array(await subtle4.exportKey("raw", kp.publicKey));
+  const kp = await subtle3.generateKey(ED25519, extractable, ["sign", "verify"]);
+  const publicRaw = new Uint8Array(await subtle3.exportKey("raw", kp.publicKey));
   return { privateKey: kp.privateKey, publicRaw };
 }
+async function importSigningPublic(raw) {
+  if (raw.length !== 32)
+    throw new Error(`Ed25519 public key must be 32 bytes, got ${raw.length}`);
+  return subtle3.importKey("raw", bs3(raw), ED25519, true, ["verify"]);
+}
 async function signingKeyFromSeed(seed) {
   if (seed.length !== 32)
     throw new Error(`Ed25519 seed must be 32 bytes, got ${seed.length}`);
@@ -65277,14 +65508,14 @@ async function signingKeyFromSeed(seed) {
     32
   ]);
   const pkcs8 = concat2(prefix, seed);
-  const privateKey = await subtle4.importKey("pkcs8", bs4(pkcs8), ED25519, true, ["sign"]);
-  const jwk = await subtle4.exportKey("jwk", privateKey);
+  const privateKey = await subtle3.importKey("pkcs8", bs3(pkcs8), ED25519, true, ["sign"]);
+  const jwk = await subtle3.exportKey("jwk", privateKey);
   if (typeof jwk.x !== "string")
     throw new Error("Ed25519 JWK missing x");
   return { privateKey, publicRaw: unb64u2(jwk.x) };
 }
 async function exportStaticPrivate(kp) {
-  const jwk = await subtle4.exportKey("jwk", kp.privateKey);
+  const jwk = await subtle3.exportKey("jwk", kp.privateKey);
   if (typeof jwk.d !== "string")
     throw new Error("X25519 JWK missing d");
   const raw = unb64u2(jwk.d);
@@ -65292,16 +65523,44 @@ async function exportStaticPrivate(kp) {
     throw new Error(`X25519 private key must be 32 bytes, got ${raw.length}`);
   return raw;
 }
+async function exportSigningPrivate(kp) {
+  return subtle3.exportKey("jwk", kp.privateKey);
+}
+async function importSigningPrivate(jwk) {
+  const privateKey = await subtle3.importKey("jwk", jwk, ED25519, true, ["sign"]);
+  if (typeof jwk.x !== "string")
+    throw new Error("Ed25519 JWK missing x");
+  return { privateKey, publicRaw: unb64u2(jwk.x) };
+}
 async function sign2(privateKey, message) {
-  return new Uint8Array(await subtle4.sign(ED25519, privateKey, bs4(message)));
+  return new Uint8Array(await subtle3.sign(ED25519, privateKey, bs3(message)));
+}
+async function verify2(publicRaw, message, sig) {
+  if (sig.length !== 64 || publicRaw.length !== 32)
+    return false;
+  try {
+    const key2 = await importSigningPublic(publicRaw);
+    return await subtle3.verify(ED25519, key2, bs3(sig), bs3(message));
+  } catch {
+    return false;
+  }
 }
 async function generateStaticKey(extractable = true) {
-  const kp = await subtle4.generateKey(X25519, extractable, ["deriveBits"]);
-  const publicRaw = new Uint8Array(await subtle4.exportKey("raw", kp.publicKey));
+  const kp = await subtle3.generateKey(X25519, extractable, ["deriveBits"]);
+  const publicRaw = new Uint8Array(await subtle3.exportKey("raw", kp.publicKey));
   return { privateKey: kp.privateKey, publicRaw };
 }
 async function sha2562(bytes2) {
-  return new Uint8Array(await subtle4.digest("SHA-256", bs4(bytes2)));
+  return new Uint8Array(await subtle3.digest("SHA-256", bs3(bytes2)));
+}
+function blake2s256(bytes2) {
+  return blake2s(bytes2, { dkLen: 32 });
+}
+function b64u2(bytes2) {
+  let s = "";
+  for (const b of bytes2)
+    s += String.fromCharCode(b);
+  return btoa(s).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
 }
 function unb64u2(s) {
   const pad2 = s.length % 4 === 0 ? "" : "=".repeat(4 - s.length % 4);
@@ -65314,7 +65573,7 @@ function unb64u2(s) {
 function hex3(bytes2) {
   return Array.from(bytes2, (b) => b.toString(16).padStart(2, "0")).join("");
 }
-function utf83(s) {
+function utf82(s) {
   return new TextEncoder().encode(s);
 }
 function concat2(...parts) {
@@ -65327,12 +65586,21 @@ function concat2(...parts) {
   }
   return out;
 }
-var subtle4, bs4, ED25519, X25519;
+function bytesEqual(a, b) {
+  if (a.length !== b.length)
+    return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++)
+    diff |= a[i] ^ b[i];
+  return diff === 0;
+}
+var subtle3, bs3, ED25519, X25519;
 var init_crypto = __esm({
   "../../packages/mesh-pki/dist/crypto.js"() {
     "use strict";
-    subtle4 = globalThis.crypto.subtle;
-    bs4 = (b) => b;
+    init_blake2s();
+    subtle3 = globalThis.crypto.subtle;
+    bs3 = (b) => b;
     ED25519 = "Ed25519";
     X25519 = "X25519";
   }
@@ -65417,9 +65685,55 @@ function readGenesisBody(r) {
   validateGenesis(g);
   return g;
 }
+function encodeSignedGenesis(sg) {
+  const body = encodeGenesis(sg.block);
+  const w = new Writer();
+  w.bytes(body, LIMITS.GENESIS);
+  w.vec(sg.sigs, (ww, s) => {
+    ww.u8(s.keyIndex).fixed(s.sig, 64);
+  });
+  return w.finish();
+}
+function decodeSignedGenesis(bytes2) {
+  const r = new Reader(bytes2);
+  const body = r.bytes(LIMITS.GENESIS);
+  const sigs = r.vec((rr) => ({ keyIndex: rr.u8(), sig: rr.fixed(64) }));
+  r.finish();
+  return { block: decodeGenesis(body), sigs };
+}
 async function genesisFingerprint(g) {
   return sha2562(encodeGenesis(g));
 }
+function fingerprintShort(fp, groups = 12) {
+  const h = hex3(fp.subarray(0, Math.min(fp.length, groups * 2)));
+  return (h.match(/.{1,4}/g) ?? []).join(" ");
+}
+async function signGenesis(block2, signers) {
+  const body = encodeGenesis(block2);
+  const sigs = [];
+  for (const s of [...signers].sort((a, b) => a.keyIndex - b.keyIndex)) {
+    if (s.keyIndex < 0 || s.keyIndex >= block2.caKeys.length) {
+      throw new MeshCodecError("bad-value", `signer index ${s.keyIndex}`);
+    }
+    sigs.push({ keyIndex: s.keyIndex, sig: await sign2(s.privateKey, body) });
+  }
+  return { block: block2, sigs };
+}
+async function verifyGenesis(sg) {
+  const { block: block2, sigs } = sg;
+  const body = encodeGenesis(block2);
+  const seen = /* @__PURE__ */ new Set();
+  for (const s of sigs) {
+    if (s.keyIndex >= block2.caKeys.length)
+      return false;
+    if (seen.has(s.keyIndex))
+      return false;
+    if (!await verify2(block2.caKeys[s.keyIndex], body, s.sig))
+      return false;
+    seen.add(s.keyIndex);
+  }
+  return seen.size >= block2.kCa;
+}
 async function deriveMeshPrefix6(orgId) {
   const h = await sha2562(new TextEncoder().encode(orgId));
   const out = new Uint8Array(6);
@@ -65562,6 +65876,9 @@ function decodeCert(bytes2) {
   r.finish();
   return { details: decodeDetails(body), sigs };
 }
+async function certFingerprint(d) {
+  return sha2562(encodeDetails(d));
+}
 async function issueCert(details, signers) {
   const body = encodeDetails(details);
   const sigs = [];
@@ -65570,7 +65887,115 @@ async function issueCert(details, signers) {
   }
   return { details, sigs };
 }
-var TNC_VERSION, FLAG_IS_CA, FLAG_IS_EXIT_NODE, FLAG_IS_RELAY, FLAG_IS_EPHEMERAL, KNOWN_FLAGS, NAME_RE, ZERO16;
+async function verifyCert(leaf, genesis, opts) {
+  const genFp = await genesisFingerprint(genesis);
+  const byFp = /* @__PURE__ */ new Map();
+  for (const c of opts.intermediates ?? []) {
+    byFp.set(hexKey(await certFingerprint(c.details)), c);
+  }
+  let cur = leaf;
+  let depth = 0;
+  const seen = /* @__PURE__ */ new Set();
+  for (; ; ) {
+    const d = cur.details;
+    if (d.version !== TNC_VERSION)
+      return no("bad-version");
+    if (!bytesEqual(d.genesisFp, genFp))
+      return no("wrong-mesh");
+    if (!opts.ignoreTime) {
+      if (opts.now + CLOCK_SKEW_MS < d.notBefore)
+        return no("not-yet-valid");
+      if (opts.now - CLOCK_SKEW_MS > d.notAfter)
+        return no("expired");
+    }
+    if (opts.revokedSerials?.some((s) => bytesEqual(s, d.serial)))
+      return no("revoked", "serial");
+    if (opts.revokedStatics?.some((s) => bytesEqual(s, d.staticPub)))
+      return no("revoked", "staticPub");
+    const selfFp = await certFingerprint(d);
+    const selfKey = hexKey(selfFp);
+    if (seen.has(selfKey))
+      return no("chain-cycle");
+    seen.add(selfKey);
+    const body = encodeDetails(d);
+    if (bytesEqual(d.issuerFp, genFp)) {
+      const q2 = await checkQuorum(body, cur.sigs, genesis.caKeys, genesis.kCa);
+      if (q2 !== "ok")
+        return no(q2);
+      return { ok: true, details: leaf.details, chainDepth: depth };
+    }
+    const parent = byFp.get(hexKey(d.issuerFp));
+    if (!parent)
+      return no("unknown-issuer");
+    if (!isCa(parent.details))
+      return no("issuer-not-ca");
+    const q = await checkQuorum(body, cur.sigs, [parent.details.sigPub], 1);
+    if (q !== "ok")
+      return no(q);
+    const narrow = checkNarrowing(parent.details, d);
+    if (narrow)
+      return no(narrow);
+    depth++;
+    if (depth >= MAX_CHAIN_DEPTH)
+      return no("chain-too-deep");
+    cur = parent;
+  }
+}
+function no(reason, detail) {
+  return { ok: false, reason, detail };
+}
+async function checkQuorum(body, sigs, keys, threshold) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const s of sigs) {
+    if (s.keyIndex >= keys.length)
+      return "bad-signature";
+    if (seen.has(s.keyIndex))
+      return "bad-signature";
+    if (!await verify2(keys[s.keyIndex], body, s.sig))
+      return "bad-signature";
+    seen.add(s.keyIndex);
+  }
+  return seen.size >= threshold ? "ok" : "quorum-not-met";
+}
+function checkNarrowing(parent, child) {
+  const parentGroups = new Set(parent.groups);
+  for (const g of child.groups) {
+    if (!parentGroups.has(g))
+      return "narrowing-groups";
+  }
+  for (const r of child.routes) {
+    if (!parent.routes.some((p) => prefixContains(p, r)))
+      return "narrowing-routes";
+  }
+  if (child.notAfter > parent.notAfter)
+    return "narrowing-expiry";
+  if (parent.overlayIp4 !== 0 && child.overlayIp4 !== parent.overlayIp4)
+    return "narrowing-address";
+  if (hasV6(parent) && !bytesEqual(child.overlayIp6, parent.overlayIp6))
+    return "narrowing-address";
+  const widened = child.flags & ~parent.flags & (FLAG_IS_EXIT_NODE | FLAG_IS_RELAY);
+  if (widened !== 0)
+    return "narrowing-address";
+  return null;
+}
+function maySourceAddr(d, afi, src) {
+  if (afi === AFI_V4) {
+    if (src.length !== 4)
+      return false;
+    const asU32 = (src[0] << 24 >>> 0) + (src[1] << 16) + (src[2] << 8) + src[3];
+    if (d.overlayIp4 !== 0 && asU32 === d.overlayIp4)
+      return true;
+  } else if (afi === AFI_V6) {
+    if (src.length !== 16)
+      return false;
+    if (hasV6(d) && bytesEqual(src, d.overlayIp6))
+      return true;
+  } else {
+    return false;
+  }
+  return d.routes.some((p) => p.afi === afi && prefixContainsAddr(p, src));
+}
+var TNC_VERSION, FLAG_IS_CA, FLAG_IS_EXIT_NODE, FLAG_IS_RELAY, FLAG_IS_EPHEMERAL, KNOWN_FLAGS, CLOCK_SKEW_MS, MAX_CHAIN_DEPTH, NAME_RE, isCa, isExitNode, isRelay, ZERO16, hasV6, hexKey;
 var init_cert = __esm({
   "../../packages/mesh-pki/dist/cert.js"() {
     "use strict";
@@ -65584,12 +66009,56 @@ var init_cert = __esm({
     FLAG_IS_RELAY = 1 << 2;
     FLAG_IS_EPHEMERAL = 1 << 3;
     KNOWN_FLAGS = FLAG_IS_CA | FLAG_IS_EXIT_NODE | FLAG_IS_RELAY | FLAG_IS_EPHEMERAL;
+    CLOCK_SKEW_MS = 12e4;
+    MAX_CHAIN_DEPTH = 4;
     NAME_RE = /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/;
+    isCa = (d) => (d.flags & FLAG_IS_CA) !== 0;
+    isExitNode = (d) => (d.flags & FLAG_IS_EXIT_NODE) !== 0;
+    isRelay = (d) => (d.flags & FLAG_IS_RELAY) !== 0;
     ZERO16 = new Uint8Array(16);
+    hasV6 = (d) => !bytesEqual(d.overlayIp6, ZERO16);
+    hexKey = (b) => Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
   }
 });
 
 // ../../packages/mesh-pki/dist/addr.js
+function deriveOverlayV6(meshPrefix6, genesisFp, staticPub) {
+  if (meshPrefix6.length !== 6)
+    throw new MeshCodecError("bad-value", "meshPrefix6 must be 6 bytes");
+  if (genesisFp.length !== 32)
+    throw new MeshCodecError("bad-value", "genesisFp must be 32 bytes");
+  if (staticPub.length !== 32)
+    throw new MeshCodecError("bad-value", "staticPub must be 32 bytes");
+  const iid = blake2s256(concat2(CTX_V6, genesisFp, staticPub));
+  const out = new Uint8Array(16);
+  out.set(meshPrefix6, 0);
+  out.set(iid.subarray(0, 10), 6);
+  return out;
+}
+function deriveOverlayV4Hint(cidr, genesisFp, staticPub) {
+  if (cidr.afi !== AFI_V4)
+    throw new MeshCodecError("bad-value", "cidr must be IPv4");
+  const hostBits = maxLenOf(AFI_V4) - cidr.len;
+  if (hostBits < 2)
+    throw new MeshCodecError("bad-value", `mesh cidr /${cidr.len} too small`);
+  const h = blake2s256(concat2(CTX_V4, genesisFp, staticPub));
+  const raw = (h[0] << 24 >>> 0) + (h[1] << 16) + (h[2] << 8) + h[3];
+  const span = hostBits >= 32 ? 4294967296 : 2 ** hostBits;
+  const host = raw % (span - 2) + 1;
+  const base = (cidr.addr[0] << 24 >>> 0) + (cidr.addr[1] << 16) + (cidr.addr[2] << 8) + cidr.addr[3];
+  return base + host >>> 0;
+}
+function u32ToAddr(v) {
+  return new Uint8Array([v >>> 24 & 255, v >>> 16 & 255, v >>> 8 & 255, v & 255]);
+}
+function addrToU32(a) {
+  if (a.length !== 4)
+    throw new MeshCodecError("bad-value", "IPv4 must be 4 bytes");
+  return (a[0] << 24 >>> 0) + (a[1] << 16) + (a[2] << 8) + a[3] >>> 0;
+}
+function meshFqdn(name, orgSlug) {
+  return `${name}.${orgSlug}.tsr.internal`;
+}
 var CTX_V6, CTX_V4;
 var init_addr = __esm({
   "../../packages/mesh-pki/dist/addr.js"() {
@@ -65597,12 +66066,41 @@ var init_addr = __esm({
     init_crypto();
     init_prefix();
     init_codec();
-    CTX_V6 = utf83("tsr-addr6-v1");
-    CTX_V4 = utf83("tsr-addr4-v1");
+    CTX_V6 = utf82("tsr-addr6-v1");
+    CTX_V4 = utf82("tsr-addr4-v1");
   }
 });
 
 // ../../packages/mesh-pki/dist/policy.js
+function canonicalGroups(indices) {
+  return [...new Set(indices)].sort((a, b) => a - b);
+}
+function canonicalPorts(ranges) {
+  const sorted = [...ranges].sort((a, b) => a.lo - b.lo || a.hi - b.hi);
+  for (let i = 0; i < sorted.length; i++) {
+    const r = sorted[i];
+    if (!Number.isInteger(r.lo) || !Number.isInteger(r.hi) || r.lo < 0 || r.hi > 65535 || r.lo > r.hi) {
+      throw new MeshCodecError("bad-value", `port range ${r.lo}-${r.hi}`);
+    }
+    if (i > 0 && r.lo <= sorted[i - 1].hi) {
+      throw new MeshCodecError("bad-value", `overlapping port ranges ${sorted[i - 1].lo}-${sorted[i - 1].hi} / ${r.lo}-${r.hi}`);
+    }
+  }
+  return sorted;
+}
+function makeRule(r = {}) {
+  const rule = {
+    action: r.action ?? ACTION_ACCEPT,
+    proto: r.proto ?? PROTO_ANY,
+    srcGroups: canonicalGroups(r.srcGroups ?? []),
+    srcCidrs: canonicalPrefixes(r.srcCidrs ?? []),
+    dstCidrs: canonicalPrefixes(r.dstCidrs ?? []),
+    ports: canonicalPorts(r.ports ?? []),
+    caps: r.caps ?? 0
+  };
+  validateRule(rule);
+  return rule;
+}
 function validateRule(r) {
   if (r.action !== ACTION_ACCEPT && r.action !== ACTION_DROP) {
     throw new MeshCodecError("bad-value", `action ${r.action}`);
@@ -65638,6 +66136,107 @@ function writeRule(w, r) {
     w.u16(p.lo).u16(p.hi);
   w.u32(r.caps);
 }
+function readRule(r) {
+  const action = r.u8();
+  const proto = r.u8();
+  const nG = r.u16();
+  if (nG > LIMITS.VEC)
+    throw new MeshCodecError("too-long", "srcGroups");
+  const srcGroups = [];
+  for (let i = 0; i < nG; i++) {
+    const g = r.u16();
+    if (i > 0) {
+      if (g === srcGroups[i - 1])
+        throw new MeshCodecError("duplicate", "srcGroups");
+      if (g < srcGroups[i - 1])
+        throw new MeshCodecError("not-sorted", "srcGroups");
+    }
+    srcGroups.push(g);
+  }
+  const srcCidrs = readPrefixes(r);
+  const dstCidrs = readPrefixes(r);
+  const nP = r.u16();
+  if (nP > LIMITS.VEC)
+    throw new MeshCodecError("too-long", "ports");
+  const ports = [];
+  for (let i = 0; i < nP; i++) {
+    const lo = r.u16();
+    const hi = r.u16();
+    if (lo > hi)
+      throw new MeshCodecError("bad-value", `port range ${lo}-${hi}`);
+    if (i > 0 && lo <= ports[i - 1].hi)
+      throw new MeshCodecError("not-sorted", "ports");
+    ports.push({ lo, hi });
+  }
+  const caps = r.u32();
+  const rule = { action, proto, srcGroups, srcCidrs, dstCidrs, ports, caps };
+  validateRule(rule);
+  return rule;
+}
+function ruleMatches(r, peerGroups, q) {
+  if (r.proto !== PROTO_ANY && r.proto !== q.proto)
+    return false;
+  if (r.srcGroups.length > 0 && !r.srcGroups.some((g) => peerGroups.has(g)))
+    return false;
+  if (r.srcCidrs.length > 0 && !r.srcCidrs.some((p) => p.afi === q.afi && prefixContainsAddr(p, q.src)))
+    return false;
+  if (r.dstCidrs.length > 0 && !r.dstCidrs.some((p) => p.afi === q.afi && prefixContainsAddr(p, q.dst)))
+    return false;
+  if (r.ports.length > 0) {
+    if (!PORTED.has(q.proto))
+      return false;
+    const dp = q.dport;
+    if (dp === void 0)
+      return false;
+    if (!r.ports.some((p) => dp >= p.lo && dp <= p.hi))
+      return false;
+  }
+  return true;
+}
+function evaluate(rules, peerGroups, q) {
+  for (let i = 0; i < rules.length; i++) {
+    if (ruleMatches(rules[i], peerGroups, q)) {
+      return {
+        allowed: rules[i].action === ACTION_ACCEPT,
+        caps: rules[i].action === ACTION_ACCEPT ? rules[i].caps : 0,
+        ruleIndex: i
+      };
+    }
+  }
+  return { allowed: false, caps: 0, ruleIndex: -1 };
+}
+function compilePeerFilter(rules, peerGroups) {
+  const live = rules.filter((r) => r.srcGroups.length === 0 || r.srcGroups.some((g) => peerGroups.has(g)));
+  if (live.length === 0)
+    return { kind: "deny-all" };
+  const first = live[0];
+  const unconditional = first.action === ACTION_ACCEPT && first.proto === PROTO_ANY && first.srcCidrs.length === 0 && first.dstCidrs.length === 0 && first.ports.length === 0;
+  if (unconditional)
+    return { kind: "allow-all", caps: first.caps };
+  return { kind: "rules", rules: live };
+}
+function applyPeerFilter(f, peerGroups, q) {
+  switch (f.kind) {
+    case "deny-all":
+      return { allowed: false, caps: 0 };
+    case "allow-all":
+      return { allowed: true, caps: f.caps };
+    case "rules": {
+      const r = evaluate(f.rules, peerGroups, q);
+      return { allowed: r.allowed, caps: r.caps };
+    }
+  }
+}
+function resolveGroups(groupTable, certGroups) {
+  const idx = new Map(groupTable.map((g, i) => [g, i]));
+  const out = /* @__PURE__ */ new Set();
+  for (const g of certGroups) {
+    const i = idx.get(g);
+    if (i !== void 0)
+      out.add(i);
+  }
+  return out;
+}
 var ACTION_ACCEPT, ACTION_DROP, PROTO_ANY, PROTO_ICMP, PROTO_TCP, PROTO_UDP, PROTO_ICMPV6, KNOWN_PROTOS, PORTED, CAP_EXIT_NODE, CAP_USE_ROUTE, KNOWN_CAPS;
 var init_policy = __esm({
   "../../packages/mesh-pki/dist/policy.js"() {
@@ -65660,6 +66259,14 @@ var init_policy = __esm({
 });
 
 // ../../packages/mesh-pki/dist/bundle.js
+function sortedUniqueBytes(items, what) {
+  const sorted = [...items].sort(cmpBytes);
+  for (let i = 1; i < sorted.length; i++) {
+    if (cmpBytes(sorted[i - 1], sorted[i]) === 0)
+      throw new MeshCodecError("duplicate", what);
+  }
+  return sorted;
+}
 function validateBundle(b) {
   if (b.version !== TPB_VERSION)
     throw new MeshCodecError("bad-value", `bundle version ${b.version}`);
@@ -65735,6 +66342,101 @@ function writeRevocations(w, items, width) {
   for (const it of items)
     w.fixed(it, width);
 }
+function readRevocations(r, width) {
+  const n = r.u16();
+  if (n > LIMITS.REVOKED)
+    throw new MeshCodecError("too-long", "revocations");
+  const out = [];
+  for (let i = 0; i < n; i++) {
+    const v = r.fixed(width);
+    if (i > 0) {
+      const c = cmpBytes(out[i - 1], v);
+      if (c === 0)
+        throw new MeshCodecError("duplicate", "revocations");
+      if (c > 0)
+        throw new MeshCodecError("not-sorted", "revocations");
+    }
+    out.push(v);
+  }
+  return out;
+}
+function decodeBundle(bytes2) {
+  if (bytes2.length > LIMITS.BUNDLE)
+    throw new MeshCodecError("too-long", "bundle");
+  const r = new Reader(bytes2);
+  const version2 = r.u8();
+  const genesisFp = r.fixed(32);
+  const epoch2 = r.u64();
+  const issuedAt = r.u64();
+  const maxStaleness = r.u32();
+  const nG = r.u16();
+  if (nG > LIMITS.GROUPS)
+    throw new MeshCodecError("too-long", "groupTable");
+  const groupTable = [];
+  for (let i = 0; i < nG; i++)
+    groupTable.push(r.str());
+  const nR = r.u16();
+  if (nR > LIMITS.RULES)
+    throw new MeshCodecError("too-long", "rules");
+  const rules = [];
+  for (let i = 0; i < nR; i++)
+    rules.push(readRule(r));
+  const nRo = r.u16();
+  if (nRo > LIMITS.ROSTER)
+    throw new MeshCodecError("too-long", "roster");
+  const roster = [];
+  for (let i = 0; i < nRo; i++) {
+    const e = {
+      nodeId: r.str(),
+      name: r.str(),
+      staticPub: r.fixed(32),
+      certFp: r.fixed(32),
+      ip4: r.u32(),
+      ip6: r.fixed(16)
+    };
+    if (i > 0) {
+      const c = cmpBytes(roster[i - 1].staticPub, e.staticPub);
+      if (c === 0)
+        throw new MeshCodecError("duplicate", "roster");
+      if (c > 0)
+        throw new MeshCodecError("not-sorted", "roster");
+    }
+    roster.push(e);
+  }
+  const revokedSerials = readRevocations(r, 16);
+  const revokedStatics = readRevocations(r, 32);
+  const nE = r.u16();
+  if (nE > LIMITS.ROSTER)
+    throw new MeshCodecError("too-long", "ip4Exceptions");
+  const ip4Exceptions = [];
+  for (let i = 0; i < nE; i++) {
+    const e = { staticPub: r.fixed(32), ip4: r.u32() };
+    if (i > 0) {
+      const c = cmpBytes(ip4Exceptions[i - 1].staticPub, e.staticPub);
+      if (c === 0)
+        throw new MeshCodecError("duplicate", "ip4Exceptions");
+      if (c > 0)
+        throw new MeshCodecError("not-sorted", "ip4Exceptions");
+    }
+    ip4Exceptions.push(e);
+  }
+  r.finish();
+  const b = {
+    version: version2,
+    genesisFp,
+    epoch: epoch2,
+    issuedAt,
+    maxStaleness,
+    groupTable,
+    rules,
+    roster,
+    revokedSerials,
+    revokedStatics,
+    ip4Exceptions
+  };
+  validateBundle(b);
+  return b;
+}
 function encodeSignedBundle(sb) {
   const body = encodeBundle(sb.bundle);
   const w = new Writer();
@@ -65744,6 +66446,13 @@ function encodeSignedBundle(sb) {
   });
   return w.finish();
 }
+function decodeSignedBundle(bytes2) {
+  const r = new Reader(bytes2);
+  const body = r.bytes(LIMITS.BUNDLE);
+  const sigs = r.vec((rr) => ({ keyIndex: rr.u8(), sig: rr.fixed(64) }));
+  r.finish();
+  return { bundle: decodeBundle(body), sigs };
+}
 async function signBundle(bundle, signers) {
   const body = encodeBundle(bundle);
   const sigs = [];
@@ -65752,7 +66461,38 @@ async function signBundle(bundle, signers) {
   }
   return { bundle, sigs };
 }
-var TPB_VERSION, DEFAULT_MAX_STALENESS_MS, cmpBytes;
+async function verifyBundle(sb, genesis, genesisFp, opts) {
+  const b = sb.bundle;
+  if (b.version !== TPB_VERSION)
+    return { ok: false, reason: "bad-version" };
+  if (!bytesEqual(b.genesisFp, genesisFp))
+    return { ok: false, reason: "wrong-mesh" };
+  if (opts.knownEpoch !== void 0 && b.epoch <= opts.knownEpoch) {
+    return { ok: false, reason: "rollback" };
+  }
+  if (!opts.ignoreStaleness && opts.now - b.issuedAt > b.maxStaleness) {
+    return { ok: false, reason: "stale" };
+  }
+  const body = encodeBundle(b);
+  const seen = /* @__PURE__ */ new Set();
+  for (const s of sb.sigs) {
+    if (s.keyIndex >= genesis.polKeys.length)
+      return { ok: false, reason: "bad-signature" };
+    if (seen.has(s.keyIndex))
+      return { ok: false, reason: "bad-signature" };
+    if (!await verify2(genesis.polKeys[s.keyIndex], body, s.sig)) {
+      return { ok: false, reason: "bad-signature" };
+    }
+    seen.add(s.keyIndex);
+  }
+  if (seen.size < genesis.kPol)
+    return { ok: false, reason: "quorum-not-met" };
+  return { ok: true };
+}
+async function bundleHash(b) {
+  return sha2562(encodeBundle(b));
+}
+var TPB_VERSION, DEFAULT_MAX_STALENESS_MS, cmpBytes, canonicalRoster, canonicalExceptions, canonicalRevocations, isFresh, revokes;
 var init_bundle = __esm({
   "../../packages/mesh-pki/dist/bundle.js"() {
     "use strict";
@@ -65768,6 +66508,11 @@ var init_bundle = __esm({
           return a[i] < b[i] ? -1 : 1;
       return a.length === b.length ? 0 : a.length < b.length ? -1 : 1;
     };
+    canonicalRoster = (r) => [...r].sort((a, b) => cmpBytes(a.staticPub, b.staticPub));
+    canonicalExceptions = (e) => [...e].sort((a, b) => cmpBytes(a.staticPub, b.staticPub));
+    canonicalRevocations = (r) => sortedUniqueBytes(r, "revocation");
+    isFresh = (b, now2) => now2 - b.issuedAt <= b.maxStaleness;
+    revokes = (b, serial, staticPub) => b.revokedSerials.some((s) => bytesEqual(s, serial)) || b.revokedStatics.some((s) => bytesEqual(s, staticPub));
   }
 });
 
@@ -67827,7 +68572,66 @@ zoo`.split("\n");
 });
 
 // ../../packages/mesh-pki/dist/sas.js
-var WORD_BITS, WORD_MASK, CTX_ENROLL;
+function wordsFromDigest(digest, count = SAS_WORDS) {
+  const bits = count * WORD_BITS;
+  if (bits < SAS_MIN_BITS) {
+    throw new MeshCodecError("bad-value", `${count} words = ${bits} bits, below the ${SAS_MIN_BITS}-bit floor`);
+  }
+  const needBytes = Math.ceil((bits + 7) / 8) + 1;
+  if (digest.length < needBytes) {
+    throw new MeshCodecError("bad-value", `digest too short: need ${needBytes}, got ${digest.length}`);
+  }
+  const out = [];
+  for (let i = 0; i < count; i++) {
+    const bitOffset = i * WORD_BITS;
+    const byteIdx = bitOffset >>> 3;
+    const bitInByte = bitOffset & 7;
+    const chunk = (digest[byteIdx] << 16 | digest[byteIdx + 1] << 8 | digest[byteIdx + 2]) >>> 0;
+    const idx = chunk >>> 24 - bitInByte - WORD_BITS & WORD_MASK;
+    out.push(wordlist[idx]);
+  }
+  return out;
+}
+function enrolmentSas(genesisFp, staticPub, count = SAS_WORDS) {
+  if (genesisFp.length !== 32)
+    throw new MeshCodecError("bad-value", "genesisFp must be 32 bytes");
+  if (staticPub.length !== 32)
+    throw new MeshCodecError("bad-value", "staticPub must be 32 bytes");
+  return wordsFromDigest(blake2s256(concat2(CTX_ENROLL, genesisFp, staticPub)), count);
+}
+function fingerprintWords(genesisFp, count = SAS_WORDS) {
+  if (genesisFp.length !== 32)
+    throw new MeshCodecError("bad-value", "genesisFp must be 32 bytes");
+  return wordsFromDigest(genesisFp, count);
+}
+function nameWords(entropy, count = 2) {
+  if (count < 1 || count > 8)
+    throw new MeshCodecError("bad-value", `nameWords count ${count}`);
+  if (entropy.length < count * 2) {
+    throw new MeshCodecError("bad-value", "not enough entropy for that many words");
+  }
+  const out = [];
+  for (let i = 0; i < count; i++) {
+    const idx = (entropy[i * 2] << 8 | entropy[i * 2 + 1]) & 2047;
+    out.push(wordlist[idx]);
+  }
+  return out;
+}
+function sasEqual(a, b) {
+  if (a.length !== b.length)
+    return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) {
+    const x = a[i];
+    const y = b[i];
+    diff |= x.length ^ y.length;
+    for (let j = 0; j < Math.max(x.length, y.length); j++) {
+      diff |= (x.charCodeAt(j) | 0) ^ (y.charCodeAt(j) | 0);
+    }
+  }
+  return diff === 0;
+}
+var WORD_BITS, WORD_MASK, SAS_WORDS, SAS_MIN_BITS, CTX_ENROLL, formatWords;
 var init_sas = __esm({
   "../../packages/mesh-pki/dist/sas.js"() {
     "use strict";
@@ -67836,10 +68640,13 @@ var init_sas = __esm({
     init_crypto();
     WORD_BITS = 11;
     WORD_MASK = (1 << WORD_BITS) - 1;
-    CTX_ENROLL = utf83("tsr-enroll-sas-v1");
+    SAS_WORDS = 6;
+    SAS_MIN_BITS = 64;
+    CTX_ENROLL = utf82("tsr-enroll-sas-v1");
     if (wordlist.length !== 1 << WORD_BITS) {
       throw new Error(`BIP-39 wordlist must have ${1 << WORD_BITS} entries, got ${wordlist.length}`);
     }
+    formatWords = (words) => words.join("-");
   }
 });
 
@@ -67874,7 +68681,7 @@ function clean(...arrays) {
 function createView(arr) {
   return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
 }
-function rotr(word, shift) {
+function rotr2(word, shift) {
   return word << 32 - shift | word >>> shift;
 }
 function utf8ToBytes2(str3) {
@@ -68136,15 +68943,15 @@ var init_sha2 = __esm({
         for (let i = 16; i < 64; i++) {
           const W15 = SHA256_W[i - 15];
           const W2 = SHA256_W[i - 2];
-          const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
-          const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
+          const s0 = rotr2(W15, 7) ^ rotr2(W15, 18) ^ W15 >>> 3;
+          const s1 = rotr2(W2, 17) ^ rotr2(W2, 19) ^ W2 >>> 10;
           SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
         }
         let { A, B, C, D, E, F, G: G2, H } = this;
         for (let i = 0; i < 64; i++) {
-          const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+          const sigma1 = rotr2(E, 6) ^ rotr2(E, 11) ^ rotr2(E, 25);
           const T1 = H + sigma1 + Chi(E, F, G2) + SHA256_K[i] + SHA256_W[i] | 0;
-          const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+          const sigma0 = rotr2(A, 2) ^ rotr2(A, 13) ^ rotr2(A, 22);
           const T2 = sigma0 + Maj(A, B, C) | 0;
           H = G2;
           G2 = F;
@@ -68254,7 +69061,7 @@ function alphabet(letters) {
   };
 }
 // @__NO_SIDE_EFFECTS__
-function join70(separator = "") {
+function join61(separator = "") {
   astr("join", separator);
   return {
     encode: (from) => {
@@ -68459,13 +69266,25 @@ var init_esm = __esm({
       convertRadix2,
       radix,
       radix2,
-      join: join70,
+      join: join61,
       padding
     };
   }
 });
 
 // ../../node_modules/@scure/bip39/esm/index.js
+function nfkd(str3) {
+  if (typeof str3 !== "string")
+    throw new TypeError("invalid mnemonic type: " + typeof str3);
+  return str3.normalize("NFKD");
+}
+function normalize2(str3) {
+  const norm = nfkd(str3);
+  const words = norm.split(" ");
+  if (![12, 15, 18, 21, 24].includes(words.length))
+    throw new Error("Invalid mnemonic");
+  return { nfkd: norm, words };
+}
 function aentropy(ent) {
   abytes(ent, 16, 20, 24, 28, 32);
 }
@@ -68478,11 +69297,25 @@ function getCoder(wordlist2) {
   });
   return utils.chain(utils.checksum(1, calcChecksum), utils.radix2(11, true), utils.alphabet(wordlist2));
 }
+function mnemonicToEntropy(mnemonic, wordlist2) {
+  const { words } = normalize2(mnemonic);
+  const entropy = getCoder(wordlist2).decode(words);
+  aentropy(entropy);
+  return entropy;
+}
 function entropyToMnemonic(entropy, wordlist2) {
   aentropy(entropy);
   const words = getCoder(wordlist2).encode(entropy);
   return words.join(isJapanese(wordlist2) ? "\u3000" : " ");
 }
+function validateMnemonic(mnemonic, wordlist2) {
+  try {
+    mnemonicToEntropy(mnemonic, wordlist2);
+  } catch (e) {
+    return false;
+  }
+  return true;
+}
 var isJapanese, calcChecksum;
 var init_esm2 = __esm({
   "../../node_modules/@scure/bip39/esm/index.js"() {
@@ -68504,7 +69337,7 @@ function validateKdf2(k) {
     throw new MeshCodecError("bad-value", `unsupported KDF cost (m=${k.m} t=${k.t} p=${k.p})`);
 }
 function kdf(passphrase, salt, cost) {
-  return argon2id(utf83(passphrase.normalize("NFKC")), salt, { ...cost, dkLen: KEY_LEN });
+  return argon2id(utf82(passphrase.normalize("NFKC")), salt, { ...cost, dkLen: KEY_LEN });
 }
 function header(version2, label, kdfCost, salt, nonce2) {
   const w = new Writer();
@@ -68522,8 +69355,8 @@ async function sealCaKey(seed, passphrase, label = "mesh CA", cost = DEFAULT_KDF
   if (label.length > MAX_LABEL)
     throw new MeshCodecError("too-long", "label too long");
   validateKdf2(cost);
-  const salt = randomBytes9(SALT_LEN);
-  const nonce2 = randomBytes9(NONCE_LEN);
+  const salt = randomBytes7(SALT_LEN);
+  const nonce2 = randomBytes7(NONCE_LEN);
   const aad = header(RECOVERY_VERSION, label, cost, salt, nonce2);
   const key2 = await aesKey(kdf(passphrase, salt, cost));
   const ct = new Uint8Array(await crypto.subtle.encrypt({ name: "AES-GCM", iv: nonce2, additionalData: aad }, key2, seed));
@@ -68568,11 +69401,26 @@ function caKeyToMnemonic(seed) {
     throw new MeshCodecError("bad-value", `CA seed must be ${SECRET_LEN} bytes`);
   return entropyToMnemonic(seed, wordlist);
 }
+function caKeyFromMnemonic(mnemonic) {
+  const norm = mnemonic.normalize("NFKD").trim().replace(/\s+/g, " ").toLowerCase();
+  if (norm.split(" ").length !== MNEMONIC_WORDS) {
+    throw new MeshCodecError("bad-value", `recovery mnemonic must be ${MNEMONIC_WORDS} words`);
+  }
+  if (!validateMnemonic(norm, wordlist)) {
+    throw new MeshCodecError("bad-value", "recovery mnemonic failed its checksum \u2014 check for a mistyped word");
+  }
+  return mnemonicToEntropy(norm, wordlist);
+}
 async function newDisablement() {
-  const secret = randomBytes9(SECRET_LEN);
+  const secret = randomBytes7(SECRET_LEN);
   return { secret, hash: await sha2562(secret) };
 }
-var RECOVERY_VERSION, SECRET_LEN, KDF_MEMORY_KIB, KDF_PASSES, KDF_LANES, DEFAULT_KDF, KDF_MIN, KDF_MAX, SALT_LEN, NONCE_LEN, KEY_LEN, MAX_LABEL, DOMAIN;
+async function verifyDisablement(secret, committedHash) {
+  if (secret.length !== SECRET_LEN || committedHash.length !== 32)
+    return false;
+  return bytesEqual(await sha2562(secret), committedHash);
+}
+var RECOVERY_VERSION, SECRET_LEN, MNEMONIC_WORDS, KDF_MEMORY_KIB, KDF_PASSES, KDF_LANES, DEFAULT_KDF, KDF_MIN, KDF_MAX, SALT_LEN, NONCE_LEN, KEY_LEN, MAX_LABEL, DOMAIN;
 var init_recovery = __esm({
   "../../packages/mesh-pki/dist/recovery.js"() {
     "use strict";
@@ -68583,6 +69431,7 @@ var init_recovery = __esm({
     init_crypto();
     RECOVERY_VERSION = 1;
     SECRET_LEN = 32;
+    MNEMONIC_WORDS = 24;
     KDF_MEMORY_KIB = 64 * 1024;
     KDF_PASSES = 3;
     KDF_LANES = 4;
@@ -68593,12 +69442,114 @@ var init_recovery = __esm({
     NONCE_LEN = 12;
     KEY_LEN = 32;
     MAX_LABEL = 128;
-    DOMAIN = utf83("tesseract-mesh-recovery-v1");
+    DOMAIN = utf82("tesseract-mesh-recovery-v1");
   }
 });
 
 // ../../packages/mesh-pki/dist/enroll.js
-var DEFAULT_TICKET_TTL_MS;
+async function mintJoinTicket(opts) {
+  const genesisFp = await genesisFingerprint(opts.genesis);
+  const ttl = opts.ttlMs ?? DEFAULT_TICKET_TTL_MS;
+  const details = {
+    version: 1,
+    serial: randomBytes7(16),
+    genesisFp,
+    nodeId: opts.nodeId,
+    name: opts.name,
+    // The intermediate is a signing identity, not a data-plane peer. It carries no
+    // usable X25519 static key — the redeeming node supplies its own.
+    staticPub: new Uint8Array(32),
+    sigPub: opts.intermediate.publicRaw,
+    overlayIp4: opts.overlayIp4,
+    overlayIp6: opts.overlayIp6,
+    routes: canonicalPrefixes(opts.routes ?? []),
+    flags: FLAG_IS_CA,
+    groups: canonicalStrs(opts.groups),
+    notBefore: opts.now - 6e4,
+    // small backdate absorbs clock skew at redemption
+    notAfter: opts.now + ttl,
+    issuerFp: genesisFp
+  };
+  return {
+    genesis: opts.genesis,
+    caCert: await issueCert(details, opts.signers),
+    caPrivate: opts.intermediate.privateScalar
+  };
+}
+function encodeJoinTicket(t) {
+  const w = new Writer();
+  w.u8(TICKET_VERSION);
+  w.bytes(encodeGenesis(t.genesis), LIMITS.GENESIS);
+  w.bytes(encodeCert(t.caCert), LIMITS.CERT);
+  w.fixed(t.caPrivate, 32);
+  return w.finish();
+}
+function decodeJoinTicket(bytes2) {
+  const r = new Reader(bytes2);
+  const version2 = r.u8();
+  if (version2 !== TICKET_VERSION)
+    throw new MeshCodecError("bad-value", `ticket version ${version2}`);
+  const genesis = decodeGenesis(r.bytes(LIMITS.GENESIS));
+  const caCert = decodeCert(r.bytes(LIMITS.CERT));
+  const caPrivate = r.fixed(32);
+  r.finish();
+  return { genesis, caCert, caPrivate };
+}
+async function redeemJoinTicket(opts) {
+  const { ticket } = opts;
+  const ca = ticket.caCert.details;
+  if (!(ca.flags & FLAG_IS_CA))
+    return { ok: false, reason: "ticket-not-ca" };
+  if (opts.now > ca.notAfter)
+    return { ok: false, reason: "ticket-expired" };
+  const groups = canonicalStrs(opts.groups ?? ca.groups);
+  const parentGroups = new Set(ca.groups);
+  if (groups.some((g) => !parentGroups.has(g)))
+    return { ok: false, reason: "widens-groups" };
+  const routes = canonicalPrefixes(opts.routes ?? ca.routes);
+  const parentKeys = new Set(ca.routes.map((p) => `${p.afi}/${p.len}/${p.addr.join(".")}`));
+  if (routes.some((p) => !parentKeys.has(`${p.afi}/${p.len}/${p.addr.join(".")}`))) {
+    return { ok: false, reason: "widens-routes" };
+  }
+  const wanted2 = opts.now + (opts.leafTtlMs ?? DEFAULT_TICKET_TTL_MS);
+  const notAfter = Math.min(wanted2, ca.notAfter);
+  const genesisFp = await genesisFingerprint(ticket.genesis);
+  const details = {
+    version: 1,
+    serial: randomBytes7(16),
+    genesisFp,
+    nodeId: opts.nodeId ?? ca.nodeId,
+    name: opts.name ?? ca.name,
+    staticPub: opts.staticPub,
+    sigPub: opts.sigPub,
+    // Pinned by the ticket — narrowing forbids changing these.
+    overlayIp4: ca.overlayIp4,
+    overlayIp6: ca.overlayIp6,
+    routes,
+    flags: 0,
+    groups,
+    notBefore: opts.now - 6e4,
+    notAfter,
+    issuerFp: await certFingerprint(ca)
+  };
+  const key2 = await importSigningPrivate({
+    kty: "OKP",
+    crv: "Ed25519",
+    d: b64u2(ticket.caPrivate),
+    x: b64u2(ca.sigPub),
+    key_ops: ["sign"],
+    ext: true
+  });
+  const leaf = await issueCert(details, [{ keyIndex: 0, privateKey: key2.privateKey }]);
+  return {
+    ok: true,
+    result: { leaf, genesis: ticket.genesis, intermediates: [ticket.caCert] }
+  };
+}
+async function predictOverlayV6(genesis, staticPub) {
+  return deriveOverlayV6(genesis.meshPrefix6, await genesisFingerprint(genesis), staticPub);
+}
+var TICKET_VERSION, DEFAULT_TICKET_TTL_MS, joinTicketToString, joinTicketFromString;
 var init_enroll = __esm({
   "../../packages/mesh-pki/dist/enroll.js"() {
     "use strict";
@@ -68609,11 +69560,167 @@ var init_enroll = __esm({
     init_crypto();
     init_codec();
     init_addr();
+    TICKET_VERSION = 1;
     DEFAULT_TICKET_TTL_MS = 15 * 60 * 1e3;
+    joinTicketToString = (t) => b64u2(encodeJoinTicket(t));
+    joinTicketFromString = (s) => decodeJoinTicket(unb64u2(s));
   }
 });
 
 // ../../packages/mesh-pki/dist/index.js
+var dist_exports3 = {};
+__export(dist_exports3, {
+  ACTION_ACCEPT: () => ACTION_ACCEPT,
+  ACTION_DROP: () => ACTION_DROP,
+  AFI_V4: () => AFI_V4,
+  AFI_V6: () => AFI_V6,
+  CAP_EXIT_NODE: () => CAP_EXIT_NODE,
+  CAP_USE_ROUTE: () => CAP_USE_ROUTE,
+  CLOCK_SKEW_MS: () => CLOCK_SKEW_MS,
+  DEFAULT_MAX_STALENESS_MS: () => DEFAULT_MAX_STALENESS_MS,
+  DEFAULT_MESH_CIDR4: () => DEFAULT_MESH_CIDR4,
+  DEFAULT_TICKET_TTL_MS: () => DEFAULT_TICKET_TTL_MS,
+  ED25519: () => ED25519,
+  FLAG_IS_CA: () => FLAG_IS_CA,
+  FLAG_IS_EPHEMERAL: () => FLAG_IS_EPHEMERAL,
+  FLAG_IS_EXIT_NODE: () => FLAG_IS_EXIT_NODE,
+  FLAG_IS_RELAY: () => FLAG_IS_RELAY,
+  GENESIS_VERSION: () => GENESIS_VERSION,
+  KDF_LANES: () => KDF_LANES,
+  KDF_MEMORY_KIB: () => KDF_MEMORY_KIB,
+  KDF_PASSES: () => KDF_PASSES,
+  LIMITS: () => LIMITS,
+  MAX_CHAIN_DEPTH: () => MAX_CHAIN_DEPTH,
+  MIN_MESH_PREFIX_LEN: () => MIN_MESH_PREFIX_LEN,
+  MNEMONIC_WORDS: () => MNEMONIC_WORDS,
+  MeshCodecError: () => MeshCodecError,
+  PROTO_ANY: () => PROTO_ANY,
+  PROTO_ICMP: () => PROTO_ICMP,
+  PROTO_ICMPV6: () => PROTO_ICMPV6,
+  PROTO_TCP: () => PROTO_TCP,
+  PROTO_UDP: () => PROTO_UDP,
+  RECOVERY_VERSION: () => RECOVERY_VERSION,
+  Reader: () => Reader,
+  SAS_MIN_BITS: () => SAS_MIN_BITS,
+  SAS_WORDS: () => SAS_WORDS,
+  SECRET_LEN: () => SECRET_LEN,
+  TICKET_VERSION: () => TICKET_VERSION,
+  TNC_VERSION: () => TNC_VERSION,
+  TPB_VERSION: () => TPB_VERSION,
+  Writer: () => Writer,
+  X25519: () => X25519,
+  addrToU32: () => addrToU32,
+  applyPeerFilter: () => applyPeerFilter,
+  b64u: () => b64u2,
+  blake2s256: () => blake2s256,
+  bundleHash: () => bundleHash,
+  bytesEqual: () => bytesEqual,
+  caKeyFromMnemonic: () => caKeyFromMnemonic,
+  caKeyToMnemonic: () => caKeyToMnemonic,
+  canonicalExceptions: () => canonicalExceptions,
+  canonicalGroups: () => canonicalGroups,
+  canonicalPorts: () => canonicalPorts,
+  canonicalPrefixes: () => canonicalPrefixes,
+  canonicalRevocations: () => canonicalRevocations,
+  canonicalRoster: () => canonicalRoster,
+  canonicalStrs: () => canonicalStrs,
+  certFingerprint: () => certFingerprint,
+  checkNarrowing: () => checkNarrowing,
+  comparePrefix: () => comparePrefix,
+  compareUtf8: () => compareUtf8,
+  compilePeerFilter: () => compilePeerFilter,
+  concat: () => concat2,
+  decodeBundle: () => decodeBundle,
+  decodeCert: () => decodeCert,
+  decodeDetails: () => decodeDetails,
+  decodeGenesis: () => decodeGenesis,
+  decodeJoinTicket: () => decodeJoinTicket,
+  decodeRecoveryBundle: () => decodeRecoveryBundle,
+  decodeSignedBundle: () => decodeSignedBundle,
+  decodeSignedGenesis: () => decodeSignedGenesis,
+  deriveMeshPrefix6: () => deriveMeshPrefix6,
+  deriveOverlayV4Hint: () => deriveOverlayV4Hint,
+  deriveOverlayV6: () => deriveOverlayV6,
+  encodeBundle: () => encodeBundle,
+  encodeCert: () => encodeCert,
+  encodeDetails: () => encodeDetails,
+  encodeGenesis: () => encodeGenesis,
+  encodeJoinTicket: () => encodeJoinTicket,
+  encodeRecoveryBundle: () => encodeRecoveryBundle,
+  encodeSignedBundle: () => encodeSignedBundle,
+  encodeSignedGenesis: () => encodeSignedGenesis,
+  enrolmentSas: () => enrolmentSas,
+  evaluate: () => evaluate,
+  exportSigningPrivate: () => exportSigningPrivate,
+  exportStaticPrivate: () => exportStaticPrivate,
+  fingerprintShort: () => fingerprintShort,
+  fingerprintWords: () => fingerprintWords,
+  formatAddr: () => formatAddr,
+  formatPrefix: () => formatPrefix,
+  formatWords: () => formatWords,
+  generateSigningKey: () => generateSigningKey,
+  generateStaticKey: () => generateStaticKey,
+  genesisFingerprint: () => genesisFingerprint,
+  hex: () => hex3,
+  importSigningPrivate: () => importSigningPrivate,
+  importSigningPublic: () => importSigningPublic,
+  isCa: () => isCa,
+  isExitNode: () => isExitNode,
+  isFresh: () => isFresh,
+  isMasked: () => isMasked,
+  isRelay: () => isRelay,
+  isValidMeshRange: () => isValidMeshRange,
+  issueCert: () => issueCert,
+  joinTicketFromString: () => joinTicketFromString,
+  joinTicketToString: () => joinTicketToString,
+  makeGenesis: () => makeGenesis,
+  makePrefix: () => makePrefix,
+  makeRule: () => makeRule,
+  mask: () => mask,
+  maxLenOf: () => maxLenOf,
+  maySourceAddr: () => maySourceAddr,
+  meshFqdn: () => meshFqdn,
+  mintJoinTicket: () => mintJoinTicket,
+  nameWords: () => nameWords,
+  newDisablement: () => newDisablement,
+  openCaKey: () => openCaKey,
+  parseAddr: () => parseAddr,
+  parsePrefix: () => parsePrefix,
+  predictOverlayV6: () => predictOverlayV6,
+  prefixContains: () => prefixContains,
+  prefixContainsAddr: () => prefixContainsAddr,
+  prefixEqual: () => prefixEqual,
+  randomBytes: () => randomBytes7,
+  readPrefix: () => readPrefix,
+  readPrefixes: () => readPrefixes,
+  readRule: () => readRule,
+  redeemJoinTicket: () => redeemJoinTicket,
+  resolveGroups: () => resolveGroups,
+  revokes: () => revokes,
+  sasEqual: () => sasEqual,
+  sealCaKey: () => sealCaKey,
+  sha256: () => sha2562,
+  sign: () => sign2,
+  signBundle: () => signBundle,
+  signGenesis: () => signGenesis,
+  signingKeyFromSeed: () => signingKeyFromSeed,
+  u32ToAddr: () => u32ToAddr,
+  unb64u: () => unb64u2,
+  utf8: () => utf82,
+  validateBundle: () => validateBundle,
+  validateDetails: () => validateDetails,
+  validateGenesis: () => validateGenesis,
+  verify: () => verify2,
+  verifyBundle: () => verifyBundle,
+  verifyCert: () => verifyCert,
+  verifyDisablement: () => verifyDisablement,
+  verifyGenesis: () => verifyGenesis,
+  widthOf: () => widthOf,
+  wordsFromDigest: () => wordsFromDigest,
+  writePrefix: () => writePrefix,
+  writePrefixes: () => writePrefixes,
+  writeRule: () => writeRule
+});
 var init_dist6 = __esm({
   "../../packages/mesh-pki/dist/index.js"() {
     "use strict";
@@ -69782,7 +70889,7 @@ async function netCaCommand(rest, flags) {
     if (pass.length < 12) die("Use a passphrase of at least 12 characters \u2014 this key issues every identity on the mesh.");
     const confirm2 = await readPassphrase("Confirm: ");
     if (pass !== confirm2) die("Passphrases did not match.");
-    const seed = randomBytes9(SEED_LEN);
+    const seed = randomBytes7(SEED_LEN);
     const ca = await signingKeyFromSeed(seed);
     const pol = ca;
     const disable = await newDisablement();
@@ -69847,7 +70954,7 @@ Next, issue an identity for a machine (pick a free address in ${formatPrefix(gen
     const cert = await issueCert(
       {
         version: 1,
-        serial: randomBytes9(16),
+        serial: randomBytes7(16),
         genesisFp: fp,
         nodeId: name,
         name,
@@ -72086,10 +73193,10 @@ function createHostedVerification() {
       let reviewText = "";
       for (let i = 0; i < rv.RV_MAX_CYCLES * 2 + 2; i++) {
         const gate = state3.phase === "review" ? "review" : "completeness";
-        const call2 = gate === "review" ? rv.reviewGrade(task, reviewText || text9) : rv.completenessGrade(task, text9, todos);
+        const call3 = gate === "review" ? rv.reviewGrade(task, reviewText || text9) : rv.completenessGrade(task, text9, todos);
         let verdict = null;
         try {
-          verdict = rv.parseVerdict(await grade({ model, system: call2.system, prompt: call2.prompt, maxTokens: 16e3, schema: call2.schema }));
+          verdict = rv.parseVerdict(await grade({ model, system: call3.system, prompt: call3.prompt, maxTokens: 16e3, schema: call3.schema }));
         } catch {
           verdict = null;
         }
@@ -73373,7 +74480,7 @@ async function pickPort() {
 var CALL_TIMEOUT_MS = 8e3;
 function createEngineHttpApi(port, host = "127.0.0.1") {
   const baseUrl = `http://${host}:${port}`;
-  async function call2(method, path6, body, timeoutMs = CALL_TIMEOUT_MS) {
+  async function call3(method, path6, body, timeoutMs = CALL_TIMEOUT_MS) {
     const ac = new AbortController();
     const timer2 = setTimeout(() => ac.abort(), timeoutMs);
     try {
@@ -73401,12 +74508,12 @@ function createEngineHttpApi(port, host = "127.0.0.1") {
   }
   return {
     baseUrl,
-    get: (path6, timeoutMs) => call2("GET", path6, void 0, timeoutMs),
-    post: (path6, body, timeoutMs, method) => call2(method ?? "POST", path6, body, timeoutMs),
+    get: (path6, timeoutMs) => call3("GET", path6, void 0, timeoutMs),
+    post: (path6, body, timeoutMs, method) => call3(method ?? "POST", path6, body, timeoutMs),
     async ready(timeoutMs = 5e3) {
       const deadline = Date.now() + timeoutMs;
       while (Date.now() < deadline) {
-        const h = await call2("GET", "/global/health", void 0, 1500);
+        const h = await call3("GET", "/global/health", void 0, 1500);
         if (h && h !== true && h.healthy !== false)
           return true;
         if (h === true)
@@ -74784,20 +75891,20 @@ ${text9}`);
   }
   async function sendMessage(params) {
     const origin = params.origin;
-    const fail3 = (sessionId, error51, transient = false) => send4({ type: "chat:error", sessionId, clientRequestId: params.clientRequestId, error: error51, ...transient ? { transient: true } : {} }, origin);
+    const fail4 = (sessionId, error51, transient = false) => send4({ type: "chat:error", sessionId, clientRequestId: params.clientRequestId, error: error51, ...transient ? { transient: true } : {} }, origin);
     const spawnCfg = resolve16(engine.id);
     if (!spawnCfg) {
-      fail3(params.sessionId ?? "", `${engine.label} isn't installed or configured. Open Settings \u2192 Models & accounts.`);
+      fail4(params.sessionId ?? "", `${engine.label} isn't installed or configured. Open Settings \u2192 Models & accounts.`);
       return;
     }
     const configError = spawnConfigError(spawnCfg);
     if (configError) {
-      fail3(params.sessionId ?? "", configError);
+      fail4(params.sessionId ?? "", configError);
       send4({ type: "agent:status", sessionId: params.sessionId ?? "", clientRequestId: params.clientRequestId, status: "error" }, origin);
       return;
     }
     if (!params.projectDir) {
-      fail3(params.sessionId ?? "", "No project folder is open. Open a folder to start working with the agent.");
+      fail4(params.sessionId ?? "", "No project folder is open. Open a folder to start working with the agent.");
       return;
     }
     let t;
@@ -74819,13 +75926,13 @@ ${text9}`);
     try {
       t = await ensureProcess(spawnCfg.command, spawnCfg.env, params.projectDir, mcpSpecsFor(params), !!wantSandbox, JSON.stringify(engine.askEnv?.(params.permissionMode) ?? null));
     } catch (e) {
-      fail3(params.sessionId ?? "", `OpenCode failed to start: ${String(e?.message ?? e)}`, true);
+      fail4(params.sessionId ?? "", `OpenCode failed to start: ${String(e?.message ?? e)}`, true);
       return;
     }
     if (params.message.trim() === "/compact" && !engine.compactCommand && params.sessionId) {
       const from = params.sessionId;
       if (turns.has(from)) {
-        fail3(from, `${engine.label} is still working on this conversation \u2014 compaction will run once it finishes.`, false);
+        fail4(from, `${engine.label} is still working on this conversation \u2014 compaction will run once it finishes.`, false);
         send4({ type: "agent:status", sessionId: from, clientRequestId: params.clientRequestId, status: "idle" }, origin);
         return;
       }
@@ -74853,7 +75960,7 @@ ${text9}`);
         turns.delete(from);
       }
       if (!snapshot3) {
-        fail3(from, `${engine.label} could not summarise this conversation to compact it.`, false);
+        fail4(from, `${engine.label} could not summarise this conversation to compact it.`, false);
         send4({ type: "agent:status", sessionId: from, clientRequestId: params.clientRequestId, status: "idle" }, origin);
         return;
       }
@@ -74861,7 +75968,7 @@ ${text9}`);
       const fresh = await t.request("session/new", { cwd: params.projectDir, mcpServers: mcpServersFor(params, compactHold) }).catch(() => null);
       const next = fresh?.sessionId;
       if (!next) {
-        fail3(from, `${engine.label} could not open a fresh session to compact into.`, true);
+        fail4(from, `${engine.label} could not open a fresh session to compact into.`, true);
         send4({ type: "agent:status", sessionId: from, clientRequestId: params.clientRequestId, status: "error" }, origin);
         return;
       }
@@ -74932,7 +76039,7 @@ ${text9}`);
       await applyRunMode(t, sid, params.permissionMode, params.model);
       await applyThinking(t, sid, params.thinking);
     } catch (e) {
-      fail3(params.sessionId ?? "", `Couldn't start a ${engineLabel} session: ${String(e?.message ?? e)}`, true);
+      fail4(params.sessionId ?? "", `Couldn't start a ${engineLabel} session: ${String(e?.message ?? e)}`, true);
       return;
     }
     const userSeq = userTurnSeq.get(sid) ?? 0;
@@ -75067,7 +76174,7 @@ ${text9}`);
         send4({ type: "agent:status", sessionId: sid, clientRequestId: params.clientRequestId, status: "idle" }, origin);
         return;
       }
-      fail3(sid, overflow ? `${CONTEXT_OVERFLOW_HINT}
+      fail4(sid, overflow ? `${CONTEXT_OVERFLOW_HINT}
 
 ${detail}` : detail, !overflow);
       send4({ type: "agent:status", sessionId: sid, clientRequestId: params.clientRequestId, status: "error" }, origin);
@@ -76090,7 +77197,7 @@ function createCodexAppServerBackend(send4, resolve16, onBrowserRequest, loadPlu
   }
   const pendingApprovals = /* @__PURE__ */ new Map();
   const pendingDialogs = /* @__PURE__ */ new Map();
-  const fail3 = (sessionId, clientRequestId, error51, origin, transient = false) => {
+  const fail4 = (sessionId, clientRequestId, error51, origin, transient = false) => {
     send4({ type: "chat:error", sessionId, clientRequestId, error: error51, ...transient ? { transient: true } : {} }, origin);
   };
   function parkApproval(raw, toolName, allow, allowPersist, deny, detail) {
@@ -76292,7 +77399,7 @@ function createCodexAppServerBackend(send4, resolve16, onBrowserRequest, loadPlu
         const t = p.turn ?? {};
         if (t.status === "failed" && !turn.reported) {
           turn.reported = true;
-          fail3(threadId, turn.clientRequestId, codexErrorText(t.error), turn.origin, true);
+          fail4(threadId, turn.clientRequestId, codexErrorText(t.error), turn.origin, true);
         }
         turn.finish(t.status ?? null);
         return;
@@ -76303,7 +77410,7 @@ function createCodexAppServerBackend(send4, resolve16, onBrowserRequest, loadPlu
           return;
         if (!turn.reported) {
           turn.reported = true;
-          fail3(threadId, turn.clientRequestId, codexErrorText(p.error), turn.origin, true);
+          fail4(threadId, turn.clientRequestId, codexErrorText(p.error), turn.origin, true);
         }
         turn.finish(null);
         return;
@@ -76377,7 +77484,7 @@ function createCodexAppServerBackend(send4, resolve16, onBrowserRequest, loadPlu
         spawnedCwd = null;
         for (const [tid, turn] of turns) {
           turn.finish(null);
-          fail3(tid, turn.clientRequestId, `${label} restarted.`, turn.origin, true);
+          fail4(tid, turn.clientRequestId, `${label} restarted.`, turn.origin, true);
         }
         turns.clear();
         for (const w of compactWaiters.values())
@@ -76496,17 +77603,17 @@ function createCodexAppServerBackend(send4, resolve16, onBrowserRequest, loadPlu
     const origin = params.origin;
     const cfg2 = resolve16(ENGINE_ID2);
     if (!cfg2) {
-      fail3(params.sessionId ?? "", params.clientRequestId, `${label} isn't installed or configured. Open Settings \u2192 Models & accounts.`, origin);
+      fail4(params.sessionId ?? "", params.clientRequestId, `${label} isn't installed or configured. Open Settings \u2192 Models & accounts.`, origin);
       return;
     }
     const cfgErr = spawnConfigError(cfg2);
     if (cfgErr) {
-      fail3(params.sessionId ?? "", params.clientRequestId, cfgErr, origin);
+      fail4(params.sessionId ?? "", params.clientRequestId, cfgErr, origin);
       send4({ type: "agent:status", sessionId: params.sessionId ?? "", clientRequestId: params.clientRequestId, status: "error" }, origin);
       return;
     }
     if (!params.projectDir) {
-      fail3(params.sessionId ?? "", params.clientRequestId, "No project folder is open. Open a folder to start working with the agent.", origin);
+      fail4(params.sessionId ?? "", params.clientRequestId, "No project folder is open. Open a folder to start working with the agent.", origin);
       return;
     }
     await ensureHostedToolset();
@@ -76514,7 +77621,7 @@ function createCodexAppServerBackend(send4, resolve16, onBrowserRequest, loadPlu
     try {
       t = await ensureProcess(cfg2.command, cfg2.env, params.projectDir);
     } catch (e) {
-      fail3(params.sessionId ?? "", params.clientRequestId, `${label} failed to start: ${String(e?.message ?? e)}`, origin, true);
+      fail4(params.sessionId ?? "", params.clientRequestId, `${label} failed to start: ${String(e?.message ?? e)}`, origin, true);
       return;
     }
     await installTools(t, { ...injectedServers, ...params.mcpServers ?? {} });
@@ -76546,18 +77653,18 @@ function createCodexAppServerBackend(send4, resolve16, onBrowserRequest, loadPlu
       if (model)
         sessionModel.set(threadId, model);
     } catch (e) {
-      fail3(params.sessionId ?? "", params.clientRequestId, `Couldn't start a ${label} thread: ${String(e?.message ?? e)}`, origin, true);
+      fail4(params.sessionId ?? "", params.clientRequestId, `Couldn't start a ${label} thread: ${String(e?.message ?? e)}`, origin, true);
       return;
     }
     if (params.message.trim() === "/compact") {
       const ok = await t.request("thread/compact/start", { threadId }).then(() => true).catch(() => false);
       if (!ok) {
-        fail3(threadId, params.clientRequestId, `${label} could not compact this conversation.`, origin);
+        fail4(threadId, params.clientRequestId, `${label} could not compact this conversation.`, origin);
         send4({ type: "agent:status", sessionId: threadId, clientRequestId: params.clientRequestId, status: "error" }, origin);
         return;
       }
       if (compactWaiters.has(threadId)) {
-        fail3(threadId, params.clientRequestId, `${label} is already compacting this conversation.`, origin);
+        fail4(threadId, params.clientRequestId, `${label} is already compacting this conversation.`, origin);
         send4({ type: "agent:status", sessionId: threadId, clientRequestId: params.clientRequestId, status: "idle" }, origin);
         return;
       }
@@ -76578,7 +77685,7 @@ function createCodexAppServerBackend(send4, resolve16, onBrowserRequest, loadPlu
         compactWaiters.set(threadId, { settle: finish, keepAlive: arm });
       });
       if (!compacted) {
-        fail3(threadId, params.clientRequestId, `${label} did not finish compacting this conversation in time.`, origin);
+        fail4(threadId, params.clientRequestId, `${label} did not finish compacting this conversation in time.`, origin);
         send4({ type: "agent:status", sessionId: threadId, clientRequestId: params.clientRequestId, status: "error" }, origin);
         return;
       }
@@ -76691,7 +77798,7 @@ function createCodexAppServerBackend(send4, resolve16, onBrowserRequest, loadPlu
         send4({ type: "agent:status", sessionId: threadId, clientRequestId: params.clientRequestId, status: "idle" }, origin);
         return;
       }
-      fail3(threadId, params.clientRequestId, detail, origin, true);
+      fail4(threadId, params.clientRequestId, detail, origin, true);
       send4({ type: "agent:status", sessionId: threadId, clientRequestId: params.clientRequestId, status: "error" }, origin);
     }
   }
@@ -90468,13 +91575,13 @@ var ActiveLinkEngine = class {
         localByHash.set(h, j);
     });
     const reuse = /* @__PURE__ */ new Map();
-    const request = [];
+    const request2 = [];
     blocks.forEach((h, i) => {
       const j = localByHash.get(h);
       if (j !== void 0)
         reuse.set(i, j);
       else
-        request.push(i);
+        request2.push(i);
     });
     const existing = this.pendingPulls.get(rel);
     if (existing)
@@ -90482,14 +91589,14 @@ var ActiveLinkEngine = class {
       });
     const assembler = new BlockAssembler(this.stagingPath(rel, "blk"));
     await assembler.open();
-    const pending2 = { mtimeMs, mode, size, wholeHash, blocks, reuse, localSize: localRec?.size ?? 0, remaining: new Set(request), assembler };
+    const pending2 = { mtimeMs, mode, size, wholeHash, blocks, reuse, localSize: localRec?.size ?? 0, remaining: new Set(request2), assembler };
     this.pendingPulls.set(rel, pending2);
     this.touchInbound();
-    if (request.length === 0) {
+    if (request2.length === 0) {
       await this.finalizeBlockPull(rel);
       return;
     }
-    this.send({ type: "link:requestBlocks", linkId: this.opts.linkId, fromHost: this.opts.ownHostId, rel, mtimeMs, indexes: request });
+    this.send({ type: "link:requestBlocks", linkId: this.opts.linkId, fromHost: this.opts.ownHostId, rel, mtimeMs, indexes: request2 });
   }
   async onBlockData(frame) {
     const pending2 = this.pendingPulls.get(frame.rel);
@@ -91521,6 +92628,15 @@ function ownHostId() {
   const mine = serverHosts.find((h) => h.hostId.endsWith(`:${deviceId}`));
   return mine?.hostId ?? "local";
 }
+var lastOwnHostLog = null;
+function logOwnHostVerdict() {
+  const own2 = ownHostId();
+  const verdict = own2 === "local" ? `NOT REGISTERED \u2014 the account lists ${serverHosts.length} host(s), none matching this deviceId=${deviceId.slice(0, 8)}; this machine is invisible to every client` : `registered as ${own2}`;
+  if (verdict === lastOwnHostLog)
+    return;
+  lastOwnHostLog = verdict;
+  console.log(`[control-link] own host: ${verdict}`);
+}
 function presentedHosts() {
   const out = serverHosts.slice();
   if (!out.some((h) => h.hostId.endsWith(`:${deviceId}`))) {
@@ -92321,6 +93437,8 @@ function handleHostChannel(payload) {
     entitlementDenied = true;
     stopHeartbeat();
     const message = typeof payload.message === "string" ? payload.message : "Running agents on your own machines requires a paid plan.";
+    const d = payload;
+    console.log(`[control-link] host:register DENIED reason=${String(d.reason ?? "?")} feature=${String(d.feature ?? "?")} limit=${String(d.limit ?? "?")} \u2014 ${message}`);
     hooks?.notify({ type: "notify", level: "warning", message });
     scheduleEntitlementRetry();
     return;
@@ -92344,6 +93462,7 @@ function handleHostChannel(payload) {
         setActiveLinkPeerOnline(l.linkId, true);
   }
   assertServerSelection();
+  logOwnHostVerdict();
   hooks?.ownHostResolved(ownHostId());
   hooks?.pushHosts(presentedHosts());
   resumeActiveLinks();
@@ -92365,6 +93484,7 @@ function registerAsHost() {
   const upAdvert = upscaleAdvert();
   if (upAdvert.gpu)
     caps.push("gpu");
+  console.log(`[control-link] host:register \u2192 deviceId=${deviceId.slice(0, 8)} machineId=${getMachinePublicId() ?? "none"} kind=${kind ?? "electron"} caps=${caps.join(",")}`);
   send3("host", { type: "host:register", name, platform: process.platform, deviceId, publicMachineId: getMachinePublicId(), caps, ...kind ? { kind } : {}, ...staticMetrics(hostVersion), gpu: upAdvert.gpu, upscaleModels: upAdvert.upscaleModels, ...p2pAdvert ?? {} });
   if (!heartbeat)
     heartbeat = setInterval(() => send3("host", { type: "host:heartbeat", ...dynamicMetrics() }), 2e4);
@@ -92686,7 +93806,7 @@ function connect() {
       } else if (rdSession && typeof p?.type === "string" && p.type.startsWith("rdesk:")) {
         if (inbound) {
           if (driving)
-            hooks?.onRdesk?.(env.payload, clientId, rdSession);
+            hooks?.onRdesk?.(env.payload, clientId, rdSession, env.viewerOwner === true);
         } else
           hooks?.deliverRdesk?.(env.payload, typeof env.hostId === "string" ? env.hostId : void 0, rdSession);
       }
@@ -92699,7 +93819,7 @@ function connect() {
         return;
       if (inbound) {
         if (driving)
-          hooks?.onRdesk?.(p, clientId, sessionId);
+          hooks?.onRdesk?.(p, clientId, sessionId, env.viewerOwner === true);
         return;
       }
       hooks?.deliverRdesk?.(p, typeof env.hostId === "string" ? env.hostId : void 0, sessionId);
@@ -92931,6 +94051,32 @@ var RdeskSessionManager = class {
       return 0;
     return Math.min(PW_BACKOFF_BASE_MS * 2 ** (over - 1), PW_BACKOFF_MAX_MS);
   }
+  /** Tell the viewer that this host is (or is again) producing a picture.
+   *
+   *  Sent by the HOST because only the host can know why: the OS reports a muted or ended
+   *  capture track as a fact, whereas a viewer sees an absence of frames and cannot tell a
+   *  slept display from a slow link from a genuinely black screen. Audited too, so "it just
+   *  showed black" is answerable after the fact. */
+  reportCapture(sessionId, clientId, ok, message) {
+    this.log(`capture ${ok ? "restored" : `lost \u2014 ${message}`} sessionId=${sessionId}`);
+    this.audit({ event: "capture", sessionId, detail: ok ? "ok" : message });
+    this.deps.sendControl(sessionId, clientId, { type: "rdesk:capture", ok, ...message ? { message } : {} });
+  }
+  /** Record which path a session's media actually took, once ICE has settled.
+   *
+   *  Media is direct-first (no relay pinning); TURN exists only as a last resort for NATs
+   *  that never punch through. That makes relay usage a COST we pay, so it is written to
+   *  the audit trail rather than only logged — `path` events in rdesk-audit.jsonl answer
+   *  "what fraction of sessions actually relayed?" without grepping daemon logs. Candidate
+   *  types only: an audit file is not the place for peer addresses. */
+  recordPath(sessionId, viewerUserId, path6, d) {
+    this.audit({
+      event: "path",
+      sessionId,
+      viewerUserId,
+      detail: `${path6} local=${d.localType ?? "?"} remote=${d.remoteType ?? "?"}`
+    });
+  }
   audit(e) {
     this.deps.audit?.({ at: this.now(), ...e });
   }
@@ -92955,10 +94101,10 @@ var RdeskSessionManager = class {
     const viewer = viewerIn.name || !declared ? viewerIn : { ...viewerIn, name: declared };
     const grant0 = grantOf(msg);
     this.audit({ event: "connect", sessionId, viewerUserId: viewer.userId, viewerName: viewer.name, grant: grant0 });
-    const deny = (reason) => {
-      this.log(`connect denied sessionId=${sessionId} reason=${reason}`);
-      this.audit({ event: "deny", sessionId, viewerUserId: viewer.userId, grant: grant0, detail: reason });
-      this.deps.sendControl(sessionId, viewer.clientId, { type: "rdesk:denied", reason });
+    const deny = (reason, message) => {
+      this.log(`connect denied sessionId=${sessionId} reason=${reason}${message ? ` \u2014 ${message}` : ""}`);
+      this.audit({ event: "deny", sessionId, viewerUserId: viewer.userId, grant: grant0, detail: message ? `${reason}: ${message}` : reason });
+      this.deps.sendControl(sessionId, viewer.clientId, { type: "rdesk:denied", reason, ...message ? { message } : {} });
     };
     if (!this.deps.canServe())
       return deny("entitlement");
@@ -92976,6 +94122,10 @@ var RdeskSessionManager = class {
       return deny("busy");
     }
     const grant = grantOf(msg);
+    if (grant === "registry" && viewer.sameAccount !== true) {
+      this.log(`connect denied sessionId=${sessionId} \u2014 'registry' claimed by a viewer the relay does not consider the owner`);
+      return deny("consent");
+    }
     if (grant === "password") {
       if (this.now() < this.pwLockedUntil) {
         this.log(`password attempt refused \u2014 locked for ${Math.ceil((this.pwLockedUntil - this.now()) / 1e3)}s`);
@@ -93016,7 +94166,9 @@ var RdeskSessionManager = class {
       sendControl: (m) => this.deps.sendControl(sessionId, viewer.clientId, m),
       sendData: (_m) => {
       },
-      log: (m) => this.log(`${sessionId}: ${m}`)
+      log: (m) => this.log(`${sessionId}: ${m}`),
+      onPath: (path6, d) => this.recordPath(sessionId, viewer.userId, path6, d),
+      onCapture: (ok, message) => this.reportCapture(sessionId, viewer.clientId, ok, message)
     };
     let engine;
     try {
@@ -93027,7 +94179,7 @@ var RdeskSessionManager = class {
       const err2 = e instanceof Error ? e.message : String(e);
       this.log(`engine start failed sessionId=${sessionId}: ${err2}`);
       this.deps.onCaptureBlocked?.({ sessionId, viewerName: viewer.name, error: err2 });
-      return deny("offline");
+      return deny("offline", err2);
     }
     const monitors = await engine.listMonitors().catch(() => []);
     const sources = await engine.listSources?.().catch(() => []) ?? [];
@@ -93096,7 +94248,9 @@ var RdeskSessionManager = class {
       sendControl: (m) => this.deps.sendControl(s.sessionId, s.viewer.clientId, m),
       sendData: () => {
       },
-      log: (m) => this.log(`${s.sessionId}: ${m}`)
+      log: (m) => this.log(`${s.sessionId}: ${m}`),
+      onPath: (path6, d) => this.recordPath(s.sessionId, s.viewer.userId, path6, d),
+      onCapture: (ok, message) => this.reportCapture(s.sessionId, s.viewer.clientId, ok, message)
     };
     try {
       s.engine = await this.deps.createEngine("tesseract", ctx2);
@@ -93271,6 +94425,93 @@ var RdeskSessionManager = class {
   }
 };
 
+// ../../packages/host-core/dist/daemon-identity-reload.js
+var reload = null;
+function setDaemonIdentityReload(fn) {
+  reload = fn;
+}
+function nextDaemonIdentity(fresh, current) {
+  if (!fresh?.accessToken)
+    return { kind: "machine" };
+  if (fresh.accessToken === current.accessToken && (fresh.userId ?? "") === current.userId)
+    return { kind: "unchanged" };
+  return { kind: "account" };
+}
+
+// ../../packages/host-core/dist/rdesk/screen-permission.js
+function screenRecordingStatus() {
+  if (process.platform !== "darwin")
+    return "unsupported";
+  try {
+    const sp = electronModule()?.systemPreferences;
+    const s = sp?.getMediaAccessStatus("screen");
+    if (s === "granted" || s === "denied" || s === "restricted" || s === "not-determined")
+      return s;
+    return "not-determined";
+  } catch {
+    return "not-determined";
+  }
+}
+function canCaptureScreen() {
+  const s = screenRecordingStatus();
+  return s === "granted" || s === "unsupported";
+}
+async function registerForScreenRecording() {
+  try {
+    const dc = electronModule()?.desktopCapturer;
+    await dc?.getSources({ types: ["screen"], thumbnailSize: { width: 1, height: 1 } });
+  } catch {
+  }
+}
+async function openScreenRecordingSettings() {
+  if (process.platform !== "darwin")
+    return;
+  await registerForScreenRecording();
+  try {
+    const shell = electronModule()?.shell;
+    await shell?.openExternal("x-apple.systempreferences:com.apple.preference.security?Privacy_ScreenCapture");
+  } catch {
+  }
+}
+var PROMPT_COOLDOWN_MS = 6e4;
+var lastPromptAt = 0;
+async function promptForScreenRecording(opts = {}) {
+  if (process.platform !== "darwin")
+    return false;
+  if (screenRecordingStatus() === "granted") {
+    opts.log?.("capture failed although Screen Recording IS granted \u2014 the capture stack is wedged (seen after a GPU-process crash); restarting Tesseract clears it");
+    return false;
+  }
+  const now2 = Date.now();
+  if (now2 - lastPromptAt < PROMPT_COOLDOWN_MS)
+    return false;
+  lastPromptAt = now2;
+  const el2 = electronModule();
+  const who = opts.viewerName ? `${opts.viewerName} is` : "Someone is";
+  opts.log?.(`screen recording not granted \u2014 prompting (${who} waiting)`);
+  if (!el2?.dialog) {
+    opts.log?.("no GUI to prompt with \u2014 grant Screen Recording in System Settings \u2192 Privacy & Security");
+    return false;
+  }
+  try {
+    const { response } = await el2.dialog.showMessageBox({
+      type: "warning",
+      buttons: ["Open System Settings", "Not Now"],
+      defaultId: 0,
+      cancelId: 1,
+      message: "Allow screen sharing on this Mac?",
+      detail: `${who} trying to connect to this computer, but macOS is blocking screen capture.
+
+Open System Settings \u2192 Privacy & Security \u2192 Screen Recording and switch on Tesseract Remote Desktop, then ask them to connect again.`
+    });
+    if (response === 0)
+      await openScreenRecordingSettings();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // ../../packages/host-core/dist/rdesk/publisher-window.js
 import { join as join54 } from "node:path";
 var windows = /* @__PURE__ */ new Map();
@@ -93308,6 +94549,7 @@ function ensureIpc() {
   el2.ipcMain.on("rdesk:pub:ready", (_e, p) => route2(p, (w) => w.handlers.onReady()));
   el2.ipcMain.on("rdesk:pub:error", (_e, p) => route2(p, (w, x) => w.handlers.onError(String(x.error ?? "publisher error"))));
   el2.ipcMain.on("rdesk:pub:path", (_e, p) => route2(p, (w, x) => w.handlers.onPath?.(String(x.path ?? "unknown"), { localType: x.localType ?? null, remoteType: x.remoteType ?? null })));
+  el2.ipcMain.on("rdesk:pub:capture", (_e, p) => route2(p, (w, x) => w.handlers.onCapture?.(x.ok !== false, String(x.message ?? ""))));
   el2.ipcMain.on("rdesk:pub:stopped", (_e, p) => route2(p, (w) => w.onStoppedAck()));
 }
 async function listPublisherMonitors() {
@@ -93354,21 +94596,41 @@ function displayBoundsById(monitorId) {
   const d = el2.screen.getAllDisplays().find((x) => String(x.id) === monitorId) ?? el2.screen.getPrimaryDisplay();
   return d ? { x: d.bounds.x, y: d.bounds.y, width: d.bounds.width, height: d.bounds.height } : null;
 }
-async function sourceIdForMonitor(monitorId) {
+async function wakeDisplay(log9) {
+  if (process.platform !== "darwin")
+    return;
+  try {
+    const { spawn: spawn17 } = await import("node:child_process");
+    spawn17("caffeinate", ["-u", "-t", "5"], { detached: true, stdio: "ignore" }).unref();
+    log9?.("display was asleep \u2014 declared user activity to wake it");
+    await new Promise((r) => setTimeout(r, 1200));
+  } catch {
+  }
+}
+async function sourceIdForMonitor(monitorId, log9) {
   const el2 = electronModule();
   if (!el2?.desktopCapturer || !el2.screen)
     throw new Error("Screen capture unavailable (Electron desktopCapturer/screen missing).");
   const display = el2.screen.getAllDisplays().find((d) => String(d.id) === monitorId) ?? el2.screen.getPrimaryDisplay();
-  const sources = await el2.desktopCapturer.getSources({ types: ["screen"], thumbnailSize: { width: 1, height: 1 } });
+  const list = async () => el2.desktopCapturer.getSources({ types: ["screen"], thumbnailSize: { width: 1, height: 1 } });
+  let sources = await list();
+  if (sources.length === 0) {
+    await wakeDisplay(log9);
+    sources = await list();
+  }
   const match = sources.find((s) => s.display_id === String(display.id)) ?? sources[0];
-  if (!match)
-    throw new Error("Screen capture failed: no screen source (grant Screen Recording permission).");
+  if (!match) {
+    const denied = !canCaptureScreen();
+    throw new Error(denied ? "Screen capture failed: Screen Recording permission is not granted to this app." : "Screen capture failed: no screen source. Screen Recording IS granted, so this is usually a display that stayed asleep, or a Mac with no active display attached.");
+  }
   return match.id;
 }
 var PublisherWindow = class {
   sessionId;
   handlers;
   win = null;
+  /** powerSaveBlocker id held for the life of the session — see startDisplayHold(). */
+  displayHold = null;
   stopAck = null;
   constructor(sessionId, handlers) {
     this.sessionId = sessionId;
@@ -93386,6 +94648,7 @@ var PublisherWindow = class {
     if (!el2?.BrowserWindow)
       throw new Error("Publisher requires the daemon GUI shell (no BrowserWindow).");
     ensureIpc();
+    this.startDisplayHold();
     const sourceId = opts.sourceId ?? await sourceIdForMonitor(opts.monitorId ?? await this.primaryMonitorId());
     const win3 = new el2.BrowserWindow({
       width: 320,
@@ -93499,7 +94762,36 @@ var PublisherWindow = class {
       maxFps: opts.maxFps
     });
   }
+  /** Hold the display awake for as long as this session lives.
+   *
+   *  Waking it once at start is not enough: the idle timer keeps running, so an unattended
+   *  host would go dark again a few minutes into a session and capture would die with the
+   *  same empty source list it started with. Released in stop() — never leaked, or the host
+   *  can never sleep again. */
+  startDisplayHold() {
+    if (this.displayHold !== null)
+      return;
+    try {
+      const psb = electronModule()?.powerSaveBlocker;
+      if (psb)
+        this.displayHold = psb.start("prevent-display-sleep");
+    } catch {
+    }
+  }
+  releaseDisplayHold() {
+    const id = this.displayHold;
+    this.displayHold = null;
+    if (id === null)
+      return;
+    try {
+      const psb = electronModule()?.powerSaveBlocker;
+      if (psb?.isStarted(id))
+        psb.stop(id);
+    } catch {
+    }
+  }
   async stop() {
+    this.releaseDisplayHold();
     const w = this.win;
     this.win = null;
     if (!w || w.isDestroyed()) {
@@ -93861,10 +95153,20 @@ var TesseractEngine = class {
         }
       },
       onReady: () => this.ctx.log("publisher connected"),
-      onError: (err2) => this.ctx.log(`publisher error: ${err2}`),
+      onError: (err2) => {
+        this.ctx.log(`publisher error: ${err2}`);
+        this.ctx.sendControl({ type: "rdesk:closed", reason: "network" });
+      },
       // Media is direct-first; log which path actually won so a regression to relay
       // (which costs real bandwidth) is visible instead of silent. Types only, no IPs.
-      onPath: (path6, d) => this.ctx.log(`media path=${path6} (local=${d.localType ?? "?"} remote=${d.remoteType ?? "?"})`)
+      onCapture: (ok, message) => {
+        this.ctx.log(`capture ${ok ? "ok" : `LOST \u2014 ${message}`}`);
+        this.ctx.onCapture?.(ok, message);
+      },
+      onPath: (path6, d) => {
+        this.ctx.log(`media path=${path6} (local=${d.localType ?? "?"} remote=${d.remoteType ?? "?"})`);
+        this.ctx.onPath?.(path6, d);
+      }
     });
     this.pub = pub;
     await pub.start({
@@ -96333,7 +97635,7 @@ async function startLocalServer(opts) {
           const rd = opts.getRdesk?.();
           if (rd && env.sessionId) {
             rdeskSessions.add(env.sessionId);
-            void rd.onClientMessage(env.sessionId, { clientId: loopbackOrigin, name: "This device" }, env.payload);
+            void rd.onClientMessage(env.sessionId, { clientId: loopbackOrigin, name: "This device", sameAccount: true }, env.payload);
           }
         }
       } else if (env.channel === "signal") {
@@ -96918,8 +98220,8 @@ async function startLocalServer(opts) {
 init_base_paths();
 import { readFileSync as readFileSync45, writeFileSync as writeFileSync38, existsSync as existsSync35, mkdirSync as mkdirSync37, unlinkSync as unlinkSync6, chmodSync as chmodSync7, statSync as statSync9 } from "node:fs";
 import { execFileSync as execFileSync5 } from "node:child_process";
-import { join as join69 } from "node:path";
-import { randomBytes as randomBytes8 } from "node:crypto";
+import { join as join70 } from "node:path";
+import { randomBytes as randomBytes10 } from "node:crypto";
 import { hostname as hostname5 } from "node:os";
 
 // ../../packages/shared/dist/daemon-registry.js
@@ -97372,10 +98674,13 @@ function readLocal(meshId) {
 function writeLocal(meshId, state3) {
   try {
     mkdirSync32(oneMeshDir(meshId), { recursive: true, mode: 448 });
-    writeFileSync33(join60(oneMeshDir(meshId), FILES.local), JSON.stringify(state3, null, 2));
+    writeFileSync33(join60(oneMeshDir(meshId), FILES.local), JSON.stringify(state3, null, 2), { mode: 384 });
   } catch {
   }
 }
+function updateLocal(meshId, patch) {
+  writeLocal(meshId, { ...readLocal(meshId), ...patch });
+}
 function loadMesh(meshId) {
   if (!isMeshId(meshId))
     return null;
@@ -97633,6 +98938,9 @@ function loadMeshCore() {
   }
 }
 var meshCore = loadMeshCore();
+function meshEngineStatus() {
+  return { available: meshCore.available === true, reason: meshCore.loadError ?? null };
+}
 var TICK_MS2 = 1e3;
 var BIND_PORT = 0;
 var shortKey = (k) => k.subarray(0, 4).toString("hex");
@@ -97742,9 +99050,54 @@ var MeshNode = class {
   #relayed = /* @__PURE__ */ new Set();
   /** staticPub hex → the Buffer, so events can be matched back to a peer. */
   #peers = /* @__PURE__ */ new Map();
+  /**
+   * Peers whose CERTIFICATE says they are this network's way out, by display name.
+   *
+   * A hint for the UI, never an authorisation: the engine checks the same signed bit per
+   * packet, alongside our own selection and a bundle capability. This exists so a person
+   * can be offered a choice that has somewhere to go.
+   */
+  #exitNodes = /* @__PURE__ */ new Map();
   #lan = null;
   #offRejoin = null;
   #statusTimer = null;
+  /**
+   * Route this machine's non-mesh traffic through the network's exit node, or stop.
+   *
+   * GATE 1 OF THREE, and the only one that lives on this machine. `Engine::exit_allowed`
+   * additionally requires that the CA marked the peer's certificate and that the signed
+   * bundle grants CAP_EXIT_NODE, both checked per packet — so selecting a peer widens
+   * nothing by itself, and selecting one that turns out not to qualify simply drops the
+   * traffic rather than misrouting it.
+   *
+   * Without this call netd installs the routes and the engine refuses every packet that
+   * arrives on them: a machine with its default route captured and nothing carrying it,
+   * which is the worst of both states.
+   *
+   * Returns the name selected, or null when there is nobody to select.
+   */
+  useExitNode(on) {
+    const engine = this.#engine;
+    if (!engine)
+      return null;
+    if (!on) {
+      try {
+        engine.setExitNode?.(null);
+      } catch {
+      }
+      return null;
+    }
+    const first = [...this.#exitNodes.entries()][0];
+    if (first === void 0)
+      return null;
+    const [hex6, name] = first;
+    try {
+      engine.setExitNode?.(Buffer.from(hex6, "hex"));
+    } catch {
+      return null;
+    }
+    return name;
+  }
   status() {
     return {
       available: meshCore.available,
@@ -97756,6 +99109,14 @@ var MeshNode = class {
       peers: this.#engine?.peerCount() ?? 0,
       established: [...this.#established],
       relayed: [...this.#relayed],
+      exitNodes: [...this.#exitNodes.values()],
+      // Derived from the SAME sets the peer list is: an exit node with no established
+      // session is one that cannot carry traffic yet, and saying "waiting" is different
+      // from saying "none". Keyed by name so a caller never has to hold a key to read it.
+      exitPaths: Object.fromEntries([...this.#exitNodes.entries()].map(([hex6, name]) => [
+        name,
+        this.#established.has(hex6) ? this.#relayed.has(hex6) ? "relay" : "direct" : "none"
+      ])),
       meter: this.#engine?.meter() ?? null,
       lastError: this.#lastError,
       // Surfaced so `net status` can say "removed" rather than "not running". Those look
@@ -97927,11 +99288,11 @@ var MeshNode = class {
     const engine = this.#engine;
     if (!engine)
       return;
-    const hex5 = staticPub.toString("hex");
+    const hex6 = staticPub.toString("hex");
     try {
-      if (!this.#peers.has(hex5)) {
+      if (!this.#peers.has(hex6)) {
         engine.addPeer(staticPub, 0, Buffer.alloc(16));
-        this.#peers.set(hex5, staticPub);
+        this.#peers.set(hex6, staticPub);
       }
       engine.addPath(staticPub, `${address}:${port}`, false);
       engine.startHandshake(staticPub, Date.now());
@@ -98008,10 +99369,10 @@ var MeshNode = class {
           const pk = Buffer.from(m.fromStaticPub, "base64");
           if (pk.length !== 32)
             break;
-          const hex5 = pk.toString("hex");
-          if (!this.#peers.has(hex5)) {
+          const hex6 = pk.toString("hex");
+          if (!this.#peers.has(hex6)) {
             engine.addPeer(pk, 0, Buffer.alloc(16));
-            this.#peers.set(hex5, pk);
+            this.#peers.set(hex6, pk);
           }
           for (const ep of m.endpoints ?? []) {
             try {
@@ -98024,9 +99385,11 @@ var MeshNode = class {
         }
         case "mesh:gone": {
           const pk = Buffer.from(m.staticPub, "base64");
+          if (pk.length === 32)
+            this.#exitNodes.delete(pk.toString("hex"));
           if (pk.length === 32) {
-            const hex5 = pk.toString("hex");
-            this.#peers.delete(hex5);
+            const hex6 = pk.toString("hex");
+            this.#peers.delete(hex6);
             this.#established.delete(shortKey(pk));
             this.#relayed.delete(shortKey(pk));
           }
@@ -98052,10 +99415,22 @@ var MeshNode = class {
     const pk = Buffer.from(p.staticPub, "base64");
     if (pk.length !== 32)
       return;
-    const hex5 = pk.toString("hex");
-    if (!this.#peers.has(hex5)) {
+    const hex6 = pk.toString("hex");
+    if (p.cert) {
+      try {
+        const bytes2 = Buffer.from(p.cert, "base64");
+        const pki = (init_dist6(), __toCommonJS(dist_exports3));
+        const details = pki.decodeCert(new Uint8Array(bytes2)).details;
+        if (pki.isExitNode(details))
+          this.#exitNodes.set(hex6, details.name);
+        else
+          this.#exitNodes.delete(hex6);
+      } catch {
+      }
+    }
+    if (!this.#peers.has(hex6)) {
       engine.addPeer(pk, 0, Buffer.alloc(16));
-      this.#peers.set(hex5, pk);
+      this.#peers.set(hex6, pk);
     }
     for (const e of p.endpoints)
       engine.addPath(pk, `${e.ip}:${e.port}`, false);
@@ -98190,16 +99565,26 @@ var MeshManager = class {
    */
   disable(meshId) {
     this.stop(meshId);
-    writeLocal(meshId, { ...readLocal(meshId), enabled: false });
+    updateLocal(meshId, { enabled: false });
   }
   /** Undo `disable`, and start it. */
   enable(meshId) {
-    writeLocal(meshId, { ...readLocal(meshId), enabled: true });
+    updateLocal(meshId, { enabled: true });
     return this.start(meshId);
   }
   node(meshId) {
     return this.#nodes.get(meshId) ?? null;
   }
+  /**
+   * The meshes with a LIVE node, which is what routes may be installed for.
+   *
+   * Deliberately not `ids()`: a certificate on disk is not a reason to steer traffic, and a
+   * disabled mesh has one. `syncRoutes` takes this rather than the on-disk list precisely so
+   * that confusion has to be made on purpose.
+   */
+  running() {
+    return [...this.#nodes.keys()];
+  }
   /** The first-joined running mesh — for callers that predate multi-mesh. */
   primary() {
     for (const meshId of this.ids()) {
@@ -98225,17 +99610,238 @@ function meshManager() {
   return singleton3;
 }
 
+// ../../packages/host-core/dist/mesh/netd-client.js
+import { connect as connect2 } from "node:net";
+import { platform as platform3 } from "node:process";
+var NETD_WIRE_VERSION = 1;
+var MAX_LINE = 1024 * 1024;
+var TIMEOUT_MS2 = 15e3;
+function netdEndpoint() {
+  if (platform3 === "win32")
+    return "\\\\.\\pipe\\tesseract-netd";
+  if (platform3 === "darwin")
+    return "/var/run/tesseract-netd.sock";
+  return "/run/tesseract-netd.sock";
+}
+function endpointOverride() {
+  return process.env.CCB_NETD_SOCKET ?? null;
+}
+function fail2(code, detail) {
+  return { ok: false, code, detail };
+}
+async function call(line) {
+  const endpoint2 = endpointOverride() ?? netdEndpoint();
+  return new Promise((resolve16) => {
+    let settled = false;
+    const done = (r) => {
+      if (settled)
+        return;
+      settled = true;
+      try {
+        sock.destroy();
+      } catch {
+      }
+      resolve16(r);
+    };
+    let sock;
+    try {
+      sock = connect2(endpoint2);
+    } catch (e) {
+      return resolve16(fail2("not-installed", e instanceof Error ? e.message : String(e)));
+    }
+    const timer2 = setTimeout(() => {
+      done(fail2("timeout", `no answer from the network helper in ${TIMEOUT_MS2}ms`));
+    }, TIMEOUT_MS2);
+    timer2.unref?.();
+    sock.setTimeout(TIMEOUT_MS2);
+    sock.on("timeout", () => {
+      clearTimeout(timer2);
+      done(fail2("timeout", "socket idle"));
+    });
+    sock.on("error", (e) => {
+      clearTimeout(timer2);
+      const absent = e.code === "ENOENT" || e.code === "ECONNREFUSED";
+      done(fail2(absent ? "not-installed" : "io", e.message));
+    });
+    let buf = "";
+    sock.on("data", (chunk) => {
+      buf += chunk.toString("utf8");
+      if (buf.length > MAX_LINE) {
+        clearTimeout(timer2);
+        done(fail2("protocol", "the helper sent an oversized line"));
+        return;
+      }
+      const nl = buf.indexOf("\n");
+      if (nl === -1)
+        return;
+      clearTimeout(timer2);
+      done({ ok: true, line: buf.slice(0, nl) });
+    });
+    sock.on("close", () => {
+      clearTimeout(timer2);
+      done(fail2("protocol", "the helper closed the connection without answering"));
+    });
+    sock.on("connect", () => {
+      sock.write(`${line}
+`);
+    });
+  });
+}
+function parse3(line) {
+  let body;
+  try {
+    body = JSON.parse(line);
+  } catch {
+    return fail2("protocol", "the helper sent something that is not JSON");
+  }
+  if (typeof body !== "object" || body === null) {
+    return fail2("protocol", "the helper sent something that is not an object");
+  }
+  const o = body;
+  if (o.ok === false) {
+    const code = typeof o.code === "string" ? o.code : "refused";
+    const detail = typeof o.detail === "string" ? o.detail : "the helper refused";
+    return fail2(code, detail);
+  }
+  if (o.ok !== true)
+    return fail2("protocol", "the helper did not say whether it succeeded");
+  return { ok: true, body: o };
+}
+async function request(line) {
+  const r = await call(line);
+  return r.ok ? parse3(r.line) : r;
+}
+function hex4(b) {
+  return Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
+}
+async function netdHello() {
+  const r = await request(JSON.stringify({ op: "hello", wireVersion: NETD_WIRE_VERSION }));
+  if (!r.ok)
+    return r;
+  const v = r.body.wireVersion;
+  if (typeof v !== "number")
+    return fail2("protocol", "the helper did not report a wire version");
+  if (v !== NETD_WIRE_VERSION) {
+    return fail2("wire-version", `the helper speaks ${v}, this build speaks ${NETD_WIRE_VERSION}`);
+  }
+  return { ok: true, wireVersion: v };
+}
+async function netdStatus() {
+  const r = await request(JSON.stringify({ op: "status" }));
+  if (!r.ok)
+    return r;
+  const meshes = Array.isArray(r.body.meshes) ? r.body.meshes.filter((m) => typeof m === "string") : [];
+  const iface = typeof r.body.interface === "string" ? r.body.interface : null;
+  return { ok: true, meshes, interface: iface };
+}
+async function netdUp(args) {
+  const r = await request(JSON.stringify({
+    op: "up",
+    meshId: args.meshId,
+    genesis: hex4(args.genesis),
+    cert: hex4(args.cert),
+    fullTunnel: args.fullTunnel === true
+  }));
+  return r.ok ? { ok: true } : r;
+}
+async function netdDown(meshId) {
+  const r = await request(JSON.stringify({ op: "down", meshId }));
+  return r.ok ? { ok: true } : r;
+}
+async function netdAvailable() {
+  return (await netdHello()).ok;
+}
+
+// ../../packages/host-core/dist/mesh/route-sync.js
+async function syncRoutes(running2, log9 = () => {
+}) {
+  const out = { up: [], down: [], failed: [], helperAbsent: false };
+  if (!await netdAvailable()) {
+    out.helperAbsent = true;
+    return out;
+  }
+  const status2 = await netdStatus();
+  if (!status2.ok) {
+    out.failed.push({ meshId: "*", reason: status2.detail });
+    return out;
+  }
+  const installed = new Set(status2.meshes);
+  const want = new Set(running2);
+  for (const meshId of want) {
+    const identity = loadMesh(meshId);
+    if (identity === null) {
+      out.failed.push({ meshId, reason: "no enrolment on disk" });
+      continue;
+    }
+    const r = await netdUp({
+      meshId,
+      genesis: identity.genesis,
+      cert: identity.cert,
+      // The per-machine choice, and `=== true` rather than a truthiness check: an absent or
+      // malformed field must read as NO. netd unions this across meshes itself — any mesh
+      // asking for a full tunnel makes it one for the machine — so this stays per mesh here.
+      fullTunnel: readLocal(meshId)?.fullTunnel === true
+    });
+    if (r.ok) {
+      out.up.push(meshId);
+      log9(`routes installed for ${meshId}`);
+    } else {
+      out.failed.push({ meshId, reason: r.detail });
+      log9(`routes NOT installed for ${meshId}: ${r.detail}`);
+    }
+  }
+  for (const meshId of installed) {
+    if (want.has(meshId))
+      continue;
+    const r = await netdDown(meshId);
+    if (r.ok) {
+      out.down.push(meshId);
+      log9(`routes removed for ${meshId}`);
+    } else {
+      out.failed.push({ meshId, reason: r.detail });
+      log9(`routes could NOT be removed for ${meshId}: ${r.detail}`);
+    }
+  }
+  return out;
+}
+
 // ../../packages/host-core/dist/mesh/start-meshes.js
 function startMeshes(log9) {
+  const running2 = startNodes(log9);
+  void syncRoutes(running2, log9).then((r) => {
+    if (r.helperAbsent) {
+      log9("routes: the network helper is not installed \u2014 the overlay carries no traffic yet");
+      return;
+    }
+    if (r.up.length)
+      log9(`routes: installed for ${r.up.join(", ")}`);
+    if (r.down.length)
+      log9(`routes: removed for ${r.down.join(", ")}`);
+    for (const f of r.failed)
+      log9(`routes: ${f.meshId} refused \u2014 ${f.reason}`);
+  }).catch((e) => {
+    log9(`routes: sync threw \u2014 ${e instanceof Error ? e.message : String(e)}`);
+  });
+}
+function startNodes(log9) {
   const ids = listMeshIds();
   if (ids.length <= 1) {
+    const only = ids[0];
+    if (only !== void 0 && readLocal(only)?.enabled === false) {
+      log9("mesh: the only network is switched off");
+      return [];
+    }
     const started2 = meshNode().start();
     log9(started2.ok ? "mesh: node up" : `mesh: not started \u2014 ${started2.reason}`);
-    return;
+    return started2.ok && only !== void 0 ? [only] : [];
   }
+  const running2 = [];
   for (const r of meshManager().startAll()) {
     log9(r.ok ? `mesh ${r.meshId}: up` : `mesh ${r.meshId}: not started \u2014 ${r.reason}`);
+    if (r.ok)
+      running2.push(r.meshId);
   }
+  return running2;
 }
 
 // ../../packages/host-core/dist/drops/receive-ui.js
@@ -98333,7 +99939,7 @@ import { basename as basename13 } from "node:path";
 // ../../packages/host-core/dist/drops/paths.js
 init_base_paths();
 import { mkdir as mkdir12 } from "node:fs/promises";
-import { join as join61 } from "node:path";
+import { join as join62 } from "node:path";
 
 // ../../packages/host-core/dist/drops/names.js
 var WINDOWS_RESERVED = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])$/i;
@@ -98342,8 +99948,8 @@ var BIDI = /[\u200e\u200f\u202a-\u202e\u2066-\u2069]/g;
 var MAX_NAME_BYTES = 200;
 var MAX_EXT_BYTES = 32;
 var MAX_DEPTH2 = 32;
-var utf82 = new TextEncoder();
-var byteLen = (s) => utf82.encode(s).length;
+var utf83 = new TextEncoder();
+var byteLen = (s) => utf83.encode(s).length;
 function capBytes(stem, ext, max) {
   if (byteLen(stem + ext) <= max)
     return stem + ext;
@@ -98422,7 +100028,7 @@ function basenameOf(p) {
 function resolveDropsRoot() {
   const root = resolveHostRoot();
   const preferred = dropsDir();
-  return isInsideRoot(preferred, root) ? preferred : join61(root, "Drops");
+  return isInsideRoot(preferred, root) ? preferred : join62(root, "Drops");
 }
 async function ensureDropsRoot() {
   const dir2 = resolveDropsRoot();
@@ -98438,7 +100044,7 @@ async function ensureDropDir(opts) {
     parts.push(sanitizeDropName(opts.sender, "Unknown sender"));
   if (!opts.singleItem && opts.label)
     parts.push(sanitizeDropName(opts.label, "Files"));
-  const dir2 = join61(...parts);
+  const dir2 = join62(...parts);
   await mkdir12(dir2, { recursive: true });
   return dir2;
 }
@@ -98581,7 +100187,7 @@ function createDropHandler(deps) {
 // ../../packages/host-core/dist/drops/blob-fetch.js
 import { createWriteStream as createWriteStream2 } from "node:fs";
 import { mkdir as mkdir13, rm as rm5, chmod as chmod3 } from "node:fs/promises";
-import { dirname as dirname26, join as join62 } from "node:path";
+import { dirname as dirname26, join as join63 } from "node:path";
 import { Readable as Readable2 } from "node:stream";
 import { pipeline } from "node:stream/promises";
 
@@ -98593,10 +100199,10 @@ var HEADER_BYTES = MAGIC2.length + NONCE_BYTES;
 var FRAME_BYTES = 1024 * 1024;
 var TAG_BYTES = 16;
 var MAX_FRAME_CIPHERTEXT = FRAME_BYTES + TAG_BYTES + 1024;
-var subtle3 = () => globalThis.crypto.subtle;
-var bs3 = (b) => b;
+var subtle4 = () => globalThis.crypto.subtle;
+var bs4 = (b) => b;
 async function importKey(raw) {
-  return subtle3().importKey("raw", bs3(raw), { name: "AES-GCM" }, false, ["encrypt", "decrypt"]);
+  return subtle4().importKey("raw", bs4(raw), { name: "AES-GCM" }, false, ["encrypt", "decrypt"]);
 }
 function nonceFor(base, index) {
   const n = Buffer.from(base);
@@ -98691,7 +100297,7 @@ function decryptStream(source, keyRaw) {
           const frame = q.peek(4 + len);
           if (!frame)
             break;
-          const plain = Buffer.from(await subtle3().decrypt({ name: "AES-GCM", iv: bs3(nonceFor(base, index)), additionalData: bs3(aadFor(index)) }, key2, bs3(frame.subarray(4))));
+          const plain = Buffer.from(await subtle4().decrypt({ name: "AES-GCM", iv: bs4(nonceFor(base, index)), additionalData: bs4(aadFor(index)) }, key2, bs4(frame.subarray(4))));
           this.push(plain);
           index += 1;
           q.consume(4 + len);
@@ -98753,7 +100359,7 @@ async function fetchBlobDrop(opts) {
         log7(`drop ${opts.dropId}: refusing directory "${item.rel}"`);
         continue;
       }
-      const abs = join62(opts.destDir, rel);
+      const abs = join63(opts.destDir, rel);
       if (!isInsideRoot(abs, opts.destDir)) {
         log7(`drop ${opts.dropId}: refusing directory outside the destination`);
         continue;
@@ -98774,7 +100380,7 @@ async function fetchBlobDrop(opts) {
         log7(`drop ${opts.dropId}: refusing "${item.rel}"`);
         continue;
       }
-      let abs = join62(opts.destDir, rel);
+      let abs = join63(opts.destDir, rel);
       if (!isInsideRoot(abs, opts.destDir)) {
         log7(`drop ${opts.dropId}: refusing a path outside the destination`);
         continue;
@@ -99052,12 +100658,12 @@ var RdeskServerChannel = class {
 
 // ../../packages/host-core/dist/rdesk/channel-client.js
 import { readFileSync as readFileSync44 } from "node:fs";
-import { join as join63 } from "node:path";
+import { join as join64 } from "node:path";
 var RECONNECT_MS = 2e3;
 var CLAIM_RETRY_MS = 5e3;
 function readEndpoint(dir2, selfPid) {
   try {
-    const s = JSON.parse(readFileSync44(join63(dir2, "status.json"), "utf8"));
+    const s = JSON.parse(readFileSync44(join64(dir2, "status.json"), "utf8"));
     if (selfPid && s.pid === selfPid)
       return null;
     return s.localPort && s.localToken ? `ws://127.0.0.1:${s.localPort}/?token=${s.localToken}` : null;
@@ -99091,11 +100697,11 @@ function startRdeskChannelClient(deps) {
       return;
     retry = setTimeout(() => {
       retry = null;
-      connect2();
+      connect3();
     }, RECONNECT_MS);
     retry.unref?.();
   };
-  function connect2() {
+  function connect3() {
     if (stopped2 || sock)
       return;
     const url2 = readEndpoint(deps.daemonDir(), deps.selfPid);
@@ -99161,7 +100767,7 @@ function startRdeskChannelClient(deps) {
     ws.on("error", () => {
     });
   }
-  connect2();
+  connect3();
   const claimPoll = setInterval(() => {
     if (stopped2 || holding)
       return;
@@ -99198,19 +100804,6 @@ function setRdeskServerAdmin(a) {
   admin = a;
 }
 
-// ../../packages/host-core/dist/daemon-identity-reload.js
-var reload = null;
-function setDaemonIdentityReload(fn) {
-  reload = fn;
-}
-function nextDaemonIdentity(fresh, current) {
-  if (!fresh?.accessToken)
-    return { kind: "machine" };
-  if (fresh.accessToken === current.accessToken && (fresh.userId ?? "") === current.userId)
-    return { kind: "unchanged" };
-  return { kind: "account" };
-}
-
 // ../../packages/host-core/dist/daemon-online-watch.js
 var FIRST_DELAY_MS = 5e3;
 var MAX_DELAY_MS = 3e4;
@@ -99503,10 +101096,10 @@ function registerRdpEngine() {
 // ../../packages/host-core/dist/rdesk/audit.js
 init_credentials();
 import { appendFile, stat as stat8, rename as rename3 } from "node:fs/promises";
-import { join as join64 } from "node:path";
+import { join as join65 } from "node:path";
 var MAX_BYTES = 2 * 1024 * 1024;
 function rdeskAuditPath() {
-  return join64(daemonDir2(), "rdesk-audit.jsonl");
+  return join65(daemonDir2(), "rdesk-audit.jsonl");
 }
 var queue = [];
 var draining = false;
@@ -99546,81 +101139,13 @@ function appendRdeskAudit(e) {
   }
 }
 
-// ../../packages/host-core/dist/rdesk/screen-permission.js
-function screenRecordingStatus() {
-  if (process.platform !== "darwin")
-    return "unsupported";
-  try {
-    const sp = electronModule()?.systemPreferences;
-    const s = sp?.getMediaAccessStatus("screen");
-    if (s === "granted" || s === "denied" || s === "restricted" || s === "not-determined")
-      return s;
-    return "not-determined";
-  } catch {
-    return "not-determined";
-  }
-}
-async function registerForScreenRecording() {
-  try {
-    const dc = electronModule()?.desktopCapturer;
-    await dc?.getSources({ types: ["screen"], thumbnailSize: { width: 1, height: 1 } });
-  } catch {
-  }
-}
-async function openScreenRecordingSettings() {
-  if (process.platform !== "darwin")
-    return;
-  await registerForScreenRecording();
-  try {
-    const shell = electronModule()?.shell;
-    await shell?.openExternal("x-apple.systempreferences:com.apple.preference.security?Privacy_ScreenCapture");
-  } catch {
-  }
-}
-var PROMPT_COOLDOWN_MS = 6e4;
-var lastPromptAt = 0;
-async function promptForScreenRecording(opts = {}) {
-  if (process.platform !== "darwin")
-    return false;
-  if (screenRecordingStatus() === "granted")
-    return false;
-  const now2 = Date.now();
-  if (now2 - lastPromptAt < PROMPT_COOLDOWN_MS)
-    return false;
-  lastPromptAt = now2;
-  const el2 = electronModule();
-  const who = opts.viewerName ? `${opts.viewerName} is` : "Someone is";
-  opts.log?.(`screen recording not granted \u2014 prompting (${who} waiting)`);
-  if (!el2?.dialog) {
-    opts.log?.("no GUI to prompt with \u2014 grant Screen Recording in System Settings \u2192 Privacy & Security");
-    return false;
-  }
-  try {
-    const { response } = await el2.dialog.showMessageBox({
-      type: "warning",
-      buttons: ["Open System Settings", "Not Now"],
-      defaultId: 0,
-      cancelId: 1,
-      message: "Allow screen sharing on this Mac?",
-      detail: `${who} trying to connect to this computer, but macOS is blocking screen capture.
-
-Open System Settings \u2192 Privacy & Security \u2192 Screen Recording and switch on Tesseract Remote Desktop, then ask them to connect again.`
-    });
-    if (response === 0)
-      await openScreenRecordingSettings();
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 // ../../packages/host-core/dist/fileprovider-bridge.js
 import { writeFileSync as writeFileSync34, mkdirSync as mkdirSync33, rmSync as rmSync8, existsSync as existsSync31 } from "node:fs";
 import { homedir as homedir9 } from "node:os";
-import { join as join65 } from "node:path";
+import { join as join66 } from "node:path";
 var APPEX_BUNDLE_ID = "dev.tesseract.FileProvider";
 function appexBridgeInfoPath() {
-  return join65(homedir9(), "Library", "Containers", APPEX_BUNDLE_ID, "Data", "Library", "Application Support", "tesseract-bridge.json");
+  return join66(homedir9(), "Library", "Containers", APPEX_BUNDLE_ID, "Data", "Library", "Application Support", "tesseract-bridge.json");
 }
 function clearBridgeInfo() {
   if (process.platform !== "darwin")
@@ -99787,10 +101312,10 @@ function stopFileProviderBridge() {
 }
 
 // ../../packages/host-core/dist/vault/autofill-bridge.js
-import { randomBytes as randomBytes7 } from "node:crypto";
+import { randomBytes as randomBytes9 } from "node:crypto";
 import { existsSync as existsSync32, mkdirSync as mkdirSync34, writeFileSync as writeFileSync35, rmSync as rmSync9 } from "node:fs";
 import { homedir as homedir10 } from "node:os";
-import { join as join66 } from "node:path";
+import { join as join67 } from "node:path";
 
 // ../../packages/host-core/dist/vault/peer-verify.js
 import { execFile as execFile9 } from "node:child_process";
@@ -99852,10 +101377,10 @@ async function isTrustedAutofillPeer(remotePort) {
 var APPEX_BUNDLE_ID2 = "dev.tesseract.AutoFill";
 var BRIDGE_PORTS2 = [17872, 17873, 17874, 17875];
 function appexContainerData() {
-  return join66(homedir10(), "Library", "Containers", APPEX_BUNDLE_ID2, "Data");
+  return join67(homedir10(), "Library", "Containers", APPEX_BUNDLE_ID2, "Data");
 }
 function bridgeInfoPath() {
-  return join66(appexContainerData(), "Library", "Application Support", "tesseract-autofill-bridge.json");
+  return join67(appexContainerData(), "Library", "Application Support", "tesseract-autofill-bridge.json");
 }
 var infoLoggedOnce = false;
 function writeBridgeInfo(port, token3, log9) {
@@ -99870,7 +101395,7 @@ function writeBridgeInfo(port, token3, log9) {
       }
       return;
     }
-    const dir2 = join66(containerData, "Library", "Application Support");
+    const dir2 = join67(containerData, "Library", "Application Support");
     mkdirSync34(dir2, { recursive: true });
     writeFileSync35(bridgeInfoPath(), JSON.stringify({ port, token: token3, pid: process.pid, ts: Date.now() }), { mode: 384 });
     if (!infoLoggedOnce) {
@@ -100031,7 +101556,7 @@ function startAutofillBridge(log9 = () => {
   if (process.platform !== "darwin" || wss2)
     return;
   stopping2 = false;
-  token2 = randomBytes7(24).toString("base64url");
+  token2 = randomBytes9(24).toString("base64url");
   bind(0, log9);
 }
 function stopAutofillBridge() {
@@ -100057,15 +101582,15 @@ function stopAutofillBridge() {
 
 // ../../packages/host-core/dist/power-node.js
 import { spawn as spawn13 } from "node:child_process";
-import { platform as platform3 } from "node:os";
+import { platform as platform4 } from "node:os";
 function createNodePowerController() {
   const active = /* @__PURE__ */ new Set();
   let proc = null;
   function spawnInhibitor() {
     try {
-      if (platform3() === "darwin")
+      if (platform4() === "darwin")
         return spawn13("caffeinate", ["-i"], { stdio: "ignore" });
-      if (platform3() === "linux") {
+      if (platform4() === "linux") {
         return spawn13("systemd-inhibit", ["--what=sleep", "--why=tesseract agent running", "--mode=block", "sleep", "infinity"], { stdio: "ignore" });
       }
     } catch {
@@ -100115,28 +101640,28 @@ function createNodePowerController() {
 // ../../packages/host-core/dist/native-host.js
 import { execFileSync as execFileSync4 } from "node:child_process";
 import { chmodSync as chmodSync6, existsSync as existsSync33, mkdirSync as mkdirSync35, writeFileSync as writeFileSync36 } from "node:fs";
-import { homedir as homedir11, platform as platform4 } from "node:os";
-import { dirname as dirname27, join as join67, resolve as resolve12 } from "node:path";
+import { homedir as homedir11, platform as platform5 } from "node:os";
+import { dirname as dirname27, join as join68, resolve as resolve12 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 var HOST_NAME = "com.tesseract.companion";
 var EXTENSION_IDS = ["icpnghhpcmaonjckkpilpajblfehpplo", "giolfpookdhjfafcchaflhmigghaeffn"];
 var BRIDGE_BASENAME = "host.cjs";
 function browserProfileDirs() {
   const home = homedir11();
-  const p = platform4();
+  const p = platform5();
   if (p === "darwin") {
-    const base = join67(home, "Library/Application Support");
-    return ["Google/Chrome", "Google/Chrome Beta", "Google/Chrome Dev", "Google/Chrome Canary", "Chromium", "Microsoft Edge", "BraveSoftware/Brave-Browser", "Vivaldi", "Arc"].map((b) => join67(base, b));
+    const base = join68(home, "Library/Application Support");
+    return ["Google/Chrome", "Google/Chrome Beta", "Google/Chrome Dev", "Google/Chrome Canary", "Chromium", "Microsoft Edge", "BraveSoftware/Brave-Browser", "Vivaldi", "Arc"].map((b) => join68(base, b));
   }
   if (p === "win32")
     return [];
-  const cfg2 = join67(home, ".config");
-  return ["google-chrome", "google-chrome-beta", "chromium", "microsoft-edge", "BraveSoftware/Brave-Browser", "vivaldi"].map((b) => join67(cfg2, b));
+  const cfg2 = join68(home, ".config");
+  return ["google-chrome", "google-chrome-beta", "chromium", "microsoft-edge", "BraveSoftware/Brave-Browser", "vivaldi"].map((b) => join68(cfg2, b));
 }
 function resolveBridge(log9) {
   const candidates = [
     process.env.CCB_COMPANION_HOST_JS,
-    process.resourcesPath ? join67(process.resourcesPath, "companion-host", BRIDGE_BASENAME) : void 0
+    process.resourcesPath ? join68(process.resourcesPath, "companion-host", BRIDGE_BASENAME) : void 0
   ];
   try {
     const here = dirname27(fileURLToPath5(import.meta.url));
@@ -100151,8 +101676,8 @@ function resolveBridge(log9) {
   return null;
 }
 function writeLauncher(daemonDir3, bridge, runtime) {
-  const isWin = platform4() === "win32";
-  const launcher = join67(daemonDir3, isWin ? "companion-host.cmd" : "companion-host.sh");
+  const isWin = platform5() === "win32";
+  const launcher = join68(daemonDir3, isWin ? "companion-host.cmd" : "companion-host.sh");
   if (isWin) {
     writeFileSync36(launcher, `@echo off\r
 set ELECTRON_RUN_AS_NODE=1\r
@@ -100183,16 +101708,16 @@ function registerNativeHost(opts) {
       type: "stdio",
       allowed_origins: EXTENSION_IDS.map((id) => `chrome-extension://${id}/`)
     }, null, 2);
-    if (platform4() === "win32")
+    if (platform5() === "win32")
       return registerWindows(opts.daemonDir, manifestJson, log9);
     let wrote = 0;
     for (const profile of browserProfileDirs()) {
       if (!existsSync33(profile))
         continue;
       try {
-        const dir2 = join67(profile, "NativeMessagingHosts");
+        const dir2 = join68(profile, "NativeMessagingHosts");
         mkdirSync35(dir2, { recursive: true });
-        writeFileSync36(join67(dir2, `${HOST_NAME}.json`), manifestJson);
+        writeFileSync36(join68(dir2, `${HOST_NAME}.json`), manifestJson);
         wrote++;
       } catch {
       }
@@ -100204,7 +101729,7 @@ function registerNativeHost(opts) {
 }
 function registerWindows(daemonDir3, manifestJson, log9) {
   try {
-    const manifestPath = join67(daemonDir3, `${HOST_NAME}.json`);
+    const manifestPath = join68(daemonDir3, `${HOST_NAME}.json`);
     writeFileSync36(manifestPath, manifestJson);
     for (const root of ["Software\\Google\\Chrome", "Software\\Microsoft\\Edge", "Software\\BraveSoftware\\Brave-Browser"]) {
       try {
@@ -100224,9 +101749,9 @@ init_daemon_settings();
 // ../../packages/host-core/dist/activity/activity-tracker.js
 init_credentials();
 import { promises as fsp, writeFileSync as writeFileSync37, mkdirSync as mkdirSync36, existsSync as existsSync34 } from "node:fs";
-import { join as join68 } from "node:path";
+import { join as join69 } from "node:path";
 function activityProfilePath() {
-  return join68(daemonDir2(), "activity-profile.json");
+  return join69(daemonDir2(), "activity-profile.json");
 }
 var MAX_APPS = 300;
 var MAX_AGE_DAYS = 120;
@@ -100535,8 +102060,8 @@ async function runDaemon(opts = {}) {
   log9("paths", JSON.stringify(sealBasePaths()));
   const OUR_STARTED_AT = procStartedAt(process.pid);
   let ownsMachine = false;
-  const pidfile = () => join69(daemonDir2(), "daemon.lock");
-  const statusFile = () => join69(daemonDir2(), "status.json");
+  const pidfile = () => join70(daemonDir2(), "daemon.lock");
+  const statusFile = () => join70(daemonDir2(), "status.json");
   const isAlive2 = (pid) => {
     try {
       process.kill(pid, 0);
@@ -100976,12 +102501,43 @@ async function runDaemon(opts = {}) {
         } catch {
         }
       });
-      eapp.on("render-process-gone", (_e, d) => {
+      const renderRecoveries = [];
+      const RECOVER_WINDOW_MS = 6e4, RECOVER_MAX = 4, RECOVER_DELAY_MS = 300;
+      const recoverRenderer = (wc, reason) => {
+        if (!mergedProcess || deliberateMergedQuit())
+          return;
+        if (reason && !["killed", "crashed", "abnormal-exit", "oom", "launch-failed", "integrity-failure"].includes(reason))
+          return;
+        const now2 = Date.now();
+        while (renderRecoveries.length && now2 - renderRecoveries[0] > RECOVER_WINDOW_MS)
+          renderRecoveries.shift();
+        if (renderRecoveries.length >= RECOVER_MAX) {
+          try {
+            log9(`render-recover: ${RECOVER_MAX} reloads in <60s \u2014 backing off (page may be genuinely crashing)`);
+          } catch {
+          }
+          return;
+        }
+        renderRecoveries.push(now2);
+        const contents = wc;
+        setTimeout(() => {
+          try {
+            if (!contents || contents.isDestroyed?.())
+              return;
+            log9(`render-recover: reloading window after '${reason ?? "unknown"}' (recovery #${renderRecoveries.length})`);
+            contents.reload?.();
+          } catch {
+          }
+        }, RECOVER_DELAY_MS).unref?.();
+      };
+      eapp.on("render-process-gone", (_e, wc, details) => {
+        const reason = details?.reason;
         try {
-          log9(`render-process-gone (kept alive) uptime=${Date.now() - daemonStartedAt}ms: ${JSON.stringify(d)}`);
+          log9(`render-process-gone (kept alive) uptime=${Date.now() - daemonStartedAt}ms: ${JSON.stringify(details ?? {})}`);
           snapshotProcs("render-gone");
         } catch {
         }
+        recoverRenderer(wc, reason);
       });
       eapp.on("child-process-gone", (_e, d) => {
         try {
@@ -101000,7 +102556,7 @@ async function runDaemon(opts = {}) {
   }
   if (ownsMachine)
     setHostDaemonRole(true);
-  const localToken = randomBytes8(24).toString("hex");
+  const localToken = randomBytes10(24).toString("hex");
   const sendToViewer = (kind, sessionId, clientId, msg) => {
     const lb = loopbackRdeskSend.get(clientId);
     if (lb) {
@@ -101159,7 +102715,7 @@ async function runDaemon(opts = {}) {
         if (r.status === 401) {
           log9("device token no longer valid \u2014 dropping to local-only on restart");
           try {
-            unlinkSync6(join69(daemonDir2(), "credentials.json"));
+            unlinkSync6(join70(daemonDir2(), "credentials.json"));
           } catch {
           }
           shutdown(0, "token-revoked-401");
@@ -101557,14 +103113,14 @@ async function runDaemon(opts = {}) {
     // is on; with it off it is the standalone Remote Desktop app, and we forward rather than
     // handle. `provider()` re-reads the setting every time, so switching it back on takes the
     // channel away from the claimant mid-flight — there is never a moment with two servers.
-    onRdesk: (payload, clientId, sessionId) => {
+    onRdesk: (payload, clientId, sessionId, viewerOwner) => {
       const p = rdeskChannel.provider();
       if (p && clientId) {
         p.control(sessionId, clientId, payload);
         return;
       }
       if (rdesk && clientId)
-        void rdesk.onClientMessage(sessionId, { clientId }, payload);
+        void rdesk.onClientMessage(sessionId, { clientId, sameAccount: viewerOwner }, payload);
     },
     onRdeskSignal: (payload, clientId, sessionId) => {
       const p = rdeskChannel.provider();
@@ -101657,7 +103213,7 @@ async function runDaemon(opts = {}) {
     if (appPid > 0 && appPid !== process.pid) {
       const quitMarker = () => {
         try {
-          return Number(readFileSync45(join69(daemonDir2(), "app-quit.marker"), "utf-8").trim()) || 0;
+          return Number(readFileSync45(join70(daemonDir2(), "app-quit.marker"), "utf-8").trim()) || 0;
         } catch {
           return 0;
         }
@@ -101682,7 +103238,7 @@ async function runDaemon(opts = {}) {
           log9(`desktop app (pid ${appPid}) is gone with NO clean-quit marker \u2014 reporting`);
           const tail3 = (name) => {
             try {
-              const buf = readFileSync45(join69(daemonDir2(), name), "utf-8");
+              const buf = readFileSync45(join70(daemonDir2(), name), "utf-8");
               return buf.length > 4096 ? buf.slice(-4096) : buf;
             } catch {
               return void 0;
@@ -101713,7 +103269,7 @@ async function runDaemon(opts = {}) {
   }
   try {
     const DAEMON_LOG_CAP = 2 * 1024 * 1024;
-    const daemonLogFile = join69(daemonDir2(), "daemon.log");
+    const daemonLogFile = join70(daemonDir2(), "daemon.log");
     const capTimer = setInterval(() => {
       try {
         if (existsSync35(daemonLogFile) && statSync9(daemonLogFile).size > DAEMON_LOG_CAP) {
@@ -101765,17 +103321,17 @@ init_dist6();
 init_credentials();
 init_dist();
 var MESH_BASE = "/api/core/tesseract/mesh";
-function fail2(code, detail) {
+function fail3(code, detail) {
   return { ok: false, code, detail };
 }
-async function call(path6, init, auth = true) {
+async function call2(path6, init, auth = true) {
   const creds3 = auth ? readCredentials() : null;
   if (auth && !creds3) {
-    return fail2("not-signed-in", "sign in first: tesseract-agent login");
+    return fail3("not-signed-in", "sign in first: tesseract-agent login");
   }
   const origin = creds3?.apiOrigin;
   if (!origin)
-    return fail2("not-signed-in", "no API origin is configured on this machine");
+    return fail3("not-signed-in", "no API origin is configured on this machine");
   let res;
   try {
     res = await fetch(`${origin.replace(/\/$/, "")}${MESH_BASE}${path6}`, {
@@ -101787,7 +103343,7 @@ async function call(path6, init, auth = true) {
       ...init.body === void 0 ? {} : { body: JSON.stringify(init.body) }
     });
   } catch (e) {
-    return fail2("network", e instanceof Error ? e.message : String(e));
+    return fail3("network", e instanceof Error ? e.message : String(e));
   }
   const text9 = await res.text();
   if (!res.ok) {
@@ -101798,30 +103354,31 @@ async function call(path6, init, auth = true) {
         detail = Array.isArray(parsed.message) ? parsed.message.join("; ") : parsed.message;
     } catch {
     }
-    return fail2(res.status >= 500 ? "server" : "refused", detail);
+    return fail3(res.status >= 500 ? "server" : "refused", detail);
   }
   try {
     return { ok: true, data: text9 ? JSON.parse(text9) : {} };
   } catch {
-    return fail2("server", "the server sent something that is not JSON");
+    return fail3("server", "the server sent something that is not JSON");
   }
 }
 async function listMeshes() {
-  const r = await call("/meshes", { method: "GET" });
+  const r = await call2("/meshes", { method: "GET" });
   return r.ok ? { ok: true, meshes: r.data } : r;
 }
 async function deleteMesh(args) {
-  const r = await call(`/meshes/${encodeURIComponent(args.meshId)}?confirm=${encodeURIComponent(args.confirm)}`, { method: "DELETE" });
+  const r = await call2(`/meshes/${encodeURIComponent(args.meshId)}?confirm=${encodeURIComponent(args.confirm)}`, { method: "DELETE" });
   return r.ok ? { ok: true, deleted: r.data.deleted } : r;
 }
 async function createMesh(args = {}) {
-  const r = await call("/meshes", {
+  const r = await call2("/meshes", {
     method: "POST",
     body: {
       ...args.name ? { name: args.name } : {},
       ...args.cidr ? { meshCidr4: args.cidr } : {},
       ...args.approvalMode ? { approvalMode: args.approvalMode } : {},
       ...args.allowExitNode !== void 0 ? { allowExitNode: args.allowExitNode } : {},
+      ...args.fullTunnelDefault !== void 0 ? { fullTunnelDefault: args.fullTunnelDefault } : {},
       ...args.allowRelay !== void 0 ? { allowRelay: args.allowRelay } : {},
       ...args.magicDns !== void 0 ? { magicDns: args.magicDns } : {}
     }
@@ -101829,42 +103386,42 @@ async function createMesh(args = {}) {
   return r.ok ? { ok: true, ...r.data } : r;
 }
 async function joinToken(args) {
-  const r = await call(`/meshes/${encodeURIComponent(args.meshId)}/token`, { method: "GET" });
+  const r = await call2(`/meshes/${encodeURIComponent(args.meshId)}/token`, { method: "GET" });
   return r.ok ? { ok: true, token: r.data.token } : r;
 }
 async function rotateJoinToken(args) {
-  const r = await call(`/meshes/${encodeURIComponent(args.meshId)}/token/rotate`, { method: "POST", body: {} });
+  const r = await call2(`/meshes/${encodeURIComponent(args.meshId)}/token/rotate`, { method: "POST", body: {} });
   return r.ok ? { ok: true, token: r.data.token } : r;
 }
 async function approveNode(args) {
-  const r = await call(`/meshes/${encodeURIComponent(args.meshId)}/nodes/${encodeURIComponent(args.nodeId)}/approve`, { method: "POST", body: {} });
+  const r = await call2(`/meshes/${encodeURIComponent(args.meshId)}/nodes/${encodeURIComponent(args.nodeId)}/approve`, { method: "POST", body: {} });
   return r.ok ? { ok: true, epoch: r.data.epoch } : r;
 }
 async function newJoinCode(args) {
-  const r = await call(`/meshes/${encodeURIComponent(args.meshId)}/codes`, { method: "POST", body: { uses: args.uses, ttlMinutes: args.ttlMinutes } });
+  const r = await call2(`/meshes/${encodeURIComponent(args.meshId)}/codes`, { method: "POST", body: { uses: args.uses, ttlMinutes: args.ttlMinutes } });
   return r.ok ? { ok: true, ...r.data } : r;
 }
 async function evictNode(args) {
-  const r = await call(`/meshes/${encodeURIComponent(args.meshId)}/nodes/${encodeURIComponent(args.nodeId)}`, { method: "DELETE", body: {} });
+  const r = await call2(`/meshes/${encodeURIComponent(args.meshId)}/nodes/${encodeURIComponent(args.nodeId)}`, { method: "DELETE", body: {} });
   return r.ok ? { ok: true, epoch: r.data.epoch } : r;
 }
 async function enrolWith(requested, post) {
   const name = normaliseNodeName(requested);
   if (!name) {
-    return fail2("bad-name", `"${requested}" cannot be a machine name \u2014 names are DNS labels, so letters, digits and hyphens only`);
+    return fail3("bad-name", `"${requested}" cannot be a machine name \u2014 names are DNS labels, so letters, digits and hyphens only`);
   }
   const stat9 = await generateStaticKey();
   const sig = await generateSigningKey();
   const staticPrivate = await rawPrivate(stat9.privateKey);
   const sigPrivate = await rawPrivate(sig.privateKey);
-  const r = await post(hex4(stat9.publicRaw), hex4(sig.publicRaw), name);
+  const r = await post(hex5(stat9.publicRaw), hex5(sig.publicRaw), name);
   if (!r.ok)
     return r;
   const cert = fromHexOrB64(r.data.cert);
   const genesis = fromHexOrB64(r.data.genesis);
   const meshId = meshIdOf(cert);
   if (!meshId)
-    return fail2("server", "the certificate the server returned is unreadable");
+    return fail3("server", "the certificate the server returned is unreadable");
   let issuedName = name;
   try {
     issuedName = decodeCert(cert).details.name || name;
@@ -101873,8 +103430,14 @@ async function enrolWith(requested, post) {
   try {
     saveMesh(meshId, { genesis, cert, staticPrivate, sigPrivate });
     writeLocal(meshId, { joinedAt: Date.now(), enabled: true });
+    if (r.data.bundle) {
+      try {
+        cacheBundle(fromHexOrB64(r.data.bundle), meshId);
+      } catch {
+      }
+    }
   } catch (e) {
-    return fail2("disk", `the certificate was issued but could not be saved: ${e instanceof Error ? e.message : String(e)}. Ask an admin for a new join code \u2014 this one has been used.`);
+    return fail3("disk", `the certificate was issued but could not be saved: ${e instanceof Error ? e.message : String(e)}. Ask an admin for a new join code \u2014 this one has been used.`);
   }
   return {
     ok: true,
@@ -101888,9 +103451,9 @@ async function enrolWith(requested, post) {
   };
 }
 async function enrol(args) {
-  return enrolWith(args.name, (staticPub, sigPub, name) => call(`/meshes/${encodeURIComponent(args.meshId)}/nodes`, {
+  return enrolWith(args.name, (staticPub, sigPub, name) => call2(`/meshes/${encodeURIComponent(args.meshId)}/nodes`, {
     method: "POST",
-    body: { name, staticPub, sigPub }
+    body: { name, staticPub, sigPub, ...args.exitNode === true ? { exitNode: true } : {} }
   }));
 }
 async function joinWithToken(args) {
@@ -101899,7 +103462,7 @@ async function joinWithToken(args) {
 async function postJoin(origin, body) {
   const base = origin ?? readCredentials()?.apiOrigin;
   if (!base) {
-    return fail2("not-signed-in", "this machine has never signed in \u2014 pass --origin https://\u2026 so it knows which server to ask");
+    return fail3("not-signed-in", "this machine has never signed in \u2014 pass --origin https://\u2026 so it knows which server to ask");
   }
   let res;
   try {
@@ -101909,7 +103472,7 @@ async function postJoin(origin, body) {
       body: JSON.stringify(body)
     });
   } catch (e) {
-    return fail2("network", e instanceof Error ? e.message : String(e));
+    return fail3("network", e instanceof Error ? e.message : String(e));
   }
   const text9 = await res.text();
   if (!res.ok) {
@@ -101920,7 +103483,7 @@ async function postJoin(origin, body) {
         detail = String(parsed.message);
     } catch {
     }
-    return fail2(res.status >= 500 ? "server" : "refused", detail);
+    return fail3(res.status >= 500 ? "server" : "refused", detail);
   }
   return { ok: true, data: JSON.parse(text9) };
 }
@@ -101934,7 +103497,7 @@ async function rawPrivate(key2) {
   }
   return pkcs8.subarray(16);
 }
-function hex4(b) {
+function hex5(b) {
   return Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
 }
 function fromHexOrB64(s) {
@@ -101950,8 +103513,63 @@ function meshIdOf(cert) {
   return meshDirNameFromWireId(Array.from(cert.subarray(OFFSET, OFFSET + 32), (b) => b.toString(16).padStart(2, "0")).join(""));
 }
 
-// ../../packages/host-core/dist/mesh/netd-client.js
-var MAX_LINE = 1024 * 1024;
+// ../../packages/host-core/dist/mesh/full-tunnel.js
+function fullTunnelState(i) {
+  const no2 = (reason) => ({ allowed: false, reason, warnings: [] });
+  if (i.platform !== "linux") {
+    const name = i.platform === "darwin" ? "macOS" : i.platform === "win32" ? "Windows" : i.platform;
+    return no2(`Routing all traffic needs the network helper, which does not exist on ${name} yet.`);
+  }
+  if (!i.engineAvailable) {
+    return no2("This build shipped without the network engine, so no traffic can be routed. That is a packaging fault \u2014 please report it.");
+  }
+  if (i.helperCode === "wire-version") {
+    return no2("Update the network helper \u2014 this build speaks a newer protocol than the one installed.");
+  }
+  if (!i.helperAvailable) {
+    return no2("Turn this network on to install the network helper \u2014 nothing can be routed until it is there.");
+  }
+  if (!i.hasBundle) {
+    return no2("This machine has not received this network\u2019s policy yet, so nothing can be routed. It arrives from any other machine on the network.");
+  }
+  if (!i.networkAllows) {
+    return no2("This network does not allow routing all traffic through it. An admin of the network chooses that.");
+  }
+  if (i.selfIsExitNode) {
+    return no2("This machine is this network\u2019s way out to the internet, so it cannot route its own traffic through itself.");
+  }
+  if (i.exitNodes.length === 0) {
+    return no2("No machine on this network offers to be the way out yet, so there is nowhere for the traffic to go.");
+  }
+  if (i.claimedBy) {
+    return no2(`All traffic already goes through ${i.claimedBy}. A machine has one default route, so only one network can claim it.`);
+  }
+  if (!i.ownsNode) {
+    return no2("The Tesseract app is running this network on this machine. Change this from there.");
+  }
+  if (i.pathToExit === "none") {
+    return no2(`Waiting for a connection to ${i.exitNodes[0]}. All traffic cannot be routed until this machine can reach it.`);
+  }
+  const warnings = [];
+  if (i.pathToExit === "relay") {
+    warnings.push(`All traffic will go through ${i.exitNodes[0]} by way of a relay, so it will be slower than usual.`);
+  }
+  return { allowed: true, reason: null, warnings };
+}
+function bundleGrantsExitNode(bundle) {
+  if (bundle === void 0 || bundle.length === 0)
+    return false;
+  try {
+    const pki = (init_dist6(), __toCommonJS(dist_exports3));
+    const decoded = pki.decodeSignedBundle(bundle);
+    return decoded.bundle.rules.some((r) => (r.caps & pki.CAP_EXIT_NODE) !== 0);
+  } catch {
+    return false;
+  }
+}
+
+// ../../packages/host-core/dist/mesh/machine-owner.js
+init_credentials();
 
 // ../../packages/host-core/dist/service/exec.js
 import { execFile as execFile10, spawn as spawn14 } from "node:child_process";
@@ -101969,9 +103587,6 @@ function runInherit(cmd, args) {
 var UNIT = "tesseract-netd.service";
 var UNIT_PATH = `/etc/systemd/system/${UNIT}`;
 
-// ../../packages/host-core/dist/mesh/machine-owner.js
-init_credentials();
-
 // ../../packages/host-core/dist/clipboard/clipboard-sync.js
 var MAX_IMAGE_BYTES3 = 10 * 1024 * 1024;
 var OVERSIZED_BYTES = 512 * 1024;
@@ -101985,7 +103600,7 @@ init_daemon_settings();
 init_credentials();
 
 // ../../packages/host-core/dist/service/index.js
-import { platform as platform5 } from "node:os";
+import { platform as platform6 } from "node:os";
 
 // ../../packages/host-core/dist/service/launchd.js
 init_credentials();
@@ -102265,7 +103880,7 @@ start "" /b ${cmd} >> "${oneLine2(spec.logPath).replace(/"/g, "")}" 2>&1\r
 // ../../packages/host-core/dist/service/index.js
 function getServiceController(instanceId) {
   const id = instanceId && instanceId.length ? instanceId : void 0;
-  switch (platform5()) {
+  switch (platform6()) {
     case "darwin":
       return makeLaunchd(id);
     case "linux":
@@ -102523,12 +104138,12 @@ function isReleaseVersion(v) {
   return /^\d+\.\d+\.\d+/.test(v.trim());
 }
 function isNewer(latest, current) {
-  const parse3 = (v) => {
+  const parse4 = (v) => {
     const m = /^v?(\d+)\.(\d+)\.(\d+)/.exec(v.trim());
     return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;
   };
-  const a = parse3(latest);
-  const b = parse3(current);
+  const a = parse4(latest);
+  const b = parse4(current);
   if (!a || !b) return false;
   for (let i = 0; i < 3; i++) if (a[i] !== b[i]) return a[i] > b[i];
   return false;
@@ -102646,12 +104261,12 @@ function startSelfUpdater(current) {
 
 // src/service.ts
 import { join as join75 } from "node:path";
-import { platform as platform6 } from "node:os";
+import { platform as platform7 } from "node:os";
 import { existsSync as existsSync40, readFileSync as readFileSync46 } from "node:fs";
 function controller(instanceId) {
   const c = getServiceController(instanceId);
   if (!c) {
-    throw new Error(`tesseract-agent can't manage a background service on ${platform6()}. Run it in the foreground instead: \`tesseract-agent run\` (e.g. as a Docker entrypoint).`);
+    throw new Error(`tesseract-agent can't manage a background service on ${platform7()}. Run it in the foreground instead: \`tesseract-agent run\` (e.g. as a Docker entrypoint).`);
   }
   return c;
 }
@@ -102732,7 +104347,9 @@ Running a network (needs a signed-in account):
   tesseract-agent net new [NAME]             Create a network and print its join token.
       [--approve auto|admin]                 who may join: the token alone, or you say yes
       [--cidr A.B.C.D/L]                     address range (default 100.96.0.0/12)
-      [--exit-node] [--no-relay] [--no-dns]  everything is optional and has a default
+      [--exit-node]                          let machines route ALL traffic through it
+      [--full-tunnel-default]                ...and start new machines that way (needs --exit-node)
+      [--no-relay] [--no-dns]                everything is optional and has a default
   tesseract-agent net networks [--json]      List your networks and their machines
   tesseract-agent net token MESH [--rotate]  Show the join token again, or replace it
   tesseract-agent net approve MESH NODE      Let a waiting machine on
@@ -102741,8 +104358,13 @@ Running a network (needs a signed-in account):
                                              Delete a network for good. Irreversible.
   tesseract-agent net code new MESH [--uses N] [--ttl MIN] [--json]
                                              A ONE-SHOT code, for anyone who wants one
-  tesseract-agent net join-me MESH [--name N]
+  tesseract-agent net route-all [MESH] [--off]
+                                             Route ALL of this machine's traffic through a
+                                             network (the classic-VPN posture), or stop
+  tesseract-agent net join-me MESH [--name N] [--exit-node]
                                              Join THIS machine to a network you run
+                                             --exit-node offers this machine as everyone's
+                                             way out to the internet (the network must allow it)
 
 Admin (needs the mesh CA, not a node):
   tesseract-agent net init --org NAME [--ca-dir DIR]
@@ -102898,7 +104520,7 @@ async function netCommand(rest, flags) {
         console.error(`net ${sub}: not enrolled in ${meshId}`);
         process.exit(1);
       }
-      writeLocal(meshId, { ...readLocal(meshId), enabled: sub === "up" });
+      updateLocal(meshId, { enabled: sub === "up" });
       console.log(`${meshId}  ${sub === "up" ? "enabled" : "disabled"}`);
     }
     console.log("Run `tesseract-agent restart` for this to take effect now.");
@@ -103008,11 +104630,22 @@ async function netCommand(rest, flags) {
       console.error("net new: --approve must be 'auto' or 'admin'");
       process.exit(1);
     }
+    if (flags["full-tunnel-default"] === true && flags["exit-node"] !== true) {
+      console.error(
+        "net new: --full-tunnel-default needs --exit-node \u2014 the first is a default, the second is the permission it depends on"
+      );
+      process.exit(1);
+    }
     const r = await createMesh({
       ...name ? { name } : {},
       ...str2(flags.cidr) ? { cidr: str2(flags.cidr) } : {},
       ...approve ? { approvalMode: approve } : {},
       ...flags["exit-node"] === true ? { allowExitNode: true } : {},
+      // The DEFAULT half. Clamped to the permission server-side, but refuse it here too
+      // rather than sending a combination that can never take effect — an operator who
+      // typed only --full-tunnel-default has misunderstood which flag does what, and a
+      // silent clamp would let them keep believing it.
+      ...flags["full-tunnel-default"] === true ? { fullTunnelDefault: true } : {},
       ...flags["no-relay"] === true ? { allowRelay: false } : {},
       ...flags["no-dns"] === true ? { magicDns: false } : {}
     });
@@ -103129,7 +104762,11 @@ async function netCommand(rest, flags) {
       console.error("net join-me: that name cannot be used \u2014 letters, digits and hyphens only");
       process.exit(1);
     }
-    const r = await enrol({ meshId, name: nm });
+    const r = await enrol({
+      meshId,
+      name: nm,
+      ...flags["exit-node"] === true ? { exitNode: true } : {}
+    });
     if (!r.ok) {
       console.error(`net join-me: ${r.detail}`);
       process.exit(1);
@@ -103138,6 +104775,48 @@ async function netCommand(rest, flags) {
     if (r.name !== nm) console.log(`(another machine here is already called "${nm}")`);
     return;
   }
+  if (sub === "route-all") {
+    const ids = listMeshIds();
+    const target = rest[1] ?? str2(flags.mesh);
+    const off = flags.off === true;
+    if (!ids.length) {
+      console.error("net route-all: this machine is not in any network");
+      process.exit(1);
+    }
+    if (!target && ids.length > 1) {
+      console.error("net route-all: name a network \u2014 this machine is in several");
+      for (const meshId2 of ids) console.error(`  ${meshId2}`);
+      process.exit(1);
+    }
+    const meshId = target ?? ids[0];
+    if (!ids.includes(meshId)) {
+      console.error(`net route-all: not enrolled in ${meshId}`);
+      process.exit(1);
+    }
+    const identity = loadMesh(meshId);
+    const state3 = fullTunnelState({
+      platform: process.platform,
+      helperAvailable: await netdAvailable(),
+      helperCode: null,
+      engineAvailable: meshEngineStatus().available,
+      hasBundle: identity?.bundle !== void 0 && identity.bundle.length > 0,
+      networkAllows: bundleGrantsExitNode(identity?.bundle),
+      exitNodes: [],
+      selfIsExitNode: false,
+      pathToExit: "none",
+      claimedBy: ids.find((id) => id !== meshId && readLocal(id)?.fullTunnel === true) ?? null,
+      ownsNode: true
+    });
+    if (!off && !state3.allowed) {
+      console.error(`net route-all: ${state3.reason}`);
+      process.exit(1);
+    }
+    updateLocal(meshId, { fullTunnel: !off });
+    console.log(off ? `${meshId}  all traffic no longer routed through this network` : `${meshId}  ALL traffic from this machine will go through this network`);
+    for (const w of state3.warnings) console.log(`  ${w}`);
+    console.log("Run `tesseract-agent restart` for this to take effect now.");
+    return;
+  }
   if (sub === "peers") {
     const s = readStatus();
     if (!s || s.stale) {