@nimbus-sh/core 0.1.0

package/src/substrate/lifo/node-compat/buffer.ts

@@ -0,0 +1,357 @@
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+
+export class Buffer extends Uint8Array {
+  // Use overloaded signatures to satisfy Uint8Array's static from
+  static from(value: string | Uint8Array | number[] | ArrayBuffer | ArrayLike<number> | Iterable<number>, encodingOrMapFn?: string | ((v: number, k: number) => number), _thisArg?: unknown): Buffer {
+    if (typeof value === 'string') {
+      const encoding = encodingOrMapFn as string | undefined;
+      if (encoding === 'base64') {
+        const binary = atob(value);
+        const buf = new Buffer(binary.length);
+        for (let i = 0; i < binary.length; i++) buf[i] = binary.charCodeAt(i);
+        return buf;
+      }
+      if (encoding === 'hex') {
+        const buf = new Buffer(value.length / 2);
+        for (let i = 0; i < value.length; i += 2) {
+          buf[i / 2] = parseInt(value.substring(i, i + 2), 16);
+        }
+        return buf;
+      }
+      // utf-8 default
+      const bytes = encoder.encode(value);
+      const buf = new Buffer(bytes.length);
+      buf.set(bytes);
+      return buf;
+    }
+    if (value instanceof ArrayBuffer) {
+      const buf = new Buffer(value.byteLength);
+      buf.set(new Uint8Array(value));
+      return buf;
+    }
+    if (value instanceof Uint8Array) {
+      const buf = new Buffer(value.length);
+      buf.set(value);
+      return buf;
+    }
+    // ArrayLike<number> or number[]
+    const arr = value as ArrayLike<number>;
+    const buf = new Buffer(arr.length);
+    for (let i = 0; i < arr.length; i++) buf[i] = arr[i];
+    return buf;
+  }
+
+  static alloc(size: number, fill?: number): Buffer {
+    const buf = new Buffer(size);
+    if (fill !== undefined) buf.fill(fill);
+    return buf;
+  }
+
+  static allocUnsafe(size: number): Buffer {
+    return new Buffer(size);
+  }
+
+  static isBuffer(obj: unknown): obj is Buffer {
+    return obj instanceof Buffer;
+  }
+
+  static concat(list: (Uint8Array | Buffer)[], totalLength?: number): Buffer {
+    const len = totalLength ?? list.reduce((sum, b) => sum + b.length, 0);
+    const result = Buffer.alloc(len);
+    let offset = 0;
+    for (const buf of list) {
+      const slice = buf.subarray(0, Math.min(buf.length, len - offset));
+      result.set(slice, offset);
+      offset += slice.length;
+      if (offset >= len) break;
+    }
+    return result;
+  }
+
+  static byteLength(str: string, encoding?: string): number {
+    if (encoding === 'base64') {
+      // Remove padding and compute
+      const cleaned = str.replace(/[^A-Za-z0-9+/]/g, '');
+      return Math.floor(cleaned.length * 3 / 4);
+    }
+    if (encoding === 'hex') {
+      return str.length / 2;
+    }
+    return encoder.encode(str).length;
+  }
+
+  toString(encoding?: string, start?: number, end?: number): string {
+    const slice = (start !== undefined || end !== undefined)
+      ? this.subarray(start ?? 0, end ?? this.length)
+      : this;
+    if (encoding === 'base64') {
+      let binary = '';
+      for (let i = 0; i < slice.length; i++) binary += String.fromCharCode(slice[i]);
+      return btoa(binary);
+    }
+    if (encoding === 'hex') {
+      let hex = '';
+      for (let i = 0; i < slice.length; i++) hex += slice[i].toString(16).padStart(2, '0');
+      return hex;
+    }
+    // utf-8 default
+    return decoder.decode(slice);
+  }
+
+  write(str: string, offset?: number, length?: number, encoding?: string): number {
+    const start = offset ?? 0;
+    const maxLen = length ?? this.length - start;
+
+    let bytes: Uint8Array;
+    if (encoding === 'hex') {
+      // Each pair of hex chars = 1 byte
+      const byteLen = Math.min(Math.floor(str.length / 2), maxLen);
+      bytes = new Uint8Array(byteLen);
+      for (let i = 0; i < byteLen; i++) {
+        bytes[i] = parseInt(str.substring(i * 2, i * 2 + 2), 16);
+      }
+    } else if (encoding === 'base64') {
+      const binary = atob(str);
+      const byteLen = Math.min(binary.length, maxLen);
+      bytes = new Uint8Array(byteLen);
+      for (let i = 0; i < byteLen; i++) bytes[i] = binary.charCodeAt(i);
+    } else {
+      bytes = encoder.encode(str);
+    }
+
+    const toWrite = Math.min(bytes.length, maxLen);
+    this.set(bytes.subarray(0, toWrite), start);
+    return toWrite;
+  }
+
+  toJSON(): { type: 'Buffer'; data: number[] } {
+    return { type: 'Buffer', data: Array.from(this) };
+  }
+
+  copy(target: Buffer | Uint8Array, targetStart = 0, sourceStart = 0, sourceEnd = this.length): number {
+    const slice = this.subarray(sourceStart, sourceEnd);
+    const len = Math.min(slice.length, target.length - targetStart);
+    target.set(slice.subarray(0, len), targetStart);
+    return len;
+  }
+
+  equals(other: Uint8Array): boolean {
+    if (this.length !== other.length) return false;
+    for (let i = 0; i < this.length; i++) {
+      if (this[i] !== other[i]) return false;
+    }
+    return true;
+  }
+
+  compare(other: Uint8Array): number {
+    const len = Math.min(this.length, other.length);
+    for (let i = 0; i < len; i++) {
+      if (this[i] < other[i]) return -1;
+      if (this[i] > other[i]) return 1;
+    }
+    if (this.length < other.length) return -1;
+    if (this.length > other.length) return 1;
+    return 0;
+  }
+
+  slice(start?: number, end?: number): Buffer {
+    const sliced = super.slice(start, end);
+    return Buffer.from(sliced);
+  }
+
+  subarray(start?: number, end?: number): Buffer {
+    const sub = super.subarray(start, end);
+    return Buffer.from(sub);
+  }
+
+  // ─── Integer read methods (big-endian) ───
+
+  readUInt8(offset = 0): number {
+    return this[offset];
+  }
+
+  readUInt16BE(offset = 0): number {
+    return (this[offset] << 8) | this[offset + 1];
+  }
+
+  readUInt32BE(offset = 0): number {
+    return (
+      (this[offset] * 0x1000000) +
+      ((this[offset + 1] << 16) |
+       (this[offset + 2] << 8) |
+        this[offset + 3])
+    );
+  }
+
+  readInt8(offset = 0): number {
+    const val = this[offset];
+    return val & 0x80 ? val - 0x100 : val;
+  }
+
+  readInt16BE(offset = 0): number {
+    const val = (this[offset] << 8) | this[offset + 1];
+    return val & 0x8000 ? val - 0x10000 : val;
+  }
+
+  readInt32BE(offset = 0): number {
+    return (
+      (this[offset] << 24) |
+      (this[offset + 1] << 16) |
+      (this[offset + 2] << 8) |
+       this[offset + 3]
+    );
+  }
+
+  // ─── Integer read methods (little-endian) ───
+
+  readUInt16LE(offset = 0): number {
+    return this[offset] | (this[offset + 1] << 8);
+  }
+
+  readUInt32LE(offset = 0): number {
+    return (
+      this[offset] +
+      (this[offset + 1] << 8) +
+      (this[offset + 2] << 16) +
+      (this[offset + 3] * 0x1000000)
+    );
+  }
+
+  readInt16LE(offset = 0): number {
+    const val = this[offset] | (this[offset + 1] << 8);
+    return val & 0x8000 ? val - 0x10000 : val;
+  }
+
+  readInt32LE(offset = 0): number {
+    return (
+      this[offset] |
+      (this[offset + 1] << 8) |
+      (this[offset + 2] << 16) |
+      (this[offset + 3] << 24)
+    );
+  }
+
+  // ─── Integer write methods (big-endian) ───
+
+  writeUInt8(value: number, offset = 0): number {
+    this[offset] = value & 0xff;
+    return offset + 1;
+  }
+
+  writeUInt16BE(value: number, offset = 0): number {
+    this[offset] = (value >>> 8) & 0xff;
+    this[offset + 1] = value & 0xff;
+    return offset + 2;
+  }
+
+  writeUInt32BE(value: number, offset = 0): number {
+    this[offset] = (value >>> 24) & 0xff;
+    this[offset + 1] = (value >>> 16) & 0xff;
+    this[offset + 2] = (value >>> 8) & 0xff;
+    this[offset + 3] = value & 0xff;
+    return offset + 4;
+  }
+
+  writeInt8(value: number, offset = 0): number {
+    this[offset] = value & 0xff;
+    return offset + 1;
+  }
+
+  writeInt16BE(value: number, offset = 0): number {
+    this[offset] = (value >>> 8) & 0xff;
+    this[offset + 1] = value & 0xff;
+    return offset + 2;
+  }
+
+  writeInt32BE(value: number, offset = 0): number {
+    this[offset] = (value >>> 24) & 0xff;
+    this[offset + 1] = (value >>> 16) & 0xff;
+    this[offset + 2] = (value >>> 8) & 0xff;
+    this[offset + 3] = value & 0xff;
+    return offset + 4;
+  }
+
+  // ─── Integer write methods (little-endian) ───
+
+  writeUInt16LE(value: number, offset = 0): number {
+    this[offset] = value & 0xff;
+    this[offset + 1] = (value >>> 8) & 0xff;
+    return offset + 2;
+  }
+
+  writeUInt32LE(value: number, offset = 0): number {
+    this[offset] = value & 0xff;
+    this[offset + 1] = (value >>> 8) & 0xff;
+    this[offset + 2] = (value >>> 16) & 0xff;
+    this[offset + 3] = (value >>> 24) & 0xff;
+    return offset + 4;
+  }
+
+  writeInt16LE(value: number, offset = 0): number {
+    this[offset] = value & 0xff;
+    this[offset + 1] = (value >>> 8) & 0xff;
+    return offset + 2;
+  }
+
+  writeInt32LE(value: number, offset = 0): number {
+    this[offset] = value & 0xff;
+    this[offset + 1] = (value >>> 8) & 0xff;
+    this[offset + 2] = (value >>> 16) & 0xff;
+    this[offset + 3] = (value >>> 24) & 0xff;
+    return offset + 4;
+  }
+
+  // ─── Search methods ───
+
+  indexOf(value: number | Uint8Array | string, byteOffset?: number, encoding?: string): number {
+    const start = byteOffset ?? 0;
+    if (typeof value === 'number') {
+      for (let i = start; i < this.length; i++) {
+        if (this[i] === value) return i;
+      }
+      return -1;
+    }
+    const needle = typeof value === 'string'
+      ? Buffer.from(value, encoding)
+      : value;
+    if (needle.length === 0) return start;
+    for (let i = start; i <= this.length - needle.length; i++) {
+      let match = true;
+      for (let j = 0; j < needle.length; j++) {
+        if (this[i + j] !== needle[j]) { match = false; break; }
+      }
+      if (match) return i;
+    }
+    return -1;
+  }
+
+  lastIndexOf(value: number | Uint8Array | string, byteOffset?: number, encoding?: string): number {
+    if (typeof value === 'number') {
+      const start = byteOffset ?? this.length - 1;
+      for (let i = start; i >= 0; i--) {
+        if (this[i] === value) return i;
+      }
+      return -1;
+    }
+    const needle = typeof value === 'string'
+      ? Buffer.from(value, encoding)
+      : value;
+    if (needle.length === 0) return byteOffset ?? this.length;
+    const start = byteOffset != null ? Math.min(byteOffset, this.length - needle.length) : this.length - needle.length;
+    for (let i = start; i >= 0; i--) {
+      let match = true;
+      for (let j = 0; j < needle.length; j++) {
+        if (this[i + j] !== needle[j]) { match = false; break; }
+      }
+      if (match) return i;
+    }
+    return -1;
+  }
+
+  includes(value: number | Uint8Array | string, byteOffset?: number, encoding?: string): boolean {
+    return this.indexOf(value, byteOffset, encoding) !== -1;
+  }
+}
+
+export default Buffer;

