@volter/tabnode 0.5.20 → 0.5.22

package/dist/assets/{runtime-worker-IRKbkQwk.js → runtime-worker-Bw5ePWPu.js}

@@ -8246,20 +8246,30 @@ function descriptorWriter(fd2) {
   if (!file || file.directory || (file.flags & 3) === 0) return null;
   const { tree: tree2, path: path2 } = file;
   const append = (file.flags & flagBits().append) !== 0;
-  let position = file.position;
+  let cursor = descriptorCursors.get(file);
+  if (!cursor) {
+    cursor = { position: file.position };
+    descriptorCursors.set(file, cursor);
+  }
+  const offset2 = cursor;
   return (text) => {
     const bytes2 = new TextEncoder().encode(text);
     const shared = openFiles.get(fd2) === file ? file : null;
+    if (shared) offset2.position = shared.position;
     const existing = (shared == null ? void 0 : shared.cached) ?? (tree2.existsSync(path2) ? tree2.readFileSync(path2) : new Uint8Array(0));
-    const at3 = append ? existing.length : position;
+    const at3 = append ? existing.length : offset2.position;
     const next2 = new Uint8Array(Math.max(existing.length, at3 + bytes2.length));
     next2.set(existing, 0);
     next2.set(bytes2, at3);
     tree2.writeFileSync(path2, next2);
-    position = at3 + bytes2.length;
-    if (shared) shared.cached = next2;
+    offset2.position = at3 + bytes2.length;
+    if (shared) {
+      shared.cached = next2;
+      shared.position = offset2.position;
+    }
   };
 }
