@askexenow/exe-os 0.9.127 → 0.9.129

package/dist/chunk-MILTNDZH.js

@@ -0,0 +1,736 @@
+import {
+  MultiAgentOrchestrator
+} from "./chunk-L4X5EUHR.js";
+import {
+  createQuietRenderer,
+  createTerminalRenderer,
+  renderAgentEvents
+} from "./chunk-YZFZDJWZ.js";
+import {
+  checkPathSafety,
+  checkReadPathSafety,
+  containsPathTraversal
+} from "./chunk-NGVOA6ZQ.js";
+import {
+  checkDangerousPatterns,
+  hasCriticalPattern
+} from "./chunk-AVE2B4DQ.js";
+import {
+  ContextManager,
+  agentLoop,
+  compactMessages,
+  createContextManager,
+  createDenialTrackingState,
+  estimateTokens,
+  getContextLimit,
+  needsCompaction,
+  recordDenial,
+  recordSuccess,
+  shouldFallbackToAsk
+} from "./chunk-AJWFPKQS.js";
+import {
+  ToolRegistry,
+  partitionTools,
+  zodToJsonSchema
+} from "./chunk-JQ6TLNIV.js";
+import {
+  composeHooks,
+  createDefaultHooks
+} from "./chunk-O377P7GM.js";
+import {
+  EMPLOYEE_PERMISSIONS,
+  checkPermission,
+  createPermissionsFromPreset,
+  createRestrictedPermissions
+} from "./chunk-PRKVT4KN.js";
+import {
+  PERMISSION_PRESETS,
+  evaluatePermission,
+  getPresetByRole,
+  matchInputPattern,
+  matchToolPattern
+} from "./chunk-HF25XPZE.js";
+import {
+  StateBus,
+  init_state_bus,
+  orgBus
+} from "./chunk-WZQ4CPRG.js";
+import {
+  __export
+} from "./chunk-KFQGP6VL.js";
+
+// src/runtime/index.ts
+var runtime_exports = {};
+__export(runtime_exports, {
+  ContextManager: () => ContextManager,
+  EMPLOYEE_PERMISSIONS: () => EMPLOYEE_PERMISSIONS,
+  IPCServer: () => IPCServer,
+  MultiAgentOrchestrator: () => MultiAgentOrchestrator,
+  PERMISSION_PRESETS: () => PERMISSION_PRESETS,
+  SessionManager: () => SessionManager,
+  StateBus: () => StateBus,
+  ToolRegistry: () => ToolRegistry,
+  agentLoop: () => agentLoop,
+  checkDangerousPatterns: () => checkDangerousPatterns,
+  checkGitSafety: () => checkGitSafety,
+  checkPathSafety: () => checkPathSafety,
+  checkPermission: () => checkPermission,
+  checkReadPathSafety: () => checkReadPathSafety,
+  compactMessages: () => compactMessages,
+  composeHooks: () => composeHooks,
+  containsPathTraversal: () => containsPathTraversal,
+  createContextManager: () => createContextManager,
+  createDefaultHooks: () => createDefaultHooks,
+  createDenialTrackingState: () => createDenialTrackingState,
+  createPermissionsFromPreset: () => createPermissionsFromPreset,
+  createQuietRenderer: () => createQuietRenderer,
+  createRestrictedPermissions: () => createRestrictedPermissions,
+  createTerminalRenderer: () => createTerminalRenderer,
+  estimateTokens: () => estimateTokens,
+  evaluatePermission: () => evaluatePermission,
+  getContextLimit: () => getContextLimit,
+  getPresetByRole: () => getPresetByRole,
+  hasCriticalPattern: () => hasCriticalPattern,
+  matchInputPattern: () => matchInputPattern,
+  matchToolPattern: () => matchToolPattern,
+  needsCompaction: () => needsCompaction,
+  orgBus: () => orgBus,
+  partitionTools: () => partitionTools,
+  recordDenial: () => recordDenial,
+  recordSuccess: () => recordSuccess,
+  renderAgentEvents: () => renderAgentEvents,
+  shouldFallbackToAsk: () => shouldFallbackToAsk,
+  targetsMainBranch: () => targetsMainBranch,
+  zodToJsonSchema: () => zodToJsonSchema
+});
+
+// src/runtime/git-safety.ts
+var GIT_DANGEROUS_PATTERNS = [
+  // Force push to main/master — critical (must be before general force push)
+  {
+    regex: /\bgit\s+push\s+.*--force.*\b(main|master)\b/,
+    severity: "critical",
+    reason: "Force push to main/master \u2014 this can destroy shared history"
+  },
+  // Force push (any branch)
+  {
+    regex: /\bgit\s+push\s+.*--force\b/,
+    severity: "warning",
+    reason: "Force push can overwrite remote history"
+  },
+  {
+    regex: /\bgit\s+push\s+-f\b/,
+    severity: "warning",
+    reason: "Force push (-f) can overwrite remote history"
+  },
+  // Hard reset
+  {
+    regex: /\bgit\s+reset\s+--hard\b/,
+    severity: "warning",
+    reason: "Hard reset discards all uncommitted changes permanently"
+  },
+  // Clean with force
+  {
+    regex: /\bgit\s+clean\s+-[a-zA-Z]*f/,
+    severity: "warning",
+    reason: "Git clean -f permanently removes untracked files"
+  },
+  // Delete branch with force
+  {
+    regex: /\bgit\s+branch\s+-D\b/,
+    severity: "warning",
+    reason: "Force delete branch (uppercase -D) skips merge check"
+  },
+  // Checkout . (discard all changes)
+  {
+    regex: /\bgit\s+checkout\s+\.\s*$/,
+    severity: "warning",
+    reason: "Discards all uncommitted changes in working directory"
+  },
+  // Restore . (discard all changes)
+  {
+    regex: /\bgit\s+restore\s+\.\s*$/,
+    severity: "warning",
+    reason: "Restores all files, discarding uncommitted changes"
+  },
+  // No-verify (skip hooks)
+  {
+    regex: /\bgit\s+(commit|push)\s+.*--no-verify\b/,
+    severity: "warning",
+    reason: "Skipping git hooks (--no-verify) bypasses safety checks"
+  },
+  // Rebase with drop
+  {
+    regex: /\bgit\s+rebase\s+-i\b/,
+    severity: "warning",
+    reason: "Interactive rebase can rewrite commit history"
+  },
+  // Amend published commits
+  {
+    regex: /\bgit\s+commit\s+.*--amend\b/,
+    severity: "warning",
+    reason: "Amending commits rewrites history \u2014 dangerous if already pushed"
+  }
+];
+function checkGitSafety(command) {
+  for (const pattern of GIT_DANGEROUS_PATTERNS) {
+    if (pattern.regex.test(command)) {
+      return {
+        safe: false,
+        severity: pattern.severity,
+        reason: pattern.reason
+      };
+    }
+  }
+  return { safe: true, severity: "info" };
+}
+function targetsMainBranch(command) {
+  return /\b(main|master)\b/.test(command) && /\bgit\s+(push|rebase|reset)\b/.test(command);
+}
+
+// src/runtime/index.ts
+init_state_bus();
+
+// src/runtime/session-manager.ts
+import { randomUUID as randomUUID2 } from "crypto";
+init_state_bus();
+
+// src/runtime/exe-hooks.ts
+import { randomUUID } from "crypto";
+function createExeOSHooks(config) {
+  let sessionRegistered = false;
+  return {
+    async onSessionStart(context) {
+      try {
+        const { initStore } = await import("./lib/store.js");
+        await initStore();
+      } catch (err) {
+        process.stderr.write(
+          `[exe-hooks] store init failed: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      }
+      try {
+        const { listBehaviors } = await import("./behaviors-CSB2YLDT.js");
+        const behaviors = await listBehaviors(config.agentId, config.projectName, 12);
+        if (behaviors.length > 0) {
+          process.stderr.write(
+            `[exe-hooks] Loaded ${behaviors.length} behaviors for ${config.agentId}
+`
+          );
+        }
+      } catch (err) {
+        process.stderr.write(
+          `[exe-hooks] behavior load failed: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      }
+      try {
+        const { registerSession } = await import("./lib/session-registry.js");
+        registerSession({
+          windowName: `api-${config.agentId}-${Date.now()}`,
+          agentId: config.agentId,
+          projectDir: context.cwd,
+          parentExe: null,
+          pid: process.pid,
+          registeredAt: context.startedAt
+        });
+        sessionRegistered = true;
+      } catch (err) {
+        process.stderr.write(
+          `[exe-hooks] session register failed: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      }
+    },
+    async afterToolUse(block, result, _context) {
+      if (block.type !== "tool_use") return;
+      const toolName = block.name ?? "unknown";
+      const ALLOWED_RE = /^(Bash|Edit|Write|Read|Glob|Grep|Agent|mcp__.*)$/;
+      if (!ALLOWED_RE.test(toolName)) return;
+      try {
+        const { extractSemanticText } = await import("./content-extractor-UVZXRIPC.js");
+        const { writeMemory } = await import("./lib/store.js");
+        const toolInput = block.input ?? {};
+        const toolResponse = result.isError ? { error: result.content } : { output: result.content };
+        const rawText = extractSemanticText(toolName, toolInput, toolResponse);
+        await writeMemory({
+          id: randomUUID(),
+          agent_id: config.agentId,
+          agent_role: "employee",
+          session_id: `api-${config.agentId}`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          tool_name: toolName,
+          project_name: config.projectName,
+          has_error: result.isError ?? false,
+          raw_text: rawText,
+          vector: null
+        });
+      } catch (err) {
+        process.stderr.write(
+          `[exe-hooks] memory ingest failed for ${toolName}: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      }
+    },
+    async onSessionEnd(_context, summary) {
+      try {
+        const { writeMemory } = await import("./lib/store.js");
+        await writeMemory({
+          id: randomUUID(),
+          agent_id: config.agentId,
+          agent_role: "employee",
+          session_id: `api-${config.agentId}`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          tool_name: "SessionEnd",
+          project_name: config.projectName,
+          has_error: false,
+          raw_text: [
+            "CONTEXT CHECKPOINT [auto:session-end]",
+            `Agent: ${config.agentId}`,
+            `Project: ${config.projectName}`,
+            `Time: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+            "",
+            "## Runtime Summary",
+            summary || "Session ended. No runtime summary was provided."
+          ].join("\n"),
+          vector: null,
+          importance: 8,
+          memory_type: "checkpoint"
+        });
+      } catch (err) {
+        process.stderr.write(
+          `[exe-hooks] session summary store failed: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      }
+      if (sessionRegistered) {
+        try {
+          const { pruneStaleSessions } = await import("./lib/session-registry.js");
+          pruneStaleSessions();
+        } catch {
+        }
+      }
+    },
+    async onError(error, _context) {
+      try {
+        const { classifyError } = await import("./lib/error-detector.js");
+        const classification = classifyError(error.message);
+        process.stderr.write(
+          `[exe-hooks] Error (${classification}): ${error.message.slice(0, 100)}
+`
+        );
+      } catch {
+      }
+    },
+    async onPostCompact(removedMessages, _injectedSummary) {
+      process.stderr.write(
+        `[exe-hooks] Post-compact: ${removedMessages} messages removed for ${config.agentId}
+`
+      );
+    },
+    async onSubagentStop(_reason) {
+      try {
+        const { getClient } = await import("./lib/database.js");
+        const { sessionScopeFilter } = await import("./task-scope-MUU4KXE6.js");
+        const client = getClient();
+        const ehScope = sessionScopeFilter();
+        const tasks = await client.execute({
+          sql: `SELECT title, status FROM tasks
+                WHERE assigned_to = ? AND status IN ('open', 'in_progress')${ehScope.sql}
+                LIMIT 5`,
+          args: [config.agentId, ...ehScope.args]
+        });
+        if (tasks.rows.length > 0) {
+          const titles = tasks.rows.map((r) => `"${String(r.title)}" (${String(r.status)})`).join(", ");
+          return {
+            block: true,
+            message: `Cannot stop: ${tasks.rows.length} uncompleted task(s): ${titles}. Complete or mark blocked first.`
+          };
+        }
+      } catch {
+      }
+      return { block: false };
+    },
+    async onNotification(message) {
+      try {
+        const { getClient } = await import("./lib/database.js");
+        const client = getClient();
+        await client.execute({
+          sql: `INSERT OR IGNORE INTO notifications (id, type, source_agent, message, task_file, created_at, read)
+                VALUES (?, 'system', ?, ?, NULL, ?, 0)`,
+          args: [randomUUID(), config.agentId, message.slice(0, 500), (/* @__PURE__ */ new Date()).toISOString()]
+        });
+      } catch {
+      }
+    },
+    async onPermissionRequest(toolName) {
+      const readOnlyTools = /^(Read|Glob|Grep)$/;
+      if (readOnlyTools.test(toolName)) {
+        return { autoApprove: true };
+      }
+      return { autoApprove: false };
+    },
+    async onTaskAssigned(event) {
+      try {
+        const { writeMemory } = await import("./lib/store.js");
+        await writeMemory({
+          id: randomUUID(),
+          agent_id: config.agentId,
+          agent_role: "employee",
+          session_id: `api-${config.agentId}`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          tool_name: "TaskAssigned",
+          project_name: event.projectName,
+          has_error: false,
+          raw_text: `Task assigned: "${event.title}" [${event.priority}] by ${event.assignedBy}`,
+          vector: null
+        });
+      } catch (err) {
+        process.stderr.write(
+          `[exe-hooks] task-assigned memory failed: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      }
+    },
+    async onReviewReceived(event) {
+      try {
+        const { writeMemory } = await import("./lib/store.js");
+        await writeMemory({
+          id: randomUUID(),
+          agent_id: config.agentId,
+          agent_role: "employee",
+          session_id: `api-${config.agentId}`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          tool_name: "ReviewReceived",
+          project_name: config.projectName,
+          has_error: false,
+          raw_text: `Review received for "${event.taskTitle}" from ${event.reviewer}: ${event.result}`,
+          vector: null
+        });
+      } catch (err) {
+        process.stderr.write(
+          `[exe-hooks] review-received memory failed: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      }
+    },
+    async onContextPressure(event) {
+      process.stderr.write(
+        `[exe-hooks] Context pressure: ${event.percentUsed}% (${event.threshold}% threshold) for ${config.agentId}
+`
+      );
+      if (event.threshold >= 90) {
+        try {
+          const { writeMemory, flushBatch } = await import("./lib/store.js");
+          const { getClient } = await import("./lib/database.js");
+          const { sessionScopeFilter: cpScopeFilter } = await import("./task-scope-MUU4KXE6.js");
+          const client = getClient();
+          const cpScope = cpScopeFilter();
+          const tasks = await client.execute({
+            sql: `SELECT title, status, task_file FROM tasks
+                  WHERE assigned_to = ? AND status IN ('open', 'in_progress')${cpScope.sql}
+                  ORDER BY priority ASC LIMIT 10`,
+            args: [config.agentId, ...cpScope.args]
+          });
+          if (tasks.rows.length > 0) {
+            const taskList = tasks.rows.map((r) => `- [${String(r.status)}] ${String(r.title)} (${String(r.task_file)})`).join("\n");
+            await writeMemory({
+              id: randomUUID(),
+              agent_id: config.agentId,
+              agent_role: "employee",
+              session_id: `api-${config.agentId}`,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              tool_name: "auto-checkpoint",
+              project_name: config.projectName,
+              has_error: false,
+              raw_text: `CONTEXT CHECKPOINT [${event.percentUsed}% pressure]: Open tasks:
+${taskList}`,
+              vector: null
+            });
+            await flushBatch();
+          }
+        } catch {
+        }
+      }
+    },
+    async onCrossAgentMessage(event) {
+      process.stderr.write(
+        `[exe-hooks] Message from ${event.fromAgent}: ${event.message.slice(0, 100)}
+`
+      );
+      try {
+        const { writeMemory } = await import("./lib/store.js");
+        await writeMemory({
+          id: randomUUID(),
+          agent_id: config.agentId,
+          agent_role: "employee",
+          session_id: `api-${config.agentId}`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          tool_name: "CrossAgentMessage",
+          project_name: config.projectName,
+          has_error: false,
+          raw_text: `Message from ${event.fromAgent}: ${event.message}`,
+          vector: null
+        });
+      } catch (err) {
+        process.stderr.write(
+          `[exe-hooks] cross-agent memory failed: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      }
+    }
+  };
+}
+
+// src/runtime/session-manager.ts
+var SessionManager = class {
+  sessions = /* @__PURE__ */ new Map();
+  eventHandlers = /* @__PURE__ */ new Set();
+  /** Start a new agent session for an employee */
+  startSession(employeeId, config) {
+    const sessionId = randomUUID2();
+    const abortController = new AbortController();
+    const session = {
+      info: {
+        sessionId,
+        employeeId,
+        model: config.model,
+        provider: config.provider.name,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        status: "active",
+        messageCount: 0
+      },
+      config: { ...config, abortController },
+      history: [],
+      abortController,
+      processing: false
+    };
+    this.sessions.set(sessionId, session);
+    orgBus.emit({
+      type: "session_started",
+      sessionId,
+      employee: employeeId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return sessionId;
+  }
+  /** Stop a session */
+  stopSession(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    session.abortController.abort();
+    session.info.status = "stopped";
+    orgBus.emit({
+      type: "session_ended",
+      sessionId,
+      employee: session.info.employeeId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  /** Send a message to an active session */
+  async sendMessage(sessionId, text) {
+    const session = this.sessions.get(sessionId);
+    if (!session || session.info.status !== "active") return;
+    if (session.processing) return;
+    session.processing = true;
+    session.info.messageCount++;
+    orgBus.emit({
+      type: "employee_status",
+      employee: session.info.employeeId,
+      status: "working",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    try {
+      const events = agentLoop(text, session.history, session.config);
+      for await (const event of events) {
+        for (const handler of this.eventHandlers) {
+          try {
+            handler(sessionId, event);
+          } catch {
+          }
+        }
+        if (event.type === "text") {
+        }
+      }
+    } catch (err) {
+      for (const handler of this.eventHandlers) {
+        try {
+          handler(sessionId, {
+            type: "error",
+            error: err instanceof Error ? err : new Error(String(err))
+          });
+        } catch {
+        }
+      }
+    } finally {
+      session.processing = false;
+      orgBus.emit({
+        type: "employee_status",
+        employee: session.info.employeeId,
+        status: "idle",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    session.history.push({ role: "user", content: text });
+  }
+  /** Get all active sessions */
+  getActiveSessions() {
+    return [...this.sessions.values()].filter((s) => s.info.status === "active").map((s) => ({ ...s.info }));
+  }
+  /** Get all sessions (including stopped) */
+  getAllSessions() {
+    return [...this.sessions.values()].map((s) => ({ ...s.info }));
+  }
+  /** Get a specific session */
+  getSession(sessionId) {
+    return this.sessions.get(sessionId)?.info;
+  }
+  /** Subscribe to events from all sessions */
+  onEvent(handler) {
+    this.eventHandlers.add(handler);
+  }
+  /** Unsubscribe */
+  offEvent(handler) {
+    this.eventHandlers.delete(handler);
+  }
+  /** Start a session with ExeOS hooks wired in */
+  startExeOSSession(employeeId, config, hookConfig) {
+    const exeHooks = createExeOSHooks(hookConfig);
+    const composedConfig = {
+      ...config,
+      hooks: composeHooks(exeHooks, config.hooks)
+    };
+    return this.startSession(employeeId, composedConfig);
+  }
+  /** Stop all sessions */
+  stopAll() {
+    for (const sessionId of this.sessions.keys()) {
+      this.stopSession(sessionId);
+    }
+  }
+};
+
+// src/runtime/ipc.ts
+import { createServer } from "http";
+import { WebSocketServer, WebSocket } from "ws";
+var PERMISSION_TIMEOUT_MS = 6e4;
+var IPCServer = class {
+  httpServer = null;
+  wss = null;
+  clients = /* @__PURE__ */ new Set();
+  commandHandler = null;
+  pendingPermissions = /* @__PURE__ */ new Map();
+  /** Start the WebSocket server */
+  async start(port) {
+    return new Promise((resolve, reject) => {
+      this.httpServer = createServer();
+      this.wss = new WebSocketServer({ server: this.httpServer });
+      this.wss.on("connection", (ws) => {
+        this.clients.add(ws);
+        ws.on("close", () => this.clients.delete(ws));
+        ws.on("message", (data) => {
+          try {
+            const cmd = JSON.parse(data.toString());
+            if (cmd.type === "permission_response") {
+              this.resolvePermission(cmd.toolCallId, cmd.decision);
+              return;
+            }
+            if (this.commandHandler) {
+              this.commandHandler(cmd, (resp) => {
+                if (ws.readyState === WebSocket.OPEN) {
+                  ws.send(JSON.stringify(resp));
+                }
+              });
+            }
+          } catch {
+            if (ws.readyState === WebSocket.OPEN) {
+              ws.send(JSON.stringify({ type: "error", message: "Invalid command" }));
+            }
+          }
+        });
+      });
+      this.httpServer.listen(port, () => {
+        resolve();
+      });
+      this.httpServer.on("error", reject);
+    });
+  }
+  /** Stop the server */
+  async stop() {
+    for (const [, pending] of this.pendingPermissions) {
+      clearTimeout(pending.timer);
+      pending.resolve("deny");
+    }
+    this.pendingPermissions.clear();
+    for (const client of this.clients) {
+      client.close();
+    }
+    this.clients.clear();
+    if (this.wss) {
+      this.wss.close();
+      this.wss = null;
+    }
+    if (this.httpServer) {
+      await new Promise((resolve) => {
+        this.httpServer.close(() => resolve());
+      });
+      this.httpServer = null;
+    }
+  }
+  /** Broadcast an agent event to all connected clients */
+  broadcastEvent(sessionId, event) {
+    const message = JSON.stringify({ type: "event", sessionId, event });
+    for (const client of this.clients) {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(message);
+      }
+    }
+  }
+  /** Register a command handler */
+  onCommand(handler) {
+    this.commandHandler = handler;
+  }
+  /**
+   * Request permission from a connected client.
+   * Broadcasts a permission_request event and waits for a permission_response command.
+   * Auto-denies after 60s timeout if no response is received.
+   */
+  requestPermission(sessionId, req) {
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this.pendingPermissions.delete(req.id);
+        resolve("deny");
+      }, PERMISSION_TIMEOUT_MS);
+      this.pendingPermissions.set(req.id, { resolve, timer });
+      this.broadcastEvent(sessionId, {
+        type: "permission_request",
+        name: req.name,
+        id: req.id,
+        description: req.description,
+        filePath: req.filePath
+      });
+    });
+  }
+  /** Resolve a pending permission request with the user's decision */
+  resolvePermission(toolCallId, decision) {
+    const pending = this.pendingPermissions.get(toolCallId);
+    if (pending) {
+      clearTimeout(pending.timer);
+      this.pendingPermissions.delete(toolCallId);
+      pending.resolve(decision);
+    }
+  }
+  /** Get connected client count */
+  get clientCount() {
+    return this.clients.size;
+  }
+};
+
+export {
+  checkGitSafety,
+  targetsMainBranch,
+  SessionManager,
+  IPCServer,
+  runtime_exports
+};