@trim21/personal-pi-extensions 0.1.654 → 0.1.655

package/src/codemode/sandbox.ts

@@ -0,0 +1,192 @@
+/**
+ * codemode 的沙箱客户端：主线程侧管理 worker 线程的一次执行与回收。
+ *
+ * 沙箱就是 QuickJS VM 本身（VM 里没有 node、文件、网络、timer），脚本唯一的出口是
+ * 注入的工具，而这些工具由主线程执行——所以这里只做三件事：把注册时编译好的 wasm
+ * 与脚本交给 worker、转发脚本的嵌套调用与输出、在结束/超时/中止时 `terminate()`。
+ *
+ * worker 一次执行一个：死循环脚本由主线程 terminate 掉，连同它那份 VM 一起丢弃，
+ * 不会污染后续执行，也不需要取消协议。
+ */
+
+import { Worker } from "node:worker_threads";
+
+import {
+  type CodemodeOutputItem,
+  decodeWorkerMessage,
+  type ScriptError,
+  type ScriptTool,
+  type StoreWrites,
+  type WorkerMessage,
+} from "./protocol.js";
+import { compileQuickJSWasm } from "./wasm.js";
+
+/** 脚本侧一次嵌套调用的记录（主线程是执行方，所以由它记录）。 */
+export interface ScriptCall {
+  name: string;
+  status: "ok" | "error";
+  durationMs: number;
+}
+
+export type SandboxCallOutcome = { ok: true; value: unknown } | { ok: false; error: string };
+
+export type SandboxOutcome = {
+  output: CodemodeOutputItem[];
+  calls: ScriptCall[];
+} & (
+  | { ok: true; value: unknown; writes: StoreWrites }
+  | { ok: false; error: ScriptError; writes: StoreWrites }
+);
+
+export interface SandboxRunOptions {
+  code: string;
+  tools: readonly ScriptTool[];
+  store: Record<string, unknown>;
+  timeoutMs: number;
+  signal?: AbortSignal;
+  /** 每次嵌套调用：由调用方执行工具并把结果回给脚本。 */
+  onCall(request: { id: number; name: string; args: unknown }): Promise<SandboxCallOutcome>;
+  /** 脚本流式产生的输出项，用于 toolcall 进度。 */
+  onOutput?(items: readonly CodemodeOutputItem[]): void;
+  /** 嵌套调用的开始与结束，用于 toolcall 进度。 */
+  onCallProgress?(event: {
+    phase: "start" | "finish";
+    name: string;
+    args?: unknown;
+    status?: string;
+  }): void;
+}
+
+export interface CodemodeSandbox {
+  run(options: SandboxRunOptions): Promise<SandboxOutcome>;
+}
+
+/** worker 入口是 esbuild 构建产物 `worker.js`（prelude 与消息类型已打进去），随仓库提交。 */
+function workerUrl(): URL {
+  return new URL("worker.js", import.meta.url);
+}
+
+const NO_WRITES: StoreWrites = { set: {}, delete: [] };
+
+/** 注册工具时调用一次：编译 wasm 并返回可复用的沙箱。 */
+export async function createCodemodeSandbox(): Promise<CodemodeSandbox> {
+  const wasm = await compileQuickJSWasm();
+  return {
+    run: (options) => runInWorker(wasm, options),
+  };
+}
+
+function runInWorker(wasm: object, options: SandboxRunOptions): Promise<SandboxOutcome> {
+  return new Promise<SandboxOutcome>((resolve) => {
+    const worker = new Worker(workerUrl(), { workerData: { wasm } });
+
+    const output: CodemodeOutputItem[] = [];
+    const calls: ScriptCall[] = [];
+    const started = new Map<number, { name: string; at: number }>();
+    let settled = false;
+    let deadline: NodeJS.Timeout | undefined;
+
+    const finish = (
+      body:
+        | { ok: true; value: unknown; writes: StoreWrites }
+        | { ok: false; error: ScriptError; writes: StoreWrites },
+    ): void => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (deadline) {
+        clearTimeout(deadline);
+      }
+      void worker.terminate();
+      resolve({ ...body, output, calls });
+    };
+
+    const fail = (message: string, kind: ScriptError["kind"] = "sandbox"): void => {
+      finish({ ok: false, error: { kind, message }, writes: NO_WRITES });
+    };
+
+    // 默认没有超时（Infinity）：setTimeout 会把 Infinity 当成 1ms，必须显式判断
+    if (Number.isFinite(options.timeoutMs)) {
+      deadline = setTimeout(() => {
+        fail(`the script exceeded its ${options.timeoutMs}ms deadline`, "timeout");
+      }, options.timeoutMs);
+      deadline.unref();
+    }
+
+    if (options.signal) {
+      if (options.signal.aborted) {
+        fail("codemode execution was aborted", "aborted");
+        return;
+      }
+      options.signal.addEventListener(
+        "abort",
+        () => fail("codemode execution was aborted", "aborted"),
+        {
+          once: true,
+        },
+      );
+    }
+
+    const handleCall = async (id: number, name: string, args: unknown): Promise<void> => {
+      started.set(id, { name, at: Date.now() });
+      options.onCallProgress?.({ phase: "start", name, args });
+      let outcome: SandboxCallOutcome;
+      try {
+        outcome = await options.onCall({ id, name, args });
+      } catch (error) {
+        outcome = { ok: false, error: error instanceof Error ? error.message : String(error) };
+      }
+      const entry = started.get(id);
+      started.delete(id);
+      calls.push({
+        name,
+        status: outcome.ok ? "ok" : "error",
+        durationMs: entry ? Date.now() - entry.at : 0,
+      });
+      options.onCallProgress?.({ phase: "finish", name, status: outcome.ok ? "ok" : "error" });
+      if (!settled) {
+        worker.postMessage({ t: "result", id, ...outcome });
+      }
+    };
+
+    const handleMessage = (frame: WorkerMessage): void => {
+      if (frame.t === "call") {
+        void handleCall(frame.id, frame.name, frame.args);
+        return;
+      }
+      if (frame.t === "output") {
+        output.push(...frame.items);
+        options.onOutput?.(frame.items);
+        return;
+      }
+      if (frame.ok) {
+        finish({ ok: true, value: frame.value, writes: frame.writes });
+      } else {
+        finish({ ok: false, error: frame.error, writes: frame.writes });
+      }
+    };
+
+    worker.on("message", (value: unknown) => {
+      const decoded = decodeWorkerMessage(value);
+      if (!decoded.ok) {
+        fail(`codemode worker sent an invalid message (${decoded.error})`);
+        return;
+      }
+      handleMessage(decoded.frame);
+    });
+    worker.on("error", (error: Error) => fail(`codemode worker failed: ${error.message}`));
+    worker.on("exit", (code) => {
+      if (!settled) {
+        fail(`codemode worker exited early with code ${code}`);
+      }
+    });
+
+    worker.postMessage({
+      t: "start",
+      code: options.code,
+      tools: [...options.tools],
+      store: options.store,
+    });
+  });
+}

