nitro-patcher 0.1.0

package/src/nitro-patch-helper.ts

@@ -0,0 +1,95 @@
+// Native TypeScript port of NitroPatchHelper/PatchHelper.cs, GPL-3.0.
+import { hashDigest, readFile } from '#nitro-runtime';
+import { bytes } from './nitro/binary';
+import { NDSFile } from './nitro/nds-file';
+import { readZip } from './patch/zip';
+import { decodeXdelta } from './patch/xdelta';
+
+export const PatchReturnValue = Object.freeze({
+  SUCCESS: 'SUCCESS',
+  MD5_MISMATCH: 'MD5_MISMATCH',
+} as const);
+export type PatchReturnValue = (typeof PatchReturnValue)[keyof typeof PatchReturnValue];
+
+export interface PatchResult {
+  /** Generated ROM bytes. Also returned when the MD5 does not match, as in the original helper. */
+  buffer: Buffer;
+  returnValue: PatchReturnValue;
+  /** MD5 of the original input, before preprocessing. */
+  inputMd5: string;
+  outputMd5: string;
+}
+
+export interface PatchOptions {
+  /** Maximum generated ROM/Xdelta target size in bytes, default 1 GiB. */
+  maxOutputSize?: number;
+  /** Maximum target size of an individual VCDIFF window, default 16 MiB. */
+  maxWindowSize?: number;
+  /** Maximum total uncompressed ZIP bytes, default 1 GiB. */
+  maxUncompressedSize?: number;
+  /** Maximum ZIP entry count. */
+  maxEntries?: number;
+}
+
+const md5 = (data: Uint8Array): string => hashDigest('md5', data).toString('hex');
+
+/** Apply an existing NitroPatcher ZIP package entirely in memory. */
+export const patchBuffer = (
+  original: Uint8Array,
+  patch: Uint8Array,
+  options: PatchOptions = {},
+): PatchResult => {
+  const input = bytes(original, 'original ROM');
+  const patches = readZip(patch, options);
+  const inputMd5 = md5(input);
+  const preprocessing = patches.get(`preprocessing/${inputMd5}.xdelta`);
+  const rom = new NDSFile(
+    preprocessing ? decodeXdelta(input, preprocessing, options) : input,
+    options,
+  );
+  let matched = true;
+  const md5File = patches.get('md5.txt');
+  if (md5File) {
+    matched = false;
+    for (const line of md5File.toString('utf8').split('\n')) {
+      const expected = line.trim();
+      if (!expected || expected.startsWith('#')) continue;
+      // Keep the original format contract: exactly 32 characters, case-insensitive comparison.
+      if (expected.length !== 32) throw new Error('md5.txt 格式错误，可能是因为补丁包已损坏。');
+      if (expected.toLowerCase() === inputMd5) {
+        matched = true;
+        break;
+      }
+    }
+  }
+  for (const { path } of rom.listFiles()) {
+    const normalized = path.replaceAll('\\', '/').toLowerCase();
+    const delta = patches.get(`xdelta/${normalized}`);
+    const replacement = delta
+      ? decodeXdelta(rom.getFile(path), delta, options)
+      : patches.get(normalized);
+    if (replacement) rom.replaceFile(path, replacement);
+  }
+  const buffer = rom.toBuffer();
+  return {
+    buffer,
+    returnValue: matched ? PatchReturnValue.SUCCESS : PatchReturnValue.MD5_MISMATCH,
+    inputMd5,
+    outputMd5: md5(buffer),
+  };
+};
+
+/** Read input files and apply the patch. Does not write an output file. */
+export const patchIt = async (
+  originalPath: string,
+  patchPath: string,
+  options: PatchOptions = {},
+): Promise<PatchResult> => {
+  const [original, patch] = await Promise.all([readFile(originalPath), readFile(patchPath)]);
+  return patchBuffer(original, patch, options);
+};
+
+/** Namespaced counterpart of the original C# helper, sharing the same typed functions. */
+export const PatchHelper = Object.freeze({ patchBuffer, patchIt });
+export { decodeXdelta } from './patch/xdelta';
+export type { XdeltaOptions } from './patch/xdelta';

