@seanhogg/builderforce-webcontainers-core 2026.10.2 → 2026.10.4

package/src/node/fs/sync.ts

@@ -0,0 +1,335 @@
+/**
+ * The synchronous fs API over the VirtualFileSystem. Everything else (callback,
+ * promise and stream forms) is layered on these in index.ts, so error codes and
+ * edge cases live in exactly one place.
+ */
+import type { VirtualFileSystem } from '../../vfs.js';
+import { normalizePath, dirname, join } from '../../paths.js';
+import { Buffer, encode } from '../buffer.js';
+import { Dirent, fsError, Stats, constants } from './stats.js';
+
+export interface FsContext {
+  vfs: VirtualFileSystem;
+  cwd(): string;
+  /** fd 1 and 2: `fs.writeSync(1, …)` is how some CLIs print. */
+  stdout(chunk: string | Uint8Array): void;
+  stderr(chunk: string | Uint8Array): void;
+}
+
+type PathLike = string | Uint8Array | URL;
+type Data = string | ArrayBufferView;
+type EncodingOption = string | null | undefined | { encoding?: string | null; flag?: string; withFileTypes?: boolean; recursive?: boolean; force?: boolean; mode?: number; throwIfNoEntry?: boolean };
+
+interface OpenFile {
+  path: string;
+  flags: string;
+  position: number;
+}
+
+const encodingOf = (options: EncodingOption): string | null | undefined => (typeof options === 'string' ? options : options?.encoding);
+
+export function createSyncFs(ctx: FsContext) {
+  const { vfs } = ctx;
+  const fds = new Map<number, OpenFile>();
+  let nextFd = 20;
+
+  const resolve = (p: PathLike): string => {
+    if (p instanceof URL) {
+      if (p.protocol !== 'file:') throw new TypeError('The URL must be of scheme file');
+      return normalizePath(decodeURIComponent(p.pathname));
+    }
+    const text = typeof p === 'string' ? p : new TextDecoder().decode(p);
+    if (typeof text !== 'string') throw new TypeError('The "path" argument must be of type string, Buffer or URL');
+    if (text.startsWith('file://')) return normalizePath(decodeURIComponent(new URL(text).pathname));
+    return text.startsWith('/') ? normalizePath(text) : join(ctx.cwd(), text);
+  };
+
+  const bytesOf = (path: string): Uint8Array => {
+    const contents = vfs.readFile(path)!;
+    return typeof contents === 'string' ? encode(contents) : contents;
+  };
+
+  const requireParent = (path: string, syscall: string) => {
+    const parent = dirname(path);
+    if (vfs.isFile(parent)) throw fsError('ENOTDIR', syscall, path);
+    if (!vfs.isDirectory(parent)) throw fsError('ENOENT', syscall, path);
+  };
+
+  const toStored = (data: Data, encoding?: string | null): string | Uint8Array => {
+    if (typeof data === 'string') return !encoding || /^utf-?8$/i.test(encoding) ? data : encode(data, encoding).slice();
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength).slice();
+  };
+
+  const stat = (p: PathLike, options?: { throwIfNoEntry?: boolean }): Stats | undefined => {
+    const path = resolve(p);
+    if (vfs.isFile(path)) return new Stats(path, 'file', bytesOf(path).length, vfs.mtime(path) ?? Date.now());
+    if (vfs.isDirectory(path)) return new Stats(path, 'directory', 4096, 0);
+    if (options?.throwIfNoEntry === false) return undefined;
+    throw fsError('ENOENT', 'stat', path);
+  };
+
+  const writeFile = (p: PathLike | number, data: Data, options?: EncodingOption) => {
+    if (typeof p === 'number') return writeFd(p, data);
+    const path = resolve(p);
+    const flag = typeof options === 'object' && options ? options.flag ?? 'w' : 'w';
+    if (vfs.isDirectory(path)) throw fsError('EISDIR', 'open', path);
+    requireParent(path, 'open');
+    if (flag.includes('x') && vfs.isFile(path)) throw fsError('EEXIST', 'open', path);
+    if (flag.startsWith('a') && vfs.isFile(path)) {
+      const before = vfs.readFile(path)!;
+      const add = toStored(data, encodingOf(options));
+      vfs.writeFile(path, typeof before === 'string' && typeof add === 'string' ? before + add : Buffer.concat([typeof before === 'string' ? encode(before) : before, typeof add === 'string' ? encode(add) : add]));
+      return;
+    }
+    vfs.writeFile(path, toStored(data, encodingOf(options)));
+  };
+
+  const writeFd = (fd: number, data: Data | Uint8Array, offset?: number | string | null, length?: number, position?: number | null): number => {
+    const bytes = typeof data === 'string' ? encode(data, typeof offset === 'string' ? offset : undefined) : new Uint8Array(data.buffer, data.byteOffset + (typeof offset === 'number' ? offset : 0), length ?? data.byteLength - (typeof offset === 'number' ? offset : 0));
+    if (fd === 1 || fd === 2) {
+      (fd === 1 ? ctx.stdout : ctx.stderr)(bytes.slice());
+      return bytes.length;
+    }
+    const file = fds.get(fd);
+    if (!file || file.flags === 'r') throw fsError('EBADF', 'write');
+    const current = vfs.isFile(file.path) ? bytesOf(file.path) : new Uint8Array();
+    const at = file.flags.startsWith('a') ? current.length : position ?? file.position;
+    const next = new Uint8Array(Math.max(current.length, at + bytes.length));
+    next.set(current);
+    next.set(bytes, at);
+    vfs.writeFile(file.path, next);
+    if (position === undefined || position === null) file.position = at + bytes.length;
+    return bytes.length;
+  };
+
+  const readdirEntries = (dir: string, recursive: boolean, prefix = ''): Array<{ name: string; parent: string; kind: 'file' | 'directory' }> => {
+    const out: Array<{ name: string; parent: string; kind: 'file' | 'directory' }> = [];
+    for (const name of vfs.readdir(dir)) {
+      const full = join(dir, name);
+      const kind = vfs.isDirectory(full) ? 'directory' : 'file';
+      out.push({ name: prefix + name, parent: dir, kind });
+      if (recursive && kind === 'directory') out.push(...readdirEntries(full, true, `${prefix}${name}/`));
+    }
+    return out;
+  };
+
+  const mkdir = (p: PathLike, options?: EncodingOption | number): string | undefined => {
+    const path = resolve(p);
+    const recursive = typeof options === 'object' && !!options?.recursive;
+    if (vfs.isFile(path)) throw fsError('EEXIST', 'mkdir', path);
+    if (vfs.isDirectory(path)) {
+      if (recursive) return undefined;
+      throw fsError('EEXIST', 'mkdir', path);
+    }
+    if (!recursive) requireParent(path, 'mkdir');
+    let first: string | undefined;
+    for (let dir = path; !vfs.isDirectory(dir); dir = dirname(dir)) {
+      if (vfs.isFile(dir)) throw fsError('ENOTDIR', 'mkdir', path);
+      first = dir;
+    }
+    vfs.mkdir(path);
+    return recursive ? first : undefined;
+  };
+
+  const rm = (p: PathLike, options?: { recursive?: boolean; force?: boolean }) => {
+    const path = resolve(p);
+    if (!vfs.exists(path)) {
+      if (options?.force) return;
+      throw fsError('ENOENT', 'rm', path);
+    }
+    if (vfs.isDirectory(path) && !options?.recursive) throw Object.assign(fsError('EISDIR', 'rm', path), { code: 'ERR_FS_EISDIR' });
+    vfs.rm(path);
+  };
+
+  const copyFile = (src: PathLike, dest: PathLike, mode = 0) => {
+    const from = resolve(src);
+    const to = resolve(dest);
+    if (!vfs.isFile(from)) throw fsError(vfs.isDirectory(from) ? 'EISDIR' : 'ENOENT', 'copyfile', from, to);
+    if (mode & constants.COPYFILE_EXCL && vfs.exists(to)) throw fsError('EEXIST', 'copyfile', from, to);
+    requireParent(to, 'copyfile');
+    const contents = vfs.readFile(from)!;
+    vfs.writeFile(to, typeof contents === 'string' ? contents : contents.slice());
+  };
+
+  const copyTree = (from: string, to: string) => {
+    if (vfs.isFile(from)) {
+      const contents = vfs.readFile(from)!;
+      vfs.writeFile(to, typeof contents === 'string' ? contents : contents.slice());
+      return;
+    }
+    vfs.mkdir(to);
+    for (const name of vfs.readdir(from)) copyTree(join(from, name), join(to, name));
+  };
+
+  const open = (p: PathLike, flags: string | number = 'r'): number => {
+    const path = resolve(p);
+    const f = typeof flags === 'number' ? (flags & constants.O_APPEND ? 'a' : flags & (constants.O_WRONLY | constants.O_RDWR) ? 'w' : 'r') : flags;
+    if (vfs.isDirectory(path) && f !== 'r') throw fsError('EISDIR', 'open', path);
+    if (f.startsWith('r')) {
+      if (!vfs.exists(path)) throw fsError('ENOENT', 'open', path);
+    } else {
+      if (f.includes('x') && vfs.exists(path)) throw fsError('EEXIST', 'open', path);
+      requireParent(path, 'open');
+      if (f.startsWith('w') || !vfs.isFile(path)) vfs.writeFile(path, '');
+    }
+    const fd = nextFd++;
+    fds.set(fd, { path, flags: f, position: 0 });
+    return fd;
+  };
+
+  const fileOf = (fd: number, syscall: string) => {
+    const file = fds.get(fd);
+    if (!file) throw fsError('EBADF', syscall);
+    return file;
+  };
+
+  const api = {
+    existsSync: (p: PathLike) => {
+      try {
+        return vfs.exists(resolve(p));
+      } catch {
+        return false;
+      }
+    },
+    accessSync(p: PathLike) {
+      const path = resolve(p);
+      if (!vfs.exists(path)) throw fsError('ENOENT', 'access', path);
+    },
+    statSync: stat,
+    lstatSync: stat,
+    fstatSync: (fd: number) => stat(fileOf(fd, 'fstat').path)!,
+    readFileSync(p: PathLike | number, options?: EncodingOption): string | Buffer {
+      if (p === 0) return Buffer.alloc(0); // stdin is not readable synchronously here
+      const path = typeof p === 'number' ? fileOf(p, 'read').path : resolve(p);
+      if (vfs.isDirectory(path)) throw fsError('EISDIR', 'read', path);
+      const contents = vfs.readFile(path);
+      if (contents === undefined) throw fsError('ENOENT', 'open', path);
+      const encoding = encodingOf(options);
+      if (encoding) return typeof contents === 'string' && /^utf-?8$/i.test(encoding) ? contents : Buffer.from(typeof contents === 'string' ? encode(contents) : contents).toString(encoding as 'utf8');
+      return Buffer.from(typeof contents === 'string' ? encode(contents) : contents);
+    },
+    writeFileSync: writeFile,
+    appendFileSync: (p: PathLike | number, data: Data, options?: EncodingOption) => writeFile(p, data, { ...(typeof options === 'string' ? { encoding: options } : options ?? {}), flag: 'a' }),
+    mkdirSync: mkdir,
+    mkdtempSync(prefix: string) {
+      const path = `${prefix}${Math.random().toString(36).slice(2, 8)}`;
+      mkdir(path);
+      return resolve(path);
+    },
+    readdirSync(p: PathLike, options?: EncodingOption) {
+      const path = resolve(p);
+      if (vfs.isFile(path)) throw fsError('ENOTDIR', 'scandir', path);
+      if (!vfs.isDirectory(path)) throw fsError('ENOENT', 'scandir', path);
+      const opts = typeof options === 'object' ? options : undefined;
+      const entries = readdirEntries(path, !!opts?.recursive);
+      if (opts?.withFileTypes) return entries.map((e) => new Dirent(e.name.slice(e.name.lastIndexOf('/') + 1), e.name.includes('/') ? join(path, e.name, '..') : e.parent, e.kind));
+      return entries.map((e) => (encodingOf(options) === 'buffer' ? Buffer.from(e.name) : e.name));
+    },
+    rmSync: rm,
+    rmdirSync(p: PathLike, options?: { recursive?: boolean }) {
+      const path = resolve(p);
+      if (vfs.isFile(path)) throw fsError('ENOTDIR', 'rmdir', path);
+      if (!vfs.isDirectory(path)) throw fsError('ENOENT', 'rmdir', path);
+      if (vfs.readdir(path).length && !options?.recursive) throw fsError('ENOTEMPTY', 'rmdir', path);
+      vfs.rm(path);
+    },
+    unlinkSync(p: PathLike) {
+      const path = resolve(p);
+      if (vfs.isDirectory(path)) throw fsError('EISDIR', 'unlink', path);
+      if (!vfs.isFile(path)) throw fsError('ENOENT', 'unlink', path);
+      vfs.rm(path);
+    },
+    renameSync(a: PathLike, b: PathLike) {
+      const from = resolve(a);
+      const to = resolve(b);
+      if (!vfs.exists(from)) throw fsError('ENOENT', 'rename', from, to);
+      if (from === to) return;
+      if (vfs.isDirectory(to) && vfs.isFile(from)) throw fsError('EISDIR', 'rename', from, to);
+      requireParent(to, 'rename');
+      if (vfs.isFile(to) && vfs.isDirectory(from)) throw fsError('ENOTDIR', 'rename', from, to);
+      vfs.rm(to);
+      copyTree(from, to);
+      vfs.rm(from);
+    },
+    copyFileSync: copyFile,
+    cpSync(src: PathLike, dest: PathLike, options?: { recursive?: boolean; force?: boolean }) {
+      const from = resolve(src);
+      if (vfs.isDirectory(from) && !options?.recursive) throw Object.assign(fsError('EISDIR', 'cp', from), { code: 'ERR_FS_EISDIR' });
+      if (!vfs.exists(from)) throw fsError('ENOENT', 'cp', from);
+      copyTree(from, resolve(dest));
+    },
+    realpathSync: Object.assign((p: PathLike) => {
+      const path = resolve(p);
+      if (!vfs.exists(path)) throw fsError('ENOENT', 'realpath', path);
+      return path;
+    }, { native: (p: PathLike) => api.realpathSync(p) }),
+    readlinkSync: (p: PathLike) => {
+      throw fsError('EINVAL', 'readlink', resolve(p));
+    },
+    /** No symlinks in the VFS: a link to a file becomes a copy of it. */
+    symlinkSync(target: PathLike, p: PathLike) {
+      const path = resolve(p);
+      const from = typeof target === 'string' && !target.startsWith('/') ? join(dirname(path), target) : resolve(target);
+      copyTree(from, path);
+    },
+    linkSync: (a: PathLike, b: PathLike) => copyFile(a, b),
+    truncateSync(p: PathLike, length = 0) {
+      const path = resolve(p);
+      if (!vfs.isFile(path)) throw fsError('ENOENT', 'open', path);
+      const bytes = bytesOf(path);
+      const next = new Uint8Array(length);
+      next.set(bytes.subarray(0, length));
+      vfs.writeFile(path, next);
+    },
+    chmodSync: (p: PathLike) => void api.accessSync(p),
+    lchmodSync: (p: PathLike) => void api.accessSync(p),
+    chownSync: (p: PathLike) => void api.accessSync(p),
+    lchownSync: (p: PathLike) => void api.accessSync(p),
+    utimesSync: (p: PathLike) => void api.accessSync(p),
+    lutimesSync: (p: PathLike) => void api.accessSync(p),
+    fchmodSync: (fd: number) => void fileOf(fd, 'fchmod'),
+    fchownSync: (fd: number) => void fileOf(fd, 'fchown'),
+    futimesSync: (fd: number) => void fileOf(fd, 'futimes'),
+    fsyncSync: (fd: number) => void fileOf(fd, 'fsync'),
+    fdatasyncSync: (fd: number) => void fileOf(fd, 'fdatasync'),
+    ftruncateSync: (fd: number, length = 0) => api.truncateSync(fileOf(fd, 'ftruncate').path, length),
+    openSync: open,
+    closeSync(fd: number) {
+      if (fd > 2) fileOf(fd, 'close');
+      fds.delete(fd);
+    },
+    readSync(fd: number, buffer: ArrayBufferView, offsetOrOptions?: number | { offset?: number; length?: number; position?: number | null }, length?: number, position?: number | null): number {
+      const opts = typeof offsetOrOptions === 'object' ? offsetOrOptions : { offset: offsetOrOptions, length, position };
+      const file = fileOf(fd, 'read');
+      const bytes = bytesOf(file.path);
+      const target = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      const offset = opts.offset ?? 0;
+      const from = opts.position ?? file.position;
+      const chunk = bytes.subarray(from, from + Math.min(opts.length ?? target.length - offset, target.length - offset));
+      target.set(chunk, offset);
+      if (opts.position === undefined || opts.position === null) file.position = from + chunk.length;
+      return chunk.length;
+    },
+    writeSync: writeFd,
+    opendirSync(p: PathLike) {
+      const path = resolve(p);
+      const entries = api.readdirSync(path, { withFileTypes: true }) as Dirent[];
+      let i = 0;
+      return {
+        path,
+        readSync: () => entries[i++] ?? null,
+        read: async () => entries[i++] ?? null,
+        closeSync: () => undefined,
+        close: async () => undefined,
+        async *[Symbol.asyncIterator]() {
+          while (i < entries.length) yield entries[i++]!;
+        },
+      };
+    },
+    /** For the stream and watch layers. */
+    _resolve: resolve,
+  };
+  return api;
+}
+
+export type SyncFs = ReturnType<typeof createSyncFs>;

