@hot-updater/bsdiff 0.25.13

package/LICENSE

@@ -0,0 +1,33 @@
+MIT License
+
+Copyright (c) 2023 Sungyu Kang 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+ADDITIONAL DISCLAIMER
+
+The authors of this software shall not be held responsible for any legal issues,
+regulatory violations, policy violations, or disputes arising from the use,
+distribution, or integration of this software.
+
+Users are solely responsible for ensuring compliance with all applicable laws,
+regulations, and third-party policies (including but not limited to app store
+policies).

package/dist/bun.d.ts

@@ -0,0 +1,3 @@
+import { HdiffError, HdiffErrorCode } from "./errors.js";
+import { hdiff } from "./hdiff.js";
+export { HdiffError, type HdiffErrorCode, hdiff };

package/dist/bun.js

@@ -0,0 +1,19 @@
+import { HdiffError } from "./errors.js";
+import { hdiff } from "./hdiff.js";
+import { installPrecompiledWasm } from "./precompiled.js";
+import { readFileSync } from "node:fs";
+
+//#region src/bun.ts
+const HDIFF_WASM_URL = new URL("../assets/hdiff.wasm", import.meta.url);
+installPrecompiledWasm(loadBunWasmModule());
+function loadBunWasmModule() {
+	try {
+		return new WebAssembly.Module(readFileSync(HDIFF_WASM_URL));
+	} catch {
+		throw new HdiffError("PATCH_FAILED", `Failed to load hdiff.wasm for Bun runtime: ${HDIFF_WASM_URL.toString()}`);
+	}
+}
+
+//#endregion
+export { HdiffError, hdiff };
+//# sourceMappingURL=bun.js.map

package/dist/bun.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bun.js","names":[],"sources":["../src/bun.ts"],"sourcesContent":["import { readFileSync } from \"node:fs\";\nimport { HdiffError, type HdiffErrorCode } from \"./errors.js\";\nimport { hdiff } from \"./hdiff.js\";\nimport { installPrecompiledWasm } from \"./precompiled.js\";\n\nconst HDIFF_WASM_URL = new URL(\"../assets/hdiff.wasm\", import.meta.url);\n\ninstallPrecompiledWasm(loadBunWasmModule());\n\nfunction loadBunWasmModule(): WebAssembly.Module {\n  try {\n    return new WebAssembly.Module(readFileSync(HDIFF_WASM_URL));\n  } catch {\n    throw new HdiffError(\n      \"PATCH_FAILED\",\n      `Failed to load hdiff.wasm for Bun runtime: ${HDIFF_WASM_URL.toString()}`,\n    );\n  }\n}\n\nexport { hdiff, HdiffError, type HdiffErrorCode };\n"],"mappings":";;;;;;AAKA,MAAM,iBAAiB,IAAI,IAAI,wBAAwB,OAAO,KAAK,IAAI;AAEvE,uBAAuB,mBAAmB,CAAC;AAE3C,SAAS,oBAAwC;AAC/C,KAAI;AACF,SAAO,IAAI,YAAY,OAAO,aAAa,eAAe,CAAC;SACrD;AACN,QAAM,IAAI,WACR,gBACA,8CAA8C,eAAe,UAAU,GACxE"}

package/dist/deno.d.ts

@@ -0,0 +1,3 @@
+import { HdiffError, HdiffErrorCode } from "./errors.js";
+import { hdiff } from "./hdiff.js";
+export { HdiffError, type HdiffErrorCode, hdiff };

package/dist/deno.js

@@ -0,0 +1,20 @@
+import { HdiffError } from "./errors.js";
+import { hdiff } from "./hdiff.js";
+import { installPrecompiledWasm } from "./precompiled.js";
+
+//#region src/deno.ts
+const HDIFF_WASM_URL = new URL("../assets/hdiff.wasm", import.meta.url);
+installPrecompiledWasm(loadDenoWasmModule());
+function loadDenoWasmModule() {
+	const deno = globalThis.Deno;
+	if (!deno || typeof deno.readFileSync !== "function") throw new HdiffError("PATCH_FAILED", "Deno runtime does not expose Deno.readFileSync");
+	try {
+		return new WebAssembly.Module(deno.readFileSync(HDIFF_WASM_URL));
+	} catch {
+		throw new HdiffError("PATCH_FAILED", `Failed to load hdiff.wasm for Deno runtime: ${HDIFF_WASM_URL.toString()}`);
+	}
+}
+
+//#endregion
+export { HdiffError, hdiff };
+//# sourceMappingURL=deno.js.map

package/dist/deno.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deno.js","names":[],"sources":["../src/deno.ts"],"sourcesContent":["import { HdiffError, type HdiffErrorCode } from \"./errors.js\";\nimport { hdiff } from \"./hdiff.js\";\nimport { installPrecompiledWasm } from \"./precompiled.js\";\n\nconst HDIFF_WASM_URL = new URL(\"../assets/hdiff.wasm\", import.meta.url);\n\ninstallPrecompiledWasm(loadDenoWasmModule());\n\nfunction loadDenoWasmModule(): WebAssembly.Module {\n  const deno = (\n    globalThis as {\n      Deno?: { readFileSync?: (path: string | URL) => Uint8Array };\n    }\n  ).Deno;\n  if (!deno || typeof deno.readFileSync !== \"function\") {\n    throw new HdiffError(\n      \"PATCH_FAILED\",\n      \"Deno runtime does not expose Deno.readFileSync\",\n    );\n  }\n\n  try {\n    return new WebAssembly.Module(deno.readFileSync(HDIFF_WASM_URL));\n  } catch {\n    throw new HdiffError(\n      \"PATCH_FAILED\",\n      `Failed to load hdiff.wasm for Deno runtime: ${HDIFF_WASM_URL.toString()}`,\n    );\n  }\n}\n\nexport { hdiff, HdiffError, type HdiffErrorCode };\n"],"mappings":";;;;;AAIA,MAAM,iBAAiB,IAAI,IAAI,wBAAwB,OAAO,KAAK,IAAI;AAEvE,uBAAuB,oBAAoB,CAAC;AAE5C,SAAS,qBAAyC;CAChD,MAAM,OACJ,WAGA;AACF,KAAI,CAAC,QAAQ,OAAO,KAAK,iBAAiB,WACxC,OAAM,IAAI,WACR,gBACA,iDACD;AAGH,KAAI;AACF,SAAO,IAAI,YAAY,OAAO,KAAK,aAAa,eAAe,CAAC;SAC1D;AACN,QAAM,IAAI,WACR,gBACA,+CAA+C,eAAe,UAAU,GACzE"}

package/dist/errors.d.ts

@@ -0,0 +1,9 @@
+//#region src/errors.d.ts
+type HdiffErrorCode = "INVALID_HBC" | "NON_EXECUTION_FORM" | "BYTECODE_VERSION_MISMATCH" | "PATCH_FAILED";
+declare class HdiffError extends Error {
+  readonly code: HdiffErrorCode;
+  constructor(code: HdiffErrorCode, message: string, options?: ErrorOptions);
+}
+//#endregion
+export { HdiffError, HdiffErrorCode };
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","names":[],"sources":["../src/errors.ts"],"mappings":";KAAY,cAAA;AAAA,cAMC,UAAA,SAAmB,KAAA;EAAA,SACd,IAAA,EAAM,cAAA;cAGpB,IAAA,EAAM,cAAA,EACN,OAAA,UACA,OAAA,GAAU,YAAA;AAAA"}

package/dist/errors.js

@@ -0,0 +1,13 @@
+//#region src/errors.ts
+var HdiffError = class extends Error {
+	code;
+	constructor(code, message, options) {
+		super(message, options);
+		this.name = "HdiffError";
+		this.code = code;
+	}
+};
+
+//#endregion
+export { HdiffError };
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","names":[],"sources":["../src/errors.ts"],"sourcesContent":["export type HdiffErrorCode =\n  | \"INVALID_HBC\"\n  | \"NON_EXECUTION_FORM\"\n  | \"BYTECODE_VERSION_MISMATCH\"\n  | \"PATCH_FAILED\";\n\nexport class HdiffError extends Error {\n  public readonly code: HdiffErrorCode;\n\n  public constructor(\n    code: HdiffErrorCode,\n    message: string,\n    options?: ErrorOptions,\n  ) {\n    super(message, options);\n    this.name = \"HdiffError\";\n    this.code = code;\n  }\n}\n"],"mappings":";AAMA,IAAa,aAAb,cAAgC,MAAM;CACpC,AAAgB;CAEhB,AAAO,YACL,MACA,SACA,SACA;AACA,QAAM,SAAS,QAAQ;AACvB,OAAK,OAAO;AACZ,OAAK,OAAO"}

package/dist/hdiff.d.ts

@@ -0,0 +1,7 @@
+import { BytesLike } from "./internal/bytes.js";
+
+//#region src/hdiff.d.ts
+declare function hdiff(base: BytesLike, next: BytesLike): Promise<Uint8Array>;
+//#endregion
+export { hdiff };
+//# sourceMappingURL=hdiff.d.ts.map

package/dist/hdiff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hdiff.d.ts","names":[],"sources":["../src/hdiff.ts"],"mappings":";;;iBAKsB,KAAA,CACpB,IAAA,EAAM,SAAA,EACN,IAAA,EAAM,SAAA,GACL,OAAA,CAAQ,UAAA"}

package/dist/hdiff.js