package/src/patch/xdelta.ts

@@ -0,0 +1,214 @@
+/** Native RFC 3284 VCDIFF decoder with the xdelta3 Adler32/app-header extensions.
+ * Supports the same default-table, uncompressed format as PleOps.XdeltaSharp 1.3.0.
+ * Secondary compression and custom code tables are explicitly unsupported there too.
+ */
+const UINT32_MAX = 0xffffffff;
+const fail = (message: string): never => {
+  throw new Error(`VCDIFF: ${message}`);
+};
+
+class Reader {
+  pos = 0;
+  constructor(
+    readonly bytes: Buffer,
+    readonly label = 'patch',
+  ) {}
+  get remaining() {
+    return this.bytes.length - this.pos;
+  }
+  byte() {
+    if (!this.remaining) fail(`truncated ${this.label}`);
+    return this.bytes[this.pos++]!;
+  }
+  integer(): number {
+    let value = 0;
+    for (let count = 0; count < 5; count++) {
+      const byte = this.byte();
+      value = value * 128 + (byte & 127);
+      if (value > UINT32_MAX) fail(`integer exceeds 32-bit limit in ${this.label}`);
+      if (!(byte & 128)) return value;
+    }
+    return fail(`invalid variable-length integer in ${this.label}`);
+  }
+  take(size: number): Buffer {
+    if (size > this.remaining)
+      fail(`truncated ${this.label}: requested ${size} bytes, ${this.remaining} remain`);
+    const result = this.bytes.subarray(this.pos, this.pos + size);
+    this.pos += size;
+    return result;
+  }
+}
+
+// RFC 3284 section 5.6: (operation, size, COPY address mode), up to two per opcode.
+type Operation = { type: 'ADD' | 'RUN' | 'COPY'; size: number; mode: number };
+const table: Operation[][] = [];
+const op = (type: Operation['type'], size: number, mode = 0): Operation => ({ type, size, mode });
+table.push([op('RUN', 0)]);
+for (let size = 0; size <= 17; size++) table.push([op('ADD', size)]);
+for (let mode = 0; mode <= 8; mode++) {
+  table.push([op('COPY', 0, mode)]);
+  for (let size = 4; size <= 18; size++) table.push([op('COPY', size, mode)]);
+}
+for (let mode = 0; mode <= 5; mode++) {
+  for (let add = 1; add <= 4; add++) {
+    for (let copy = 4; copy <= 6; copy++) table.push([op('ADD', add), op('COPY', copy, mode)]);
+  }
+}
+for (let mode = 6; mode <= 8; mode++) {
+  for (let add = 1; add <= 4; add++) table.push([op('ADD', add), op('COPY', 4, mode)]);
+}
+for (let mode = 0; mode <= 8; mode++) table.push([op('COPY', 4, mode), op('ADD', 1)]);
+
+function adler32(bytes: Uint8Array): number {
+  let a = 1,
+    b = 0;
+  for (let start = 0; start < bytes.length; start += 5552) {
+    const end = Math.min(start + 5552, bytes.length);
+    for (let i = start; i < end; i++) {
+      a += bytes[i]!;
+      b += a;
+    }
+    a %= 65521;
+    b %= 65521;
+  }
+  return (b * 65536 + a) >>> 0;
+}
+
+function asBuffer(value: Uint8Array, name: string): Buffer {
+  if (!(value instanceof Uint8Array)) throw new TypeError(`${name} must be a Buffer or Uint8Array`);
+  return Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+}
+function limit(value: number | undefined, fallback: number, name: string): number {
+  value ??= fallback;
+  if (!Number.isSafeInteger(value) || value < 0 || value > UINT32_MAX)
+    throw new RangeError(`${name} must be an integer between 0 and ${UINT32_MAX}`);
+  return value;
+}
+
+/**
+ * @param {Buffer|Uint8Array} source Original bytes.
+ * @param {Buffer|Uint8Array} patch VCDIFF bytes.
+ * @param {{maxOutputSize?: number, maxWindowSize?: number}} [options]
+ * @returns {Buffer} Decoded target, only returned after all windows/checksums validate.
+ */
+export interface XdeltaOptions {
+  maxOutputSize?: number;
+  maxWindowSize?: number;
+}
+
+export const decodeXdelta = (
+  source: Uint8Array,
+  patch: Uint8Array,
+  options: XdeltaOptions = {},
+): Buffer => {
+  const sourceBytes = asBuffer(source, 'source');
+  const reader = new Reader(asBuffer(patch, 'patch'));
+  const maxOutput = limit(options.maxOutputSize, 1024 * 1024 * 1024, 'maxOutputSize');
+  const maxWindow = limit(options.maxWindowSize, 16 * 1024 * 1024, 'maxWindowSize');
+  if (!reader.take(3).equals(Buffer.from([0xd6, 0xc3, 0xc4]))) fail('invalid file signature');
+  if (reader.byte() !== 0) fail('unsupported version (expected 0)');
+  const header = reader.byte();
+  if (header & ~7) fail('unrecognized header indicator bits');
+  if (header & 1)
+    fail('secondary compression is unsupported; recreate the patch using xdelta3 -S none');
+  if (header & 2) fail('custom code table is unsupported');
+  if (header & 4) reader.take(reader.integer());
+  const windows: Buffer[] = [];
+  let total = 0;
+
+  while (reader.remaining) {
+    const indicator = reader.byte();
+    if (indicator & ~7 || (indicator & 3) === 3)
+      fail('invalid window indicator: source and target are mutually exclusive');
+    let dictionary: Buffer = Buffer.alloc(0);
+    if (indicator & 3) {
+      const length = reader.integer();
+      const offset = reader.integer();
+      const available = indicator & 1 ? sourceBytes.length : total;
+      if (offset > available || length > available - offset)
+        fail('source segment exceeds available source/target bounds');
+      if (indicator & 1) dictionary = sourceBytes.subarray(offset, offset + length);
+      else {
+        dictionary = Buffer.allocUnsafe(length);
+        let base = 0;
+        for (const previous of windows) {
+          const start = Math.max(offset, base),
+            end = Math.min(offset + length, base + previous.length);
+          if (end > start) previous.copy(dictionary, start - offset, start - base, end - base);
+          base += previous.length;
+          if (base >= offset + length) break;
+        }
+      }
+    }
+    const deltaLength = reader.integer();
+    const delta = new Reader(reader.take(deltaLength), 'delta window');
+    const targetLength = delta.integer();
+    if (targetLength > maxWindow)
+      fail(`window size ${targetLength} exceeds maximum limit ${maxWindow}`);
+    if (targetLength > maxOutput - total) fail(`output size exceeds maximum limit ${maxOutput}`);
+    if (dictionary.length + targetLength > UINT32_MAX)
+      fail('window address space exceeds 32-bit limit');
+    const compressed = delta.byte();
+    if (compressed & ~7) fail('unrecognized delta indicator bits');
+    if (compressed) fail('secondary compression in delta sections is unsupported');
+    const dataLength = delta.integer(),
+      instructionLength = delta.integer(),
+      addressLength = delta.integer();
+    const checksum = indicator & 4 ? delta.take(4).readUInt32BE() : null;
+    const data = new Reader(delta.take(dataLength), 'data section');
+    const instructions = new Reader(delta.take(instructionLength), 'instruction section');
+    const addresses = new Reader(delta.take(addressLength), 'address section');
+    if (delta.remaining) fail('delta encoding length does not match section lengths');
+    const target = Buffer.allocUnsafe(targetLength);
+    const near = new Uint32Array(4),
+      same = new Uint32Array(768);
+    let nearIndex = 0,
+      position = 0;
+    while (instructions.remaining) {
+      const operations = table[instructions.byte()]!;
+      for (const { type, size: fixedSize, mode } of operations) {
+        const size = fixedSize || instructions.integer();
+        if (size > targetLength - position) fail(`${type} size exceeds target window length`);
+        if (type === 'ADD') {
+          data.take(size).copy(target, position);
+        } else if (type === 'RUN') {
+          target.fill(data.byte(), position, position + size);
+        } else {
+          const here = dictionary.length + position;
+          let address;
+          if (mode === 0) address = addresses.integer();
+          else if (mode === 1) address = here - addresses.integer();
+          else if (mode < 6) address = near[mode - 2]! + addresses.integer();
+          else address = same[(mode - 6) * 256 + addresses.byte()]!;
+          if (address < 0 || address >= here)
+            fail(`COPY address ${address} is outside decoded address space ${here}`);
+          near[nearIndex] = address;
+          nearIndex = (nearIndex + 1) % near.length;
+          same[address % same.length] = address;
+          let copied = 0;
+          if (address < dictionary.length) {
+            copied = Math.min(size, dictionary.length - address);
+            dictionary.copy(target, position, address, address + copied);
+          }
+          // Copy only already available bytes per iteration. Doubling handles overlap
+          // (including a copy crossing from dictionary to current target) efficiently.
+          const from = Math.max(0, address - dictionary.length);
+          while (copied < size) {
+            const count = Math.min(size - copied, position + copied - from);
+            if (count <= 0) fail('COPY references unavailable target bytes');
+            target.copy(target, position + copied, from, from + count);
+            copied += count;
+          }
+        }
+        position += size;
+      }
+    }
+    if (position !== targetLength)
+      fail(`target window length mismatch: decoded ${position}, expected ${targetLength}`);
+    if (data.remaining || addresses.remaining) fail('unused bytes in data/address section');
+    if (checksum !== null && adler32(target) !== checksum) fail('Adler32 checksum mismatch');
+    windows.push(target);
+    total += targetLength;
+  }
+  return Buffer.concat(windows, total);
+};