package/src/substrate/lifo/node-compat/child_process.ts

@@ -0,0 +1,52 @@
+import { EventEmitter } from './events.js';
+
+type ExecuteCapture = (input: string) => Promise<string>;
+
+export function createChildProcess(executeCapture?: ExecuteCapture) {
+  function exec(
+    cmd: string,
+    optionsOrCb?: Record<string, unknown> | ((err: Error | null, stdout: string, stderr: string) => void),
+    cb?: (err: Error | null, stdout: string, stderr: string) => void,
+  ): EventEmitter {
+    const callback = typeof optionsOrCb === 'function' ? optionsOrCb : cb;
+    const child = new EventEmitter();
+
+    if (!executeCapture) {
+      queueMicrotask(() => {
+        const err = new Error('child_process.exec() requires shell interpreter');
+        if (callback) callback(err, '', '');
+        child.emit('error', err);
+      });
+      return child;
+    }
+
+    const run = executeCapture;
+    queueMicrotask(async () => {
+      try {
+        const output = await run(cmd);
+        if (callback) callback(null, output, '');
+        child.emit('close', 0);
+      } catch (e) {
+        const err = e instanceof Error ? e : new Error(String(e));
+        if (callback) callback(err, '', err.message);
+        child.emit('close', 1);
+      }
+    });
+
+    return child;
+  }
+
+  function execSync(): never {
+    throw new Error('child_process.execSync() is not supported in Lifo');
+  }
+
+  function spawn(): never {
+    throw new Error('child_process.spawn() is not supported in Lifo');
+  }
+
+  function fork(): never {
+    throw new Error('child_process.fork() is not supported in Lifo');
+  }
+
+  return { exec, execSync, spawn, fork };
+}