package/src/codemode/source.ts

@@ -0,0 +1,91 @@
+/**
+ * codemode 脚本源码的解析：首行可选的 `// @options: {"max_output_tokens":…, "timeout_ms":…}`。
+ *
+ * 选项行与脚本首行共用一行，解析后原样保留为空行，脚本里报错的行号因此与用户写的
+ * 一致。解析失败（空输入、JSON 非法、未知字段、只有选项行没有代码）直接报错。
+ */
+
+const OPTIONS_PREFIX = "// @options:";
+const SUPPORTED_FIELDS = ["max_output_tokens", "timeout_ms"] as const;
+
+export const DEFAULT_OUTPUT_TOKENS = 10_000;
+/**
+ * 脚本默认没有超时：编排一批工具调用本来就可能跑几分钟（例如批量读大文件）。
+ * 调用方中止与 `// @options: {"timeout_ms": …}` 都能提前结束。
+ */
+export const DEFAULT_TIMEOUT_MS = Infinity;
+
+export class CodemodeSourceError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "CodemodeSourceError";
+  }
+}
+
+export interface CodemodeSourceOptions {
+  maxOutputTokens: number;
+  timeoutMs: number;
+}
+
+export interface ParsedCodemodeSource {
+  code: string;
+  options: Partial<CodemodeSourceOptions>;
+}
+
+function parseOptions(json: string): Partial<CodemodeSourceOptions> {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    throw new CodemodeSourceError(
+      `${OPTIONS_PREFIX} expects a JSON object, got ${JSON.stringify(json)}`,
+    );
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new CodemodeSourceError(`${OPTIONS_PREFIX} expects a JSON object`);
+  }
+  const options: Partial<CodemodeSourceOptions> = {};
+  for (const [key, value] of Object.entries(parsed as Record<string, unknown>)) {
+    if (!(SUPPORTED_FIELDS as readonly string[]).includes(key)) {
+      throw new CodemodeSourceError(
+        `${OPTIONS_PREFIX} does not support ${JSON.stringify(key)}; supported fields are ${SUPPORTED_FIELDS.map((field) => `\`${field}\``).join(" and ")}`,
+      );
+    }
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+      throw new CodemodeSourceError(`${OPTIONS_PREFIX} ${key} must be a positive number`);
+    }
+    if (key === "max_output_tokens") {
+      options.maxOutputTokens = value;
+    } else {
+      options.timeoutMs = value;
+    }
+  }
+  return options;
+}
+
+export function parseCodemodeSource(input: string): ParsedCodemodeSource {
+  if (input.trim() === "") {
+    throw new CodemodeSourceError("Expected JavaScript source text (non-empty).");
+  }
+  const newline = input.indexOf("\n");
+  const firstLine = (newline === -1 ? input : input.slice(0, newline)).replace(/\r$/, "");
+  const trimmed = firstLine.trimStart();
+  if (!trimmed.startsWith(OPTIONS_PREFIX)) {
+    return { code: input, options: {} };
+  }
+  const code = newline === -1 ? "" : input.slice(newline);
+  if (code.trim() === "") {
+    throw new CodemodeSourceError(
+      "The @options line must be followed by JavaScript source on subsequent lines",
+    );
+  }
+  return { code, options: parseOptions(trimmed.slice(OPTIONS_PREFIX.length).trim()) };
+}
+
+/**
+ * 只允许「首行可选的 @options + 任意 JS」的 Lark 语法，供支持语法约束采样的 provider
+ * 使用（`constrainedSampling`）。
+ */
+export const CODEMODE_SOURCE_GRAMMAR = String.raw`start: options? source
+options: /\/\/ @options: \{[^\n]*\}\n/
+source: /(?s:.)+/`;

package/src/codemode/tool.ts

@@ -0,0 +1,353 @@
+/**
+ * codemode 工具：模型写一段 JavaScript，脚本在 QuickJS VM（worker 线程）里执行，脚本唯一
+ * 的能力是调用 `tools.*`——每个嵌套调用都由主线程经本仓库的工具总线执行，因此工具实现
+ * 内部的审批（工作区外写入、Bash 沙箱提权等）照常生效；codemode 不再加自己的确认层。
+ *
+ * 可调用集合：总线上实际注册的工具减去 codemode 自身，执行时再与 active 列表求交——
+ * pi 自己的 `defaultTools` / `--tools` / 子代理白名单的排除因此同样生效。
+ *
+ * wasm 在注册这个工具时编译一次（`createCodemodeSandbox`），worker 复用编译结果。
+ */
+
+import { randomBytes } from "node:crypto";
+import { writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+
+import type { ToolPendant } from "../lib/pendant.js";
+import { type ToolBus, toolResultText } from "../lib/tool-bus.js";
+import { renderDeclarations, toScriptTools } from "./declarations.js";
+import type { CodemodeOutputItem, ScriptError, StoreWrites } from "./protocol.js";
+import { type CodemodeSandbox, createCodemodeSandbox, type ScriptCall } from "./sandbox.js";
+import {
+  CODEMODE_SOURCE_GRAMMAR,
+  DEFAULT_OUTPUT_TOKENS,
+  DEFAULT_TIMEOUT_MS,
+  parseCodemodeSource,
+} from "./source.js";
+
+export const CODEMODE_TOOL_NAME = "codemode";
+
+/** store 落在 session 的自定义 entry 上：随分支保存与恢复。 */
+const STORE_ENTRY_TYPE = "codemode-store";
+
+/** 估计 token 用的字符数（与 pi 一致）。 */
+const CHARS_PER_TOKEN = 4;
+
+export interface CodemodeTools {
+  /**
+   * 注册 codemode 工具。注册时编译 quickjs.wasm（编译失败则注册失败，由入口记成
+   * 警告），之后每次执行复用同一份编译结果。
+   */
+  register(bus: ToolBus): Promise<void>;
+}
+
+interface CallableTool {
+  name: string;
+  description?: string;
+  parameters?: unknown;
+}
+
+/** 只在 pi 有 active 工具概念时才求交（子代理、`--tools` 等场景）。 */
+function allowedToolNames(pi: ExtensionAPI): Set<string> | undefined {
+  try {
+    const active = pi.getActiveTools();
+    return active.length > 0 ? new Set(active) : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function collectTools(bus: ToolBus, allowed: Set<string> | undefined): CallableTool[] {
+  return bus
+    .list()
+    .filter((definition) => definition.name !== CODEMODE_TOOL_NAME)
+    .filter((definition) => allowed === undefined || allowed.has(definition.name))
+    .map((definition) => ({
+      name: definition.name,
+      description: definition.description,
+      parameters: definition.parameters,
+    }));
+}
+
+function buildDescription(tools: readonly CallableTool[]): string {
+  return [
+    "Run JavaScript code that orchestrates tool calls in a QuickJS sandbox.",
+    "- The code is the body of an async function: top-level `await` and `return` both work.",
+    "- Call tools with `await tools.<name>(args)`. Arguments and results make a JSON round trip,",
+    "  and a failing tool rejects with an `Error` you can catch.",
+    "- Only what the script passes to `text(value)` / `console.log(...)` and its `return` value enter",
+    "  this conversation; nested calls and their results stay out of it.",
+    "- `store(key, value)` and `load(key)` keep values across codemode calls in this session.",
+    "- The sandbox has no file system, network, timers or Node APIs: calling tools is its only",
+    "  capability. Tool calls still go through each tool's own approvals, so a call that needs the",
+    "  user's consent will ask for it.",
+    "- Prefer one script over many round trips: batch independent calls with `Promise.all`, filter in",
+    "  JavaScript, and print only what matters.",
+    "",
+    "```ts",
+    renderDeclarations(tools),
+    "```",
+  ].join("\n");
+}
+
+function readStore(ctx: ExtensionContext): Record<string, unknown> {
+  const store = new Map<string, unknown>();
+  for (const entry of ctx.sessionManager.getBranch()) {
+    if (entry.type !== "custom" || entry.customType !== STORE_ENTRY_TYPE) {
+      continue;
+    }
+    const data = (entry as { data?: unknown }).data;
+    if (typeof data !== "object" || data === null) {
+      continue;
+    }
+    const writes = data as Partial<StoreWrites>;
+    for (const key of writes.delete ?? []) {
+      store.delete(key);
+    }
+    for (const [key, value] of Object.entries(writes.set ?? {})) {
+      store.set(key, value);
+    }
+  }
+  return Object.fromEntries(store);
+}
+
+function errorText(error: ScriptError): string {
+  const head = error.name ? `${error.name}: ${error.message}` : error.message;
+  return `${head}${error.stack && error.stack !== head ? `\n${error.stack}` : ""}`;
+}
+
+/** 文本项拼接：脚本的 `text()` 输出与返回值。 */
+function textOf(items: readonly CodemodeOutputItem[]): string {
+  return items
+    .filter((item): item is { type: "text"; text: string } => item.type === "text")
+    .map((item) => item.text)
+    .join("\n");
+}
+
+function imagesOf(
+  items: readonly CodemodeOutputItem[],
+): { type: "image"; data: string; mimeType: string }[] {
+  return items.filter(
+    (item): item is { type: "image"; data: string; mimeType: string } => item.type === "image",
+  );
+}
+
+/** 输出太长时把全文写到临时文件，返回路径（写失败返回错误文本）。 */
+async function spillOutput(text: string): Promise<{ path: string } | { error: string }> {
+  const path = join(tmpdir(), `pi-codemode-${randomBytes(8).toString("hex")}.txt`);
+  try {
+    await writeFile(path, text);
+    return { path };
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+/**
+ * 套用输出预算：文本超过 `maxTokens * 4` 个字符时保留头尾、写全文到临时文件。
+ * 图片不受影响，始终保留。
+ */
+async function truncateOutput(
+  text: string,
+  images: readonly { type: "image"; data: string; mimeType: string }[],
+  maxTokens: number,
+): Promise<{ text: string; fullOutputPath?: string }> {
+  const budget = maxTokens * CHARS_PER_TOKEN;
+  if (text.length <= budget) {
+    return { text };
+  }
+  const headChars = Math.floor(budget / 2);
+  const tailChars = budget - headChars;
+  const removed = text.length - headChars - tailChars;
+  const spilled = await spillOutput(text);
+  const notice =
+    "path" in spilled
+      ? `[Full output: ${spilled.path} (read with offset/limit)]`
+      : `[Could not save the full output: ${spilled.error}]`;
+  return {
+    text: [
+      `Warning: truncated output (original token count: ${Math.ceil(text.length / CHARS_PER_TOKEN)})`,
+      `Total output lines: ${text.split("\n").length}`,
+      "",
+      `${text.slice(0, headChars)}…${Math.ceil(removed / CHARS_PER_TOKEN)} tokens truncated…${
+        tailChars > 0 ? text.slice(-tailChars) : ""
+      }`,
+      "",
+      notice,
+      images.length > 0
+        ? `(${images.length} image output${images.length === 1 ? "" : "s"} not shown here)`
+        : "",
+    ]
+      .filter((line) => line !== "")
+      .join("\n"),
+    ...("path" in spilled && { fullOutputPath: spilled.path }),
+  };
+}
+
+/**
+ * TUI 面板：脚本原文放在 js 代码块里，用比脚本里最长反引号串更长的围栏包住，
+ * 免得脚本里的 ``` 把面板截断。
+ */
+function scriptPendant(code: string, subtitle: string): ToolPendant {
+  const longest = (code.match(/`+/g) ?? []).reduce((max, run) => Math.max(max, run.length), 0);
+  const fence = "`".repeat(Math.max(3, longest + 1));
+  return {
+    title: CODEMODE_TOOL_NAME,
+    subtitle,
+    markdown: `${fence}js\n${code.trimEnd()}\n${fence}`,
+  };
+}
+
+function formatCallSummary(calls: readonly ScriptCall[]): string {
+  if (calls.length === 0) {
+    return "No tool calls were made.";
+  }
+  return `Tool calls made before the failure (they are not undone): ${calls
+    .map((call) => `${call.name} (${call.status})`)
+    .join(", ")}`;
+}
+
+export function createCodemodeTools(pi: ExtensionAPI): CodemodeTools {
+  return {
+    async register(bus) {
+      const sandbox: CodemodeSandbox = await createCodemodeSandbox();
+      const tools = collectTools(bus, allowedToolNames(pi));
+      const callable = new Set(tools.map((tool) => tool.name));
+      const scriptTools = toScriptTools(tools);
+
+      bus.register({
+        name: CODEMODE_TOOL_NAME,
+        label: "codemode",
+        description: buildDescription(tools),
+        promptSnippet: "codemode: run JavaScript that calls tools in parallel",
+        promptGuidelines: [
+          "Use codemode to batch or chain several tool calls, or to filter large tool output down to what matters, instead of issuing many individual tool calls.",
+        ],
+        parameters: Type.Object({
+          code: Type.String({
+            description:
+              'Raw JavaScript source. Top-level await and return work. May start with a `// @options: {"timeout_ms": 30000}` line.',
+          }),
+        }),
+        constrainedSampling: {
+          type: "grammar",
+          variants: { openai_lark: CODEMODE_SOURCE_GRAMMAR },
+        },
+        executionMode: "sequential",
+
+        async execute(_toolCallId, params, signal, onUpdate, ctx) {
+          let code: string;
+          let timeoutMs = DEFAULT_TIMEOUT_MS;
+          let maxOutputTokens = DEFAULT_OUTPUT_TOKENS;
+          try {
+            const parsed = parseCodemodeSource(params.code);
+            code = parsed.code;
+            timeoutMs = parsed.options.timeoutMs ?? timeoutMs;
+            maxOutputTokens = parsed.options.maxOutputTokens ?? maxOutputTokens;
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+              isError: true,
+              content: [{ type: "text", text: message }],
+              details: {
+                error: message,
+                pendant: scriptPendant(params.code, "invalid @options"),
+              },
+            };
+          }
+
+          const outcome = await sandbox.run({
+            code,
+            tools: scriptTools,
+            store: readStore(ctx),
+            timeoutMs,
+            signal,
+            onOutput: (items) => {
+              const text = textOf(items);
+              if (text) {
+                onUpdate?.({
+                  content: [{ type: "text", text }],
+                  details: { pendant: scriptPendant(code, text.slice(0, 80)) },
+                });
+              }
+            },
+            onCallProgress: ({ phase, name, args }) => {
+              const detail =
+                phase === "start" && args !== undefined
+                  ? ` ${JSON.stringify(args).slice(0, 200)}`
+                  : "";
+              const line = `${phase === "start" ? "→" : "←"} ${name}${detail}`;
+              onUpdate?.({
+                content: [{ type: "text", text: line }],
+                details: { pendant: scriptPendant(code, line.slice(0, 120)) },
+              });
+            },
+            onCall: async ({ name, args }) => {
+              if (!callable.has(name)) {
+                return { ok: false, error: `Tool "${name}" is not available in codemode.` };
+              }
+              const result = await bus.executeTool(name, args, { ctx, signal });
+              const text = toolResultText(result);
+              if (result.isError) {
+                return { ok: false, error: text };
+              }
+              return { ok: true, value: text };
+            },
+          });
+
+          const images = imagesOf(outcome.output);
+          if (outcome.ok) {
+            const writes = outcome.writes;
+            if (Object.keys(writes.set).length > 0 || writes.delete.length > 0) {
+              pi.appendEntry(STORE_ENTRY_TYPE, writes);
+            }
+            const value =
+              outcome.value === undefined ? "" : `\n\n${JSON.stringify(outcome.value, null, 2)}`;
+            const truncated = await truncateOutput(
+              textOf(outcome.output) + value,
+              images,
+              maxOutputTokens,
+            );
+            return {
+              content: [
+                { type: "text" as const, text: truncated.text },
+                ...images.map((image) => ({
+                  type: "image" as const,
+                  data: image.data,
+                  mimeType: image.mimeType,
+                })),
+              ],
+              details: {
+                calls: outcome.calls,
+                pendant: scriptPendant(code, `${outcome.calls.length} tool call(s)`),
+                ...(truncated.fullOutputPath && { fullOutputPath: truncated.fullOutputPath }),
+              },
+            };
+          }
+
+          const body = textOf(outcome.output);
+          const text = [
+            `Script failed (${outcome.error.kind}):\n${errorText(outcome.error)}`,
+            body,
+            formatCallSummary(outcome.calls),
+          ]
+            .filter((part) => part !== "")
+            .join("\n\n");
+          return {
+            isError: true,
+            content: [{ type: "text", text }],
+            details: {
+              calls: outcome.calls,
+              error: outcome.error.kind,
+              pendant: scriptPendant(code, `failed (${outcome.error.kind})`),
+            },
+          };
+        },
+      });
+    },
+  };
+}

package/src/codemode/wasm.ts

@@ -0,0 +1,20 @@
+/**
+ * `quickjs.wasm` 的编译：codemode 注册工具时做一次，得到 `WebAssembly.Module`，之后
+ * 每次执行把它交给 worker 实例化 VM —— 编译只发生一次，不是每次执行都付出。
+ *
+ * wasm 由 `quickjs-wasi` 包分发（vercel-labs 的 QuickJS-NG wasi 构建），这里只负责
+ * 读文件并编译。
+ */
+
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+
+interface WebAssemblyGlobal {
+  compile(bytes: Uint8Array): Promise<object>;
+}
+
+export async function compileQuickJSWasm(): Promise<object> {
+  const resolved = createRequire(import.meta.url).resolve("quickjs-wasi/quickjs.wasm");
+  const { WebAssembly } = globalThis as unknown as { WebAssembly: WebAssemblyGlobal };
+  return await WebAssembly.compile(await readFile(resolved));
+}