package/src/patch/zip.ts

@@ -0,0 +1,206 @@
+import { inflateRawSync } from '#nitro-runtime';
+import { crc32 } from '../nitro/crc';
+
+/** Resource limits apply to every central-directory entry, including duplicates. */
+export interface ZipOptions {
+  maxUncompressedSize?: number;
+  maxEntries?: number;
+}
+
+const fail = (message: string): never => {
+  throw new Error(`ZIP: ${message}`);
+};
+const utf8 = new TextDecoder('utf-8', { fatal: true });
+// IBM code page 437, byte values 0x80..0xff. ASCII bytes retain their literal values.
+const cp437 =
+  'ÇüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜ¢£¥₧ƒáíóúñѪº¿⌐¬½¼¡«»░▒▓│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀αßΓπΣσµτΦΘΩδ∞φε∩≡±≥≤⌠⌡÷≈°∙·√ⁿ²■ ';
+
+function decodeUtf8(bytes: Uint8Array): string {
+  try {
+    return utf8.decode(bytes);
+  } catch {
+    return fail('invalid UTF-8 filename');
+  }
+}
+function boundOption(value: number | undefined, fallback: number, label: string): number {
+  value ??= fallback;
+  if (!Number.isSafeInteger(value) || value < 0)
+    throw new RangeError(`${label} must be a non-negative safe integer`);
+  return value;
+}
+function checkRange(bytes: Buffer, offset: number, length: number, end = bytes.length): void {
+  if (offset < 0 || offset > end || length > end - offset)
+    fail(`truncated or out-of-bounds record at ${offset} (length ${length})`);
+}
+function extras(bytes: Buffer): Map<number, Buffer> {
+  const fields = new Map<number, Buffer>();
+  let offset = 0;
+  while (offset < bytes.length) {
+    checkRange(bytes, offset, 4);
+    const id = bytes.readUInt16LE(offset),
+      length = bytes.readUInt16LE(offset + 2);
+    offset += 4;
+    checkRange(bytes, offset, length);
+    if (id === 1) fail('ZIP64 archives are unsupported');
+    fields.set(id, bytes.subarray(offset, offset + length));
+    offset += length;
+  }
+  return fields;
+}
+function filename(raw: Buffer, flags: number, fields: Map<number, Buffer>): string {
+  if (flags & 0x800) return decodeUtf8(raw);
+  const unicode = fields.get(0x7075);
+  if (unicode && unicode.length >= 5 && unicode[0] === 1 && unicode.readUInt32LE(1) === crc32(raw))
+    return decodeUtf8(unicode.subarray(5));
+  let result = '';
+  for (const byte of raw) result += byte < 128 ? String.fromCharCode(byte) : cp437[byte - 128]!;
+  return result;
+}
+
+/**
+ * Read stored/deflated, single-disk ZIPs entirely in memory. Central-directory
+ * sizes support streamed entries with data descriptors. Paths match PatchHelper:
+ * backslashes become slashes, names are lowercase, and the final duplicate wins.
+ * ZIP64, encryption, split archives and other compression methods fail explicitly.
+ * Format reference: https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
+ */
+export const readZip = (input: Uint8Array, options: ZipOptions = {}): Map<string, Buffer> => {
+  if (!(input instanceof Uint8Array))
+    throw new TypeError('ZIP input must be a Buffer or Uint8Array');
+  const bytes = Buffer.from(input.buffer, input.byteOffset, input.byteLength);
+  const maxSize = boundOption(
+    options.maxUncompressedSize,
+    1024 * 1024 * 1024,
+    'maxUncompressedSize',
+  );
+  const maxEntries = boundOption(options.maxEntries, 100000, 'maxEntries');
+  let eocd = -1;
+  for (let offset = bytes.length - 22; offset >= Math.max(0, bytes.length - 65557); offset--) {
+    if (
+      bytes.readUInt32LE(offset) === 0x06054b50 &&
+      offset + 22 + bytes.readUInt16LE(offset + 20) === bytes.length
+    ) {
+      eocd = offset;
+      break;
+    }
+  }
+  if (eocd < 0) fail('end of central directory not found or truncated');
+  const disk = bytes.readUInt16LE(eocd + 4),
+    centralDisk = bytes.readUInt16LE(eocd + 6);
+  const diskEntries = bytes.readUInt16LE(eocd + 8),
+    count = bytes.readUInt16LE(eocd + 10);
+  const centralSize = bytes.readUInt32LE(eocd + 12),
+    centralOffset = bytes.readUInt32LE(eocd + 16);
+  if (
+    count === 0xffff ||
+    diskEntries === 0xffff ||
+    centralSize === 0xffffffff ||
+    centralOffset === 0xffffffff ||
+    (eocd >= 20 && bytes.readUInt32LE(eocd - 20) === 0x07064b50)
+  )
+    fail('ZIP64 archives are unsupported');
+  if (disk || centralDisk || diskEntries !== count)
+    fail('split or multiple-disk archives are unsupported');
+  if (count > maxEntries) fail(`entry count exceeds limit ${maxEntries}`);
+  checkRange(bytes, centralOffset, centralSize, eocd);
+  if (centralOffset + centralSize !== eocd) fail('central directory size/offset mismatch');
+  if (count > Math.floor(centralSize / 46)) fail('entry count exceeds central directory size');
+  const result = new Map<string, Buffer>();
+  const ranges: Array<{ start: number; end: number }> = [];
+  let offset = centralOffset,
+    totalSize = 0;
+  for (let index = 0; index < count; index++) {
+    checkRange(bytes, offset, 46, eocd);
+    if (bytes.readUInt32LE(offset) !== 0x02014b50) fail('invalid central directory signature');
+    const flags = bytes.readUInt16LE(offset + 8),
+      method = bytes.readUInt16LE(offset + 10);
+    const checksum = bytes.readUInt32LE(offset + 16),
+      compressedSize = bytes.readUInt32LE(offset + 20),
+      size = bytes.readUInt32LE(offset + 24);
+    const nameLength = bytes.readUInt16LE(offset + 28),
+      extraLength = bytes.readUInt16LE(offset + 30),
+      commentLength = bytes.readUInt16LE(offset + 32);
+    const startDisk = bytes.readUInt16LE(offset + 34),
+      localOffset = bytes.readUInt32LE(offset + 42);
+    if (
+      size === 0xffffffff ||
+      compressedSize === 0xffffffff ||
+      localOffset === 0xffffffff ||
+      startDisk === 0xffff
+    )
+      fail('ZIP64 entry is unsupported');
+    if (startDisk) fail('split or multiple-disk entry is unsupported');
+    if (flags & 0x2041) fail('encrypted entries are unsupported');
+    if (flags & ~0x80e) fail('unsupported general purpose flags');
+    if (method !== 0 && method !== 8) fail(`unsupported compression method ${method}`);
+    if (size > maxSize - totalSize) fail(`uncompressed size exceeds limit ${maxSize}`);
+    totalSize += size;
+    checkRange(bytes, offset + 46, nameLength + extraLength + commentLength, eocd);
+    const rawName = bytes.subarray(offset + 46, offset + 46 + nameLength);
+    const fields = extras(
+      bytes.subarray(offset + 46 + nameLength, offset + 46 + nameLength + extraLength),
+    );
+    const name = filename(rawName, flags, fields).replaceAll('\\', '/').toLowerCase();
+    offset += 46 + nameLength + extraLength + commentLength;
+
+    checkRange(bytes, localOffset, 30, centralOffset);
+    if (bytes.readUInt32LE(localOffset) !== 0x04034b50) fail('invalid local header signature');
+    if (
+      bytes.readUInt16LE(localOffset + 6) !== flags ||
+      bytes.readUInt16LE(localOffset + 8) !== method
+    )
+      fail('local header flags/compression method mismatch');
+    const localNameLength = bytes.readUInt16LE(localOffset + 26),
+      localExtraLength = bytes.readUInt16LE(localOffset + 28);
+    const dataOffset = localOffset + 30 + localNameLength + localExtraLength;
+    checkRange(bytes, localOffset + 30, localNameLength + localExtraLength, centralOffset);
+    if (!rawName.equals(bytes.subarray(localOffset + 30, localOffset + 30 + localNameLength)))
+      fail('local filename differs from central directory');
+    extras(bytes.subarray(localOffset + 30 + localNameLength, dataOffset));
+    if (
+      !(flags & 8) &&
+      (bytes.readUInt32LE(localOffset + 14) !== checksum ||
+        bytes.readUInt32LE(localOffset + 18) !== compressedSize ||
+        bytes.readUInt32LE(localOffset + 22) !== size)
+    )
+      fail('local header CRC/size mismatch');
+    checkRange(bytes, dataOffset, compressedSize, centralOffset);
+    let dataEnd = dataOffset + compressedSize;
+    if (flags & 8) {
+      // A descriptor may omit its signature. Use the CRC and both sizes to
+      // disambiguate the rare case of an unsigned CRC equal to the signature.
+      checkRange(bytes, dataEnd, 12, centralOffset);
+      const matches = (at: number): boolean =>
+        at + 12 <= centralOffset &&
+        bytes.readUInt32LE(at) === checksum &&
+        bytes.readUInt32LE(at + 4) === compressedSize &&
+        bytes.readUInt32LE(at + 8) === size;
+      if (matches(dataEnd)) dataEnd += 12;
+      else if (bytes.readUInt32LE(dataEnd) === 0x08074b50 && matches(dataEnd + 4)) dataEnd += 16;
+      else fail('data descriptor CRC/size mismatch');
+    }
+    ranges.push({ start: localOffset, end: dataEnd });
+    const compressed = bytes.subarray(dataOffset, dataOffset + compressedSize);
+    let data: Buffer;
+    if (method === 0) {
+      if (compressedSize !== size) fail('stored entry compressed/uncompressed size mismatch');
+      data = Buffer.from(compressed);
+    } else {
+      try {
+        data = inflateRawSync(compressed, { maxOutputLength: Math.max(1, size) });
+      } catch (error) {
+        return fail(
+          `cannot inflate entry ${JSON.stringify(name)} within declared size: ${error instanceof Error ? error.message : String(error)}`,
+        );
+      }
+    }
+    if (data.length !== size) fail(`uncompressed size mismatch for ${JSON.stringify(name)}`);
+    if (crc32(data) !== checksum) fail(`CRC32 mismatch for ${JSON.stringify(name)}`);
+    if (name && !name.endsWith('/')) result.set(name, data);
+  }
+  if (offset !== eocd) fail('central directory entry count/length mismatch');
+  ranges.sort((a, b) => a.start - b.start);
+  for (let i = 1; i < ranges.length; i++)
+    if (ranges[i]!.start < ranges[i - 1]!.end) fail('overlapping local entry ranges');
+  return result;
+};