@@ -0,0 +1,18 @@
+import { HdiffError } from "./errors.js";
+import { createBsdiffPatch } from "./internal/bsdiff.js";
+import { toUint8Array } from "./internal/bytes.js";
+import { validateExecutionHbc } from "./internal/hermes-validate.js";
+
+//#region src/hdiff.ts
+async function hdiff(base, next) {
+	const baseBytes = toUint8Array(base);
+	const nextBytes = toUint8Array(next);
+	const baseMeta = await validateExecutionHbc(baseBytes);
+	const nextMeta = await validateExecutionHbc(nextBytes);
+	if (baseMeta.version !== nextMeta.version) throw new HdiffError("BYTECODE_VERSION_MISMATCH", `HBC version mismatch: base=${baseMeta.version}, next=${nextMeta.version}`);
+	return await createBsdiffPatch(baseBytes, nextBytes);
+}
+
+//#endregion
+export { hdiff };
+//# sourceMappingURL=hdiff.js.map

package/dist/hdiff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hdiff.js","names":[],"sources":["../src/hdiff.ts"],"sourcesContent":["import { HdiffError } from \"./errors.js\";\nimport { createBsdiffPatch } from \"./internal/bsdiff.js\";\nimport { type BytesLike, toUint8Array } from \"./internal/bytes.js\";\nimport { validateExecutionHbc } from \"./internal/hermes-validate.js\";\n\nexport async function hdiff(\n  base: BytesLike,\n  next: BytesLike,\n): Promise<Uint8Array> {\n  const baseBytes = toUint8Array(base);\n  const nextBytes = toUint8Array(next);\n\n  const baseMeta = await validateExecutionHbc(baseBytes);\n  const nextMeta = await validateExecutionHbc(nextBytes);\n\n  if (baseMeta.version !== nextMeta.version) {\n    throw new HdiffError(\n      \"BYTECODE_VERSION_MISMATCH\",\n      `HBC version mismatch: base=${baseMeta.version}, next=${nextMeta.version}`,\n    );\n  }\n\n  return await createBsdiffPatch(baseBytes, nextBytes);\n}\n"],"mappings":";;;;;;AAKA,eAAsB,MACpB,MACA,MACqB;CACrB,MAAM,YAAY,aAAa,KAAK;CACpC,MAAM,YAAY,aAAa,KAAK;CAEpC,MAAM,WAAW,MAAM,qBAAqB,UAAU;CACtD,MAAM,WAAW,MAAM,qBAAqB,UAAU;AAEtD,KAAI,SAAS,YAAY,SAAS,QAChC,OAAM,IAAI,WACR,6BACA,8BAA8B,SAAS,QAAQ,SAAS,SAAS,UAClE;AAGH,QAAO,MAAM,kBAAkB,WAAW,UAAU"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { HdiffError, HdiffErrorCode } from "./errors.js";
+import { hdiff } from "./hdiff.js";
+export { HdiffError, type HdiffErrorCode, hdiff };

package/dist/index.js

@@ -0,0 +1,5 @@
+import { HdiffError } from "./errors.js";
+import { hdiff } from "./hdiff.js";
+import "./node.js";
+
+export { HdiffError, hdiff };

package/dist/internal/bsdiff.d.ts

@@ -0,0 +1,6 @@
+//#region src/internal/bsdiff.d.ts
+declare function createBsdiffPatch(base: Uint8Array, next: Uint8Array): Promise<Uint8Array>;
+declare function applyBsdiffPatch(base: Uint8Array, patch: Uint8Array): Promise<Uint8Array>;
+//#endregion
+export { applyBsdiffPatch, createBsdiffPatch };
+//# sourceMappingURL=bsdiff.d.ts.map

package/dist/internal/bsdiff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bsdiff.d.ts","names":[],"sources":["../../src/internal/bsdiff.ts"],"mappings":";iBAgCsB,iBAAA,CACpB,IAAA,EAAM,UAAA,EACN,IAAA,EAAM,UAAA,GACL,OAAA,CAAQ,UAAA;AAAA,iBAkBW,gBAAA,CACpB,IAAA,EAAM,UAAA,EACN,KAAA,EAAO,UAAA,GACN,OAAA,CAAQ,UAAA"}

package/dist/internal/bsdiff.js

@@ -0,0 +1,103 @@
+import { HdiffError } from "../errors.js";
+
+//#region src/internal/bsdiff.ts
+var BsdiffStatus = /* @__PURE__ */ function(BsdiffStatus) {
+	BsdiffStatus[BsdiffStatus["OK"] = 0] = "OK";
+	BsdiffStatus[BsdiffStatus["INVALID_INPUT"] = 1] = "INVALID_INPUT";
+	BsdiffStatus[BsdiffStatus["PATCH_FAILED"] = 2] = "PATCH_FAILED";
+	BsdiffStatus[BsdiffStatus["INVALID_PATCH"] = 3] = "INVALID_PATCH";
+	return BsdiffStatus;
+}(BsdiffStatus || {});
+let wasmPromise;
+async function createBsdiffPatch(base, next) {
+	const wasm = await getBsdiffWasm();
+	const status = runBinaryOperation(wasm, base, next, (basePtr, baseLen, nextPtr, nextLen) => wasm.create_patch(basePtr, baseLen, nextPtr, nextLen));
+	if (status !== BsdiffStatus.OK) throw mapPatchError(status);
+	return readAndFreeOutput(wasm);
+}
+async function applyBsdiffPatch(base, patch) {
+	const wasm = await getBsdiffWasm();
+	const status = runBinaryOperation(wasm, base, patch, (basePtr, baseLen, patchPtr, patchLen) => wasm.apply_patch(basePtr, baseLen, patchPtr, patchLen));
+	if (status !== BsdiffStatus.OK) throw mapApplyError(status);
+	return readAndFreeOutput(wasm);
+}
+function runBinaryOperation(wasm, left, right, run) {
+	const leftPtr = wasm.alloc(left.byteLength);
+	const rightPtr = wasm.alloc(right.byteLength);
+	try {
+		writeBytesToMemory(wasm.memory, leftPtr, left);
+		writeBytesToMemory(wasm.memory, rightPtr, right);
+		return run(leftPtr, left.byteLength, rightPtr, right.byteLength);
+	} finally {
+		if (left.byteLength > 0) wasm.dealloc(leftPtr, left.byteLength);
+		if (right.byteLength > 0) wasm.dealloc(rightPtr, right.byteLength);
+	}
+}
+function writeBytesToMemory(memory, ptr, bytes) {
+	if (bytes.byteLength === 0) return;
+	new Uint8Array(memory.buffer, ptr, bytes.byteLength).set(bytes);
+}
+function readAndFreeOutput(wasm) {
+	const outPtr = wasm.output_ptr();
+	const outLen = wasm.output_len();
+	if (outLen === 0) {
+		wasm.free_output();
+		return new Uint8Array();
+	}
+	const output = new Uint8Array(wasm.memory.buffer, outPtr, outLen);
+	const copied = new Uint8Array(output);
+	wasm.free_output();
+	return copied;
+}
+function mapPatchError(status) {
+	if (status === BsdiffStatus.INVALID_INPUT) return new HdiffError("PATCH_FAILED", "Invalid input bytes provided to bsdiff wasm");
+	if (status === BsdiffStatus.PATCH_FAILED) return new HdiffError("PATCH_FAILED", "Failed to generate BSDIFF40 patch");
+	if (status === BsdiffStatus.INVALID_PATCH) return new HdiffError("PATCH_FAILED", "Unexpected patch-validation status while creating patch");
+	return new HdiffError("PATCH_FAILED", `Unknown bsdiff wasm status: ${status}`);
+}
+function mapApplyError(status) {
+	if (status === BsdiffStatus.INVALID_INPUT) return new HdiffError("PATCH_FAILED", "Invalid input bytes provided to bspatch wasm");
+	if (status === BsdiffStatus.INVALID_PATCH) return new HdiffError("PATCH_FAILED", "Invalid BSDIFF40 patch bytes");
+	if (status === BsdiffStatus.PATCH_FAILED) return new HdiffError("PATCH_FAILED", "Unexpected patch-generation status while applying patch");
+	return new HdiffError("PATCH_FAILED", `Unknown bspatch wasm status: ${status}`);
+}
+async function getBsdiffWasm() {
+	wasmPromise ??= loadBsdiffWasm();
+	return wasmPromise;
+}
+async function loadBsdiffWasm() {
+	const precompiled = getPrecompiledBsdiffModule();
+	const directExports = asBsdiffExports(precompiled);
+	if (directExports) return directExports;
+	if (isWasmModuleLike(precompiled)) return toBsdiffExports((await WebAssembly.instantiate(precompiled)).exports);
+	throw new HdiffError("PATCH_FAILED", "No precompiled bsdiff WASM configured. Import a runtime entry such as hermes-bundle-diff/node, /bun, /deno, or /worker.");
+}
+function getPrecompiledBsdiffModule() {
+	const hdiffGlobal = globalThis;
+	const mod = hdiffGlobal.__HDIFF_PRECOMPILED_BSDIFF_WASM__ ?? hdiffGlobal.__HDIFF_PRECOMPILED_WASM__;
+	if (mod && typeof mod === "object" && "default" in mod) return mod.default;
+	return mod;
+}
+function isWasmModuleLike(mod) {
+	if (mod instanceof WebAssembly.Module) return true;
+	return Object.prototype.toString.call(mod) === "[object WebAssembly.Module]";
+}
+function isWasmMemoryLike(memory) {
+	if (memory instanceof WebAssembly.Memory) return true;
+	return Object.prototype.toString.call(memory) === "[object WebAssembly.Memory]";
+}
+function toBsdiffExports(source) {
+	const direct = asBsdiffExports(source);
+	if (direct) return direct;
+	throw new HdiffError("PATCH_FAILED", "bsdiff wasm exports are incomplete");
+}
+function asBsdiffExports(source) {
+	if (source && typeof source === "object") {
+		const maybe = source;
+		if (isWasmMemoryLike(maybe.memory) && typeof maybe.alloc === "function" && typeof maybe.dealloc === "function" && typeof maybe.create_patch === "function" && typeof maybe.apply_patch === "function" && typeof maybe.output_ptr === "function" && typeof maybe.output_len === "function" && typeof maybe.free_output === "function") return maybe;
+	}
+}
+
+//#endregion
+export { applyBsdiffPatch, createBsdiffPatch };
+//# sourceMappingURL=bsdiff.js.map

