@prisma/streams-server 0.0.1 → 0.1.0

package/src/reader.ts

@@ -0,0 +1,454 @@
+import { existsSync, openSync, readSync, closeSync } from "node:fs";
+import type { Config } from "./config";
+import type { SqliteDurableStore, SegmentRow } from "./db/db";
+import type { ObjectStore } from "./objectstore/interface";
+import { parseOffsetResult, offsetToSeqOrNeg1, encodeOffset } from "./offset";
+import { decodeBlockResult, iterateBlocksResult, parseBlockHeaderResult, parseFooterBytes, DSB3_HEADER_BYTES, type SegmentFooter } from "./segment/format";
+import { SegmentDiskCache, type SegmentCacheStats } from "./segment/cache";
+import { Bloom256 } from "./util/bloom256";
+import { segmentObjectKey, streamHash16Hex } from "./util/stream_paths";
+import { readU32BE } from "./util/endian";
+import { retry, type RetryOptions } from "./util/retry";
+import { LruCache } from "./util/lru";
+import type { IndexManager } from "./index/indexer";
+import { dsError } from "./util/ds_error.ts";
+import { Result } from "better-result";
+
+export type ReadFormat = "raw" | "json";
+
+export type ReadBatch = {
+  stream: string;
+  format: ReadFormat;
+  key: string | null;
+  requestOffset: string;
+  endOffset: string; // checkpoint at end of stream
+  nextOffset: string; // checkpoint after this response
+  endOffsetSeq: bigint;
+  nextOffsetSeq: bigint;
+  records: Array<{ offset: bigint; payload: Uint8Array }>; // payload bytes in wire order
+};
+
+export type ReaderError =
+  | { kind: "not_found"; message: string }
+  | { kind: "gone"; message: string }
+  | { kind: "invalid_offset"; message: string }
+  | { kind: "internal"; message: string };
+
+type FooterCacheEntry = { footer: SegmentFooter | null; footerStart: number };
+
+function errorMessage(e: unknown): string {
+  return String((e as any)?.message ?? e);
+}
+
+function utf8Bytes(s: string): Uint8Array {
+  return new TextEncoder().encode(s);
+}
+
+function objectKeyForSegment(seg: SegmentRow): string {
+  const streamHash = streamHash16Hex(seg.stream);
+  return segmentObjectKey(streamHash, seg.segment_index);
+}
+
+function readRangeFromFile(path: string, start: number, end: number): Uint8Array {
+  const len = end - start + 1;
+  const fd = openSync(path, "r");
+  try {
+    const buf = Buffer.alloc(len);
+    const bytesRead = readSync(fd, buf, 0, len, start);
+    if (bytesRead !== len) throw dsError("short read");
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+  } finally {
+    closeSync(fd);
+  }
+}
+
+async function readSegmentRange(
+  os: ObjectStore,
+  seg: SegmentRow,
+  start: number,
+  end: number,
+  diskCache?: SegmentDiskCache,
+  retryOpts?: RetryOptions
+): Promise<Uint8Array> {
+  const local = seg.local_path;
+  if (existsSync(local)) return readRangeFromFile(local, start, end);
+
+  const objectKey = objectKeyForSegment(seg);
+  if (diskCache && diskCache.has(objectKey)) {
+    diskCache.recordHit();
+    diskCache.touch(objectKey);
+    return readRangeFromFile(diskCache.getPath(objectKey), start, end);
+  }
+  if (diskCache) diskCache.recordMiss();
+
+  const bytes = await retry(
+    async () => {
+      const res = await os.get(objectKey, { range: { start, end } });
+      if (!res) throw dsError(`object store missing segment: ${objectKey}`);
+      return res;
+    },
+    retryOpts ?? { retries: 0, baseDelayMs: 0, maxDelayMs: 0, timeoutMs: 0 }
+  );
+  if (diskCache && start === 0 && end === seg.size_bytes - 1) {
+    diskCache.put(objectKey, bytes);
+  }
+  return bytes;
+}
+
+async function loadSegmentBytes(
+  os: ObjectStore,
+  seg: SegmentRow,
+  diskCache?: SegmentDiskCache,
+  retryOpts?: RetryOptions
+): Promise<Uint8Array> {
+  return readSegmentRange(os, seg, 0, seg.size_bytes - 1, diskCache, retryOpts);
+}
+
+async function loadSegmentFooter(
+  os: ObjectStore,
+  seg: SegmentRow,
+  diskCache?: SegmentDiskCache,
+  retryOpts?: RetryOptions,
+  footerCache?: LruCache<string, FooterCacheEntry>
+): Promise<{ footer: SegmentFooter | null; footerStart: number } | null> {
+  const cacheKey = seg.segment_id;
+  if (footerCache) {
+    const cached = footerCache.get(cacheKey);
+    if (cached) return cached;
+  }
+  if (seg.size_bytes < 8) return null;
+  const tail = await readSegmentRange(os, seg, seg.size_bytes - 8, seg.size_bytes - 1, diskCache, retryOpts);
+  const magic = String.fromCharCode(tail[4], tail[5], tail[6], tail[7]);
+  if (magic !== "DSF1") return null;
+  const footerLen = readU32BE(tail, 0);
+  const footerStart = seg.size_bytes - 8 - footerLen;
+  if (footerStart < 0) return null;
+  const footerBytes = await readSegmentRange(os, seg, footerStart, footerStart + footerLen - 1, diskCache, retryOpts);
+  const footer = parseFooterBytes(footerBytes);
+  const result = { footer, footerStart };
+  if (footerCache) footerCache.set(cacheKey, result);
+  return result;
+}
+
+export class StreamReader {
+  private readonly config: Config;
+  private readonly db: SqliteDurableStore;
+  private readonly os: ObjectStore;
+  private readonly diskCache?: SegmentDiskCache;
+  private readonly footerCache?: LruCache<string, FooterCacheEntry>;
+  private readonly index?: IndexManager;
+
+  constructor(config: Config, db: SqliteDurableStore, os: ObjectStore, diskCache?: SegmentDiskCache, index?: IndexManager) {
+    this.config = config;
+    this.db = db;
+    this.os = os;
+    this.diskCache = diskCache;
+    this.index = index;
+    if (config.segmentFooterCacheEntries > 0) {
+      this.footerCache = new LruCache(config.segmentFooterCacheEntries);
+    }
+  }
+
+  cacheStats(): SegmentCacheStats | null {
+    return this.diskCache ? this.diskCache.stats() : null;
+  }
+
+  private retryOpts(): RetryOptions {
+    return {
+      retries: this.config.objectStoreRetries,
+      baseDelayMs: this.config.objectStoreBaseDelayMs,
+      maxDelayMs: this.config.objectStoreMaxDelayMs,
+      timeoutMs: this.config.objectStoreTimeoutMs,
+    };
+  }
+
+  async seekOffsetByTimestampResult(stream: string, sinceMs: bigint, key: string | null): Promise<Result<string, ReaderError>> {
+    const srow = this.db.getStream(stream);
+    if (!srow || this.db.isDeleted(srow)) return Result.err({ kind: "not_found", message: "not_found" });
+    if (srow.expires_at_ms != null && this.db.nowMs() > srow.expires_at_ms) {
+      return Result.err({ kind: "gone", message: "stream expired" });
+    }
+    try {
+      const sinceNs = sinceMs * 1_000_000n;
+      const keyBytes = key ? utf8Bytes(key) : null;
+
+      // Scan segments in order.
+      const segments = this.db.listSegmentsForStream(stream);
+      for (const seg of segments) {
+        const segBytes = await loadSegmentBytes(this.os, seg, this.diskCache, this.retryOpts());
+        let curOffset = seg.start_offset;
+        for (const blockRes of iterateBlocksResult(segBytes)) {
+          if (Result.isError(blockRes)) return Result.err({ kind: "internal", message: blockRes.error.message });
+          const { decoded } = blockRes.value;
+          if (decoded.lastAppendNs < sinceNs) {
+            curOffset += BigInt(decoded.recordCount);
+            continue;
+          }
+          for (const r of decoded.records) {
+            if (keyBytes && !bytesEqual(r.routingKey, keyBytes)) {
+              curOffset += 1n;
+              continue;
+            }
+            if (r.appendNs >= sinceNs) {
+              const prev = curOffset - 1n;
+              return Result.ok(encodeOffset(srow.epoch, prev));
+            }
+            curOffset += 1n;
+          }
+        }
+      }
+
+      // Scan WAL tail.
+      const start = srow.sealed_through + 1n;
+      const end = srow.next_offset - 1n;
+      if (start <= end) {
+        for (const rec of this.db.iterWalRange(stream, start, end, keyBytes ?? undefined)) {
+          const tsNs = BigInt(rec.ts_ms) * 1_000_000n;
+          if (tsNs >= sinceNs) {
+            const off = BigInt(rec.offset) - 1n;
+            return Result.ok(encodeOffset(srow.epoch, off));
+          }
+        }
+      }
+
+      const endOffsetNum = srow.next_offset - 1n;
+      return Result.ok(encodeOffset(srow.epoch, endOffsetNum));
+    } catch (e: unknown) {
+      return Result.err({ kind: "internal", message: errorMessage(e) });
+    }
+  }
+
+  async seekOffsetByTimestamp(stream: string, sinceMs: bigint, key: string | null): Promise<string> {
+    const res = await this.seekOffsetByTimestampResult(stream, sinceMs, key);
+    if (Result.isError(res)) throw dsError(res.error.message);
+    return res.value;
+  }
+
+  async readResult(args: { stream: string; offset: string; key: string | null; format: ReadFormat }): Promise<Result<ReadBatch, ReaderError>> {
+    const { stream, offset, key, format } = args;
+    const srow = this.db.getStream(stream);
+    if (!srow || this.db.isDeleted(srow)) return Result.err({ kind: "not_found", message: "not_found" });
+    if (srow.expires_at_ms != null && this.db.nowMs() > srow.expires_at_ms) {
+      return Result.err({ kind: "gone", message: "stream expired" });
+    }
+    const epoch = srow.epoch;
+
+    try {
+      const parsed = parseOffsetResult(offset);
+      if (Result.isError(parsed)) {
+        return Result.err({ kind: "invalid_offset", message: parsed.error.message });
+      }
+      const startOffsetExclusive = offsetToSeqOrNeg1(parsed.value);
+      const desiredOffset = startOffsetExclusive + 1n;
+
+      const endOffsetNum = srow.next_offset - 1n;
+      const endOffset = encodeOffset(srow.epoch, endOffsetNum);
+
+      const results: Array<{ offset: bigint; payload: Uint8Array }> = [];
+      let bytesOut = 0;
+
+      // Nothing to read.
+      if (desiredOffset > endOffsetNum) {
+        return Result.ok({
+          stream,
+          format,
+          key,
+          requestOffset: offset,
+          endOffset,
+          nextOffset: encodeOffset(srow.epoch, startOffsetExclusive),
+          endOffsetSeq: endOffsetNum,
+          nextOffsetSeq: startOffsetExclusive,
+          records: [],
+        });
+      }
+
+      let seq = desiredOffset;
+      const keyBytes = key ? utf8Bytes(key) : null;
+      const indexInfo = keyBytes && this.index ? await this.index.candidateSegments(stream, keyBytes) : null;
+      const candidateSegments = indexInfo?.segments ?? null;
+      const indexedThrough = indexInfo?.indexedThrough ?? 0;
+
+      const scanSegmentBytes = async (segBytes: Uint8Array, seg: SegmentRow): Promise<Result<void, ReaderError>> => {
+        let curOffset = seg.start_offset;
+        for (const blockRes of iterateBlocksResult(segBytes)) {
+          if (Result.isError(blockRes)) return Result.err({ kind: "internal", message: blockRes.error.message });
+          const { decoded } = blockRes.value;
+          if (keyBytes) {
+            const bloom = new Bloom256(decoded.bloom);
+            if (!bloom.maybeHas(keyBytes)) {
+              curOffset += BigInt(decoded.recordCount);
+              continue;
+            }
+          }
+          for (const r of decoded.records) {
+            if (curOffset < seq) {
+              curOffset += 1n;
+              continue;
+            }
+            if (curOffset > endOffsetNum) break;
+            if (keyBytes && !bytesEqual(r.routingKey, keyBytes)) {
+              curOffset += 1n;
+              continue;
+            }
+            results.push({ offset: curOffset, payload: r.payload });
+            bytesOut += r.payload.byteLength;
+            curOffset += 1n;
+            if (results.length >= this.config.readMaxRecords || bytesOut >= this.config.readMaxBytes) {
+              seq = curOffset;
+              return Result.ok(undefined);
+            }
+          }
+        }
+        return Result.ok(undefined);
+      };
+
+      // 1) Read from sealed segments.
+      while (seq <= endOffsetNum && seq <= srow.sealed_through) {
+        const seg = this.db.findSegmentForOffset(stream, seq);
+        if (!seg) {
+          // Corruption in local metadata: sealed_through points past segments table.
+          break;
+        }
+        if (keyBytes && candidateSegments && seg.segment_index < indexedThrough && !candidateSegments.has(seg.segment_index)) {
+          seq = seg.end_offset + 1n;
+          continue;
+        }
+        const preferFull = !keyBytes && this.config.readMaxBytes >= seg.size_bytes;
+        if (preferFull) {
+          const segBytes = await loadSegmentBytes(this.os, seg, this.diskCache, this.retryOpts());
+          const scanRes = await scanSegmentBytes(segBytes, seg);
+          if (Result.isError(scanRes)) return scanRes;
+          if (results.length >= this.config.readMaxRecords || bytesOut >= this.config.readMaxBytes) return Result.ok(finalize());
+        } else {
+          const footerInfo = await loadSegmentFooter(this.os, seg, this.diskCache, this.retryOpts(), this.footerCache);
+          if (!footerInfo || !footerInfo.footer) {
+            const segBytes = await loadSegmentBytes(this.os, seg, this.diskCache, this.retryOpts());
+            const scanRes = await scanSegmentBytes(segBytes, seg);
+            if (Result.isError(scanRes)) return scanRes;
+            if (results.length >= this.config.readMaxRecords || bytesOut >= this.config.readMaxBytes) return Result.ok(finalize());
+          } else {
+            const footer = footerInfo.footer;
+            for (const entry of footer.blocks) {
+              const blockStart = entry.firstOffset;
+              const blockEnd = entry.firstOffset + BigInt(entry.recordCount) - 1n;
+              if (blockEnd < seq) continue;
+              if (blockStart > endOffsetNum) break;
+
+              if (keyBytes) {
+                const headerBytes = await readSegmentRange(
+                  this.os,
+                  seg,
+                  entry.blockOffset,
+                  entry.blockOffset + DSB3_HEADER_BYTES - 1,
+                  this.diskCache,
+                  this.retryOpts()
+                );
+                const headerRes = parseBlockHeaderResult(headerBytes);
+                if (Result.isError(headerRes)) return Result.err({ kind: "internal", message: headerRes.error.message });
+                const header = headerRes.value;
+                const bloom = new Bloom256(header.bloom);
+                if (!bloom.maybeHas(keyBytes)) continue;
+              }
+
+              const totalLen = DSB3_HEADER_BYTES + entry.compressedLen;
+              const blockBytes = await readSegmentRange(
+                this.os,
+                seg,
+                entry.blockOffset,
+                entry.blockOffset + totalLen - 1,
+                this.diskCache,
+                this.retryOpts()
+              );
+              const decodedRes = decodeBlockResult(blockBytes);
+              if (Result.isError(decodedRes)) return Result.err({ kind: "internal", message: decodedRes.error.message });
+              const decoded = decodedRes.value;
+              let curOffset = entry.firstOffset;
+              for (const r of decoded.records) {
+                if (curOffset < seq) {
+                  curOffset += 1n;
+                  continue;
+                }
+                if (curOffset > endOffsetNum) break;
+                if (keyBytes && !bytesEqual(r.routingKey, keyBytes)) {
+                  curOffset += 1n;
+                  continue;
+                }
+                results.push({ offset: curOffset, payload: r.payload });
+                bytesOut += r.payload.byteLength;
+                curOffset += 1n;
+                if (results.length >= this.config.readMaxRecords || bytesOut >= this.config.readMaxBytes) {
+                  seq = curOffset;
+                  return Result.ok(finalize());
+                }
+              }
+            }
+          }
+        }
+
+        // Move to next segment.
+        seq = seg.end_offset + 1n;
+      }
+
+      // 2) Read remaining from WAL tail.
+      if (seq <= endOffsetNum) {
+        let hitLimit = false;
+        for (const rec of this.db.iterWalRange(stream, seq, endOffsetNum, keyBytes ?? undefined)) {
+          const s = BigInt(rec.offset);
+          const payload: Uint8Array = rec.payload;
+          results.push({ offset: s, payload });
+          bytesOut += payload.byteLength;
+          if (results.length >= this.config.readMaxRecords || bytesOut >= this.config.readMaxBytes) {
+            hitLimit = true;
+            // We only emitted payloads up through this offset (key-filtered reads
+            // may skip offsets in SQL). Resume from the next offset.
+            seq = s + 1n;
+            break;
+          }
+        }
+        if (!hitLimit) {
+          // We exhausted the iterator for this [seq, endOffsetNum] range. Even if
+          // it yielded zero records (common for key-filtered reads), we have
+          // scanned through endOffsetNum and should advance the stream cursor to
+          // avoid tight catchup loops.
+          seq = endOffsetNum + 1n;
+        }
+      }
+
+      return Result.ok(finalize());
+
+      function finalize(): ReadBatch {
+        // nextOffset is a stream cursor, not a "last matching record" cursor. For
+        // key-filtered reads, this must still advance past non-matching offsets,
+        // otherwise SSE/long-poll can spin forever when the stream advances but no
+        // matching keys appear.
+        const scannedThrough = seq - 1n;
+        const nextOffset = encodeOffset(epoch, scannedThrough);
+        return {
+          stream,
+          format,
+          key,
+          requestOffset: offset,
+          endOffset,
+          nextOffset,
+          endOffsetSeq: endOffsetNum,
+          nextOffsetSeq: scannedThrough,
+          records: results,
+        };
+      }
+    } catch (e: unknown) {
+      return Result.err({ kind: "internal", message: errorMessage(e) });
+    }
+  }
+
+  async read(args: { stream: string; offset: string; key: string | null; format: ReadFormat }): Promise<ReadBatch> {
+    const res = await this.readResult(args);
+    if (Result.isError(res)) throw dsError(res.error.message);
+    return res.value;
+  }
+}
+
+function bytesEqual(a: Uint8Array, b: Uint8Array): boolean {
+  if (a.byteLength !== b.byteLength) return false;
+  for (let i = 0; i < a.byteLength; i++) if (a[i] !== b[i]) return false;
+  return true;
+}