package/src/runtime/browser.ts

@@ -0,0 +1,40 @@
+import { md5, sha1 } from '#browser-hashes';
+import { hmac } from '#browser-hmac';
+import { ecb } from '#browser-aes';
+import { Inflate } from 'fflate';
+
+export const hashDigest = (algorithm: 'md5' | 'sha1', data: Uint8Array): Buffer =>
+  Buffer.from((algorithm === 'md5' ? md5 : sha1)(data));
+export const hmacSha1 = (key: Uint8Array, data: Uint8Array): Buffer =>
+  Buffer.from(hmac(sha1, key, data));
+export const createAesBlockCipher =
+  (key: Uint8Array): ((block: Uint8Array) => Buffer) =>
+  (block) =>
+    Buffer.from(ecb(key, { disablePadding: true }).encrypt(block));
+
+/** Bound decompression output even when a ZIP entry lies about its size. */
+export const inflateRawSync = (data: Uint8Array, options: { maxOutputLength: number }): Buffer => {
+  const output = Buffer.alloc(options.maxOutputLength);
+  let length = 0;
+  const stream = new Inflate((chunk) => {
+    if (chunk.length > output.length - length)
+      throw new RangeError('Inflated data exceeds declared size');
+    output.set(chunk, length);
+    length += chunk.length;
+  });
+  for (let offset = 0; offset < data.length; offset += 1024) {
+    stream.push(data.subarray(offset, offset + 1024), offset + 1024 >= data.length);
+  }
+  if (!data.length) stream.push(data, true);
+  return output.subarray(0, length);
+};
+
+// These Node-only methods are not exposed by the browser public API. Keep a
+// clear error if a future internal call accidentally crosses that boundary.
+const nodeOnly = (): never => {
+  throw new Error('Filesystem and RSA APIs are only available in the Node entry');
+};
+export const readFile = nodeOnly;
+export const writeFile = nodeOnly;
+export const readFileSync = nodeOnly;
+export const verifyRsaSha1 = nodeOnly;

