@jsonstudio/zterm-daemon-win32-x64 0.1.3 → 0.1.4

package/runtime/server.cjs

@@ -2228,7 +2228,7 @@ var require_websocket = __commonJS({
     var http = require("http");
     var net = require("net");
     var tls = require("tls");
-    var { randomBytes, createHash: createHash4 } = require("crypto");
+    var { randomBytes, createHash: createHash5 } = require("crypto");
     var { Duplex, Readable } = require("stream");
     var { URL: URL2 } = require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -2888,7 +2888,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash4("sha1").update(key + GUID).digest("base64");
+        const digest = createHash5("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -3167,7 +3167,7 @@ var require_stream = __commonJS({
       };
       duplex._final = function(callback) {
         if (ws.readyState === ws.CONNECTING) {
-          ws.once("open", function open() {
+          ws.once("open", function open2() {
             duplex._final(callback);
           });
           return;
@@ -3188,7 +3188,7 @@ var require_stream = __commonJS({
       };
       duplex._write = function(chunk, encoding, callback) {
         if (ws.readyState === ws.CONNECTING) {
-          ws.once("open", function open() {
+          ws.once("open", function open2() {
             duplex._write(chunk, encoding, callback);
           });
           return;
@@ -3255,7 +3255,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = require("events");
     var http = require("http");
     var { Duplex } = require("stream");
-    var { createHash: createHash4 } = require("crypto");
+    var { createHash: createHash5 } = require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -3556,7 +3556,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash4("sha1").update(key + GUID).digest("base64");
+        const digest = createHash5("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -5040,6 +5040,7 @@ var import_sender = __toESM(require_sender(), 1);
 var import_subprotocol = __toESM(require_subprotocol(), 1);
 var import_websocket = __toESM(require_websocket(), 1);
 var import_websocket_server = __toESM(require_websocket_server(), 1);
+var wrapper_default = import_websocket.default;
 
 // src/server/server.ts
 var import_http = require("http");
@@ -5184,7 +5185,8 @@ function resolveDaemonRuntimeConfig(options) {
   const relayPassword = asString(env.ZTERM_TRAVERSAL_PASSWORD) || asString(relayConfig.password);
   const relayHostId = asString(env.ZTERM_TRAVERSAL_HOST_ID) || asString(relayConfig.hostId);
   const relayDefaultHostName = (0, import_os.hostname)().trim();
-  const relayDeviceId = asString(env.ZTERM_TRAVERSAL_DEVICE_ID) || asString(relayConfig.deviceId) || relayDefaultHostName;
+  const configuredDeviceId = asString(env.ZTERM_TRAVERSAL_DEVICE_ID) || asString(relayConfig.deviceId);
+  const relayDeviceId = configuredDeviceId || relayDefaultHostName;
   const relayDeviceName = asString(env.ZTERM_TRAVERSAL_DEVICE_NAME) || asString(relayConfig.deviceName) || relayDefaultHostName;
   const relayPlatform = asString(env.ZTERM_TRAVERSAL_PLATFORM) || asString(relayConfig.platform) || process.platform;
   const relayAppVersion = asString(env.ZTERM_TRAVERSAL_APP_VERSION) || asString(env.ZTERM_APP_VERSION) || asString(relayConfig.appVersion);
@@ -5207,6 +5209,7 @@ function resolveDaemonRuntimeConfig(options) {
     authToken,
     terminalCacheLines,
     sessionName,
+    deviceId: configuredDeviceId,
     daemonHostId,
     configPath: path,
     configFound: found,
@@ -7505,9 +7508,11 @@ function v4(options, buf, offset) {
 }
 var v4_default = v4;
 
-// src/server/terminal-transport-runtime.ts
+// src/server/terminal-runtime-types.ts
 var TRANSPORT_BACKPRESSURE_BUFFERED_BYTES = 128e3;
 var TRANSPORT_BACKPRESSURE_LOW_WATER_BYTES = 64e3;
+
+// src/server/terminal-transport-runtime.ts
 var TERMINAL_TRANSPORT_STALE_INBOUND_MS = 19e4;
 function estimateTransportMessageBytes(text) {
   return Buffer.byteLength(text, "utf8");
@@ -7517,6 +7522,7 @@ function readTerminalTransportBackpressureSnapshot(transport) {
     return null;
   }
   const bufferedBytes = Math.max(0, Math.floor(transport.bufferedAmount || 0));
+  const flowUnknown = !!transport.flowUnknown;
   const backpressure = bufferedBytes >= TRANSPORT_BACKPRESSURE_BUFFERED_BYTES;
   if (backpressure) {
     transport.backpressureCount = Math.max(0, Math.floor(transport.backpressureCount || 0)) + 1;
@@ -7529,6 +7535,7 @@ function readTerminalTransportBackpressureSnapshot(transport) {
     bufferedBytes,
     backpressure,
     lowWaterDrained: bufferedBytes <= TRANSPORT_BACKPRESSURE_LOW_WATER_BYTES,
+    flowUnknown,
     backpressureCount: Math.max(0, Math.floor(transport.backpressureCount || 0)),
     lastSendBytes: Math.max(0, Math.floor(transport.lastSendBytes || 0)),
     totalSendBytes: Math.max(0, Math.floor(transport.totalSendBytes || 0)),
@@ -7850,6 +7857,9 @@ function createDaemonBufferPublisherRuntime(deps) {
     if (!snapshot?.ready) {
       return true;
     }
+    if (snapshot.flowUnknown) {
+      return true;
+    }
     if (snapshot.backpressure) {
       state.highWaterActive = true;
       if (!state.highWaterEnteredAt) {
@@ -7918,6 +7928,9 @@ function createDaemonBufferPublisherRuntime(deps) {
       const start = Math.max(0, item.nextChunkIndex || 0);
       const end = Math.min(messages.length, start + Math.max(1, Math.floor(maxChunks)));
       for (let index = start; index < end; index += 1) {
+        if (shouldHoldPendingForBackpressure(state, session)) {
+          return sentChunks > 0 ? { status: "sent", sentChunks } : { status: "backpressured", sentChunks: 0 };
+        }
         deps.sendText(session.transport, messages[index].text);
         item.nextChunkIndex = index + 1;
         sentChunks += 1;
@@ -8011,6 +8024,9 @@ function createDaemonBufferPublisherRuntime(deps) {
     try {
       deps.ensureSessionReady(session, mirror);
       for (let index = start; index < end; index += 1) {
+        if (shouldHoldPendingForBackpressure(state, session)) {
+          return sentChunks > 0 ? { status: "sent", sentChunks } : { status: "backpressured", sentChunks: 0 };
+        }
         const message = messages[index];
         deps.recordPerformanceTrace?.({
           ...traceBase,
@@ -10414,6 +10430,7 @@ function logFileTransferRuntimeError(scope, error, context) {
 var MAX_REMOTE_DIRECTORY_CACHE_ENTRIES = 32;
 function createTerminalFileTransferListRuntime(deps) {
   const directoryCache = /* @__PURE__ */ new Map();
+  const cancelActiveDownloads = /* @__PURE__ */ new Set();
   function readDirectorySnapshot(resolvedPath) {
     const entries = (0, import_fs4.readdirSync)(resolvedPath, { withFileTypes: true });
     const fileEntries = [];
@@ -10568,6 +10585,10 @@ function createTerminalFileTransferListRuntime(deps) {
     }
   }
   function dispose() {
+    for (const cancel of cancelActiveDownloads) {
+      cancel();
+    }
+    cancelActiveDownloads.clear();
     for (const entry of directoryCache.values()) {
       closeDirectoryCacheEntry(entry);
     }
@@ -10578,32 +10599,99 @@ function createTerminalFileTransferListRuntime(deps) {
   }
   function sendFileDownloadBuffer(session, requestId, fileName, fileBuffer) {
     const totalChunks = Math.ceil(fileBuffer.length / FILE_CHUNK_SIZE);
+    const requestTransportId = session.transportId;
     let index = 0;
-    function sendNextChunk() {
-      if (index >= totalChunks) {
-        deps.sendMessage(session, {
-          type: "file-download-complete",
-          payload: { requestId, fileName, totalBytes: fileBuffer.length }
-        });
-        return;
+    let cancelled = false;
+    let waitTimer = null;
+    let draining = false;
+    function stop() {
+      cancelled = true;
+      if (waitTimer) {
+        clearTimeout(waitTimer);
+        waitTimer = null;
       }
-      const start = index * FILE_CHUNK_SIZE;
-      const end = Math.min(start + FILE_CHUNK_SIZE, fileBuffer.length);
-      const chunk = fileBuffer.subarray(start, end);
+      cancelActiveDownloads.delete(stop);
+    }
+    function fail(error) {
+      stop();
       deps.sendMessage(session, {
-        type: "file-download-chunk",
+        type: "file-download-error",
         payload: {
           requestId,
-          chunkIndex: index,
-          totalChunks,
-          fileName,
-          dataBase64: chunk.toString("base64")
+          error: error instanceof Error ? error.message : String(error)
         }
       });
+    }
+    function pump() {
+      if (cancelled) {
+        return;
+      }
+      if (session.transportId !== requestTransportId) {
+        stop();
+        return;
+      }
+      const transport = session.transport;
+      if (transport) {
+        if (transport.readyState !== import_websocket.default.OPEN) {
+          stop();
+          return;
+        }
+        if (transport.flowUnknown) {
+          draining = true;
+          waitTimer = setTimeout(() => {
+            waitTimer = null;
+            pump();
+          }, 20);
+          return;
+        }
+        const bufferedBytes = Math.max(0, Math.floor(transport.bufferedAmount || 0));
+        const holding = draining ? bufferedBytes > TRANSPORT_BACKPRESSURE_LOW_WATER_BYTES : bufferedBytes >= TRANSPORT_BACKPRESSURE_BUFFERED_BYTES;
+        if (holding) {
+          draining = true;
+          waitTimer = setTimeout(() => {
+            waitTimer = null;
+            pump();
+          }, 20);
+          return;
+        }
+        draining = false;
+      }
+      if (index >= totalChunks) {
+        try {
+          deps.sendMessage(session, {
+            type: "file-download-complete",
+            payload: { requestId, fileName, totalBytes: fileBuffer.length }
+          });
+        } catch (error) {
+          fail(error);
+          return;
+        }
+        stop();
+        return;
+      }
+      const start = index * FILE_CHUNK_SIZE;
+      const end = Math.min(start + FILE_CHUNK_SIZE, fileBuffer.length);
+      const chunk = fileBuffer.subarray(start, end);
+      try {
+        deps.sendMessage(session, {
+          type: "file-download-chunk",
+          payload: {
+            requestId,
+            chunkIndex: index,
+            totalChunks,
+            fileName,
+            dataBase64: chunk.toString("base64")
+          }
+        });
+      } catch (error) {
+        fail(error);
+        return;
+      }
       index += 1;
-      setImmediate(sendNextChunk);
+      setImmediate(pump);
     }
-    sendNextChunk();
+    cancelActiveDownloads.add(stop);
+    pump();
   }
   function buildRemoteScreenshotFileName(prefix = "remote-screenshot") {
     const now = /* @__PURE__ */ new Date();
@@ -19823,199 +19911,2709 @@ function createTerminalAttachTokenRuntime() {
   };
 }
 
-// src/server/remote-screenshot-daemon.ts
-var import_node_child_process6 = require("node:child_process");
-var import_node_os2 = require("node:os");
-var import_node_path5 = require("node:path");
-async function captureRemoteScreenshotWithDaemon(options) {
-  const gate = runPhase3Screenshot({
-    execution_id: `remote-screenshot:${Date.now()}`,
-    attempt_id: "1",
-    inputs: {
-      "arc.screenshot_request": {
-        sessionId: options.sessionId || "daemon-screenshot",
-        outputPath: options.outputPath
-      },
-      "arc.screenshot_permission": { allowScreenshot: true }
-    }
-  });
-  if (!gate.ok) {
-    throw new Error(`dagpipe screenshot gate rejected capture: ${gate.error}`);
+// src/server/daemon-app-messaging-runtime.ts
+var import_node_crypto3 = require("node:crypto");
+
+// ../packages/shared/src/connection/app-protocol.ts
+var APP_PROTOCOL_VERSION = 1;
+var APP_MAX_MESSAGE_BYTES = 1048576;
+var APP_MAX_FILE_BYTES = 268435456;
+var APP_FILE_CHUNK_BYTES = 16384;
+var APP_MAX_SAFE_FILE_NAME_BYTES = 255;
+var APP_MAX_PATH_IDENTITY_BYTES = 191;
+var APP_MAX_INBOX_RECORDS = 512;
+var APP_MAX_INBOX_BYTES = 2 * 1024 * 1024 * 1024;
+var APP_STREAM_OUTBOUND_QUEUE_BYTES = 4 * 1024 * 1024;
+var APP_ACKED_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
+var APP_SERVER_NAME = "zterm.app";
+var AppProtocolError = class extends Error {
+  constructor(options) {
+    super(options.message);
+    this.name = "AppProtocolError";
+    this.code = options.code;
+    this.stage = options.stage;
+    this.requestId = options.requestId;
+    this.messageId = options.messageId;
+    this.transferId = options.transferId;
   }
-  return await new Promise((resolve4, reject) => {
-    const daemonBinary = (process.env.ZTERM_DAEMON_NATIVE || "").trim() || (0, import_node_path5.join)((0, import_node_os2.homedir)(), ".zterm", "bin", "zterm-daemon");
-    const args = ["capture-screen", options.outputPath];
-    const windowId = options.windowId?.trim();
-    if (windowId) {
-      args.push("--window-id", windowId);
-    }
-    if (options.rect) {
-      args.push(
-        "--rect",
-        [
-          Math.round(options.rect.x),
-          Math.round(options.rect.y),
-          Math.round(options.rect.width),
-          Math.round(options.rect.height)
-        ].join(",")
-      );
-    }
-    (0, import_node_child_process6.execFile)(daemonBinary, args, {
-      timeout: options.timeoutMs,
-      windowsHide: true
-    }, (error, stdout, stderr) => {
-      if (error) {
-        const details = [error.message, stderr, stdout].filter(Boolean).join("\n");
-        reject(new Error(details || "daemon screenshot capture failed"));
-        return;
-      }
-      resolve4({ outputPath: options.outputPath });
+};
+var APP_CAPABILITIES = {
+  serverName: APP_SERVER_NAME,
+  protocolVersion: APP_PROTOCOL_VERSION,
+  messages: true,
+  files: true,
+  durableInbox: true,
+  push: true,
+  ackStates: ["delivered", "consumed"],
+  resumeFileTransfer: true,
+  maxMessageBytes: APP_MAX_MESSAGE_BYTES,
+  maxFileBytes: APP_MAX_FILE_BYTES,
+  fileChunkBytes: APP_FILE_CHUNK_BYTES
+};
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function requiredString(value, field, stage) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new AppProtocolError({
+      code: "invalid_frame",
+      message: `${field} must be a non-empty string`,
+      stage
     });
-  });
-}
-
-// src/server/remote-window-stream-daemon.ts
-var import_wrtc2 = __toESM(require_lib2(), 1);
-
-// src/server/remote-window-stream-daemon-helpers.ts
-function cloneRemoteWindowTargetCatalogResponse(response, requestId) {
-  return {
-    requestId,
-    targets: response.targets.slice(),
-    ...response.errors ? {
-      errors: response.errors.map((error) => ({
-        ...error,
-        requestId
-      }))
-    } : {}
-  };
+  }
+  return value;
 }
-function cloneRemoteWindowTargetCatalogResult(result, requestId) {
-  if ("targets" in result) {
-    return cloneRemoteWindowTargetCatalogResponse(result, requestId);
+function stringValue(value, field, stage) {
+  if (typeof value !== "string") {
+    throw new AppProtocolError({
+      code: "invalid_frame",
+      message: `${field} must be a string`,
+      stage
+    });
   }
-  return {
-    ...result,
-    requestId
-  };
+  return value;
 }
-function normalizeRtcDescription(description, expectedType) {
-  if (!description || description.type !== expectedType || typeof description.sdp !== "string") {
-    throw new Error(`remote window daemon expected ${expectedType} description`);
+function requiredInteger(value, field, stage, min) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < min) {
+    throw new AppProtocolError({
+      code: "invalid_frame",
+      message: `${field} must be an integer >= ${min}`,
+      stage
+    });
   }
-  return {
-    type: expectedType,
-    sdp: description.sdp
-  };
+  return value;
 }
-function normalizeIceCandidate(candidate) {
-  const candidateLike = typeof candidate.toJSON === "function" ? candidate.toJSON() : candidate;
-  return {
-    candidate: String(candidateLike.candidate || ""),
-    sdpMid: candidateLike.sdpMid ?? null,
-    sdpMLineIndex: candidateLike.sdpMLineIndex ?? null,
-    usernameFragment: candidateLike.usernameFragment ?? null
-  };
+function requiredBoolean(value, field, stage) {
+  if (typeof value !== "boolean") {
+    throw new AppProtocolError({
+      code: "invalid_frame",
+      message: `${field} must be a boolean`,
+      stage
+    });
+  }
+  return value;
 }
-function normalizeRemoteWindowVideoProfile(input) {
-  if (!input) {
-    return null;
+function requiredFiniteNumber(value, field, stage) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new AppProtocolError({
+      code: "invalid_frame",
+      message: `${field} must be a finite number`,
+      stage
+    });
   }
-  if (input.preference !== "smooth" && input.preference !== "quality") {
-    throw new Error(`remote window video preference is invalid: ${String(input.preference)}`);
+  return value;
+}
+function optionalIntegerValue(value, field, stage, min) {
+  return value === void 0 ? void 0 : requiredInteger(value, field, stage, min);
+}
+function optionalString(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function optionalStringValue(value) {
+  return typeof value === "string" ? value : void 0;
+}
+var APP_RECORD_STATES = ["received", "delivered", "consumed", "rejected"];
+var APP_SEND_STATUSES = [
+  "received",
+  "delivered",
+  "consumed",
+  "rejected",
+  "resultUnknown",
+  "unreachable",
+  "receiving"
+];
+var APP_SEND_STAGES = [
+  "prepared",
+  "sent",
+  "received",
+  "result_unknown"
+];
+var APP_ERROR_CODES = [
+  "invalid_version",
+  "invalid_frame",
+  "missing_identity",
+  "unauthorized",
+  "forbidden_role",
+  "message_id_conflict",
+  "message_too_large",
+  "file_too_large",
+  "invalid_file_name",
+  "invalid_chunk",
+  "chunk_conflict",
+  "transfer_conflict",
+  "transfer_incomplete",
+  "integrity_mismatch",
+  "inbox_full",
+  "not_found",
+  "ambiguous_message_id",
+  "invalid_state",
+  "slow_consumer",
+  "unreachable",
+  "result_unknown",
+  "source_changed",
+  "storage_error",
+  "cancelled",
+  "internal_error"
+];
+function oneOf(value, allowed, field, stage) {
+  if (typeof value !== "string" || !allowed.includes(value)) {
+    throw new AppProtocolError({
+      code: "invalid_frame",
+      message: `${field} must be one of ${allowed.join(", ")}`,
+      stage
+    });
   }
-  const fields = [
-    ["maxBitrateBps", input.maxBitrateBps, 5e5, 25e6],
-    ["maxFrameRateFps", input.maxFrameRateFps, 1, 60],
-    ["maxCaptureWidth", input.maxCaptureWidth, 320, 3840],
-    ["maxCaptureHeight", input.maxCaptureHeight, 240, 2400],
-    ["maxFrameAgeMs", input.maxFrameAgeMs, 40, 1e3],
-    ["overviewMaxBitrateBps", input.overviewMaxBitrateBps, 0, 2e6],
-    ["overviewMaxFrameRateFps", input.overviewMaxFrameRateFps, 0, 8]
-  ];
-  for (const [name, value, minimum, maximum] of fields) {
-    if (!Number.isFinite(value) || value < minimum || value > maximum) {
-      throw new Error(`remote window video profile ${name} is out of range`);
-    }
+  return value;
+}
+function assertAppProtocolVersion(value) {
+  if (value !== APP_PROTOCOL_VERSION) {
+    throw new AppProtocolError({
+      code: "invalid_version",
+      message: `unsupported protocol version: ${String(value)}`,
+      stage: "admission"
+    });
   }
-  if (input.overviewMaxBitrateBps >= input.maxBitrateBps) {
-    throw new Error("remote window overview bitrate must remain below the total bitrate");
+  return APP_PROTOCOL_VERSION;
+}
+function validateAppHello(value) {
+  if (!isRecord2(value)) {
+    throw new AppProtocolError({ code: "invalid_frame", message: "hello must be an object", stage: "admission" });
   }
-  if (input.overviewMaxFrameRateFps > input.maxFrameRateFps) {
-    throw new Error("remote window overview frame rate must not exceed focus frame rate");
+  const requestId = requiredString(value.requestId, "requestId", "admission");
+  const role = value.role;
+  if (role !== "local" && role !== "peer") {
+    throw new AppProtocolError({
+      code: "invalid_frame",
+      message: "role must be local or peer",
+      stage: "admission",
+      requestId
+    });
   }
+  assertAppProtocolVersion(value.protocolVersion);
   return {
-    preference: input.preference,
-    maxBitrateBps: Math.floor(input.maxBitrateBps),
-    maxFrameRateFps: Math.floor(input.maxFrameRateFps),
-    maxCaptureWidth: Math.floor(input.maxCaptureWidth),
-    maxCaptureHeight: Math.floor(input.maxCaptureHeight),
-    maxFrameAgeMs: Math.floor(input.maxFrameAgeMs),
-    interactionActive: input.interactionActive === true,
-    overviewMaxBitrateBps: Math.floor(input.overviewMaxBitrateBps),
-    overviewMaxFrameRateFps: Math.floor(input.overviewMaxFrameRateFps)
+    protocolVersion: APP_PROTOCOL_VERSION,
+    requestId,
+    role,
+    clientInstanceId: requiredString(value.clientInstanceId, "clientInstanceId", "admission"),
+    deviceId: requiredString(value.deviceId, "deviceId", "admission"),
+    daemonHostId: requiredString(value.daemonHostId, "daemonHostId", "admission"),
+    capabilities: isRecord2(value.capabilities) ? value.capabilities : {}
   };
 }
-function formatRemoteWindowVideoProfileError(error) {
-  if (error instanceof Error) {
-    return error.message || error.name || "remote window video bitrate could not be applied";
+function validateAppTarget(value, stage) {
+  if (!isRecord2(value)) {
+    throw new AppProtocolError({ code: "invalid_frame", message: "target must be an object", stage });
   }
-  const message = String(error || "").trim();
-  return message || "remote window video bitrate could not be applied";
-}
-function convertRgbaToI420Frame(frame, convert) {
-  const width = Math.max(1, Math.floor(frame.width));
-  const height = Math.max(1, Math.floor(frame.height));
-  const chromaWidth = Math.ceil(width / 2);
-  const chromaHeight = Math.ceil(height / 2);
-  const i420 = {
-    width,
-    height,
-    data: new Uint8Array(width * height + chromaWidth * chromaHeight * 2)
+  return {
+    deviceId: requiredString(value.deviceId, "target.deviceId", stage),
+    daemonHostId: requiredString(value.daemonHostId, "target.daemonHostId", stage),
+    wsUrl: requiredString(value.wsUrl, "target.wsUrl", stage),
+    authToken: typeof value.authToken === "string" ? value.authToken : ""
   };
-  convert({
-    width,
-    height,
-    data: frame.rgba
-  }, i420);
-  return i420;
 }
-var REMOTE_WINDOW_LATENCY_SAMPLE_CAPACITY = 240;
-function pushBounded(samples, value) {
-  if (!Number.isFinite(value) || value < 0) {
-    return;
-  }
-  samples.push(value);
-  if (samples.length > REMOTE_WINDOW_LATENCY_SAMPLE_CAPACITY) {
-    samples.splice(0, samples.length - REMOTE_WINDOW_LATENCY_SAMPLE_CAPACITY);
-  }
+function optionalAppTarget(value, stage) {
+  return value === void 0 ? void 0 : validateAppTarget(value, stage);
 }
-function nearestRankPercentile(samples, percentile) {
-  if (samples.length === 0) {
-    return null;
+function validateAppClientFrame(value) {
+  if (!isRecord2(value) || typeof value.type !== "string" || !isRecord2(value.payload)) {
+    throw new AppProtocolError({ code: "invalid_frame", message: "frame must have a type and payload object", stage: "frame" });
   }
-  const sorted = [...samples].sort((left, right) => left - right);
-  const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil(percentile * sorted.length) - 1));
-  return sorted[index];
-}
-function readStatsNumber(entry, key) {
-  const value = entry[key];
-  return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-function createRemoteWindowLatencyAccumulator() {
-  const captureToEncodeSamples = [];
-  const captureArrivalTimestamps = [];
-  const dispatchTimestamps = [];
-  const inputInjectionSamples = [];
-  let previousOutbound = null;
-  let encodeMsPerFrame = null;
-  let packetSendDelayMs = null;
-  let encodedFps = null;
-  let sentBitrateBps = null;
-  let codecMimeType = null;
-  let networkRttMs = null;
-  let networkJitterMs = null;
-  let packetLossRatio = null;
+  const payload = value.payload;
+  switch (value.type) {
+    case "app-hello":
+      return { type: "app-hello", payload: validateAppHello(payload) };
+    case "app-send-message": {
+      const body = validateMessageBody(payload.body);
+      return {
+        type: "app-send-message",
+        payload: {
+          requestId: requiredString(payload.requestId, "requestId", "send-message"),
+          messageId: requiredString(payload.messageId, "messageId", "send-message"),
+          subject: requiredString(payload.subject, "subject", "send-message"),
+          body,
+          target: optionalAppTarget(payload.target, "send-message")
+        }
+      };
+    }
+    case "app-send-file-start":
+      return {
+        type: "app-send-file-start",
+        payload: {
+          requestId: requiredString(payload.requestId, "requestId", "file-start"),
+          messageId: requiredString(payload.messageId, "messageId", "file-start"),
+          subject: stringValue(payload.subject, "subject", "file-start"),
+          file: validateAppFileMetadata(payload.file, "file-start"),
+          target: optionalAppTarget(payload.target, "file-start")
+        }
+      };
+    case "app-send-file-chunk":
+      return {
+        type: "app-send-file-chunk",
+        payload: {
+          requestId: requiredString(payload.requestId, "requestId", "file-chunk"),
+          messageId: requiredString(payload.messageId, "messageId", "file-chunk"),
+          transferId: requiredString(payload.transferId, "transferId", "file-chunk"),
+          offset: validateOffset(payload.offset, "file-chunk"),
+          chunkIndex: validateChunkIndex(payload.chunkIndex, "file-chunk"),
+          dataBase64: requiredString(payload.dataBase64, "dataBase64", "file-chunk")
+        }
+      };
+    case "app-send-file-commit":
+      return {
+        type: "app-send-file-commit",
+        payload: {
+          requestId: requiredString(payload.requestId, "requestId", "file-commit"),
+          messageId: requiredString(payload.messageId, "messageId", "file-commit"),
+          transferId: requiredString(payload.transferId, "transferId", "file-commit")
+        }
+      };
+    case "app-ack":
+      return {
+        type: "app-ack",
+        payload: {
+          requestId: requiredString(payload.requestId, "requestId", "ack"),
+          messageId: requiredString(payload.messageId, "messageId", "ack"),
+          senderDaemonHostId: optionalString(payload.senderDaemonHostId)
+        }
+      };
+    case "app-consume":
+      return {
+        type: "app-consume",
+        payload: {
+          requestId: requiredString(payload.requestId, "requestId", "consume"),
+          messageId: requiredString(payload.messageId, "messageId", "consume"),
+          senderDaemonHostId: optionalString(payload.senderDaemonHostId)
+        }
+      };
+    case "app-status":
+      return {
+        type: "app-status",
+        payload: {
+          requestId: requiredString(payload.requestId, "requestId", "status"),
+          messageId: requiredString(payload.messageId, "messageId", "status"),
+          senderDaemonHostId: optionalString(payload.senderDaemonHostId),
+          remote: payload.remote === true,
+          target: optionalAppTarget(payload.target, "status")
+        }
+      };
+    case "app-ping": {
+      const sentAt = payload.sentAt;
+      if (typeof sentAt !== "number" || !Number.isFinite(sentAt)) {
+        throw new AppProtocolError({ code: "invalid_frame", message: "sentAt must be a finite number", stage: "ping" });
+      }
+      return {
+        type: "app-ping",
+        payload: {
+          requestId: requiredString(payload.requestId, "requestId", "ping"),
+          sentAt
+        }
+      };
+    }
+    default:
+      throw new AppProtocolError({ code: "invalid_frame", message: `unsupported frame: ${value.type}`, stage: "frame" });
+  }
+}
+function validateAppServerFrame(value) {
+  if (!isRecord2(value) || typeof value.type !== "string" || !isRecord2(value.payload)) {
+    throw new AppProtocolError({
+      code: "invalid_frame",
+      message: "server frame must have a type and payload object",
+      stage: "frame"
+    });
+  }
+  const payload = value.payload;
+  switch (value.type) {
+    case "app-ready": {
+      const requestId = requiredString(payload.requestId, "requestId", "ready");
+      assertAppProtocolVersion(payload.protocolVersion);
+      return {
+        type: "app-ready",
+        payload: {
+          requestId,
+          protocolVersion: APP_PROTOCOL_VERSION,
+          deviceId: requiredString(payload.deviceId, "deviceId", "ready"),
+          daemonHostId: requiredString(payload.daemonHostId, "daemonHostId", "ready"),
+          capabilities: isRecord2(payload.capabilities) ? payload.capabilities : (() => {
+            throw new AppProtocolError({
+              code: "invalid_frame",
+              message: "capabilities must be an object",
+              stage: "ready",
+              requestId
+            });
+          })()
+        }
+      };
+    }
+    case "app-inbound-message":
+      return {
+        type: "app-inbound-message",
+        payload: {
+          messageId: requiredString(payload.messageId, "messageId", "inbound"),
+          senderDeviceId: requiredString(payload.senderDeviceId, "senderDeviceId", "inbound"),
+          senderDaemonHostId: requiredString(payload.senderDaemonHostId, "senderDaemonHostId", "inbound"),
+          receiverDeviceId: requiredString(payload.receiverDeviceId, "receiverDeviceId", "inbound"),
+          receiverDaemonHostId: requiredString(payload.receiverDaemonHostId, "receiverDaemonHostId", "inbound"),
+          subject: stringValue(payload.subject, "subject", "inbound"),
+          body: stringValue(payload.body, "body", "inbound"),
+          state: oneOf(payload.state, APP_RECORD_STATES, "state", "inbound"),
+          receivedAt: requiredString(payload.receivedAt, "receivedAt", "inbound")
+        }
+      };
+    case "app-inbound-file":
+      return {
+        type: "app-inbound-file",
+        payload: {
+          messageId: requiredString(payload.messageId, "messageId", "inbound"),
+          transferId: requiredString(payload.transferId, "transferId", "inbound"),
+          senderDeviceId: requiredString(payload.senderDeviceId, "senderDeviceId", "inbound"),
+          senderDaemonHostId: requiredString(payload.senderDaemonHostId, "senderDaemonHostId", "inbound"),
+          receiverDeviceId: requiredString(payload.receiverDeviceId, "receiverDeviceId", "inbound"),
+          receiverDaemonHostId: requiredString(payload.receiverDaemonHostId, "receiverDaemonHostId", "inbound"),
+          subject: stringValue(payload.subject, "subject", "inbound"),
+          fileName: validateSafeFileName(payload.fileName, "inbound"),
+          totalBytes: requiredInteger(payload.totalBytes, "totalBytes", "inbound", 0),
+          sha256: requiredString(payload.sha256, "sha256", "inbound"),
+          absolutePath: requiredString(payload.absolutePath, "absolutePath", "inbound"),
+          state: oneOf(payload.state, APP_RECORD_STATES, "state", "inbound"),
+          receivedAt: requiredString(payload.receivedAt, "receivedAt", "inbound")
+        }
+      };
+    case "app-send-result": {
+      const requestId = requiredString(payload.requestId, "requestId", "send-result");
+      return {
+        type: "app-send-result",
+        payload: {
+          requestId,
+          messageId: requiredString(payload.messageId, "messageId", "send-result"),
+          transferId: optionalStringValue(payload.transferId),
+          absolutePath: optionalStringValue(payload.absolutePath),
+          status: oneOf(payload.status, APP_SEND_STATUSES, "status", "send-result"),
+          stage: oneOf(payload.stage, APP_SEND_STAGES, "stage", "send-result"),
+          persistedOffset: optionalIntegerValue(payload.persistedOffset, "persistedOffset", "send-result", 0)
+        }
+      };
+    }
+    case "app-status-result": {
+      const requestId = requiredString(payload.requestId, "requestId", "status-result");
+      return {
+        type: "app-status-result",
+        payload: {
+          requestId,
+          messageId: requiredString(payload.messageId, "messageId", "status-result"),
+          found: requiredBoolean(payload.found, "found", "status-result"),
+          kind: payload.kind === void 0 ? void 0 : oneOf(payload.kind, ["inbox", "outbox"], "kind", "status-result"),
+          senderDaemonHostId: optionalStringValue(payload.senderDaemonHostId),
+          targetDaemonHostId: optionalStringValue(payload.targetDaemonHostId),
+          state: payload.state === void 0 ? void 0 : oneOf(payload.state, APP_RECORD_STATES, "state", "status-result"),
+          transferId: optionalStringValue(payload.transferId),
+          absolutePath: optionalStringValue(payload.absolutePath),
+          outboxState: payload.outboxState === void 0 ? void 0 : oneOf(payload.outboxState, ["pending", "sent", "received", "result_unknown", "failed"], "outboxState", "status-result"),
+          ambiguous: payload.ambiguous === void 0 ? void 0 : requiredBoolean(payload.ambiguous, "ambiguous", "status-result")
+        }
+      };
+    }
+    case "app-connection-state": {
+      const requestId = requiredString(payload.requestId, "requestId", "connection-state");
+      return {
+        type: "app-connection-state",
+        payload: {
+          requestId,
+          state: oneOf(
+            payload.state,
+            ["connected", "disconnected", "peer-connected", "peer-disconnected"],
+            "state",
+            "connection-state"
+          ),
+          daemonHostId: optionalStringValue(payload.daemonHostId),
+          code: optionalIntegerValue(payload.code, "code", "connection-state", 1e3),
+          reason: optionalStringValue(payload.reason)
+        }
+      };
+    }
+    case "app-error": {
+      const requestId = optionalStringValue(payload.requestId);
+      return {
+        type: "app-error",
+        payload: {
+          requestId,
+          messageId: optionalStringValue(payload.messageId),
+          transferId: optionalStringValue(payload.transferId),
+          code: oneOf(payload.code, APP_ERROR_CODES, "code", "error"),
+          stage: stringValue(payload.stage, "stage", "error"),
+          message: stringValue(payload.message, "message", "error")
+        }
+      };
+    }
+    case "app-pong": {
+      const requestId = requiredString(payload.requestId, "requestId", "pong");
+      return {
+        type: "app-pong",
+        payload: {
+          requestId,
+          sentAt: requiredFiniteNumber(payload.sentAt, "sentAt", "pong"),
+          receivedAt: requiredFiniteNumber(payload.receivedAt, "receivedAt", "pong")
+        }
+      };
+    }
+    default:
+      throw new AppProtocolError({ code: "invalid_frame", message: `unsupported server frame: ${value.type}`, stage: "frame" });
+  }
+}
+function validateMessageBody(value) {
+  if (typeof value !== "string") {
+    throw new AppProtocolError({ code: "invalid_frame", message: "body must be a string", stage: "validate" });
+  }
+  const bytes = new TextEncoder().encode(value).length;
+  if (bytes > APP_MAX_MESSAGE_BYTES) {
+    throw new AppProtocolError({ code: "message_too_large", message: "message body exceeds 1 MiB", stage: "validate" });
+  }
+  return value;
+}
+function validateAppFileMetadata(value, stage) {
+  if (!isRecord2(value)) {
+    throw new AppProtocolError({ code: "invalid_frame", message: "file metadata must be an object", stage });
+  }
+  const transferId = requiredString(value.transferId, "transferId", stage);
+  const fileName = validateSafeFileName(value.fileName, stage);
+  const totalBytes = requiredInteger(value.totalBytes, "totalBytes", stage, 0);
+  const chunkCount = requiredInteger(value.chunkCount, "chunkCount", stage, 0);
+  const sha256 = requiredString(value.sha256, "sha256", stage);
+  if (totalBytes > APP_MAX_FILE_BYTES) {
+    throw new AppProtocolError({ code: "file_too_large", message: "file exceeds 256 MiB", stage, transferId });
+  }
+  const expectedChunks = computeAppChunkCount(totalBytes);
+  if (chunkCount !== expectedChunks) {
+    throw new AppProtocolError({
+      code: "invalid_frame",
+      message: `chunkCount ${chunkCount} does not match ${expectedChunks} for ${totalBytes} bytes`,
+      stage,
+      transferId
+    });
+  }
+  if (!/^[0-9a-f]{64}$/.test(sha256)) {
+    throw new AppProtocolError({ code: "invalid_frame", message: "sha256 must be a 64 hex digest", stage, transferId });
+  }
+  return { transferId, fileName, totalBytes, chunkCount, sha256 };
+}
+function computeAppChunkCount(totalBytes) {
+  if (totalBytes <= 0) return 0;
+  return Math.ceil(totalBytes / APP_FILE_CHUNK_BYTES);
+}
+function validateSafeFileName(value, stage) {
+  if (typeof value !== "string") {
+    throw new AppProtocolError({ code: "invalid_file_name", message: "fileName must be a string", stage });
+  }
+  if (value.length === 0 || value === "." || value === "..") {
+    throw new AppProtocolError({ code: "invalid_file_name", message: "fileName is not a valid basename", stage });
+  }
+  if (value.includes("/") || value.includes("\\") || value.includes("\0")) {
+    throw new AppProtocolError({ code: "invalid_file_name", message: "fileName must be a single basename", stage });
+  }
+  const bytes = new TextEncoder().encode(value).length;
+  if (bytes > APP_MAX_SAFE_FILE_NAME_BYTES) {
+    throw new AppProtocolError({ code: "invalid_file_name", message: "fileName exceeds 255 UTF-8 bytes", stage });
+  }
+  return value;
+}
+function validateChunkIndex(value, stage) {
+  return requiredInteger(value, "chunkIndex", stage, 0);
+}
+function validateOffset(value, stage) {
+  return requiredInteger(value, "offset", stage, 0);
+}
+function encodeAppPathSegment(value) {
+  if (value.length === 0) {
+    throw new AppProtocolError({ code: "invalid_frame", message: "identity segment is empty", stage: "storage" });
+  }
+  if (new TextEncoder().encode(value).length > APP_MAX_PATH_IDENTITY_BYTES) {
+    throw new AppProtocolError({ code: "invalid_frame", message: "identity segment exceeds 191 UTF-8 bytes", stage: "storage" });
+  }
+  const bytes = new TextEncoder().encode(value);
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  const base64 = globalThis.btoa?.(binary) ?? Buffer.from(bytes).toString("base64");
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function appErrorPayload(options) {
+  return {
+    requestId: options.requestId,
+    messageId: options.messageId,
+    transferId: options.transferId,
+    code: options.code,
+    stage: options.stage,
+    message: options.message
+  };
+}
+
+// src/server/daemon-app-messaging-store.ts
+var import_node_crypto2 = require("node:crypto");
+var import_promises2 = require("node:fs/promises");
+var import_node_path5 = require("node:path");
+var AppStoreError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message);
+    this.name = "AppStoreError";
+    this.code = code;
+    if (options?.cause !== void 0) {
+      Object.defineProperty(this, "cause", { value: options.cause });
+    }
+  }
+};
+function assertSegment(value) {
+  if (value.length === 0 || new TextEncoder().encode(value).length > APP_MAX_PATH_IDENTITY_BYTES) {
+    throw new AppStoreError("storage_error", "identity segment is empty or longer than 191 UTF-8 bytes");
+  }
+  return value;
+}
+function sameStagedFile(record, meta) {
+  return record.kind === "file" && record.file?.transferId === meta.transferId && record.file.fileName === meta.fileName && record.file.totalBytes === meta.totalBytes && record.file.chunkCount === meta.chunkCount && record.file.sha256 === meta.sha256;
+}
+async function fsyncDirectory(directory) {
+  try {
+    const handle = await (0, import_promises2.open)(directory, "r");
+    try {
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+  } catch {
+  }
+}
+async function atomicWriteJson(filePath, value) {
+  const directory = (0, import_node_path5.dirname)(filePath);
+  await (0, import_promises2.mkdir)(directory, { recursive: true });
+  const tmpPath = (0, import_node_path5.join)(directory, `.tmp-${(0, import_node_crypto2.randomUUID)()}.json`);
+  const handle = await (0, import_promises2.open)(tmpPath, "wx");
+  try {
+    await handle.writeFile(JSON.stringify(value), "utf8");
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  await (0, import_promises2.rename)(tmpPath, filePath);
+  await fsyncDirectory(directory);
+}
+async function readJson(filePath) {
+  try {
+    const raw = await (0, import_promises2.readFile)(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch (error) {
+    if (error && typeof error === "object" && error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+var DaemonAppMessagingStore = class {
+  inboxRoot;
+  outboxRoot;
+  maxInboxRecords;
+  maxInboxBytes;
+  queue = Promise.resolve();
+  constructor(options) {
+    this.inboxRoot = (0, import_node_path5.join)(options.appRootDir, "app-inbox");
+    this.outboxRoot = (0, import_node_path5.join)(options.appRootDir, "app-outbox");
+    this.maxInboxRecords = options.maxInboxRecords ?? APP_MAX_INBOX_RECORDS;
+    this.maxInboxBytes = options.maxInboxBytes ?? APP_MAX_INBOX_BYTES;
+  }
+  async initialize() {
+    await (0, import_promises2.mkdir)(this.inboxRoot, { recursive: true });
+    await (0, import_promises2.mkdir)(this.outboxRoot, { recursive: true });
+  }
+  runExclusive(operation) {
+    const next = this.queue.then(operation, operation);
+    this.queue = next.catch(() => void 0);
+    return next;
+  }
+  recordDir(partition) {
+    return (0, import_node_path5.join)(this.inboxRoot, "records", encodeAppPathSegment(assertSegment(partition)));
+  }
+  filesDir(partition, messageId) {
+    return (0, import_node_path5.join)(this.inboxRoot, "files", encodeAppPathSegment(assertSegment(partition)), encodeAppPathSegment(assertSegment(messageId)));
+  }
+  stagingDir(partition) {
+    return (0, import_node_path5.join)(this.inboxRoot, "staging", encodeAppPathSegment(assertSegment(partition)));
+  }
+  outboxDir(partition) {
+    return (0, import_node_path5.join)(this.outboxRoot, "records", encodeAppPathSegment(assertSegment(partition)));
+  }
+  // An encoded identity is the longest path component (at most 255 ASCII bytes
+  // for the 191-byte protocol limit), so every durable file name is a fixed
+  // short name inside a directory owned by that identity. Appending `.json` or
+  // `.part` to the encoded identity would exceed the 255-byte NAME_MAX.
+  inboxRecordPath(senderDaemonHostId, messageId) {
+    return (0, import_node_path5.join)(this.recordDir(senderDaemonHostId), encodeAppPathSegment(assertSegment(messageId)), "record.json");
+  }
+  outboxRecordPath(targetDaemonHostId, messageId) {
+    return (0, import_node_path5.join)(this.outboxDir(targetDaemonHostId), encodeAppPathSegment(assertSegment(messageId)), "record.json");
+  }
+  stagingPartPath(senderDaemonHostId, transferId) {
+    return (0, import_node_path5.join)(this.stagingDir(senderDaemonHostId), encodeAppPathSegment(assertSegment(transferId)), "data.part");
+  }
+  stagingMetaPath(senderDaemonHostId, transferId) {
+    return (0, import_node_path5.join)(this.stagingDir(senderDaemonHostId), encodeAppPathSegment(assertSegment(transferId)), "meta.json");
+  }
+  stagingEntryDir(senderDaemonHostId, transferId) {
+    return (0, import_node_path5.join)(this.stagingDir(senderDaemonHostId), encodeAppPathSegment(assertSegment(transferId)));
+  }
+  async removeStagingEntry(senderDaemonHostId, transferId) {
+    await (0, import_promises2.rm)(this.stagingEntryDir(senderDaemonHostId, transferId), { recursive: true, force: true });
+  }
+  finalFilePath(senderDaemonHostId, messageId, safeFileName) {
+    return (0, import_node_path5.join)(this.filesDir(senderDaemonHostId, messageId), safeFileName);
+  }
+  async writeInboxRecord(record) {
+    await atomicWriteJson(this.inboxRecordPath(record.senderDaemonHostId, record.messageId), record);
+  }
+  async readInboxRecord(senderDaemonHostId, messageId) {
+    return readJson(this.inboxRecordPath(senderDaemonHostId, messageId));
+  }
+  async listInboxRecords() {
+    const records = [];
+    await this.walkJson(this.recordRoot(), (record) => {
+      records.push(record);
+    });
+    return records;
+  }
+  async writeOutboxRecord(record) {
+    await atomicWriteJson(this.outboxRecordPath(record.targetDaemonHostId, record.messageId), record);
+  }
+  async readOutboxRecord(targetDaemonHostId, messageId) {
+    return readJson(this.outboxRecordPath(targetDaemonHostId, messageId));
+  }
+  async listOutboxRecords() {
+    const records = [];
+    await this.walkJson((0, import_node_path5.join)(this.outboxRoot, "records"), (record) => {
+      records.push(record);
+    });
+    return records;
+  }
+  async listStagingMetadata() {
+    const metadata = [];
+    const stagingRoot = (0, import_node_path5.join)(this.inboxRoot, "staging");
+    await this.walkJson(stagingRoot, (record) => {
+      if (record && record.schemaVersion === 1) {
+        metadata.push(record);
+      }
+    });
+    return metadata;
+  }
+  async writeStagingMetadata(metadata) {
+    await atomicWriteJson(this.stagingMetaPath(metadata.senderDaemonHostId, metadata.transferId), metadata);
+  }
+  async readStagingMetadata(senderDaemonHostId, transferId) {
+    return readJson(this.stagingMetaPath(senderDaemonHostId, transferId));
+  }
+  async hasStagingKey(senderDaemonHostId, messageId) {
+    const all = await this.listStagingMetadata();
+    return all.some(
+      (meta) => meta.senderDaemonHostId === senderDaemonHostId && meta.messageId === messageId
+    );
+  }
+  async findStagingKey(senderDaemonHostId, messageId) {
+    const all = await this.listStagingMetadata();
+    return all.find(
+      (meta) => meta.senderDaemonHostId === senderDaemonHostId && meta.messageId === messageId
+    ) ?? null;
+  }
+  async openStagingPart(metadata) {
+    await (0, import_promises2.mkdir)(this.stagingDir(metadata.senderDaemonHostId), { recursive: true });
+    await (0, import_promises2.mkdir)(this.filesDir(metadata.senderDaemonHostId, metadata.messageId), { recursive: true });
+    await this.writeStagingMetadata({ ...metadata, phase: "open" });
+    const partPath = this.stagingPartPath(metadata.senderDaemonHostId, metadata.transferId);
+    const handle = await (0, import_promises2.open)(partPath, "w");
+    await handle.sync();
+    await handle.close();
+    await fsyncDirectory((0, import_node_path5.dirname)(partPath));
+  }
+  async appendPart(senderDaemonHostId, transferId, expectedOffset, data) {
+    const partPath = this.stagingPartPath(senderDaemonHostId, transferId);
+    const handle = await (0, import_promises2.open)(partPath, "r+");
+    try {
+      const currentSize = (await handle.stat()).size;
+      if (currentSize !== expectedOffset) {
+        throw new AppStoreError("chunk_conflict", `offset ${expectedOffset} does not match persisted part size ${currentSize}`);
+      }
+      await handle.write(data, 0, data.length, expectedOffset);
+      await handle.sync();
+      return expectedOffset + data.length;
+    } finally {
+      await handle.close();
+    }
+  }
+  async statPart(senderDaemonHostId, transferId) {
+    try {
+      return (await (0, import_promises2.stat)(this.stagingPartPath(senderDaemonHostId, transferId))).size;
+    } catch (error) {
+      if (error && typeof error === "object" && error.code === "ENOENT") {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async truncatePart(senderDaemonHostId, transferId, size) {
+    const handle = await (0, import_promises2.open)(this.stagingPartPath(senderDaemonHostId, transferId), "r+");
+    try {
+      await handle.truncate(size);
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+  }
+  async readPartRange(senderDaemonHostId, transferId, offset, length) {
+    const handle = await (0, import_promises2.open)(this.stagingPartPath(senderDaemonHostId, transferId), "r");
+    try {
+      const buffer = Buffer.alloc(length);
+      const { bytesRead } = await handle.read(buffer, 0, length, offset);
+      return bytesRead === length ? buffer : buffer.subarray(0, bytesRead);
+    } finally {
+      await handle.close();
+    }
+  }
+  async removePart(senderDaemonHostId, transferId) {
+    await (0, import_promises2.rm)(this.stagingPartPath(senderDaemonHostId, transferId), { force: true });
+  }
+  async renamePartToFinal(senderDaemonHostId, messageId, safeFileName, transferId) {
+    const target = this.finalFilePath(senderDaemonHostId, messageId, safeFileName);
+    await (0, import_promises2.mkdir)((0, import_node_path5.dirname)(target), { recursive: true });
+    await (0, import_promises2.rename)(this.stagingPartPath(senderDaemonHostId, transferId), target);
+    await fsyncDirectory((0, import_node_path5.dirname)(target));
+    return target;
+  }
+  async computeFileSha256(filePath) {
+    const hash2 = (0, import_node_crypto2.createHash)("sha256");
+    const handle = await (0, import_promises2.open)(filePath, "r");
+    try {
+      const buffer = Buffer.alloc(64 * 1024);
+      let position = 0;
+      while (true) {
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, position);
+        if (bytesRead <= 0) break;
+        hash2.update(buffer.subarray(0, bytesRead));
+        position += bytesRead;
+      }
+    } finally {
+      await handle.close();
+    }
+    return hash2.digest("hex");
+  }
+  async computeInboxUsage(excludeStaging) {
+    let records = 0;
+    let bytes = 0;
+    await this.walkJson(this.recordRoot(), (record) => {
+      records += 1;
+      const inbox = record;
+      if (inbox.kind === "message" && typeof inbox.body === "string") {
+        bytes += Buffer.byteLength(inbox.body, "utf8");
+      }
+    });
+    await this.walkFiles((0, import_node_path5.join)(this.inboxRoot, "files"), (_filePath, size) => {
+      bytes += size;
+    });
+    const staging = await this.listStagingMetadata();
+    for (const meta of staging) {
+      if (excludeStaging && meta.senderDaemonHostId === excludeStaging.senderDaemonHostId && meta.transferId === excludeStaging.transferId) {
+        continue;
+      }
+      records += 1;
+      bytes += meta.reservedBytes;
+    }
+    return { records, bytes };
+  }
+  async admitInboxRecord(record, reservedBytes, options) {
+    const existing = await this.readInboxRecord(record.senderDaemonHostId, record.messageId);
+    const isNew = existing === null;
+    if (isNew) {
+      const usage = await this.computeInboxUsage(options?.staging);
+      if (usage.records + 1 > this.maxInboxRecords) {
+        throw new AppStoreError("inbox_full", "durable inbox record limit reached");
+      }
+      if (usage.bytes + reservedBytes > this.maxInboxBytes) {
+        throw new AppStoreError("inbox_full", "durable inbox byte limit reached");
+      }
+    }
+    await this.writeInboxRecord(record);
+    return isNew;
+  }
+  async removeInboxRecord(record) {
+    await (0, import_promises2.rm)(this.inboxRecordPath(record.senderDaemonHostId, record.messageId), { force: true });
+    if (record.file) {
+      await (0, import_promises2.rm)((0, import_node_path5.dirname)(record.file.absolutePath), { recursive: true, force: true });
+    }
+  }
+  async cleanupRetention(now, retentionMs) {
+    const records = await this.listInboxRecords();
+    for (const record of records) {
+      if (record.state !== "delivered" && record.state !== "consumed") continue;
+      const settledAt = record.consumedAt ?? record.deliveredAt ?? record.receivedAt;
+      const settled = Date.parse(settledAt);
+      if (!Number.isFinite(settled) || now - settled < retentionMs) continue;
+      await this.removeInboxRecord(record);
+    }
+  }
+  async recoverStaging() {
+    const recovered = [];
+    for (const meta of await this.listStagingMetadata()) {
+      const partSize = await this.statPart(meta.senderDaemonHostId, meta.transferId);
+      if (meta.phase === "verified") {
+        const absolutePath = meta.absolutePath ?? this.finalFilePath(meta.senderDaemonHostId, meta.messageId, meta.fileName);
+        if (partSize === null) {
+          const finalSize = await (0, import_promises2.stat)(absolutePath).then((s) => s.size).catch(() => -1);
+          if (finalSize !== meta.totalBytes) {
+            throw new AppStoreError("storage_inconsistent", `verified transfer ${meta.transferId} has neither a complete part nor a final file`);
+          }
+        } else if (partSize !== meta.totalBytes) {
+          throw new AppStoreError("storage_inconsistent", `verified transfer ${meta.transferId} part size ${partSize} != ${meta.totalBytes}`);
+        } else {
+          await this.renamePartToFinal(meta.senderDaemonHostId, meta.messageId, meta.fileName, meta.transferId);
+        }
+        const record = await this.finishRecoveredFile(meta, absolutePath);
+        if (record) recovered.push(record);
+        continue;
+      }
+      const openPartSize = partSize ?? 0;
+      if (openPartSize < meta.persistedOffset) {
+        throw new AppStoreError("storage_inconsistent", `open transfer ${meta.transferId} part ${openPartSize} < persisted offset ${meta.persistedOffset}`);
+      }
+      if (openPartSize > meta.persistedOffset) {
+        await this.truncatePart(meta.senderDaemonHostId, meta.transferId, meta.persistedOffset);
+      }
+    }
+    return recovered;
+  }
+  async finishRecoveredFile(meta, absolutePath) {
+    const existing = await this.readInboxRecord(meta.senderDaemonHostId, meta.messageId);
+    if (existing) {
+      if (!sameStagedFile(existing, meta)) {
+        throw new AppStoreError(
+          "storage_inconsistent",
+          `inbox record ${meta.messageId} does not match verified transfer ${meta.transferId}`
+        );
+      }
+      await this.removeStagingEntry(meta.senderDaemonHostId, meta.transferId);
+      return null;
+    }
+    const receivedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const record = {
+      schemaVersion: 1,
+      senderDaemonHostId: meta.senderDaemonHostId,
+      senderDeviceId: meta.senderDeviceId,
+      receiverDeviceId: meta.receiverDeviceId,
+      receiverDaemonHostId: meta.receiverDaemonHostId,
+      messageId: meta.messageId,
+      kind: "file",
+      subject: meta.subject,
+      file: {
+        transferId: meta.transferId,
+        fileName: meta.fileName,
+        totalBytes: meta.totalBytes,
+        chunkCount: meta.chunkCount,
+        sha256: meta.sha256,
+        absolutePath
+      },
+      state: "received",
+      receivedAt
+    };
+    await this.writeInboxRecord(record);
+    await this.removeStagingEntry(meta.senderDaemonHostId, meta.transferId);
+    return record;
+  }
+  recordRoot() {
+    return (0, import_node_path5.join)(this.inboxRoot, "records");
+  }
+  async walkJson(root, visit) {
+    let entries = [];
+    try {
+      entries = await (0, import_promises2.readdir)(root, { withFileTypes: true });
+    } catch (error) {
+      if (error && typeof error === "object" && error.code === "ENOENT") {
+        return;
+      }
+      throw error;
+    }
+    for (const entry of entries) {
+      const next = (0, import_node_path5.join)(root, entry.name);
+      if (entry.isDirectory()) {
+        await this.walkJson(next, visit);
+      } else if (entry.isFile() && (entry.name === "record.json" || entry.name === "meta.json")) {
+        const value = await readJson(next);
+        if (value !== null) await visit(value);
+      }
+    }
+  }
+  async walkFiles(root, visit) {
+    let entries = [];
+    try {
+      entries = await (0, import_promises2.readdir)(root, { withFileTypes: true });
+    } catch (error) {
+      if (error && typeof error === "object" && error.code === "ENOENT") {
+        return;
+      }
+      throw error;
+    }
+    for (const entry of entries) {
+      const next = (0, import_node_path5.join)(root, entry.name);
+      if (entry.isDirectory()) {
+        await this.walkFiles(next, visit);
+      } else if (entry.isFile()) {
+        const size = (await (0, import_promises2.stat)(next)).size;
+        await visit(next, size);
+      }
+    }
+  }
+};
+
+// src/server/daemon-app-messaging-runtime.ts
+var PeerLinkError = class extends Error {
+  code;
+  afterSend;
+  constructor(code, message, afterSend) {
+    super(message);
+    this.name = "PeerLinkError";
+    this.code = code;
+    this.afterSend = afterSend;
+  }
+};
+function nowIso(now) {
+  return new Date(now()).toISOString();
+}
+function decodeStrictBase64(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new AppProtocolError({ code: "invalid_chunk", message: "chunk data is empty", stage: "file-chunk" });
+  }
+  if (!/^[A-Za-z0-9+/]*={0,2}$/.test(value) || value.length % 4 !== 0) {
+    throw new AppProtocolError({ code: "invalid_chunk", message: "chunk data is not strict base64", stage: "file-chunk" });
+  }
+  const buffer = Buffer.from(value, "base64");
+  if (buffer.toString("base64") !== value) {
+    throw new AppProtocolError({ code: "invalid_chunk", message: "chunk data decoded lossily", stage: "file-chunk" });
+  }
+  return buffer;
+}
+function sameMessageContent(record, payload) {
+  return record.kind === "message" && record.subject === payload.subject && record.body === payload.body;
+}
+function sameFileContent(record, payload) {
+  return record.kind === "file" && record.subject === payload.subject && record.file?.transferId === payload.file.transferId && record.file.fileName === payload.file.fileName && record.file.totalBytes === payload.file.totalBytes && record.file.chunkCount === payload.file.chunkCount && record.file.sha256 === payload.file.sha256;
+}
+function sameOutboxMessage(record, payload) {
+  return record.kind === "message" && record.subject === payload.subject && record.body === payload.body;
+}
+function sameOutboxFile(record, payload) {
+  return record.kind === "file" && record.subject === payload.subject && record.file?.transferId === payload.file.transferId && record.file.fileName === payload.file.fileName && record.file.totalBytes === payload.file.totalBytes && record.file.chunkCount === payload.file.chunkCount && record.file.sha256 === payload.file.sha256;
+}
+function inboundMessageFrame(record) {
+  const payload = {
+    messageId: record.messageId,
+    senderDeviceId: record.senderDeviceId,
+    senderDaemonHostId: record.senderDaemonHostId,
+    receiverDeviceId: record.receiverDeviceId,
+    receiverDaemonHostId: record.receiverDaemonHostId,
+    subject: record.subject,
+    body: record.body ?? "",
+    state: record.state,
+    receivedAt: record.receivedAt
+  };
+  return { type: "app-inbound-message", payload };
+}
+function inboundFileFrame(record) {
+  if (!record.file) return null;
+  const payload = {
+    messageId: record.messageId,
+    transferId: record.file.transferId,
+    senderDeviceId: record.senderDeviceId,
+    senderDaemonHostId: record.senderDaemonHostId,
+    receiverDeviceId: record.receiverDeviceId,
+    receiverDaemonHostId: record.receiverDaemonHostId,
+    subject: record.subject,
+    fileName: record.file.fileName,
+    totalBytes: record.file.totalBytes,
+    sha256: record.file.sha256,
+    absolutePath: record.file.absolutePath,
+    state: record.state,
+    receivedAt: record.receivedAt
+  };
+  return { type: "app-inbound-file", payload };
+}
+function recordStatusPayload(record, requestId) {
+  return {
+    requestId,
+    messageId: record.messageId,
+    found: true,
+    kind: "inbox",
+    senderDaemonHostId: record.senderDaemonHostId,
+    state: record.state,
+    transferId: record.file?.transferId,
+    absolutePath: record.file?.absolutePath
+  };
+}
+function outboxStatusPayload(record, requestId) {
+  return {
+    requestId,
+    messageId: record.messageId,
+    found: true,
+    kind: "outbox",
+    targetDaemonHostId: record.targetDaemonHostId,
+    transferId: record.file?.transferId,
+    state: record.state === "received" ? "received" : "rejected",
+    outboxState: record.state
+  };
+}
+function frameRequestId(frame) {
+  return "requestId" in frame.payload && typeof frame.payload.requestId === "string" ? frame.payload.requestId : void 0;
+}
+function createDaemonAppMessagingRuntime(options) {
+  const now = options.now ?? (() => Date.now());
+  const retentionMs = options.retentionMs ?? APP_ACKED_RETENTION_MS;
+  const peerRequestTimeoutMs = options.peerRequestTimeoutMs ?? 15e3;
+  const store = new DaemonAppMessagingStore({
+    appRootDir: options.appRootDir,
+    maxInboxRecords: options.maxInboxRecords ?? APP_MAX_INBOX_RECORDS,
+    maxInboxBytes: options.maxInboxBytes ?? APP_MAX_INBOX_BYTES
+  });
+  const subscribers = /* @__PURE__ */ new Map();
+  const peerLinks = /* @__PURE__ */ new Map();
+  const activeFileSends = /* @__PURE__ */ new Map();
+  let initialized = false;
+  let initializationError = null;
+  let retentionTimer = null;
+  const createSocket = options.createWebSocket ?? ((url, authToken) => new wrapper_default(url, {
+    headers: authToken ? { Authorization: `Bearer ${authToken}` } : {}
+  }));
+  function sendError(link, error, requestId, messageId, transferId) {
+    const code = error instanceof AppProtocolError || error instanceof PeerLinkError ? error.code : error instanceof AppStoreError ? error.code === "storage_inconsistent" ? "storage_error" : error.code : "internal_error";
+    const stage = error instanceof AppProtocolError ? error.stage : "execute";
+    const message = error instanceof Error ? error.message : String(error);
+    link.send({
+      type: "app-error",
+      payload: appErrorPayload({
+        code,
+        stage,
+        message,
+        requestId,
+        messageId,
+        transferId
+      })
+    });
+  }
+  function notifySubscribers(frame) {
+    for (const [id, subscriber] of [...subscribers]) {
+      if (!subscriber.send(frame)) {
+        subscribers.delete(id);
+        subscriber.close("slow_consumer", 4008);
+      }
+    }
+  }
+  function fileSendKey(linkId, transferId) {
+    return `${linkId}\0${transferId}`;
+  }
+  function reserveFileSend(link, file, messageId, target) {
+    const key = fileSendKey(link.id, file.transferId);
+    const current = activeFileSends.get(key);
+    if (current) {
+      if (current.messageId !== messageId || current.target.daemonHostId !== target.daemonHostId) {
+        throw new AppProtocolError({
+          code: "transfer_conflict",
+          message: "transferId is already bound to another message or target on this connection",
+          stage: "file-start",
+          messageId,
+          transferId: file.transferId
+        });
+      }
+      current.peer = void 0;
+      current.revision += 1;
+      return { active: current, token: current.revision };
+    }
+    const reserved = { linkId: link.id, transferId: file.transferId, messageId, target, revision: 1 };
+    activeFileSends.set(key, reserved);
+    return { active: reserved, token: 1 };
+  }
+  function bindFileSendPeer(link, reservation, peer) {
+    const key = fileSendKey(link.id, reservation.active.transferId);
+    const current = activeFileSends.get(key);
+    if (current === reservation.active && current.revision === reservation.token) {
+      current.peer = peer;
+    }
+  }
+  function clearFileSend(link, transferId, active, token) {
+    const key = fileSendKey(link.id, transferId);
+    const current = activeFileSends.get(key);
+    if (current === active && current.revision === token) activeFileSends.delete(key);
+  }
+  function resolveActiveFileSend(link, messageId, transferId, stage) {
+    const active = activeFileSends.get(fileSendKey(link.id, transferId));
+    if (!active) {
+      throw new AppProtocolError({
+        code: "invalid_state",
+        message: "file transfer is not active; restart with file-start",
+        stage,
+        transferId
+      });
+    }
+    if (active.messageId !== messageId) {
+      throw new AppProtocolError({
+        code: "transfer_conflict",
+        message: "transferId is bound to another messageId on this connection",
+        stage,
+        messageId,
+        transferId
+      });
+    }
+    return active;
+  }
+  function publishRecord(record) {
+    const frame = record.kind === "file" ? inboundFileFrame(record) : inboundMessageFrame(record);
+    if (frame) notifySubscribers(frame);
+  }
+  function notifyPeerState(state, daemonHostId) {
+    notifySubscribers({
+      type: "app-connection-state",
+      payload: {
+        requestId: `event-${(0, import_node_crypto3.randomUUID)()}`,
+        state,
+        daemonHostId
+      }
+    });
+  }
+  async function closePeerLink(peer, reason) {
+    if (peer.closed) return;
+    peer.closed = true;
+    peerLinks.delete(peer.key);
+    for (const pending of peer.pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(new PeerLinkError(pending.settlement.code, reason, pending.settlement.afterSend));
+    }
+    peer.pending.clear();
+    try {
+      peer.ws.close(1e3, reason);
+    } catch {
+    }
+    notifyPeerState("peer-disconnected", peer.target.daemonHostId);
+  }
+  async function connectPeer(target) {
+    const key = `${target.daemonHostId}\0${target.wsUrl}`;
+    const existing = peerLinks.get(key);
+    if (existing && !existing.closed && existing.ws.readyState === wrapper_default.OPEN && existing.ready) {
+      if (await probePeerLink(existing)) {
+        return existing;
+      }
+      await closePeerLink(existing, "peer liveness probe failed");
+    }
+    const ws = createSocket(target.wsUrl, target.authToken);
+    const peer = {
+      key,
+      target,
+      ws,
+      ready: false,
+      closed: false,
+      pending: /* @__PURE__ */ new Map()
+    };
+    peerLinks.set(key, peer);
+    ws.on("message", (raw) => {
+      try {
+        const parsed = JSON.parse(typeof raw === "string" ? raw : Buffer.from(raw).toString("utf8"));
+        const frame = validateAppServerFrame(parsed);
+        handlePeerFrame(peer, frame);
+      } catch (error) {
+        const requestId = resolvePeerRequestIdFromRaw(raw);
+        for (const [id, pending] of [...peer.pending]) {
+          if (requestId === void 0 || id === requestId) {
+            clearTimeout(pending.timer);
+            peer.pending.delete(id);
+            pending.reject(new PeerLinkError(
+              "invalid_frame",
+              `peer returned an invalid frame: ${error instanceof Error ? error.message : String(error)}`,
+              false
+            ));
+          }
+        }
+      }
+    });
+    ws.on("close", () => {
+      void closePeerLink(peer, "peer closed");
+    });
+    ws.on("error", (error) => {
+      void closePeerLink(peer, error.message);
+    });
+    const helloRequestId = `hello-${(0, import_node_crypto3.randomUUID)()}`;
+    const ready = await new Promise((resolve4, reject) => {
+      const timer = setTimeout(() => {
+        peer.pending.delete(helloRequestId);
+        reject(new PeerLinkError("unreachable", "peer handshake timed out", false));
+      }, peerRequestTimeoutMs);
+      peer.pending.set(helloRequestId, {
+        resolve: resolve4,
+        reject,
+        timer,
+        settlement: { code: "unreachable", afterSend: false }
+      });
+      ws.once("open", () => {
+        ws.send(JSON.stringify({
+          type: "app-hello",
+          payload: {
+            protocolVersion: APP_PROTOCOL_VERSION,
+            requestId: helloRequestId,
+            role: "peer",
+            clientInstanceId: `daemon-${(0, import_node_crypto3.randomUUID)()}`,
+            deviceId: options.deviceId,
+            daemonHostId: options.daemonHostId,
+            capabilities: {}
+          }
+        }));
+      });
+      ws.once("unexpected-response", (_request, response) => {
+        clearTimeout(timer);
+        peer.pending.delete(helloRequestId);
+        reject(new PeerLinkError(
+          response.statusCode === 401 ? "unauthorized" : "unreachable",
+          `peer upgrade rejected with HTTP ${response.statusCode}`,
+          false
+        ));
+      });
+      ws.once("error", (error) => {
+        clearTimeout(timer);
+        peer.pending.delete(helloRequestId);
+        reject(new PeerLinkError("unreachable", error.message, false));
+      });
+    }).catch(async (error) => {
+      await closePeerLink(peer, error instanceof Error ? error.message : "peer handshake failed");
+      throw error;
+    });
+    if (ready.type !== "app-ready" || ready.payload.protocolVersion !== APP_PROTOCOL_VERSION || ready.payload.daemonHostId !== target.daemonHostId || ready.payload.deviceId !== target.deviceId) {
+      await closePeerLink(peer, "peer identity or version mismatch");
+      throw new PeerLinkError("unreachable", "peer returned a different daemon identity or protocol version", false);
+    }
+    notifyPeerState("peer-connected", target.daemonHostId);
+    return peer;
+  }
+  function resolvePeerRequestIdFromRaw(raw) {
+    try {
+      const parsed = JSON.parse(typeof raw === "string" ? raw : Buffer.from(raw).toString("utf8"));
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        const payload = parsed.payload;
+        if (payload && typeof payload === "object") {
+          return payload.requestId;
+        }
+      }
+      return void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  function handlePeerFrame(peer, frame) {
+    const requestId = "payload" in frame && frame.payload && typeof frame.payload === "object" ? frame.payload.requestId : void 0;
+    if (frame.type === "app-ready" && typeof requestId === "string") {
+      const pending2 = peer.pending.get(requestId);
+      if (pending2) {
+        clearTimeout(pending2.timer);
+        peer.pending.delete(requestId);
+        peer.ready = true;
+        pending2.resolve(frame);
+      }
+      return;
+    }
+    if (typeof requestId !== "string") return;
+    const pending = peer.pending.get(requestId);
+    if (!pending) return;
+    clearTimeout(pending.timer);
+    peer.pending.delete(requestId);
+    pending.resolve(frame);
+  }
+  async function probePeerLink(peer) {
+    if (peer.closed || peer.ws.readyState !== wrapper_default.OPEN || !peer.ready) return false;
+    const requestId = `probe-${(0, import_node_crypto3.randomUUID)()}`;
+    try {
+      await new Promise((resolve4, reject) => {
+        const timer = setTimeout(() => {
+          peer.pending.delete(requestId);
+          reject(new PeerLinkError("unreachable", "peer liveness probe timed out", false));
+        }, peerRequestTimeoutMs);
+        const pending = {
+          resolve: (frame) => {
+            if (frame.type === "app-pong" && frame.payload.requestId === requestId) {
+              resolve4();
+              return;
+            }
+            reject(new PeerLinkError("unreachable", "peer liveness probe returned an unexpected frame", false));
+          },
+          reject,
+          timer,
+          settlement: { code: "unreachable", afterSend: false }
+        };
+        peer.pending.set(requestId, pending);
+        try {
+          peer.ws.send(JSON.stringify({
+            type: "app-ping",
+            payload: { requestId, sentAt: now() }
+          }));
+        } catch (error) {
+          clearTimeout(timer);
+          peer.pending.delete(requestId);
+          reject(new PeerLinkError("unreachable", error instanceof Error ? error.message : "peer liveness probe send failed", false));
+        }
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async function peerRequest(peer, frame) {
+    if (peer.closed || peer.ws.readyState !== wrapper_default.OPEN) {
+      throw new PeerLinkError("unreachable", "peer transport is closed", false);
+    }
+    const requestId = frameRequestId(frame);
+    if (!requestId) {
+      throw new AppProtocolError({ code: "invalid_frame", message: "requestId is required", stage: "peer" });
+    }
+    return new Promise((resolve4, reject) => {
+      const timer = setTimeout(() => {
+        peer.pending.delete(requestId);
+        reject(new PeerLinkError("result_unknown", "peer receipt timed out", true));
+      }, peerRequestTimeoutMs);
+      peer.pending.set(requestId, {
+        resolve: resolve4,
+        reject,
+        timer,
+        settlement: { code: "result_unknown", afterSend: true }
+      });
+      try {
+        peer.ws.send(JSON.stringify(frame));
+      } catch (error) {
+        clearTimeout(timer);
+        peer.pending.delete(requestId);
+        reject(new PeerLinkError("result_unknown", error instanceof Error ? error.message : "peer send failed", true));
+      }
+    });
+  }
+  function peerResultFrame(requestId, messageId, status, stage, extra) {
+    return {
+      type: "app-send-result",
+      payload: {
+        requestId,
+        messageId,
+        ...extra?.transferId ? { transferId: extra.transferId } : {},
+        status,
+        stage,
+        ...extra?.persistedOffset !== void 0 ? { persistedOffset: extra.persistedOffset } : {}
+      }
+    };
+  }
+  async function prepareMessageOutbox(payload) {
+    const target = validateAppTarget(payload.target, "send-message");
+    const record = {
+      schemaVersion: 1,
+      targetDeviceId: target.deviceId,
+      targetDaemonHostId: target.daemonHostId,
+      messageId: payload.messageId,
+      kind: "message",
+      subject: payload.subject,
+      body: payload.body,
+      state: "pending",
+      updatedAt: nowIso(now)
+    };
+    await store.runExclusive(async () => {
+      const existing = await store.readOutboxRecord(target.daemonHostId, payload.messageId);
+      if (existing && existing.kind !== "message") {
+        throw new AppProtocolError({ code: "message_id_conflict", message: "messageId collision", stage: "outbox", messageId: payload.messageId });
+      }
+      if (existing && !sameOutboxMessage(existing, payload)) {
+        throw new AppProtocolError({ code: "message_id_conflict", message: "messageId content conflict", stage: "outbox", messageId: payload.messageId });
+      }
+      if (existing?.state === "received") return;
+      await store.writeOutboxRecord(record);
+    });
+    return store.readOutboxRecord(target.daemonHostId, payload.messageId);
+  }
+  async function prepareFileOutbox(payload) {
+    const target = validateAppTarget(payload.target, "file-start");
+    const record = {
+      schemaVersion: 1,
+      targetDeviceId: target.deviceId,
+      targetDaemonHostId: target.daemonHostId,
+      messageId: payload.messageId,
+      kind: "file",
+      subject: payload.subject,
+      file: payload.file,
+      state: "pending",
+      updatedAt: nowIso(now)
+    };
+    await store.runExclusive(async () => {
+      const existing = await store.readOutboxRecord(target.daemonHostId, payload.messageId);
+      if (existing && existing.kind !== "file") {
+        throw new AppProtocolError({ code: "message_id_conflict", message: "messageId collision", stage: "outbox", messageId: payload.messageId });
+      }
+      if (existing && !sameOutboxFile(existing, payload)) {
+        throw new AppProtocolError({ code: "message_id_conflict", message: "messageId content conflict", stage: "outbox", messageId: payload.messageId });
+      }
+      if (existing?.state === "received") return;
+      await store.writeOutboxRecord(record);
+    });
+    return store.readOutboxRecord(target.daemonHostId, payload.messageId);
+  }
+  async function updateOutbox(targetDaemonHostId, messageId, state, lastError) {
+    await store.runExclusive(async () => {
+      const existing = await store.readOutboxRecord(targetDaemonHostId, messageId);
+      if (!existing) return;
+      await store.writeOutboxRecord({
+        ...existing,
+        state,
+        ...lastError ? { lastError } : { lastError: void 0 },
+        updatedAt: nowIso(now)
+      });
+    });
+  }
+  async function sendMessageFromLocal(link, payload) {
+    const target = validateAppTarget(payload.target, "send-message");
+    const body = validateMessageBody(payload.body);
+    await prepareMessageOutbox({ ...payload, target, body });
+    const outbox = await store.readOutboxRecord(target.daemonHostId, payload.messageId);
+    if (outbox?.state === "received") {
+      link.send(peerResultFrame(payload.requestId, payload.messageId, "received", "received"));
+      return;
+    }
+    try {
+      if (target.daemonHostId === options.daemonHostId) {
+        const result = await receiveMessage(
+          { deviceId: options.deviceId, daemonHostId: options.daemonHostId },
+          { ...payload, body }
+        );
+        await updateOutbox(target.daemonHostId, payload.messageId, result === "received" || result === "delivered" || result === "consumed" ? "received" : "failed");
+        link.send(peerResultFrame(payload.requestId, payload.messageId, result === "rejected" ? "rejected" : "received", "received"));
+        return;
+      }
+      const peer = await connectPeer(target);
+      const response = await peerRequest(peer, {
+        type: "app-send-message",
+        payload: {
+          requestId: payload.requestId,
+          messageId: payload.messageId,
+          subject: payload.subject,
+          body
+        }
+      });
+      if (response.type === "app-error") {
+        await updateOutbox(target.daemonHostId, payload.messageId, "failed", response.payload.code);
+        link.send(response);
+        return;
+      }
+      if (response.type !== "app-send-result") {
+        await updateOutbox(target.daemonHostId, payload.messageId, "result_unknown", "unexpected peer response");
+        link.send(peerResultFrame(payload.requestId, payload.messageId, "resultUnknown", "result_unknown"));
+        return;
+      }
+      const state = response.payload.status === "received" || response.payload.status === "delivered" || response.payload.status === "consumed" ? "received" : response.payload.status === "rejected" ? "failed" : "result_unknown";
+      await updateOutbox(target.daemonHostId, payload.messageId, state);
+      link.send({ ...response, payload: { ...response.payload, requestId: payload.requestId } });
+    } catch (error) {
+      if (error instanceof PeerLinkError) {
+        const state = error.afterSend ? "result_unknown" : "failed";
+        await updateOutbox(target.daemonHostId, payload.messageId, state, error.code);
+        if (error.code === "result_unknown") {
+          link.send(peerResultFrame(payload.requestId, payload.messageId, "resultUnknown", "result_unknown"));
+        } else {
+          sendError(link, error, payload.requestId, payload.messageId);
+        }
+        return;
+      }
+      await updateOutbox(target.daemonHostId, payload.messageId, "failed", error instanceof Error ? error.message : "send failed");
+      sendError(link, error, payload.requestId, payload.messageId);
+    }
+  }
+  async function sendFileStartFromLocal(link, payload) {
+    const target = validateAppTarget(payload.target, "file-start");
+    const file = validateAppFileMetadata(payload.file, "file-start");
+    await prepareFileOutbox({ ...payload, target, file });
+    const outbox = await store.readOutboxRecord(target.daemonHostId, payload.messageId);
+    if (outbox?.state === "received") {
+      link.send(peerResultFrame(payload.requestId, payload.messageId, "received", "received", { transferId: file.transferId }));
+      return;
+    }
+    let reservation = null;
+    try {
+      reservation = await store.runExclusive(async () => {
+        return reserveFileSend(link, file, payload.messageId, target);
+      });
+      if (target.daemonHostId === options.daemonHostId) {
+        const result = await receiveFileStart(
+          { deviceId: options.deviceId, daemonHostId: options.daemonHostId },
+          { ...payload, file }
+        );
+        if (result.type !== "app-send-result" || result.payload.status !== "receiving") {
+          clearFileSend(link, file.transferId, reservation.active, reservation.token);
+        }
+        link.send(result);
+        return;
+      }
+      const peer = await connectPeer(target);
+      bindFileSendPeer(link, reservation, peer);
+      const response = await peerRequest(peer, {
+        type: "app-send-file-start",
+        payload: {
+          requestId: payload.requestId,
+          messageId: payload.messageId,
+          subject: payload.subject,
+          file
+        }
+      });
+      if (response.type === "app-error") {
+        clearFileSend(link, file.transferId, reservation.active, reservation.token);
+        await updateOutbox(target.daemonHostId, payload.messageId, "failed", response.payload.code);
+      }
+      link.send(response);
+    } catch (error) {
+      if (reservation) clearFileSend(link, file.transferId, reservation.active, reservation.token);
+      if (error instanceof PeerLinkError) {
+        const state = error.afterSend ? "result_unknown" : "failed";
+        await updateOutbox(target.daemonHostId, payload.messageId, state, error.code);
+        if (error.code === "result_unknown") {
+          link.send(peerResultFrame(payload.requestId, payload.messageId, "resultUnknown", "result_unknown", { transferId: file.transferId }));
+        } else {
+          sendError(link, error, payload.requestId, payload.messageId, file.transferId);
+        }
+        return;
+      }
+      await updateOutbox(target.daemonHostId, payload.messageId, "failed", error instanceof Error ? error.message : "file start failed");
+      sendError(link, error, payload.requestId, payload.messageId, file.transferId);
+    }
+  }
+  async function forwardFileChunk(link, payload) {
+    const active = resolveActiveFileSend(link, payload.messageId, payload.transferId, "file-chunk");
+    try {
+      if (active.target.daemonHostId === options.daemonHostId) {
+        const response2 = await receiveFileChunk(
+          { deviceId: options.deviceId, daemonHostId: options.daemonHostId },
+          payload
+        );
+        link.send(response2);
+        return;
+      }
+      if (!active.peer) {
+        throw new AppProtocolError({ code: "invalid_state", message: "peer transport is not active", stage: "file-chunk", transferId: payload.transferId });
+      }
+      const response = await peerRequest(active.peer, { type: "app-send-file-chunk", payload });
+      if (response.type === "app-error") {
+        await updateOutbox(active.target.daemonHostId, payload.messageId, "failed", response.payload.code);
+      }
+      link.send(response);
+    } catch (error) {
+      if (error instanceof PeerLinkError) {
+        const state = error.afterSend ? "result_unknown" : "failed";
+        await updateOutbox(active.target.daemonHostId, payload.messageId, state, error.code);
+        if (error.code === "result_unknown") {
+          link.send(peerResultFrame(payload.requestId, payload.messageId, "resultUnknown", "result_unknown", { transferId: payload.transferId }));
+        } else {
+          sendError(link, error, payload.requestId, payload.messageId, payload.transferId);
+        }
+        return;
+      }
+      await updateOutbox(active.target.daemonHostId, payload.messageId, "failed", error instanceof Error ? error.message : "file chunk failed");
+      sendError(link, error, payload.requestId, payload.messageId, payload.transferId);
+    }
+  }
+  async function forwardFileCommit(link, payload) {
+    const active = resolveActiveFileSend(link, payload.messageId, payload.transferId, "file-commit");
+    const commitToken = active.revision;
+    try {
+      if (active.target.daemonHostId === options.daemonHostId) {
+        const response2 = await receiveFileCommit(
+          { deviceId: options.deviceId, daemonHostId: options.daemonHostId },
+          payload
+        );
+        if (response2.type === "app-send-result" && (response2.payload.status === "received" || response2.payload.status === "delivered" || response2.payload.status === "consumed")) {
+          await updateOutbox(active.target.daemonHostId, payload.messageId, "received");
+          clearFileSend(link, payload.transferId, active, commitToken);
+        }
+        link.send(response2);
+        return;
+      }
+      if (!active.peer) {
+        throw new AppProtocolError({ code: "invalid_state", message: "peer transport is not active", stage: "file-commit", transferId: payload.transferId });
+      }
+      const response = await peerRequest(active.peer, { type: "app-send-file-commit", payload });
+      if (response.type === "app-error") {
+        await updateOutbox(active.target.daemonHostId, payload.messageId, "failed", response.payload.code);
+        link.send(response);
+        return;
+      }
+      if (response.type === "app-send-result" && (response.payload.status === "received" || response.payload.status === "delivered" || response.payload.status === "consumed")) {
+        await updateOutbox(active.target.daemonHostId, payload.messageId, "received");
+        clearFileSend(link, payload.transferId, active, commitToken);
+      }
+      link.send(response);
+    } catch (error) {
+      if (error instanceof PeerLinkError) {
+        const state = error.afterSend ? "result_unknown" : "failed";
+        await updateOutbox(active.target.daemonHostId, payload.messageId, state, error.code);
+        if (error.code === "result_unknown") {
+          link.send(peerResultFrame(payload.requestId, payload.messageId, "resultUnknown", "result_unknown", { transferId: payload.transferId }));
+        } else {
+          sendError(link, error, payload.requestId, payload.messageId, payload.transferId);
+        }
+        return;
+      }
+      await updateOutbox(active.target.daemonHostId, payload.messageId, "failed", error instanceof Error ? error.message : "file commit failed");
+      sendError(link, error, payload.requestId, payload.messageId, payload.transferId);
+    }
+  }
+  async function receiveMessage(sender, payload) {
+    const body = validateMessageBody(payload.body);
+    return store.runExclusive(async () => {
+      const existing = await store.readInboxRecord(sender.daemonHostId, payload.messageId);
+      if (existing) {
+        if (!sameMessageContent(existing, { ...payload, body })) {
+          throw new AppProtocolError({
+            code: "message_id_conflict",
+            message: "messageId already exists with different content",
+            stage: "inbound",
+            messageId: payload.messageId
+          });
+        }
+        return existing.state;
+      }
+      if (await store.hasStagingKey(sender.daemonHostId, payload.messageId)) {
+        throw new AppProtocolError({
+          code: "message_id_conflict",
+          message: "messageId is already being received as a file transfer",
+          stage: "inbound",
+          messageId: payload.messageId
+        });
+      }
+      const record = {
+        schemaVersion: 1,
+        senderDeviceId: sender.deviceId,
+        senderDaemonHostId: sender.daemonHostId,
+        receiverDeviceId: options.deviceId,
+        receiverDaemonHostId: options.daemonHostId,
+        messageId: payload.messageId,
+        kind: "message",
+        subject: payload.subject,
+        body,
+        state: "received",
+        receivedAt: nowIso(now)
+      };
+      await store.admitInboxRecord(record, Buffer.byteLength(body, "utf8"));
+      publishRecord(record);
+      return record.state;
+    });
+  }
+  async function receiveFileStart(sender, payload) {
+    const file = validateAppFileMetadata(payload.file, "file-start");
+    return store.runExclusive(async () => {
+      const existingRecord = await store.readInboxRecord(sender.daemonHostId, payload.messageId);
+      if (existingRecord) {
+        if (!sameFileContent(existingRecord, { ...payload, file })) {
+          throw new AppProtocolError({
+            code: "message_id_conflict",
+            message: "messageId already exists with a different file",
+            stage: "inbound-file",
+            messageId: payload.messageId
+          });
+        }
+        return peerResultFrame(payload.requestId, payload.messageId, existingRecord.state === "received" ? "received" : existingRecord.state === "rejected" ? "rejected" : "received", "received", {
+          transferId: file.transferId
+        });
+      }
+      const sameKeyStaging = await store.findStagingKey(sender.daemonHostId, payload.messageId);
+      if (sameKeyStaging && sameKeyStaging.transferId !== file.transferId) {
+        throw new AppProtocolError({
+          code: "message_id_conflict",
+          message: "messageId is already being received as a different transfer",
+          stage: "inbound-file",
+          messageId: payload.messageId
+        });
+      }
+      const existingStaging = await store.readStagingMetadata(sender.daemonHostId, file.transferId);
+      if (existingStaging) {
+        const matches = existingStaging.messageId === payload.messageId && existingStaging.fileName === file.fileName && existingStaging.totalBytes === file.totalBytes && existingStaging.chunkCount === file.chunkCount && existingStaging.sha256 === file.sha256;
+        if (!matches) {
+          throw new AppProtocolError({
+            code: "transfer_conflict",
+            message: "transferId already exists with different metadata",
+            stage: "inbound-file",
+            transferId: file.transferId
+          });
+        }
+        return peerResultFrame(payload.requestId, payload.messageId, "receiving", "prepared", {
+          transferId: file.transferId,
+          persistedOffset: existingStaging.persistedOffset
+        });
+      }
+      const usage = await store.computeInboxUsage();
+      if (usage.records + 1 > (options.maxInboxRecords ?? APP_MAX_INBOX_RECORDS) || usage.bytes + file.totalBytes > (options.maxInboxBytes ?? APP_MAX_INBOX_BYTES)) {
+        throw new AppStoreError("inbox_full", "durable inbox capacity would be exceeded by this file");
+      }
+      const metadata = {
+        schemaVersion: 1,
+        senderDaemonHostId: sender.daemonHostId,
+        senderDeviceId: sender.deviceId,
+        receiverDeviceId: options.deviceId,
+        receiverDaemonHostId: options.daemonHostId,
+        transferId: file.transferId,
+        messageId: payload.messageId,
+        subject: payload.subject,
+        fileName: file.fileName,
+        totalBytes: file.totalBytes,
+        chunkCount: file.chunkCount,
+        sha256: file.sha256,
+        reservedBytes: file.totalBytes,
+        persistedOffset: 0,
+        phase: "open"
+      };
+      await store.openStagingPart(metadata);
+      return peerResultFrame(payload.requestId, payload.messageId, "receiving", "prepared", {
+        transferId: file.transferId,
+        persistedOffset: 0
+      });
+    });
+  }
+  async function receiveFileChunk(sender, payload) {
+    const data = decodeStrictBase64(payload.dataBase64);
+    return store.runExclusive(async () => {
+      const metadata = await store.readStagingMetadata(sender.daemonHostId, payload.transferId);
+      if (!metadata) {
+        throw new AppProtocolError({
+          code: "not_found",
+          message: "transfer staging record not found",
+          stage: "inbound-file",
+          transferId: payload.transferId
+        });
+      }
+      if (metadata.messageId !== payload.messageId) {
+        throw new AppProtocolError({
+          code: "transfer_conflict",
+          message: "transferId belongs to another message",
+          stage: "inbound-file",
+          transferId: payload.transferId
+        });
+      }
+      const expectedOffset = payload.chunkIndex * APP_FILE_CHUNK_BYTES;
+      const isLast = payload.chunkIndex === metadata.chunkCount - 1;
+      const expectedLength = isLast ? metadata.totalBytes - expectedOffset : APP_FILE_CHUNK_BYTES;
+      if (payload.offset !== expectedOffset || payload.chunkIndex < 0 || payload.chunkIndex >= metadata.chunkCount || data.length !== expectedLength) {
+        throw new AppProtocolError({
+          code: "invalid_chunk",
+          message: `chunk ${payload.chunkIndex} offset/length does not match the transfer`,
+          stage: "inbound-file",
+          transferId: payload.transferId
+        });
+      }
+      if (payload.offset < metadata.persistedOffset) {
+        if (payload.offset + data.length > metadata.persistedOffset) {
+          throw new AppProtocolError({ code: "chunk_conflict", message: "chunk overlaps persisted data", stage: "inbound-file", transferId: payload.transferId });
+        }
+        const existing = await store.readPartRange(sender.daemonHostId, payload.transferId, payload.offset, data.length);
+        if (!existing.equals(data)) {
+          throw new AppProtocolError({ code: "chunk_conflict", message: "duplicate chunk bytes differ", stage: "inbound-file", transferId: payload.transferId });
+        }
+        return peerResultFrame(payload.requestId, payload.messageId, "receiving", "prepared", {
+          transferId: payload.transferId,
+          persistedOffset: metadata.persistedOffset
+        });
+      }
+      if (payload.offset > metadata.persistedOffset) {
+        throw new AppProtocolError({ code: "invalid_chunk", message: "chunk offset is ahead of persisted offset", stage: "inbound-file", transferId: payload.transferId });
+      }
+      const nextOffset = await store.appendPart(sender.daemonHostId, payload.transferId, metadata.persistedOffset, data);
+      const updated = { ...metadata, persistedOffset: nextOffset };
+      await store.writeStagingMetadata(updated);
+      return peerResultFrame(payload.requestId, payload.messageId, "receiving", "prepared", {
+        transferId: payload.transferId,
+        persistedOffset: nextOffset
+      });
+    });
+  }
+  async function receiveFileCommit(sender, payload) {
+    return store.runExclusive(async () => {
+      const existing = await store.readInboxRecord(sender.daemonHostId, payload.messageId);
+      if (existing?.kind === "file" && existing.file?.transferId === payload.transferId) {
+        return peerResultFrame(payload.requestId, payload.messageId, "received", "received", {
+          transferId: payload.transferId,
+          absolutePath: existing.file.absolutePath
+        });
+      }
+      if (existing) {
+        throw new AppProtocolError({
+          code: "message_id_conflict",
+          message: "messageId already exists for a different transfer",
+          stage: "file-commit",
+          messageId: payload.messageId,
+          transferId: payload.transferId
+        });
+      }
+      const metadata = await store.readStagingMetadata(sender.daemonHostId, payload.transferId);
+      if (!metadata || metadata.messageId !== payload.messageId) {
+        throw new AppProtocolError({ code: "not_found", message: "transfer staging record not found", stage: "file-commit", transferId: payload.transferId });
+      }
+      const partSize = await store.statPart(sender.daemonHostId, payload.transferId);
+      if (partSize !== metadata.totalBytes || metadata.persistedOffset !== metadata.totalBytes) {
+        throw new AppProtocolError({
+          code: "transfer_incomplete",
+          message: `transfer has ${partSize ?? 0}/${metadata.totalBytes} persisted bytes`,
+          stage: "file-commit",
+          transferId: payload.transferId
+        });
+      }
+      const actualSha = await store.computeFileSha256(store.stagingPartPath(sender.daemonHostId, payload.transferId));
+      if (actualSha !== metadata.sha256) {
+        throw new AppProtocolError({
+          code: "integrity_mismatch",
+          message: "transfer SHA-256 does not match the declared digest",
+          stage: "file-commit",
+          transferId: payload.transferId
+        });
+      }
+      const finalPath = store.finalFilePath(sender.daemonHostId, payload.messageId, metadata.fileName);
+      const verified = { ...metadata, phase: "verified", absolutePath: finalPath };
+      await store.writeStagingMetadata(verified);
+      await store.renamePartToFinal(sender.daemonHostId, payload.messageId, metadata.fileName, payload.transferId);
+      const record = {
+        schemaVersion: 1,
+        senderDeviceId: sender.deviceId,
+        senderDaemonHostId: sender.daemonHostId,
+        receiverDeviceId: options.deviceId,
+        receiverDaemonHostId: options.daemonHostId,
+        messageId: payload.messageId,
+        kind: "file",
+        subject: metadata.subject,
+        file: {
+          transferId: metadata.transferId,
+          fileName: metadata.fileName,
+          totalBytes: metadata.totalBytes,
+          chunkCount: metadata.chunkCount,
+          sha256: metadata.sha256,
+          absolutePath: finalPath
+        },
+        state: "received",
+        receivedAt: nowIso(now)
+      };
+      await store.admitInboxRecord(record, 0, {
+        staging: { senderDaemonHostId: sender.daemonHostId, transferId: payload.transferId }
+      });
+      await store.removeStagingEntry(sender.daemonHostId, payload.transferId);
+      publishRecord(record);
+      return peerResultFrame(payload.requestId, payload.messageId, "received", "received", {
+        transferId: payload.transferId,
+        absolutePath: finalPath
+      });
+    });
+  }
+  async function resolveInboxRecord(messageId, senderDaemonHostId) {
+    if (senderDaemonHostId) {
+      const record = await store.readInboxRecord(senderDaemonHostId, messageId);
+      if (!record) {
+        throw new AppProtocolError({ code: "not_found", message: "message not found", stage: "status", messageId });
+      }
+      return record;
+    }
+    const matches = (await store.listInboxRecords()).filter((record) => record.messageId === messageId);
+    if (matches.length === 1) return matches[0];
+    if (matches.length === 0) {
+      throw new AppProtocolError({ code: "not_found", message: "message not found", stage: "status", messageId });
+    }
+    throw new AppProtocolError({ code: "ambiguous_message_id", message: "messageId matches multiple senders", stage: "status", messageId });
+  }
+  async function settleLocalState(messageId, senderDaemonHostId, targetState) {
+    return store.runExclusive(async () => {
+      const record = await resolveInboxRecord(messageId, senderDaemonHostId);
+      if (record.state === "rejected") {
+        throw new AppProtocolError({ code: "invalid_state", message: "rejected messages cannot advance", stage: "ack", messageId });
+      }
+      if (targetState === "delivered") {
+        if (record.state !== "received") return { changed: false, record };
+        const next2 = { ...record, state: "delivered", deliveredAt: nowIso(now) };
+        await store.writeInboxRecord(next2);
+        return { changed: true, record: next2 };
+      }
+      if (record.state === "received") {
+        throw new AppProtocolError({ code: "invalid_state", message: "consume requires delivered state", stage: "consume", messageId });
+      }
+      if (record.state === "consumed") return { changed: false, record };
+      const next = { ...record, state: "consumed", consumedAt: nowIso(now) };
+      await store.writeInboxRecord(next);
+      return { changed: true, record: next };
+    });
+  }
+  async function localStatus(link, requestId, messageId, senderDaemonHostId) {
+    try {
+      const record = await resolveInboxRecord(messageId, senderDaemonHostId);
+      link.send({ type: "app-status-result", payload: recordStatusPayload(record, requestId) });
+      return;
+    } catch (error) {
+      if (!(error instanceof AppProtocolError) || error.code !== "not_found") {
+        sendError(link, error, requestId, messageId);
+        return;
+      }
+    }
+    const outbox = (await store.listOutboxRecords()).filter((record) => record.messageId === messageId);
+    if (outbox.length === 1) {
+      link.send({ type: "app-status-result", payload: outboxStatusPayload(outbox[0], requestId) });
+      return;
+    }
+    if (outbox.length > 1) {
+      link.send({
+        type: "app-status-result",
+        payload: { requestId, messageId, found: false, ambiguous: true }
+      });
+      return;
+    }
+    link.send({ type: "app-status-result", payload: { requestId, messageId, found: false } });
+  }
+  async function remoteStatus(link, requestId, messageId, target) {
+    try {
+      const peer = await connectPeer(target);
+      const response = await peerRequest(peer, {
+        type: "app-status",
+        payload: { requestId, messageId }
+      });
+      link.send(response);
+    } catch (error) {
+      if (error instanceof PeerLinkError && error.code === "result_unknown") {
+        sendError(link, error, requestId, messageId);
+        return;
+      }
+      sendError(link, error, requestId, messageId);
+    }
+  }
+  async function peerStatus(link, requestId, messageId, senderDaemonHostId) {
+    if (senderDaemonHostId && senderDaemonHostId !== link.daemonHostId) {
+      throw new AppProtocolError({ code: "not_found", message: "peer may only query its own sender scope", stage: "status", messageId });
+    }
+    const record = await store.readInboxRecord(link.daemonHostId, messageId);
+    if (!record) {
+      link.send({ type: "app-status-result", payload: { requestId, messageId, found: false } });
+      return;
+    }
+    link.send({ type: "app-status-result", payload: recordStatusPayload(record, requestId) });
+  }
+  async function recoverOutbox() {
+    await store.runExclusive(async () => {
+      for (const record of await store.listOutboxRecords()) {
+        if (record.state !== "pending" && record.state !== "sent") continue;
+        await store.writeOutboxRecord({ ...record, state: "result_unknown", updatedAt: nowIso(now) });
+      }
+    });
+  }
+  return {
+    async initialize() {
+      if (initialized) return;
+      try {
+        await store.initialize();
+        const recovered = await store.runExclusive(() => store.recoverStaging());
+        await recoverOutbox();
+        await store.runExclusive(() => store.cleanupRetention(now(), retentionMs));
+        for (const record of recovered) publishRecord(record);
+        retentionTimer = setInterval(() => {
+          void store.runExclusive(() => store.cleanupRetention(now(), retentionMs)).catch(() => void 0);
+        }, options.retentionIntervalMs ?? 60 * 60 * 1e3);
+        retentionTimer.unref?.();
+        initialized = true;
+        initializationError = null;
+      } catch (error) {
+        initializationError = error instanceof Error ? error : new Error(String(error));
+      }
+    },
+    dispose() {
+      if (retentionTimer) {
+        clearInterval(retentionTimer);
+        retentionTimer = null;
+      }
+      for (const peer of [...peerLinks.values()]) {
+        void closePeerLink(peer, "daemon dispose");
+      }
+      for (const [id, subscriber] of subscribers) {
+        subscriber.close("daemon dispose", 1001);
+        subscribers.delete(id);
+      }
+      activeFileSends.clear();
+      initialized = false;
+      initializationError = null;
+    },
+    getInitializationError() {
+      return initializationError;
+    },
+    getCapabilities() {
+      return APP_CAPABILITIES;
+    },
+    getIdentity() {
+      return { deviceId: options.deviceId, daemonHostId: options.daemonHostId };
+    },
+    async subscribeLocal(link) {
+      await store.runExclusive(async () => {
+        subscribers.set(link.id, link);
+        for (const record of await store.listInboxRecords()) {
+          if (record.state !== "received") continue;
+          const frame = record.kind === "file" ? inboundFileFrame(record) : inboundMessageFrame(record);
+          if (frame && !link.send(frame)) {
+            subscribers.delete(link.id);
+            link.close("slow_consumer", 4008);
+            break;
+          }
+        }
+      });
+    },
+    revokeLink(linkId) {
+      subscribers.delete(linkId);
+      for (const [key, active] of [...activeFileSends]) {
+        if (active.linkId === linkId) activeFileSends.delete(key);
+      }
+    },
+    async handleFrame(link, frame) {
+      const requestId = frameRequestId(frame);
+      const messageId = "messageId" in frame.payload && typeof frame.payload.messageId === "string" ? frame.payload.messageId : void 0;
+      const transferId = "transferId" in frame.payload && typeof frame.payload.transferId === "string" ? frame.payload.transferId : void 0;
+      try {
+        if (initializationError) {
+          throw new AppProtocolError({
+            code: "storage_error",
+            message: `app messaging is unavailable: ${initializationError.message}`,
+            stage: "admission",
+            requestId
+          });
+        }
+        if (frame.type === "app-ack" || frame.type === "app-consume") {
+          if (link.role !== "local") {
+            throw new AppProtocolError({ code: "forbidden_role", message: "peer connections cannot ack or consume", stage: "admission" });
+          }
+          const state = frame.type === "app-ack" ? "delivered" : "consumed";
+          const settled = await settleLocalState(frame.payload.messageId, frame.payload.senderDaemonHostId, state);
+          link.send({ type: "app-status-result", payload: recordStatusPayload(settled.record, frame.payload.requestId) });
+          if (settled.changed) {
+            return { settled: true, messageId: settled.record.messageId, senderDaemonHostId: settled.record.senderDaemonHostId };
+          }
+          return { settled: false };
+        }
+        switch (frame.type) {
+          case "app-send-message":
+            if (link.role === "local") {
+              await sendMessageFromLocal(link, frame.payload);
+            } else {
+              const state = await receiveMessage(link, frame.payload);
+              link.send(peerResultFrame(frame.payload.requestId, frame.payload.messageId, state === "rejected" ? "rejected" : "received", "received"));
+            }
+            return { settled: false };
+          case "app-send-file-start":
+            if (link.role === "local") {
+              await sendFileStartFromLocal(link, frame.payload);
+            } else {
+              link.send(await receiveFileStart(link, frame.payload));
+            }
+            return { settled: false };
+          case "app-send-file-chunk":
+            if (link.role === "local") {
+              await forwardFileChunk(link, frame.payload);
+            } else {
+              link.send(await receiveFileChunk(link, frame.payload));
+            }
+            return { settled: false };
+          case "app-send-file-commit":
+            if (link.role === "local") {
+              await forwardFileCommit(link, frame.payload);
+            } else {
+              link.send(await receiveFileCommit(link, frame.payload));
+            }
+            return { settled: false };
+          case "app-status":
+            if (link.role === "peer") {
+              await peerStatus(link, frame.payload.requestId, frame.payload.messageId, frame.payload.senderDaemonHostId);
+              return { settled: false };
+            }
+            if (frame.payload.remote) {
+              const target = validateAppTarget(frame.payload.target, "status");
+              await remoteStatus(link, frame.payload.requestId, frame.payload.messageId, target);
+              return { settled: false };
+            }
+            await localStatus(link, frame.payload.requestId, frame.payload.messageId, frame.payload.senderDaemonHostId);
+            return { settled: false };
+          case "app-ping":
+            link.send({
+              type: "app-pong",
+              payload: {
+                requestId: frame.payload.requestId,
+                sentAt: frame.payload.sentAt,
+                receivedAt: now()
+              }
+            });
+            return { settled: false };
+          default:
+            throw new AppProtocolError({ code: "invalid_frame", message: `unsupported frame: ${frame.type}`, stage: "dispatch" });
+        }
+      } catch (error) {
+        sendError(link, error, requestId, messageId, transferId);
+        return { settled: false };
+      }
+      return { settled: false };
+    }
+  };
+}
+
+// src/server/daemon-app-websocket-runtime.ts
+var import_node_crypto4 = require("node:crypto");
+function assertDaemonAppHelloAdmission(input) {
+  if (!input.deviceId || !input.daemonHostId) {
+    throw new AppProtocolError({
+      code: "missing_identity",
+      message: "daemon device identity is not configured; set zterm.android.relay.deviceId",
+      stage: "admission",
+      requestId: input.hello.requestId
+    });
+  }
+  if (input.hello.role === "local") {
+    if (!input.remoteLoopback) {
+      throw new AppProtocolError({ code: "forbidden_role", message: "local role requires a loopback connection", stage: "admission", requestId: input.hello.requestId });
+    }
+    if (input.hello.daemonHostId !== input.daemonHostId || input.hello.deviceId !== input.deviceId) {
+      throw new AppProtocolError({ code: "forbidden_role", message: "local role identity does not match this daemon", stage: "admission", requestId: input.hello.requestId });
+    }
+  }
+}
+var APP_PATH = "/app";
+var HANDSHAKE_TIMEOUT_MS = 15e3;
+var SLOW_CONSUMER_GRACE_MS = 2e4;
+function isLoopbackAddress(address) {
+  if (!address) return false;
+  return address === "127.0.0.1" || address === "::1" || address === "::ffff:127.0.0.1";
+}
+function bearerToken(request) {
+  const authorization = request.headers.authorization?.trim() || "";
+  return authorization.toLowerCase().startsWith("bearer ") ? authorization.slice(7).trim() : "";
+}
+function tokensEqual(left, right) {
+  if (!left || !right) return false;
+  const leftBytes = Buffer.from(left);
+  const rightBytes = Buffer.from(right);
+  return leftBytes.length === rightBytes.length && (0, import_node_crypto4.timingSafeEqual)(leftBytes, rightBytes);
+}
+function rejectUpgrade(socket, status, message) {
+  socket.write(
+    `HTTP/1.1 ${status} ${message}\r
+Connection: close\r
+Content-Length: 0\r
+\r
+`
+  );
+  socket.destroy();
+}
+function rawText(rawData) {
+  if (typeof rawData === "string") return rawData;
+  if (Buffer.isBuffer(rawData)) return rawData.toString("utf8");
+  if (Array.isArray(rawData)) return Buffer.concat(rawData).toString("utf8");
+  return Buffer.from(rawData).toString("utf8");
+}
+function createDaemonAppGateway(options) {
+  const wss2 = new import_websocket_server.default({ noServer: true });
+  const connections2 = /* @__PURE__ */ new Set();
+  const log = options.log ?? (() => void 0);
+  function sendRawError(ws, error, requestId) {
+    if (ws.readyState !== wrapper_default.OPEN) return;
+    ws.send(JSON.stringify({
+      type: "app-error",
+      payload: appErrorPayload({
+        code: error.code,
+        stage: error.stage,
+        message: error.message,
+        requestId: error.requestId ?? requestId
+      })
+    }));
+  }
+  function handleConnection(ws, request) {
+    connections2.add(ws);
+    let link = null;
+    let helloSeen = false;
+    let pendingBytes = 0;
+    let overLimitSince = null;
+    let lastAckProgressAt = null;
+    let slowConsumerTimer = null;
+    let slowConsumerClosed = false;
+    const pendingMessages = /* @__PURE__ */ new Map();
+    const pendingWrite = (frame, bytes) => {
+      if (frame.type === "app-connection-state" || frame.type === "app-error" && frame.payload.requestId === void 0) {
+        if (ws.readyState === wrapper_default.OPEN) {
+          ws.send(JSON.stringify(frame));
+        }
+        return;
+      }
+      if (frame.type === "app-inbound-message" || frame.type === "app-inbound-file") {
+        trackPendingInbound(frame, bytes);
+      }
+      const text = JSON.stringify(frame);
+      ws.send(text, (error) => {
+        if (error) {
+          ws.close(1011, "send failed");
+        }
+      });
+    };
+    const slowConsumerGraceMs = options.slowConsumerGraceMs ?? SLOW_CONSUMER_GRACE_MS;
+    const remoteLoopback = isLoopbackAddress(request.socket.remoteAddress);
+    const handshakeTimer = setTimeout(() => {
+      if (helloSeen || ws.readyState !== wrapper_default.OPEN) return;
+      sendRawError(ws, new AppProtocolError({ code: "invalid_frame", message: "app handshake timed out", stage: "admission" }));
+      ws.close(4003, "handshake timeout");
+    }, HANDSHAKE_TIMEOUT_MS);
+    handshakeTimer.unref?.();
+    function clearSlowConsumerTimer() {
+      if (slowConsumerTimer) {
+        clearTimeout(slowConsumerTimer);
+        slowConsumerTimer = null;
+      }
+    }
+    function oldestPendingMessage() {
+      let oldest = null;
+      for (const pending of pendingMessages.values()) {
+        if (!oldest || pending.enqueuedAt < oldest.enqueuedAt) oldest = pending;
+      }
+      return oldest;
+    }
+    function scheduleSlowConsumerCheck() {
+      clearSlowConsumerTimer();
+      if (slowConsumerClosed || ws.readyState !== wrapper_default.OPEN) return;
+      if (pendingBytes <= APP_STREAM_OUTBOUND_QUEUE_BYTES) {
+        overLimitSince = null;
+        return;
+      }
+      const oldest = oldestPendingMessage();
+      if (!oldest) {
+        overLimitSince = null;
+        return;
+      }
+      const currentTime = Date.now();
+      if (overLimitSince === null) overLimitSince = currentTime;
+      const eligibleAt = Math.max(
+        oldest.enqueuedAt,
+        overLimitSince,
+        lastAckProgressAt ?? 0
+      );
+      const delayMs = Math.max(0, eligibleAt + slowConsumerGraceMs - currentTime);
+      slowConsumerTimer = setTimeout(checkSlowConsumer, delayMs);
+      slowConsumerTimer.unref?.();
+    }
+    function checkSlowConsumer() {
+      slowConsumerTimer = null;
+      if (slowConsumerClosed || ws.readyState !== wrapper_default.OPEN) return;
+      if (pendingBytes <= APP_STREAM_OUTBOUND_QUEUE_BYTES) {
+        overLimitSince = null;
+        return;
+      }
+      const oldest = oldestPendingMessage();
+      if (!oldest) {
+        overLimitSince = null;
+        return;
+      }
+      const currentTime = Date.now();
+      if (overLimitSince === null) overLimitSince = currentTime;
+      const eligibleAt = Math.max(
+        oldest.enqueuedAt,
+        overLimitSince,
+        lastAckProgressAt ?? 0
+      );
+      if (currentTime - eligibleAt < slowConsumerGraceMs) {
+        scheduleSlowConsumerCheck();
+        return;
+      }
+      slowConsumerClosed = true;
+      clearSlowConsumerTimer();
+      sendRawError(ws, new AppProtocolError({
+        code: "slow_consumer",
+        stage: "publish",
+        message: "local app stream has unacknowledged inbound data beyond the slow-consumer grace period"
+      }));
+      ws.close(4008, "slow_consumer");
+    }
+    function inboundPendingKey(frame) {
+      if (frame.type === "app-inbound-message") {
+        return `${frame.payload.senderDaemonHostId}\0${frame.payload.messageId}`;
+      }
+      if (frame.type === "app-inbound-file") {
+        return `${frame.payload.senderDaemonHostId}\0${frame.payload.messageId}`;
+      }
+      return null;
+    }
+    function trackPendingInbound(frame, bytes) {
+      if (!link || link.role !== "local") return;
+      const key = inboundPendingKey(frame);
+      if (!key) return;
+      if (pendingMessages.has(key)) return;
+      const currentTime = Date.now();
+      pendingMessages.set(key, { bytes, enqueuedAt: currentTime });
+      pendingBytes += bytes;
+      if (pendingBytes > APP_STREAM_OUTBOUND_QUEUE_BYTES && overLimitSince === null) {
+        overLimitSince = currentTime;
+      }
+      if (pendingBytes > APP_STREAM_OUTBOUND_QUEUE_BYTES) scheduleSlowConsumerCheck();
+    }
+    function acknowledgePending(senderDaemonHostId, messageId) {
+      let key = null;
+      if (senderDaemonHostId) {
+        const candidate = `${senderDaemonHostId}\0${messageId}`;
+        if (pendingMessages.has(candidate)) key = candidate;
+      } else {
+        const matches = [...pendingMessages.keys()].filter((entry) => entry.endsWith(`\0${messageId}`));
+        if (matches.length === 1) key = matches[0];
+      }
+      if (key === null) return;
+      const pending = pendingMessages.get(key);
+      if (!pending) return;
+      pendingMessages.delete(key);
+      pendingBytes = Math.max(0, pendingBytes - pending.bytes);
+      lastAckProgressAt = Date.now();
+      if (pendingBytes <= APP_STREAM_OUTBOUND_QUEUE_BYTES) {
+        overLimitSince = null;
+        clearSlowConsumerTimer();
+        return;
+      }
+      overLimitSince = lastAckProgressAt;
+      scheduleSlowConsumerCheck();
+    }
+    function enqueue(frame) {
+      if (ws.readyState !== wrapper_default.OPEN) return false;
+      const text = JSON.stringify(frame);
+      const bytes = Buffer.byteLength(text, "utf8");
+      pendingWrite(frame, bytes);
+      return true;
+    }
+    function closeLink(reason, code = 1e3) {
+      if (ws.readyState === wrapper_default.OPEN || ws.readyState === wrapper_default.CONNECTING) {
+        ws.close(code, reason);
+      }
+    }
+    async function acceptHello(hello) {
+      if (helloSeen) {
+        throw new AppProtocolError({ code: "invalid_frame", message: "app-hello may only be sent once", stage: "admission", requestId: hello.requestId });
+      }
+      assertDaemonAppHelloAdmission({
+        hello,
+        deviceId: options.deviceId,
+        daemonHostId: options.daemonHostId,
+        remoteLoopback
+      });
+      const initError = options.messaging.getInitializationError();
+      if (initError) {
+        throw new AppProtocolError({
+          code: "storage_error",
+          message: `app messaging is unavailable: ${initError.message}`,
+          stage: "admission",
+          requestId: hello.requestId
+        });
+      }
+      helloSeen = true;
+      clearTimeout(handshakeTimer);
+      const connectionId = `app-${(0, import_node_crypto4.randomUUID)()}`;
+      link = {
+        id: connectionId,
+        role: hello.role,
+        deviceId: hello.deviceId,
+        daemonHostId: hello.daemonHostId,
+        clientInstanceId: hello.clientInstanceId,
+        send: enqueue,
+        close: closeLink
+      };
+      const ready = {
+        requestId: hello.requestId,
+        protocolVersion: APP_PROTOCOL_VERSION,
+        deviceId: options.deviceId,
+        daemonHostId: options.daemonHostId,
+        capabilities: APP_CAPABILITIES
+      };
+      ws.send(JSON.stringify({ type: "app-ready", payload: ready }));
+      if (hello.role === "local") {
+        await options.messaging.subscribeLocal(link);
+        enqueue({
+          type: "app-connection-state",
+          payload: {
+            requestId: `event-${(0, import_node_crypto4.randomUUID)()}`,
+            state: "connected",
+            daemonHostId: options.daemonHostId
+          }
+        });
+      }
+    }
+    ws.on("message", (rawData) => {
+      let parsed;
+      try {
+        parsed = JSON.parse(rawText(rawData));
+      } catch {
+        sendRawError(ws, new AppProtocolError({ code: "invalid_frame", message: "frame is not valid JSON", stage: "frame" }));
+        ws.close(4003, "invalid frame");
+        return;
+      }
+      let frame;
+      try {
+        frame = validateAppClientFrame(parsed);
+      } catch (error) {
+        if (error instanceof AppProtocolError) {
+          sendRawError(ws, error);
+          if (error.code === "invalid_frame" || error.code === "invalid_version") {
+            ws.close(4003, error.code);
+          }
+          return;
+        }
+        sendRawError(ws, new AppProtocolError({ code: "invalid_frame", message: "frame validation failed", stage: "frame" }));
+        ws.close(4003, "invalid frame");
+        return;
+      }
+      if (frame.type === "app-hello") {
+        void acceptHello(frame.payload).catch((error) => {
+          if (error instanceof AppProtocolError) {
+            sendRawError(ws, error, frame.payload.requestId);
+          }
+          ws.close(4003, "admission rejected");
+        });
+        return;
+      }
+      if (!link || !helloSeen) {
+        sendRawError(ws, new AppProtocolError({ code: "invalid_frame", message: "app-hello must be the first frame", stage: "admission" }));
+        ws.close(4003, "hello required");
+        return;
+      }
+      void options.messaging.handleFrame(link, frame).then((result) => {
+        if (result.settled && result.messageId) {
+          acknowledgePending(result.senderDaemonHostId, result.messageId);
+        }
+      }).catch((error) => {
+        log(`app frame handling failed: ${error instanceof Error ? error.message : String(error)}`);
+      });
+    });
+    ws.on("close", () => {
+      clearTimeout(handshakeTimer);
+      clearSlowConsumerTimer();
+      if (link) options.messaging.revokeLink(link.id);
+      connections2.delete(ws);
+    });
+    ws.on("error", (error) => {
+      clearTimeout(handshakeTimer);
+      clearSlowConsumerTimer();
+      if (link) options.messaging.revokeLink(link.id);
+      connections2.delete(ws);
+      log(`app websocket error: ${error.message}`);
+    });
+  }
+  return {
+    handleServerUpgrade(request, socket, head) {
+      let pathname;
+      try {
+        pathname = new URL(request.url || "/", "ws://localhost").pathname;
+      } catch {
+        rejectUpgrade(socket, 404, "Not Found");
+        return true;
+      }
+      if (pathname !== APP_PATH) return false;
+      if (!options.requiredAuthToken) {
+        rejectUpgrade(socket, 401, "Unauthorized");
+        return true;
+      }
+      if (!tokensEqual(bearerToken(request), options.requiredAuthToken)) {
+        rejectUpgrade(socket, 401, "Unauthorized");
+        return true;
+      }
+      wss2.handleUpgrade(request, socket, head, (ws) => handleConnection(ws, request));
+      return true;
+    },
+    dispose() {
+      for (const ws of [...connections2]) {
+        try {
+          ws.close(1001, "daemon dispose");
+        } catch {
+        }
+      }
+      connections2.clear();
+      wss2.close();
+    }
+  };
+}
+
+// src/server/remote-screenshot-daemon.ts
+var import_node_child_process6 = require("node:child_process");
+var import_node_os2 = require("node:os");
+var import_node_path6 = require("node:path");
+async function captureRemoteScreenshotWithDaemon(options) {
+  const gate = runPhase3Screenshot({
+    execution_id: `remote-screenshot:${Date.now()}`,
+    attempt_id: "1",
+    inputs: {
+      "arc.screenshot_request": {
+        sessionId: options.sessionId || "daemon-screenshot",
+        outputPath: options.outputPath
+      },
+      "arc.screenshot_permission": { allowScreenshot: true }
+    }
+  });
+  if (!gate.ok) {
+    throw new Error(`dagpipe screenshot gate rejected capture: ${gate.error}`);
+  }
+  return await new Promise((resolve4, reject) => {
+    const daemonBinary = (process.env.ZTERM_DAEMON_NATIVE || "").trim() || (0, import_node_path6.join)((0, import_node_os2.homedir)(), ".zterm", "bin", "zterm-daemon");
+    const args = ["capture-screen", options.outputPath];
+    const windowId = options.windowId?.trim();
+    if (windowId) {
+      args.push("--window-id", windowId);
+    }
+    if (options.rect) {
+      args.push(
+        "--rect",
+        [
+          Math.round(options.rect.x),
+          Math.round(options.rect.y),
+          Math.round(options.rect.width),
+          Math.round(options.rect.height)
+        ].join(",")
+      );
+    }
+    (0, import_node_child_process6.execFile)(daemonBinary, args, {
+      timeout: options.timeoutMs,
+      windowsHide: true
+    }, (error, stdout, stderr) => {
+      if (error) {
+        const details = [error.message, stderr, stdout].filter(Boolean).join("\n");
+        reject(new Error(details || "daemon screenshot capture failed"));
+        return;
+      }
+      resolve4({ outputPath: options.outputPath });
+    });
+  });
+}
+
+// src/server/remote-window-stream-daemon.ts
+var import_wrtc2 = __toESM(require_lib2(), 1);
+
+// src/server/remote-window-stream-daemon-helpers.ts
+function cloneRemoteWindowTargetCatalogResponse(response, requestId) {
+  return {
+    requestId,
+    targets: response.targets.slice(),
+    ...response.errors ? {
+      errors: response.errors.map((error) => ({
+        ...error,
+        requestId
+      }))
+    } : {}
+  };
+}
+function cloneRemoteWindowTargetCatalogResult(result, requestId) {
+  if ("targets" in result) {
+    return cloneRemoteWindowTargetCatalogResponse(result, requestId);
+  }
+  return {
+    ...result,
+    requestId
+  };
+}
+function normalizeRtcDescription(description, expectedType) {
+  if (!description || description.type !== expectedType || typeof description.sdp !== "string") {
+    throw new Error(`remote window daemon expected ${expectedType} description`);
+  }
+  return {
+    type: expectedType,
+    sdp: description.sdp
+  };
+}
+function normalizeIceCandidate(candidate) {
+  const candidateLike = typeof candidate.toJSON === "function" ? candidate.toJSON() : candidate;
+  return {
+    candidate: String(candidateLike.candidate || ""),
+    sdpMid: candidateLike.sdpMid ?? null,
+    sdpMLineIndex: candidateLike.sdpMLineIndex ?? null,
+    usernameFragment: candidateLike.usernameFragment ?? null
+  };
+}
+function normalizeRemoteWindowVideoProfile(input) {
+  if (!input) {
+    return null;
+  }
+  if (input.preference !== "smooth" && input.preference !== "quality") {
+    throw new Error(`remote window video preference is invalid: ${String(input.preference)}`);
+  }
+  const fields = [
+    ["maxBitrateBps", input.maxBitrateBps, 5e5, 25e6],
+    ["maxFrameRateFps", input.maxFrameRateFps, 1, 60],
+    ["maxCaptureWidth", input.maxCaptureWidth, 320, 3840],
+    ["maxCaptureHeight", input.maxCaptureHeight, 240, 2400],
+    ["maxFrameAgeMs", input.maxFrameAgeMs, 40, 1e3],
+    ["overviewMaxBitrateBps", input.overviewMaxBitrateBps, 0, 2e6],
+    ["overviewMaxFrameRateFps", input.overviewMaxFrameRateFps, 0, 8]
+  ];
+  for (const [name, value, minimum, maximum] of fields) {
+    if (!Number.isFinite(value) || value < minimum || value > maximum) {
+      throw new Error(`remote window video profile ${name} is out of range`);
+    }
+  }
+  if (input.overviewMaxBitrateBps >= input.maxBitrateBps) {
+    throw new Error("remote window overview bitrate must remain below the total bitrate");
+  }
+  if (input.overviewMaxFrameRateFps > input.maxFrameRateFps) {
+    throw new Error("remote window overview frame rate must not exceed focus frame rate");
+  }
+  return {
+    preference: input.preference,
+    maxBitrateBps: Math.floor(input.maxBitrateBps),
+    maxFrameRateFps: Math.floor(input.maxFrameRateFps),
+    maxCaptureWidth: Math.floor(input.maxCaptureWidth),
+    maxCaptureHeight: Math.floor(input.maxCaptureHeight),
+    maxFrameAgeMs: Math.floor(input.maxFrameAgeMs),
+    interactionActive: input.interactionActive === true,
+    overviewMaxBitrateBps: Math.floor(input.overviewMaxBitrateBps),
+    overviewMaxFrameRateFps: Math.floor(input.overviewMaxFrameRateFps)
+  };
+}
+function formatRemoteWindowVideoProfileError(error) {
+  if (error instanceof Error) {
+    return error.message || error.name || "remote window video bitrate could not be applied";
+  }
+  const message = String(error || "").trim();
+  return message || "remote window video bitrate could not be applied";
+}
+function convertRgbaToI420Frame(frame, convert) {
+  const width = Math.max(1, Math.floor(frame.width));
+  const height = Math.max(1, Math.floor(frame.height));
+  const chromaWidth = Math.ceil(width / 2);
+  const chromaHeight = Math.ceil(height / 2);
+  const i420 = {
+    width,
+    height,
+    data: new Uint8Array(width * height + chromaWidth * chromaHeight * 2)
+  };
+  convert({
+    width,
+    height,
+    data: frame.rgba
+  }, i420);
+  return i420;
+}
+var REMOTE_WINDOW_LATENCY_SAMPLE_CAPACITY = 240;
+function pushBounded(samples, value) {
+  if (!Number.isFinite(value) || value < 0) {
+    return;
+  }
+  samples.push(value);
+  if (samples.length > REMOTE_WINDOW_LATENCY_SAMPLE_CAPACITY) {
+    samples.splice(0, samples.length - REMOTE_WINDOW_LATENCY_SAMPLE_CAPACITY);
+  }
+}
+function nearestRankPercentile(samples, percentile) {
+  if (samples.length === 0) {
+    return null;
+  }
+  const sorted = [...samples].sort((left, right) => left - right);
+  const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil(percentile * sorted.length) - 1));
+  return sorted[index];
+}
+function readStatsNumber(entry, key) {
+  const value = entry[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function createRemoteWindowLatencyAccumulator() {
+  const captureToEncodeSamples = [];
+  const captureArrivalTimestamps = [];
+  const dispatchTimestamps = [];
+  const inputInjectionSamples = [];
+  let previousOutbound = null;
+  let encodeMsPerFrame = null;
+  let packetSendDelayMs = null;
+  let encodedFps = null;
+  let sentBitrateBps = null;
+  let codecMimeType = null;
+  let networkRttMs = null;
+  let networkJitterMs = null;
+  let packetLossRatio = null;
   let captureWidth = null;
   let captureHeight = null;
   return {
@@ -20541,23 +23139,23 @@ function rectWithOffset(rect, offset) {
 var import_child_process3 = require("child_process");
 
 // src/server/macos-swift-script.ts
-var import_node_crypto2 = require("node:crypto");
+var import_node_crypto5 = require("node:crypto");
 var import_node_child_process7 = require("node:child_process");
 var import_node_fs4 = require("node:fs");
 var import_node_os3 = require("node:os");
-var import_node_path6 = require("node:path");
+var import_node_path7 = require("node:path");
 var import_node_util = require("node:util");
 var execFileAsync = (0, import_node_util.promisify)(import_node_child_process7.execFile);
 var SWIFT_SCRIPT_COMPILE_TIMEOUT_MS = 12e4;
 function cacheRoot() {
-  return process.env.ZTERM_SWIFT_SCRIPT_CACHE_DIR || (0, import_node_path6.join)((0, import_node_os3.homedir)(), ".zterm", "cache", "swift-scripts");
+  return process.env.ZTERM_SWIFT_SCRIPT_CACHE_DIR || (0, import_node_path7.join)((0, import_node_os3.homedir)(), ".zterm", "cache", "swift-scripts");
 }
 function swiftScriptCacheKey(source, swiftVersion) {
-  return (0, import_node_crypto2.createHash)("sha256").update(`${swiftVersion}
+  return (0, import_node_crypto5.createHash)("sha256").update(`${swiftVersion}
 ${source}`).digest("hex").slice(0, 32);
 }
 function swiftScriptCachePath(source, swiftVersion) {
-  return (0, import_node_path6.join)(cacheRoot(), `zterm-swift-${swiftScriptCacheKey(source, swiftVersion)}`);
+  return (0, import_node_path7.join)(cacheRoot(), `zterm-swift-${swiftScriptCacheKey(source, swiftVersion)}`);
 }
 function resolveCachedSwiftScript(source, swiftVersion) {
   const binaryPath = swiftScriptCachePath(source, swiftVersion);
@@ -20575,11 +23173,11 @@ async function prepareSwiftScript(options) {
   if (cached) {
     return cached;
   }
-  const stagingDir = (0, import_node_fs4.mkdtempSync)((0, import_node_path6.join)((0, import_node_os3.tmpdir)(), "zterm-swift-"));
+  const stagingDir = (0, import_node_fs4.mkdtempSync)((0, import_node_path7.join)((0, import_node_os3.tmpdir)(), "zterm-swift-"));
   try {
     (0, import_node_fs4.mkdirSync)(cacheRoot(), { recursive: true });
-    const sourcePath = (0, import_node_path6.join)(stagingDir, "script.swift");
-    const binaryPath = (0, import_node_path6.join)(stagingDir, "script");
+    const sourcePath = (0, import_node_path7.join)(stagingDir, "script.swift");
+    const binaryPath = (0, import_node_path7.join)(stagingDir, "script");
     (0, import_node_fs4.writeFileSync)(sourcePath, options.source);
     await execFileAsync(`${options.swiftBinary}c`, ["-swift-version", swiftVersion, "-O", "-o", binaryPath, sourcePath], {
       timeout: options.timeoutMs || SWIFT_SCRIPT_COMPILE_TIMEOUT_MS
@@ -27115,6 +29713,48 @@ relayHostClient = createTraversalRelayHostClient({
   }),
   listTerminalSessionCatalog
 });
+async function startAppMessagingGateway() {
+  const appMessagingRuntime = createDaemonAppMessagingRuntime({
+    appRootDir: WTERM_HOME_DIR,
+    deviceId: DAEMON_CONFIG.deviceId,
+    daemonHostId: DAEMON_CONFIG.daemonHostId
+  });
+  await appMessagingRuntime.initialize().catch((error) => {
+    console.error(
+      `[${logTimePrefix()}] app messaging initialization failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  });
+  let appGateway = null;
+  try {
+    appGateway = createDaemonAppGateway({
+      requiredAuthToken: REQUIRED_AUTH_TOKEN,
+      daemonHostId: DAEMON_CONFIG.daemonHostId,
+      deviceId: DAEMON_CONFIG.deviceId,
+      messaging: appMessagingRuntime,
+      log: (message) => console.warn(`[${logTimePrefix()}] ${message}`)
+    });
+  } catch (error) {
+    console.error(
+      `[${logTimePrefix()}] app messaging gateway unavailable: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  server.on("upgrade", (request, socket, head) => {
+    if (appGateway?.handleServerUpgrade(request, socket, head)) return;
+    handleServerUpgrade(request, socket, head);
+  });
+  server.on("close", () => {
+    appGateway?.dispose();
+    appMessagingRuntime.dispose();
+  });
+  server.listen(PORT, HOST, () => {
+    handleDaemonServerListening();
+  });
+}
+void startAppMessagingGateway().catch((error) => {
+  console.error(
+    `[${logTimePrefix()}] app messaging gateway startup failed: ${error instanceof Error ? error.message : String(error)}`
+  );
+});
 wss.on("connection", handleWebSocketConnection);
 startHeartbeatLoop();
 startMemoryGuardLoop();
@@ -27133,10 +29773,6 @@ wss.on("close", () => {
 server.on("error", (error) => {
   handleDaemonServerError(error);
 });
-server.on("upgrade", handleServerUpgrade);
-server.listen(PORT, HOST, () => {
-  handleDaemonServerListening();
-});
 process.on("SIGINT", () => shutdownDaemon("SIGINT", 0));
 process.on("SIGTERM", () => shutdownDaemon("SIGTERM", 0));
 process.on("SIGHUP", () => shutdownDaemon("SIGHUP", 0));