castrum 0.9.0 → 0.9.2

package/src/shared/runtime.ts

@@ -1,34 +1,29 @@
-// src/shared/runtime.ts — runtime detection helpers.
+// src/shared/runtime.ts — runtime detection helpers (facade).
 //
-// castrum is Bun-first but must also run under Node.js. This module is the
-// single place that detects the host runtime, so the rest of the codebase can
-// branch on `isBun()` / `isNode()` without sprinkling `typeof Bun` checks
-// everywhere. Importing this module has zero side effects.
+// Facade over the cached detection in `src/runtime/detect.ts` (the ONLY place
+// `typeof Bun` is checked — resolved ONCE at module load by the runtime
+// adapter). Kept so existing `isBun()` / `isNode()` / `runtimeName()` /
+// `nodeMajorVersion()` call sites work unchanged.
 
-export type RuntimeName = 'bun' | 'node' | 'unknown'
+import {
+  detectedRuntime,
+  isBunRuntime,
+  isNodeRuntime,
+  nodeMajorVersion as nodeMajorVersionDetected,
+} from '../runtime/detect'
+import type { RuntimeName as RuntimeNameType } from '../runtime/types'
 
-/** Whether the current runtime is Bun (the primary target). */
-export function isBun(): boolean {
-  // Bun defines the global `Bun` object; Node does not.
-  return typeof (globalThis as { Bun?: unknown }).Bun !== 'undefined'
-}
+/** Host runtime identifier. */
+export type RuntimeName = RuntimeNameType
+
+/** Whether the current runtime is Bun (the primary target). Cached once at load. */
+export const isBun: () => boolean = isBunRuntime
 
 /** Whether the current runtime is Node.js. */
-export function isNode(): boolean {
-  return !isBun() && typeof process !== 'undefined' && process.versions?.node != null
-}
+export const isNode: () => boolean = isNodeRuntime
 
 /** Best-effort name of the current runtime. */
-export function runtimeName(): RuntimeName {
-  if (isBun()) return 'bun'
-  if (isNode()) return 'node'
-  return 'unknown'
-}
+export const runtimeName: () => RuntimeName = () => detectedRuntime
 
 /** The Node.js major version when running under Node, otherwise `null`. */
-export function nodeMajorVersion(): number | null {
-  if (!isNode()) return null
-  const v = process.versions.node
-  const major = Number(v?.split('.')[0])
-  return Number.isFinite(major) ? major : null
-}
+export const nodeMajorVersion: () => number | null = nodeMajorVersionDetected

package/src/shared/uuid.ts

@@ -1,31 +1,15 @@
-// src/shared/uuid.ts — UUIDv7 generation.
+// src/shared/uuid.ts — UUIDv7 generation (facade).
 //
-// Deliberately does NOT implement UUIDv7 in Rust: the decision matrix
-// (docs/bun-builtins-decision-matrix.md) measured Bun.randomUUIDv7 ~2x faster
-// than the FFI-crossing rust random-token path, so this delegates to the Bun
-// built-in and falls back to crypto.randomUUID (RFC 4122 v4) under Node.
+// UUIDv7 delegates to the runtime adapter's uuid (`src/runtime/uuid.ts`):
+// `Bun.randomUUIDv7` on Bun (measured ~2x faster than the FFI-crossing rust
+// path) and `crypto.randomUUID` (RFC 4122 v4) under Node.
 
-/** Generate a UUIDv7 (time-ordered) string, preferring Bun's native built-in. */
-export function uuidv7(): string {
-  const bun = (globalThis as { Bun?: { randomUUIDv7?: () => string } }).Bun
-  if (typeof bun?.randomUUIDv7 === 'function') {
-    return bun.randomUUIDv7()
-  }
-  // Node / non-Bun fallback: crypto.randomUUID (v4 — order not guaranteed).
-  return globalThis.crypto?.randomUUID?.() ?? fallbackRandomUuid()
-}
+import { runtimeUuid } from '../runtime/uuid'
 