package/src/runtime/node.ts

@@ -0,0 +1,28 @@
+import { createHash, createHmac, createCipheriv, createPublicKey, verify } from 'node:crypto';
+export { readFile, writeFile } from 'node:fs/promises';
+export { readFileSync } from 'node:fs';
+export { inflateRawSync } from 'node:zlib';
+
+export const hashDigest = (algorithm: 'md5' | 'sha1', data: Uint8Array): Buffer =>
+  createHash(algorithm).update(data).digest();
+export const hmacSha1 = (key: Uint8Array, data: Uint8Array): Buffer =>
+  createHmac('sha1', key).update(data).digest();
+export const createAesBlockCipher = (key: Uint8Array): ((block: Uint8Array) => Buffer) => {
+  const cipher = createCipheriv('aes-128-ecb', key, null);
+  cipher.setAutoPadding(false);
+  return (block) => cipher.update(block);
+};
+export const verifyRsaSha1 = (data: Uint8Array, signature: Uint8Array): boolean => {
+  const key = createPublicKey({
+    key: {
+      kty: 'RSA',
+      n: Buffer.from(
+        '956F790DF08BB85A76AAEFA27FE874758BED9EDF9E9A670CD818BEB9B2885203B3FA11AEAA186513B5D6BB85A384D0D0EFB366CBC6051AAA86827AB74311F59C9BFC6C7079D5F17BD0819F522056738C721F40CF2361932590A3C5DC94CFD17A8CBC954A918AA858F4D804BAF7D3C1C4D7B8F077012FA170260B2C049056F3A5',
+        'hex',
+      ).toString('base64url'),
+      e: 'AQAB',
+    },
+    format: 'jwk',
+  });
+  return verify('RSA-SHA1', data, key, signature);
+};