nolo-cli 0.33.0-alpha.21 → 0.33.0-alpha.23

package/{chunk-2UDMTJOM.js → chunk-PFJA4C7K.js}

@@ -11,24 +11,32 @@ import {
   deleteDialog,
   resetMsgs,
   toast
-} from "./chunk-JL2PUYVS.js";
+} from "./chunk-YBWR3WBJ.js";
 import {
   deleteServerSyncedCredential
-} from "./chunk-XS543SNR.js";
+} from "./chunk-25MFIHEP.js";
 import {
   require_date_fns
 } from "./chunk-M76ECQRD.js";
 import {
   createFileCredentialBroker
 } from "./chunk-RQFO3CAF.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+import {
+  UNCATEGORIZED_ID,
+  addContentAction,
+  checkSpaceMembership,
+  createSpaceKey,
+  localSpaceAuthorityPatchStamp,
+  normalizeSpaceId
+} from "./chunk-KMMQFY5O.js";
 import {
   clearPendingAttachments,
   clearPendingUserInputQueue,
   require_react
 } from "./chunk-MRWGHF56.js";
-import {
-  toErrorMessage
-} from "./chunk-HNMXYYJR.js";
 import {
   isSystemAdmin,
   selectRemoteServer,
@@ -37,14 +45,6 @@ import {
 import {
   asRecordOrEmpty
 } from "./chunk-KX6YBIHG.js";
-import {
-  UNCATEGORIZED_ID,
-  addContentAction,
-  checkSpaceMembership,
-  createSpaceKey,
-  localSpaceAuthorityPatchStamp,
-  normalizeSpaceId
-} from "./chunk-KMMQFY5O.js";
 import {
   patch,
   read,

package/{chunk-7BNPRRDS.js → chunk-R7UWXBVG.js}

@@ -21,6 +21,9 @@ import {
   readPageFunctionSchema,
   slateToSimplifiedMarkdown
 } from "./chunk-KIL7V27H.js";
+import {
+  setDialogExtraReferencesAction
+} from "./chunk-L5XKDBSH.js";
 import {
   markdownToSlate
 } from "./chunk-INZZJSQF.js";
@@ -35,17 +38,14 @@ import {
 } from "./chunk-VF4K2QE6.js";
 import {
   createDocState
-} from "./chunk-SBPGB6TF.js";
-import {
-  setDialogExtraReferencesAction
-} from "./chunk-L5XKDBSH.js";
+} from "./chunk-G3ONB6Y5.js";
 import {
   BUILTIN_OBJECT_SKILL_IDS,
   buildBuiltinObjectSkillConfig,
   buildBuiltinObjectSkillDbKey,
   buildBuiltinObjectSkillPageContent,
   createDialogAction
-} from "./chunk-RO3AEN3L.js";
+} from "./chunk-UCUCOZXY.js";
 import {
   addCategory,
   addContentToSpace,
@@ -65,7 +65,7 @@ import {
   loadTableRows,
   updateContentCategory,
   updateContentTitle
-} from "./chunk-2UDMTJOM.js";
+} from "./chunk-PFJA4C7K.js";
 import {
   incrementFailedSteps,
   incrementStepsExecuted,
@@ -79,13 +79,13 @@ import {
   uiAskChoiceFunc,
   uiAskChoiceFunctionSchema,
   updateStep
-} from "./chunk-JL2PUYVS.js";
+} from "./chunk-YBWR3WBJ.js";
 import {
   createAgent,
   runLlm,
   streamAgentChatTurn,
   updateAgent
-} from "./chunk-XS543SNR.js";
+} from "./chunk-25MFIHEP.js";
 import {
   NOLO_WORKSPACE_TOOL_NAMES,
   buildAgentRuntimeAgentLookupKeys,
@@ -103,10 +103,18 @@ import {
 } from "./chunk-ADLYMQB6.js";
 import {
   buildDatabaseFileContentUrl
-} from "./chunk-HCOIKLSH.js";
+} from "./chunk-CP4QR2D2.js";
 import {
   DEFAULT_MODEL
 } from "./chunk-7SLMYTSF.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+import {