package/dist/internal/bsdiff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bsdiff.js","names":[],"sources":["../../src/internal/bsdiff.ts"],"sourcesContent":["import { HdiffError } from \"../errors.js\";\n\ntype BsdiffExports = {\n  memory: WebAssembly.Memory;\n  alloc: (len: number) => number;\n  dealloc: (ptr: number, len: number) => void;\n  create_patch: (\n    basePtr: number,\n    baseLen: number,\n    nextPtr: number,\n    nextLen: number,\n  ) => number;\n  apply_patch: (\n    basePtr: number,\n    baseLen: number,\n    patchPtr: number,\n    patchLen: number,\n  ) => number;\n  output_ptr: () => number;\n  output_len: () => number;\n  free_output: () => void;\n};\n\nenum BsdiffStatus {\n  OK = 0,\n  INVALID_INPUT = 1,\n  PATCH_FAILED = 2,\n  INVALID_PATCH = 3,\n}\n\nlet wasmPromise: Promise<BsdiffExports> | undefined;\n\nexport async function createBsdiffPatch(\n  base: Uint8Array,\n  next: Uint8Array,\n): Promise<Uint8Array> {\n  const wasm = await getBsdiffWasm();\n\n  const status = runBinaryOperation(\n    wasm,\n    base,\n    next,\n    (basePtr, baseLen, nextPtr, nextLen) =>\n      wasm.create_patch(basePtr, baseLen, nextPtr, nextLen),\n  );\n\n  if (status !== BsdiffStatus.OK) {\n    throw mapPatchError(status);\n  }\n\n  return readAndFreeOutput(wasm);\n}\n\nexport async function applyBsdiffPatch(\n  base: Uint8Array,\n  patch: Uint8Array,\n): Promise<Uint8Array> {\n  const wasm = await getBsdiffWasm();\n\n  const status = runBinaryOperation(\n    wasm,\n    base,\n    patch,\n    (basePtr, baseLen, patchPtr, patchLen) =>\n      wasm.apply_patch(basePtr, baseLen, patchPtr, patchLen),\n  );\n\n  if (status !== BsdiffStatus.OK) {\n    throw mapApplyError(status);\n  }\n\n  return readAndFreeOutput(wasm);\n}\n\nfunction runBinaryOperation(\n  wasm: BsdiffExports,\n  left: Uint8Array,\n  right: Uint8Array,\n  run: (\n    leftPtr: number,\n    leftLen: number,\n    rightPtr: number,\n    rightLen: number,\n  ) => number,\n): number {\n  const leftPtr = wasm.alloc(left.byteLength);\n  const rightPtr = wasm.alloc(right.byteLength);\n\n  try {\n    writeBytesToMemory(wasm.memory, leftPtr, left);\n    writeBytesToMemory(wasm.memory, rightPtr, right);\n    return run(leftPtr, left.byteLength, rightPtr, right.byteLength);\n  } finally {\n    if (left.byteLength > 0) {\n      wasm.dealloc(leftPtr, left.byteLength);\n    }\n    if (right.byteLength > 0) {\n      wasm.dealloc(rightPtr, right.byteLength);\n    }\n  }\n}\n\nfunction writeBytesToMemory(\n  memory: WebAssembly.Memory,\n  ptr: number,\n  bytes: Uint8Array,\n): void {\n  if (bytes.byteLength === 0) {\n    return;\n  }\n  new Uint8Array(memory.buffer, ptr, bytes.byteLength).set(bytes);\n}\n\nfunction readAndFreeOutput(wasm: BsdiffExports): Uint8Array {\n  const outPtr = wasm.output_ptr();\n  const outLen = wasm.output_len();\n\n  if (outLen === 0) {\n    wasm.free_output();\n    return new Uint8Array();\n  }\n\n  const output = new Uint8Array(wasm.memory.buffer, outPtr, outLen);\n  const copied = new Uint8Array(output);\n  wasm.free_output();\n  return copied;\n}\n\nfunction mapPatchError(status: number): HdiffError {\n  if (status === BsdiffStatus.INVALID_INPUT) {\n    return new HdiffError(\n      \"PATCH_FAILED\",\n      \"Invalid input bytes provided to bsdiff wasm\",\n    );\n  }\n  if (status === BsdiffStatus.PATCH_FAILED) {\n    return new HdiffError(\"PATCH_FAILED\", \"Failed to generate BSDIFF40 patch\");\n  }\n  if (status === BsdiffStatus.INVALID_PATCH) {\n    return new HdiffError(\n      \"PATCH_FAILED\",\n      \"Unexpected patch-validation status while creating patch\",\n    );\n  }\n  return new HdiffError(\n    \"PATCH_FAILED\",\n    `Unknown bsdiff wasm status: ${status}`,\n  );\n}\n\nfunction mapApplyError(status: number): HdiffError {\n  if (status === BsdiffStatus.INVALID_INPUT) {\n    return new HdiffError(\n      \"PATCH_FAILED\",\n      \"Invalid input bytes provided to bspatch wasm\",\n    );\n  }\n  if (status === BsdiffStatus.INVALID_PATCH) {\n    return new HdiffError(\"PATCH_FAILED\", \"Invalid BSDIFF40 patch bytes\");\n  }\n  if (status === BsdiffStatus.PATCH_FAILED) {\n    return new HdiffError(\n      \"PATCH_FAILED\",\n      \"Unexpected patch-generation status while applying patch\",\n    );\n  }\n  return new HdiffError(\n    \"PATCH_FAILED\",\n    `Unknown bspatch wasm status: ${status}`,\n  );\n}\n\nasync function getBsdiffWasm(): Promise<BsdiffExports> {\n  wasmPromise ??= loadBsdiffWasm();\n  return wasmPromise;\n}\n\nasync function loadBsdiffWasm(): Promise<BsdiffExports> {\n  const precompiled = getPrecompiledBsdiffModule();\n  const directExports = asBsdiffExports(precompiled);\n  if (directExports) {\n    return directExports;\n  }\n\n  if (isWasmModuleLike(precompiled)) {\n    const instance = await WebAssembly.instantiate(precompiled);\n    return toBsdiffExports(instance.exports);\n  }\n\n  throw new HdiffError(\n    \"PATCH_FAILED\",\n    \"No precompiled bsdiff WASM configured. Import a runtime entry such as hermes-bundle-diff/node, /bun, /deno, or /worker.\",\n  );\n}\n\nfunction getPrecompiledBsdiffModule(): unknown {\n  const hdiffGlobal = globalThis as {\n    __HDIFF_PRECOMPILED_WASM__?: unknown;\n    __HDIFF_PRECOMPILED_BSDIFF_WASM__?: unknown;\n  };\n\n  const mod =\n    hdiffGlobal.__HDIFF_PRECOMPILED_BSDIFF_WASM__ ??\n    hdiffGlobal.__HDIFF_PRECOMPILED_WASM__;\n  if (mod && typeof mod === \"object\" && \"default\" in mod) {\n    return (mod as { default?: unknown }).default;\n  }\n  return mod;\n}\n\nfunction isWasmModuleLike(mod: unknown): mod is WebAssembly.Module {\n  if (mod instanceof WebAssembly.Module) {\n    return true;\n  }\n  return Object.prototype.toString.call(mod) === \"[object WebAssembly.Module]\";\n}\n\nfunction isWasmMemoryLike(memory: unknown): memory is WebAssembly.Memory {\n  if (memory instanceof WebAssembly.Memory) {\n    return true;\n  }\n  return (\n    Object.prototype.toString.call(memory) === \"[object WebAssembly.Memory]\"\n  );\n}\n\nfunction toBsdiffExports(source: unknown): BsdiffExports {\n  const direct = asBsdiffExports(source);\n  if (direct) {\n    return direct;\n  }\n\n  throw new HdiffError(\"PATCH_FAILED\", \"bsdiff wasm exports are incomplete\");\n}\n\nfunction asBsdiffExports(source: unknown): BsdiffExports | undefined {\n  if (source && typeof source === \"object\") {\n    const maybe = source as Partial<BsdiffExports>;\n    if (\n      isWasmMemoryLike(maybe.memory) &&\n      typeof maybe.alloc === \"function\" &&\n      typeof maybe.dealloc === \"function\" &&\n      typeof maybe.create_patch === \"function\" &&\n      typeof maybe.apply_patch === \"function\" &&\n      typeof maybe.output_ptr === \"function\" &&\n      typeof maybe.output_len === \"function\" &&\n      typeof maybe.free_output === \"function\"\n    ) {\n      return maybe as BsdiffExports;\n    }\n  }\n  return undefined;\n}\n"],"mappings":"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"}

package/dist/internal/bytes.d.ts