+const descriptorCursors = /* @__PURE__ */ new WeakMap();
 function statArray(stats, bigint, path2) {
   var _a3, _b3, _c3;
   const mtime = stats.mtime instanceof Date ? stats.mtime.getTime() : Number(stats.mtimeMs ?? 0);
@@ -23695,6 +23705,83 @@ function createCryptoModule(require2) {
     const keyInfo = extractKeyInfo(key);
     return new KeyObject2("private", keyInfo.keyData, keyInfo.algorithm);
   }
+  const NAMED_CURVES = {
+    "prime256v1": "P-256",
+    "p-256": "P-256",
+    "secp256r1": "P-256",
+    "secp384r1": "P-384",
+    "p-384": "P-384",
+    "secp521r1": "P-521",
+    "p-521": "P-521"
+  };
+  function keyPairAlgorithm(type2, options) {
+    const exponent = (value) => {
+      let rest = value ?? 65537;
+      const bytes2 = [];
+      while (rest > 0) {
+        bytes2.unshift(rest & 255);
+        rest = Math.floor(rest / 256);
+      }
+      return new Uint8Array(bytes2);
+    };
+    switch (type2) {
+      case "rsa":
+      case "rsa-pss": {
+        if (!Number.isInteger(options.modulusLength)) throw Object.assign(new TypeError('The "options.modulusLength" property must be of type number.'), { code: "ERR_INVALID_ARG_TYPE" });
+        const name = type2 === "rsa" ? "RSASSA-PKCS1-v1_5" : "RSA-PSS";
+        return { generate: { name, modulusLength: options.modulusLength, publicExponent: exponent(options.publicExponent), hash: "SHA-256" }, usages: ["sign", "verify"], name: type2 === "rsa" ? "RSA-SHA256" : "RSA-PSS" };
+      }
+      case "ec": {
+        const curve = NAMED_CURVES[String(options.namedCurve ?? "").toLowerCase()];
+        if (!curve) throw Object.assign(new TypeError(`Invalid EC curve name ${String(options.namedCurve)}`), { code: "ERR_CRYPTO_INVALID_CURVE" });
+        return { generate: { name: "ECDSA", namedCurve: curve }, usages: ["sign", "verify"], name: curve === "P-256" ? "ES256" : curve === "P-384" ? "ES384" : "ES512" };
+      }
+      case "ed25519":
+        return { generate: { name: "Ed25519" }, usages: ["sign", "verify"], name: "Ed25519" };
+      case "x25519":
+        return { generate: { name: "X25519" }, usages: ["deriveBits"], name: "X25519" };
+      default:
+        throw Object.assign(new TypeError(`The argument 'type' must be a supported key type. Received '${type2}'`), { code: "ERR_INVALID_ARG_VALUE" });
+    }
+  }
+  function encodedKey(der, encoding, kind) {
+    const expected = kind === "public" ? "spki" : "pkcs8";
+    if (encoding.type !== void 0 && encoding.type !== expected) {
+      unsupported2(`Encoding a ${kind} key as ${encoding.type}`);
+    }
+    const bytes2 = Buffer2.from(der);
+    if (encoding.format === "der") return bytes2;
+    if (encoding.format !== "pem") unsupported2(`Encoding a key in the ${String(encoding.format)} format`);
+    const label = kind === "public" ? "PUBLIC KEY" : "PRIVATE KEY";
+    const body = bytes2.toString("base64").match(/.{1,64}/g).join("\n");
+    return `-----BEGIN ${label}-----
+${body}
+-----END ${label}-----
+`;
+  }
+  async function generateKeyPairAsync(type2, options) {
+    const algorithm = keyPairAlgorithm(type2, options);
+    const pair = await crypto.subtle.generateKey(algorithm.generate, true, algorithm.usages);
+    const publicKey = options.publicKeyEncoding ? encodedKey(await crypto.subtle.exportKey("spki", pair.publicKey), options.publicKeyEncoding, "public") : new KeyObject2("public", pair.publicKey, algorithm.name);
+    const privateKey = options.privateKeyEncoding ? encodedKey(await crypto.subtle.exportKey("pkcs8", pair.privateKey), options.privateKeyEncoding, "private") : new KeyObject2("private", pair.privateKey, algorithm.name);
+    return { publicKey, privateKey };
+  }
+  function generateKeyPair2(type2, options, callback) {
+    if (typeof options === "function") {
+      callback = options;
+      options = {};
+    }
+    if (typeof callback !== "function") throw Object.assign(new TypeError('The "callback" argument must be of type function.'), { code: "ERR_INVALID_ARG_TYPE" });
+    const done = callback;
+    keyPairAlgorithm(type2, options ?? {});
+    generateKeyPairAsync(type2, options ?? {}).then(
+      ({ publicKey, privateKey }) => done(null, publicKey, privateKey),
+      (error) => done(error instanceof Error ? error : new Error(String(error)))
+    );
+  }
+  Object.defineProperty(generateKeyPair2, Symbol.for("nodejs.util.promisify.custom"), {
+    value: (type2, options) => generateKeyPairAsync(type2, options ?? {})
+  });
   function timingSafeEqual2(a, b) {
     if (a.length !== b.length) {
       return false;
@@ -23851,11 +23938,12 @@ function createCryptoModule(require2) {
     KeyObject: KeyObject2,
     createSecretKey: createSecretKey2,
     createPublicKey: createPublicKey2,
-    createPrivateKey: createPrivateKey2
+    createPrivateKey: createPrivateKey2,
+    generateKeyPair: generateKeyPair2
   };
 }
 const cryptoModule = createCryptoModule();
-const { randomBytes, randomFillSync, randomFill, randomUUID, randomInt, getRandomValues, unsupported, createHash, createHmac, hash, pbkdf2Sync, pbkdf2, sign, verify, createSign, createVerify, KeyObject, createSecretKey, createPublicKey, createPrivateKey, timingSafeEqual, getCiphers, getHashes } = cryptoModule;
+const { randomBytes, randomFillSync, randomFill, randomUUID, randomInt, getRandomValues, unsupported, createHash, createHmac, hash, pbkdf2Sync, pbkdf2, sign, verify, createSign, createVerify, KeyObject, createSecretKey, createPublicKey, createPrivateKey, generateKeyPair, timingSafeEqual, getCiphers, getHashes } = cryptoModule;
 var cryptoShim = /* @__PURE__ */ Object.freeze({
   __proto__: null,
   KeyObject,
@@ -23869,6 +23957,7 @@ var cryptoShim = /* @__PURE__ */ Object.freeze({
   createSign,
   createVerify,
   default: cryptoModule,
+  generateKeyPair,
   getCiphers,
   getHashes,
   getRandomValues,
@@ -74566,8 +74655,15 @@ async function handleNpmInstall(args, ctx) {
   }
 }
 async function handleNpmInit(args, ctx) {
+  var _a3;
   const yes = args.includes("-y") || args.includes("--yes");
-  const initializer = args.find((a) => !a.startsWith("-"));
+  const takesValue = (flag) => !flag.includes("=") && (flag === "--scope" || flag === "-w" || flag === "--workspace" || flag.startsWith("--init-"));
+  const valueOf = (flag) => {
+    const at3 = args.findIndex((a) => a === flag || a.startsWith(`${flag}=`));
+    if (at3 < 0) return void 0;
+    return args[at3].includes("=") ? args[at3].slice(args[at3].indexOf("=") + 1) : args[at3 + 1];
+  };
+  const initializer = args.find((a, i10) => !a.startsWith("-") && !(i10 > 0 && takesValue(args[i10 - 1])));
   if (initializer) {
     return { stdout: "", stderr: `npm ERR! npm init ${initializer} runs an initializer package, which this engine's npm does not; write package.json, or run \`npm init -y\`.
 `, exitCode: 1 };
@@ -74587,7 +74683,9 @@ async function handleNpmInit(args, ctx) {
     }
   }
   const base = ctx.cwd.split("/").filter(Boolean).pop() ?? "package";
-  const name = base.toLowerCase().replace(/^[._]+/, "").replace(/[^a-z0-9._~-]+/g, "-") || "package";
+  const bare = base.toLowerCase().replace(/^[._]+/, "").replace(/[^a-z0-9._~-]+/g, "-") || "package";
+  const scope = (_a3 = valueOf("--scope")) == null ? void 0 : _a3.replace(/^@?/, "@");
+  const name = scope ? `${scope}/${bare}` : bare;
   const manifest = {
     name,
     version: "1.0.0",

package/dist/index.mjs

@@ -8402,20 +8402,30 @@ function descriptorWriter(fd) {
   if (!file || file.directory || (file.flags & 3) === 0) return null;
   const { tree: tree2, path: path2 } = file;
   const append = (file.flags & flagBits().append) !== 0;
-  let position = file.position;
+  let cursor = descriptorCursors.get(file);
+  if (!cursor) {
+    cursor = { position: file.position };
+    descriptorCursors.set(file, cursor);
+  }
+  const offset2 = cursor;
   return (text) => {
     const bytes2 = new TextEncoder().encode(text);
     const shared = openFiles.get(fd) === file ? file : null;
+    if (shared) offset2.position = shared.position;
     const existing = (shared == null ? void 0 : shared.cached) ?? (tree2.existsSync(path2) ? tree2.readFileSync(path2) : new Uint8Array(0));
-    const at2 = append ? existing.length : position;
+    const at2 = append ? existing.length : offset2.position;
     const next = new Uint8Array(Math.max(existing.length, at2 + bytes2.length));
     next.set(existing, 0);
     next.set(bytes2, at2);
     tree2.writeFileSync(path2, next);
-    position = at2 + bytes2.length;
-    if (shared) shared.cached = next;
+    offset2.position = at2 + bytes2.length;
+    if (shared) {
+      shared.cached = next;
+      shared.position = offset2.position;
+    }
   };
 }
+const descriptorCursors = /* @__PURE__ */ new WeakMap();
 function statArray(stats, bigint, path2) {
   var _a2, _b2, _c2;
   const mtime = stats.mtime instanceof Date ? stats.mtime.getTime() : Number(stats.mtimeMs ?? 0);
@@ -23871,6 +23881,83 @@ function createCryptoModule(require2) {
     const keyInfo = extractKeyInfo(key);
     return new KeyObject2("private", keyInfo.keyData, keyInfo.algorithm);
   }
+  const NAMED_CURVES = {
+    "prime256v1": "P-256",
+    "p-256": "P-256",
+    "secp256r1": "P-256",
+    "secp384r1": "P-384",
+    "p-384": "P-384",
+    "secp521r1": "P-521",
+    "p-521": "P-521"
+  };
+  function keyPairAlgorithm(type2, options) {
+    const exponent = (value) => {
+      let rest = value ?? 65537;
+      const bytes2 = [];
+      while (rest > 0) {
+        bytes2.unshift(rest & 255);
+        rest = Math.floor(rest / 256);
+      }
+      return new Uint8Array(bytes2);
+    };
+    switch (type2) {
+      case "rsa":
+      case "rsa-pss": {
+        if (!Number.isInteger(options.modulusLength)) throw Object.assign(new TypeError('The "options.modulusLength" property must be of type number.'), { code: "ERR_INVALID_ARG_TYPE" });
+        const name = type2 === "rsa" ? "RSASSA-PKCS1-v1_5" : "RSA-PSS";
+        return { generate: { name, modulusLength: options.modulusLength, publicExponent: exponent(options.publicExponent), hash: "SHA-256" }, usages: ["sign", "verify"], name: type2 === "rsa" ? "RSA-SHA256" : "RSA-PSS" };
+      }
+      case "ec": {
+        const curve = NAMED_CURVES[String(options.namedCurve ?? "").toLowerCase()];
+        if (!curve) throw Object.assign(new TypeError(`Invalid EC curve name ${String(options.namedCurve)}`), { code: "ERR_CRYPTO_INVALID_CURVE" });
+        return { generate: { name: "ECDSA", namedCurve: curve }, usages: ["sign", "verify"], name: curve === "P-256" ? "ES256" : curve === "P-384" ? "ES384" : "ES512" };
+      }
+      case "ed25519":
+        return { generate: { name: "Ed25519" }, usages: ["sign", "verify"], name: "Ed25519" };
+      case "x25519":
+        return { generate: { name: "X25519" }, usages: ["deriveBits"], name: "X25519" };
+      default:
+        throw Object.assign(new TypeError(`The argument 'type' must be a supported key type. Received '${type2}'`), { code: "ERR_INVALID_ARG_VALUE" });
+    }
+  }
+  function encodedKey(der, encoding, kind) {
+    const expected = kind === "public" ? "spki" : "pkcs8";
+    if (encoding.type !== void 0 && encoding.type !== expected) {
+      unsupported2(`Encoding a ${kind} key as ${encoding.type}`);
+    }
+    const bytes2 = Buffer2.from(der);
+    if (encoding.format === "der") return bytes2;
+    if (encoding.format !== "pem") unsupported2(`Encoding a key in the ${String(encoding.format)} format`);
+    const label = kind === "public" ? "PUBLIC KEY" : "PRIVATE KEY";
+    const body = bytes2.toString("base64").match(/.{1,64}/g).join("\n");
+    return `-----BEGIN ${label}-----
+${body}
+-----END ${label}-----
+`;
+  }
+  async function generateKeyPairAsync(type2, options) {
+    const algorithm = keyPairAlgorithm(type2, options);
+    const pair = await crypto.subtle.generateKey(algorithm.generate, true, algorithm.usages);
+    const publicKey = options.publicKeyEncoding ? encodedKey(await crypto.subtle.exportKey("spki", pair.publicKey), options.publicKeyEncoding, "public") : new KeyObject2("public", pair.publicKey, algorithm.name);
+    const privateKey = options.privateKeyEncoding ? encodedKey(await crypto.subtle.exportKey("pkcs8", pair.privateKey), options.privateKeyEncoding, "private") : new KeyObject2("private", pair.privateKey, algorithm.name);
+    return { publicKey, privateKey };
+  }
+  function generateKeyPair2(type2, options, callback) {
+    if (typeof options === "function") {
+      callback = options;
+      options = {};
+    }
+    if (typeof callback !== "function") throw Object.assign(new TypeError('The "callback" argument must be of type function.'), { code: "ERR_INVALID_ARG_TYPE" });
+    const done = callback;
+    keyPairAlgorithm(type2, options ?? {});
+    generateKeyPairAsync(type2, options ?? {}).then(
+      ({ publicKey, privateKey }) => done(null, publicKey, privateKey),
+      (error) => done(error instanceof Error ? error : new Error(String(error)))
+    );
+  }
+  Object.defineProperty(generateKeyPair2, Symbol.for("nodejs.util.promisify.custom"), {
+    value: (type2, options) => generateKeyPairAsync(type2, options ?? {})
+  });
   function timingSafeEqual2(a, b) {
     if (a.length !== b.length) {
       return false;
@@ -24027,11 +24114,12 @@ function createCryptoModule(require2) {
     KeyObject: KeyObject2,
     createSecretKey: createSecretKey2,
     createPublicKey: createPublicKey2,
-    createPrivateKey: createPrivateKey2
+    createPrivateKey: createPrivateKey2,
+    generateKeyPair: generateKeyPair2
   };
 }
 const cryptoModule = createCryptoModule();
-const { randomBytes, randomFillSync, randomFill, randomUUID, randomInt, getRandomValues, unsupported: unsupported$1, createHash, createHmac, hash, pbkdf2Sync, pbkdf2, sign, verify, createSign, createVerify, KeyObject, createSecretKey, createPublicKey, createPrivateKey, timingSafeEqual, getCiphers, getHashes } = cryptoModule;
+const { randomBytes, randomFillSync, randomFill, randomUUID, randomInt, getRandomValues, unsupported: unsupported$1, createHash, createHmac, hash, pbkdf2Sync, pbkdf2, sign, verify, createSign, createVerify, KeyObject, createSecretKey, createPublicKey, createPrivateKey, generateKeyPair, timingSafeEqual, getCiphers, getHashes } = cryptoModule;
 const cryptoShim = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   KeyObject,
@@ -24045,6 +24133,7 @@ const cryptoShim = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   createSign,
   createVerify,
   default: cryptoModule,
+  generateKeyPair,
   getCiphers,
   getHashes,
   getRandomValues,
@@ -34229,8 +34318,15 @@ async function handleNpmInstall(args, ctx) {
   }
 }
 async function handleNpmInit(args, ctx) {
+  var _a2;
   const yes = args.includes("-y") || args.includes("--yes");
-  const initializer = args.find((a) => !a.startsWith("-"));
+  const takesValue = (flag) => !flag.includes("=") && (flag === "--scope" || flag === "-w" || flag === "--workspace" || flag.startsWith("--init-"));
+  const valueOf = (flag) => {
+    const at2 = args.findIndex((a) => a === flag || a.startsWith(`${flag}=`));
+    if (at2 < 0) return void 0;
+    return args[at2].includes("=") ? args[at2].slice(args[at2].indexOf("=") + 1) : args[at2 + 1];
+  };
+  const initializer = args.find((a, i2) => !a.startsWith("-") && !(i2 > 0 && takesValue(args[i2 - 1])));
   if (initializer) {
     return { stdout: "", stderr: `npm ERR! npm init ${initializer} runs an initializer package, which this engine's npm does not; write package.json, or run \`npm init -y\`.
 `, exitCode: 1 };
@@ -34250,7 +34346,9 @@ async function handleNpmInit(args, ctx) {
     }
   }
   const base = ctx.cwd.split("/").filter(Boolean).pop() ?? "package";
-  const name = base.toLowerCase().replace(/^[._]+/, "").replace(/[^a-z0-9._~-]+/g, "-") || "package";
+  const bare = base.toLowerCase().replace(/^[._]+/, "").replace(/[^a-z0-9._~-]+/g, "-") || "package";
+  const scope = (_a2 = valueOf("--scope")) == null ? void 0 : _a2.replace(/^@?/, "@");
+  const name = scope ? `${scope}/${bare}` : bare;
   const manifest = {
     name,
     version: "1.0.0",
@@ -39827,7 +39925,7 @@ class WorkerRuntime {
     this.worker = new Worker(
       new URL(
         /* @vite-ignore */
-        "/assets/runtime-worker-IRKbkQwk.js",
+        "/assets/runtime-worker-Bw5ePWPu.js",
         import.meta.url
       ),
       { type: "module" }

package/dist/shims/crypto.d.ts

@@ -245,6 +245,19 @@ export declare function createCryptoModule(require?: (name: string) => any): {
             format?: string;
         }): Buffer | string;
     };
+    generateKeyPair: (type: string, options: {
+        modulusLength?: number;
+        publicExponent?: number;
+        namedCurve?: string;
+        publicKeyEncoding?: {
+            type?: string;
+            format?: string;
+        };
+        privateKeyEncoding?: {
+            type?: string;
+            format?: string;
+        };
+    } | ((error: Error | null, publicKey?: unknown, privateKey?: unknown) => void), callback?: (error: Error | null, publicKey?: unknown, privateKey?: unknown) => void) => void;
 };
 declare const cryptoModule: {
     unsupported: (operation: string) => never;
@@ -477,6 +490,19 @@ declare const cryptoModule: {
             format?: string;
         }): Buffer | string;
     };
+    generateKeyPair: (type: string, options: {
+        modulusLength?: number;
+        publicExponent?: number;
+        namedCurve?: string;
+        publicKeyEncoding?: {
+            type?: string;
+            format?: string;
+        };
+        privateKeyEncoding?: {
+            type?: string;
+            format?: string;
+        };
+    } | ((error: Error | null, publicKey?: unknown, privateKey?: unknown) => void), callback?: (error: Error | null, publicKey?: unknown, privateKey?: unknown) => void) => void;
 };
 export declare const randomBytes: {
     (size: number): Buffer;
@@ -679,6 +705,18 @@ export declare const randomBytes: {
         type?: string;
         format?: string;
     }): Buffer | string;
-}, timingSafeEqual: (a: Buffer | Uint8Array, b: Buffer | Uint8Array) => boolean, getCiphers: () => string[], getHashes: () => string[];
+}, generateKeyPair: (type: string, options: {
+    modulusLength?: number;
+    publicExponent?: number;
+    namedCurve?: string;
+    publicKeyEncoding?: {
+        type?: string;
+        format?: string;
+    };
+    privateKeyEncoding?: {
+        type?: string;
+        format?: string;
+    };
+} | ((error: Error | null, publicKey?: unknown, privateKey?: unknown) => void), callback?: (error: Error | null, publicKey?: unknown, privateKey?: unknown) => void) => void, timingSafeEqual: (a: Buffer | Uint8Array, b: Buffer | Uint8Array) => boolean, getCiphers: () => string[], getHashes: () => string[];
 export type KeyObject = InstanceType<typeof KeyObject>;
 export default cryptoModule;

package/package.json

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

package/src/node-lib/binding/fs.ts

@@ -186,21 +186,28 @@ export function descriptorWriter(fd: number): ((text: string) => void) | null {
   if (!file || file.directory || (file.flags & 3) === 0) return null;
   const { tree, path } = file;
   const append = (file.flags & flagBits().append) !== 0;
-  let position = file.position;
+  // One offset per open file, as a dup'd descriptor shares one: a child's
+  // stdout and stderr on the same file follow each other, and the parent's
+  // own position moves with them while its copy is open.
+  let cursor = descriptorCursors.get(file);
+  if (!cursor) { cursor = { position: file.position }; descriptorCursors.set(file, cursor); }
+  const offset = cursor;
   return (text) => {
     const bytes = new TextEncoder().encode(text);
     // the parent's copy, while it is open, holds the file's bytes as it last wrote them
     const shared = openFiles.get(fd) === file ? file : null;
+    if (shared) offset.position = shared.position;
     const existing = shared?.cached ?? (tree.existsSync(path) ? tree.readFileSync(path) as Uint8Array : new Uint8Array(0));
-    const at = append ? existing.length : position;
+    const at = append ? existing.length : offset.position;
     const next = new Uint8Array(Math.max(existing.length, at + bytes.length));
     next.set(existing, 0);
     next.set(bytes, at);
     tree.writeFileSync(path, next);
-    position = at + bytes.length;
-    if (shared) shared.cached = next;
+    offset.position = at + bytes.length;
+    if (shared) { shared.cached = next; shared.position = offset.position; }
   };
 }
+const descriptorCursors = new WeakMap<object, { position: number }>();
 
 /** Node's stat array: eighteen numbers, with each time a second and a nanosecond. */
 function statArray(stats: VfsStats, bigint: boolean, path?: string): Float64Array | BigInt64Array {

package/src/shims/child_process.ts

@@ -1308,7 +1308,14 @@ async function handleNpmInstall(args: string[], ctx: CommandContext): Promise<Ju
  */
 async function handleNpmInit(args: string[], ctx: CommandContext): Promise<JustBashExecResult> {
   const yes = args.includes('-y') || args.includes('--yes');
-  const initializer = args.find((a) => !a.startsWith('-'));
+  // a flag's value is not an initializer: `--scope @x`, `-w pkg`, `--init-license MIT`
+  const takesValue = (flag: string) => !flag.includes('=') && (flag === '--scope' || flag === '-w' || flag === '--workspace' || flag.startsWith('--init-'));
+  const valueOf = (flag: string) => {
+    const at = args.findIndex((a) => a === flag || a.startsWith(`${flag}=`));
+    if (at < 0) return undefined;
+    return args[at].includes('=') ? args[at].slice(args[at].indexOf('=') + 1) : args[at + 1];
+  };
+  const initializer = args.find((a, i) => !a.startsWith('-') && !(i > 0 && takesValue(args[i - 1]!)));
   if (initializer) {
     return { stdout: '', stderr: `npm ERR! npm init ${initializer} runs an initializer package, which this engine's npm does not; write package.json, or run \`npm init -y\`.\n`, exitCode: 1 };
   }
@@ -1323,7 +1330,9 @@ async function handleNpmInit(args: string[], ctx: CommandContext): Promise<JustB
     catch { return { stdout: '', stderr: `npm ERR! ${file} is not valid JSON\n`, exitCode: 1 }; }
   }
   const base = ctx.cwd.split('/').filter(Boolean).pop() ?? 'package';
-  const name = base.toLowerCase().replace(/^[._]+/, '').replace(/[^a-z0-9._~-]+/g, '-') || 'package';
+  const bare = base.toLowerCase().replace(/^[._]+/, '').replace(/[^a-z0-9._~-]+/g, '-') || 'package';
+  const scope = valueOf('--scope')?.replace(/^@?/, '@');
+  const name = scope ? `${scope}/${bare}` : bare;
   const manifest = {
     name,
     version: '1.0.0',

package/src/shims/crypto.ts

@@ -800,6 +800,92 @@ function createPrivateKey(key: KeyLike): KeyObject {
   return new KeyObject('private', keyInfo.keyData as Uint8Array, keyInfo.algorithm);
 }
 
+// ============================================================================
+// generateKeyPair: Node's asynchronous key generation, done by WebCrypto.
+// A browser has no synchronous key generation, so generateKeyPairSync stays
+// absent; the callback form and its promisified form (which resolves
+// { publicKey, privateKey }, as Node's custom promisify does) are complete for
+// the types WebCrypto generates. jose's Node build promisifies this function
+// when it loads, so its absence failed any module that imported jose.
+// ============================================================================
+
+type KeyEncoding = { type?: string; format?: string };
+type KeyPairOptions = { modulusLength?: number; publicExponent?: number; namedCurve?: string; publicKeyEncoding?: KeyEncoding; privateKeyEncoding?: KeyEncoding };
+
+const NAMED_CURVES: Record<string, string> = {
+  'prime256v1': 'P-256', 'p-256': 'P-256', 'secp256r1': 'P-256',
+  'secp384r1': 'P-384', 'p-384': 'P-384',
+  'secp521r1': 'P-521', 'p-521': 'P-521',
+};
+
+function keyPairAlgorithm(type: string, options: KeyPairOptions): { generate: AlgorithmIdentifier & Record<string, unknown>; usages: KeyUsage[]; name: string } {
+  const exponent = (value: number | undefined): Uint8Array => {
+    let rest = value ?? 0x10001;
+    const bytes: number[] = [];
+    while (rest > 0) { bytes.unshift(rest & 0xff); rest = Math.floor(rest / 256); }
+    return new Uint8Array(bytes);
+  };
+  switch (type) {
+    case 'rsa':
+    case 'rsa-pss': {
+      if (!Number.isInteger(options.modulusLength)) throw Object.assign(new TypeError('The "options.modulusLength" property must be of type number.'), { code: 'ERR_INVALID_ARG_TYPE' });
+      const name = type === 'rsa' ? 'RSASSA-PKCS1-v1_5' : 'RSA-PSS';
+      return { generate: { name, modulusLength: options.modulusLength, publicExponent: exponent(options.publicExponent), hash: 'SHA-256' }, usages: ['sign', 'verify'], name: type === 'rsa' ? 'RSA-SHA256' : 'RSA-PSS' };
+    }
+    case 'ec': {
+      const curve = NAMED_CURVES[String(options.namedCurve ?? '').toLowerCase()];
+      if (!curve) throw Object.assign(new TypeError(`Invalid EC curve name ${String(options.namedCurve)}`), { code: 'ERR_CRYPTO_INVALID_CURVE' });
+      return { generate: { name: 'ECDSA', namedCurve: curve }, usages: ['sign', 'verify'], name: curve === 'P-256' ? 'ES256' : curve === 'P-384' ? 'ES384' : 'ES512' };
+    }
+    case 'ed25519':
+      return { generate: { name: 'Ed25519' }, usages: ['sign', 'verify'], name: 'Ed25519' };
+    case 'x25519':
+      return { generate: { name: 'X25519' }, usages: ['deriveBits'], name: 'X25519' };
+    default:
+      throw Object.assign(new TypeError(`The argument 'type' must be a supported key type. Received '${type}'`), { code: 'ERR_INVALID_ARG_VALUE' });
+  }
+}
+
+function encodedKey(der: ArrayBuffer, encoding: KeyEncoding, kind: 'public' | 'private'): string | Buffer {
+  const expected = kind === 'public' ? 'spki' : 'pkcs8';
+  if (encoding.type !== undefined && encoding.type !== expected) {
+    unsupported(`Encoding a ${kind} key as ${encoding.type}`);
+  }
+  const bytes = Buffer.from(der);
+  if (encoding.format === 'der') return bytes;
+  if (encoding.format !== 'pem') unsupported(`Encoding a key in the ${String(encoding.format)} format`);
+  const label = kind === 'public' ? 'PUBLIC KEY' : 'PRIVATE KEY';
+  const body = bytes.toString('base64').match(/.{1,64}/g)!.join('\n');
+  return `-----BEGIN ${label}-----\n${body}\n-----END ${label}-----\n`;
+}
+
+async function generateKeyPairAsync(type: string, options: KeyPairOptions): Promise<{ publicKey: KeyObject | string | Buffer; privateKey: KeyObject | string | Buffer }> {
+  const algorithm = keyPairAlgorithm(type, options);
+  const pair = await crypto.subtle.generateKey(algorithm.generate as AlgorithmIdentifier, true, algorithm.usages) as CryptoKeyPair;
+  const publicKey = options.publicKeyEncoding
+    ? encodedKey(await crypto.subtle.exportKey('spki', pair.publicKey), options.publicKeyEncoding, 'public')
+    : new KeyObject('public', pair.publicKey, algorithm.name);
+  const privateKey = options.privateKeyEncoding
+    ? encodedKey(await crypto.subtle.exportKey('pkcs8', pair.privateKey), options.privateKeyEncoding, 'private')
+    : new KeyObject('private', pair.privateKey, algorithm.name);
+  return { publicKey, privateKey };
+}
+
+function generateKeyPair(type: string, options: KeyPairOptions | ((error: Error | null, publicKey?: unknown, privateKey?: unknown) => void), callback?: (error: Error | null, publicKey?: unknown, privateKey?: unknown) => void): void {
+  if (typeof options === 'function') { callback = options; options = {}; }
+  if (typeof callback !== 'function') throw Object.assign(new TypeError('The "callback" argument must be of type function.'), { code: 'ERR_INVALID_ARG_TYPE' });
+  const done = callback;
+  // Argument errors throw synchronously, as Node's do.
+  keyPairAlgorithm(type, options ?? {});
+  generateKeyPairAsync(type, options ?? {}).then(
+    ({ publicKey, privateKey }) => done(null, publicKey, privateKey),
+    (error) => done(error instanceof Error ? error : new Error(String(error))),
+  );
+}
+Object.defineProperty(generateKeyPair, Symbol.for('nodejs.util.promisify.custom'), {
+  value: (type: string, options?: KeyPairOptions) => generateKeyPairAsync(type, options ?? {}),
+});
+
 // ============================================================================
 // Utility functions
 // ============================================================================
@@ -1067,10 +1153,11 @@ return {
   createSecretKey,
   createPublicKey,
   createPrivateKey,
+  generateKeyPair,
 };
 
 }
 const cryptoModule = createCryptoModule();
-export const { randomBytes, randomFillSync, randomFill, randomUUID, randomInt, getRandomValues, unsupported, createHash, createHmac, hash, pbkdf2Sync, pbkdf2, sign, verify, createSign, createVerify, KeyObject, createSecretKey, createPublicKey, createPrivateKey, timingSafeEqual, getCiphers, getHashes } = cryptoModule;
+export const { randomBytes, randomFillSync, randomFill, randomUUID, randomInt, getRandomValues, unsupported, createHash, createHmac, hash, pbkdf2Sync, pbkdf2, sign, verify, createSign, createVerify, KeyObject, createSecretKey, createPublicKey, createPrivateKey, generateKeyPair, timingSafeEqual, getCiphers, getHashes } = cryptoModule;
 export type KeyObject = InstanceType<typeof KeyObject>;
 export default cryptoModule;