+  addContentAction,
+  createSpaceKey,
+  normalizeSpaceId
+} from "./chunk-KMMQFY5O.js";
 import {
   CODING_SKILL_SLUGS,
   buildCodingSkillConfig,
@@ -155,9 +163,6 @@ import {
   formatStopRunCard,
   resolveRunLabel
 } from "./chunk-KXKQO4Q6.js";
-import {
-  toErrorMessage
-} from "./chunk-HNMXYYJR.js";
 import {
   shareResourceAction
 } from "./chunk-DDET6246.js";
@@ -172,11 +177,6 @@ import {
 import {
   asRecordOrEmpty
 } from "./chunk-KX6YBIHG.js";
-import {
-  addContentAction,
-  createSpaceKey,
-  normalizeSpaceId
-} from "./chunk-KMMQFY5O.js";
 import {
   patch,
   read,
@@ -14907,7 +14907,7 @@ async function deleteDialogsFunc(args, thunkApi) {
   const deletedDialogIds = [];
   const deletedDialogKeys = [];
   const failures = [];
-  const { deleteDialog } = await import("./dialogSlice-5R4O4377.js");
+  const { deleteDialog } = await import("./dialogSlice-S7CBGXUY.js");
   for (const target of targets) {
     try {
       await thunkApi.dispatch(deleteDialog(target.dbKey)).unwrap();
@@ -24434,7 +24434,7 @@ var executeToolRun = createAsyncThunk(
     if (!executionInput) {
       throw new Error(`ToolRun ${id} has no input to execute with.`);
     }
-    const { findToolExecutor: findToolExecutor2 } = await import("./tools-KWYWDJ77.js");
+    const { findToolExecutor: findToolExecutor2 } = await import("./tools-XAC2C4LK.js");
     const { executor } = findToolExecutor2(run.toolName);
     toolRunStarted({
       id: run.id,
@@ -24458,7 +24458,7 @@ var executeToolRun = createAsyncThunk(
         const latestState = thunkApi.getState();
         const userId = latestState.auth?.currentUser?.userId;
         if (userId) {
-          const { fetchUserSpaceMemberships } = await import("./spaceSlice-TL2FR4AF.js");
+          const { fetchUserSpaceMemberships } = await import("./spaceSlice-KD2BB5GS.js");
           await thunkApi.dispatch(fetchUserSpaceMemberships(userId));
         }
       }
@@ -26941,7 +26941,7 @@ async function updateDocFunc(args, thunkApi) {
       updated_at: (/* @__PURE__ */ new Date()).toISOString()
     };
     await dispatch(write({ data: updatedPageData, customKey: id })).unwrap();
-    const { getDocState, applyExternalDocUpdate } = await import("./docStore-A4SRW2DJ.js");
+    const { getDocState, applyExternalDocUpdate } = await import("./docStore-YZACMKQG.js");
     if (getDocState().pageKey === id) {
       applyExternalDocUpdate({
         slateData: finalSlateData,

package/{chunk-YH3FPBG6.js → chunk-SEFDSJK4.js}

@@ -18,11 +18,14 @@ import {
   formatMessagesForSummaryWithTruncation,
   planCompression,
   planContextUsage
-} from "./chunk-HCOIKLSH.js";
+} from "./chunk-CP4QR2D2.js";
 import {
   findModelConfig,
   getProviderByModelName
 } from "./chunk-7SLMYTSF.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
 import {
   buildDialogSummaryLayer
 } from "./chunk-3AOLVADY.js";
@@ -33,9 +36,6 @@ import {
   canonicalizeToolName,
   canonicalizeToolNames
 } from "./chunk-ZZ2MH7LE.js";
-import {
-  toErrorMessage
-} from "./chunk-HNMXYYJR.js";
 import {
   asRecordOrEmpty
 } from "./chunk-KX6YBIHG.js";
@@ -1709,6 +1709,307 @@ function createCapabilitySdk(args) {
   };
 }
 
+// packages/agent-runtime/capabilities/ptcExecutionContext.ts
+import { isAbsolute } from "node:path";
+var PtcContextValidationError = class extends Error {
+  constructor(message) {
+    super(`PTC context validation failed: ${message}`);
+    this.name = "PtcContextValidationError";
+  }
+};
+function createPtcFailClosedContext(input) {
+  if (!input || typeof input !== "object") {
+    throw new PtcContextValidationError("Turn context object is required for PTC execution.");
+  }
+  const raw = input;
+  if (typeof raw.workspaceRoot !== "string" || !raw.workspaceRoot.trim()) {
+    throw new PtcContextValidationError(
+      "PTC execution requires an explicit, non-empty 'workspaceRoot'. Fallback to process.cwd() is strictly forbidden."
+    );
+  }
+  if (!isAbsolute(raw.workspaceRoot.trim())) {
+    throw new PtcContextValidationError(
+      `PTC execution requires an absolute path for 'workspaceRoot' (received "${raw.workspaceRoot}").`
+    );
+  }
+  if (!raw.abortSignal || !(raw.abortSignal instanceof AbortSignal) || typeof raw.abortSignal.aborted !== "boolean" || typeof raw.abortSignal.addEventListener !== "function") {
+    throw new PtcContextValidationError(
+      "PTC execution requires an explicit 'abortSignal' (AbortSignal) from current turn context."
+    );
+  }
+  if (typeof raw.restrictToWorkspace !== "boolean") {
+    throw new PtcContextValidationError(
+      "PTC execution requires an explicit boolean 'restrictToWorkspace' setting."
+    );
+  }
+  if (typeof raw.enableDestructiveShellGuard !== "boolean") {
+    throw new PtcContextValidationError(
+      "PTC execution requires an explicit boolean 'enableDestructiveShellGuard' setting."
+    );
+  }
+  const validated = {
+    workspaceRoot: raw.workspaceRoot.trim(),
+    abortSignal: raw.abortSignal,
+    restrictToWorkspace: raw.restrictToWorkspace,
+    enableDestructiveShellGuard: raw.enableDestructiveShellGuard,
+    blockDestructiveWithoutConfirmation: typeof raw.blockDestructiveWithoutConfirmation === "boolean" ? raw.blockDestructiveWithoutConfirmation : void 0,
+    confirmDestructiveAction: typeof raw.confirmDestructiveAction === "function" ? raw.confirmDestructiveAction : void 0,
+    commandTimeoutMs: typeof raw.commandTimeoutMs === "number" ? raw.commandTimeoutMs : void 0,
+    commandOutputLimit: typeof raw.commandOutputLimit === "number" ? raw.commandOutputLimit : void 0,
+    commandPrefix: Array.isArray(raw.commandPrefix) ? raw.commandPrefix : void 0,
+    detachMs: typeof raw.detachMs === "number" ? raw.detachMs : void 0,
+    confirmed: typeof raw.confirmed === "boolean" ? raw.confirmed : void 0,
+    agentRunService: raw.agentRunService,
+    onInvoke: typeof raw.onInvoke === "function" ? raw.onInvoke : void 0,
+    activityContext: raw.activityContext,
+    onActivity: typeof raw.onActivity === "function" ? raw.onActivity : void 0
+  };
+  return validated;
+}
+function createPtcCapabilitySdk(args) {
+  const strictContext = createPtcFailClosedContext(args.turnContext);
+  const sdk = createCapabilitySdk({
+    context: strictContext,
+    capabilities: args.capabilities ?? BUILTIN_CAPABILITIES
+  });
+  return {
+    sdk,
+    context: strictContext
+  };
+}
+
+// node_modules/quickjs-emscripten-core/dist/index.mjs
+async function newQuickJSWASMModuleFromVariant(variantOrPromise) {
+  let variant2 = smartUnwrap(await variantOrPromise), [wasmModuleLoader, QuickJSFFI, { QuickJSWASMModule: QuickJSWASMModule2 }] = await Promise.all([variant2.importModuleLoader().then(smartUnwrap), variant2.importFFI(), import("./module-ES6BEMUI-AFCVSBMS.js").then(smartUnwrap)]), wasmModule = await wasmModuleLoader();
+  wasmModule.type = "sync";
+  let ffi = new QuickJSFFI(wasmModule);
+  return new QuickJSWASMModule2(wasmModule, ffi);
+}
+function smartUnwrap(val) {
+  return val && "default" in val && val.default ? val.default && "default" in val.default && val.default.default ? val.default.default : val.default : val;
+}
+
+// node_modules/@jitl/quickjs-wasmfile-release-sync/dist/index.mjs
+var variant = { type: "sync", importFFI: () => import("./ffi-AEYWSYLM.js").then((mod) => mod.QuickJSFFI), importModuleLoader: () => import("./emscripten-module-OFHQ7EL3.js").then((mod) => mod.default) };
+var src_default = variant;
+
+// node_modules/quickjs-emscripten/dist/chunk-OHAYRCBA.mjs
+async function newQuickJSWASMModule(variantOrPromise = src_default) {
+  return newQuickJSWASMModuleFromVariant(variantOrPromise);
+}
+
+// packages/agent-runtime/ptcQuickJsPrototype.ts
+function marshalJsonToQuickJs(vm, data) {
+  const jsonStr = JSON.stringify(data ?? null);
+  const strHandle = vm.newString(jsonStr);
+  const jsonHandle = vm.getProp(vm.global, "JSON");
+  const parseHandle = vm.getProp(jsonHandle, "parse");
+  const res = vm.callFunction(parseHandle, jsonHandle, strHandle);
+  strHandle.dispose();
+  jsonHandle.dispose();
+  parseHandle.dispose();
+  return vm.unwrapResult(res);
+}
+async function executePtcQuickJsPrototype(options) {
+  const QuickJS = await newQuickJSWASMModule();
+  const runtime = QuickJS.newRuntime();
+  if (options.memoryLimitBytes) {
+    runtime.setMemoryLimit(options.memoryLimitBytes);
+  } else {
+    runtime.setMemoryLimit(16 * 1024 * 1024);
+  }
+  const executionController = new AbortController();
+  const onParentAbort = () => {
+    executionController.abort(options.abortSignal?.reason);
+  };
+  if (options.abortSignal) {
+    if (options.abortSignal.aborted) {
+      executionController.abort(options.abortSignal.reason);
+    } else {
+      options.abortSignal.addEventListener("abort", onParentAbort, { once: true });
+    }
+  }
+  let wasInterrupted = false;
+  const startTime = Date.now();
+  const timeoutMs = options.timeoutMs ?? 5e3;
+  const deadline = startTime + timeoutMs;
+  runtime.setInterruptHandler(() => {
+    if (executionController.signal.aborted || options.abortSignal?.aborted) {
+      wasInterrupted = true;
+      return true;
+    }
+    if (Date.now() > deadline) {
+      wasInterrupted = true;
+      executionController.abort(new Error("Execution timed out."));
+      return true;
+    }
+    return false;
+  });
+  const vm = runtime.newContext();
+  const activeHandles = [];
+  const activePromises = /* @__PURE__ */ new Set();
+  const trackHandle = (h) => {
+    activeHandles.push(h);
+    return h;
+  };
+  try {
+    const toolsHandle = vm.newObject();
+    if (options.tools?.execShell) {
+      const execShellHost = options.tools.execShell;
+      const execShellFn = vm.newFunction("execShell", (argHandle) => {
+        const promiseObj = vm.newPromise();
+        activePromises.add(promiseObj);
+        const input = vm.dump(argHandle);
+        execShellHost(input, { signal: executionController.signal }).then((res) => {
+          if (vm.alive) {
+            const val = marshalJsonToQuickJs(vm, res);
+            promiseObj.resolve(val);
+            val.dispose();
+            runtime.executePendingJobs();
+          }
+        }).catch((err) => {
+          if (vm.alive) {
+            const errHandle = vm.newError(err?.message ?? String(err));
+            promiseObj.reject(errHandle);
+            errHandle.dispose();
+            runtime.executePendingJobs();
+          }
+        }).finally(() => {
+          activePromises.delete(promiseObj);
+          try {
+            promiseObj.dispose();
+          } catch {
+          }
+        });
+        return promiseObj.handle;
+      });
+      vm.setProp(toolsHandle, "execShell", execShellFn);
+      execShellFn.dispose();
+    }
+    const agentsHandle = vm.newObject();
+    if (options.tools?.agents?.run) {
+      const agentsRunHost = options.tools.agents.run;
+      const agentsRunFn = vm.newFunction("run", (argHandle) => {
+        const promiseObj = vm.newPromise();
+        activePromises.add(promiseObj);
+        const input = vm.dump(argHandle);
+        agentsRunHost(input, { signal: executionController.signal }).then((res) => {
+          if (vm.alive) {
+            const val = marshalJsonToQuickJs(vm, res);
+            promiseObj.resolve(val);
+            val.dispose();
+            runtime.executePendingJobs();
+          }
+        }).catch((err) => {
+          if (vm.alive) {
+            const errHandle = vm.newError(err?.message ?? String(err));
+            promiseObj.reject(errHandle);
+            errHandle.dispose();
+            runtime.executePendingJobs();
+          }
+        }).finally(() => {
+          activePromises.delete(promiseObj);
+          try {
+            promiseObj.dispose();
+          } catch {
+          }
+        });
+        return promiseObj.handle;
+      });
+      vm.setProp(agentsHandle, "run", agentsRunFn);
+      agentsRunFn.dispose();
+    }
+    vm.setProp(toolsHandle, "agents", agentsHandle);
+    agentsHandle.dispose();
+    vm.setProp(vm.global, "tools", toolsHandle);
+    toolsHandle.dispose();
+    const wrapper = `
+      ${options.code}
+      ;(async () => {
+        if (typeof main !== "function") {
+          throw new Error("Entrypoint 'main(tools)' function not found.");
+        }
+        return await main(tools);
+      })();
+    `;
+    const evalRes = vm.evalCode(wrapper);
+    if (evalRes.error) {
+      const errorDump = vm.dump(evalRes.error);
+      evalRes.error.dispose();
+      const errorMsg = typeof errorDump === "object" && errorDump !== null ? errorDump.message || JSON.stringify(errorDump) : String(errorDump);
+      const isOom = errorMsg.includes("out of memory");
+      const isInterrupted = errorMsg.includes("interrupted") || wasInterrupted;
+      return {
+        ok: false,
+        error: errorMsg,
+        interrupted: isInterrupted,
+        outOfMemory: isOom
+      };
+    }
+    const mainPromiseHandle = trackHandle(vm.unwrapResult(evalRes));
+    while (true) {
+      if (options.abortSignal?.aborted || executionController.signal.aborted) {
+        return { ok: false, error: "Execution aborted by AbortSignal.", interrupted: true };
+      }
+      if (Date.now() > deadline) {
+        executionController.abort(new Error("Execution timed out."));
+        return { ok: false, error: "Execution timed out.", interrupted: true };
+      }
+      runtime.executePendingJobs();
+      const state = vm.getPromiseState(mainPromiseHandle);
+      if (state.type === "fulfilled") {
+        const val = vm.dump(state.value);
+        state.value.dispose();
+        return { ok: true, result: val };
+      } else if (state.type === "rejected") {
+        const err = vm.dump(state.error);
+        state.error.dispose();
+        const errorMsg = typeof err === "object" && err !== null ? err.message || JSON.stringify(err) : String(err);
+        const isOom = errorMsg.includes("out of memory");
+        const isInterrupted = errorMsg.includes("interrupted") || wasInterrupted;
+        return {
+          ok: false,
+          error: errorMsg,
+          interrupted: isInterrupted,
+          outOfMemory: isOom
+        };
+      }
+      await new Promise((r) => setTimeout(r, 10));
+    }
+  } catch (err) {
+    return { ok: false, error: err?.message ?? String(err) };
+  } finally {
+    if (options.abortSignal) {
+      options.abortSignal.removeEventListener("abort", onParentAbort);
+    }
+    try {
+      executionController.abort(new Error("Sandbox context disposed."));
+    } catch {
+    }
+    for (const p of activePromises) {
+      try {
+        p.dispose();
+      } catch {
+      }
+    }
+    activePromises.clear();
+    for (const h of activeHandles) {
+      try {
+        if (h.alive) h.dispose();
+      } catch {
+      }
+    }
+    try {
+      vm.dispose();
+    } catch {
+    }
+    try {
+      runtime.dispose();
+    } catch {
+    }
+  }
+}
+
 // packages/agent-runtime/toolCallPairing.ts
 function readToolCallId(message) {
   if (typeof message.tool_call_id === "string" && message.tool_call_id) {
@@ -2721,6 +3022,22 @@ async function runLocalAgentTurn(input) {
     ...typeof input.runtimeContext?.blockDestructiveWithoutConfirmation === "boolean" ? { blockDestructiveWithoutConfirmation: input.runtimeContext.blockDestructiveWithoutConfirmation } : {}
   });
   const tools = createLocalCapabilitySdk(input.adapter, execShellContext);
+  if (input.__testPtcProgram) {
+    const { sdk: ptcSdk, context: ptcContext } = createPtcCapabilitySdk({
+      turnContext: {
+        ...execShellContext,
+        agentRunService: createHostToolAgentRunService(input.adapter.executeTool)
+      }
+    });
+    const ptcResult = await executePtcQuickJsPrototype({
+      code: input.__testPtcProgram.code,
+      tools: ptcSdk,
+      abortSignal: ptcContext.abortSignal,
+      timeoutMs: input.__testPtcProgram.timeoutMs,
+      memoryLimitBytes: input.__testPtcProgram.memoryLimitBytes
+    });
+    input.__testPtcProgram.onResult?.(ptcResult);
+  }
   if (input.__testProgram) {
     await input.__testProgram(tools);
   }

package/chunk-TVXJEOU2.js

@@ -0,0 +1,78 @@
+import {
+  Lifetime,
+  QuickJSContext,
+  QuickJSNotImplemented,
+  QuickJSRuntime,
+  QuickJSWASMModule,
+  Scope,
+  applyBaseRuntimeOptions,
+  applyModuleEvalRuntimeOptions,
+  evalOptionsToFlags,
+  intrinsicsToFlags
+} from "./chunk-UOLENXLQ.js";
+
+// node_modules/quickjs-emscripten-core/dist/chunk-TAV5CUKK.mjs
+var QuickJSAsyncContext = class extends QuickJSContext {
+  async evalCodeAsync(code, filename = "eval.js", options) {
+    let detectModule = options === void 0 ? 1 : 0, flags = evalOptionsToFlags(options), resultPtr = 0;
+    try {
+      resultPtr = await this.memory.newHeapCharPointer(code).consume((charHandle) => this.ffi.QTS_Eval_MaybeAsync(this.ctx.value, charHandle.value.ptr, charHandle.value.strlen, filename, detectModule, flags));
+    } catch (error) {
+      throw this.runtime.debugLog("QTS_Eval_MaybeAsync threw", error), error;
+    }
+    let errorPtr = this.ffi.QTS_ResolveException(this.ctx.value, resultPtr);
+    return errorPtr ? (this.ffi.QTS_FreeValuePointer(this.ctx.value, resultPtr), this.fail(this.memory.heapValueHandle(errorPtr))) : this.success(this.memory.heapValueHandle(resultPtr));
+  }
+  newAsyncifiedFunction(name, fn) {
+    return this.newFunction(name, fn);
+  }
+};
+var QuickJSAsyncRuntime = class extends QuickJSRuntime {
+  constructor(args) {
+    super(args);
+  }
+  newContext(options = {}) {
+    let intrinsics = intrinsicsToFlags(options.intrinsics), ctx = new Lifetime(this.ffi.QTS_NewContext(this.rt.value, intrinsics), void 0, (ctx_ptr) => {
+      this.contextMap.delete(ctx_ptr), this.callbacks.deleteContext(ctx_ptr), this.ffi.QTS_FreeContext(ctx_ptr);
+    }), context = new QuickJSAsyncContext({ module: this.module, ctx, ffi: this.ffi, rt: this.rt, ownedLifetimes: [], runtime: this, callbacks: this.callbacks });
+    return this.contextMap.set(ctx.value, context), context;
+  }
+  setModuleLoader(moduleLoader, moduleNormalizer) {
+    super.setModuleLoader(moduleLoader, moduleNormalizer);
+  }
+  setMaxStackSize(stackSize) {
+    return super.setMaxStackSize(stackSize);
+  }
+};
+var QuickJSAsyncWASMModule = class extends QuickJSWASMModule {
+  constructor(module, ffi) {
+    super(module, ffi);
+    this.ffi = ffi, this.module = module;
+  }
+  newRuntime(options = {}) {
+    let rt = new Lifetime(this.ffi.QTS_NewRuntime(), void 0, (rt_ptr) => {
+      this.callbacks.deleteRuntime(rt_ptr), this.ffi.QTS_FreeRuntime(rt_ptr);
+    }), runtime = new QuickJSAsyncRuntime({ module: this.module, ffi: this.ffi, rt, callbacks: this.callbacks });
+    return applyBaseRuntimeOptions(runtime, options), options.moduleLoader && runtime.setModuleLoader(options.moduleLoader), runtime;
+  }
+  newContext(options = {}) {
+    let runtime = this.newRuntime(), lifetimes = options.ownedLifetimes ? options.ownedLifetimes.concat([runtime]) : [runtime], context = runtime.newContext({ ...options, ownedLifetimes: lifetimes });
+    return runtime.context = context, context;
+  }
+  evalCode() {
+    throw new QuickJSNotImplemented("QuickJSWASMModuleAsyncify.evalCode: use evalCodeAsync instead");
+  }
+  evalCodeAsync(code, options) {
+    return Scope.withScopeAsync(async (scope) => {
+      let vm = scope.manage(this.newContext());
+      applyModuleEvalRuntimeOptions(vm.runtime, options);
+      let result = await vm.evalCodeAsync(code, "eval.js");
+      if (options.memoryLimitBytes !== void 0 && vm.runtime.setMemoryLimit(-1), result.error) throw vm.dump(scope.manage(result.error));
+      return vm.dump(scope.manage(result.value));
+    });
+  }
+};
+
+export {
+  QuickJSAsyncWASMModule
+};

package/{chunk-GTEHJWXU.js → chunk-TZV6ELNR.js}

@@ -1,6 +1,6 @@
 import {
   requireTokenUser
-} from "./chunk-V4MT7AEN.js";
+} from "./chunk-3CVNNFKF.js";
 import {
   resolveServerUrl
 } from "./chunk-A7GB5UGH.js";

package/{chunk-RO3AEN3L.js → chunk-UCUCOZXY.js}

@@ -1,11 +1,11 @@
 import {
   addContentToSpace
-} from "./chunk-2UDMTJOM.js";
+} from "./chunk-PFJA4C7K.js";
 import {
   prepareAndPersistMessage,
   uiAskChoiceFunc,
   uiAskChoiceFunctionSchema
-} from "./chunk-JL2PUYVS.js";
+} from "./chunk-YBWR3WBJ.js";
 import {
   require_date_fns
 } from "./chunk-M76ECQRD.js";