@@ -0,0 +1,8 @@
+//#region src/internal/bytes.d.ts
+type BytesLike = Uint8Array | ArrayBuffer;
+declare function toUint8Array(value: BytesLike): Uint8Array;
+declare function equalsBytes(a: Uint8Array, b: Uint8Array): boolean;
+declare function cloneBytes(value: Uint8Array): Uint8Array;
+//#endregion
+export { BytesLike, cloneBytes, equalsBytes, toUint8Array };
+//# sourceMappingURL=bytes.d.ts.map

package/dist/internal/bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.d.ts","names":[],"sources":["../../src/internal/bytes.ts"],"mappings":";KAAY,SAAA,GAAY,UAAA,GAAa,WAAA;AAAA,iBAErB,YAAA,CAAa,KAAA,EAAO,SAAA,GAAY,UAAA;AAAA,iBAUhC,WAAA,CAAY,CAAA,EAAG,UAAA,EAAY,CAAA,EAAG,UAAA;AAAA,iBAY9B,UAAA,CAAW,KAAA,EAAO,UAAA,GAAa,UAAA"}

package/dist/internal/bytes.js

@@ -0,0 +1,18 @@
+//#region src/internal/bytes.ts
+function toUint8Array(value) {
+	if (value instanceof Uint8Array) return value;
+	if (value instanceof ArrayBuffer) return new Uint8Array(value);
+	throw new TypeError("Expected Uint8Array or ArrayBuffer");
+}
+function equalsBytes(a, b) {
+	if (a.byteLength !== b.byteLength) return false;
+	for (let i = 0; i < a.byteLength; i += 1) if (a[i] !== b[i]) return false;
+	return true;
+}
+function cloneBytes(value) {
+	return new Uint8Array(value);
+}
+
+//#endregion
+export { cloneBytes, equalsBytes, toUint8Array };
+//# sourceMappingURL=bytes.js.map

package/dist/internal/bytes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.js","names":[],"sources":["../../src/internal/bytes.ts"],"sourcesContent":["export type BytesLike = Uint8Array | ArrayBuffer;\n\nexport function toUint8Array(value: BytesLike): Uint8Array {\n  if (value instanceof Uint8Array) {\n    return value;\n  }\n  if (value instanceof ArrayBuffer) {\n    return new Uint8Array(value);\n  }\n  throw new TypeError(\"Expected Uint8Array or ArrayBuffer\");\n}\n\nexport function equalsBytes(a: Uint8Array, b: Uint8Array): boolean {\n  if (a.byteLength !== b.byteLength) {\n    return false;\n  }\n  for (let i = 0; i < a.byteLength; i += 1) {\n    if (a[i] !== b[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function cloneBytes(value: Uint8Array): Uint8Array {\n  return new Uint8Array(value);\n}\n"],"mappings":";AAEA,SAAgB,aAAa,OAA8B;AACzD,KAAI,iBAAiB,WACnB,QAAO;AAET,KAAI,iBAAiB,YACnB,QAAO,IAAI,WAAW,MAAM;AAE9B,OAAM,IAAI,UAAU,qCAAqC;;AAG3D,SAAgB,YAAY,GAAe,GAAwB;AACjE,KAAI,EAAE,eAAe,EAAE,WACrB,QAAO;AAET,MAAK,IAAI,IAAI,GAAG,IAAI,EAAE,YAAY,KAAK,EACrC,KAAI,EAAE,OAAO,EAAE,GACb,QAAO;AAGX,QAAO;;AAGT,SAAgB,WAAW,OAA+B;AACxD,QAAO,IAAI,WAAW,MAAM"}

package/dist/internal/hermes-validate.d.ts

@@ -0,0 +1,8 @@
+//#region src/internal/hermes-validate.d.ts
+type ValidatedHbc = {
+  version: number;
+};
+declare function validateExecutionHbc(input: Uint8Array): Promise<ValidatedHbc>;
+//#endregion
+export { validateExecutionHbc };
+//# sourceMappingURL=hermes-validate.d.ts.map

package/dist/internal/hermes-validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hermes-validate.d.ts","names":[],"sources":["../../src/internal/hermes-validate.ts"],"mappings":";KAUK,YAAA;EACH,OAAA;AAAA;AAAA,iBAaoB,oBAAA,CACpB,KAAA,EAAO,UAAA,GACN,OAAA,CAAQ,YAAA"}

package/dist/internal/hermes-validate.js

@@ -0,0 +1,84 @@
+import { HdiffError } from "../errors.js";
+
+//#region src/internal/hermes-validate.ts
+var ValidateCode = /* @__PURE__ */ function(ValidateCode) {
+	ValidateCode[ValidateCode["OK"] = 0] = "OK";
+	ValidateCode[ValidateCode["TOO_SMALL"] = 1] = "TOO_SMALL";
+	ValidateCode[ValidateCode["INVALID_MAGIC"] = 2] = "INVALID_MAGIC";
+	ValidateCode[ValidateCode["DELTA_MAGIC"] = 3] = "DELTA_MAGIC";
+	ValidateCode[ValidateCode["INVALID_LENGTH"] = 4] = "INVALID_LENGTH";
+	return ValidateCode;
+}(ValidateCode || {});
+let wasmPromise;
+async function validateExecutionHbc(input) {
+	const wasm = await getHermesValidator();
+	if (typeof wasm.alloc === "function" && typeof wasm.dealloc === "function") {
+		const ptr = wasm.alloc(input.byteLength);
+		try {
+			if (input.byteLength > 0) new Uint8Array(wasm.memory.buffer, ptr, input.byteLength).set(input);
+			const code = wasm.validate(ptr, input.byteLength);
+			if (code !== ValidateCode.OK) throw mapValidationError(code);
+			return { version: wasm.version(ptr) >>> 0 };
+		} finally {
+			if (input.byteLength > 0) wasm.dealloc(ptr, input.byteLength);
+		}
+	}
+	ensureMemorySize(wasm.memory, input.byteLength);
+	new Uint8Array(wasm.memory.buffer, 0, input.byteLength).set(input);
+	const code = wasm.validate(0, input.byteLength);
+	if (code !== ValidateCode.OK) throw mapValidationError(code);
+	return { version: wasm.version(0) >>> 0 };
+}
+async function getHermesValidator() {
+	wasmPromise ??= loadHermesValidator();
+	return wasmPromise;
+}
+async function loadHermesValidator() {
+	const precompiled = getPrecompiledHermesModule();
+	const directExports = asHermesExports(precompiled);
+	if (directExports) return directExports;
+	if (isWasmModuleLike(precompiled)) return toHermesExports((await WebAssembly.instantiate(precompiled)).exports);
+	throw new HdiffError("INVALID_HBC", "No precompiled Hermes validator WASM configured. Import a runtime entry such as hermes-bundle-diff/node, /bun, /deno, or /worker.");
+}
+function getPrecompiledHermesModule() {
+	const hdiffGlobal = globalThis;
+	const mod = hdiffGlobal.__HDIFF_PRECOMPILED_HERMES_HBC_WASM__ ?? hdiffGlobal.__HDIFF_PRECOMPILED_WASM__;
+	if (mod && typeof mod === "object" && "default" in mod) return mod.default;
+	return mod;
+}
+function ensureMemorySize(memory, requiredBytes) {
+	const pageSize = 64 * 1024;
+	const currentBytes = memory.buffer.byteLength;
+	if (currentBytes >= requiredBytes) return;
+	const bytesNeeded = requiredBytes - currentBytes;
+	const additionalPages = Math.ceil(bytesNeeded / pageSize);
+	memory.grow(additionalPages);
+}
+function mapValidationError(code) {
+	if (code === ValidateCode.DELTA_MAGIC) return new HdiffError("NON_EXECUTION_FORM", "Input HBC is delta-form. execution-form HBC is required.");
+	if (code === ValidateCode.TOO_SMALL || code === ValidateCode.INVALID_MAGIC || code === ValidateCode.INVALID_LENGTH) return new HdiffError("INVALID_HBC", "Input is not a valid execution-form HBC");
+	return new HdiffError("INVALID_HBC", `Unknown Hermes validation error: ${code}`);
+}
+function isWasmModuleLike(mod) {
+	if (mod instanceof WebAssembly.Module) return true;
+	return Object.prototype.toString.call(mod) === "[object WebAssembly.Module]";
+}
+function isWasmMemoryLike(memory) {
+	if (memory instanceof WebAssembly.Memory) return true;
+	return Object.prototype.toString.call(memory) === "[object WebAssembly.Memory]";
+}
+function toHermesExports(source) {
+	const direct = asHermesExports(source);
+	if (direct) return direct;
+	throw new HdiffError("INVALID_HBC", "Hermes validator WASM exports are incomplete");
+}
+function asHermesExports(source) {
+	if (source && typeof source === "object") {
+		const maybe = source;
+		if (isWasmMemoryLike(maybe.memory) && typeof maybe.validate === "function" && typeof maybe.version === "function") return maybe;
+	}
+}
+
+//#endregion
+export { validateExecutionHbc };
+//# sourceMappingURL=hermes-validate.js.map