-/** Last-resort synchronous UUIDv4 (only if crypto.randomUUID is unavailable). */
-function fallbackRandomUuid(): string {
-  const bytes = new Uint8Array(16)
-  const c = globalThis.crypto
-  if (c?.getRandomValues) {
-    c.getRandomValues(bytes)
-  } else {
-    for (let i = 0; i < 16; i++) bytes[i] = Math.floor(Math.random() * 256)
-  }
-  bytes[6] = ((bytes[6] ?? 0) & 0x0f) | 0x40 // version 4
-  bytes[8] = ((bytes[8] ?? 0) & 0x3f) | 0x80 // variant 10xx
-  const hex = [...bytes].map((b) => b.toString(16).padStart(2, '0')).join('')
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`
-}
+/**
+ * Generate a UUIDv7 (time-ordered) string, preferring Bun's native built-in.
+ * Under Node this falls back to `crypto.randomUUID` (v4).
+ *
+ * @returns A UUID string.
+ */
+export const uuidv7: () => string = runtimeUuid.uuidv7

package/src/data/json-rows.ts

@@ -1,33 +0,0 @@
-import { encoder } from '../shared/bytes'
-
-export interface JsonRowNested {
-  version: number
-  createdAt: string
-}
-
-export interface JsonRow {
-  id: number
-  name: string
-  active: boolean
-  score: number
-  tags: string[]
-  nested: JsonRowNested
-}
-
-export function createJsonRows(rows: number): JsonRow[] {
-  return Array.from({ length: rows }, (_, i) => ({
-    id: i,
-    name: `user_${i}`,
-    active: i % 2 === 0,
-    score: i * 1.25,
-    tags: ['alpha', 'beta', 'gamma'],
-    nested: {
-      version: i % 10,
-      createdAt: '2026-01-01T00:00:00Z',
-    },
-  }))
-}
-
-export function jsonRowsBytes(rows: number): Uint8Array {
-  return encoder.encode(JSON.stringify(createJsonRows(rows)))
-}

package/src/rust-ffi/batch.ts

@@ -1,431 +0,0 @@
-// src/rust-ffi/batch.ts — Array-of-bytes FFI namespace.
-//
-// `rust.batch.*` packs an array of byte slices into the packed wire format,
-// calls the native batch function, and unpacks the result into the friendly
-// JS shape (bitsets, u32 arrays, i64 arrays, byte results).
-
-import {
-  schemaValidateBatch,
-  schemaValidateBatchCount,
-  unpackBitset,
-  unpackByteResults,
-  unpackI64ArrayAsBigInt,
-  unpackMultipartParts,
-  unpackU32Array,
-  unpackU64ArrayAsBigInt,
-  withPackScratch,
-  withPackScratch2,
-  type SchemaValidator,
-} from '../shared/packed'
-import { resolvePoolNative, type RustClientContext } from './context'
-import type { MultipartPart, PasswordHashOptions } from '../native'
-
-/** Array-of-bytes FFI namespace. */
-export interface RustBatch {
-  jsonValid(items: Uint8Array[]): Uint8Array
-  crc32(items: Uint8Array[]): Uint32Array
-  validateEmail(items: Uint8Array[]): Uint8Array
-  validateUuid(items: Uint8Array[]): Uint8Array
-  validateIpv4(items: Uint8Array[]): Uint8Array
-  validateIpv6(items: Uint8Array[]): Uint8Array
-  jsonSumIds(items: Uint8Array[]): BigInt64Array
-  queryParse(items: Uint8Array[]): Uint8Array[]
-  cookieParse(items: Uint8Array[]): Uint8Array[]
-  httpParseRequest(items: Uint8Array[]): Uint8Array[]
-  /** Apply N RFC 6902 patches (docs and patches zipped). Fail-fast on error. */
-  jsonPatch(docs: Uint8Array[], patches: Uint8Array[]): Uint8Array[]
-  /** Encode N items to lowercase hex (packed in → byte results). */
-  hexEncode(items: Uint8Array[]): Uint8Array[]
-  /** Decode N lowercase/uppercase hex strings to bytes. */
-  hexDecode(items: Uint8Array[]): Uint8Array[]
-  /** Base64-encode N items (standard by default; url-safe/padding configurable). */
-  base64Encode(items: Uint8Array[], urlSafe?: boolean, padding?: boolean): Uint8Array[]
-  /** Base64-decode N items (standard by default; url-safe/padding configurable). */
-  base64Decode(items: Uint8Array[], urlSafe?: boolean, padding?: boolean): Uint8Array[]
-  formParse(items: Uint8Array[]): Uint8Array[]
-  /** Sign N cookie values (packed → byte results). */
-  signCookie(items: Uint8Array[], secret: Uint8Array): Uint8Array[]
-  /** Verify N signed cookies (bitset of valid). */
-  verifyCookie(items: Uint8Array[], secret: Uint8Array): Uint8Array
-  /** Verify N CSRF tokens (bitset of valid). */
-  csrfVerify(items: Uint8Array[], secret: Uint8Array): Uint8Array
-  schemaValidate(validator: SchemaValidator, items: Uint8Array[]): Uint8Array
-  schemaValidateCount(validator: SchemaValidator, items: Uint8Array[]): number
-  /** Hash N items with FNV-1a 64 (packed → unsigned u64 array). */
-  fnv1a64(items: Uint8Array[]): BigUint64Array
-  /** Generate N ETags (strong by default; weak flag applies to all items). */
-  etag(items: Uint8Array[], weak?: boolean | null): Uint8Array[]
-  urlEncode(items: Uint8Array[]): Uint8Array[]
-  /** Percent-decode N strings (UTF-8 validated; malformed items → empty). */
-  urlDecode(items: Uint8Array[]): Uint8Array[]
-  /** Strict percent-decode N strings (no UTF-8 validation). */
-  urlDecodeBytes(items: Uint8Array[]): Uint8Array[]
-  mimeFromExtension(items: Uint8Array[]): Uint8Array[]
-  wsAcceptKey(items: Uint8Array[]): Uint8Array[]
-  /** Base64url-encode N items (URL-safe, no padding). */
-  base64UrlEncode(items: Uint8Array[]): Uint8Array[]
-  /** Base64url-decode N items (URL-safe, no padding). */
-  base64UrlDecode(items: Uint8Array[]): Uint8Array[]
-
-  // ── Backend-framework features ──
-  passwordHash(
-    passwords: Uint8Array[],
-    salt: Uint8Array,
-    options?: PasswordHashOptions | null,
-  ): Uint8Array[]
-  aeadEncrypt(
-    key: Uint8Array,
-    nonce: Uint8Array,
-    items: Uint8Array[],
-    algorithm?: string | null,
-  ): Uint8Array[]
-  aeadDecrypt(
-    key: Uint8Array,
-    nonce: Uint8Array,
-    items: Uint8Array[],
-    algorithm?: string | null,
-  ): Uint8Array[]
-  gzipCompress(items: Uint8Array[], level?: number | null): Uint8Array[]
-  gzipDecompress(items: Uint8Array[], maxDecompressed?: number | null): Uint8Array[]
-  brotliCompress(items: Uint8Array[], quality?: number | null): Uint8Array[]
-  brotliDecompress(items: Uint8Array[], maxDecompressed?: number | null): Uint8Array[]
-  jwtVerify(tokens: Uint8Array[], secret: Uint8Array, nowSeconds: number): Uint8Array
-  /** Sign N messages to lowercase-hex HMAC-SHA256 signatures (packed → byte results). */
-  hmacSha256(items: Uint8Array[], key: Uint8Array): Uint8Array[]
-  /** Verify N message + hex-signature pairs (two packed lists, zipped) → bitset of valid. */
-  hmacSha256Verify(items: Uint8Array[], sigs: Uint8Array[], key: Uint8Array): Uint8Array
-  /** Verify N password+PHC pairs (two packed lists, zipped) → bitset of valid. */
-  passwordVerify(items: Uint8Array[], phcs: Uint8Array[]): Uint8Array
-  /** Resolve N references against N bases (two packed lists, zipped). */
-  urlResolve(bases: Uint8Array[], references: Uint8Array[]): Uint8Array[]
-  /** Sign N JSON claim documents (packed → signed tokens). */
-  jwtSign(
-    items: Uint8Array[],
-    secret: Uint8Array,
-    ttlSeconds?: number | null,
-    nowSeconds?: number,
-  ): Uint8Array[]
-  /** Encode N SSE events with shared event/id/retry. */
-  sseEncode(
-    items: Uint8Array[],
-    event?: string | null,
-    id?: string | null,
-    retry?: number | null,
-  ): Uint8Array[]
-  /** Encode N frames (same opcode/mask/fin) from payloads. */
-  wsFrameEncode(items: Uint8Array[], opcode: number, mask: boolean, fin: boolean): Uint8Array[]
-  /** Decode N frames → payloads (opcodes/flags dropped; failed items → empty). */
-  wsFrameDecode(items: Uint8Array[]): Uint8Array[]
-  /** Parse N multipart bodies → array of parts per item (same boundary). */
-  multipartParse(items: Uint8Array[], boundary: Uint8Array): MultipartPart[][]
-  /**
-   * @performance Template render: ~1.7x slower than the JS baseline (1/3 tasks failed) [check:annotate]
-   * @deprecated Slower than the native JS baseline (~1.7x) — prefer the JS/Bun baseline. [check:annotate]
-   * @remarks Promotion candidate: 2/3 benchmarks won in the latest run (static: not-competitive). [check:annotate]
-   * @remarks The allocating render marshals the context via napi DOM (~1.5x loss). Use TemplateRenderer.renderBytes (JSON-bytes context) which avoids it and wins ~1.37x. [check:annotate]
-   */
-  templateRender(source: string, contexts: Uint8Array[]): Uint8Array[]
-}
-
-// Native batch fns are process-wide singletons (one lazy addon). `resolvePoolNative`
-// resolves each once (triggering pool init + addon load on first use) and caches
-// it, so the hot path skips the lazy-addon Proxy get on every call — the same
-// cache `resolveNative`/packed use (context.ts), with pool init for the
-// rayon-backed batch surface.
-function nativeFn(ctx: RustClientContext, name: string): (...args: unknown[]) => unknown {
-  return resolvePoolNative(ctx, name)
-}
-
-/** Build the `batch` namespace for a client context. */
-export function buildBatch(ctx: RustClientContext): RustBatch {
-  return {
-    jsonValid(items) {
-      return withPackScratch(items, (packed) =>
-        unpackBitset(nativeFn(ctx, 'jsonValidBatchPacked')(packed) as Buffer),
-      )
-    },
-    crc32(items) {
-      return withPackScratch(items, (packed) =>
-        unpackU32Array(nativeFn(ctx, 'crc32BatchPacked')(packed) as Buffer),
-      )
-    },
-    validateEmail(items) {
-      return withPackScratch(items, (packed) =>
-        unpackBitset(nativeFn(ctx, 'validateEmailBatchPacked')(packed) as Buffer),
-      )
-    },
-    validateUuid(items) {
-      return withPackScratch(items, (packed) =>
-        unpackBitset(nativeFn(ctx, 'validateUuidBatchPacked')(packed) as Buffer),
-      )
-    },
-    validateIpv4(items) {
-      return withPackScratch(items, (packed) =>
-        unpackBitset(nativeFn(ctx, 'validateIpv4BatchPacked')(packed) as Buffer),
-      )
-    },
-    validateIpv6(items) {
-      return withPackScratch(items, (packed) =>
-        unpackBitset(nativeFn(ctx, 'validateIpv6BatchPacked')(packed) as Buffer),
-      )
-    },
-    jsonSumIds(items) {
-      return withPackScratch(items, (packed) =>
-        unpackI64ArrayAsBigInt(nativeFn(ctx, 'jsonSumBatchPacked')(packed) as Buffer),
-      )
-    },
-    queryParse(items) {
-      return withPackScratch(items, (packed) =>
-        unpackByteResults(nativeFn(ctx, 'queryParseBatchPacked')(packed) as Buffer),
-      )
-    },
-    cookieParse(items) {
-      return withPackScratch(items, (packed) =>
-        unpackByteResults(nativeFn(ctx, 'cookieParseBatchPacked')(packed) as Buffer),
-      )
-    },
-    formParse(items) {
-      return withPackScratch(items, (packed) =>
-        unpackByteResults(nativeFn(ctx, 'formParseBatchPacked')(packed) as Buffer),
-      )
-    },
-    signCookie(items, secret) {
-      return withPackScratch(items, (packed) =>
-        unpackByteResults(nativeFn(ctx, 'signCookieBatchPacked')(packed, secret) as Buffer),
-      )
-    },
-    verifyCookie(items, secret) {
-      return withPackScratch(items, (packed) =>
-        unpackBitset(nativeFn(ctx, 'verifyCookieBatchPacked')(packed, secret) as Buffer),
-      )
-    },
-    csrfVerify(items, secret) {
-      return withPackScratch(items, (packed) =>
-        unpackBitset(nativeFn(ctx, 'csrfVerifyBatchPacked')(packed, secret) as Buffer),
-      )
-    },
-    httpParseRequest(items) {
-      return withPackScratch(items, (packed) =>
-        unpackByteResults(nativeFn(ctx, 'httpParseRequestBatchPacked')(packed) as Buffer),
-      )
-    },
-    fnv1a64(items) {
-      return withPackScratch(items, (packed) =>
-        unpackU64ArrayAsBigInt(nativeFn(ctx, 'fnv1A64BatchPacked')(packed) as Buffer),
-      )
-    },
-    etag(items, weak) {
-      return withPackScratch(items, (packed) =>
-        unpackByteResults(nativeFn(ctx, 'etagBatchPacked')(packed, weak ?? null) as Buffer),
-      )
-    },
-    urlEncode(items) {
-      return withPackScratch(items, (packed) =>
-        unpackByteResults(nativeFn(ctx, 'urlEncodeBatchPacked')(packed) as Buffer),
-      )
-    },
-    urlDecode(items) {
-      return withPackScratch(items, (packed) =>
-        unpackByteResults(nativeFn(ctx, 'urlDecodeBatchPacked')(packed) as Buffer),
-      )
-    },
-    urlDecodeBytes(items) {
-      return withPackScratch(items, (packed) =>
-        unpackByteResults(nativeFn(ctx, 'urlDecodeBytesBatchPacked')(packed) as Buffer),
-      )
-    },
-    mimeFromExtension(items) {
-      return withPackScratch(items, (packed) =>
-        unpackByteResults(nativeFn(ctx, 'mimeFromExtensionBatchPacked')(packed) as Buffer),
-      )
-    },
-    wsAcceptKey(items) {
-      return withPackScratch(items, (packed) =>
-        unpackByteResults(nativeFn(ctx, 'wsAcceptKeyBatchPacked')(packed) as Buffer),
-      )
-    },
-    base64UrlEncode(items) {
-      return withPackScratch(items, (packed) =>
-        unpackByteResults(nativeFn(ctx, 'base64EncodeBatchPacked')(packed, true, false) as Buffer),
-      )
-    },
-    base64UrlDecode(items) {
-      return withPackScratch(items, (packed) =>
-        unpackByteResults(nativeFn(ctx, 'base64DecodeBatchPacked')(packed, true, false) as Buffer),
-      )
-    },
-    jsonPatch(docs, patches) {
-      return withPackScratch2(docs, patches, (packedDocs, packedPatches) =>
-        unpackByteResults(
-          nativeFn(ctx, 'jsonPatchBatchPacked')(packedDocs, packedPatches) as Buffer,
-        ),
-      )
-    },
-    hexEncode(items) {
-      return withPackScratch(items, (packed) =>
-        unpackByteResults(nativeFn(ctx, 'hexEncodeBatchPacked')(packed) as Buffer),
-      )
-    },
-    hexDecode(items) {
-      return withPackScratch(items, (packed) =>
-        unpackByteResults(nativeFn(ctx, 'hexDecodeBatchPacked')(packed) as Buffer),
-      )
-    },
-    base64Encode(items, urlSafe, padding) {
-      return withPackScratch(items, (packed) =>
-        unpackByteResults(
-          nativeFn(ctx, 'base64EncodeBatchPacked')(
-            packed,
-            urlSafe ?? null,
-            padding ?? null,
-          ) as Buffer,
-        ),
-      )
-    },
-    base64Decode(items, urlSafe, padding) {
-      return withPackScratch(items, (packed) =>
-        unpackByteResults(
-          nativeFn(ctx, 'base64DecodeBatchPacked')(
-            packed,
-            urlSafe ?? null,
-            padding ?? null,
-          ) as Buffer,
-        ),
-      )
-    },
-    schemaValidate(validator, items) {
-      return schemaValidateBatch(validator, items)
-    },
-    schemaValidateCount(validator, items) {
-      return schemaValidateBatchCount(validator, items)
-    },
-
-    // ── Backend-framework features ──
-    passwordHash(password, salt, options) {
-      return withPackScratch(password, (packed) =>
-        unpackByteResults(
-          nativeFn(ctx, 'passwordHashBatchPacked')(packed, salt, options ?? null) as Buffer,
-        ),
-      )
-    },
-    aeadEncrypt(key, nonce, items, algorithm) {
-      return withPackScratch(items, (packed) =>
-        unpackByteResults(
-          nativeFn(ctx, 'aeadEncryptBatchPacked')(packed, key, nonce, algorithm ?? null) as Buffer,
-        ),
-      )
-    },
-    aeadDecrypt(key, nonce, items, algorithm) {
-      return withPackScratch(items, (packed) =>
-        unpackByteResults(
-          nativeFn(ctx, 'aeadDecryptBatchPacked')(packed, key, nonce, algorithm ?? null) as Buffer,
-        ),
-      )
-    },
-    gzipCompress(items, level) {
-      return withPackScratch(items, (packed) =>
-        unpackByteResults(
-          nativeFn(ctx, 'gzipCompressBatchPacked')(packed, level ?? null) as Buffer,
-        ),
-      )
-    },
-    gzipDecompress(items, maxDecompressed) {
-      return withPackScratch(items, (packed) =>
-        unpackByteResults(
-          nativeFn(ctx, 'gzipDecompressBatchPacked')(packed, maxDecompressed ?? null) as Buffer,
-        ),
-      )
-    },
-    brotliCompress(items, quality) {
-      return withPackScratch(items, (packed) =>
-        unpackByteResults(
-          nativeFn(ctx, 'brotliCompressBatchPacked')(packed, quality ?? null) as Buffer,
-        ),
-      )
-    },
-    brotliDecompress(items, maxDecompressed) {
-      return withPackScratch(items, (packed) =>
-        unpackByteResults(
-          nativeFn(ctx, 'brotliDecompressBatchPacked')(packed, maxDecompressed ?? null) as Buffer,
-        ),
-      )
-    },
-    jwtVerify(tokens, secret, nowSeconds) {
-      return withPackScratch(tokens, (packed) =>
-        unpackBitset(nativeFn(ctx, 'jwtVerifyBatchPacked')(packed, secret, nowSeconds) as Buffer),
-      )
-    },
-    hmacSha256(items, key) {
-      return withPackScratch(items, (packed) =>
-        unpackByteResults(nativeFn(ctx, 'hmacSha256BatchPacked')(packed, key) as Buffer),
-      )
-    },
-    hmacSha256Verify(items, sigs, key) {
-      return withPackScratch2(items, sigs, (packedItems, packedSigs) =>
-        unpackBitset(
-          nativeFn(ctx, 'hmacSha256VerifyBatchPacked')(packedItems, packedSigs, key) as Buffer,
-        ),
-      )
-    },
-    templateRender(source, contexts) {
-      return withPackScratch(contexts, (packed) =>
-        unpackByteResults(nativeFn(ctx, 'templateRenderBatchPacked')(packed, source) as Buffer),
-      )
-    },
-    passwordVerify(items, phcs) {
-      return withPackScratch2(items, phcs, (packedItems, packedPhcs) =>
-        unpackBitset(nativeFn(ctx, 'passwordVerifyBatchPacked')(packedItems, packedPhcs) as Buffer),
-      )
-    },
-    urlResolve(bases, references) {
-      return withPackScratch2(bases, references, (packedBases, packedRefs) =>
-        unpackByteResults(
-          nativeFn(ctx, 'urlResolveBatchPacked')(packedBases, packedRefs) as Buffer,
-        ),
-      )
-    },
-    jwtSign(items, secret, ttlSeconds, nowSeconds) {
-      return withPackScratch(items, (packed) =>
-        unpackByteResults(
-          nativeFn(ctx, 'jwtSignBatchPacked')(
-            packed,
-            secret,
-            ttlSeconds ?? null,
-            nowSeconds ?? Math.floor(Date.now() / 1000),
-          ) as Buffer,
-        ),
-      )
-    },
-    sseEncode(items, event, id, retry) {
-      return withPackScratch(items, (packed) =>
-        unpackByteResults(
-          nativeFn(ctx, 'sseEncodeBatchPacked')(
-            packed,
-            event ?? null,
-            id ?? null,
-            retry ?? null,
-          ) as Buffer,
-        ),
-      )
-    },
-    wsFrameEncode(items, opcode, mask, fin) {
-      return withPackScratch(items, (packed) =>
-        unpackByteResults(
-          nativeFn(ctx, 'wsFrameEncodeBatchPacked')(packed, opcode, mask, fin) as Buffer,
-        ),
-      )
-    },
-    wsFrameDecode(items) {
-      return withPackScratch(items, (packed) =>
-        unpackByteResults(nativeFn(ctx, 'wsFrameDecodeBatchPacked')(packed) as Buffer),
-      )
-    },
-    multipartParse(items, boundary) {
-      return withPackScratch(items, (packed) =>
-        unpackMultipartParts(
-          nativeFn(ctx, 'multipartParseBatchPacked')(packed, boundary) as Buffer,
-        ),
-      )
-    },
-  }
-}