package/src/node/hashes.ts

@@ -0,0 +1,171 @@
+/**
+ * Synchronous message digests for `crypto.createHash` — WebCrypto's digest is
+ * async-only, and Node's API is sync. md5, sha1, sha256, sha224, sha384, sha512.
+ * Inputs are buffered and hashed at `digest()`, which keeps each algorithm a
+ * single pure function.
+ */
+
+const rotl = (x: number, n: number) => (x << n) | (x >>> (32 - n));
+const rotr = (x: number, n: number) => (x >>> n) | (x << (32 - n));
+
+function pad(bytes: Uint8Array, blockSize: number, lengthBytes: number, littleEndian: boolean): Uint8Array {
+  const bitLength = bytes.length * 8;
+  const total = Math.ceil((bytes.length + 1 + lengthBytes) / blockSize) * blockSize;
+  const out = new Uint8Array(total);
+  out.set(bytes);
+  out[bytes.length] = 0x80;
+  const view = new DataView(out.buffer);
+  const hi = Math.floor(bitLength / 2 ** 32);
+  const lo = bitLength >>> 0;
+  if (littleEndian) {
+    view.setUint32(total - 8, lo, true);
+    view.setUint32(total - 4, hi, true);
+  } else {
+    view.setUint32(total - 4, lo);
+    view.setUint32(total - 8, hi);
+  }
+  return out;
+}
+
+const MD5_S = [7, 12, 17, 22, 5, 9, 14, 20, 4, 11, 16, 23, 6, 10, 15, 21];
+const MD5_K = Array.from({ length: 64 }, (_, i) => Math.floor(Math.abs(Math.sin(i + 1)) * 2 ** 32) >>> 0);
+
+function md5(input: Uint8Array): Uint8Array {
+  const data = pad(input, 64, 8, true);
+  const view = new DataView(data.buffer);
+  let a0 = 0x67452301, b0 = 0xefcdab89, c0 = 0x98badcfe, d0 = 0x10325476;
+  for (let off = 0; off < data.length; off += 64) {
+    let a = a0, b = b0, c = c0, d = d0;
+    for (let i = 0; i < 64; i++) {
+      let f: number, g: number;
+      if (i < 16) [f, g] = [(b & c) | (~b & d), i];
+      else if (i < 32) [f, g] = [(d & b) | (~d & c), (5 * i + 1) % 16];
+      else if (i < 48) [f, g] = [b ^ c ^ d, (3 * i + 5) % 16];
+      else [f, g] = [c ^ (b | ~d), (7 * i) % 16];
+      const tmp = d;
+      d = c;
+      c = b;
+      b = (b + rotl((a + f + MD5_K[i]! + view.getUint32(off + g * 4, true)) | 0, MD5_S[(i >> 4) * 4 + (i % 4)]!)) | 0;
+      a = tmp;
+    }
+    a0 = (a0 + a) | 0; b0 = (b0 + b) | 0; c0 = (c0 + c) | 0; d0 = (d0 + d) | 0;
+  }
+  const out = new DataView(new ArrayBuffer(16));
+  [a0, b0, c0, d0].forEach((v, i) => out.setUint32(i * 4, v, true));
+  return new Uint8Array(out.buffer);
+}
+
+function sha1(input: Uint8Array): Uint8Array {
+  const data = pad(input, 64, 8, false);
+  const view = new DataView(data.buffer);
+  const h = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];
+  const w = new Int32Array(80);
+  for (let off = 0; off < data.length; off += 64) {
+    for (let i = 0; i < 16; i++) w[i] = view.getInt32(off + i * 4);
+    for (let i = 16; i < 80; i++) w[i] = rotl(w[i - 3]! ^ w[i - 8]! ^ w[i - 14]! ^ w[i - 16]!, 1);
+    let [a, b, c, d, e] = h as [number, number, number, number, number];
+    for (let i = 0; i < 80; i++) {
+      const [f, k] = i < 20 ? [(b & c) | (~b & d), 0x5a827999] : i < 40 ? [b ^ c ^ d, 0x6ed9eba1] : i < 60 ? [(b & c) | (b & d) | (c & d), 0x8f1bbcdc] : [b ^ c ^ d, 0xca62c1d6];
+      const t = (rotl(a, 5) + f + e + k + w[i]!) | 0;
+      e = d; d = c; c = rotl(b, 30); b = a; a = t;
+    }
+    h[0] = (h[0]! + a) | 0; h[1] = (h[1]! + b) | 0; h[2] = (h[2]! + c) | 0; h[3] = (h[3]! + d) | 0; h[4] = (h[4]! + e) | 0;
+  }
+  const out = new DataView(new ArrayBuffer(20));
+  h.forEach((v, i) => out.setUint32(i * 4, v >>> 0));
+  return new Uint8Array(out.buffer);
+}
+
+const K256 = [
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+  0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+  0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+  0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+];
+
+function sha256(input: Uint8Array, init = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19], outWords = 8): Uint8Array {
+  const data = pad(input, 64, 8, false);
+  const view = new DataView(data.buffer);
+  const h = [...init];
+  const w = new Int32Array(64);
+  for (let off = 0; off < data.length; off += 64) {
+    for (let i = 0; i < 16; i++) w[i] = view.getInt32(off + i * 4);
+    for (let i = 16; i < 64; i++) {
+      const s0 = rotr(w[i - 15]!, 7) ^ rotr(w[i - 15]!, 18) ^ (w[i - 15]! >>> 3);
+      const s1 = rotr(w[i - 2]!, 17) ^ rotr(w[i - 2]!, 19) ^ (w[i - 2]! >>> 10);
+      w[i] = (w[i - 16]! + s0 + w[i - 7]! + s1) | 0;
+    }
+    let [a, b, c, d, e, f, g, hh] = h as [number, number, number, number, number, number, number, number];
+    for (let i = 0; i < 64; i++) {
+      const t1 = (hh + (rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)) + ((e & f) ^ (~e & g)) + K256[i]! + w[i]!) | 0;
+      const t2 = ((rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + ((a & b) ^ (a & c) ^ (b & c))) | 0;
+      hh = g; g = f; f = e; e = (d + t1) | 0; d = c; c = b; b = a; a = (t1 + t2) | 0;
+    }
+    [a, b, c, d, e, f, g, hh].forEach((v, i) => (h[i] = (h[i]! + v) | 0));
+  }
+  const out = new DataView(new ArrayBuffer(outWords * 4));
+  for (let i = 0; i < outWords; i++) out.setUint32(i * 4, h[i]! >>> 0);
+  return new Uint8Array(out.buffer);
+}
+
+const K512 = [
+  '428a2f98d728ae22', '7137449123ef65cd', 'b5c0fbcfec4d3b2f', 'e9b5dba58189dbbc', '3956c25bf348b538', '59f111f1b605d019', '923f82a4af194f9b', 'ab1c5ed5da6d8118',
+  'd807aa98a3030242', '12835b0145706fbe', '243185be4ee4b28c', '550c7dc3d5ffb4e2', '72be5d74f27b896f', '80deb1fe3b1696b1', '9bdc06a725c71235', 'c19bf174cf692694',
+  'e49b69c19ef14ad2', 'efbe4786384f25e3', '0fc19dc68b8cd5b5', '240ca1cc77ac9c65', '2de92c6f592b0275', '4a7484aa6ea6e483', '5cb0a9dcbd41fbd4', '76f988da831153b5',
+  '983e5152ee66dfab', 'a831c66d2db43210', 'b00327c898fb213f', 'bf597fc7beef0ee4', 'c6e00bf33da88fc2', 'd5a79147930aa725', '06ca6351e003826f', '142929670a0e6e70',
+  '27b70a8546d22ffc', '2e1b21385c26c926', '4d2c6dfc5ac42aed', '53380d139d95b3df', '650a73548baf63de', '766a0abb3c77b2a8', '81c2c92e47edaee6', '92722c851482353b',
+  'a2bfe8a14cf10364', 'a81a664bbc423001', 'c24b8b70d0f89791', 'c76c51a30654be30', 'd192e819d6ef5218', 'd69906245565a910', 'f40e35855771202a', '106aa07032bbd1b8',
+  '19a4c116b8d2d0c8', '1e376c085141ab53', '2748774cdf8eeb99', '34b0bcb5e19b48a8', '391c0cb3c5c95a63', '4ed8aa4ae3418acb', '5b9cca4f7763e373', '682e6ff3d6b2b8a3',
+  '748f82ee5defb2fc', '78a5636f43172f60', '84c87814a1f0ab72', '8cc702081a6439ec', '90befffa23631e28', 'a4506cebde82bde9', 'bef9a3f7b2c67915', 'c67178f2e372532b',
+  'ca273eceea26619c', 'd186b8c721c0c207', 'eada7dd6cde0eb1e', 'f57d4f7fee6ed178', '06f067aa72176fba', '0a637dc5a2c898a6', '113f9804bef90dae', '1b710b35131c471b',
+  '28db77f523047d84', '32caab7b40c72493', '3c9ebe0a15c9bebc', '431d67c49c100d4c', '4cc5d4becb3e42b6', '597f299cfc657e2a', '5fcb6fab3ad6faec', '6c44198c4a475817',
+].map((h) => BigInt('0x' + h));
+
+const M64 = (1n << 64n) - 1n;
+const rotr64 = (x: bigint, n: bigint) => ((x >> n) | (x << (64n - n))) & M64;
+
+function sha512(input: Uint8Array, init: string[], outBytes: number): Uint8Array {
+  const data = pad(input, 128, 16, false);
+  const view = new DataView(data.buffer);
+  const h = init.map((v) => BigInt('0x' + v));
+  const w: bigint[] = new Array(80);
+  for (let off = 0; off < data.length; off += 128) {
+    for (let i = 0; i < 16; i++) w[i] = view.getBigUint64(off + i * 8);
+    for (let i = 16; i < 80; i++) {
+      const s0 = rotr64(w[i - 15]!, 1n) ^ rotr64(w[i - 15]!, 8n) ^ (w[i - 15]! >> 7n);
+      const s1 = rotr64(w[i - 2]!, 19n) ^ rotr64(w[i - 2]!, 61n) ^ (w[i - 2]! >> 6n);
+      w[i] = (w[i - 16]! + s0 + w[i - 7]! + s1) & M64;
+    }
+    let [a, b, c, d, e, f, g, hh] = h as [bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint];
+    for (let i = 0; i < 80; i++) {
+      const t1 = (hh + (rotr64(e, 14n) ^ rotr64(e, 18n) ^ rotr64(e, 41n)) + ((e & f) ^ (~e & M64 & g)) + K512[i]! + w[i]!) & M64;
+      const t2 = ((rotr64(a, 28n) ^ rotr64(a, 34n) ^ rotr64(a, 39n)) + ((a & b) ^ (a & c) ^ (b & c))) & M64;
+      hh = g; g = f; f = e; e = (d + t1) & M64; d = c; c = b; b = a; a = (t1 + t2) & M64;
+    }
+    [a, b, c, d, e, f, g, hh].forEach((v, i) => (h[i] = (h[i]! + v) & M64));
+  }
+  const out = new DataView(new ArrayBuffer(64));
+  h.forEach((v, i) => out.setBigUint64(i * 8, v));
+  return new Uint8Array(out.buffer).slice(0, outBytes);
+}
+
+const SHA512_INIT = ['6a09e667f3bcc908', 'bb67ae8584caa73b', '3c6ef372fe94f82b', 'a54ff53a5f1d36f1', '510e527fade682d1', '9b05688c2b3e6c1f', '1f83d9abfb41bd6b', '5be0cd19137e2179'];
+const SHA384_INIT = ['cbbb9d5dc1059ed8', '629a292a367cd507', '9159015a3070dd17', '152fecd8f70e5939', '67332667ffc00b31', '8eb44a8768581511', 'db0c2e0d64f98fa7', '47b5481dbefa4fa4'];
+
+export const HASHES: Record<string, { digest(data: Uint8Array): Uint8Array; blockSize: number }> = {
+  md5: { digest: md5, blockSize: 64 },
+  sha1: { digest: sha1, blockSize: 64 },
+  sha256: { digest: (d) => sha256(d), blockSize: 64 },
+  sha224: { digest: (d) => sha256(d, [0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4], 7), blockSize: 64 },
+  sha384: { digest: (d) => sha512(d, SHA384_INIT, 48), blockSize: 128 },
+  sha512: { digest: (d) => sha512(d, SHA512_INIT, 64), blockSize: 128 },
+};
+
+export function hashAlgorithm(name: string): { digest(data: Uint8Array): Uint8Array; blockSize: number } {
+  const key = name.toLowerCase().replace(/^rsa-/, '').replace('-', '');
+  const algo = HASHES[key];
+  if (!algo) throw new Error(`Digest method not supported: ${name}`);
+  return algo;
+}