package/dist/internal/hermes-validate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hermes-validate.js","names":[],"sources":["../../src/internal/hermes-validate.ts"],"sourcesContent":["import { HdiffError } from \"../errors.js\";\n\ntype HermesValidateExports = {\n  memory: WebAssembly.Memory;\n  validate: (ptr: number, len: number) => number;\n  version: (ptr: number) => number;\n  alloc?: (len: number) => number;\n  dealloc?: (ptr: number, len: number) => void;\n};\n\ntype ValidatedHbc = {\n  version: number;\n};\n\nenum ValidateCode {\n  OK = 0,\n  TOO_SMALL = 1,\n  INVALID_MAGIC = 2,\n  DELTA_MAGIC = 3,\n  INVALID_LENGTH = 4,\n}\n\nlet wasmPromise: Promise<HermesValidateExports> | undefined;\n\nexport async function validateExecutionHbc(\n  input: Uint8Array,\n): Promise<ValidatedHbc> {\n  const wasm = await getHermesValidator();\n  if (typeof wasm.alloc === \"function\" && typeof wasm.dealloc === \"function\") {\n    const ptr = wasm.alloc(input.byteLength);\n    try {\n      if (input.byteLength > 0) {\n        new Uint8Array(wasm.memory.buffer, ptr, input.byteLength).set(input);\n      }\n\n      const code = wasm.validate(ptr, input.byteLength);\n      if (code !== ValidateCode.OK) {\n        throw mapValidationError(code);\n      }\n\n      return { version: wasm.version(ptr) >>> 0 };\n    } finally {\n      if (input.byteLength > 0) {\n        wasm.dealloc(ptr, input.byteLength);\n      }\n    }\n  }\n\n  ensureMemorySize(wasm.memory, input.byteLength);\n  const view = new Uint8Array(wasm.memory.buffer, 0, input.byteLength);\n  view.set(input);\n\n  const code = wasm.validate(0, input.byteLength);\n  if (code !== ValidateCode.OK) {\n    throw mapValidationError(code);\n  }\n\n  return { version: wasm.version(0) >>> 0 };\n}\n\nasync function getHermesValidator(): Promise<HermesValidateExports> {\n  wasmPromise ??= loadHermesValidator();\n  return wasmPromise;\n}\n\nasync function loadHermesValidator(): Promise<HermesValidateExports> {\n  const precompiled = getPrecompiledHermesModule();\n  const directExports = asHermesExports(precompiled);\n  if (directExports) {\n    return directExports;\n  }\n\n  if (isWasmModuleLike(precompiled)) {\n    const instance = await WebAssembly.instantiate(precompiled);\n    return toHermesExports(instance.exports);\n  }\n\n  throw new HdiffError(\n    \"INVALID_HBC\",\n    \"No precompiled Hermes validator WASM configured. Import a runtime entry such as hermes-bundle-diff/node, /bun, /deno, or /worker.\",\n  );\n}\n\nfunction getPrecompiledHermesModule(): unknown {\n  const hdiffGlobal = globalThis as {\n    __HDIFF_PRECOMPILED_WASM__?: unknown;\n    __HDIFF_PRECOMPILED_HERMES_HBC_WASM__?: unknown;\n  };\n\n  const mod =\n    hdiffGlobal.__HDIFF_PRECOMPILED_HERMES_HBC_WASM__ ??\n    hdiffGlobal.__HDIFF_PRECOMPILED_WASM__;\n  if (mod && typeof mod === \"object\" && \"default\" in mod) {\n    return (mod as { default?: unknown }).default;\n  }\n  return mod;\n}\n\nfunction ensureMemorySize(\n  memory: WebAssembly.Memory,\n  requiredBytes: number,\n): void {\n  const pageSize = 64 * 1024;\n  const currentBytes = memory.buffer.byteLength;\n  if (currentBytes >= requiredBytes) {\n    return;\n  }\n\n  const bytesNeeded = requiredBytes - currentBytes;\n  const additionalPages = Math.ceil(bytesNeeded / pageSize);\n  memory.grow(additionalPages);\n}\n\nfunction mapValidationError(code: number): HdiffError {\n  if (code === ValidateCode.DELTA_MAGIC) {\n    return new HdiffError(\n      \"NON_EXECUTION_FORM\",\n      \"Input HBC is delta-form. execution-form HBC is required.\",\n    );\n  }\n  if (\n    code === ValidateCode.TOO_SMALL ||\n    code === ValidateCode.INVALID_MAGIC ||\n    code === ValidateCode.INVALID_LENGTH\n  ) {\n    return new HdiffError(\n      \"INVALID_HBC\",\n      \"Input is not a valid execution-form HBC\",\n    );\n  }\n  return new HdiffError(\n    \"INVALID_HBC\",\n    `Unknown Hermes validation error: ${code}`,\n  );\n}\n\nfunction isWasmModuleLike(mod: unknown): mod is WebAssembly.Module {\n  if (mod instanceof WebAssembly.Module) {\n    return true;\n  }\n  return Object.prototype.toString.call(mod) === \"[object WebAssembly.Module]\";\n}\n\nfunction isWasmMemoryLike(memory: unknown): memory is WebAssembly.Memory {\n  if (memory instanceof WebAssembly.Memory) {\n    return true;\n  }\n  return (\n    Object.prototype.toString.call(memory) === \"[object WebAssembly.Memory]\"\n  );\n}\n\nfunction toHermesExports(source: unknown): HermesValidateExports {\n  const direct = asHermesExports(source);\n  if (direct) {\n    return direct;\n  }\n\n  throw new HdiffError(\n    \"INVALID_HBC\",\n    \"Hermes validator WASM exports are incomplete\",\n  );\n}\n\nfunction asHermesExports(source: unknown): HermesValidateExports | undefined {\n  if (source && typeof source === \"object\") {\n    const maybe = source as Partial<HermesValidateExports>;\n    if (\n      isWasmMemoryLike(maybe.memory) &&\n      typeof maybe.validate === \"function\" &&\n      typeof maybe.version === \"function\"\n    ) {\n      return maybe as HermesValidateExports;\n    }\n  }\n  return undefined;\n}\n"],"mappings":";;;AAcA,IAAK,eAAL;AACE;AACA;AACA;AACA;AACA;;EALG,mBAMJ;AAED,IAAI;AAEJ,eAAsB,qBACpB,OACuB;CACvB,MAAM,OAAO,MAAM,oBAAoB;AACvC,KAAI,OAAO,KAAK,UAAU,cAAc,OAAO,KAAK,YAAY,YAAY;EAC1E,MAAM,MAAM,KAAK,MAAM,MAAM,WAAW;AACxC,MAAI;AACF,OAAI,MAAM,aAAa,EACrB,KAAI,WAAW,KAAK,OAAO,QAAQ,KAAK,MAAM,WAAW,CAAC,IAAI,MAAM;GAGtE,MAAM,OAAO,KAAK,SAAS,KAAK,MAAM,WAAW;AACjD,OAAI,SAAS,aAAa,GACxB,OAAM,mBAAmB,KAAK;AAGhC,UAAO,EAAE,SAAS,KAAK,QAAQ,IAAI,KAAK,GAAG;YACnC;AACR,OAAI,MAAM,aAAa,EACrB,MAAK,QAAQ,KAAK,MAAM,WAAW;;;AAKzC,kBAAiB,KAAK,QAAQ,MAAM,WAAW;AAE/C,CADa,IAAI,WAAW,KAAK,OAAO,QAAQ,GAAG,MAAM,WAAW,CAC/D,IAAI,MAAM;CAEf,MAAM,OAAO,KAAK,SAAS,GAAG,MAAM,WAAW;AAC/C,KAAI,SAAS,aAAa,GACxB,OAAM,mBAAmB,KAAK;AAGhC,QAAO,EAAE,SAAS,KAAK,QAAQ,EAAE,KAAK,GAAG;;AAG3C,eAAe,qBAAqD;AAClE,iBAAgB,qBAAqB;AACrC,QAAO;;AAGT,eAAe,sBAAsD;CACnE,MAAM,cAAc,4BAA4B;CAChD,MAAM,gBAAgB,gBAAgB,YAAY;AAClD,KAAI,cACF,QAAO;AAGT,KAAI,iBAAiB,YAAY,CAE/B,QAAO,iBADU,MAAM,YAAY,YAAY,YAAY,EAC3B,QAAQ;AAG1C,OAAM,IAAI,WACR,eACA,oIACD;;AAGH,SAAS,6BAAsC;CAC7C,MAAM,cAAc;CAKpB,MAAM,MACJ,YAAY,yCACZ,YAAY;AACd,KAAI,OAAO,OAAO,QAAQ,YAAY,aAAa,IACjD,QAAQ,IAA8B;AAExC,QAAO;;AAGT,SAAS,iBACP,QACA,eACM;CACN,MAAM,WAAW,KAAK;CACtB,MAAM,eAAe,OAAO,OAAO;AACnC,KAAI,gBAAgB,cAClB;CAGF,MAAM,cAAc,gBAAgB;CACpC,MAAM,kBAAkB,KAAK,KAAK,cAAc,SAAS;AACzD,QAAO,KAAK,gBAAgB;;AAG9B,SAAS,mBAAmB,MAA0B;AACpD,KAAI,SAAS,aAAa,YACxB,QAAO,IAAI,WACT,sBACA,2DACD;AAEH,KACE,SAAS,aAAa,aACtB,SAAS,aAAa,iBACtB,SAAS,aAAa,eAEtB,QAAO,IAAI,WACT,eACA,0CACD;AAEH,QAAO,IAAI,WACT,eACA,oCAAoC,OACrC;;AAGH,SAAS,iBAAiB,KAAyC;AACjE,KAAI,eAAe,YAAY,OAC7B,QAAO;AAET,QAAO,OAAO,UAAU,SAAS,KAAK,IAAI,KAAK;;AAGjD,SAAS,iBAAiB,QAA+C;AACvE,KAAI,kBAAkB,YAAY,OAChC,QAAO;AAET,QACE,OAAO,UAAU,SAAS,KAAK,OAAO,KAAK;;AAI/C,SAAS,gBAAgB,QAAwC;CAC/D,MAAM,SAAS,gBAAgB,OAAO;AACtC,KAAI,OACF,QAAO;AAGT,OAAM,IAAI,WACR,eACA,+CACD;;AAGH,SAAS,gBAAgB,QAAoD;AAC3E,KAAI,UAAU,OAAO,WAAW,UAAU;EACxC,MAAM,QAAQ;AACd,MACE,iBAAiB,MAAM,OAAO,IAC9B,OAAO,MAAM,aAAa,cAC1B,OAAO,MAAM,YAAY,WAEzB,QAAO"}