package/src/substrate/lifo/node-compat/console.ts

@@ -0,0 +1,70 @@
+import type { CommandOutputStream } from '../commands/types.js';
+import { format } from './util.js';
+
+export function createConsole(stdout: CommandOutputStream, stderr: CommandOutputStream) {
+  const timers = new Map<string, number>();
+
+  return {
+    log: (...args: unknown[]) => {
+      stdout.write(format(args[0] as string, ...args.slice(1)) + '\n');
+    },
+    info: (...args: unknown[]) => {
+      stdout.write(format(args[0] as string, ...args.slice(1)) + '\n');
+    },
+    warn: (...args: unknown[]) => {
+      stderr.write(format(args[0] as string, ...args.slice(1)) + '\n');
+    },
+    error: (...args: unknown[]) => {
+      stderr.write(format(args[0] as string, ...args.slice(1)) + '\n');
+    },
+    debug: (...args: unknown[]) => {
+      stdout.write(format(args[0] as string, ...args.slice(1)) + '\n');
+    },
+    dir: (obj: unknown) => {
+      stdout.write(format('%o', obj) + '\n');
+    },
+    time: (label = 'default') => {
+      timers.set(label, performance.now());
+    },
+    timeEnd: (label = 'default') => {
+      const start = timers.get(label);
+      if (start !== undefined) {
+        const elapsed = performance.now() - start;
+        stdout.write(`${label}: ${elapsed.toFixed(3)}ms\n`);
+        timers.delete(label);
+      } else {
+        stderr.write(`Warning: No such label '${label}' for console.timeEnd()\n`);
+      }
+    },
+    timeLog: (label = 'default', ...args: unknown[]) => {
+      const start = timers.get(label);
+      if (start !== undefined) {
+        const elapsed = performance.now() - start;
+        stdout.write(`${label}: ${elapsed.toFixed(3)}ms ${args.map((a) => format('%o', a)).join(' ')}\n`);
+      }
+    },
+    trace: (...args: unknown[]) => {
+      stderr.write('Trace: ' + format(args[0] as string, ...args.slice(1)) + '\n');
+    },
+    assert: (condition: unknown, ...args: unknown[]) => {
+      if (!condition) {
+        stderr.write('Assertion failed: ' + (args.length > 0 ? format(args[0] as string, ...args.slice(1)) : '') + '\n');
+      }
+    },
+    clear: () => { /* no-op */ },
+    count: (() => {
+      const counts = new Map<string, number>();
+      return (label = 'default') => {
+        const count = (counts.get(label) ?? 0) + 1;
+        counts.set(label, count);
+        stdout.write(`${label}: ${count}\n`);
+      };
+    })(),
+    countReset: () => { /* no-op */ },
+    group: () => { /* no-op */ },
+    groupEnd: () => { /* no-op */ },
+    table: (data: unknown) => {
+      stdout.write(format('%o', data) + '\n');
+    },
+  };
+}

