codetrellis 0.0.0-stage → 0.3.0

package/src/backend/services/remote-interaction-service.js

@@ -0,0 +1,275 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var remote_interaction_service_exports = {};
+__export(remote_interaction_service_exports, {
+  broadcastAgentSessions: () => broadcastAgentSessions,
+  broadcastChannelEvent: () => broadcastChannelEvent,
+  broadcastChannelResolved: () => broadcastChannelResolved,
+  broadcastInputRequest: () => broadcastInputRequest,
+  getPendingInputRequest: () => getPendingInputRequest,
+  getPendingInputRequests: () => getPendingInputRequests,
+  isRemoteInteractionRunning: () => isRemoteInteractionRunning,
+  onRemoteChannelEvent: () => onRemoteChannelEvent,
+  onRemoteInteractionEvent: () => onRemoteInteractionEvent,
+  respondToInputRequest: () => respondToInputRequest,
+  startRemoteInteraction: () => startRemoteInteraction,
+  stopRemoteInteraction: () => stopRemoteInteraction
+});
+module.exports = __toCommonJS(remote_interaction_service_exports);
+var _lazy___push_notification_service = __toESM(require("./push-notification-service"));
+var import_types = require("../../shared/types");
+var import_webrtc_service = require("./webrtc-service");
+var sessionService = __toESM(require("./session-service"));
+let running = false;
+let instanceId = "";
+let unsubMessage = null;
+let unsubConnection = null;
+const pendingInputRequests = /* @__PURE__ */ new Map();
+const eventListeners = /* @__PURE__ */ new Set();
+const channelEventListeners = /* @__PURE__ */ new Set();
+function startRemoteInteraction(myInstanceId) {
+  if (running) return;
+  running = true;
+  instanceId = myInstanceId;
+  unsubMessage = (0, import_webrtc_service.onChannelMessage)(import_types.DATA_CHANNELS.CONTROL, handleControlMessage);
+  unsubConnection = (0, import_webrtc_service.onConnectionStateChange)((fingerprint, state) => {
+    if (state === "connected") {
+      sendAgentSessions(fingerprint);
+    } else if (state === "disconnected" || state === "failed") {
+      for (const [id, req] of pendingInputRequests) {
+        if (req.peerFingerprint === fingerprint) {
+          pendingInputRequests.delete(id);
+        }
+      }
+    }
+  });
+  console.log("[RemoteInteraction] Started");
+}
+function stopRemoteInteraction() {
+  if (!running) return;
+  running = false;
+  if (unsubMessage) {
+    unsubMessage();
+    unsubMessage = null;
+  }
+  if (unsubConnection) {
+    unsubConnection();
+    unsubConnection = null;
+  }
+  pendingInputRequests.clear();
+  console.log("[RemoteInteraction] Stopped");
+}
+function broadcastChannelEvent(eventData) {
+  if (!running) return;
+  const msg = {
+    method: "channel-event",
+    params: eventData,
+    sourceInstanceId: instanceId
+  };
+  (0, import_webrtc_service.broadcastToAllPeers)(import_types.DATA_CHANNELS.CONTROL, JSON.stringify(msg));
+}
+function broadcastChannelResolved(eventUid, status) {
+  if (!running) return;
+  const msg = {
+    method: "channel-resolved",
+    params: { uid: eventUid, status },
+    sourceInstanceId: instanceId
+  };
+  (0, import_webrtc_service.broadcastToAllPeers)(import_types.DATA_CHANNELS.CONTROL, JSON.stringify(msg));
+}
+function broadcastInputRequest(requestId, prompt, options, planUid, itemUid) {
+  if (!running) return;
+  const msg = {
+    method: "user-input-request",
+    params: { requestId, prompt, options, planUid, itemUid },
+    sourceInstanceId: instanceId
+  };
+  (0, import_webrtc_service.broadcastToAllPeers)(import_types.DATA_CHANNELS.CONTROL, JSON.stringify(msg));
+}
+function respondToInputRequest(requestId, response, respondedBy) {
+  const request = pendingInputRequests.get(requestId);
+  if (!request || request.answered) return false;
+  request.answered = true;
+  const msg = {
+    method: "user-input-response",
+    params: { requestId, response, respondedBy },
+    sourceInstanceId: instanceId
+  };
+  (0, import_webrtc_service.sendToPeer)(request.peerFingerprint, import_types.DATA_CHANNELS.CONTROL, JSON.stringify(msg));
+  pendingInputRequests.delete(requestId);
+  return true;
+}
+function broadcastAgentSessions() {
+  if (!running) return;
+  const sessions = sessionService.getActiveSessions().map((s) => ({
+    sessionId: s.sessionId,
+    agentType: s.agentType,
+    model: s.model ?? "",
+    activePlanUid: s.activePlanUid ?? null,
+    lastSeen: s.lastSeen
+  }));
+  const msg = {
+    method: "agent-sessions",
+    params: { sessions },
+    sourceInstanceId: instanceId
+  };
+  (0, import_webrtc_service.broadcastToAllPeers)(import_types.DATA_CHANNELS.CONTROL, JSON.stringify(msg));
+}
+function getPendingInputRequests() {
+  return Array.from(pendingInputRequests.values()).filter((r) => !r.answered);
+}
+function getPendingInputRequest(requestId) {
+  return pendingInputRequests.get(requestId) ?? null;
+}
+function onRemoteChannelEvent(cb) {
+  channelEventListeners.add(cb);
+  return () => {
+    channelEventListeners.delete(cb);
+  };
+}
+function onRemoteInteractionEvent(cb) {
+  eventListeners.add(cb);
+  return () => {
+    eventListeners.delete(cb);
+  };
+}
+function isRemoteInteractionRunning() {
+  return running;
+}
+function sendAgentSessions(fingerprint) {
+  const sessions = sessionService.getActiveSessions().map((s) => ({
+    sessionId: s.sessionId,
+    agentType: s.agentType,
+    model: s.model ?? "",
+    activePlanUid: s.activePlanUid ?? null,
+    lastSeen: s.lastSeen
+  }));
+  const msg = {
+    method: "agent-sessions",
+    params: { sessions },
+    sourceInstanceId: instanceId
+  };
+  (0, import_webrtc_service.sendToPeer)(fingerprint, import_types.DATA_CHANNELS.CONTROL, JSON.stringify(msg));
+}
+function handleControlMessage(fingerprint, data) {
+  try {
+    const text = typeof data === "string" ? data : data.toString("utf-8");
+    const msg = JSON.parse(text);
+    if (msg.sourceInstanceId === instanceId) return;
+    if (msg.method === "ping" || msg.method === "pong") return;
+    if (msg.type === "ping" || msg.type === "pong") return;
+    switch (msg.method) {
+      case "channel-event": {
+        for (const cb of channelEventListeners) {
+          try {
+            cb(msg.params);
+          } catch {
+          }
+        }
+        emitEvent("remote-channel-event", { fingerprint, event: msg.params });
+        break;
+      }
+      case "channel-resolved": {
+        emitEvent("remote-channel-resolved", { fingerprint, ...msg.params });
+        break;
+      }
+      case "user-input-request": {
+        const { requestId, prompt, options, planUid, itemUid } = msg.params;
+        if (requestId && prompt) {
+          const request = {
+            requestId,
+            peerFingerprint: fingerprint,
+            prompt,
+            options,
+            planUid,
+            itemUid,
+            receivedAt: Date.now(),
+            answered: false
+          };
+          pendingInputRequests.set(requestId, request);
+          emitEvent("remote-input-request", request);
+        }
+        break;
+      }
+      case "user-input-response": {
+        const { requestId, response, respondedBy } = msg.params;
+        const by = respondedBy && typeof respondedBy.actorType === "string" ? respondedBy : { actorType: "unknown" };
+        emitEvent("remote-input-response", { requestId, response, fingerprint, respondedBy: by });
+        break;
+      }
+      case "agent-sessions": {
+        const { sessions } = msg.params;
+        emitEvent("remote-agent-sessions", { fingerprint, sessions });
+        break;
+      }
+      case "register-push-token": {
+        const { token } = msg.params;
+        if (token) {
+          const { registerPushToken } = _lazy___push_notification_service;
+          registerPushToken(fingerprint, token);
+          try {
+            (0, import_webrtc_service.sendToPeer)(
+              fingerprint,
+              import_types.DATA_CHANNELS.CONTROL,
+              JSON.stringify({ method: "push-token-ack", params: { ok: true } })
+            );
+          } catch {
+          }
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  } catch (err) {
+    console.warn("[RemoteInteraction] Invalid control message:", err);
+  }
+}
+function emitEvent(event, data) {
+  for (const cb of eventListeners) {
+    try {
+      cb(event, data);
+    } catch {
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  broadcastAgentSessions,
+  broadcastChannelEvent,
+  broadcastChannelResolved,
+  broadcastInputRequest,
+  getPendingInputRequest,
+  getPendingInputRequests,
+  isRemoteInteractionRunning,
+  onRemoteChannelEvent,
+  onRemoteInteractionEvent,
+  respondToInputRequest,
+  startRemoteInteraction,
+  stopRemoteInteraction
+});

package/src/backend/services/remote-terminal-service.js

@@ -0,0 +1,324 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var remote_terminal_service_exports = {};
+__export(remote_terminal_service_exports, {
+  getRemoteTerminals: () => getRemoteTerminals,
+  getRemoteTerminalsForPeer: () => getRemoteTerminalsForPeer,
+  isRemoteTerminalRunning: () => isRemoteTerminalRunning,
+  onRemoteTerminalEvent: () => onRemoteTerminalEvent,
+  resizeRemoteTerminal: () => resizeRemoteTerminal,
+  startRemoteTerminals: () => startRemoteTerminals,
+  stopRemoteTerminals: () => stopRemoteTerminals,
+  writeRemoteTerminal: () => writeRemoteTerminal
+});
+module.exports = __toCommonJS(remote_terminal_service_exports);
+var import_types = require("../../shared/types");
+var import_webrtc_service = require("./webrtc-service");
+var import_paired_device_service = require("./paired-device-service");
+var import_peer_grants = require("./peer-grants");
+var import_peer_audit_service = require("./peer-audit-service");
+var import_terminal_service = require("./terminal-service");
+const MSG = {
+  TERMINAL_LIST: 1,
+  TERMINAL_OUTPUT: 2,
+  TERMINAL_INPUT: 3,
+  TERMINAL_CREATED: 4,
+  TERMINAL_EXITED: 5,
+  TERMINAL_RESIZED: 6
+};
+let running = false;
+let unsubMessage = null;
+let unsubConnection = null;
+let unsubTerminalData = null;
+let unsubTerminalExit = null;
+let unsubGrants = null;
+const remoteTerminals = /* @__PURE__ */ new Map();
+const remoteTerminalListeners = /* @__PURE__ */ new Set();
+let localTerminalIds = [];
+function mayUseTerminals(fingerprint) {
+  return (0, import_peer_grants.peerHolds)(fingerprint, "terminal");
+}
+function sendToTerminalPeers(payload) {
+  for (const peer of (0, import_webrtc_service.getPeerConnections)()) {
+    if (peer.state === "connected" && mayUseTerminals(peer.fingerprint)) {
+      (0, import_webrtc_service.sendToPeer)(peer.fingerprint, import_types.DATA_CHANNELS.TERMINAL, payload);
+    }
+  }
+}
+const lastInputAudit = /* @__PURE__ */ new Map();
+function auditRelay(fingerprint, kind, method, terminalId) {
+  if (kind === "terminal-access") {
+    const key = `${fingerprint}|${terminalId}`;
+    const last = lastInputAudit.get(key) ?? 0;
+    if (Date.now() - last < 6e4) return;
+    lastInputAudit.set(key, Date.now());
+  }
+  (0, import_peer_audit_service.recordPeerAudit)({
+    kind,
+    fingerprint,
+    alias: (0, import_paired_device_service.getPairedDevice)(fingerprint)?.alias ?? "unknown device",
+    method,
+    detail: kind === "refused" ? "terminal relay: no terminal grant on a confirmed pairing" : `terminal relay: ${terminalId ?? "unknown terminal"}`
+  });
+}
+function startRemoteTerminals() {
+  if (running) return;
+  running = true;
+  unsubMessage = (0, import_webrtc_service.onChannelMessage)(import_types.DATA_CHANNELS.TERMINAL, handleTerminalMessage);
+  unsubConnection = (0, import_webrtc_service.onConnectionStateChange)((fingerprint, state) => {
+    if (state === "connected" && mayUseTerminals(fingerprint)) {
+      sendTerminalList(fingerprint);
+      sendTerminalSnapshots(fingerprint);
+    } else if (state === "disconnected" || state === "failed") {
+      remoteTerminals.delete(fingerprint);
+      emitEvent("remote-terminals-changed", { fingerprint });
+    }
+  });
+  unsubGrants = (0, import_paired_device_service.onDeviceGrantsChanged)((fingerprint, added) => {
+    if (added.includes("terminal") && mayUseTerminals(fingerprint)) {
+      sendTerminalList(fingerprint);
+      sendTerminalSnapshots(fingerprint);
+    }
+  });
+  unsubTerminalData = (0, import_terminal_service.onTerminalData)((id, data) => {
+    const idx = localTerminalIds.indexOf(id);
+    if (idx < 0) {
+      refreshLocalTerminalList();
+      broadcastTerminalList();
+      return;
+    }
+    const payload = Buffer.alloc(2 + Buffer.byteLength(data, "utf-8"));
+    payload[0] = MSG.TERMINAL_OUTPUT;
+    payload[1] = idx;
+    payload.write(data, 2, "utf-8");
+    sendToTerminalPeers(payload);
+  });
+  unsubTerminalExit = (0, import_terminal_service.onTerminalExit)((id, exitCode) => {
+    const msg = Buffer.from(
+      String.fromCharCode(MSG.TERMINAL_EXITED) + JSON.stringify({ id, exitCode })
+    );
+    sendToTerminalPeers(msg);
+    refreshLocalTerminalList();
+    broadcastTerminalList();
+  });
+  console.log("[RemoteTerminal] Started");
+}
+function stopRemoteTerminals() {
+  if (!running) return;
+  running = false;
+  if (unsubMessage) {
+    unsubMessage();
+    unsubMessage = null;
+  }
+  if (unsubConnection) {
+    unsubConnection();
+    unsubConnection = null;
+  }
+  if (unsubTerminalData) {
+    unsubTerminalData();
+    unsubTerminalData = null;
+  }
+  if (unsubTerminalExit) {
+    unsubTerminalExit();
+    unsubTerminalExit = null;
+  }
+  if (unsubGrants) {
+    unsubGrants();
+    unsubGrants = null;
+  }
+  remoteTerminals.clear();
+  localTerminalIds = [];
+  console.log("[RemoteTerminal] Stopped");
+}
+function getRemoteTerminals() {
+  const result = [];
+  for (const terminals of remoteTerminals.values()) {
+    result.push(...terminals);
+  }
+  return result;
+}
+function getRemoteTerminalsForPeer(fingerprint) {
+  return remoteTerminals.get(fingerprint) ?? [];
+}
+function writeRemoteTerminal(fingerprint, terminalId, data) {
+  const terminals = remoteTerminals.get(fingerprint);
+  if (!terminals) return false;
+  const terminal = terminals.find((t) => t.id === terminalId);
+  if (!terminal) return false;
+  const payload = Buffer.alloc(2 + Buffer.byteLength(data, "utf-8"));
+  payload[0] = MSG.TERMINAL_INPUT;
+  payload[1] = terminal.index;
+  payload.write(data, 2, "utf-8");
+  return (0, import_webrtc_service.sendToPeer)(fingerprint, import_types.DATA_CHANNELS.TERMINAL, payload);
+}
+function resizeRemoteTerminal(fingerprint, terminalId, cols, rows) {
+  const msg = Buffer.from(
+    String.fromCharCode(MSG.TERMINAL_RESIZED) + JSON.stringify({ id: terminalId, cols, rows })
+  );
+  return (0, import_webrtc_service.sendToPeer)(fingerprint, import_types.DATA_CHANNELS.TERMINAL, msg);
+}
+function onRemoteTerminalEvent(cb) {
+  remoteTerminalListeners.add(cb);
+  return () => {
+    remoteTerminalListeners.delete(cb);
+  };
+}
+function isRemoteTerminalRunning() {
+  return running;
+}
+function refreshLocalTerminalList() {
+  localTerminalIds = (0, import_terminal_service.listTerminals)().map((t) => t.id);
+}
+function broadcastTerminalList() {
+  const terminals = (0, import_terminal_service.listTerminals)();
+  localTerminalIds = terminals.map((t) => t.id);
+  const list = terminals.map((t, i) => ({
+    id: t.id,
+    preset: t.preset,
+    title: t.title,
+    cwd: t.cwd,
+    alive: t.alive,
+    index: i
+  }));
+  const msg = Buffer.from(
+    String.fromCharCode(MSG.TERMINAL_LIST) + JSON.stringify(list)
+  );
+  sendToTerminalPeers(msg);
+}
+function sendTerminalSnapshots(fingerprint) {
+  const terminals = (0, import_terminal_service.listTerminals)();
+  localTerminalIds = terminals.map((t) => t.id);
+  const SCREEN_RESET = "\x1B[2J\x1B[H";
+  for (let i = 0; i < terminals.length; i++) {
+    const t = terminals[i];
+    if (!t.alive) continue;
+    const delta = (0, import_terminal_service.readTerminalDelta)(t.id);
+    if (delta === null || delta.data.length === 0) continue;
+    const data = SCREEN_RESET + delta.data;
+    const payload = Buffer.alloc(2 + Buffer.byteLength(data, "utf-8"));
+    payload[0] = MSG.TERMINAL_OUTPUT;
+    payload[1] = i;
+    payload.write(data, 2, "utf-8");
+    (0, import_webrtc_service.sendToPeer)(fingerprint, import_types.DATA_CHANNELS.TERMINAL, payload);
+  }
+}
+function sendTerminalList(fingerprint) {
+  const terminals = (0, import_terminal_service.listTerminals)();
+  localTerminalIds = terminals.map((t) => t.id);
+  const list = terminals.map((t, i) => ({
+    id: t.id,
+    preset: t.preset,
+    title: t.title,
+    cwd: t.cwd,
+    alive: t.alive,
+    index: i
+  }));
+  const msg = Buffer.from(
+    String.fromCharCode(MSG.TERMINAL_LIST) + JSON.stringify(list)
+  );
+  (0, import_webrtc_service.sendToPeer)(fingerprint, import_types.DATA_CHANNELS.TERMINAL, msg);
+}
+function handleTerminalMessage(fingerprint, data) {
+  try {
+    const buf = typeof data === "string" ? Buffer.from(data, "utf-8") : data;
+    if (buf.length < 1) return;
+    const msgType = buf[0];
+    switch (msgType) {
+      case MSG.TERMINAL_LIST: {
+        const json = buf.slice(1).toString("utf-8");
+        const list = JSON.parse(json);
+        const terminals = list.map((t) => ({
+          ...t,
+          peerFingerprint: fingerprint,
+          peerAlias: ""
+          // filled in by the UI from the paired device record
+        }));
+        remoteTerminals.set(fingerprint, terminals);
+        emitEvent("remote-terminals-changed", { fingerprint, terminals });
+        break;
+      }
+      case MSG.TERMINAL_OUTPUT: {
+        if (buf.length < 3) return;
+        const idx = buf[1];
+        const output = buf.slice(2).toString("utf-8");
+        emitEvent("remote-terminal-output", { fingerprint, index: idx, data: output });
+        break;
+      }
+      case MSG.TERMINAL_INPUT: {
+        if (buf.length < 3) return;
+        const idx = buf[1];
+        const input = buf.slice(2).toString("utf-8");
+        const terminalId = localTerminalIds[idx];
+        if (!mayUseTerminals(fingerprint)) {
+          auditRelay(fingerprint, "refused", "terminal-relay.input", terminalId ?? null);
+          return;
+        }
+        if (terminalId) {
+          auditRelay(fingerprint, "terminal-access", "terminal-relay.input", terminalId);
+          (0, import_terminal_service.writeTerminal)(terminalId, input);
+        }
+        break;
+      }
+      case MSG.TERMINAL_CREATED: {
+        const json = buf.slice(1).toString("utf-8");
+        const info = JSON.parse(json);
+        emitEvent("remote-terminal-created", { fingerprint, ...info });
+        break;
+      }
+      case MSG.TERMINAL_EXITED: {
+        const json = buf.slice(1).toString("utf-8");
+        const info = JSON.parse(json);
+        emitEvent("remote-terminal-exited", { fingerprint, ...info });
+        break;
+      }
+      case MSG.TERMINAL_RESIZED: {
+        const json = buf.slice(1).toString("utf-8");
+        const { id, cols, rows } = JSON.parse(json);
+        if (!mayUseTerminals(fingerprint)) {
+          auditRelay(fingerprint, "refused", "terminal-relay.resize", typeof id === "string" ? id : null);
+          return;
+        }
+        if (id && Number.isInteger(cols) && Number.isInteger(rows) && cols > 0 && rows > 0 && cols <= 500 && rows <= 300) {
+          (0, import_terminal_service.resizeTerminal)(id, cols, rows);
+        }
+        break;
+      }
+    }
+  } catch (err) {
+    console.warn("[RemoteTerminal] Invalid message:", err);
+  }
+}
+function emitEvent(event, data) {
+  for (const cb of remoteTerminalListeners) {
+    try {
+      cb(event, data);
+    } catch {
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRemoteTerminals,
+  getRemoteTerminalsForPeer,
+  isRemoteTerminalRunning,
+  onRemoteTerminalEvent,
+  resizeRemoteTerminal,
+  startRemoteTerminals,
+  stopRemoteTerminals,
+  writeRemoteTerminal
+});

package/src/backend/services/rendition/child/main.js

@@ -0,0 +1,76 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_module = __toESM(require("node:module"));
+const REFUSED = /* @__PURE__ */ new Set([
+  "net",
+  "tls",
+  "http",
+  "https",
+  "http2",
+  "dns",
+  "dgram",
+  "child_process",
+  "cluster",
+  "inspector"
+]);
+function lockDown() {
+  const mod = import_node_module.default;
+  const load = mod._load;
+  mod._load = function(request, ...rest) {
+    if (REFUSED.has(request.replace(/^node:/, ""))) {
+      throw new Error(`The conversion engine may not load ${request}`);
+    }
+    return load.call(this, request, ...rest);
+  };
+  for (const name of ["fetch", "WebSocket", "EventSource", "XMLHttpRequest"]) {
+    try {
+      delete globalThis[name];
+    } catch {
+    }
+  }
+}
+async function main() {
+  const dir = process.argv[2];
+  if (!dir || !process.send) throw new Error("engine-child: no engine directory, or no IPC channel");
+  const manifest = JSON.parse(import_node_fs.default.readFileSync(import_node_path.default.join(dir, "engine.json"), "utf-8"));
+  lockDown();
+  const adapter = import_node_module.default.createRequire(import_node_path.default.join(dir, "engine.json"))(import_node_path.default.join(dir, manifest.adapter));
+  const engine = await adapter.create({ dir });
+  process.on("message", (raw) => {
+    const msg = raw;
+    if (msg?.type !== "convert") return;
+    engine.convert(msg.bytes, msg.ext).then(
+      (pdf) => process.send?.({ type: "result", id: msg.id, pdf }),
+      (err) => process.send?.({ type: "error", id: msg.id, message: err instanceof Error ? err.message : String(err) })
+    );
+  });
+  process.on("disconnect", () => process.exit(0));
+  process.send({ type: "ready", version: manifest.version });
+}
+main().catch((err) => {
+  process.stderr.write(`engine-child: ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(1);
+});