package/dist/node.d.ts

@@ -0,0 +1,3 @@
+import { HdiffError, HdiffErrorCode } from "./errors.js";
+import { hdiff } from "./hdiff.js";
+export { HdiffError, type HdiffErrorCode, hdiff };

package/dist/node.js

@@ -0,0 +1,19 @@
+import { HdiffError } from "./errors.js";
+import { hdiff } from "./hdiff.js";
+import { installPrecompiledWasm } from "./precompiled.js";
+import { readFileSync } from "node:fs";
+
+//#region src/node.ts
+const HDIFF_WASM_URL = new URL("../assets/hdiff.wasm", import.meta.url);
+installPrecompiledWasm(loadNodeWasmModule());
+function loadNodeWasmModule() {
+	try {
+		return new WebAssembly.Module(readFileSync(HDIFF_WASM_URL));
+	} catch {
+		throw new HdiffError("PATCH_FAILED", `Failed to load hdiff.wasm for Node runtime: ${HDIFF_WASM_URL.toString()}`);
+	}
+}
+
+//#endregion
+export { HdiffError, hdiff };
+//# sourceMappingURL=node.js.map

package/dist/node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.js","names":[],"sources":["../src/node.ts"],"sourcesContent":["import { readFileSync } from \"node:fs\";\nimport { HdiffError, type HdiffErrorCode } from \"./errors.js\";\nimport { hdiff } from \"./hdiff.js\";\nimport { installPrecompiledWasm } from \"./precompiled.js\";\n\nconst HDIFF_WASM_URL = new URL(\"../assets/hdiff.wasm\", import.meta.url);\n\ninstallPrecompiledWasm(loadNodeWasmModule());\n\nfunction loadNodeWasmModule(): WebAssembly.Module {\n  try {\n    return new WebAssembly.Module(readFileSync(HDIFF_WASM_URL));\n  } catch {\n    throw new HdiffError(\n      \"PATCH_FAILED\",\n      `Failed to load hdiff.wasm for Node runtime: ${HDIFF_WASM_URL.toString()}`,\n    );\n  }\n}\n\nexport { hdiff, HdiffError, type HdiffErrorCode };\n"],"mappings":";;;;;;AAKA,MAAM,iBAAiB,IAAI,IAAI,wBAAwB,OAAO,KAAK,IAAI;AAEvE,uBAAuB,oBAAoB,CAAC;AAE5C,SAAS,qBAAyC;AAChD,KAAI;AACF,SAAO,IAAI,YAAY,OAAO,aAAa,eAAe,CAAC;SACrD;AACN,QAAM,IAAI,WACR,gBACA,+CAA+C,eAAe,UAAU,GACzE"}

package/dist/precompiled.d.ts

@@ -0,0 +1,5 @@
+//#region src/precompiled.d.ts
+declare function installPrecompiledWasm(wasmModule: WebAssembly.Module): void;
+//#endregion
+export { installPrecompiledWasm };
+//# sourceMappingURL=precompiled.d.ts.map

package/dist/precompiled.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"precompiled.d.ts","names":[],"sources":["../src/precompiled.ts"],"mappings":";iBAMgB,sBAAA,CAAuB,UAAA,EAAY,WAAA,CAAY,MAAA"}

package/dist/precompiled.js

@@ -0,0 +1,11 @@
+//#region src/precompiled.ts
+function installPrecompiledWasm(wasmModule) {
+	const hdiffGlobal = globalThis;
+	if (hdiffGlobal.__HDIFF_PRECOMPILED_WASM__ === void 0) hdiffGlobal.__HDIFF_PRECOMPILED_WASM__ = wasmModule;
+	if (hdiffGlobal.__HDIFF_PRECOMPILED_BSDIFF_WASM__ === void 0) hdiffGlobal.__HDIFF_PRECOMPILED_BSDIFF_WASM__ = wasmModule;
+	if (hdiffGlobal.__HDIFF_PRECOMPILED_HERMES_HBC_WASM__ === void 0) hdiffGlobal.__HDIFF_PRECOMPILED_HERMES_HBC_WASM__ = wasmModule;
+}
+
+//#endregion
+export { installPrecompiledWasm };
+//# sourceMappingURL=precompiled.js.map

package/dist/precompiled.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"precompiled.js","names":[],"sources":["../src/precompiled.ts"],"sourcesContent":["type HdiffGlobal = {\n  __HDIFF_PRECOMPILED_WASM__?: unknown;\n  __HDIFF_PRECOMPILED_BSDIFF_WASM__?: unknown;\n  __HDIFF_PRECOMPILED_HERMES_HBC_WASM__?: unknown;\n};\n\nexport function installPrecompiledWasm(wasmModule: WebAssembly.Module): void {\n  const hdiffGlobal = globalThis as HdiffGlobal;\n\n  if (hdiffGlobal.__HDIFF_PRECOMPILED_WASM__ === undefined) {\n    hdiffGlobal.__HDIFF_PRECOMPILED_WASM__ = wasmModule;\n  }\n  if (hdiffGlobal.__HDIFF_PRECOMPILED_BSDIFF_WASM__ === undefined) {\n    hdiffGlobal.__HDIFF_PRECOMPILED_BSDIFF_WASM__ = wasmModule;\n  }\n  if (hdiffGlobal.__HDIFF_PRECOMPILED_HERMES_HBC_WASM__ === undefined) {\n    hdiffGlobal.__HDIFF_PRECOMPILED_HERMES_HBC_WASM__ = wasmModule;\n  }\n}\n"],"mappings":";AAMA,SAAgB,uBAAuB,YAAsC;CAC3E,MAAM,cAAc;AAEpB,KAAI,YAAY,+BAA+B,OAC7C,aAAY,6BAA6B;AAE3C,KAAI,YAAY,sCAAsC,OACpD,aAAY,oCAAoC;AAElD,KAAI,YAAY,0CAA0C,OACxD,aAAY,wCAAwC"}

package/dist/worker.d.ts

@@ -0,0 +1,3 @@
+import { HdiffError, HdiffErrorCode } from "./errors.js";
+import { hdiff } from "./hdiff.js";
+export { HdiffError, type HdiffErrorCode, hdiff };

package/dist/worker.js

@@ -0,0 +1,11 @@
+import { HdiffError } from "./errors.js";
+import { hdiff } from "./hdiff.js";
+import { installPrecompiledWasm } from "./precompiled.js";
+import hdiffWasmModule from "../assets/hdiff.wasm";
+
+//#region src/worker.ts
+installPrecompiledWasm(hdiffWasmModule);
+
+//#endregion
+export { HdiffError, hdiff };
+//# sourceMappingURL=worker.js.map

package/dist/worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.js","names":[],"sources":["../src/worker.ts"],"sourcesContent":["import hdiffWasmModule from \"../assets/hdiff.wasm\";\nimport { HdiffError, type HdiffErrorCode } from \"./errors.js\";\nimport { hdiff } from \"./hdiff.js\";\nimport { installPrecompiledWasm } from \"./precompiled.js\";\n\ninstallPrecompiledWasm(hdiffWasmModule);\n\nexport { hdiff, HdiffError, type HdiffErrorCode };\n"],"mappings":";;;;;;AAKA,uBAAuB,gBAAgB"}

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@hot-updater/bsdiff",
+  "version": "0.25.13",
+  "description": "Hot Updater BSdiff library that produces BSDIFF40 patches for RN bspatch flows",
+  "type": "module",
+  "main": "./dist/node.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "workerd": "./dist/worker.js",
+      "worker": "./dist/worker.js",
+      "deno": "./dist/deno.js",
+      "bun": "./dist/bun.js",
+      "node": "./dist/node.js",
+      "import": "./dist/node.js",
+      "default": "./dist/node.js"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "import": "./dist/node.js",
+      "default": "./dist/node.js"
+    },
+    "./deno": {
+      "types": "./dist/deno.d.ts",
+      "import": "./dist/deno.js",
+      "default": "./dist/deno.js"
+    },
+    "./bun": {
+      "types": "./dist/bun.d.ts",
+      "import": "./dist/bun.js",
+      "default": "./dist/bun.js"
+    },
+    "./worker": {
+      "types": "./dist/worker.d.ts",
+      "import": "./dist/worker.js",
+      "default": "./dist/worker.js"
+    }
+  },
+  "files": [
+    "dist",
+    "assets",
+    "scripts/wasm-build",
+    "rust/hdiff-wasm/Cargo.toml",
+    "rust/hdiff-wasm/src"
+  ],
+  "keywords": [
+    "hermes",
+    "hbc",
+    "bsdiff",
+    "bspatch",
+    "react-native"
+  ],
+  "devDependencies": {
+    "@types/node": "^25.3.2",
+    "tsdown": "0.21.0-beta.2",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18",
+    "wrangler": "^4.69.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "pnpm run build:wasm && tsdown",
+    "build:watch": "tsdown --watch",
+    "build:wasm": "node ./scripts/wasm-build/build-wasm.mjs",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:runtime:node": "vitest run tests/runtime.node.test.ts",
+    "test:runtime:endpoints": "vitest run tests/runtime.endpoints.test.ts"
+  }
+}