package/src/substrate/lifo/node-compat/crypto.ts

@@ -0,0 +1,186 @@
+import { Buffer } from './buffer.js';
+
+export function randomBytes(size: number): Buffer {
+  const buf = Buffer.alloc(size);
+  crypto.getRandomValues(buf);
+  return buf;
+}
+
+export function randomUUID(): string {
+  return crypto.randomUUID();
+}
+
+interface HashObject {
+  update(data: string | Uint8Array): HashObject;
+  digest(encoding?: string): string | Buffer;
+}
+
+export function createHash(algorithm: string): HashObject {
+  const algo = algorithm.toLowerCase().replace('-', '');
+  if (algo !== 'sha256' && algo !== 'sha1') {
+    throw new Error(`Digest method not supported: ${algorithm} (only sha1 and sha256 are supported)`);
+  }
+
+  const chunks: Uint8Array[] = [];
+
+  return {
+    update(data: string | Uint8Array): ReturnType<typeof createHash> {
+      if (typeof data === 'string') {
+        chunks.push(new TextEncoder().encode(data));
+      } else {
+        chunks.push(data);
+      }
+      return this;
+    },
+    digest(encoding?: string): string | Buffer {
+      let totalLen = 0;
+      for (const c of chunks) totalLen += c.length;
+      const merged = new Uint8Array(totalLen);
+      let offset = 0;
+      for (const c of chunks) {
+        merged.set(c, offset);
+        offset += c.length;
+      }
+
+      const result = algo === 'sha1' ? sha1sync(merged) : sha256sync(merged);
+
+      if (encoding === 'hex') return toHex(result);
+      if (encoding === 'base64') return Buffer.from(result).toString('base64');
+      return Buffer.from(result);
+    },
+  };
+}
+
+export function randomInt(min: number, max?: number): number {
+  if (max === undefined) {
+    max = min;
+    min = 0;
+  }
+  const range = max - min;
+  const array = new Uint32Array(1);
+  crypto.getRandomValues(array);
+  return min + (array[0] % range);
+}
+
+// Node.js 19+ exposes Web Crypto APIs directly on the crypto module
+export function getRandomValues<T extends ArrayBufferView>(array: T): T {
+  const bytes = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+  crypto.getRandomValues(bytes);
+  return array;
+}
+
+export const subtle = crypto.subtle;
+
+// ── Sync one-shot hash (Node.js 21+ crypto.hash) ──
+// crypto.subtle.digest is async-only, so we use a pure-JS fallback for sync hashing.
+// This covers the common case: Vite calls crypto.hash('sha256', data, 'hex').
+
+function rotl(x: number, n: number): number { return (x << n) | (x >>> (32 - n)); }
+
+function sha1sync(data: Uint8Array): Uint8Array {
+  let h0 = 0x67452301, h1 = 0xEFCDAB89, h2 = 0x98BADCFE, h3 = 0x10325476, h4 = 0xC3D2E1F0;
+  const len = data.length;
+  const bitLen = len * 8;
+  const totalLen = Math.ceil((len + 9) / 64) * 64;
+  const buf = new Uint8Array(totalLen);
+  buf.set(data);
+  buf[len] = 0x80;
+  const view = new DataView(buf.buffer);
+  view.setUint32(totalLen - 8, Math.floor(bitLen / 0x100000000), false);
+  view.setUint32(totalLen - 4, bitLen >>> 0, false);
+  const W = new Int32Array(80);
+  for (let off = 0; off < buf.length; off += 64) {
+    for (let i = 0; i < 16; i++) W[i] = view.getUint32(off + i * 4, false);
+    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 = h0, b = h1, c = h2, d = h3, e = h4;
+    for (let i = 0; i < 80; i++) {
+      let f: number, k: number;
+      if (i < 20) { f = (b & c) | (~b & d); k = 0x5A827999; }
+      else if (i < 40) { f = b ^ c ^ d; k = 0x6ED9EBA1; }
+      else if (i < 60) { f = (b & c) | (b & d) | (c & d); k = 0x8F1BBCDC; }
+      else { f = b ^ c ^ d; k = 0xCA62C1D6; }
+      const t = (rotl(a, 5) + f + e + k + W[i]) | 0;
+      e = d; d = c; c = rotl(b, 30); b = a; a = t;
+    }
+    h0 = (h0 + a) | 0; h1 = (h1 + b) | 0; h2 = (h2 + c) | 0; h3 = (h3 + d) | 0; h4 = (h4 + e) | 0;
+  }
+  const out = new Uint8Array(20);
+  const ov = new DataView(out.buffer);
+  ov.setUint32(0, h0, false); ov.setUint32(4, h1, false); ov.setUint32(8, h2, false);
+  ov.setUint32(12, h3, false); ov.setUint32(16, h4, false);
+  return out;
+}
+
+function rotr(x: number, n: number): number { return (x >>> n) | (x << (32 - n)); }
+
+function sha256sync(data: Uint8Array): Uint8Array {
+  const K = [
+    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,
+  ];
+  let h0=0x6a09e667,h1=0xbb67ae85,h2=0x3c6ef372,h3=0xa54ff53a,h4=0x510e527f,h5=0x9b05688c,h6=0x1f83d9ab,h7=0x5be0cd19;
+  const len = data.length;
+  const bitLen = len * 8;
+  // Padding: message + 0x80 + zeros + 8-byte big-endian bit length, total must be multiple of 64
+  const totalLen = Math.ceil((len + 9) / 64) * 64;
+  const buf = new Uint8Array(totalLen);
+  buf.set(data);
+  buf[len] = 0x80;
+  const view = new DataView(buf.buffer);
+  // 64-bit big-endian bit length (high 32 bits then low 32 bits)
+  view.setUint32(totalLen - 8, Math.floor(bitLen / 0x100000000), false);
+  view.setUint32(totalLen - 4, bitLen >>> 0, false);
+  // Process 64-byte blocks
+  const W = new Int32Array(64);
+  for (let off = 0; off < buf.length; off += 64) {
+    for (let i = 0; i < 16; i++) W[i] = view.getUint32(off + i * 4, false);
+    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=h0,b=h1,c=h2,d=h3,e=h4,f=h5,g=h6,h=h7;
+    for (let i = 0; i < 64; i++) {
+      const S1 = rotr(e,6) ^ rotr(e,11) ^ rotr(e,25);
+      const ch = (e & f) ^ (~e & g);
+      const t1 = (h + S1 + ch + K[i] + W[i]) | 0;
+      const S0 = rotr(a,2) ^ rotr(a,13) ^ rotr(a,22);
+      const maj = (a & b) ^ (a & c) ^ (b & c);
+      const t2 = (S0 + maj) | 0;
+      h=g; g=f; f=e; e=(d+t1)|0; d=c; c=b; b=a; a=(t1+t2)|0;
+    }
+    h0=(h0+a)|0; h1=(h1+b)|0; h2=(h2+c)|0; h3=(h3+d)|0; h4=(h4+e)|0; h5=(h5+f)|0; h6=(h6+g)|0; h7=(h7+h)|0;
+  }
+  const out = new Uint8Array(32);
+  const ov = new DataView(out.buffer);
+  ov.setUint32(0,h0,false); ov.setUint32(4,h1,false); ov.setUint32(8,h2,false); ov.setUint32(12,h3,false);
+  ov.setUint32(16,h4,false); ov.setUint32(20,h5,false); ov.setUint32(24,h6,false); ov.setUint32(28,h7,false);
+  return out;
+}
+
+function toHex(bytes: Uint8Array): string {
+  let s = '';
+  for (let i = 0; i < bytes.length; i++) s += bytes[i].toString(16).padStart(2, '0');
+  return s;
+}
+
+/** Node.js 21+ one-shot sync hash: crypto.hash(algo, data, encoding) */
+export function hash(algorithm: string, data: string | Uint8Array, outputEncoding: string = 'hex'): string {
+  const bytes = typeof data === 'string' ? new TextEncoder().encode(data) : data;
+  const algo = algorithm.toLowerCase().replace('-', '');
+  if (algo !== 'sha256') {
+    throw new Error(`crypto.hash: only sha256 is supported in browser, got ${algorithm}`);
+  }
+  const digest = sha256sync(bytes);
+  if (outputEncoding === 'hex') return toHex(digest);
+  if (outputEncoding === 'base64') return Buffer.from(digest).toString('base64');
+  return toHex(digest);
+}
+
+export default { randomBytes, randomUUID, createHash, randomInt, getRandomValues, subtle, hash };