package/src/runtime/hash.ts

@@ -0,0 +1,156 @@
+import { Result } from "better-result";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { dsError } from "../util/ds_error.ts";
+type HashInput = string | Uint8Array;
+
+export type HashError = { kind: "hasher_not_initialized"; message: string };
+
+type Hash32Hasher = {
+  init(seed?: number): void;
+  update(input: HashInput): void;
+  digest(outputType?: "hex"): string | number | bigint;
+};
+
+type Hash64Hasher = {
+  init(seed?: number | bigint): void;
+  update(input: HashInput): void;
+  digest(outputType?: "hex"): string | number | bigint;
+};
+
+type XXH3Module = {
+  createXXHash3(seedLow?: number, seedHigh?: number): Promise<Hash64Hasher>;
+};
+
+type XXH64Module = {
+  createXXHash64(seed?: number | bigint): Promise<Hash64Hasher>;
+};
+
+type XXH32Module = {
+  createXXHash32(seed?: number): Promise<Hash32Hasher>;
+};
+
+let xxh3Hasher: Hash64Hasher | null = null;
+let xxh64Hasher: Hash64Hasher | null = null;
+let xxh32Hasher: Hash32Hasher | null = null;
+
+const isBunRuntime = typeof (globalThis as any).Bun !== "undefined";
+const require = createRequire(import.meta.url);
+
+function loadVendoredModule<T>(name: string): T {
+  const path = fileURLToPath(new URL(`./hash_vendor/${name}`, import.meta.url));
+  return require(path) as T;
+}
+
+if (!isBunRuntime) {
+  const xxh3Module = loadVendoredModule<XXH3Module>("xxhash3.umd.min.cjs");
+  const xxh64Module = loadVendoredModule<XXH64Module>("xxhash64.umd.min.cjs");
+  const xxh32Module = loadVendoredModule<XXH32Module>("xxhash32.umd.min.cjs");
+  xxh3Hasher = (await xxh3Module.createXXHash3()) as Hash64Hasher;
+  xxh64Hasher = (await xxh64Module.createXXHash64()) as Hash64Hasher;
+  xxh32Hasher = (await xxh32Module.createXXHash32()) as Hash32Hasher;
+}
+
+function toBigIntDigest(value: string | number | bigint): bigint {
+  if (typeof value === "bigint") return value;
+  if (typeof value === "number") return BigInt(value >>> 0);
+  const hex = value.startsWith("0x") ? value.slice(2) : value;
+  if (hex.length === 0) return 0n;
+  return BigInt(`0x${hex}`);
+}
+
+function toHex16(value: bigint): string {
+  const masked = value & 0xffff_ffff_ffff_ffffn;
+  return masked.toString(16).padStart(16, "0");
+}
+
+function bunHash64(input: HashInput, fn: (x: HashInput) => bigint): bigint {
+  return fn(input);
+}
+
+function nodeHash64Result(input: HashInput, hasher: Hash64Hasher | null, label: string): Result<bigint, HashError> {
+  if (!hasher) return Result.err({ kind: "hasher_not_initialized", message: `${label} hasher not initialized` });
+  hasher.init();
+  hasher.update(input);
+  const digest = hasher.digest("hex");
+  return Result.ok(toBigIntDigest(digest));
+}
+
+function nodeHash32Result(input: HashInput): Result<number, HashError> {
+  if (!xxh32Hasher) return Result.err({ kind: "hasher_not_initialized", message: "xxh32 hasher not initialized" });
+  xxh32Hasher.init();
+  xxh32Hasher.update(input);
+  const digest = xxh32Hasher.digest("hex");
+  if (typeof digest === "number") return Result.ok(digest >>> 0);
+  const asBigInt = toBigIntDigest(digest);
+  return Result.ok(Number(asBigInt & 0xffff_ffffn) >>> 0);
+}
+
+export function xxh3BigIntResult(input: HashInput): Result<bigint, HashError> {
+  if (isBunRuntime) return Result.ok(bunHash64(input, (x) => Bun.hash.xxHash3(x)));
+  return nodeHash64Result(input, xxh3Hasher, "xxh3");
+}
+
+export function xxh64BigIntResult(input: HashInput): Result<bigint, HashError> {
+  if (isBunRuntime) return Result.ok(bunHash64(input, (x) => Bun.hash.xxHash64(x)));
+  return nodeHash64Result(input, xxh64Hasher, "xxh64");
+}
+
+export function wyhashBigIntResult(input: HashInput): Result<bigint, HashError> {
+  if (isBunRuntime) return Result.ok(bunHash64(input, (x) => Bun.hash.wyhash(x)));
+  // Node fallback: use xxh3 for deterministic cross-runtime behavior.
+  return xxh3BigIntResult(input);
+}
+
+export function xxh3HexResult(input: HashInput): Result<string, HashError> {
+  const res = xxh3BigIntResult(input);
+  if (Result.isError(res)) return res;
+  return Result.ok(toHex16(res.value));
+}
+
+export function xxh64HexResult(input: HashInput): Result<string, HashError> {
+  const res = xxh64BigIntResult(input);
+  if (Result.isError(res)) return res;
+  return Result.ok(toHex16(res.value));
+}
+
+export function xxh32Result(input: HashInput): Result<number, HashError> {
+  if (isBunRuntime) return Result.ok((Bun.hash.xxHash32(input) as number) >>> 0);
+  return nodeHash32Result(input);
+}
+
+export function xxh3BigInt(input: HashInput): bigint {
+  const res = xxh3BigIntResult(input);
+  if (Result.isError(res)) throw dsError(res.error.message);
+  return res.value;
+}
+
+export function xxh64BigInt(input: HashInput): bigint {
+  const res = xxh64BigIntResult(input);
+  if (Result.isError(res)) throw dsError(res.error.message);
+  return res.value;
+}
+
+export function wyhashBigInt(input: HashInput): bigint {
+  const res = wyhashBigIntResult(input);
+  if (Result.isError(res)) throw dsError(res.error.message);
+  return res.value;
+}
+
+export function xxh3Hex(input: HashInput): string {
+  const res = xxh3HexResult(input);
+  if (Result.isError(res)) throw dsError(res.error.message);
+  return res.value;
+}
+
+export function xxh64Hex(input: HashInput): string {
+  const res = xxh64HexResult(input);
+  if (Result.isError(res)) throw dsError(res.error.message);
+  return res.value;
+}
+
+export function xxh32(input: HashInput): number {
+  const res = xxh32Result(input);
+  if (Result.isError(res)) throw dsError(res.error.message);
+  return res.value;
+}

