@volter/tabnode 0.5.27 → 0.5.29

package/dist/index.mjs

@@ -6202,99 +6202,85 @@ const bufferBinding = {
   setBufferPrototype,
   createFromString
 };
-class AsyncResource {
-  constructor(_type2, _options2) {
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  runInAsyncScope(fn, thisArg, ...args) {
-    return fn.apply(thisArg, args);
-  }
-  emitDestroy() {
-    return this;
-  }
-  asyncId() {
-    return 0;
-  }
-  triggerAsyncId() {
-    return 0;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  static bind(fn, _type2) {
-    return fn;
+const ROOT_FRAME = /* @__PURE__ */ new Map();
+let currentFrame = ROOT_FRAME;
+const nativeQueueMicrotask = globalThis.queueMicrotask.bind(globalThis);
+let resetQueued = false;
+const resetFrame = () => {
+  resetQueued = false;
+  currentFrame = ROOT_FRAME;
+};
+const resumeFrame = (frame) => {
+  if (frame === currentFrame) return;
+  currentFrame = frame;
+  if (!resetQueued) {
+    resetQueued = true;
+    nativeQueueMicrotask(resetFrame);
+  }
+};
+const withFrame = (frame, callback) => {
+  const previous = currentFrame;
+  currentFrame = frame;
+  try {
+    return callback();
+  } finally {
+    currentFrame = previous;
   }
-}
-const __substrateAsyncLocalStorages = /* @__PURE__ */ new Set();
+};
 class AsyncLocalStorage {
-  constructor() {
-    __publicField(this, "store");
-    __substrateAsyncLocalStorages.add(this);
-  }
   static snapshot() {
-    const captured = /* @__PURE__ */ new Map();
-    for (const storage of __substrateAsyncLocalStorages) captured.set(storage, storage.store);
-    return (callback, ...args) => {
-      const previous = /* @__PURE__ */ new Map();
-      for (const [storage, store] of captured) {
-        previous.set(storage, storage.store);
-        storage.store = store;
-      }
-      try {
-        return callback(...args);
-      } finally {
-        for (const [storage, store] of previous) storage.store = store;
-      }
-    };
+    const captured = currentFrame;
+    return (callback, ...args) => withFrame(captured, () => callback(...args));
   }
   static bind(callback) {
     const snapshot = AsyncLocalStorage.snapshot();
     return (...args) => snapshot(callback, ...args);
   }
   disable() {
+    if (!currentFrame.has(this)) return;
+    const next = new Map(currentFrame);
+    next.delete(this);
+    currentFrame = next;
   }
   getStore() {
-    return this.store;
+    return currentFrame.get(this);
   }
-  /**
-   * A store entered for an async callback used to be left the moment the
-   * callback returned its promise, so the first `await` inside a Server Action
-   * lost Next's request store and `cookies()` was "outside a request scope". A
-   * tab has no async_hooks and no AsyncContext, and an `await` of a native
-   * promise bypasses any `then` a patch could install, so the continuations
-   * cannot be followed. What can be done honestly is keep the store current
-   * until the callback's promise settles: exact for one run at a time, and
-   * last-entered-wins where two async runs overlap.
-   */
   run(store, callback, ...args) {
-    const prev = this.store;
-    this.store = store;
-    let result;
-    try {
-      result = callback(...args);
-    } catch (error) {
-      this.store = prev;
-      throw error;
-    }
-    if (result && typeof result.then === "function") {
-      const restore = () => {
-        if (this.store === store) this.store = prev;
-      };
-      result.then(restore, restore);
-      return result;
-    }
-    this.store = prev;
-    return result;
+    const next = new Map(currentFrame);
+    next.set(this, store);
+    return withFrame(next, () => callback(...args));
   }
   exit(callback) {
-    const prev = this.store;
-    this.store = void 0;
-    try {
-      return callback();
-    } finally {
-      this.store = prev;
-    }
+    const next = new Map(currentFrame);
+    next.delete(this);
+    return withFrame(next, callback);
   }
   enterWith(store) {
-    this.store = store;
+    const next = new Map(currentFrame);
+    next.set(this, store);
+    currentFrame = next;
+  }
+}
+class AsyncResource {
+  constructor(_type2, _options2) {
+    __publicField(this, "frame", currentFrame);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  runInAsyncScope(fn, thisArg, ...args) {
+    return withFrame(this.frame, () => fn.apply(thisArg, args));
+  }
+  emitDestroy() {
+    return this;
+  }
+  asyncId() {
+    return 0;
+  }
+  triggerAsyncId() {
+    return 0;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static bind(fn, _type2) {
+    return AsyncLocalStorage.bind(fn);
   }
 }
 forGuestRealm(() => {
@@ -6321,6 +6307,14 @@ forGuestRealm(() => {
   };
   takeFromHost(Promise.prototype, "then", carriedThen);
   takeFromHost(globalThis, "__substrateCarried", carried);
+  takeFromHost(globalThis, "__substrateContext", () => currentFrame);
+  takeFromHost(globalThis, "__substrateResume", (frame, value) => {
+    resumeFrame(frame);
+    return value;
+  });
+  takeFromHost(globalThis, "__substrateRestore", (frame) => {
+    resumeFrame(frame);
+  });
 });
 function createHook(_callbacks) {
   return {
@@ -29720,7 +29714,7 @@ Parser.acorn = {
 function parse3(input, options) {
   return Parser.parse(input, options);
 }
-class Script {
+let Script$1 = class Script {
   constructor(code2, _options2) {
     __publicField(this, "code");
     this.code = code2;
@@ -29783,7 +29777,7 @@ class Script {
   createCachedData() {
     return Buffer.from("");
   }
-}
+};
 function createContext(contextObject, _options2) {
   return contextObject || {};
 }
@@ -29794,7 +29788,7 @@ function runInThisContext(code, _options) {
   return eval(code);
 }
 function runInNewContext(code2, contextObject, _options2) {
-  const script = new Script(code2);
+  const script = new Script$1(code2);
   return script.runInNewContext(contextObject);
 }
 function runInContext(code2, context2, _options2) {
@@ -29832,7 +29826,7 @@ class SyntheticModule extends Module {
   }
 }
 const vm = {
-  Script,
+  Script: Script$1,
   createContext,
   isContext,
   runInThisContext,
@@ -29846,7 +29840,7 @@ const vm = {
 const vmShim = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   Module,
-  Script,
+  Script: Script$1,
   SourceTextModule,
   SyntheticModule,
   compileFunction,
@@ -34343,7 +34337,24 @@ function readPackageJson(cwd) {
   }
 }
 async function handleNpmRun(args, ctx) {
-  const scriptName = args[0];
+  let scriptName;
+  let silent = false;
+  let ifPresent = false;
+  const passed = [];
+  for (let index2 = 0; index2 < args.length; index2++) {
+    const arg = args[index2];
+    if (arg === "--") {
+      if (scriptName !== void 0) passed.push(...args.slice(index2 + 1));
+      break;
+    }
+    if (arg.startsWith("-") && arg !== "-") {
+      if (arg === "--silent" || arg === "-s" || arg === "--quiet" || arg === "-q" || arg === "--loglevel=silent") silent = true;
+      else if (arg === "--if-present") ifPresent = true;
+      continue;
+    }
+    if (scriptName === void 0) scriptName = arg;
+    else passed.push(arg);
+  }
   if (!scriptName) {
     return listScripts(ctx);
   }
@@ -34353,6 +34364,7 @@ async function handleNpmRun(args, ctx) {
   const scripts = pkgJson.scripts || {};
   const scriptCommand = scripts[scriptName];
   if (!scriptCommand) {
+    if (ifPresent) return { stdout: "", stderr: "", exitCode: 0 };
     const available = Object.keys(scripts);
     let msg2 = `npm ERR! Missing script: "${scriptName}"
 `;
@@ -34385,7 +34397,7 @@ async function handleNpmRun(args, ctx) {
   const label = `${pkgJson.name || ""}@${pkgJson.version || ""}`;
   const preScript = scripts[`pre${scriptName}`];
   if (preScript) {
-    allStderr += `
+    if (!silent) allStderr += `
 > ${label} pre${scriptName}
 > ${preScript}
 
@@ -34397,12 +34409,13 @@ async function handleNpmRun(args, ctx) {
       return { stdout: allStdout, stderr: allStderr, exitCode: preResult.exitCode };
     }
   }
-  allStderr += `
+  const command = passed.length > 0 ? `${scriptCommand} ${passed.map((arg) => /^[\w@%+=:,./-]+$/.test(arg) ? arg : `'${arg.replace(/'/g, `'\\''`)}'`).join(" ")}` : scriptCommand;
+  if (!silent) allStderr += `
 > ${label} ${scriptName}
-> ${scriptCommand}
+> ${command}
 
 `;
-  const mainResult = await ctx.exec(scriptCommand, { cwd: ctx.cwd, env: npmEnv });
+  const mainResult = await ctx.exec(command, { cwd: ctx.cwd, env: npmEnv, ...typeof ctx.stdin === "string" ? { stdin: ctx.stdin } : {} });
   allStdout += mainResult.stdout;
   allStderr += mainResult.stderr;
   if (mainResult.exitCode !== 0) {
@@ -34410,7 +34423,7 @@ async function handleNpmRun(args, ctx) {
   }
   const postScript = scripts[`post${scriptName}`];
   if (postScript) {
-    allStderr += `
+    if (!silent) allStderr += `
 > ${label} post${scriptName}
 > ${postScript}
 
@@ -37937,6 +37950,22 @@ function __substrateGuestConstructor(Constructor, process2) {
     return __substrateFunctionScope(__substrateGuestGlobal(process2), String(compiled));
   } });
 }
+const __substrateScriptScope = Function("__substrateScriptGlobals", "__substrateScriptSource", "with (__substrateScriptGlobals) { return eval(__substrateScriptSource); }");
+const __substrateGuestVms = /* @__PURE__ */ new WeakMap();
+function __substrateGuestVm(process2) {
+  let vm2 = __substrateGuestVms.get(process2);
+  if (vm2) return vm2;
+  const run = (code2) => __substrateScriptScope(__substrateGuestGlobal(process2), String(code2));
+  class Script2 extends Script$1 {
+    runInThisContext(_options2) {
+      return run(this.code);
+    }
+  }
+  vm2 = { ...vmShim, Script: Script2, runInThisContext: (code2, _options2) => run(code2), default: void 0 };
+  vm2.default = vm2;
+  __substrateGuestVms.set(process2, vm2);
+  return vm2;
+}
 function __substrateModuleTypes(code2, resolvedPath, format2, process2) {
   const typescript = format2 === void 0 ? /[.](?:ts|mts|cts)$/u.test(resolvedPath) && !resolvedPath.endsWith(".d.ts") : format2 === "typescript" || format2 === "commonjs-typescript" || format2 === "module-typescript";
   if (!typescript) return code2;
@@ -38149,6 +38178,72 @@ function collectDirectEval(node, replacements) {
   replacements.push([source.start, source.start, "__substrateEvalSource("]);
   replacements.push([source.end, source.end, ")"]);
 }
+const ASYNC_FRAME = "__substrateAsyncFrame";
+const FOLLOW_MARK = "/*substrate*/";
+const FOLLOW_TAKE = `const ${ASYNC_FRAME}=__substrateContext();`;
+const FOLLOW_RESTORE = `__substrateRestore(${ASYNC_FRAME});`;
+const FOLLOW_RESUME_FRAMED = `__substrateResume(${ASYNC_FRAME},`;
+const FOLLOW_RESUME_TAKEN = "__substrateResume(__substrateContext(),";
+function __substrateFollowAwaits(code2) {
+  if (!/\bawait\b/.test(code2)) return code2;
+  let ast;
+  try {
+    ast = parse3(code2, { ecmaVersion: "latest", sourceType: "script", allowReturnOutsideFunction: true, allowHashBang: true, allowAwaitOutsideFunction: true });
+  } catch {
+    return code2;
+  }
+  const edits = [];
+  const insert = (at2, text) => {
+    edits.push([at2, at2, text]);
+  };
+  const isFunction = (node) => node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
+  const visit = (node, framed, parent) => {
+    if (isFunction(node)) {
+      framed = node.async && node.body.type === "BlockStatement";
+      if (framed) {
+        const directives = node.body.body.filter((statement) => statement.directive !== void 0);
+        const at2 = directives.length ? directives[directives.length - 1].end : node.body.start + 1;
+        insert(at2, FOLLOW_TAKE);
+      }
+    } else if (node.type === "AwaitExpression") {
+      insert(node.start, framed ? FOLLOW_RESUME_FRAMED : FOLLOW_RESUME_TAKEN);
+      insert(node.end, `${FOLLOW_MARK})`);
+    } else if (framed && node.type === "CatchClause") {
+      insert(node.body.start + 1, FOLLOW_RESTORE);
+    } else if (framed && node.type === "TryStatement" && node.finalizer) {
+      insert(node.finalizer.start + 1, FOLLOW_RESTORE);
+    } else if (framed && node.type === "ForOfStatement" && node.await) {
+      const whole = (parent == null ? void 0 : parent.type) === "LabeledStatement" ? parent : node;
+      insert(whole.start, `{${FOLLOW_MARK}`);
+      insert(whole.end, `;${FOLLOW_RESTORE}${FOLLOW_MARK}}`);
+      if (node.body.type === "BlockStatement") insert(node.body.start + 1, FOLLOW_RESTORE);
+      else {
+        insert(node.body.start, `{${FOLLOW_MARK}${FOLLOW_RESTORE}`);
+        insert(node.body.end, `${FOLLOW_MARK}}`);
+      }
+    }
+    for (const key of Object.keys(node)) {
+      if (key === "type" || key === "start" || key === "end" || key === "loc" || key === "range") continue;
+      const child = node[key];
+      if (!child || typeof child !== "object") continue;
+      if (Array.isArray(child)) {
+        for (const item of child) if (item && typeof item.type === "string") visit(item, framed, node);
+      } else if (typeof child.type === "string") visit(child, framed, node);
+    }
+  };
+  visit(ast, false, void 0);
+  return edits.length ? applyReplacements(code2, edits) : code2;
+}
+function __substrateUnfollowAwaits(source) {
+  if (!source.includes("__substrate")) return source;
+  return source.replaceAll(`;${FOLLOW_RESTORE}${FOLLOW_MARK}}`, "").replaceAll(`{${FOLLOW_MARK}${FOLLOW_RESTORE}`, "").replaceAll(`{${FOLLOW_MARK}`, "").replaceAll(`${FOLLOW_MARK}}`, "").replaceAll(`${FOLLOW_MARK})`, "").replaceAll(FOLLOW_TAKE, "").replaceAll(FOLLOW_RESTORE, "").replaceAll(FOLLOW_RESUME_FRAMED, "").replaceAll(FOLLOW_RESUME_TAKEN, "");
+}
+forGuestRealm(() => {
+  const native = Function.prototype.toString;
+  takeFromHost(Function.prototype, "toString", function toString2() {
+    return __substrateUnfollowAwaits(native.call(this));
+  });
+});
 function applyReplacements(code2, replacements) {
   replacements.sort((a, b) => b[0] - a[0] || b[1] - a[1]);
   let out = code2;
@@ -38170,12 +38265,12 @@ function __substratePrepareBody(rawCode, resolvedPath, format2, process2) {
     const lowered = transformEsmToCjs(code2, resolvedPath);
     code2 = lowered === code2 ? code2 : `${__substrateModuleMarker}"use strict";${lowered}`;
   } else {
-    code2 = transformDynamicImportsRegex(code2);
+    code2 = __substrateRewriteDynamicImportsInScript(code2);
   }
-  return code2;
+  return __substrateFollowAwaits(code2);
 }
 const PREPARED_MODULES_DIR = "/.tabnode/prepared";
-const PREPARED_MODULES_FORMAT = "tabnode-prepared-1";
+const PREPARED_MODULES_FORMAT = "tabnode-prepared-2";
 function preparedModuleKey(rawCode, resolvedPath) {
   var _a2;
   const extension = (_a2 = /\.(js|cjs|mjs)$/u.exec(resolvedPath)) == null ? void 0 : _a2[1];
@@ -38320,6 +38415,17 @@ async function __substrateImportChain(hooks, id, parentURL, moduleRequire) {
   }));
   return doors.__loadFromURL(resolved.url, loaded2.format ?? resolved.format, loaded2.source ?? void 0);
 }
+function createImportMeta(moduleRequire, url2, dirname2, filename) {
+  const resolve2 = (specifier, parent) => {
+    const id = typeof specifier === "string" ? specifier : String(specifier);
+    const base = parent === void 0 ? url2 : String(parent);
+    if (id.startsWith("./") || id.startsWith("../") || id.startsWith("/")) return new URL(id, base).href;
+    if (/^[a-zA-Z][a-zA-Z\d+.-]*:/.test(id)) return id.startsWith("node:") ? id : new URL(id).href;
+    if (Object.prototype.hasOwnProperty.call(builtinModules, id)) return `node:${id}`;
+    return "file://" + moduleRequire.resolve(id);
+  };
+  return { url: url2, dirname: dirname2, filename, resolve: resolve2 };
+}
 function createDynamicImport(moduleRequire, process2, parentURL) {
   return async (specifier) => {
     var _a2;
@@ -39288,7 +39394,7 @@ function createRequire(vfs2, fsShim, process2, currentDir, moduleCache, options,
         dirname2,
         process2,
         consoleWrapper,
-        { url: importMetaUrl, dirname: dirname2, filename: resolvedPath },
+        createImportMeta(moduleRequire, importMetaUrl, dirname2, resolvedPath),
         dynamicImport,
         __substrateGuestGlobal,
         __substrateGuestConstructor
@@ -39391,6 +39497,9 @@ function createRequire(vfs2, fsShim, process2, currentDir, moduleCache, options,
     if (id === "module") {
       return __substrateModule();
     }
+    if (id === "vm") {
+      return __substrateGuestVm(process2);
+    }
     if (id === "wasi") {
       return __substrateGuestWasi(fsShim, process2);
     }
@@ -39613,7 +39722,7 @@ class Runtime {
       const lowered = transformEsmToCjs(code2, filename);
       code2 = lowered === code2 ? code2 : `${__substrateModuleMarker}"use strict";${lowered}`;
     } else {
-      code2 = transformDynamicImportsRegex(code2);
+      code2 = __substrateRewriteDynamicImportsInScript(code2);
     }
     try {
       const importMetaUrl = "file://" + filename;
@@ -39644,7 +39753,7 @@ class Runtime {
         dirname$1,
         this.process,
         consoleWrapper,
-        { url: importMetaUrl, dirname: dirname$1, filename },
+        createImportMeta(require2, importMetaUrl, dirname$1, filename),
         dynamicImport,
         __substrateGuestGlobal,
         __substrateGuestConstructor
@@ -40120,7 +40229,7 @@ class WorkerRuntime {
     this.worker = new Worker(
       new URL(
         /* @vite-ignore */
-        "/assets/runtime-worker-DPvtXRd8.js",
+        "/assets/runtime-worker-Dv_vTkXr.js",
         import.meta.url
       ),
       { type: "module" }

package/dist/shims/async_hooks.d.ts

@@ -1,35 +1,26 @@
 /**
- * async_hooks shim - Async tracking is not available in browser
+ * async_hooks shim: AsyncLocalStorage and AsyncResource carry context the way
+ * Node's do; the hooks themselves are not available in a browser.
  */
-export declare class AsyncResource {
-    constructor(_type: string, _options?: object);
-    runInAsyncScope<T>(fn: (...args: any[]) => T, thisArg?: unknown, ...args: any[]): T;
-    emitDestroy(): this;
-    asyncId(): number;
-    triggerAsyncId(): number;
-    static bind<T extends (...args: any[]) => any>(fn: T, _type?: string): T;
-}
 export declare class AsyncLocalStorage<T> {
-    private store;
-    constructor();
     static snapshot(): (callback: (...args: unknown[]) => unknown, ...args: unknown[]) => unknown;
     static bind(callback: (...args: unknown[]) => unknown): (...args: unknown[]) => unknown;
     disable(): void;
     getStore(): T | undefined;
-    /**
-     * A store entered for an async callback used to be left the moment the
-     * callback returned its promise, so the first `await` inside a Server Action
-     * lost Next's request store and `cookies()` was "outside a request scope". A
-     * tab has no async_hooks and no AsyncContext, and an `await` of a native
-     * promise bypasses any `then` a patch could install, so the continuations
-     * cannot be followed. What can be done honestly is keep the store current
-     * until the callback's promise settles: exact for one run at a time, and
-     * last-entered-wins where two async runs overlap.
-     */
     run<R>(store: T, callback: (...args: unknown[]) => R, ...args: unknown[]): R;
     exit<R>(callback: () => R): R;
     enterWith(store: T): void;
 }
+/** Runs its callbacks in the context it was made in, as Node's does. */
+export declare class AsyncResource {
+    private readonly frame;
+    constructor(_type: string, _options?: object);
+    runInAsyncScope<T>(fn: (...args: any[]) => T, thisArg?: unknown, ...args: any[]): T;
+    emitDestroy(): this;
+    asyncId(): number;
+    triggerAsyncId(): number;
+    static bind<T extends (...args: any[]) => any>(fn: T, _type?: string): T;
+}
 export interface AsyncHook {
     enable(): this;
     disable(): this;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/tabnode",
-  "version": "0.5.27",
+  "version": "0.5.29",
   "description": "Node's own library, in a browser tab.",
   "type": "module",
   "license": "MIT",