package/rust/hdiff-wasm/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "hdiff_wasm"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+bsdiff = "0.2.1"
+bzip2 = "0.6.1"
+
+[profile.release]
+opt-level = "z"
+lto = true
+codegen-units = 1
+panic = "abort"

package/rust/hdiff-wasm/src/lib.rs

@@ -0,0 +1,380 @@
+use bzip2::read::BzDecoder;
+use bzip2::write::BzEncoder;
+use bzip2::Compression;
+use std::io::Cursor;
+use std::io::Read;
+use std::io::Write;
+
+const MIN_HEADER_LEN: u32 = 128;
+const EXEC_MAGIC_LO: u32 = 0x03BC_1FC6;
+const EXEC_MAGIC_HI: u32 = 0x1F19_03C1;
+const DELTA_MAGIC_LO: u32 = 0xFC43_E039;
+const DELTA_MAGIC_HI: u32 = 0xE0E6_FC3E;
+
+const OFFSET_VERSION: u32 = 8;
+const OFFSET_FILE_LENGTH: u32 = 32;
+const OFFSET_MAGIC_HI: u32 = 4;
+
+const VALIDATE_OK: u32 = 0;
+const VALIDATE_TOO_SMALL: u32 = 1;
+const VALIDATE_INVALID_MAGIC: u32 = 2;
+const VALIDATE_DELTA_MAGIC: u32 = 3;
+const VALIDATE_INVALID_LENGTH: u32 = 4;
+
+const STATUS_OK: u32 = 0;
+const STATUS_INVALID_INPUT: u32 = 1;
+const STATUS_PATCH_FAILED: u32 = 2;
+const STATUS_INVALID_PATCH: u32 = 3;
+
+static mut LAST_OUTPUT_PTR: *mut u8 = std::ptr::null_mut();
+static mut LAST_OUTPUT_LEN: usize = 0;
+static mut LAST_OUTPUT_CAP: usize = 0;
+
+#[no_mangle]
+pub unsafe extern "C" fn validate(ptr: u32, len: u32) -> u32 {
+    if len < MIN_HEADER_LEN {
+        return VALIDATE_TOO_SMALL;
+    }
+
+    let magic_lo = read_u32(ptr);
+    let magic_hi = read_u32(ptr.wrapping_add(OFFSET_MAGIC_HI));
+
+    if magic_lo == EXEC_MAGIC_LO {
+        if magic_hi != EXEC_MAGIC_HI {
+            return VALIDATE_INVALID_MAGIC;
+        }
+    } else {
+        if magic_lo == DELTA_MAGIC_LO && magic_hi == DELTA_MAGIC_HI {
+            return VALIDATE_DELTA_MAGIC;
+        }
+        return VALIDATE_INVALID_MAGIC;
+    }
+
+    let file_length = read_u32(ptr.wrapping_add(OFFSET_FILE_LENGTH));
+    if file_length != len {
+        return VALIDATE_INVALID_LENGTH;
+    }
+
+    VALIDATE_OK
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn version(ptr: u32) -> u32 {
+    read_u32(ptr.wrapping_add(OFFSET_VERSION))
+}
+
+#[no_mangle]
+pub extern "C" fn alloc(len: u32) -> u32 {
+    let mut bytes = Vec::<u8>::with_capacity(len as usize);
+    let ptr = bytes.as_mut_ptr();
+    std::mem::forget(bytes);
+    ptr as u32
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn dealloc(ptr: u32, len: u32) {
+    if ptr == 0 || len == 0 {
+        return;
+    }
+
+    drop(Vec::from_raw_parts(
+        ptr as *mut u8,
+        len as usize,
+        len as usize,
+    ));
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn create_patch(
+    base_ptr: u32,
+    base_len: u32,
+    next_ptr: u32,
+    next_len: u32,
+) -> u32 {
+    let base = match copy_input(base_ptr, base_len) {
+        Ok(base) => base,
+        Err(_) => return STATUS_INVALID_INPUT,
+    };
+    let next = match copy_input(next_ptr, next_len) {
+        Ok(next) => next,
+        Err(_) => return STATUS_INVALID_INPUT,
+    };
+
+    match generate_bsdiff40_patch(&base, &next) {
+        Ok(patch) => {
+            store_output(patch);
+            STATUS_OK
+        }
+        Err(_) => STATUS_PATCH_FAILED,
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn apply_patch(
+    base_ptr: u32,
+    base_len: u32,
+    patch_ptr: u32,
+    patch_len: u32,
+) -> u32 {
+    let base = match copy_input(base_ptr, base_len) {
+        Ok(base) => base,
+        Err(_) => return STATUS_INVALID_INPUT,
+    };
+    let patch = match copy_input(patch_ptr, patch_len) {
+        Ok(patch) => patch,
+        Err(_) => return STATUS_INVALID_INPUT,
+    };
+
+    match apply_bsdiff40_patch(&base, &patch) {
+        Ok(next) => {
+            store_output(next);
+            STATUS_OK
+        }
+        Err(_) => STATUS_INVALID_PATCH,
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn output_ptr() -> u32 {
+    unsafe { LAST_OUTPUT_PTR as u32 }
+}
+
+#[no_mangle]
+pub extern "C" fn output_len() -> u32 {
+    unsafe { LAST_OUTPUT_LEN as u32 }
+}
+
+#[no_mangle]
+pub extern "C" fn free_output() {
+    unsafe {
+        free_output_buffer();
+    }
+}
+
+#[inline]
+unsafe fn read_u32(ptr: u32) -> u32 {
+    std::ptr::read_unaligned(ptr as *const u32)
+}
+
+unsafe fn copy_input(ptr: u32, len: u32) -> Result<Vec<u8>, ()> {
+    if len == 0 {
+        return Ok(Vec::new());
+    }
+    if ptr == 0 {
+        return Err(());
+    }
+
+    let bytes = std::slice::from_raw_parts(ptr as *const u8, len as usize);
+    Ok(bytes.to_vec())
+}
+
+fn store_output(bytes: Vec<u8>) {
+    unsafe {
+        free_output_buffer();
+
+        let mut output = bytes;
+        LAST_OUTPUT_PTR = output.as_mut_ptr();
+        LAST_OUTPUT_LEN = output.len();
+        LAST_OUTPUT_CAP = output.capacity();
+        std::mem::forget(output);
+    }
+}
+
+unsafe fn free_output_buffer() {
+    if LAST_OUTPUT_PTR.is_null() {
+        LAST_OUTPUT_LEN = 0;
+        LAST_OUTPUT_CAP = 0;
+        return;
+    }
+
+    drop(Vec::from_raw_parts(
+        LAST_OUTPUT_PTR,
+        LAST_OUTPUT_LEN,
+        LAST_OUTPUT_CAP,
+    ));
+    LAST_OUTPUT_PTR = std::ptr::null_mut();
+    LAST_OUTPUT_LEN = 0;
+    LAST_OUTPUT_CAP = 0;
+}
+
+fn generate_bsdiff40_patch(old: &[u8], new: &[u8]) -> Result<Vec<u8>, String> {
+    let mut legacy_patch = Vec::new();
+    bsdiff::diff(old, new, &mut legacy_patch).map_err(|error| format!("{error}"))?;
+
+    let (ctrl_block, diff_block, extra_block) = split_legacy_patch(&legacy_patch)?;
+
+    let ctrl_bz = bzip2_compress(&ctrl_block)?;
+    let diff_bz = bzip2_compress(&diff_block)?;
+    let extra_bz = bzip2_compress(&extra_block)?;
+
+    let mut patch = Vec::with_capacity(32 + ctrl_bz.len() + diff_bz.len() + extra_bz.len());
+    patch.extend_from_slice(b"BSDIFF40");
+    write_offt(ctrl_bz.len() as i64, &mut patch)?;
+    write_offt(diff_bz.len() as i64, &mut patch)?;
+    write_offt(new.len() as i64, &mut patch)?;
+    patch.extend_from_slice(&ctrl_bz);
+    patch.extend_from_slice(&diff_bz);
+    patch.extend_from_slice(&extra_bz);
+
+    Ok(patch)
+}
+
+fn split_legacy_patch(legacy_patch: &[u8]) -> Result<(Vec<u8>, Vec<u8>, Vec<u8>), String> {
+    let mut controls = Vec::new();
+    let mut diff_data = Vec::new();
+    let mut extra_data = Vec::new();
+
+    let mut cursor = 0usize;
+    while cursor < legacy_patch.len() {
+        if legacy_patch.len() - cursor < 24 {
+            return Err("invalid legacy patch control length".to_string());
+        }
+
+        let ctrl_bytes = &legacy_patch[cursor..cursor + 24];
+        let add_len = read_offt(&ctrl_bytes[0..8])?;
+        let copy_len = read_offt(&ctrl_bytes[8..16])?;
+        let _seek = read_offt(&ctrl_bytes[16..24])?;
+
+        if add_len < 0 || copy_len < 0 {
+            return Err("invalid legacy patch control values".to_string());
+        }
+
+        let add_len = usize::try_from(add_len).map_err(|_| "add length overflow".to_string())?;
+        let copy_len =
+            usize::try_from(copy_len).map_err(|_| "copy length overflow".to_string())?;
+        cursor += 24;
+
+        if legacy_patch.len() - cursor < add_len {
+            return Err("legacy patch truncated in diff section".to_string());
+        }
+        diff_data.extend_from_slice(&legacy_patch[cursor..cursor + add_len]);
+        cursor += add_len;
+
+        if legacy_patch.len() - cursor < copy_len {
+            return Err("legacy patch truncated in extra section".to_string());
+        }
+        extra_data.extend_from_slice(&legacy_patch[cursor..cursor + copy_len]);
+        cursor += copy_len;
+
+        controls.extend_from_slice(ctrl_bytes);
+    }
+
+    Ok((controls, diff_data, extra_data))
+}
+
+fn apply_bsdiff40_patch(old: &[u8], patch: &[u8]) -> Result<Vec<u8>, String> {
+    if patch.len() < 32 || &patch[0..8] != b"BSDIFF40" {
+        return Err("invalid BSDIFF40 header".to_string());
+    }
+
+    let ctrl_len = read_offt(&patch[8..16])?;
+    let diff_len = read_offt(&patch[16..24])?;
+    let new_size = read_offt(&patch[24..32])?;
+    if ctrl_len < 0 || diff_len < 0 || new_size < 0 {
+        return Err("negative BSDIFF40 header values".to_string());
+    }
+
+    let ctrl_len = usize::try_from(ctrl_len).map_err(|_| "control length overflow".to_string())?;
+    let diff_len = usize::try_from(diff_len).map_err(|_| "diff length overflow".to_string())?;
+    let new_size = usize::try_from(new_size).map_err(|_| "new size overflow".to_string())?;
+
+    let ctrl_start = 32usize;
+    let ctrl_end = ctrl_start
+        .checked_add(ctrl_len)
+        .ok_or_else(|| "control block overflow".to_string())?;
+    let diff_end = ctrl_end
+        .checked_add(diff_len)
+        .ok_or_else(|| "diff block overflow".to_string())?;
+    if diff_end > patch.len() {
+        return Err("BSDIFF40 block bounds are invalid".to_string());
+    }
+
+    let mut ctrl_reader = BzDecoder::new(Cursor::new(&patch[ctrl_start..ctrl_end]));
+    let mut diff_reader = BzDecoder::new(Cursor::new(&patch[ctrl_end..diff_end]));
+    let mut extra_reader = BzDecoder::new(Cursor::new(&patch[diff_end..]));
+
+    let mut out = Vec::with_capacity(new_size);
+    let mut old_pos: i64 = 0;
+
+    while out.len() < new_size {
+        let mut ctrl_buf = [0u8; 24];
+        ctrl_reader
+            .read_exact(&mut ctrl_buf)
+            .map_err(|error| format!("failed to read control block: {error}"))?;
+
+        let add_len = read_offt(&ctrl_buf[0..8])?;
+        let copy_len = read_offt(&ctrl_buf[8..16])?;
+        let seek_len = read_offt(&ctrl_buf[16..24])?;
+        if add_len < 0 || copy_len < 0 {
+            return Err("negative add/copy length in control block".to_string());
+        }
+
+        let add_len = usize::try_from(add_len).map_err(|_| "add length overflow".to_string())?;
+        let copy_len =
+            usize::try_from(copy_len).map_err(|_| "copy length overflow".to_string())?;
+
+        let mut diff_bytes = vec![0u8; add_len];
+        diff_reader
+            .read_exact(&mut diff_bytes)
+            .map_err(|error| format!("failed to read diff block: {error}"))?;
+        for delta_byte in diff_bytes {
+            if old_pos < 0 || old_pos as usize >= old.len() {
+                return Err("old file offset out of bounds".to_string());
+            }
+            let old_byte = old[old_pos as usize];
+            out.push(delta_byte.wrapping_add(old_byte));
+            old_pos += 1;
+        }
+
+        let mut extra_bytes = vec![0u8; copy_len];
+        extra_reader
+            .read_exact(&mut extra_bytes)
+            .map_err(|error| format!("failed to read extra block: {error}"))?;
+        out.extend_from_slice(&extra_bytes);
+
+        old_pos = old_pos
+            .checked_add(seek_len)
+            .ok_or_else(|| "old file seek overflow".to_string())?;
+
+        if out.len() > new_size {
+            return Err("patch output exceeds target size".to_string());
+        }
+    }
+
+    if out.len() != new_size {
+        return Err("patch output length mismatch".to_string());
+    }
+
+    Ok(out)
+}
+
+fn bzip2_compress(input: &[u8]) -> Result<Vec<u8>, String> {
+    let mut encoder = BzEncoder::new(Vec::new(), Compression::new(6));
+    encoder.write_all(input).map_err(|error| format!("{error}"))?;
+    encoder.finish().map_err(|error| format!("{error}"))
+}
+
+fn read_offt(bytes: &[u8]) -> Result<i64, String> {
+    if bytes.len() < 8 {
+        return Err("offset bytes too short".to_string());
+    }
+
+    let mut raw = [0u8; 8];
+    raw.copy_from_slice(&bytes[0..8]);
+    let value = i64::from_le_bytes(raw);
+    if value & (1_i64 << 63) == 0 {
+        Ok(value)
+    } else {
+        Ok(-(value & !(1_i64 << 63)))
+    }
+}
+
+fn write_offt(value: i64, out: &mut Vec<u8>) -> Result<(), String> {
+    if value < 0 {
+        return Err("negative header value".to_string());
+    }
+
+    let encoded = u64::try_from(value).map_err(|_| "header value overflow".to_string())?;
+    out.extend_from_slice(&encoded.to_le_bytes());
+    Ok(())
+}

package/scripts/wasm-build/build-wasm.mjs

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { cpSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const rootDir = findProjectRoot(__dirname);
+const configPath = path.join(__dirname, "config.json");
+const config = JSON.parse(readFileSync(configPath, "utf8"));
+
+const cargoBin = config.tools?.cargo || "cargo";
+const rustupBin = config.tools?.rustup || "rustup";
+const target = resolveBuildTarget(config.wasm || {});
+
+ensureRustTargetInstalled(rustupBin, target.rustTarget);
+
+console.log(`[wasm] building ${target.manifestPath}`);
+execFileSync(
+  cargoBin,
+  ["build", "--manifest-path", target.manifestPath, "--target", target.rustTarget, "--release"],
+  { stdio: "inherit" }
+);
+
+if (!existsSync(target.sourceWasm)) {
+  throw new Error(`[wasm] build succeeded but wasm output is missing: ${target.sourceWasm}`);
+}
+
+mkdirSync(path.dirname(target.outputWasm), { recursive: true });
+cpSync(target.sourceWasm, target.outputWasm);
+
+console.log(`[wasm] copied ${target.sourceWasm} -> ${target.outputWasm}`);
+console.log(`[wasm] sha256 ${sha256File(target.outputWasm)}`);
+
+function resolveBuildTarget(targetConfig) {
+  const crateDir = resolvePath(targetConfig.crateDir || "rust/hdiff-wasm");
+  const rustTarget = targetConfig.rustTarget || "wasm32-unknown-unknown";
+  const manifestPath = resolvePath(targetConfig.manifestPath || path.join(crateDir, "Cargo.toml"));
+  const crateName = targetConfig.crateName || readCargoPackageName(manifestPath);
+  const wasmFileName = targetConfig.wasmFileName || `${crateName.replaceAll("-", "_")}.wasm`;
+
+  const sourceWasm = resolvePath(
+    targetConfig.sourceWasm || path.join(crateDir, "target", rustTarget, "release", wasmFileName)
+  );
+
+  const outputWasm = resolvePath(targetConfig.outputWasm || "assets/hdiff.wasm");
+
+  return {
+    rustTarget,
+    manifestPath,
+    sourceWasm,
+    outputWasm,
+  };
+}
+
+function ensureRustTargetInstalled(rustup, target) {
+  let installedTargets;
+  try {
+    installedTargets = execFileSync(rustup, ["target", "list", "--installed"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+  } catch (error) {
+    throw new Error(`[wasm] ${rustup} is required to build wasm. Original error: ${String(error)}`);
+  }
+
+  const installed = new Set(installedTargets.split(/\r?\n/).filter(Boolean));
+  if (installed.has(target)) {
+    return;
+  }
+
+  console.log(`[wasm] installing rust target: ${target}`);
+  execFileSync(rustup, ["target", "add", target], { stdio: "inherit" });
+}
+
+function readCargoPackageName(manifestPath) {
+  const raw = readFileSync(manifestPath, "utf8");
+  const packageSection = raw.match(/\[package\]([\s\S]*?)(?:\n\s*\[|$)/)?.[1] ?? "";
+  const name = packageSection.match(/^\s*name\s*=\s*"([^"]+)"/m)?.[1];
+  if (!name) {
+    throw new Error(`[wasm] unable to resolve crate name from ${manifestPath}`);
+  }
+  return name;
+}
+
+function resolvePath(value) {
+  return path.isAbsolute(value) ? value : path.resolve(rootDir, value);
+}
+
+function sha256File(filePath) {
+  return createHash("sha256").update(readFileSync(filePath)).digest("hex");
+}
+
+function findProjectRoot(startDir) {
+  let cursor = startDir;
+  while (true) {
+    if (existsSync(path.join(cursor, "package.json"))) {
+      return cursor;
+    }
+
+    const parent = path.dirname(cursor);
+    if (parent === cursor) {
+      throw new Error(`[wasm] unable to find project root from ${startDir}`);
+    }
+    cursor = parent;
+  }
+}

package/scripts/wasm-build/config.json

@@ -0,0 +1,11 @@
+{
+  "tools": {
+    "cargo": "cargo",
+    "rustup": "rustup"
+  },
+  "wasm": {
+    "crateDir": "rust/hdiff-wasm",
+    "rustTarget": "wasm32-unknown-unknown",
+    "outputWasm": "assets/hdiff.wasm"
+  }
+}