package/src/runtime/hash_vendor/LICENSE.hash-wasm

@@ -0,0 +1,38 @@
+MIT License
+
+Copyright (c) 2020 Dani Biró
+
+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.
+
+Embedded C implementations might use other, similarly permissive licenses.
+Check the beginning of the files from the /src directory.
+
+Special thank you to the authors of original C algorithms:
+- Alexander Peslyak <solar@openwall.com>
+- Aleksey Kravchenko <rhash.admin@gmail.com>
+- Colin Percival
+- Stephan Brumme <create@stephan-brumme.com>
+- Steve Reid <steve@edmweb.com>
+- Samuel Neves <sneves@dei.uc.pt>
+- Solar Designer <solar@openwall.com>
+- Project Nayuki
+- ARM Limited
+- Yanbo Li dreamfly281@gmail.com, goldboar@163.comYanbo Li
+- Mark Adler
+- Yann Collet

package/src/runtime/hash_vendor/NOTICE.md

@@ -0,0 +1,8 @@
+Vendored xxhash runtime files in this directory are copied from `hash-wasm@4.12.0`:
+
+- `dist/xxhash3.umd.min.js`
+- `dist/xxhash32.umd.min.js`
+- `dist/xxhash64.umd.min.js`
+
+These files are used only for the Node runtime path in local development builds.
+The upstream license is preserved in `LICENSE.hash-wasm` in this directory.