castrum 0.9.7 → 0.9.9

package/dist/index.js

@@ -36,6 +36,13 @@ function detectRuntimeName() {
 function isBunRuntime() {
   return detectedRuntime === "bun";
 }
+function forceGc() {
+  if (detectedRuntime === "bun") {
+    Bun.gc(true);
+    return;
+  }
+  globalThis.gc?.();
+}
 var detectedRuntime;
 var init_detect = __esm(() => {
   detectedRuntime = detectRuntimeName();
@@ -87,7 +94,8 @@ function createBunCodec() {
     },
     decodeUtf8: decodeUtf8Bun,
     decodeUtf8Fatal: decodeUtf8Bun,
-    decodeUtf8Range: decodeUtf8RangeBun
+    decodeUtf8Range: decodeUtf8RangeBun,
+    decodeUtf8RangeView: decodeUtf8RangeViewBun
   };
 }
 function bunEncodeUtf8Into(s, dest, offset = 0) {
@@ -122,6 +130,14 @@ function decodeUtf8RangeBun(bytes, start, end) {
   }
   return view.toString("latin1", base + start, base + end);
 }
+function decodeUtf8RangeViewBun(view, start, end) {
+  for (let i = start;i < end; i++) {
+    if ((view[i] ?? 0) >= 128) {
+      return view.toString("utf8", start, end);
+    }
+  }
+  return view.toString("latin1", start, end);
+}
 function createNodeCodec() {
   return {
     encodeUtf8(s) {
@@ -144,6 +160,14 @@ function createNodeCodec() {
         }
       }
       return view.toString("latin1", start, end);
+    },
+    decodeUtf8RangeView(view, start, end) {
+      for (let i = start;i < end; i++) {
+        if ((view[i] ?? 0) >= 128) {
+          return view.toString("utf8", start, end);
+        }
+      }
+      return view.toString("latin1", start, end);
     }
   };
 }
@@ -264,37 +288,382 @@ var init_builtins = __esm(() => {
   runtimeBuiltins = createBuiltins(detectedRuntime);
 });
 
+// src/native/ffi/symbols.ts
+function buildFFISymbolMap(useBufferLength) {
+  const inputAbi = useBufferLength ? ["buffer", "buffer_length"] : ["ptr", "usize"];
+  const abi = (shape) => {
+    if (!useBufferLength)
+      return shape;
+    const out = [];
+    for (let i = 0;i < shape.length; i++) {
+      const t = shape[i];
+      if (t === "ptr") {
+        out.push("buffer");
+        out.push("buffer_length");
+        i++;
+      } else {
+        out.push(t);
+      }
+    }
+    return out;
+  };
+  const U64_FAST = "u64_fast";
+  return {
+    castrum_crc32: { args: inputAbi, returns: "u32" },
+    castrum_fnv1a64: { args: inputAbi, returns: "u64" },
+    castrum_xxh3: { args: inputAbi, returns: "u64" },
+    castrum_json_valid: { args: inputAbi, returns: "u8" },
+    castrum_utf8_valid: { args: inputAbi, returns: "u8" },
+    castrum_hex_encode: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
+    castrum_hex_decode: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
+    castrum_url_encode: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
+    castrum_url_decode: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
+    castrum_validate_email: { args: ["cstring"], returns: "u8" },
+    castrum_validate_uuid: { args: ["cstring"], returns: "u8" },
+    castrum_validate_ipv4: { args: ["cstring"], returns: "u8" },
+    castrum_validate_ipv6: { args: ["cstring"], returns: "u8" },
+    castrum_validate_email_bytes: { args: inputAbi, returns: "u8" },
+    castrum_validate_uuid_bytes: { args: inputAbi, returns: "u8" },
+    castrum_validate_ipv4_bytes: { args: inputAbi, returns: "u8" },
+    castrum_validate_ipv6_bytes: { args: inputAbi, returns: "u8" },
+    castrum_json_sum_ids: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
+    castrum_hmac_sha256_verify: {
+      args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
+      returns: "u8"
+    },
+    castrum_csrf_verify: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: "u8" },
+    castrum_password_verify: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: "u8" },
+    castrum_password_verify_bcrypt: {
+      args: abi(["ptr", "usize", "cstring"]),
+      returns: "u8"
+    },
+    castrum_ws_accept_key: { args: ["cstring"], returns: "cstring" },
+    castrum_ws_accept_key_into: {
+      args: abi(["ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_etag: { args: abi(["ptr", "usize", "u8"]), returns: "cstring" },
+    castrum_etag_into: { args: abi(["ptr", "usize", "u8", "ptr", "usize"]), returns: U64_FAST },
+    castrum_conditional_is_not_modified: {
+      args: abi(["usize", "ptr", "usize", "ptr", "usize", "u8"]),
+      returns: "u8"
+    },
+    castrum_media_type_matcher_matches: {
+      args: abi(["usize", "ptr", "usize"]),
+      returns: "u8"
+    },
+    castrum_accept_negotiator_negotiate: {
+      args: abi(["usize", "ptr", "usize"]),
+      returns: "cstring"
+    },
+    castrum_accept_negotiator_negotiate_server: {
+      args: ["usize", "cstring"],
+      returns: "cstring"
+    },
+    castrum_jwt_signer_sign: {
+      args: abi(["usize", "ptr", "usize", "i64", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_jwt_signer_verify: {
+      args: abi(["usize", "ptr", "usize", "i64", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_template_render: {
+      args: abi(["usize", "ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_schema_validator_validate: {
+      args: abi(["usize", "ptr", "usize"]),
+      returns: "u8"
+    },
+    castrum_rate_limiter_check: {
+      args: abi(["usize", "cstring", "i64", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_rate_limiter_check_key: {
+      args: abi(["usize", "i64", "i64", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_random_token: { args: ["u32"], returns: "cstring" },
+    castrum_random_token_into: { args: ["u32", ...abi(["ptr", "usize"])], returns: U64_FAST },
+    castrum_base64_encode: {
+      args: abi(["ptr", "usize", "ptr", "usize", "u8", "u8"]),
+      returns: U64_FAST
+    },
+    castrum_base64_decode: {
+      args: abi(["ptr", "usize", "ptr", "usize", "u8", "u8"]),
+      returns: U64_FAST
+    },
+    castrum_hmac_sha256: {
+      args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_sign_cookie: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: "cstring" },
+    castrum_sign_cookie_into: {
+      args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_verify_cookie: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: "cstring" },
+    castrum_verify_cookie_into: {
+      args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_csrf_token: { args: abi(["ptr", "usize"]), returns: "cstring" },
+    castrum_csrf_token_into: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
+    castrum_password_hash: {
+      args: abi(["ptr", "usize", "ptr", "usize", "u32", "u32", "u32", "u32", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_password_hash_bcrypt: {
+      args: abi(["ptr", "usize", "u32", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_pbkdf2_sha256: {
+      args: abi(["ptr", "usize", "ptr", "usize", "u32", "u32", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_aead_encrypt: {
+      args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize", "u8", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_aead_decrypt: {
+      args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize", "u8", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_ws_frame_encode: {
+      args: abi(["u8", "ptr", "usize", "u8", "u8", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_json_patch: {
+      args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_gzip_compress: {
+      args: abi(["ptr", "usize", "u32", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_gzip_decompress: {
+      args: abi(["ptr", "usize", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_brotli_compress: {
+      args: abi(["ptr", "usize", "u32", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_brotli_decompress: {
+      args: abi(["ptr", "usize", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_gzip_isize: { args: abi(["ptr", "usize"]), returns: "u32" },
+    castrum_http_parse_request_packed: {
+      args: abi(["ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_query_parse_packed: {
+      args: abi(["ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_cookie_parse_packed: {
+      args: abi(["ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_http_date_into: { args: ["f64", ...abi(["ptr", "usize"])], returns: U64_FAST },
+    castrum_sse_encode_into: {
+      args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize", "u8", "u32", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_jwt_sign_bytes: {
+      args: abi(["ptr", "usize", "ptr", "usize", "i64", "i64"]),
+      returns: "cstring"
+    },
+    castrum_jwt_sign_bytes_into: {
+      args: abi(["ptr", "usize", "ptr", "usize", "i64", "i64", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_ed25519_generate_keypair: {
+      args: abi(["ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_ed25519_sign: {
+      args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_ed25519_verify: {
+      args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
+      returns: "u32"
+    },
+    castrum_jwt_eddsa_sign: {
+      args: abi(["ptr", "usize", "ptr", "usize", "i64", "i64"]),
+      returns: "cstring"
+    },
+    castrum_jwt_eddsa_verify: {
+      args: abi(["ptr", "usize", "ptr", "usize", "i64"]),
+      returns: "cstring"
+    },
+    castrum_ws_frame_decode_packed: {
+      args: abi(["ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_multipart_parse_packed: {
+      args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_form_parse_packed: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
+    castrum_json_parse_packed: {
+      args: abi(["ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_parse_media_type: {
+      args: abi(["ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_parse_http_date: {
+      args: abi(["ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_parse_accept_encoding: {
+      args: abi(["ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_url_encode_query: { args: abi(["ptr", "usize"]), returns: "cstring" },
+    castrum_url_resolve: {
+      args: abi(["ptr", "usize", "ptr", "usize"]),
+      returns: "cstring"
+    },
+    castrum_url_builder_resolve: {
+      args: abi(["usize", "ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_mime_from_extension: { args: ["cstring"], returns: "cstring" },
+    castrum_jwt_verify: {
+      args: abi(["ptr", "usize", "ptr", "usize", "i64"]),
+      returns: "cstring"
+    },
+    castrum_ingress_handle_packed: {
+      args: abi(["usize", "ptr", "usize", "ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_ingress_handle_components: {
+      args: abi([
+        "usize",
+        "u8",
+        "cstring",
+        "cstring",
+        "ptr",
+        "usize",
+        "ptr",
+        "usize",
+        "ptr",
+        "usize",
+        "ptr",
+        "usize"
+      ]),
+      returns: U64_FAST
+    },
+    castrum_ingress_layout: { args: abi(["ptr", "usize"]), returns: U64_FAST },
+    castrum_route_compile: { args: abi(["ptr", "usize"]), returns: U64_FAST },
+    castrum_route_run: {
+      args: abi(["usize", "ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_route_destroy: { args: ["usize"], returns: "void" },
+    castrum_hex_validate_batch: {
+      args: abi(["ptr", "usize", "u32", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_regex_escape: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
+    castrum_metrics_create: { args: [], returns: U64_FAST },
+    castrum_metrics_counter: { args: ["usize", "cstring", "cstring"], returns: "u32" },
+    castrum_metrics_gauge: { args: ["usize", "cstring", "cstring"], returns: "u32" },
+    castrum_metrics_histogram: {
+      args: ["usize", "cstring", "cstring", "cstring"],
+      returns: "u32"
+    },
+    castrum_metrics_record: {
+      args: abi(["usize", "u32", "ptr", "usize", "f64"]),
+      returns: "u8"
+    },
+    castrum_metrics_gauge_set: {
+      args: abi(["usize", "u32", "ptr", "usize", "f64"]),
+      returns: "u8"
+    },
+    castrum_metrics_record_str: {
+      args: ["usize", "u32", "cstring", "f64"],
+      returns: "u8"
+    },
+    castrum_metrics_gauge_set_str: {
+      args: ["usize", "u32", "cstring", "f64"],
+      returns: "u8"
+    },
+    castrum_regex_escape_str: { args: ["cstring"], returns: "cstring" },
+    castrum_hex_validate_batch_str: {
+      args: abi(["cstring", "u32", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_metrics_render: { args: abi(["usize", "ptr", "usize"]), returns: U64_FAST },
+    castrum_metrics_snapshot: { args: abi(["usize", "ptr", "usize"]), returns: U64_FAST },
+    castrum_metrics_record_batch: {
+      args: abi(["usize", "ptr", "usize"]),
+      returns: "u8"
+    },
+    castrum_query_validate: { args: ["usize", "cstring"], returns: "u8" },
+    castrum_cookie_validate: { args: ["usize", "cstring"], returns: "u8" },
+    castrum_session_seal: {
+      args: ["cstring", "cstring", "i64", "cstring"],
+      returns: "cstring"
+    },
+    castrum_session_open: {
+      args: abi(["cstring", "cstring", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_session_seal_bytes: {
+      args: abi(["ptr", "usize", "ptr", "usize", "i64", "ptr", "usize"]),
+      returns: "cstring"
+    },
+    castrum_session_open_bytes: {
+      args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_task_init: { args: ["u32"], returns: "u32" },
+    castrum_task_submit: { args: abi(["u32", "ptr", "usize", "usize"]), returns: "u32" },
+    castrum_task_submit_slice: {
+      args: abi(["u32", "ptr", "usize", "ptr", "usize", "usize"]),
+      returns: "u32"
+    },
+    castrum_task_submit_out: {
+      args: abi(["u32", "ptr", "usize", "usize", "ptr", "usize"]),
+      returns: "u32"
+    },
+    castrum_task_drain: { args: abi(["ptr", "usize"]), returns: U64_FAST },
+    castrum_task_pending: { args: [], returns: "u32" },
+    castrum_task_cancel: { args: ["usize"], returns: "u32" },
+    castrum_task_set_doorbell: { args: ["ptr"], returns: "u32" },
+    castrum_task_shutdown: { args: [], returns: "u32" },
+    castrum_task_threads: { args: [], returns: "u32" },
+    castrum_metrics_destroy: { args: ["usize"], returns: "void" }
+  };
+}
+
 // src/shared/runtime.ts
-var isBun;
+var isBun, forceGc2;
 var init_runtime = __esm(() => {
   init_detect();
   isBun = isBunRuntime;
+  forceGc2 = forceGc;
 });
 
 // src/shared/codec.ts
-var encodeUtf8, encodeUtf8Into, decodeUtf8, decodeUtf8Range, decodeUtf8Fatal;
+var encodeUtf8, encodeUtf8Into, decodeUtf8, decodeUtf8Range, decodeUtf8RangeView, decodeUtf8Fatal;
 var init_codec2 = __esm(() => {
   init_codec();
   encodeUtf8 = runtimeCodec.encodeUtf8;
   encodeUtf8Into = runtimeCodec.encodeUtf8Into;
   decodeUtf8 = runtimeCodec.decodeUtf8;
   decodeUtf8Range = runtimeCodec.decodeUtf8Range;
+  decodeUtf8RangeView = runtimeCodec.decodeUtf8RangeView ? runtimeCodec.decodeUtf8RangeView : (view, start, end) => decodeUtf8Range(view, start, end);
   decodeUtf8Fatal = runtimeCodec.decodeUtf8Fatal;
 });
 
-// src/native/ffi/constants.ts
-var MAX_DECOMPRESSED, MAX_JSON_PATCH_OUTPUT, COMPRESS_INITIAL_CAP, COMPRESS_MAX_CAP, COMPRESS_HEADROOM = 64, DECOMPRESS_GUESS_MULTIPLIER_GZIP = 16, DECOMPRESS_GUESS_MULTIPLIER_BROTLI = 32, DECOMPRESS_FALLBACK_CAP, DECOMPRESS_MIN_INITIAL = 1024, SELFTEST_HEX, SELFTEST_JSON, EMPTY_VIEW;
-var init_constants = __esm(() => {
-  MAX_DECOMPRESSED = 64 * 1024 * 1024;
-  MAX_JSON_PATCH_OUTPUT = 128 * 1024 * 1024;
-  COMPRESS_INITIAL_CAP = 16 * 1024;
-  COMPRESS_MAX_CAP = 1024 * 1024;
-  DECOMPRESS_FALLBACK_CAP = 4 * 1024 * 1024;
-  SELFTEST_HEX = new Uint8Array([104, 101, 108, 108, 111]);
-  SELFTEST_JSON = new Uint8Array([123, 34, 97, 34, 58, 49, 125]);
-  EMPTY_VIEW = new Uint8Array(0);
-});
-
 // src/shared/bytes.ts
 function toBytes(v) {
   return typeof v === "string" ? encodeUtf8(v) : v;
@@ -696,365 +1065,160 @@ function buildCodecs(sym, ctx) {
     }
   };
 }
-function selfTestCodecs(b) {
+var init_codecs = __esm(() => {
+  init_codec2();
+  init_util();
+});
+
+// src/native/ffi/constants.ts
+var MAX_DECOMPRESSED, MAX_JSON_PATCH_OUTPUT, COMPRESS_INITIAL_CAP, COMPRESS_MAX_CAP, COMPRESS_HEADROOM = 64, DECOMPRESS_GUESS_MULTIPLIER_GZIP = 16, DECOMPRESS_GUESS_MULTIPLIER_BROTLI = 32, DECOMPRESS_FALLBACK_CAP, DECOMPRESS_MIN_INITIAL = 1024, SELFTEST_HEX, SELFTEST_JSON, EMPTY_VIEW;
+var init_constants = __esm(() => {
+  MAX_DECOMPRESSED = 64 * 1024 * 1024;
+  MAX_JSON_PATCH_OUTPUT = 128 * 1024 * 1024;
+  COMPRESS_INITIAL_CAP = 16 * 1024;
+  COMPRESS_MAX_CAP = 1024 * 1024;
+  DECOMPRESS_FALLBACK_CAP = 4 * 1024 * 1024;
+  SELFTEST_HEX = new Uint8Array([104, 101, 108, 108, 111]);
+  SELFTEST_JSON = new Uint8Array([123, 34, 97, 34, 58, 49, 125]);
+  EMPTY_VIEW = new Uint8Array(0);
+});
+
+// src/native/ffi/build/compress.ts
+function buildCompress(sym, ctx) {
+  const { lenOrView, scratchFor } = ctx;
+  const gzipCompress = sym.castrum_gzip_compress;
+  const gzipDecompress = sym.castrum_gzip_decompress;
+  const brotliCompress = sym.castrum_brotli_compress;
+  const brotliDecompress = sym.castrum_brotli_decompress;
+  const gzipIsize = sym.castrum_gzip_isize;
+  const jsonPatch = sym.castrum_json_patch;
+  return {
+    jsonPatch(doc, patch) {
+      let out = scratchFor(Math.min(Math.max(doc.length, patch.length) + 16, 64 * 1024));
+      let w = Number(jsonPatch(doc, lenOrView(doc), patch, lenOrView(patch), out, lenOrView(out)));
+      if (w > out.length && w <= MAX_JSON_PATCH_OUTPUT) {
+        out = new Uint8Array(w);
+        w = Number(jsonPatch(doc, lenOrView(doc), patch, lenOrView(patch), out, lenOrView(out)));
+      }
+      if (w === 0 || w > out.length) {
+        throw new Error("json patch: output buffer too small or patch inapplicable");
+      }
+      return decodeUtf8(out.subarray(0, w));
+    },
+    gzipCompress(data, level = 6) {
+      return growExact((out) => Number(gzipCompress(data, lenOrView(data), Math.min(level, 9), out, lenOrView(out))), Math.min(data.length + COMPRESS_HEADROOM, COMPRESS_INITIAL_CAP), Math.max(data.length * 2 + COMPRESS_HEADROOM, COMPRESS_MAX_CAP), "gzip compress: output buffer too small");
+    },
+    gzipCompressInto(data, output, level = 6) {
+      const w = Number(gzipCompress(data, lenOrView(data), Math.min(level, 9), output, lenOrView(output)));
+      if (w === 0) {
+        throw new Error("gzip compress: invalid input");
+      }
+      if (w > output.length) {
+        throw new Error("gzip compress: output buffer too small");
+      }
+      return w;
+    },
+    gzipDecompress(data, maxDecompressed) {
+      const max = maxDecompressed ?? MAX_DECOMPRESSED;
+      const isize = Number(gzipIsize(data, lenOrView(data)));
+      const initial = isize !== 0 ? Math.min(isize, max) : Math.min(data.length * DECOMPRESS_GUESS_MULTIPLIER_GZIP, DECOMPRESS_FALLBACK_CAP);
+      return growExact((out) => Number(gzipDecompress(data, lenOrView(data), max, out, lenOrView(out))), initial, max, "gzip decompress: invalid stream or exceeded max decompressed size");
+    },
+    gzipDecompressInto(data, output, maxDecompressed) {
+      const max = maxDecompressed ?? MAX_DECOMPRESSED;
+      const w = Number(gzipDecompress(data, lenOrView(data), max, output, lenOrView(output)));
+      if (w === 0) {
+        throw new Error("gzip decompress: invalid stream or exceeded max decompressed size");
+      }
+      if (w > output.length) {
+        throw new Error("gzip decompress: output buffer too small");
+      }
+      return w;
+    },
+    gzipIsize(data) {
+      return Number(gzipIsize(data, lenOrView(data)));
+    },
+    brotliCompress(data, quality = 5) {
+      return growExact((out) => Number(brotliCompress(data, lenOrView(data), Math.min(quality, 11), out, lenOrView(out))), Math.min(data.length + COMPRESS_HEADROOM, COMPRESS_INITIAL_CAP), Math.max(data.length * 2 + COMPRESS_HEADROOM, COMPRESS_MAX_CAP), "brotli compress: output buffer too small");
+    },
+    brotliCompressInto(data, output, quality = 5) {
+      const w = Number(brotliCompress(data, lenOrView(data), Math.min(quality, 11), output, lenOrView(output)));
+      if (w === 0) {
+        throw new Error("brotli compress: invalid input");
+      }
+      if (w > output.length) {
+        throw new Error("brotli compress: output buffer too small");
+      }
+      return w;
+    },
+    brotliDecompress(data, maxDecompressed) {
+      const max = maxDecompressed ?? MAX_DECOMPRESSED;
+      return growExact((out) => Number(brotliDecompress(data, lenOrView(data), max, out, lenOrView(out))), Math.min(Math.max(data.length * DECOMPRESS_GUESS_MULTIPLIER_BROTLI, DECOMPRESS_MIN_INITIAL), DECOMPRESS_FALLBACK_CAP), max, "brotli decompress: invalid stream or exceeded max decompressed size");
+    },
+    brotliDecompressInto(data, output, maxDecompressed) {
+      const max = maxDecompressed ?? MAX_DECOMPRESSED;
+      const w = Number(brotliDecompress(data, lenOrView(data), max, output, lenOrView(output)));
+      if (w === 0) {
+        throw new Error("brotli decompress: invalid stream or exceeded max decompressed size");
+      }
+      if (w > output.length) {
+        throw new Error("brotli decompress: output buffer too small");
+      }
+      return w;
+    }
+  };
+}
+function selfTestCompress(b) {
   const enc = { encode: encodeUtf8 };
   const dec = { decode: decodeUtf8 };
-  if (b.crc32(enc.encode("123456789")) !== 3421780262)
-    return false;
-  if (b.fnv1a64(enc.encode("foobar")) !== 0x85944171f73967e8n)
-    return false;
-  if (b.xxh3(new Uint8Array(0)) !== 0x2d06800538d394c2n)
-    return false;
-  if (b.jsonValid(SELFTEST_JSON) !== true || b.jsonValid(enc.encode("{not json")) !== false) {
-    return false;
-  }
-  if (!b.utf8Valid(enc.encode("héllo")) || b.utf8Valid(new Uint8Array([255, 254]))) {
-    return false;
-  }
-  const hexOut = new Uint8Array(SELFTEST_HEX.length * 2);
-  if (b.hexEncodeInto(SELFTEST_HEX, hexOut) !== 10 || dec.decode(hexOut) !== "68656c6c6f") {
-    return false;
-  }
-  const urlInput = enc.encode("a b/c");
-  const urlOut = new Uint8Array(9);
-  if (b.urlEncodeInto(urlInput, urlOut) !== 9 || dec.decode(urlOut) !== "a%20b%2Fc") {
+  const patched = b.jsonPatch(enc.encode(`{"a":"b"}`), enc.encode(`[{"op":"add","path":"/c","value":"d"}]`));
+  if (!patched.includes(`"c":"d"`)) {
     return false;
   }
-  if (!b.validateEmail("a@b.com") || !b.validateUuid("550e8400-e29b-41d4-a716-446655440000") || !b.validateIpv4("192.168.0.1") || !b.validateIpv6("2001:db8::1") || b.validateEmail("not-an-email") || b.validateUuid("not-a-uuid")) {
+  const gz = b.gzipCompress(SELFTEST_HEX);
+  if (dec.decode(b.gzipDecompress(gz)) !== "hello") {
     return false;
   }
-  if (!b.validateEmailBytes(enc.encode("a@b.com")) || !b.validateUuidBytes(enc.encode("550e8400-e29b-41d4-a716-446655440000")) || !b.validateIpv4Bytes(enc.encode("192.168.0.1")) || !b.validateIpv6Bytes(enc.encode("2001:db8::1")) || b.validateEmailBytes(enc.encode("not-an-email")) || b.validateIpv6Bytes(enc.encode("999"))) {
+  const br = b.brotliCompress(SELFTEST_HEX);
+  if (dec.decode(b.brotliDecompress(br)) !== "hello") {
     return false;
   }
-  if (b.jsonSumIds(enc.encode(`[{"id":1},{"id":2}]`)) !== 3n)
-    return false;
-  if (b.jsonSumIds(enc.encode(`[{"id":0},{"id":0}]`)) !== 0n)
-    return false;
-  let sumInvalidThrew = false;
+  let decompressThrew = false;
   try {
-    b.jsonSumIds(enc.encode("nope"));
+    b.gzipDecompress(enc.encode("not-a-gzip-stream"));
   } catch {
-    sumInvalidThrew = true;
+    decompressThrew = true;
   }
-  if (!sumInvalidThrew)
+  if (!decompressThrew) {
     return false;
-  {
-    const ids = enc.encode(`507f1f77bcf86cd799439011
-zz
-507F1F77BCF86CD799439012`);
-    const tiny = new Uint8Array(2);
-    const needed = b.hexValidateBatchInto(ids, 24, tiny);
-    if (needed !== 3)
-      return false;
-    const out = new Uint8Array(needed);
-    if (b.hexValidateBatchInto(ids, 24, out) !== 3)
-      return false;
-    if (out[0] !== 1 || out[1] !== 0 || out[2] !== 1)
-      return false;
-    let widthThrew = false;
-    try {
-      b.hexValidateBatchInto(ids, 0, new Uint8Array(3));
-    } catch {
-      widthThrew = true;
-    }
-    if (!widthThrew)
-      return false;
-  }
-  {
-    const out = new Uint8Array(64);
-    const w = b.regexEscapeInto(enc.encode("a.c(x)"), out);
-    if (w !== 9 || dec.decode(out.subarray(0, w)) !== "a\\.c\\(x\\)")
-      return false;
-    const plain = new Uint8Array(16);
-    const wp = b.regexEscapeInto(enc.encode("hello"), plain);
-    if (wp !== 5 || dec.decode(plain.subarray(0, wp)) !== "hello")
-      return false;
-    if (b.regexEscapeInto(enc.encode("a.b"), new Uint8Array(2)) !== 4)
-      return false;
-    if (b.regexEscapeStr("a.c(x)") !== "a\\.c\\(x\\)")
-      return false;
-    if (b.regexEscapeStr("plain text") !== "plain text")
-      return false;
-  }
-  {
-    const out = new Uint8Array(8);
-    const w = b.hexValidateBatchStr(`507f1f77bcf86cd799439011
-zz`, 24, out);
-    if (w !== 2 || out[0] !== 1 || out[1] !== 0)
-      return false;
   }
-  const hmacKey = new Uint8Array(20).fill(11);
-  const hmacData = enc.encode("Hi There");
-  const hmacSig = enc.encode("b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7");
-  if (b.hmacSha256(hmacKey, hmacData) !== "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7") {
-    return false;
+  decompressThrew = false;
+  try {
+    b.brotliDecompress(enc.encode("not-brotli-stream"));
+  } catch {
+    decompressThrew = true;
   }
-  if (!b.hmacSha256Verify(hmacKey, hmacData, hmacSig)) {
+  if (!decompressThrew) {
     return false;
   }
-  const decoded = b.hexDecode(enc.encode("68656c6c6f"));
-  if (dec.decode(decoded) !== "hello" || dec.decode(b.urlDecode(enc.encode("a%20b%2Fc"))) !== "a b/c") {
+  const gzInto = new Uint8Array(64);
+  const gzW = b.gzipCompressInto(SELFTEST_HEX, gzInto);
+  if (gzW === 0 || dec.decode(b.gzipDecompress(gzInto.subarray(0, gzW))) !== "hello") {
     return false;
   }
-  if (b.wsAcceptKey("dGhlIHNhbXBsZSBub25jZQ==") !== "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=") {
+  const brInto = new Uint8Array(64);
+  const brW = b.brotliCompressInto(SELFTEST_HEX, brInto);
+  if (brW === 0 || dec.decode(b.brotliDecompress(brInto.subarray(0, brW))) !== "hello") {
     return false;
   }
-  if (b.etag(SELFTEST_HEX).length !== 10 || b.etag(SELFTEST_HEX, true).length !== 12) {
+  const gzDst = new Uint8Array(16);
+  const gzDW = b.gzipDecompressInto(gzInto.subarray(0, gzW), gzDst);
+  if (gzDW === 0 || dec.decode(gzDst.subarray(0, gzDW)) !== "hello") {
     return false;
   }
-  if (b.base64Encode(SELFTEST_HEX) !== "aGVsbG8=") {
-    return false;
-  }
-  if (dec.decode(b.base64Decode(enc.encode("aGVsbG8="))) !== "hello") {
-    return false;
-  }
-  const secret = enc.encode("s3cr3t-secret");
-  const signed = b.signCookie(SELFTEST_HEX, secret);
-  const verified = b.verifyCookie(enc.encode(signed), secret);
-  if (verified === null || verified !== "hello") {
-    return false;
-  }
-  if (b.verifyCookie(enc.encode("tampered.0000"), secret) !== null) {
-    return false;
-  }
-  const csrfTokenStr = b.csrfToken(secret);
-  if (csrfTokenStr.length !== 129 || !b.csrfVerify(enc.encode(csrfTokenStr), secret)) {
-    return false;
-  }
-  const pw = enc.encode("correct horse battery staple");
-  const salt = enc.encode("salty-salt-16b");
-  const phc = b.passwordHash(pw, salt, 8, 1, 1, 16);
-  if (phc.length === 0 || !b.passwordVerify(pw, enc.encode(phc))) {
-    return false;
-  }
-  const bcryptPhc = b.passwordHashBcrypt(pw, 4);
-  if (bcryptPhc.length === 0 || !b.passwordVerifyBcrypt(pw, bcryptPhc)) {
-    return false;
-  }
-  const dk = b.pbkdf2Sha256(enc.encode("password"), enc.encode("salt"), 1, 32);
-  if (b.hexEncode(dk) !== "120fb6cffcf8b32c43e7225256c4f837a86548c92ccc35480805987cb70be17b") {
-    return false;
-  }
-  const aeadKey = new Uint8Array(32).fill(66);
-  const nonce = new Uint8Array(12).fill(7);
-  const ct = b.aeadEncrypt(aeadKey, nonce, SELFTEST_HEX, 0);
-  const pt = b.aeadDecrypt(aeadKey, nonce, ct, 0);
-  if (pt === null || dec.decode(pt) !== "hello") {
-    return false;
-  }
-  const rtOut = new Uint8Array(32);
-  const rtW = b.randomTokenInto(16, rtOut);
-  if (rtW !== 32 || !/^[0-9a-f]{32}$/.test(dec.decode(rtOut))) {
-    return false;
-  }
-  try {
-    b.randomTokenInto(16, new Uint8Array(8));
-    return false;
-  } catch {}
-  const waOut = new Uint8Array(28);
-  const waW = b.wsAcceptKeyInto(enc.encode("dGhlIHNhbXBsZSBub25jZQ=="), waOut);
-  const waExpected = b.wsAcceptKey("dGhlIHNhbXBsZSBub25jZQ==");
-  if (waW !== 28 || dec.decode(waOut) !== waExpected) {
-    return false;
-  }
-  const etagData = enc.encode("hello");
-  const etagOut = new Uint8Array(16);
-  const etagW = b.etagInto(etagData, etagOut);
-  if (etagW !== 10 || dec.decode(etagOut.subarray(0, etagW)) !== b.etag(etagData)) {
-    return false;
-  }
-  const csrfOut = new Uint8Array(129);
-  const csrfW = b.csrfTokenInto(enc.encode("csrf-secret"), csrfOut);
-  if (csrfW !== 129 || csrfOut[64] !== 46) {
-    return false;
-  }
-  const ckVal = enc.encode("session-value");
-  const ckSec = enc.encode("s3cr3t-secret");
-  const ckOut = new Uint8Array(256);
-  const ckW = b.signCookieInto(ckVal, ckSec, ckOut);
-  if (ckW !== ckVal.length + 65) {
-    return false;
-  }
-  const ckVerifyOut = new Uint8Array(256);
-  const ckV = b.verifyCookieInto(ckOut.subarray(0, ckW), ckSec, ckVerifyOut);
-  if (ckV !== ckVal.length || dec.decode(ckVerifyOut.subarray(0, ckV)) !== "session-value") {
-    return false;
-  }
-  if (b.urlEncode(enc.encode("a b/c")) !== "a%20b%2Fc") {
-    return false;
-  }
-  const hdInto = new Uint8Array(8);
-  if (b.hexDecodeInto(enc.encode("68656c6c6f"), hdInto) !== 5 || dec.decode(hdInto.subarray(0, 5)) !== "hello") {
-    return false;
-  }
-  const udInto = new Uint8Array(16);
-  if (b.urlDecodeInto(enc.encode("a%20b%2Fc"), udInto) !== 5 || dec.decode(udInto.subarray(0, 5)) !== "a b/c") {
-    return false;
-  }
-  const b64Into = new Uint8Array(16);
-  if (b.base64EncodeInto(SELFTEST_HEX, b64Into) !== 8 || dec.decode(b64Into.subarray(0, 8)) !== "aGVsbG8=") {
-    return false;
-  }
-  const bdInto = new Uint8Array(8);
-  if (b.base64DecodeInto(enc.encode("aGVsbG8="), bdInto) !== 5 || dec.decode(bdInto.subarray(0, 5)) !== "hello") {
-    return false;
-  }
-  if (!/^[0-9a-f]{32}$/.test(b.randomToken(16))) {
-    return false;
-  }
-  const hmacInto = new Uint8Array(64);
-  if (b.hmacSha256Into(hmacKey, hmacData, hmacInto) !== 64 || dec.decode(hmacInto) !== "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7") {
-    return false;
-  }
-  const ctInto = new Uint8Array(64);
-  const ctW = b.aeadEncryptInto(aeadKey, nonce, SELFTEST_HEX, ctInto, 0);
-  if (ctW === 0 || b.aeadDecrypt(aeadKey, nonce, ctInto.subarray(0, ctW), 0) === null) {
-    return false;
-  }
-  return true;
-}
-var init_codecs = __esm(() => {
-  init_codec2();
-  init_constants();
-  init_util();
-});
-
-// src/native/ffi/build/compress.ts
-function buildCompress(sym, ctx) {
-  const { lenOrView, scratchFor } = ctx;
-  const gzipCompress = sym.castrum_gzip_compress;
-  const gzipDecompress = sym.castrum_gzip_decompress;
-  const brotliCompress = sym.castrum_brotli_compress;
-  const brotliDecompress = sym.castrum_brotli_decompress;
-  const gzipIsize = sym.castrum_gzip_isize;
-  const jsonPatch = sym.castrum_json_patch;
-  return {
-    jsonPatch(doc, patch) {
-      let out = scratchFor(Math.min(Math.max(doc.length, patch.length) + 16, 64 * 1024));
-      let w = Number(jsonPatch(doc, lenOrView(doc), patch, lenOrView(patch), out, lenOrView(out)));
-      if (w > out.length && w <= MAX_JSON_PATCH_OUTPUT) {
-        out = new Uint8Array(w);
-        w = Number(jsonPatch(doc, lenOrView(doc), patch, lenOrView(patch), out, lenOrView(out)));
-      }
-      if (w === 0 || w > out.length) {
-        throw new Error("json patch: output buffer too small or patch inapplicable");
-      }
-      return decodeUtf8(out.subarray(0, w));
-    },
-    gzipCompress(data, level = 6) {
-      return growExact((out) => Number(gzipCompress(data, lenOrView(data), Math.min(level, 9), out, lenOrView(out))), Math.min(data.length + COMPRESS_HEADROOM, COMPRESS_INITIAL_CAP), Math.max(data.length * 2 + COMPRESS_HEADROOM, COMPRESS_MAX_CAP), "gzip compress: output buffer too small");
-    },
-    gzipCompressInto(data, output, level = 6) {
-      const w = Number(gzipCompress(data, lenOrView(data), Math.min(level, 9), output, lenOrView(output)));
-      if (w === 0) {
-        throw new Error("gzip compress: invalid input");
-      }
-      if (w > output.length) {
-        throw new Error("gzip compress: output buffer too small");
-      }
-      return w;
-    },
-    gzipDecompress(data, maxDecompressed) {
-      const max = maxDecompressed ?? MAX_DECOMPRESSED;
-      const isize = Number(gzipIsize(data, lenOrView(data)));
-      const initial = isize !== 0 ? Math.min(isize, max) : Math.min(data.length * DECOMPRESS_GUESS_MULTIPLIER_GZIP, DECOMPRESS_FALLBACK_CAP);
-      return growExact((out) => Number(gzipDecompress(data, lenOrView(data), max, out, lenOrView(out))), initial, max, "gzip decompress: invalid stream or exceeded max decompressed size");
-    },
-    gzipDecompressInto(data, output, maxDecompressed) {
-      const max = maxDecompressed ?? MAX_DECOMPRESSED;
-      const w = Number(gzipDecompress(data, lenOrView(data), max, output, lenOrView(output)));
-      if (w === 0) {
-        throw new Error("gzip decompress: invalid stream or exceeded max decompressed size");
-      }
-      if (w > output.length) {
-        throw new Error("gzip decompress: output buffer too small");
-      }
-      return w;
-    },
-    gzipIsize(data) {
-      return Number(gzipIsize(data, lenOrView(data)));
-    },
-    brotliCompress(data, quality = 5) {
-      return growExact((out) => Number(brotliCompress(data, lenOrView(data), Math.min(quality, 11), out, lenOrView(out))), Math.min(data.length + COMPRESS_HEADROOM, COMPRESS_INITIAL_CAP), Math.max(data.length * 2 + COMPRESS_HEADROOM, COMPRESS_MAX_CAP), "brotli compress: output buffer too small");
-    },
-    brotliCompressInto(data, output, quality = 5) {
-      const w = Number(brotliCompress(data, lenOrView(data), Math.min(quality, 11), output, lenOrView(output)));
-      if (w === 0) {
-        throw new Error("brotli compress: invalid input");
-      }
-      if (w > output.length) {
-        throw new Error("brotli compress: output buffer too small");
-      }
-      return w;
-    },
-    brotliDecompress(data, maxDecompressed) {
-      const max = maxDecompressed ?? MAX_DECOMPRESSED;
-      return growExact((out) => Number(brotliDecompress(data, lenOrView(data), max, out, lenOrView(out))), Math.min(Math.max(data.length * DECOMPRESS_GUESS_MULTIPLIER_BROTLI, DECOMPRESS_MIN_INITIAL), DECOMPRESS_FALLBACK_CAP), max, "brotli decompress: invalid stream or exceeded max decompressed size");
-    },
-    brotliDecompressInto(data, output, maxDecompressed) {
-      const max = maxDecompressed ?? MAX_DECOMPRESSED;
-      const w = Number(brotliDecompress(data, lenOrView(data), max, output, lenOrView(output)));
-      if (w === 0) {
-        throw new Error("brotli decompress: invalid stream or exceeded max decompressed size");
-      }
-      if (w > output.length) {
-        throw new Error("brotli decompress: output buffer too small");
-      }
-      return w;
-    }
-  };
-}
-function selfTestCompress(b) {
-  const enc = { encode: encodeUtf8 };
-  const dec = { decode: decodeUtf8 };
-  const patched = b.jsonPatch(enc.encode(`{"a":"b"}`), enc.encode(`[{"op":"add","path":"/c","value":"d"}]`));
-  if (!patched.includes(`"c":"d"`)) {
-    return false;
-  }
-  const gz = b.gzipCompress(SELFTEST_HEX);
-  if (dec.decode(b.gzipDecompress(gz)) !== "hello") {
-    return false;
-  }
-  const br = b.brotliCompress(SELFTEST_HEX);
-  if (dec.decode(b.brotliDecompress(br)) !== "hello") {
-    return false;
-  }
-  let decompressThrew = false;
-  try {
-    b.gzipDecompress(enc.encode("not-a-gzip-stream"));
-  } catch {
-    decompressThrew = true;
-  }
-  if (!decompressThrew) {
-    return false;
-  }
-  decompressThrew = false;
-  try {
-    b.brotliDecompress(enc.encode("not-brotli-stream"));
-  } catch {
-    decompressThrew = true;
-  }
-  if (!decompressThrew) {
-    return false;
-  }
-  const gzInto = new Uint8Array(64);
-  const gzW = b.gzipCompressInto(SELFTEST_HEX, gzInto);
-  if (gzW === 0 || dec.decode(b.gzipDecompress(gzInto.subarray(0, gzW))) !== "hello") {
-    return false;
-  }
-  const brInto = new Uint8Array(64);
-  const brW = b.brotliCompressInto(SELFTEST_HEX, brInto);
-  if (brW === 0 || dec.decode(b.brotliDecompress(brInto.subarray(0, brW))) !== "hello") {
-    return false;
-  }
-  const gzDst = new Uint8Array(16);
-  const gzDW = b.gzipDecompressInto(gzInto.subarray(0, gzW), gzDst);
-  if (gzDW === 0 || dec.decode(gzDst.subarray(0, gzDW)) !== "hello") {
-    return false;
-  }
-  const brDst = new Uint8Array(16);
-  const brDW = b.brotliDecompressInto(brInto.subarray(0, brW), brDst);
-  if (brDW === 0 || dec.decode(brDst.subarray(0, brDW)) !== "hello") {
+  const brDst = new Uint8Array(16);
+  const brDW = b.brotliDecompressInto(brInto.subarray(0, brW), brDst);
+  if (brDW === 0 || dec.decode(brDst.subarray(0, brDW)) !== "hello") {
     return false;
   }
   return true;
@@ -1113,7 +1277,10 @@ function buildInstances(sym, ctx) {
       return acceptNegotiatorNegotiateRaw(inner, header, lenOrView(header));
     },
     acceptNegotiatorNegotiateServer(inner, header) {
-      return acceptNegotiatorNegotiateServerRaw(inner, decodeUtf8(header));
+      const text = decodeUtf8(header);
+      if (hasNul(text))
+        return null;
+      return acceptNegotiatorNegotiateServerRaw(inner, text);
     },
     jwtSignerSign(inner, claimsJson, nowSeconds) {
       return growExact((out) => Number(jwtSignerSignRaw(inner, claimsJson, lenOrView(claimsJson), BigInt(nowSeconds), out, lenOrView(out))), Math.min(claimsJson.length + 128, 64 * 1024), 1024 * 1024, "jwt signer: invalid claims JSON or output buffer too small");
@@ -1160,6 +1327,8 @@ function buildInstances(sym, ctx) {
       return Number(sessionOpenBytesSym(token, lenOrView(token), secret, lenOrView(secret), output, lenOrView(output)));
     },
     rateLimiterCheck(inner, key, nowMs) {
+      if (hasNul(key))
+        return { allowed: false, remaining: 0, resetMs: 0 };
       const out = rateScratch;
       const w = Number(rateLimiterCheckRaw(inner, key, BigInt(Math.trunc(nowMs)), out, lenOrView(out)));
       if (w === 0)
@@ -1252,190 +1421,6 @@ function buildInstances(sym, ctx) {
     }
   };
 }
-function selfTestInstances(b) {
-  const enc = { encode: encodeUtf8 };
-  const dec = { decode: decodeUtf8 };
-  const layoutBuf = new Uint8Array(38 * 4);
-  b.ingressLayout(layoutBuf);
-  const layoutView = new DataView(layoutBuf.buffer, layoutBuf.byteOffset, layoutBuf.byteLength);
-  if (layoutView.getUint32(0, true) !== 0 || layoutView.getUint32(2 * 4, true) !== 2 || layoutView.getUint32(12 * 4, true) !== 48 || layoutView.getUint32(13 * 4, true) !== 1 || layoutView.getUint32(28 * 4, true) !== 32 || layoutView.getUint32(37 * 4, true) !== 8) {
-    return false;
-  }
-  try {
-    b.ingressHandlePacked(0, enc.encode("/"), null, new Uint8Array(64));
-    return false;
-  } catch {}
-  try {
-    b.ingressHandleComponents(0, 0, "/", "", enc.encode("rid"), new Uint8Array(2), null, new Uint8Array(64));
-    return false;
-  } catch {}
-  const routeDesc = new Uint8Array(33);
-  const rd = new DataView(routeDesc.buffer);
-  rd.setUint32(0, 1380930900, true);
-  rd.setUint32(4, 3, true);
-  rd.setUint32(8, 2 * 1024 * 1024, true);
-  rd.setUint32(12, 8192, true);
-  rd.setUint32(16, 8192, true);
-  rd.setUint32(20, 0, true);
-  rd.setUint32(24, 1, true);
-  routeDesc[28] = 0;
-  rd.setUint32(29, 0, true);
-  const routeHandle = b.routeCompile(routeDesc);
-  if (routeHandle === 0) {
-    return false;
-  }
-  const routeFrame = new Uint8Array(15);
-  const rf = new DataView(routeFrame.buffer);
-  rf.setUint32(0, 0, true);
-  rf.setUint32(4, 3, true);
-  routeFrame.set(enc.encode("a=1"), 8);
-  rf.setUint32(11, 0, true);
-  const routeOut = new Uint8Array(64);
-  const routeW = b.routeRun(routeHandle, routeFrame, routeOut);
-  if (routeW <= 8) {
-    return false;
-  }
-  const rv = new DataView(routeOut.buffer);
-  const rFlags = rv.getUint32(0, true);
-  if ((rFlags & 1) === 0 || (rFlags & 4) === 0) {
-    return false;
-  }
-  b.routeDestroy(routeHandle);
-  if (b.conditionalIsNotModified(0, null, null) !== false) {
-    return false;
-  }
-  if (b.mediaTypeMatcherMatches(0, enc.encode("x")) !== false)
-    return false;
-  if (b.acceptNegotiatorNegotiate(0, enc.encode("gzip")) !== null)
-    return false;
-  if (b.acceptNegotiatorNegotiateServer(0, enc.encode("gzip")) !== null)
-    return false;
-  if (b.schemaValidatorValidate(0, enc.encode("{}")) !== false)
-    return false;
-  if (b.jwtSignerVerify(0, enc.encode("a.b.c"), 0) !== null)
-    return false;
-  let phase6Threw = false;
-  try {
-    b.jwtSignerSign(0, enc.encode("{}"), 0);
-  } catch {
-    phase6Threw = true;
-  }
-  if (!phase6Threw)
-    return false;
-  phase6Threw = false;
-  try {
-    b.templateRender(0, enc.encode("{}"));
-  } catch {
-    phase6Threw = true;
-  }
-  if (!phase6Threw)
-    return false;
-  phase6Threw = false;
-  try {
-    b.rateLimiterCheck(0, "k", 0);
-  } catch {
-    phase6Threw = true;
-  }
-  if (!phase6Threw)
-    return false;
-  const jwtClaims = enc.encode('{"sub":"user-1"}');
-  const jwtSecret2 = enc.encode("my-secret");
-  const jwtOut = new Uint8Array(512);
-  const jwtW = b.jwtSignBytesInto(jwtClaims, jwtSecret2, 0, 0, jwtOut);
-  if (jwtW === 0 || dec.decode(jwtOut.subarray(0, jwtW)).split(".").length !== 3) {
-    return false;
-  }
-  const jwtSecret = enc.encode("my-secret");
-  const jwt = b.jwtSignBytes(enc.encode('{"sub":"user-1"}'), jwtSecret, 0, 0);
-  const jwtStr = jwt;
-  const segs = jwtStr.split(".");
-  if (segs.length !== 3 || segs[0] === "" || segs[1] === "" || segs[2] === "") {
-    return false;
-  }
-  const signingInput = enc.encode(`${segs[0]}.${segs[1]}`);
-  const sigHex = b.hmacSha256(jwtSecret, signingInput);
-  const sigBytes = b.base64Decode(enc.encode(segs[2] ?? ""), true, false);
-  if (sigBytes === null || b.hexEncode(sigBytes) !== sigHex) {
-    return false;
-  }
-  const vjwtSecret = enc.encode("verify-secret");
-  const vjwt = b.jwtSignBytes(enc.encode('{"sub":"u-1"}'), vjwtSecret, 0, 0);
-  const vjwtClaims = b.jwtVerify(enc.encode(vjwt), vjwtSecret, 0);
-  if (vjwtClaims === null || !vjwtClaims.includes('"sub":"u-1"')) {
-    return false;
-  }
-  if (b.jwtVerify(enc.encode("tampered.token.value"), vjwtSecret, 0) !== null) {
-    return false;
-  }
-  const edKp = b.ed25519GenerateKeypair();
-  const edMsg = enc.encode("ed25519 bind-time self-test");
-  const edSig = b.ed25519Sign(edMsg, edKp.privateKey);
-  if (edSig.byteLength !== 64 || !b.ed25519Verify(edMsg, edSig, edKp.publicKey)) {
-    return false;
-  }
-  const edTampered = edSig.slice();
-  edTampered[0] = (edTampered[0] ?? 0) ^ 255;
-  if (b.ed25519Verify(edMsg, edTampered, edKp.publicKey)) {
-    return false;
-  }
-  const edToken = b.jwtEdDSASign(enc.encode('{"sub":"ffi-self-test"}'), edKp.privateKey, 0, 0);
-  if (edToken === null || edToken.split(".").length !== 3) {
-    return false;
-  }
-  const edClaims = b.jwtEdDSAVerify(enc.encode(edToken), edKp.publicKey, 0);
-  if (edClaims === null || !edClaims.includes('"sub":"ffi-self-test"')) {
-    return false;
-  }
-  if (b.jwtEdDSAVerify(enc.encode("tampered.token.value"), edKp.publicKey, 0) !== null) {
-    return false;
-  }
-  let urlBuilderThrew = false;
-  try {
-    b.urlBuilderResolve(0, enc.encode("g"));
-  } catch {
-    urlBuilderThrew = true;
-  }
-  if (!urlBuilderThrew) {
-    return false;
-  }
-  if (b.queryValidate(0, "route=/a") !== false)
-    return false;
-  if (b.cookieValidate(0, "route=/a") !== false)
-    return false;
-  {
-    const tok = b.sessionSeal("sess-9", '{"n":1}', 1234567, "sekrit");
-    if (tok === null || !tok.includes(".") || !tok.startsWith('{"id":"sess-9"'))
-      return false;
-    const out = new Uint8Array(256);
-    const w = b.sessionOpen(tok, "sekrit", out);
-    if (w <= 13 || out[0] !== 1)
-      return false;
-    if (b.sessionOpen(tok, "wrong", out) !== 0)
-      return false;
-    const enc = new TextEncoder;
-    const tokB = b.sessionSealBytes(enc.encode("sess-9"), enc.encode('{"n":1}'), 1234567, enc.encode("sekrit"));
-    if (tokB === null || tokB !== tok)
-      return false;
-    const outB = new Uint8Array(256);
-    const wB = b.sessionOpenBytes(enc.encode(tokB), enc.encode("sekrit"), outB);
-    if (wB !== w || outB[0] !== 1)
-      return false;
-    if (b.sessionOpenBytes(enc.encode(tokB), enc.encode("wrong"), outB) !== 0)
-      return false;
-    if (b.sessionOpenBytes(enc.encode(tokB), enc.encode("sekrit"), outB.subarray(0, 4)) !== wB)
-      return false;
-  }
-  let rlKeyThrew = false;
-  try {
-    b.rateLimiterCheckKey(0, 12345, 0);
-  } catch {
-    rlKeyThrew = true;
-  }
-  if (!rlKeyThrew) {
-    return false;
-  }
-  return true;
-}
 var init_instances = __esm(() => {
   init_codec2();
   init_constants();
@@ -1634,123 +1619,14 @@ var init_metrics = __esm(() => {
   EMPTY = new Uint8Array(0);
 });
 
-// src/rust-ffi/scalar/json-packed.ts
-function fastDecodeUtf8(bytes) {
-  if (bytes.byteLength === 0)
-    return "";
-  if (bunFfiCodec2 === undefined) {
-    bunFfiCodec2 = null;
-    if (isBun()) {
-      try {
-        bunFfiCodec2 = __require("bun:ffi");
-      } catch {
-        bunFfiCodec2 = null;
-      }
-    }
-  }
-  if (bunFfiCodec2) {
-    return new bunFfiCodec2.CString(bunFfiCodec2.ptr(bytes), 0, bytes.byteLength).toString();
-  }
-  return decodeUtf8(bytes);
-}
-function decodeJsonPacked(bytes) {
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  let p = 0;
-  const u32 = () => {
-    const v = view.getUint32(p, true);
-    p += 4;
-    return v;
-  };
-  const strCount = u32();
-  const strings = new Array(strCount);
-  for (let i = 0;i < strCount; i++) {
-    const n = u32();
-    strings[i] = fastDecodeUtf8(bytes.subarray(p, p + n));
-    p += n;
-  }
-  const treeLen = u32();
-  const end = p + treeLen;
-  let root;
-  const frames = [];
-  const popFrame = () => {
-    const f = frames.pop();
-    if (f === undefined)
-      throw new Error("json parse: malformed packed stream");
-    return f;
-  };
-  const attach = (v) => {
-    const f = frames[frames.length - 1];
-    if (f === undefined) {
-      root = v;
-      return;
-    }
-    if (f.isObj)
-      f.obj[f.key] = v;
-    else
-      f.arr.push(v);
-  };
-  while (p < end) {
-    const t = view.getUint8(p);
-    p += 1;
-    switch (t) {
-      case TAG_NULL:
-        attach(null);
-        break;
-      case TAG_FALSE:
-        attach(false);
-        break;
-      case TAG_TRUE:
-        attach(true);
-        break;
-      case TAG_NUMBER: {
-        const v = view.getFloat64(p, true);
-        p += 8;
-        attach(v);
-        break;
-      }
-      case TAG_STRING:
-        attach(strings[u32()]);
-        break;
-      case TAG_ARRAY_START:
-        frames.push({ isObj: false, arr: [], obj: {}, key: "" });
-        break;
-      case TAG_OBJECT_START:
-        frames.push({ isObj: true, arr: [], obj: {}, key: "" });
-        break;
-      case TAG_ARRAY_END:
-        attach(popFrame().arr);
-        break;
-      case TAG_OBJECT_END:
-        attach(popFrame().obj);
-        break;
-      case TAG_KEY: {
-        const f = frames[frames.length - 1];
-        f.key = strings[u32()];
-        break;
-      }
-      default:
-        throw new Error("json parse: malformed packed token");
-    }
-  }
-  if (p !== end || frames.length !== 0) {
-    throw new Error("json parse: malformed packed stream");
-  }
-  return root;
-}
-var TAG_NULL = 0, TAG_FALSE = 1, TAG_TRUE = 2, TAG_NUMBER = 3, TAG_STRING = 4, TAG_ARRAY_START = 5, TAG_OBJECT_START = 6, TAG_ARRAY_END = 7, TAG_OBJECT_END = 8, TAG_KEY = 9, bunFfiCodec2;
-var init_json_packed = __esm(() => {
-  init_codec2();
-  init_runtime();
-});
-
-// src/native/ffi/build/parse.ts
-function sseMemoEncode(slot, s) {
-  if (s === slot.str)
-    return slot.bytes;
-  const bytes = encodeUtf8(s);
-  slot.str = s;
-  slot.bytes = bytes;
-  return bytes;
+// src/native/ffi/build/parse.ts
+function sseMemoEncode(slot, s) {
+  if (s === slot.str)
+    return slot.bytes;
+  const bytes = encodeUtf8(s);
+  slot.str = s;
+  slot.bytes = bytes;
+  return bytes;
 }
 function buildParse(sym, ctx) {
   const { lenOrView, scratchFor, dateScratch, dateScratchView } = ctx;
@@ -1911,13 +1787,635 @@ function buildParse(sym, ctx) {
       if (w === 0) {
         throw new Error("sse encode: invalid UTF-8 in event/id");
       }
-      if (w > output.length) {
-        throw new Error("sse encode: output buffer too small");
+      if (w > output.length) {
+        throw new Error("sse encode: output buffer too small");
+      }
+      return w;
+    }
+  };
+}
+var sseMemoEvent, sseMemoId;
+var init_parse = __esm(() => {
+  init_codec2();
+  init_constants();
+  init_util();
+  sseMemoEvent = { str: null, bytes: EMPTY_VIEW };
+  sseMemoId = { str: null, bytes: EMPTY_VIEW };
+});
+
+// src/native/ffi/build/task.ts
+function buildTask(sym, ctx) {
+  const { lenOrView } = ctx;
+  const init = sym.castrum_task_init;
+  const submit = sym.castrum_task_submit;
+  const submitOut = sym.castrum_task_submit_out;
+  const submitSlice = sym.castrum_task_submit_slice;
+  const drain = sym.castrum_task_drain;
+  const pending = sym.castrum_task_pending;
+  const cancel = sym.castrum_task_cancel;
+  const setDoorbell = sym.castrum_task_set_doorbell;
+  const shutdown = sym.castrum_task_shutdown;
+  const threads = sym.castrum_task_threads;
+  return {
+    taskInit: (n) => Number(init(n)),
+    taskSubmit: (op, args, taskId) => Number(submit(op, args, lenOrView(args), taskId)),
+    taskSubmitOut: (op, args, taskId, output) => Number(submitOut(op, args, lenOrView(args), taskId, output, lenOrView(output))),
+    taskSubmitSlice: (op, hdr, data, taskId) => Number(submitSlice(op, hdr, lenOrView(hdr), data, lenOrView(data), taskId)),
+    taskDrain: (output) => Number(drain(output, lenOrView(output))),
+    taskPending: () => Number(pending()),
+    taskCancel: (taskId) => Number(cancel(taskId)),
+    taskSetDoorbell: (ptr) => Number(setDoorbell(ptr)),
+    taskShutdown: () => Number(shutdown()),
+    taskThreads: () => Number(threads())
+  };
+}
+function selfTestTask(b) {
+  try {
+    if (typeof b.taskPending() !== "number")
+      return false;
+    if (typeof b.taskThreads() !== "number" || b.taskThreads() < 0)
+      return false;
+    if (b.taskSetDoorbell(0) !== 1)
+      return false;
+    if (typeof b.taskDrain(new Uint8Array(4)) !== "number")
+      return false;
+    if (typeof b.taskSubmitOut !== "function")
+      return false;
+    if (typeof b.taskSubmitSlice !== "function")
+      return false;
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/native/ffi/build.ts
+function build(sym, useBufferLength) {
+  const oneArg = (raw, v) => useBufferLength ? raw(v, v) : raw(v, v.length);
+  const lenOrView = (v) => useBufferLength ? v : v.length;
+  let encodeScratch = new Uint8Array(0);
+  const scratchFor = (size) => {
+    if (encodeScratch.byteLength < size)
+      encodeScratch = new Uint8Array(size);
+    return encodeScratch;
+  };
+  const jsonSumOut = new Uint8Array(9);
+  const jsonSumView = new DataView(jsonSumOut.buffer);
+  const dateScratch = new Uint8Array(9);
+  const dateScratchView = new DataView(dateScratch.buffer);
+  const rateScratch = new Uint8Array(13);
+  const rateScratchView = new DataView(rateScratch.buffer);
+  const ctx = {
+    useBufferLength,
+    lenOrView,
+    oneArg,
+    scratchFor,
+    jsonSumOut,
+    jsonSumView,
+    dateScratch,
+    dateScratchView,
+    rateScratch,
+    rateScratchView
+  };
+  return {
+    ...buildCodecs(sym, ctx),
+    ...buildCompress(sym, ctx),
+    ...buildParse(sym, ctx),
+    ...buildInstances(sym, ctx),
+    ...buildMetrics(sym, ctx),
+    ...buildTask(sym, ctx)
+  };
+}
+var init_build = __esm(() => {
+  init_codecs();
+  init_compress();
+  init_instances();
+  init_metrics();
+  init_parse();
+});
+
+// src/native/ffi/build/codecs-selftest.ts
+function selfTestCodecs(b) {
+  const enc = { encode: encodeUtf8 };
+  const dec = { decode: decodeUtf8 };
+  if (b.crc32(enc.encode("123456789")) !== 3421780262)
+    return false;
+  if (b.fnv1a64(enc.encode("foobar")) !== 0x85944171f73967e8n)
+    return false;
+  if (b.xxh3(new Uint8Array(0)) !== 0x2d06800538d394c2n)
+    return false;
+  if (b.jsonValid(SELFTEST_JSON) !== true || b.jsonValid(enc.encode("{not json")) !== false) {
+    return false;
+  }
+  if (!b.utf8Valid(enc.encode("héllo")) || b.utf8Valid(new Uint8Array([255, 254]))) {
+    return false;
+  }
+  const hexOut = new Uint8Array(SELFTEST_HEX.length * 2);
+  if (b.hexEncodeInto(SELFTEST_HEX, hexOut) !== 10 || dec.decode(hexOut) !== "68656c6c6f") {
+    return false;
+  }
+  const urlInput = enc.encode("a b/c");
+  const urlOut = new Uint8Array(9);
+  if (b.urlEncodeInto(urlInput, urlOut) !== 9 || dec.decode(urlOut) !== "a%20b%2Fc") {
+    return false;
+  }
+  if (!b.validateEmail("a@b.com") || !b.validateUuid("550e8400-e29b-41d4-a716-446655440000") || !b.validateIpv4("192.168.0.1") || !b.validateIpv6("2001:db8::1") || b.validateEmail("not-an-email") || b.validateUuid("not-a-uuid")) {
+    return false;
+  }
+  if (!b.validateEmailBytes(enc.encode("a@b.com")) || !b.validateUuidBytes(enc.encode("550e8400-e29b-41d4-a716-446655440000")) || !b.validateIpv4Bytes(enc.encode("192.168.0.1")) || !b.validateIpv6Bytes(enc.encode("2001:db8::1")) || b.validateEmailBytes(enc.encode("not-an-email")) || b.validateIpv6Bytes(enc.encode("999"))) {
+    return false;
+  }
+  if (b.jsonSumIds(enc.encode(`[{"id":1},{"id":2}]`)) !== 3n)
+    return false;
+  if (b.jsonSumIds(enc.encode(`[{"id":0},{"id":0}]`)) !== 0n)
+    return false;
+  let sumInvalidThrew = false;
+  try {
+    b.jsonSumIds(enc.encode("nope"));
+  } catch {
+    sumInvalidThrew = true;
+  }
+  if (!sumInvalidThrew)
+    return false;
+  {
+    const ids = enc.encode(`507f1f77bcf86cd799439011
+zz
+507F1F77BCF86CD799439012`);
+    const tiny = new Uint8Array(2);
+    const needed = b.hexValidateBatchInto(ids, 24, tiny);
+    if (needed !== 3)
+      return false;
+    const out = new Uint8Array(needed);
+    if (b.hexValidateBatchInto(ids, 24, out) !== 3)
+      return false;
+    if (out[0] !== 1 || out[1] !== 0 || out[2] !== 1)
+      return false;
+    let widthThrew = false;
+    try {
+      b.hexValidateBatchInto(ids, 0, new Uint8Array(3));
+    } catch {
+      widthThrew = true;
+    }
+    if (!widthThrew)
+      return false;
+  }
+  {
+    const out = new Uint8Array(64);
+    const w = b.regexEscapeInto(enc.encode("a.c(x)"), out);
+    if (w !== 9 || dec.decode(out.subarray(0, w)) !== "a\\.c\\(x\\)")
+      return false;
+    const plain = new Uint8Array(16);
+    const wp = b.regexEscapeInto(enc.encode("hello"), plain);
+    if (wp !== 5 || dec.decode(plain.subarray(0, wp)) !== "hello")
+      return false;
+    if (b.regexEscapeInto(enc.encode("a.b"), new Uint8Array(2)) !== 4)
+      return false;
+    if (b.regexEscapeStr("a.c(x)") !== "a\\.c\\(x\\)")
+      return false;
+    if (b.regexEscapeStr("plain text") !== "plain text")
+      return false;
+  }
+  {
+    const out = new Uint8Array(8);
+    const w = b.hexValidateBatchStr(`507f1f77bcf86cd799439011
+zz`, 24, out);
+    if (w !== 2 || out[0] !== 1 || out[1] !== 0)
+      return false;
+  }
+  const hmacKey = new Uint8Array(20).fill(11);
+  const hmacData = enc.encode("Hi There");
+  const hmacSig = enc.encode("b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7");
+  if (b.hmacSha256(hmacKey, hmacData) !== "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7") {
+    return false;
+  }
+  if (!b.hmacSha256Verify(hmacKey, hmacData, hmacSig)) {
+    return false;
+  }
+  const decoded = b.hexDecode(enc.encode("68656c6c6f"));
+  if (dec.decode(decoded) !== "hello" || dec.decode(b.urlDecode(enc.encode("a%20b%2Fc"))) !== "a b/c") {
+    return false;
+  }
+  if (b.wsAcceptKey("dGhlIHNhbXBsZSBub25jZQ==") !== "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=") {
+    return false;
+  }
+  if (b.etag(SELFTEST_HEX).length !== 10 || b.etag(SELFTEST_HEX, true).length !== 12) {
+    return false;
+  }
+  if (b.base64Encode(SELFTEST_HEX) !== "aGVsbG8=") {
+    return false;
+  }
+  if (dec.decode(b.base64Decode(enc.encode("aGVsbG8="))) !== "hello") {
+    return false;
+  }
+  const secret = enc.encode("s3cr3t-secret");
+  const signed = b.signCookie(SELFTEST_HEX, secret);
+  const verified = b.verifyCookie(enc.encode(signed), secret);
+  if (verified === null || verified !== "hello") {
+    return false;
+  }
+  if (b.verifyCookie(enc.encode("tampered.0000"), secret) !== null) {
+    return false;
+  }
+  const csrfTokenStr = b.csrfToken(secret);
+  if (csrfTokenStr.length !== 129 || !b.csrfVerify(enc.encode(csrfTokenStr), secret)) {
+    return false;
+  }
+  const pw = enc.encode("correct horse battery staple");
+  const salt = enc.encode("salty-salt-16b");
+  const phc = b.passwordHash(pw, salt, 8, 1, 1, 16);
+  if (phc.length === 0 || !b.passwordVerify(pw, enc.encode(phc))) {
+    return false;
+  }
+  const bcryptPhc = b.passwordHashBcrypt(pw, 4);
+  if (bcryptPhc.length === 0 || !b.passwordVerifyBcrypt(pw, bcryptPhc)) {
+    return false;
+  }
+  const dk = b.pbkdf2Sha256(enc.encode("password"), enc.encode("salt"), 1, 32);
+  if (b.hexEncode(dk) !== "120fb6cffcf8b32c43e7225256c4f837a86548c92ccc35480805987cb70be17b") {
+    return false;
+  }
+  const aeadKey = new Uint8Array(32).fill(66);
+  const nonce = new Uint8Array(12).fill(7);
+  const ct = b.aeadEncrypt(aeadKey, nonce, SELFTEST_HEX, 0);
+  const pt = b.aeadDecrypt(aeadKey, nonce, ct, 0);
+  if (pt === null || dec.decode(pt) !== "hello") {
+    return false;
+  }
+  const rtOut = new Uint8Array(32);
+  const rtW = b.randomTokenInto(16, rtOut);
+  if (rtW !== 32 || !/^[0-9a-f]{32}$/.test(dec.decode(rtOut))) {
+    return false;
+  }
+  try {
+    b.randomTokenInto(16, new Uint8Array(8));
+    return false;
+  } catch {}
+  const waOut = new Uint8Array(28);
+  const waW = b.wsAcceptKeyInto(enc.encode("dGhlIHNhbXBsZSBub25jZQ=="), waOut);
+  const waExpected = b.wsAcceptKey("dGhlIHNhbXBsZSBub25jZQ==");
+  if (waW !== 28 || dec.decode(waOut) !== waExpected) {
+    return false;
+  }
+  const etagData = enc.encode("hello");
+  const etagOut = new Uint8Array(16);
+  const etagW = b.etagInto(etagData, etagOut);
+  if (etagW !== 10 || dec.decode(etagOut.subarray(0, etagW)) !== b.etag(etagData)) {
+    return false;
+  }
+  const csrfOut = new Uint8Array(129);
+  const csrfW = b.csrfTokenInto(enc.encode("csrf-secret"), csrfOut);
+  if (csrfW !== 129 || csrfOut[64] !== 46) {
+    return false;
+  }
+  const ckVal = enc.encode("session-value");
+  const ckSec = enc.encode("s3cr3t-secret");
+  const ckOut = new Uint8Array(256);
+  const ckW = b.signCookieInto(ckVal, ckSec, ckOut);
+  if (ckW !== ckVal.length + 65) {
+    return false;
+  }
+  const ckVerifyOut = new Uint8Array(256);
+  const ckV = b.verifyCookieInto(ckOut.subarray(0, ckW), ckSec, ckVerifyOut);
+  if (ckV !== ckVal.length || dec.decode(ckVerifyOut.subarray(0, ckV)) !== "session-value") {
+    return false;
+  }
+  if (b.urlEncode(enc.encode("a b/c")) !== "a%20b%2Fc") {
+    return false;
+  }
+  const hdInto = new Uint8Array(8);
+  if (b.hexDecodeInto(enc.encode("68656c6c6f"), hdInto) !== 5 || dec.decode(hdInto.subarray(0, 5)) !== "hello") {
+    return false;
+  }
+  const udInto = new Uint8Array(16);
+  if (b.urlDecodeInto(enc.encode("a%20b%2Fc"), udInto) !== 5 || dec.decode(udInto.subarray(0, 5)) !== "a b/c") {
+    return false;
+  }
+  const b64Into = new Uint8Array(16);
+  if (b.base64EncodeInto(SELFTEST_HEX, b64Into) !== 8 || dec.decode(b64Into.subarray(0, 8)) !== "aGVsbG8=") {
+    return false;
+  }
+  const bdInto = new Uint8Array(8);
+  if (b.base64DecodeInto(enc.encode("aGVsbG8="), bdInto) !== 5 || dec.decode(bdInto.subarray(0, 5)) !== "hello") {
+    return false;
+  }
+  if (!/^[0-9a-f]{32}$/.test(b.randomToken(16))) {
+    return false;
+  }
+  const hmacInto = new Uint8Array(64);
+  if (b.hmacSha256Into(hmacKey, hmacData, hmacInto) !== 64 || dec.decode(hmacInto) !== "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7") {
+    return false;
+  }
+  const ctInto = new Uint8Array(64);
+  const ctW = b.aeadEncryptInto(aeadKey, nonce, SELFTEST_HEX, ctInto, 0);
+  if (ctW === 0 || b.aeadDecrypt(aeadKey, nonce, ctInto.subarray(0, ctW), 0) === null) {
+    return false;
+  }
+  return true;
+}
+var init_codecs_selftest = __esm(() => {
+  init_codec2();
+  init_constants();
+});
+
+// src/native/ffi/build/instances-selftest.ts
+function selfTestInstances(b) {
+  const enc = { encode: encodeUtf8 };
+  const dec = { decode: decodeUtf8 };
+  const layoutBuf = new Uint8Array(38 * 4);
+  b.ingressLayout(layoutBuf);
+  const layoutView = new DataView(layoutBuf.buffer, layoutBuf.byteOffset, layoutBuf.byteLength);
+  if (layoutView.getUint32(0, true) !== 0 || layoutView.getUint32(2 * 4, true) !== 2 || layoutView.getUint32(12 * 4, true) !== 48 || layoutView.getUint32(13 * 4, true) !== 1 || layoutView.getUint32(28 * 4, true) !== 32 || layoutView.getUint32(37 * 4, true) !== 8) {
+    return false;
+  }
+  try {
+    b.ingressHandlePacked(0, enc.encode("/"), null, new Uint8Array(64));
+    return false;
+  } catch {}
+  try {
+    b.ingressHandleComponents(0, 0, "/", "", enc.encode("rid"), new Uint8Array(2), null, new Uint8Array(64));
+    return false;
+  } catch {}
+  const routeDesc = new Uint8Array(33);
+  const rd = new DataView(routeDesc.buffer);
+  rd.setUint32(0, 1380930900, true);
+  rd.setUint32(4, 3, true);
+  rd.setUint32(8, 2 * 1024 * 1024, true);
+  rd.setUint32(12, 8192, true);
+  rd.setUint32(16, 8192, true);
+  rd.setUint32(20, 0, true);
+  rd.setUint32(24, 1, true);
+  routeDesc[28] = 0;
+  rd.setUint32(29, 0, true);
+  const routeHandle = b.routeCompile(routeDesc);
+  if (routeHandle === 0) {
+    return false;
+  }
+  const routeFrame = new Uint8Array(15);
+  const rf = new DataView(routeFrame.buffer);
+  rf.setUint32(0, 0, true);
+  rf.setUint32(4, 3, true);
+  routeFrame.set(enc.encode("a=1"), 8);
+  rf.setUint32(11, 0, true);
+  const routeOut = new Uint8Array(64);
+  const routeW = b.routeRun(routeHandle, routeFrame, routeOut);
+  if (routeW <= 8) {
+    return false;
+  }
+  const rv = new DataView(routeOut.buffer);
+  const rFlags = rv.getUint32(0, true);
+  if ((rFlags & 1) === 0 || (rFlags & 4) === 0) {
+    return false;
+  }
+  b.routeDestroy(routeHandle);
+  if (b.conditionalIsNotModified(0, null, null) !== false) {
+    return false;
+  }
+  if (b.mediaTypeMatcherMatches(0, enc.encode("x")) !== false)
+    return false;
+  if (b.acceptNegotiatorNegotiate(0, enc.encode("gzip")) !== null)
+    return false;
+  if (b.acceptNegotiatorNegotiateServer(0, enc.encode("gzip")) !== null)
+    return false;
+  if (b.schemaValidatorValidate(0, enc.encode("{}")) !== false)
+    return false;
+  if (b.jwtSignerVerify(0, enc.encode("a.b.c"), 0) !== null)
+    return false;
+  let phase6Threw = false;
+  try {
+    b.jwtSignerSign(0, enc.encode("{}"), 0);
+  } catch {
+    phase6Threw = true;
+  }
+  if (!phase6Threw)
+    return false;
+  phase6Threw = false;
+  try {
+    b.templateRender(0, enc.encode("{}"));
+  } catch {
+    phase6Threw = true;
+  }
+  if (!phase6Threw)
+    return false;
+  phase6Threw = false;
+  try {
+    b.rateLimiterCheck(0, "k", 0);
+  } catch {
+    phase6Threw = true;
+  }
+  if (!phase6Threw)
+    return false;
+  const jwtClaims = enc.encode('{"sub":"user-1"}');
+  const jwtSecret2 = enc.encode("my-secret");
+  const jwtOut = new Uint8Array(512);
+  const jwtW = b.jwtSignBytesInto(jwtClaims, jwtSecret2, 0, 0, jwtOut);
+  if (jwtW === 0 || dec.decode(jwtOut.subarray(0, jwtW)).split(".").length !== 3) {
+    return false;
+  }
+  const jwtSecret = enc.encode("my-secret");
+  const jwt = b.jwtSignBytes(enc.encode('{"sub":"user-1"}'), jwtSecret, 0, 0);
+  const jwtStr = jwt;
+  const segs = jwtStr.split(".");
+  if (segs.length !== 3 || segs[0] === "" || segs[1] === "" || segs[2] === "") {
+    return false;
+  }
+  const signingInput = enc.encode(`${segs[0]}.${segs[1]}`);
+  const sigHex = b.hmacSha256(jwtSecret, signingInput);
+  const sigBytes = b.base64Decode(enc.encode(segs[2] ?? ""), true, false);
+  if (sigBytes === null || b.hexEncode(sigBytes) !== sigHex) {
+    return false;
+  }
+  const vjwtSecret = enc.encode("verify-secret");
+  const vjwt = b.jwtSignBytes(enc.encode('{"sub":"u-1"}'), vjwtSecret, 0, 0);
+  const vjwtClaims = b.jwtVerify(enc.encode(vjwt), vjwtSecret, 0);
+  if (vjwtClaims === null || !vjwtClaims.includes('"sub":"u-1"')) {
+    return false;
+  }
+  if (b.jwtVerify(enc.encode("tampered.token.value"), vjwtSecret, 0) !== null) {
+    return false;
+  }
+  const edKp = b.ed25519GenerateKeypair();
+  const edMsg = enc.encode("ed25519 bind-time self-test");
+  const edSig = b.ed25519Sign(edMsg, edKp.privateKey);
+  if (edSig.byteLength !== 64 || !b.ed25519Verify(edMsg, edSig, edKp.publicKey)) {
+    return false;
+  }
+  const edTampered = edSig.slice();
+  edTampered[0] = (edTampered[0] ?? 0) ^ 255;
+  if (b.ed25519Verify(edMsg, edTampered, edKp.publicKey)) {
+    return false;
+  }
+  const edToken = b.jwtEdDSASign(enc.encode('{"sub":"ffi-self-test"}'), edKp.privateKey, 0, 0);
+  if (edToken === null || edToken.split(".").length !== 3) {
+    return false;
+  }
+  const edClaims = b.jwtEdDSAVerify(enc.encode(edToken), edKp.publicKey, 0);
+  if (edClaims === null || !edClaims.includes('"sub":"ffi-self-test"')) {
+    return false;
+  }
+  if (b.jwtEdDSAVerify(enc.encode("tampered.token.value"), edKp.publicKey, 0) !== null) {
+    return false;
+  }
+  let urlBuilderThrew = false;
+  try {
+    b.urlBuilderResolve(0, enc.encode("g"));
+  } catch {
+    urlBuilderThrew = true;
+  }
+  if (!urlBuilderThrew) {
+    return false;
+  }
+  if (b.queryValidate(0, "route=/a") !== false)
+    return false;
+  if (b.cookieValidate(0, "route=/a") !== false)
+    return false;
+  {
+    const tok = b.sessionSeal("sess-9", '{"n":1}', 1234567, "sekrit");
+    if (tok === null || !tok.includes(".") || !tok.startsWith('{"id":"sess-9"'))
+      return false;
+    const out = new Uint8Array(256);
+    const w = b.sessionOpen(tok, "sekrit", out);
+    if (w <= 13 || out[0] !== 1)
+      return false;
+    if (b.sessionOpen(tok, "wrong", out) !== 0)
+      return false;
+    const enc = new TextEncoder;
+    const tokB = b.sessionSealBytes(enc.encode("sess-9"), enc.encode('{"n":1}'), 1234567, enc.encode("sekrit"));
+    if (tokB === null || tokB !== tok)
+      return false;
+    const outB = new Uint8Array(256);
+    const wB = b.sessionOpenBytes(enc.encode(tokB), enc.encode("sekrit"), outB);
+    if (wB !== w || outB[0] !== 1)
+      return false;
+    if (b.sessionOpenBytes(enc.encode(tokB), enc.encode("wrong"), outB) !== 0)
+      return false;
+    if (b.sessionOpenBytes(enc.encode(tokB), enc.encode("sekrit"), outB.subarray(0, 4)) !== wB)
+      return false;
+  }
+  let rlKeyThrew = false;
+  try {
+    b.rateLimiterCheckKey(0, 12345, 0);
+  } catch {
+    rlKeyThrew = true;
+  }
+  if (!rlKeyThrew) {
+    return false;
+  }
+  return true;
+}
+var init_instances_selftest = __esm(() => {
+  init_codec2();
+});
+
+// src/rust-ffi/scalar/json-packed.ts
+function fastDecodeUtf8(bytes) {
+  if (bytes.byteLength === 0)
+    return "";
+  if (bunFfiCodec2 === undefined) {
+    bunFfiCodec2 = null;
+    if (isBun()) {
+      try {
+        bunFfiCodec2 = __require("bun:ffi");
+      } catch {
+        bunFfiCodec2 = null;
+      }
+    }
+  }
+  if (bunFfiCodec2) {
+    return new bunFfiCodec2.CString(bunFfiCodec2.ptr(bytes), 0, bytes.byteLength).toString();
+  }
+  return decodeUtf8(bytes);
+}
+function decodeJsonPacked(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let p = 0;
+  const u32 = () => {
+    const v = view.getUint32(p, true);
+    p += 4;
+    return v;
+  };
+  const strCount = u32();
+  const strings = new Array(strCount);
+  for (let i = 0;i < strCount; i++) {
+    const n = u32();
+    strings[i] = fastDecodeUtf8(bytes.subarray(p, p + n));
+    p += n;
+  }
+  const treeLen = u32();
+  const end = p + treeLen;
+  let root;
+  const frames = [];
+  const popFrame = () => {
+    const f = frames.pop();
+    if (f === undefined)
+      throw new Error("json parse: malformed packed stream");
+    return f;
+  };
+  const attach = (v) => {
+    const f = frames[frames.length - 1];
+    if (f === undefined) {
+      root = v;
+      return;
+    }
+    if (f.isObj)
+      f.obj[f.key] = v;
+    else
+      f.arr.push(v);
+  };
+  while (p < end) {
+    const t = view.getUint8(p);
+    p += 1;
+    switch (t) {
+      case TAG_NULL:
+        attach(null);
+        break;
+      case TAG_FALSE:
+        attach(false);
+        break;
+      case TAG_TRUE:
+        attach(true);
+        break;
+      case TAG_NUMBER: {
+        const v = view.getFloat64(p, true);
+        p += 8;
+        attach(v);
+        break;
+      }
+      case TAG_STRING:
+        attach(strings[u32()]);
+        break;
+      case TAG_ARRAY_START:
+        frames.push({ isObj: false, arr: [], obj: {}, key: "" });
+        break;
+      case TAG_OBJECT_START:
+        frames.push({ isObj: true, arr: [], obj: {}, key: "" });
+        break;
+      case TAG_ARRAY_END:
+        attach(popFrame().arr);
+        break;
+      case TAG_OBJECT_END:
+        attach(popFrame().obj);
+        break;
+      case TAG_KEY: {
+        const f = frames[frames.length - 1];
+        f.key = strings[u32()];
+        break;
       }
-      return w;
+      default:
+        throw new Error("json parse: malformed packed token");
     }
-  };
+  }
+  if (p !== end || frames.length !== 0) {
+    throw new Error("json parse: malformed packed stream");
+  }
+  return root;
 }
+var TAG_NULL = 0, TAG_FALSE = 1, TAG_TRUE = 2, TAG_NUMBER = 3, TAG_STRING = 4, TAG_ARRAY_START = 5, TAG_OBJECT_START = 6, TAG_ARRAY_END = 7, TAG_OBJECT_END = 8, TAG_KEY = 9, bunFfiCodec2;
+var init_json_packed = __esm(() => {
+  init_codec2();
+  init_runtime();
+});
+
+// src/native/ffi/build/parse-selftest.ts
 function selfTestParse(b) {
   const enc = { encode: encodeUtf8 };
   const dec = { decode: decodeUtf8 };
@@ -2096,105 +2594,10 @@ data: hello
   }
   return true;
 }
-var sseMemoEvent, sseMemoId;
-var init_parse = __esm(() => {
+var init_parse_selftest = __esm(() => {
   init_json_packed();
   init_codec2();
   init_constants();
-  init_util();
-  sseMemoEvent = { str: null, bytes: EMPTY_VIEW };
-  sseMemoId = { str: null, bytes: EMPTY_VIEW };
-});
-
-// src/native/ffi/build/task.ts
-function buildTask(sym, ctx) {
-  const { lenOrView } = ctx;
-  const init = sym.castrum_task_init;
-  const submit = sym.castrum_task_submit;
-  const submitOut = sym.castrum_task_submit_out;
-  const submitSlice = sym.castrum_task_submit_slice;
-  const drain = sym.castrum_task_drain;
-  const pending = sym.castrum_task_pending;
-  const cancel = sym.castrum_task_cancel;
-  const setDoorbell = sym.castrum_task_set_doorbell;
-  const shutdown = sym.castrum_task_shutdown;
-  const threads = sym.castrum_task_threads;
-  return {
-    taskInit: (n) => Number(init(n)),
-    taskSubmit: (op, args, taskId) => Number(submit(op, args, lenOrView(args), taskId)),
-    taskSubmitOut: (op, args, taskId, output) => Number(submitOut(op, args, lenOrView(args), taskId, output, lenOrView(output))),
-    taskSubmitSlice: (op, hdr, data, taskId) => Number(submitSlice(op, hdr, lenOrView(hdr), data, lenOrView(data), taskId)),
-    taskDrain: (output) => Number(drain(output, lenOrView(output))),
-    taskPending: () => Number(pending()),
-    taskCancel: (taskId) => Number(cancel(taskId)),
-    taskSetDoorbell: (ptr) => Number(setDoorbell(ptr)),
-    taskShutdown: () => Number(shutdown()),
-    taskThreads: () => Number(threads())
-  };
-}
-function selfTestTask(b) {
-  try {
-    if (typeof b.taskPending() !== "number")
-      return false;
-    if (typeof b.taskThreads() !== "number" || b.taskThreads() < 0)
-      return false;
-    if (b.taskSetDoorbell(0) !== 1)
-      return false;
-    if (typeof b.taskDrain(new Uint8Array(4)) !== "number")
-      return false;
-    if (typeof b.taskSubmitOut !== "function")
-      return false;
-    if (typeof b.taskSubmitSlice !== "function")
-      return false;
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/native/ffi/build.ts
-function build(sym, useBufferLength) {
-  const oneArg = (raw, v) => useBufferLength ? raw(v, v) : raw(v, v.length);
-  const lenOrView = (v) => useBufferLength ? v : v.length;
-  let encodeScratch = new Uint8Array(0);
-  const scratchFor = (size) => {
-    if (encodeScratch.byteLength < size)
-      encodeScratch = new Uint8Array(size);
-    return encodeScratch;
-  };
-  const jsonSumOut = new Uint8Array(9);
-  const jsonSumView = new DataView(jsonSumOut.buffer);
-  const dateScratch = new Uint8Array(9);
-  const dateScratchView = new DataView(dateScratch.buffer);
-  const rateScratch = new Uint8Array(13);
-  const rateScratchView = new DataView(rateScratch.buffer);
-  const ctx = {
-    useBufferLength,
-    lenOrView,
-    oneArg,
-    scratchFor,
-    jsonSumOut,
-    jsonSumView,
-    dateScratch,
-    dateScratchView,
-    rateScratch,
-    rateScratchView
-  };
-  return {
-    ...buildCodecs(sym, ctx),
-    ...buildCompress(sym, ctx),
-    ...buildParse(sym, ctx),
-    ...buildInstances(sym, ctx),
-    ...buildMetrics(sym, ctx),
-    ...buildTask(sym, ctx)
-  };
-}
-var init_build = __esm(() => {
-  init_codecs();
-  init_compress();
-  init_instances();
-  init_metrics();
-  init_parse();
 });
 
 // src/native/ffi/selftest.ts
@@ -2202,11 +2605,11 @@ function selfTest(b) {
   return selfTestCodecs(b) && selfTestCompress(b) && selfTestParse(b) && selfTestInstances(b) && selfTestMetrics(b) && selfTestTask(b);
 }
 var init_selftest = __esm(() => {
-  init_codecs();
+  init_codecs_selftest();
   init_compress();
-  init_instances();
+  init_instances_selftest();
   init_metrics();
-  init_parse();
+  init_parse_selftest();
 });
 
 // src/native/loader.ts
@@ -2366,6 +2769,12 @@ function getBunFFI() {
   cached = bind();
   return cached;
 }
+function ffiAddonPath() {
+  if (cached === undefined) {
+    getBunFFI();
+  }
+  return boundAddonPath;
+}
 function probeBufferLength(dlopen, path) {
   try {
     const { symbols, close } = dlopen(path, {
@@ -2396,361 +2805,10 @@ function bind(forcedPath, tried = []) {
   }
   const path = forcedPath ?? getAddonPath();
   try {
-    const { dlopen } = __require("bun:ffi");
-    const useBufferLength = probeBufferLength(dlopen, path);
-    bufferAbiMode = useBufferLength ? "buffer-pair" : "ptr-len";
-    const inputAbi = useBufferLength ? ["buffer", "buffer_length"] : ["ptr", "usize"];
-    const abi = (shape) => {
-      if (!useBufferLength)
-        return shape;
-      const out = [];
-      for (let i = 0;i < shape.length; i++) {
-        const t = shape[i];
-        if (t === "ptr") {
-          out.push("buffer");
-          out.push("buffer_length");
-          i++;
-        } else {
-          out.push(t);
-        }
-      }
-      return out;
-    };
-    const U64_FAST = "u64_fast";
-    const { symbols } = dlopen(path, {
-      castrum_crc32: { args: inputAbi, returns: "u32" },
-      castrum_fnv1a64: { args: inputAbi, returns: "u64" },
-      castrum_xxh3: { args: inputAbi, returns: "u64" },
-      castrum_json_valid: { args: inputAbi, returns: "u8" },
-      castrum_utf8_valid: { args: inputAbi, returns: "u8" },
-      castrum_hex_encode: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
-      castrum_hex_decode: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
-      castrum_url_encode: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
-      castrum_url_decode: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
-      castrum_validate_email: { args: ["cstring"], returns: "u8" },
-      castrum_validate_uuid: { args: ["cstring"], returns: "u8" },
-      castrum_validate_ipv4: { args: ["cstring"], returns: "u8" },
-      castrum_validate_ipv6: { args: ["cstring"], returns: "u8" },
-      castrum_validate_email_bytes: { args: inputAbi, returns: "u8" },
-      castrum_validate_uuid_bytes: { args: inputAbi, returns: "u8" },
-      castrum_validate_ipv4_bytes: { args: inputAbi, returns: "u8" },
-      castrum_validate_ipv6_bytes: { args: inputAbi, returns: "u8" },
-      castrum_json_sum_ids: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
-      castrum_hmac_sha256_verify: {
-        args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
-        returns: "u8"
-      },
-      castrum_csrf_verify: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: "u8" },
-      castrum_password_verify: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: "u8" },
-      castrum_password_verify_bcrypt: {
-        args: abi(["ptr", "usize", "cstring"]),
-        returns: "u8"
-      },
-      castrum_ws_accept_key: { args: ["cstring"], returns: "cstring" },
-      castrum_ws_accept_key_into: {
-        args: abi(["ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_etag: { args: abi(["ptr", "usize", "u8"]), returns: "cstring" },
-      castrum_etag_into: { args: abi(["ptr", "usize", "u8", "ptr", "usize"]), returns: U64_FAST },
-      castrum_conditional_is_not_modified: {
-        args: abi(["usize", "ptr", "usize", "ptr", "usize", "u8"]),
-        returns: "u8"
-      },
-      castrum_media_type_matcher_matches: {
-        args: abi(["usize", "ptr", "usize"]),
-        returns: "u8"
-      },
-      castrum_accept_negotiator_negotiate: {
-        args: abi(["usize", "ptr", "usize"]),
-        returns: "cstring"
-      },
-      castrum_accept_negotiator_negotiate_server: {
-        args: ["usize", "cstring"],
-        returns: "cstring"
-      },
-      castrum_jwt_signer_sign: {
-        args: abi(["usize", "ptr", "usize", "i64", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_jwt_signer_verify: {
-        args: abi(["usize", "ptr", "usize", "i64", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_template_render: {
-        args: abi(["usize", "ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_schema_validator_validate: {
-        args: abi(["usize", "ptr", "usize"]),
-        returns: "u8"
-      },
-      castrum_rate_limiter_check: {
-        args: abi(["usize", "cstring", "i64", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_rate_limiter_check_key: {
-        args: abi(["usize", "i64", "i64", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_random_token: { args: ["u32"], returns: "cstring" },
-      castrum_random_token_into: { args: ["u32", ...abi(["ptr", "usize"])], returns: U64_FAST },
-      castrum_base64_encode: {
-        args: abi(["ptr", "usize", "ptr", "usize", "u8", "u8"]),
-        returns: U64_FAST
-      },
-      castrum_base64_decode: {
-        args: abi(["ptr", "usize", "ptr", "usize", "u8", "u8"]),
-        returns: U64_FAST
-      },
-      castrum_hmac_sha256: {
-        args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_sign_cookie: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: "cstring" },
-      castrum_sign_cookie_into: {
-        args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_verify_cookie: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: "cstring" },
-      castrum_verify_cookie_into: {
-        args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_csrf_token: { args: abi(["ptr", "usize"]), returns: "cstring" },
-      castrum_csrf_token_into: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
-      castrum_password_hash: {
-        args: abi(["ptr", "usize", "ptr", "usize", "u32", "u32", "u32", "u32", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_password_hash_bcrypt: {
-        args: abi(["ptr", "usize", "u32", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_pbkdf2_sha256: {
-        args: abi(["ptr", "usize", "ptr", "usize", "u32", "u32", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_aead_encrypt: {
-        args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize", "u8", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_aead_decrypt: {
-        args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize", "u8", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_ws_frame_encode: {
-        args: abi(["u8", "ptr", "usize", "u8", "u8", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_json_patch: {
-        args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_gzip_compress: {
-        args: abi(["ptr", "usize", "u32", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_gzip_decompress: {
-        args: abi(["ptr", "usize", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_brotli_compress: {
-        args: abi(["ptr", "usize", "u32", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_brotli_decompress: {
-        args: abi(["ptr", "usize", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_gzip_isize: { args: abi(["ptr", "usize"]), returns: "u32" },
-      castrum_http_parse_request_packed: {
-        args: abi(["ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_query_parse_packed: {
-        args: abi(["ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_cookie_parse_packed: {
-        args: abi(["ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_http_date_into: { args: ["f64", ...abi(["ptr", "usize"])], returns: U64_FAST },
-      castrum_sse_encode_into: {
-        args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize", "u8", "u32", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_jwt_sign_bytes: {
-        args: abi(["ptr", "usize", "ptr", "usize", "i64", "i64"]),
-        returns: "cstring"
-      },
-      castrum_jwt_sign_bytes_into: {
-        args: abi(["ptr", "usize", "ptr", "usize", "i64", "i64", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_ed25519_generate_keypair: {
-        args: abi(["ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_ed25519_sign: {
-        args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_ed25519_verify: {
-        args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
-        returns: "u32"
-      },
-      castrum_jwt_eddsa_sign: {
-        args: abi(["ptr", "usize", "ptr", "usize", "i64", "i64"]),
-        returns: "cstring"
-      },
-      castrum_jwt_eddsa_verify: {
-        args: abi(["ptr", "usize", "ptr", "usize", "i64"]),
-        returns: "cstring"
-      },
-      castrum_ws_frame_decode_packed: {
-        args: abi(["ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_multipart_parse_packed: {
-        args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_form_parse_packed: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
-      castrum_json_parse_packed: {
-        args: abi(["ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_parse_media_type: {
-        args: abi(["ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_parse_http_date: {
-        args: abi(["ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_parse_accept_encoding: {
-        args: abi(["ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_url_encode_query: { args: abi(["ptr", "usize"]), returns: "cstring" },
-      castrum_url_resolve: {
-        args: abi(["ptr", "usize", "ptr", "usize"]),
-        returns: "cstring"
-      },
-      castrum_url_builder_resolve: {
-        args: abi(["usize", "ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_mime_from_extension: { args: ["cstring"], returns: "cstring" },
-      castrum_jwt_verify: {
-        args: abi(["ptr", "usize", "ptr", "usize", "i64"]),
-        returns: "cstring"
-      },
-      castrum_ingress_handle_packed: {
-        args: abi(["usize", "ptr", "usize", "ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_ingress_handle_components: {
-        args: abi([
-          "usize",
-          "u8",
-          "cstring",
-          "cstring",
-          "ptr",
-          "usize",
-          "ptr",
-          "usize",
-          "ptr",
-          "usize",
-          "ptr",
-          "usize"
-        ]),
-        returns: U64_FAST
-      },
-      castrum_ingress_layout: { args: abi(["ptr", "usize"]), returns: U64_FAST },
-      castrum_route_compile: { args: abi(["ptr", "usize"]), returns: U64_FAST },
-      castrum_route_run: {
-        args: abi(["usize", "ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_route_destroy: { args: ["usize"], returns: "void" },
-      castrum_hex_validate_batch: {
-        args: abi(["ptr", "usize", "u32", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_regex_escape: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
-      castrum_metrics_create: { args: [], returns: U64_FAST },
-      castrum_metrics_counter: { args: ["usize", "cstring", "cstring"], returns: "u32" },
-      castrum_metrics_gauge: { args: ["usize", "cstring", "cstring"], returns: "u32" },
-      castrum_metrics_histogram: {
-        args: ["usize", "cstring", "cstring", "cstring"],
-        returns: "u32"
-      },
-      castrum_metrics_record: {
-        args: abi(["usize", "u32", "ptr", "usize", "f64"]),
-        returns: "u8"
-      },
-      castrum_metrics_gauge_set: {
-        args: abi(["usize", "u32", "ptr", "usize", "f64"]),
-        returns: "u8"
-      },
-      castrum_metrics_record_str: {
-        args: ["usize", "u32", "cstring", "f64"],
-        returns: "u8"
-      },
-      castrum_metrics_gauge_set_str: {
-        args: ["usize", "u32", "cstring", "f64"],
-        returns: "u8"
-      },
-      castrum_regex_escape_str: { args: ["cstring"], returns: "cstring" },
-      castrum_hex_validate_batch_str: {
-        args: abi(["cstring", "u32", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_metrics_render: { args: abi(["usize", "ptr", "usize"]), returns: U64_FAST },
-      castrum_metrics_snapshot: { args: abi(["usize", "ptr", "usize"]), returns: U64_FAST },
-      castrum_metrics_record_batch: {
-        args: abi(["usize", "ptr", "usize"]),
-        returns: "u8"
-      },
-      castrum_query_validate: { args: ["usize", "cstring"], returns: "u8" },
-      castrum_cookie_validate: { args: ["usize", "cstring"], returns: "u8" },
-      castrum_session_seal: {
-        args: ["cstring", "cstring", "i64", "cstring"],
-        returns: "cstring"
-      },
-      castrum_session_open: {
-        args: abi(["cstring", "cstring", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_session_seal_bytes: {
-        args: abi(["ptr", "usize", "ptr", "usize", "i64", "ptr", "usize"]),
-        returns: "cstring"
-      },
-      castrum_session_open_bytes: {
-        args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_task_init: { args: ["u32"], returns: "u32" },
-      castrum_task_submit: { args: abi(["u32", "ptr", "usize", "usize"]), returns: "u32" },
-      castrum_task_submit_slice: {
-        args: abi(["u32", "ptr", "usize", "ptr", "usize", "usize"]),
-        returns: "u32"
-      },
-      castrum_task_submit_out: {
-        args: abi(["u32", "ptr", "usize", "usize", "ptr", "usize"]),
-        returns: "u32"
-      },
-      castrum_task_drain: { args: abi(["ptr", "usize"]), returns: U64_FAST },
-      castrum_task_pending: { args: [], returns: "u32" },
-      castrum_task_cancel: { args: ["usize"], returns: "u32" },
-      castrum_task_set_doorbell: { args: ["ptr"], returns: "u32" },
-      castrum_task_shutdown: { args: [], returns: "u32" },
-      castrum_task_threads: { args: [], returns: "u32" },
-      castrum_metrics_destroy: { args: ["usize"], returns: "void" }
-    });
+    const { dlopen } = __require("bun:ffi");
+    const useBufferLength = probeBufferLength(dlopen, path);
+    bufferAbiMode = useBufferLength ? "buffer-pair" : "ptr-len";
+    const { symbols } = dlopen(path, buildFFISymbolMap(useBufferLength));
     const bindings = build(symbols, useBufferLength);
     if (!selfTest(bindings)) {
       throw new Error(`bun:ffi bind-time self-test failed on ${path}`);
@@ -3425,24 +3483,53 @@ var init_wire = __esm(() => {
 });
 
 // src/shared/packed/parsers.ts
-function parseQueryString(query) {
-  const packed = addon2.queryParsePacked(encoder.encode(query));
+function scratchFor(kind, input) {
+  const need = input.length * 9 + 16;
+  let s = ffiCaches[kind];
+  if (s === null || s.length < need) {
+    s = new Uint8Array(need);
+    ffiCaches[kind] = s;
+  }
+  return s;
+}
+function parsePackedInto(kind, input) {
+  const f = getBunFFI();
+  if (!f)
+    return null;
+  const out = scratchFor(kind, input);
+  const w = kind === "query" ? f.queryParsePackedInto(input, out) : kind === "cookie" ? f.cookieParsePackedInto(input, out) : f.formParsePackedInto(input, out);
+  if (w === 0 || w > out.length)
+    return null;
+  return pairsToObject(readPairsPacked(out.subarray(0, w)));
+}
+function parseVia(kind, input) {
+  const fast = parsePackedInto(kind, input);
+  if (fast)
+    return fast;
+  const packed = kind === "query" ? addon2.queryParsePacked(input) : kind === "cookie" ? addon2.cookieParsePacked(input) : addon2.formParsePacked(input);
   return pairsToObject(readPairsPacked(packed));
 }
+function parseQueryString(query) {
+  return parseVia("query", encoder.encode(query));
+}
 function parseCookieHeader(header) {
-  const packed = addon2.cookieParsePacked(encoder.encode(header));
-  return pairsToObject(readPairsPacked(packed));
+  return parseVia("cookie", encoder.encode(header));
 }
 function parseFormBody(body) {
-  const packed = addon2.formParsePacked(body);
-  return pairsToObject(readPairsPacked(packed));
+  return parseVia("form", body);
 }
-var addon2;
+var addon2, ffiCaches;
 var init_parsers = __esm(() => {
+  init_ffi();
   init_native();
   init_bytes();
   init_wire();
   addon2 = lazyAddon(getAddon);
+  ffiCaches = {
+    query: null,
+    cookie: null,
+    form: null
+  };
 });
 
 // src/shared/packed/schema.ts
@@ -3507,6 +3594,11 @@ function asNumber(value) {
   }
   return 0;
 }
+function assertNonEmptySecret(secret, op) {
+  if (secret.byteLength === 0) {
+    throw new Error(`${op}: secret must not be empty`);
+  }
+}
 function normalizeExt(ext) {
   let s;
   try {
@@ -3525,6 +3617,24 @@ var init_options = __esm(() => {
 });
 
 // src/rust-ffi/context.ts
+function evictOldestHalf(map) {
+  if (map.size < MIME_CACHE_MAX)
+    return [];
+  const drop = Math.ceil(map.size / 2);
+  const dropped = [];
+  for (const key of map.keys()) {
+    if (dropped.length >= drop)
+      break;
+    dropped.push(key);
+  }
+  for (const key of dropped)
+    map.delete(key);
+  return dropped;
+}
+function clearMimeCaches() {
+  mimeByText.clear();
+  mimeStrCache.clear();
+}
 function resolveNative(ctx, name) {
   let f = nativeFnCache.get(name);
   if (f === undefined) {
@@ -3553,7 +3663,6 @@ function memoizeFfi(transport) {
   };
 }
 function createContext(options) {
-  const mimeByText = new Map;
   const hmacSigners = new WeakMap;
   const state = {
     mimeCache: options.mimeCache !== false,
@@ -3583,6 +3692,7 @@ function createContext(options) {
     const key = normalizeExt(ext);
     let val = mimeByText.get(key);
     if (!val) {
+      evictOldestHalf(mimeByText);
       val = addon.mimeFromExtension(ext);
       mimeByText.set(key, val);
     }
@@ -3603,7 +3713,6 @@ function createContext(options) {
     addon,
     runtime: runtimeNative,
     state,
-    mimeByText,
     hmacSigners,
     ensurePool,
     isPoolInitialized,
@@ -3613,12 +3722,14 @@ function createContext(options) {
     hmacSigner
   };
 }
-var nativeFnCache;
+var nativeFnCache, MIME_CACHE_MAX = 1024, mimeByText, mimeStrCache;
 var init_context = __esm(() => {
   init_native2();
   init_addon();
   init_options();
   nativeFnCache = new Map;
+  mimeByText = new Map;
+  mimeStrCache = new Map;
 });
 
 // src/rust-ffi/batch/build.ts
@@ -3674,17 +3785,29 @@ function buildBatch(ctx) {
     gzipDecompress: (items, maxDecompressed) => via(ctx, "gzipDecompressBatchPacked", unpackByteResults, [maxDecompressed ?? null])(items),
     brotliCompress: (items, quality) => via(ctx, "brotliCompressBatchPacked", unpackByteResults, [quality ?? null])(items),
     brotliDecompress: (items, maxDecompressed) => via(ctx, "brotliDecompressBatchPacked", unpackByteResults, [maxDecompressed ?? null])(items),
-    jwtVerify: (tokens, secret, nowSeconds) => via(ctx, "jwtVerifyBatchPacked", unpackBitset, [secret, nowSeconds])(tokens),
-    hmacSha256: (items, key) => via(ctx, "hmacSha256BatchPacked", unpackByteResults, [key])(items),
-    hmacSha256Verify: (items, sigs, key) => via2(ctx, "hmacSha256VerifyBatchPacked", unpackBitset, [key])(items, sigs),
+    jwtVerify: (tokens, secret, nowSeconds) => {
+      assertNonEmptySecret(secret, "batch.jwtVerify");
+      return via(ctx, "jwtVerifyBatchPacked", unpackBitset, [secret, nowSeconds])(tokens);
+    },
+    hmacSha256: (items, key) => {
+      assertNonEmptySecret(key, "batch.hmacSha256");
+      return via(ctx, "hmacSha256BatchPacked", unpackByteResults, [key])(items);
+    },
+    hmacSha256Verify: (items, sigs, key) => {
+      assertNonEmptySecret(key, "batch.hmacSha256Verify");
+      return via2(ctx, "hmacSha256VerifyBatchPacked", unpackBitset, [key])(items, sigs);
+    },
     passwordVerify: (items, phcs) => via2(ctx, "passwordVerifyBatchPacked", unpackBitset)(items, phcs),
     urlResolve: (bases, references) => via2(ctx, "urlResolveBatchPacked", unpackByteResults)(bases, references),
     templateRender: (source, contexts) => via(ctx, "templateRenderBatchPacked", unpackByteResults, [source])(contexts),
-    jwtSign: (items, secret, ttlSeconds, nowSeconds) => via(ctx, "jwtSignBatchPacked", unpackByteResults, [
-      secret,
-      ttlSeconds ?? null,
-      nowSeconds ?? Math.floor(Date.now() / 1000)
-    ])(items),
+    jwtSign: (items, secret, ttlSeconds, nowSeconds) => {
+      assertNonEmptySecret(secret, "batch.jwtSign");
+      return via(ctx, "jwtSignBatchPacked", unpackByteResults, [
+        secret,
+        ttlSeconds ?? null,
+        nowSeconds ?? Math.floor(Date.now() / 1000)
+      ])(items);
+    },
     sseEncode: (items, event, id, retry) => via(ctx, "sseEncodeBatchPacked", unpackByteResults, [
       event ?? null,
       id ?? null,
@@ -3698,6 +3821,7 @@ function buildBatch(ctx) {
 var init_build2 = __esm(() => {
   init_packed();
   init_context();
+  init_options();
 });
 
 // src/rust-ffi/batch/index.ts
@@ -3959,18 +4083,22 @@ function buildCrypto(ctx) {
       return writeInto("verify cookie", output, value);
     },
     csrfToken(secret) {
+      assertNonEmptySecret(secret, "csrfToken");
       return resolveNative(ctx, "csrfToken")(secret);
     },
     csrfTokenInto(secret, output) {
+      assertNonEmptySecret(secret, "csrfTokenInto");
       const f = ffi();
       if (f)
         return f.csrfTokenInto(secret, output);
       return writeInto("csrf token", output, addon.csrfToken(secret));
     },
     csrfVerify(token, secret) {
+      assertNonEmptySecret(secret, "csrfVerify");
       return resolveNative(ctx, "csrfVerify")(token, secret);
     },
     jwtSign(claims, secret, ttlSeconds, nowSeconds) {
+      assertNonEmptySecret(secret, "jwtSign");
       const f = ffi();
       if (f) {
         const token = f.jwtSignBytes(encoder.encode(JSON.stringify(claims)), secret, ttlSeconds ?? 0, nowSeconds ?? Math.floor(Date.now() / 1000));
@@ -3979,6 +4107,7 @@ function buildCrypto(ctx) {
       return addon.jwtSign(claims, secret, ttlSeconds ?? null, nowSeconds ?? Math.floor(Date.now() / 1000));
     },
     jwtSignBytes(claimsJson, secret, ttlSeconds, nowSeconds) {
+      assertNonEmptySecret(secret, "jwtSignBytes");
       const f = ffi();
       if (f) {
         return f.jwtSignBytes(claimsJson, secret, ttlSeconds ?? 0, nowSeconds ?? Math.floor(Date.now() / 1000));
@@ -3986,6 +4115,7 @@ function buildCrypto(ctx) {
       return addon.jwtSignBytes(claimsJson, secret, ttlSeconds ?? null, nowSeconds ?? Math.floor(Date.now() / 1000));
     },
     jwtSignBytesInto(claimsJson, secret, output, ttlSeconds, nowSeconds) {
+      assertNonEmptySecret(secret, "jwtSignBytesInto");
       const f = ffi();
       if (f) {
         return f.jwtSignBytesInto(claimsJson, secret, ttlSeconds ?? 0, nowSeconds ?? Math.floor(Date.now() / 1000), output);
@@ -3993,6 +4123,7 @@ function buildCrypto(ctx) {
       return writeInto("jwt sign", output, addon.jwtSignBytes(claimsJson, secret, ttlSeconds ?? null, nowSeconds ?? Math.floor(Date.now() / 1000)));
     },
     jwtVerify(token, secret, nowSeconds) {
+      assertNonEmptySecret(secret, "jwtVerify");
       const f = ffi();
       if (f) {
         const claims = f.jwtVerify(token, secret, nowSeconds ?? Math.floor(Date.now() / 1000));
@@ -4053,9 +4184,17 @@ function buildCrypto(ctx) {
 var init_crypto = __esm(() => {
   init_bytes();
   init_context();
+  init_options();
 });
 
 // src/rust-ffi/scalar/factories.ts
+function handlePtr(inner) {
+  const v = inner ?? 0n;
+  if (v < 0n || v > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new Error("castrum: native handle exceeds Number.MAX_SAFE_INTEGER");
+  }
+  return Number(v);
+}
 function ffiHmacSigner(key, ffi) {
   return {
     sign(data) {
@@ -4236,47 +4375,55 @@ function ffiFormParser(ffi) {
   };
 }
 function ffiMetricsRegistry(ffi) {
-  const handle = ffi.metricsCreate();
+  let handle = ffi.metricsCreate();
+  const live = () => {
+    if (handle === 0)
+      throw new Error("metrics registry: already destroyed");
+    return handle;
+  };
   return {
     counter(name, labelKeys) {
-      return ffi.metricsCounter(handle, name, (labelKeys ?? []).join("\x1F"));
+      return ffi.metricsCounter(live(), name, (labelKeys ?? []).join("\x1F"));
     },
     gauge(name, labelKeys) {
-      return ffi.metricsGauge(handle, name, (labelKeys ?? []).join("\x1F"));
+      return ffi.metricsGauge(live(), name, (labelKeys ?? []).join("\x1F"));
     },
     histogram(name, labelKeys, buckets) {
-      return ffi.metricsHistogram(handle, name, (labelKeys ?? []).join("\x1F"), (buckets ?? []).join(","));
+      return ffi.metricsHistogram(live(), name, (labelKeys ?? []).join("\x1F"), (buckets ?? []).join(","));
     },
     record(series, values, amount) {
       const joined = (values ?? []).join("\x1F");
-      if (!ffi.metricsRecordStr(handle, series, joined, amount ?? 1)) {
+      if (!ffi.metricsRecordStr(live(), series, joined, amount ?? 1)) {
         throw new Error("metrics record: unknown series / arity mismatch / invalid amount");
       }
     },
     gaugeSet(series, values, value) {
       const joined = (values ?? []).join("\x1F");
-      if (!ffi.metricsGaugeSetStr(handle, series, joined, value)) {
+      if (!ffi.metricsGaugeSetStr(live(), series, joined, value)) {
         throw new Error("metrics gauge set: unknown series / arity mismatch");
       }
     },
     render() {
       let out = new Uint8Array(8192);
-      let w = ffi.metricsRender(handle, out);
+      let w = ffi.metricsRender(live(), out);
       if (w > out.length) {
         out = new Uint8Array(w);
-        w = ffi.metricsRender(handle, out);
+        w = ffi.metricsRender(live(), out);
       }
       return decodeUtf8(out.subarray(0, w));
     },
     destroy() {
-      ffi.metricsDestroy(handle);
+      if (handle !== 0) {
+        ffi.metricsDestroy(handle);
+        handle = 0;
+      }
     },
     snapshot() {
       let out = new Uint8Array(4096);
-      let w = ffi.metricsSnapshot(handle, out);
+      let w = ffi.metricsSnapshot(live(), out);
       if (w > out.length) {
         out = new Uint8Array(w);
-        w = ffi.metricsSnapshot(handle, out);
+        w = ffi.metricsSnapshot(live(), out);
       }
       return out.subarray(0, w);
     }
@@ -4290,11 +4437,12 @@ function buildFactories(ctx) {
       const ffi = transport.ffi;
       if (ffi) {
         const napi = new addon.SchemaValidator(schema);
-        return ffiSchemaValidator(napi, Number(napi.innerPtr?.() ?? 0n), ffi);
+        return ffiSchemaValidator(napi, handlePtr(napi.innerPtr?.()), ffi);
       }
       return new addon.SchemaValidator(schema);
     },
     createHmacSigner(key) {
+      assertNonEmptySecret(key, "createHmacSigner");
       const ffi = transport.ffi;
       if (ffi)
         return ffiHmacSigner(key, ffi);
@@ -4304,7 +4452,7 @@ function buildFactories(ctx) {
       const ffi = transport.ffi;
       if (ffi) {
         const napi = new addon.TemplateRenderer(source);
-        return ffiTemplateRenderer(napi, Number(napi.innerPtr?.() ?? 0n), ffi);
+        return ffiTemplateRenderer(napi, handlePtr(napi.innerPtr?.()), ffi);
       }
       return new addon.TemplateRenderer(source);
     },
@@ -4321,7 +4469,7 @@ function buildFactories(ctx) {
       const ffi = transport.ffi;
       if (ffi) {
         const napi = new addon.ConditionalRequest(etagValue, lastModifiedSecs ?? undefined);
-        return ffiConditionalRequest(napi, Number(napi.innerPtr?.() ?? 0n), ffi);
+        return ffiConditionalRequest(napi, handlePtr(napi.innerPtr?.()), ffi);
       }
       return new addon.ConditionalRequest(etagValue, lastModifiedSecs ?? undefined);
     },
@@ -4329,7 +4477,7 @@ function buildFactories(ctx) {
       const ffi = transport.ffi;
       if (ffi) {
         const napi = new addon.AcceptNegotiator(supported);
-        return ffiAcceptNegotiator(napi, Number(napi.innerPtr?.() ?? 0n), ffi);
+        return ffiAcceptNegotiator(napi, handlePtr(napi.innerPtr?.()), ffi);
       }
       return new addon.AcceptNegotiator(supported);
     },
@@ -4340,12 +4488,14 @@ function buildFactories(ctx) {
       return new addon.Base64Codec(urlSafe ?? undefined, padding ?? undefined);
     },
     createCookieSigner(secret) {
+      assertNonEmptySecret(secret, "createCookieSigner");
       const ffi = transport.ffi;
       if (ffi)
         return ffiCookieSigner(secret, ffi);
       return new addon.CookieSigner(secret);
     },
     createCsrfProtector(secret) {
+      assertNonEmptySecret(secret, "createCsrfProtector");
       const ffi = transport.ffi;
       if (ffi)
         return ffiCsrfProtector(secret, ffi);
@@ -4355,15 +4505,16 @@ function buildFactories(ctx) {
       const ffi = transport.ffi;
       if (ffi) {
         const napi = new addon.UrlBuilder(base);
-        return ffiUrlBuilder(napi, Number(napi.innerPtr?.() ?? 0n), ffi);
+        return ffiUrlBuilder(napi, handlePtr(napi.innerPtr?.()), ffi);
       }
       return new addon.UrlBuilder(base);
     },
     createJwtSigner(secret, ttlSeconds) {
+      assertNonEmptySecret(secret, "createJwtSigner");
       const ffi = transport.ffi;
       if (ffi) {
         const napi = new addon.JwtSigner(secret, ttlSeconds ?? undefined);
-        return ffiJwtSigner(napi, Number(napi.innerPtr?.() ?? 0n), ffi);
+        return ffiJwtSigner(napi, handlePtr(napi.innerPtr?.()), ffi);
       }
       return new addon.JwtSigner(secret, ttlSeconds ?? undefined);
     },
@@ -4383,7 +4534,7 @@ function buildFactories(ctx) {
       const ffi = transport.ffi;
       if (ffi) {
         const napi = new addon.MediaTypeMatcher(expected);
-        return ffiMediaTypeMatcher(napi, Number(napi.innerPtr?.() ?? 0n), ffi);
+        return ffiMediaTypeMatcher(napi, handlePtr(napi.innerPtr?.()), ffi);
       }
       return new addon.MediaTypeMatcher(expected);
     },
@@ -4391,7 +4542,7 @@ function buildFactories(ctx) {
       const ffi = transport.ffi;
       if (ffi) {
         const napi = new addon.RateLimiter(limit, windowMs, maxEntries ?? undefined);
-        return ffiRateLimiter(napi, Number(napi.innerPtr?.() ?? 0n), ffi);
+        return ffiRateLimiter(napi, handlePtr(napi.innerPtr?.()), ffi);
       }
       return new addon.RateLimiter(limit, windowMs, maxEntries ?? undefined);
     },
@@ -4409,6 +4560,10 @@ function buildFactories(ctx) {
     },
     rayonNumThreads() {
       return asNumber(addon.rayonNumThreads());
+    },
+    clearSchemaCache() {
+      const native = addon;
+      native.clearSchemaCache?.();
     }
   };
 }
@@ -4492,37 +4647,63 @@ function ensureValidUtf8(bytes, ffi) {
 function u32LE(b, off) {
   return ((b[off] ?? 0) | (b[off + 1] ?? 0) << 8 | (b[off + 2] ?? 0) << 16 | (b[off + 3] ?? 0) << 24) >>> 0;
 }
+function keyBytesEqual(b, off, lit) {
+  for (let i = 0;i < lit.length; i++) {
+    if ((b[off + i] ?? 0) !== (lit[i] ?? 0))
+      return false;
+  }
+  return true;
+}
 function unpackMediaType(packed) {
+  const view = Buffer.from(packed.buffer, packed.byteOffset, packed.byteLength);
   let off = 0;
   const mtLen = u32LE(packed, off);
   off += 4;
-  const mediaType = decodeUtf8Range(packed, off, off + mtLen);
+  const mediaType = decodeUtf8RangeView(view, off, off + mtLen);
   off += mtLen;
   let charset = null;
   const csLen = u32LE(packed, off);
   off += 4;
   if (csLen !== 4294967295) {
-    charset = decodeUtf8Range(packed, off, off + csLen);
+    charset = decodeUtf8RangeView(view, off, off + csLen);
     off += csLen;
   }
   let boundary = null;
   const bLen = u32LE(packed, off);
   off += 4;
   if (bLen !== 4294967295) {
-    boundary = decodeUtf8Range(packed, off, off + bLen);
+    boundary = decodeUtf8RangeView(view, off, off + bLen);
     off += bLen;
   }
   const count = u32LE(packed, off);
   off += 4;
   const params = {};
+  let charsetTaken = charset === null;
+  let boundaryTaken = boundary === null;
   for (let i = 0;i < count; i++) {
     const kLen = u32LE(packed, off);
     off += 4;
-    const key = decodeUtf8Range(packed, off, off + kLen);
+    let key;
+    if (kLen === 7 && keyBytesEqual(packed, off, CHARSET_KEY_BYTES)) {
+      key = "charset";
+    } else if (kLen === 8 && keyBytesEqual(packed, off, BOUNDARY_KEY_BYTES)) {
+      key = "boundary";
+    } else {
+      key = decodeUtf8RangeView(view, off, off + kLen);
+    }
     off += kLen;
     const vLen = u32LE(packed, off);
     off += 4;
-    const val = decodeUtf8Range(packed, off, off + vLen);
+    let val;
+    if (!charsetTaken && key === "charset" && charset !== null) {
+      val = charset;
+      charsetTaken = true;
+    } else if (!boundaryTaken && key === "boundary" && boundary !== null) {
+      val = boundary;
+      boundaryTaken = true;
+    } else {
+      val = decodeUtf8RangeView(view, off, off + vLen);
+    }
     off += vLen;
     params[key] = val;
   }
@@ -4653,7 +4834,7 @@ function buildHttp(ctx) {
     queryParsePacked(input) {
       const f = ffi();
       if (f) {
-        const out = new Uint8Array(input.length * 9 + 16);
+        const out = new Uint8Array(input.length * 5 + 8);
         const w = f.queryParsePackedInto(input, out);
         return out.subarray(0, w);
       }
@@ -4665,7 +4846,7 @@ function buildHttp(ctx) {
     cookieParsePacked(input) {
       const f = ffi();
       if (f) {
-        const out = new Uint8Array(input.length * 9 + 16);
+        const out = new Uint8Array(input.length * 5 + 8);
         const w = f.cookieParsePackedInto(input, out);
         return out.subarray(0, w);
       }
@@ -4677,7 +4858,7 @@ function buildHttp(ctx) {
     formParsePacked(input) {
       const f = ffi();
       if (f) {
-        const out = new Uint8Array(input.length * 9 + 16);
+        const out = new Uint8Array(input.length * 5 + 8);
         const w = f.formParsePackedInto(input, out);
         return out.subarray(0, w);
       }
@@ -4749,13 +4930,15 @@ function buildHttp(ctx) {
     }
   };
 }
-var WS_ACCEPT_SCRATCH, f32Bits, f32BitsU32;
+var WS_ACCEPT_SCRATCH, CHARSET_KEY_BYTES, BOUNDARY_KEY_BYTES, f32Bits, f32BitsU32;
 var init_http = __esm(() => {
   init_bytes();
   init_codec2();
   init_packed();
   init_context();
   WS_ACCEPT_SCRATCH = new Uint8Array(64);
+  CHARSET_KEY_BYTES = new Uint8Array([99, 104, 97, 114, 115, 101, 116]);
+  BOUNDARY_KEY_BYTES = new Uint8Array([98, 111, 117, 110, 100, 97, 114, 121]);
   f32Bits = new Float32Array(1);
   f32BitsU32 = new Uint32Array(f32Bits.buffer);
 });
@@ -4835,6 +5018,7 @@ function buildPayload(ctx) {
   const { builtins, transport } = ctx.runtime;
   const HAS = { gzipCompress: builtins.has("gzipCompress") };
   const ffi = memoizeFfi(transport);
+  let SCRATCH = null;
   return {
     gzipCompress(data, level) {
       if (HAS.gzipCompress)
@@ -4888,8 +5072,20 @@ function buildPayload(ctx) {
     },
     multipartParse(body, boundary) {
       const f = ffi();
-      if (f)
-        return unpackMultipart(f.multipartParsePacked(body, boundary));
+      if (f) {
+        const need = body.length + boundary.length + 64;
+        if (need > 64 * 1024)
+          return unpackMultipart(f.multipartParsePacked(body, boundary));
+        if (!SCRATCH || SCRATCH.length < need)
+          SCRATCH = new Uint8Array(need);
+        let w;
+        try {
+          w = f.multipartParsePackedInto(body, boundary, SCRATCH);
+        } catch {
+          return unpackMultipart(f.multipartParsePacked(body, boundary));
+        }
+        return unpackMultipart(SCRATCH.subarray(0, w));
+      }
       return addon.multipartParse(body, boundary).map((p) => ({
         name: p.name,
         filename: p.filename ?? null,
@@ -5053,13 +5249,13 @@ var init_scalar = __esm(() => {
 // src/rust-ffi/text.ts
 function buildText(ctx) {
   const { builtins, transport } = ctx.runtime;
-  const mimeStrCache = new Map;
   return {
     mimeFromExtension(ext) {
       let mime = mimeStrCache.get(ext);
       if (mime === undefined) {
         const f = transport.ffi;
         mime = f ? f.mimeFromExtension(ext) ?? "application/octet-stream" : decoder.decode(ctx.cachedMime(encoder.encode(ext)));
+        evictOldestHalf(mimeStrCache);
         mimeStrCache.set(ext, mime);
       }
       return mime;
@@ -5318,10 +5514,13 @@ function createNativeRoute(plan = {}) {
   const parseQuery = plan.parseQuery === true;
   const parseCookies = plan.parseCookies === true;
   const bunFFI = getBunFFI();
-  const ffiHandle = bunFFI !== null ? compileFfi(bunFFI, descriptor) : 0;
-  const napiRoute = bunFFI === null ? compileNapi(descriptor) : null;
+  let ffiHandle = bunFFI !== null ? compileFfi(bunFFI, descriptor) : 0;
+  let napiRoute = bunFFI === null || ffiHandle === 0 ? compileNapi(descriptor) : null;
   let out = new Uint8Array(256);
   const runFrame = (frame) => {
+    if (ffiHandle === 0 && napiRoute === null) {
+      throw new Error("native route: already destroyed");
+    }
     let written;
     if (ffiHandle !== 0 && bunFFI !== null) {
       written = bunFFI.routeRun(ffiHandle, frame, out);
@@ -5354,7 +5553,10 @@ function createNativeRoute(plan = {}) {
     destroy: () => {
       if (ffiHandle !== 0 && bunFFI !== null) {
         bunFFI.routeDestroy(ffiHandle);
+        ffiHandle = 0;
       }
+      napiRoute?.destroy?.();
+      napiRoute = null;
     }
   };
 }
@@ -5378,6 +5580,26 @@ function compileNapi(descriptor) {
   }
 }
 
+// src/ingress/abort.ts
+var ABORT_CODE = "REQUEST_ABORTED";
+function isAbortError(err) {
+  return err?.code === ABORT_CODE;
+}
+function abortResponse() {
+  return new Response(null, { status: 499 });
+}
+
+// src/ingress/headers/memoized-headers.ts
+var CACHE = new WeakMap;
+function memoizedHeaders(entries) {
+  const existing = CACHE.get(entries);
+  if (existing !== undefined)
+    return existing;
+  const built = new Headers(entries);
+  CACHE.set(entries, built);
+  return built;
+}
+
 // src/ingress/shared.ts
 var DEFAULT_MAX_BODY_BYTES = 1048576;
 var DEFAULT_FAST_OUTPUT_BUFFER_SIZE = 262144;
@@ -5420,13 +5642,16 @@ function resolveIp(req, srv, opts) {
   return opts.getIp ? opts.getIp(req, srv) : undefined;
 }
 function buildSuccessInit(ingress, result, ctx, status = 200) {
-  return {
-    status,
-    headers: ingress.responseHeaders(result.headerVariant, ctx.requestIdHeader, ctx.origin, result.rateRemaining, result.rateResetMs > 0 ? secondsFromMs(result.rateResetMs) : undefined)
-  };
+  const rateResetSecs = result.rateResetMs > 0 ? secondsFromMs(result.rateResetMs) : undefined;
+  const headers = ingress.successHeaders ? ingress.successHeaders(result.headerVariant, ctx.requestIdHeader, ctx.origin, result.rateRemaining, rateResetSecs) : memoizedHeaders(ingress.responseHeaders(result.headerVariant, ctx.requestIdHeader, ctx.origin, result.rateRemaining, rateResetSecs));
+  return { status, headers };
 }
 function runBaked(ingress, opts, respond) {
-  return (req, srv) => ingress.run(req, resolveIp(req, srv, opts), null, respond);
+  return (req, srv) => {
+    if (req.signal?.aborted)
+      return abortResponse();
+    return ingress.run(req, resolveIp(req, srv, opts), null, respond);
+  };
 }
 // src/ingress/routes/read.ts
 function readHandler(ingress, opts = {}) {
@@ -5477,6 +5702,44 @@ function bodyTooLargeError() {
   err.code = "BODY_TOO_LARGE";
   return err;
 }
+function abortError() {
+  const err = new Error(ABORT_CODE);
+  err.code = ABORT_CODE;
+  return err;
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted)
+    throw abortError();
+}
+function createAbortGuard(signal) {
+  if (!signal)
+    return null;
+  if (signal.aborted) {
+    return { promise: Promise.reject(abortError()), cancel: () => {} };
+  }
+  let listener = null;
+  const promise = new Promise((_resolve, reject) => {
+    listener = () => reject(abortError());
+    signal.addEventListener("abort", listener, { once: true });
+  });
+  return {
+    promise,
+    cancel: () => {
+      if (listener !== null) {
+        signal.removeEventListener("abort", listener);
+        listener = null;
+      }
+    }
+  };
+}
+function raceRead(read, guards) {
+  if (guards.length === 0)
+    return read;
+  const racers = [read];
+  for (const guard of guards)
+    racers.push(guard.promise);
+  return Promise.race(racers);
+}
 var bodyWatchdog = (() => {
   const inflight = new Set;
   let timer = null;
@@ -5528,6 +5791,7 @@ function createDeadline(deadlineMs) {
   return { promise, cancel: () => bodyWatchdog.untrack(entry) };
 }
 async function readBodyWithLimit(req, maxBytes, guard, timeoutMs) {
+  throwIfAborted(req.signal);
   const deadline = timeoutMs && timeoutMs > 0 ? timeoutMs : 0;
   const declared = req.headers.get("content-length");
   if (declared !== null) {
@@ -5537,45 +5801,67 @@ async function readBodyWithLimit(req, maxBytes, guard, timeoutMs) {
         throw bodyTooLargeError();
       }
       if (deadline <= 0) {
-        const bytes = await readBodyBytes(req);
-        if (guard && bytes.byteLength > maxBytes) {
-          throw bodyTooLargeError();
+        const buffered = peekBufferedBody(req);
+        if (buffered !== false && "bytes" in buffered) {
+          throwIfAborted(req.signal);
+          if (guard && buffered.bytes.byteLength > maxBytes) {
+            throw bodyTooLargeError();
+          }
+          return buffered.bytes;
+        }
+        const abort = createAbortGuard(req.signal);
+        try {
+          const bytes = await raceRead(buffered === false ? readBodyBytes(req) : buffered, abort !== null ? [abort] : []);
+          throwIfAborted(req.signal);
+          if (guard && bytes.byteLength > maxBytes) {
+            throw bodyTooLargeError();
+          }
+          return bytes;
+        } finally {
+          abort?.cancel();
         }
-        return bytes;
       }
       const buffered = peekBufferedBody(req);
       if (buffered === false) {
         const dl = createDeadline(deadline);
+        const abort = createAbortGuard(req.signal);
         try {
-          const bytes = await Promise.race([readBodyBytes(req), dl.promise]);
+          const bytes = await raceRead(readBodyBytes(req), abort !== null ? [dl, abort] : [dl]);
+          throwIfAborted(req.signal);
           if (guard && bytes.byteLength > maxBytes) {
             throw bodyTooLargeError();
           }
           return bytes;
         } finally {
           dl.cancel();
+          abort?.cancel();
         }
       }
       if ("bytes" in buffered) {
+        throwIfAborted(req.signal);
         if (guard && buffered.bytes.byteLength > maxBytes) {
           throw bodyTooLargeError();
         }
         return buffered.bytes;
       }
       const dl = createDeadline(deadline);
+      const abort = createAbortGuard(req.signal);
       try {
-        const bytes = await Promise.race([buffered, dl.promise]);
+        const bytes = await raceRead(buffered, abort !== null ? [dl, abort] : [dl]);
+        throwIfAborted(req.signal);
         if (guard && bytes.byteLength > maxBytes) {
           throw bodyTooLargeError();
         }
         return bytes;
       } finally {
         dl.cancel();
+        abort?.cancel();
       }
     }
   }
   const body = req.body;
   if (!body) {
+    throwIfAborted(req.signal);
     return EMPTY_BODY;
   }
   const reader = body.getReader();
@@ -5583,9 +5869,15 @@ async function readBodyWithLimit(req, maxBytes, guard, timeoutMs) {
   let total = 0;
   let completed = false;
   const dl = deadline > 0 ? createDeadline(deadline) : null;
+  const abort = createAbortGuard(req.signal);
+  const guards = [];
+  if (dl !== null)
+    guards.push(dl);
+  if (abort !== null)
+    guards.push(abort);
   try {
     for (;; ) {
-      const { done, value } = dl !== null ? await Promise.race([reader.read(), dl.promise]) : await reader.read();
+      const { done, value } = await raceRead(reader.read(), guards);
       if (done) {
         completed = true;
         break;
@@ -5600,6 +5892,7 @@ async function readBodyWithLimit(req, maxBytes, guard, timeoutMs) {
     }
   } finally {
     dl?.cancel();
+    abort?.cancel();
     if (!completed) {
       await reader.cancel().catch(() => {});
     }
@@ -5802,11 +6095,25 @@ function rateLimitedBody(retryAfterMs) {
 }
 
 // src/ingress/routes/echo.ts
+var SAFE_ECHO_CONTENT_TYPES = new Set([
+  "application/json",
+  "application/octet-stream",
+  "text/plain"
+]);
+function echoMediaTypeOf(contentType) {
+  const semi = contentType.indexOf(";");
+  return (semi >= 0 ? contentType.slice(0, semi) : contentType).trim().toLowerCase();
+}
+function safeEchoContentType(contentType) {
+  return SAFE_ECHO_CONTENT_TYPES.has(echoMediaTypeOf(contentType)) ? contentType : "application/octet-stream";
+}
 function echoHandler(ingress, opts = {}) {
   const maxBodyBytes = opts.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES;
   const bodyTimeoutMs = opts.bodyTimeoutMs ?? DEFAULT_BODY_TIMEOUT_MS;
   return async (req, srv) => {
     const ip = resolveIp(req, srv, opts);
+    if (req.signal?.aborted)
+      return abortResponse();
     const prep = ingress.run(req, ip, null, (result, ctx) => {
       const terminal = ingress.terminalResponse(req, result, ctx);
       if (terminal)
@@ -5821,41 +6128,54 @@ function echoHandler(ingress, opts = {}) {
     });
     if (prep.terminal)
       return prep.terminal;
+    if (req.signal?.aborted)
+      return abortResponse();
     const baseHeaders = prep.headers ?? [];
-    const requestedContentType = req.headers.get("content-type") ?? "application/octet-stream";
+    const requestedContentType = safeEchoContentType(req.headers.get("content-type") ?? "application/octet-stream");
+    const withEchoHeaders = (contentType) => {
+      const headers = ingress.withContentType(baseHeaders, contentType);
+      if (!headers.some(([name]) => name.toLowerCase() === "x-content-type-options")) {
+        headers.push(["x-content-type-options", "nosniff"]);
+      }
+      return headers;
+    };
     const contentLengthHeader = req.headers.get("content-length");
     const contentLength = contentLengthHeader === null ? NaN : Number(contentLengthHeader);
     if (Number.isFinite(contentLength)) {
       if (contentLength > maxBodyBytes) {
         return new Response(ERROR_BODIES.body_too_large, {
           status: 413,
-          headers: ingress.withContentType(baseHeaders, "application/json")
+          headers: withEchoHeaders("application/json")
         });
       }
       if (contentLength <= 0 || req.body === null) {
         return new Response(null, {
           status: 200,
-          headers: ingress.withContentType(baseHeaders, requestedContentType)
+          headers: withEchoHeaders(requestedContentType)
         });
       }
       return new Response(req.body, {
         status: 200,
-        headers: ingress.withContentType(baseHeaders, requestedContentType)
+        headers: withEchoHeaders(requestedContentType)
       });
     }
     try {
       const bodyBytes = await readBodyWithLimit(req, maxBodyBytes, true, bodyTimeoutMs);
+      if (req.signal?.aborted)
+        return abortResponse();
       return new Response(bodyBytes.byteLength > 0 ? bodyBytes : null, {
         status: 200,
-        headers: ingress.withContentType(baseHeaders, requestedContentType)
+        headers: withEchoHeaders(requestedContentType)
       });
     } catch (err) {
+      if (isAbortError(err))
+        return abortResponse();
       const code = err?.code;
       const isTooLarge = code === "BODY_TOO_LARGE";
       const isTimeout = code === "REQUEST_TIMEOUT";
       return new Response(isTooLarge ? ERROR_BODIES.body_too_large : isTimeout ? ERROR_BODIES.request_timeout : ERROR_BODIES.bad_request, {
         status: isTooLarge ? 413 : isTimeout ? 408 : 400,
-        headers: ingress.withContentType(baseHeaders, "application/json")
+        headers: withEchoHeaders("application/json")
       });
     }
   };
@@ -5893,6 +6213,11 @@ function defaultJsonValid(bytes) {
     return false;
   }
 }
+function isJsonContentType(contentType) {
+  const semi = contentType.indexOf(";");
+  const mediaType = (semi >= 0 ? contentType.slice(0, semi) : contentType).trim().toLowerCase();
+  return mediaType === "application/json" || mediaType.endsWith("+json");
+}
 function jsonWriteHandler(ingress, opts = {}) {
   const maxBodyBytes = opts.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES;
   const fallback = opts.fallback ?? ingress;
@@ -5901,19 +6226,18 @@ function jsonWriteHandler(ingress, opts = {}) {
   const jsonValid = opts.jsonValid ?? ingress.jsonValid ?? defaultJsonValid;
   return async (req, srv) => {
     const ip = resolveIp(req, srv, opts);
+    if (req.signal?.aborted)
+      return abortResponse();
     const contentType = req.headers.get("content-type") ?? "";
-    if (!contentType.includes("application/json")) {
-      return fallback.run(req, ip, null, (result, ctx) => {
-        const terminal = fallback.terminalResponse(req, result, ctx);
-        if (terminal)
-          return terminal;
-        return fallback.errorResponse(req, result, 415, "unsupported_media_type", "Content-Type must be application/json", ctx);
-      });
+    if (!isJsonContentType(contentType)) {
+      return fallback.run(req, ip, null, (result, ctx) => fallback.errorResponse(req, result, 415, "unsupported_media_type", "Content-Type must be application/json", ctx));
     }
     let bodyBytes;
     try {
       bodyBytes = await readBodyWithLimit(req, maxBodyBytes, true, bodyTimeoutMs);
     } catch (err) {
+      if (isAbortError(err))
+        return abortResponse();
       const code = err?.code;
       const isTooLarge = code === "BODY_TOO_LARGE";
       return fallback.run(req, ip, null, (result, ctx) => {
@@ -5923,6 +6247,8 @@ function jsonWriteHandler(ingress, opts = {}) {
         return fallback.errorResponse(req, result, isTooLarge ? 413 : 408, isTooLarge ? "body_too_large" : "request_timeout", isTooLarge ? "Request body is too large" : "Request body read timed out", ctx);
       });
     }
+    if (req.signal?.aborted)
+      return abortResponse();
     return ingress.run(req, ip, bodyBytes, (result, ctx) => {
       const terminal = ingress.terminalResponse(req, result, ctx);
       if (terminal)
@@ -5944,12 +6270,16 @@ function jsonWriteHandler(ingress, opts = {}) {
 }
 // src/ingress/routes/options.ts
 function optionsHandler(ingress, opts = {}) {
-  return (req, srv) => ingress.run(req, resolveIp(req, srv, opts), null, (result, ctx) => {
-    const terminal = ingress.terminalResponse(req, result, ctx);
-    if (terminal)
-      return terminal;
-    return new Response(null, buildSuccessInit(ingress, result, ctx, 204));
-  });
+  return (req, srv) => {
+    if (req.signal?.aborted)
+      return abortResponse();
+    return ingress.run(req, resolveIp(req, srv, opts), null, (result, ctx) => {
+      const terminal = ingress.terminalResponse(req, result, ctx);
+      if (terminal)
+        return terminal;
+      return new Response(null, buildSuccessInit(ingress, result, ctx, 204));
+    });
+  };
 }
 // src/ingress/routes/responder.ts
 init_bytes();
@@ -6093,7 +6423,7 @@ function safeTerminalStatus(r) {
 }
 
 // src/ingress/routes/responder.ts
-var IGNGEX_SECURITY_HEADERS = [
+var IGNEX_SECURITY_HEADERS = [
   ["x-frame-options", "DENY"],
   ["x-content-type-options", "nosniff"],
   ["referrer-policy", "no-referrer"]
@@ -6101,7 +6431,7 @@ var IGNGEX_SECURITY_HEADERS = [
 function buildIgngexTerminal(result, _ctx) {
   const preflightAllowed = result.isPreflight && result.corsAllowed;
   if (preflightAllowed) {
-    return new Response(null, { status: 204, headers: IGNGEX_SECURITY_HEADERS });
+    return new Response(null, { status: 204, headers: IGNEX_SECURITY_HEADERS });
   }
   const status = safeTerminalStatus(result);
   const body = JSON.stringify({
@@ -6109,14 +6439,14 @@ function buildIgngexTerminal(result, _ctx) {
     status,
     code: errorCodeName(result.errorCode)
   });
-  const headers = new Headers(IGNGEX_SECURITY_HEADERS);
+  const headers = new Headers(IGNEX_SECURITY_HEADERS);
   headers.set("content-type", "application/json; charset=utf-8");
   return new Response(body, { status, headers });
 }
 function parseSection(json) {
   try {
-    const v = JSON.parse(json);
-    return v !== null && typeof v === "object" && !Array.isArray(v) ? v : {};
+    const parsed = JSON.parse(json);
+    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
   } catch {
     return {};
   }
@@ -6128,19 +6458,25 @@ function nativeResponderRoute(ingress, responder, opts = {}) {
   const bodyTimeoutMs = opts.bodyTimeoutMs ?? DEFAULT_BODY_TIMEOUT_MS;
   return async (req, srv, _params) => {
     const ip = resolveIp(req, srv, opts);
+    if (req.signal?.aborted)
+      return abortResponse();
     const requestId = decoder.decode(generateRequestId());
     let body = null;
     if (readBody) {
       try {
         body = await readBodyWithLimit(req, maxBodyBytes, true, bodyTimeoutMs);
       } catch (err) {
+        if (isAbortError(err))
+          return abortResponse();
         const code = err.code;
         const status = code === "REQUEST_TIMEOUT" ? 408 : code === "BODY_TOO_LARGE" ? 413 : 400;
         const payload = JSON.stringify({ error: "Bad Request", status, code: "BAD_REQUEST" });
-        const headers = new Headers(IGNGEX_SECURITY_HEADERS);
+        const headers = new Headers(IGNEX_SECURITY_HEADERS);
         headers.set("content-type", "application/json; charset=utf-8");
         return new Response(payload, { status, headers });
       }
+      if (req.signal?.aborted)
+        return abortResponse();
     }
     let terminal = null;
     let snapshot = null;
@@ -6175,10 +6511,30 @@ function nativeResponderRoute(ingress, responder, opts = {}) {
 }
 // src/ingress/routes/native.ts
 init_bytes();
+
+// src/ingress/routes/safe-record.ts
+var PROTO_KEY = "__proto__";
+function safeRecord() {
+  return {};
+}
+function assignOwn(target, key, value) {
+  if (key === PROTO_KEY) {
+    Object.defineProperty(target, key, {
+      value,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+    return;
+  }
+  target[key] = value;
+}
+
+// src/ingress/routes/native.ts
 function pairsToRecord(pairs) {
-  const out = {};
+  const out = safeRecord();
   for (const [k, v] of pairs)
-    out[k] = v;
+    assignOwn(out, k, v);
   return out;
 }
 function nativeRouteHandler(route, responder, opts = {}) {
@@ -6190,16 +6546,22 @@ function nativeRouteHandler(route, responder, opts = {}) {
   const terminal = (status, code, message) => Response.json({ ok: false, error: { code, message } }, { status, headers: { "content-type": "application/json" } });
   return async (req, srv, _params) => {
     const ip = resolveIp(req, srv, opts);
+    if (req.signal?.aborted)
+      return abortResponse();
     const requestId = decoder.decode(generateRequestId());
     let body = null;
     if (readBody) {
       try {
         body = await readBodyWithLimit(req, maxBodyBytes, true, bodyTimeoutMs);
       } catch (err) {
+        if (isAbortError(err))
+          return abortResponse();
         const code = err.code;
         const status = code === "REQUEST_TIMEOUT" ? 408 : code === "BODY_TOO_LARGE" ? 413 : 400;
         return terminal(status, "BAD_REQUEST", "Request body read failed");
       }
+      if (req.signal?.aborted)
+        return abortResponse();
     }
     const url = req.url;
     const qIndex = url.indexOf("?");
@@ -6235,6 +6597,49 @@ function nativeRouteHandler(route, responder, opts = {}) {
   };
 }
 
+// src/ingress/server-error.ts
+function toError(value) {
+  return value instanceof Error ? value : new Error(String(value));
+}
+var INTERNAL_HEADERS = [
+  ["content-type", "application/json; charset=utf-8"]
+];
+function createServerErrorHandler(opts) {
+  const headers = memoizedHeaders(INTERNAL_HEADERS);
+  return (error, req) => {
+    const err = toError(error);
+    if (opts.onError) {
+      try {
+        opts.onError({ error: err, request: req });
+      } catch {}
+    }
+    if (opts.logger) {
+      try {
+        opts.logger(JSON.stringify({
+          level: "error",
+          msg: "unhandled_handler_error",
+          error: err.message
+        }));
+      } catch {}
+    }
+    return new Response(ERROR_BODIES.internal, { status: 500, headers });
+  };
+}
+function guardRouteHandler(handler, onServerError) {
+  return (req, srv, params) => {
+    try {
+      const out = handler(req, srv, params);
+      const thenable = out;
+      if (thenable !== null && thenable !== undefined && typeof thenable.then === "function") {
+        return thenable.catch((e) => onServerError(e, req));
+      }
+      return out;
+    } catch (e) {
+      return onServerError(e, req);
+    }
+  };
+}
+
 // src/ingress/path-matcher.ts
 function buildPathMatcher(routes) {
   const exact = new Map;
@@ -6342,6 +6747,10 @@ function buildRouteHandlers(options) {
     getIp: options.getIp,
     copyBody: options.copyBody
   };
+  const onServerError = createServerErrorHandler({
+    onError: options.onError,
+    logger: options.logger
+  });
   const serverRoutes = {};
   for (const [path, spec] of Object.entries(options.routes)) {
     const routeOpts = {
@@ -6350,9 +6759,12 @@ function buildRouteHandlers(options) {
       bodyTimeoutMs: spec.bodyTimeoutMs
     };
     const methods = {};
-    if (spec.read) {
+    const hasStatic = spec.static !== undefined;
+    if (hasStatic) {
+      methods.GET = typeof spec.static === "function" ? guardRouteHandler(spec.static, onServerError) : spec.static;
+    } else if (spec.read) {
       if (typeof spec.read === "function") {
-        methods.GET = spec.read;
+        methods.GET = guardRouteHandler(spec.read, onServerError);
       } else {
         methods.GET = readHandler(spec.read, routeOpts);
         methods.HEAD = headHandler(spec.read, routeOpts);
@@ -6370,34 +6782,40 @@ function buildRouteHandlers(options) {
     if (spec.echo) {
       methods.POST = echoHandler(spec.echo, routeOpts);
     }
-    if (spec.cookies) {
+    if (spec.cookies && !hasStatic) {
       methods.GET = readHandler(spec.cookies, routeOpts);
     }
     if (spec.delete) {
       methods.DELETE = deleteHandler(spec.delete, routeOpts);
     }
     if (spec.responder) {
-      const responderRoute = nativeResponderRoute(spec.responder.ingress, spec.responder.handler, {
-        ...routeOpts,
-        terminalStyle: spec.responder.terminalStyle,
-        readBody: spec.responder.readBody
-      });
-      const responderMethods = spec.responder.methods ?? ["GET"];
-      for (const m of responderMethods) {
-        methods[m] = responderRoute;
+      const responderMethods = (spec.responder.methods ?? ["GET"]).filter((m) => !(hasStatic && m === "GET"));
+      if (responderMethods.length > 0) {
+        const responderRoute = nativeResponderRoute(spec.responder.ingress, spec.responder.handler, {
+          ...routeOpts,
+          terminalStyle: spec.responder.terminalStyle,
+          readBody: spec.responder.readBody
+        });
+        const guardedResponderRoute = guardRouteHandler(responderRoute, onServerError);
+        for (const m of responderMethods) {
+          methods[m] = guardedResponderRoute;
+        }
       }
     }
     if (spec.native) {
-      const nativeRoute = nativeRouteHandler(createNativeRoute(spec.native.plan), spec.native.handler, {
-        ...routeOpts,
-        readBody: spec.native.readBody
-      });
-      const nativeMethods = spec.native.methods ?? ["GET"];
-      for (const m of nativeMethods) {
-        methods[m] = nativeRoute;
+      const nativeMethods = (spec.native.methods ?? ["GET"]).filter((m) => !(hasStatic && m === "GET"));
+      if (nativeMethods.length > 0) {
+        const nativeRoute = nativeRouteHandler(createNativeRoute(spec.native.plan), spec.native.handler, {
+          ...routeOpts,
+          readBody: spec.native.readBody
+        });
+        const guardedNativeRoute = guardRouteHandler(nativeRoute, onServerError);
+        for (const m of nativeMethods) {
+          methods[m] = guardedNativeRoute;
+        }
       }
     }
-    const primary = spec.delete ?? (spec.read && typeof spec.read !== "function" ? spec.read : undefined) ?? spec.cookies ?? spec.write ?? spec.echo;
+    const primary = spec.delete ?? (!hasStatic && spec.read && typeof spec.read !== "function" ? spec.read : undefined) ?? (!hasStatic ? spec.cookies : undefined) ?? spec.write ?? spec.echo;
     if (primary) {
       methods.OPTIONS = optionsHandler(primary, routeOpts);
     }
@@ -6410,12 +6828,17 @@ function createIngressServer(options) {
     throw new TypeError("createIngressServer is Bun-only (it builds a Bun.serve config). " + "On Node.js use createIngressServerNode with the same route handlers.");
   }
   const { routes: serverRoutes, baseOpts } = buildRouteHandlers(options);
+  const onServerError = createServerErrorHandler({
+    onError: options.onError,
+    logger: options.logger
+  });
   const serverOptions = {
     hostname: options.hostname ?? "0.0.0.0",
     port: options.port,
     idleTimeout: options.idleTimeout ?? 30,
     routes: serverRoutes,
-    maxRequestBodySize: options.maxRequestBodySize ?? DEFAULT_MAX_REQUEST_BODY_SIZE
+    maxRequestBodySize: options.maxRequestBodySize ?? DEFAULT_MAX_REQUEST_BODY_SIZE,
+    error: (error, req) => onServerError(error, req)
   };
   if (options.reusePort) {
     serverOptions.reusePort = true;
@@ -6468,8 +6891,15 @@ function nodeRequestToWebRequest(req) {
   }
   const method = req.method ?? "GET";
   const bodyForbidden = method === "GET" || method === "HEAD";
-  const hasBody = Number(req.headers["content-length"] ?? 0) > 0 || req.headers["transfer-encoding"] !== undefined;
+  const hasBody = requestHasBody(req);
   const init = { method, headers };
+  const abort = new AbortController;
+  req.on("aborted", () => abort.abort());
+  req.on("close", () => {
+    if (!req.complete)
+      abort.abort();
+  });
+  init.signal = abort.signal;
   if (hasBody && !bodyForbidden) {
     init.body = Readable.toWeb(req);
     init.duplex = "half";
@@ -6512,7 +6942,7 @@ async function writeResponse(res, response) {
 }
 function drainUnreadBody(res) {
   const req = res.req;
-  if (req !== undefined && req !== null && !req.complete && hasBody(req)) {
+  if (req !== undefined && req !== null && !req.complete && requestHasBody(req)) {
     req.resume();
     res.shouldKeepAlive = false;
     if (!res.headersSent) {
@@ -6520,11 +6950,39 @@ function drainUnreadBody(res) {
     }
   }
 }
-function hasBody(req) {
+function requestHasBody(req) {
   return Number(req.headers["content-length"] ?? 0) > 0 || req.headers["transfer-encoding"] !== undefined;
 }
+var STATIC_RESPONSE_CACHE = new WeakMap;
+function materializeStaticResponse(response) {
+  let cached = STATIC_RESPONSE_CACHE.get(response);
+  if (cached === undefined) {
+    cached = (async () => {
+      const body = response.body === null ? null : new Uint8Array(await response.arrayBuffer());
+      const headers = new Headers(response.headers);
+      headers.delete("content-length");
+      headers.delete("transfer-encoding");
+      return {
+        status: response.status,
+        statusText: response.statusText,
+        headers,
+        body
+      };
+    })();
+    STATIC_RESPONSE_CACHE.set(response, cached);
+  }
+  return cached.then((c) => new Response(c.body, {
+    status: c.status,
+    statusText: c.statusText,
+    headers: new Headers(c.headers)
+  }));
+}
 function makeRequestListener(options, routes, baseOpts) {
   const matchPath = buildPathMatcher(routes);
+  const onServerError = createServerErrorHandler({
+    onError: options.onError,
+    logger: options.logger
+  });
   return async (req, res) => {
     try {
       const contentLengthHeader = req.headers["content-length"];
@@ -6545,10 +7003,19 @@ function makeRequestListener(options, routes, baseOpts) {
       const pathname = new URL(webReq.url).pathname;
       const method = webReq.method ?? "GET";
       const matched = matchPath(pathname);
-      const handler = matched?.methods?.[method];
+      const entry = matched?.methods?.[method];
       let response;
-      if (handler !== undefined && matched !== undefined) {
-        response = await handler(webReq, req, matched.params);
+      if (entry !== undefined && matched !== undefined) {
+        if (typeof entry === "function") {
+          response = await entry(webReq, req, matched.params);
+        } else if (entry instanceof Response) {
+          response = await materializeStaticResponse(entry);
+        } else if (options.fallback !== undefined) {
+          const fallback = fallbackHandler(options.fallback, baseOpts);
+          response = await fallback(webReq, req);
+        } else {
+          response = new Response("Not Found", { status: 404 });
+        }
       } else if (options.fallback !== undefined) {
         const fallback = fallbackHandler(options.fallback, baseOpts);
         response = await fallback(webReq, req);
@@ -6558,24 +7025,31 @@ function makeRequestListener(options, routes, baseOpts) {
       await writeResponse(res, response);
     } catch (err) {
       if (!res.headersSent) {
-        res.statusCode = 500;
-        res.setHeader("content-type", "application/json");
-        res.end(JSON.stringify({
-          error: { code: "internal_error", message: "Internal Server Error" }
-        }));
+        await writeResponse(res, onServerError(err));
       } else {
+        onServerError(err);
         res.destroy();
       }
-      if (options.onError) {
-        try {
-          options.onError({
-            error: err instanceof Error ? err : new Error(String(err))
-          });
-        } catch {}
-      }
     }
   };
 }
+var WS_PROTOCOL_TOKEN = /^[A-Za-z0-9!#$%&'*+\-.^_`|~]+$/;
+function formatWebSocketHandshake(accept, protocol) {
+  if (/[\r\n]/.test(accept)) {
+    throw new Error("invalid Sec-WebSocket-Accept value");
+  }
+  let raw = `HTTP/1.1 101 Switching Protocols\r
+` + `Upgrade: websocket\r
+` + `Connection: Upgrade\r
+` + `Sec-WebSocket-Accept: ${accept}\r
+`;
+  if (protocol && WS_PROTOCOL_TOKEN.test(protocol)) {
+    raw += `Sec-WebSocket-Protocol: ${protocol}\r
+`;
+  }
+  return `${raw}\r
+`;
+}
 function makeUpgradeListener(options) {
   return async (req, socket, head) => {
     try {
@@ -6585,18 +7059,7 @@ function makeUpgradeListener(options) {
         socket.destroy();
         return;
       }
-      let raw = `HTTP/1.1 101 Switching Protocols\r
-` + `Upgrade: websocket\r
-` + `Connection: Upgrade\r
-` + `Sec-WebSocket-Accept: ${handshake.accept}\r
-`;
-      if (handshake.protocol) {
-        raw += `Sec-WebSocket-Protocol: ${handshake.protocol}\r
-`;
-      }
-      raw += `\r
-`;
-      socket.write(raw);
+      socket.write(formatWebSocketHandshake(handshake.accept, handshake.protocol));
       options.onUpgrade?.(socket, req, head);
     } catch {
       socket.destroy();
@@ -6820,6 +7283,7 @@ class IngressResultBase {
   bodyTruncated = false;
   body = EMPTY_BODY2;
   _buf = EMPTY_BODY2;
+  _len = 0;
   _bodyJsonStart = OUT_DATA_START;
   _bodyJsonLen = 0;
   _cookiesBuf = null;
@@ -6845,6 +7309,7 @@ class IngressResultBase {
     this.bodyTruncated = false;
     this.body = EMPTY_BODY2;
     this._buf = EMPTY_BODY2;
+    this._len = 0;
     this._bodyJsonStart = OUT_DATA_START;
     this._bodyJsonLen = 0;
     this._cookiesBuf = null;
@@ -6869,8 +7334,9 @@ class IngressResultBase {
       this.retryAfterMs = 0;
     }
   }
-  setSections(buf, layout, bodyJsonLen) {
+  setSections(buf, layout, bodyJsonLen, len = buf.byteLength) {
     this._buf = buf;
+    this._len = len;
     this._bodyJsonStart = layout.bodyJsonStart;
     this._bodyJsonLen = bodyJsonLen;
     this._cookiesBuf = layout.safeCookiesLen > 0 ? buf.subarray(OUT_DATA_START, OUT_DATA_START + layout.safeCookiesLen) : null;
@@ -6900,7 +7366,7 @@ class IngressResultBase {
     if (this._bodyJsonLen === 0)
       return EMPTY_BODY2;
     const end = this._bodyJsonStart + this._bodyJsonLen;
-    if (end > this._buf.byteLength)
+    if (end > this._len)
       return EMPTY_BODY2;
     return this._buf.subarray(this._bodyJsonStart, end);
   }
@@ -6964,7 +7430,7 @@ class FastIngressResult extends IngressResultBase {
     this.isPreflight = (flags & FLAG_IS_PREFLIGHT) !== 0;
     this.rateLimited = (flags & FLAG_RATE_LIMITED) !== 0;
     const layout = sectionLayout(buf.byteLength, cookiesJsonLen, queryJsonLen, bodyJsonLen);
-    this.setSections(buf, layout, bodyJsonLen);
+    this.setSections(buf, layout, bodyJsonLen, buf.byteLength);
     this.bodyTruncated = (flags & FLAG_BODY_TRUNCATED) !== 0 || layout.truncated;
   }
   invalidate() {
@@ -7056,7 +7522,14 @@ function warnTrustProxyDeprecated() {
   if (trustProxyWarned)
     return;
   trustProxyWarned = true;
-  console.warn("[castrum] WARN: `trustProxy: true` is deprecated and trusts EVERY hop — " + "clients can spoof X-Forwarded-For / X-Real-IP to bypass IP-based rate " + "limiting. Use `trustedProxies: { enabled: true, networks: [...] }` and " + "only enable proxy trust behind a trusted edge.");
+  console.warn("[castrum] WARN: `trustProxy: true` is deprecated and trusts EVERY hop — " + "clients can spoof X-Forwarded-For / X-Real-IP to bypass IP-based rate " + "limiting. Use `trustedProxies: { enabled: true, networks: [...] }` " + "(which takes precedence) and only enable proxy trust behind a trusted edge.");
+}
+var rateLimitNoIpWarned = false;
+function warnRateLimitWithoutGetIp() {
+  if (rateLimitNoIpWarned)
+    return;
+  rateLimitNoIpWarned = true;
+  console.warn("[castrum] WARN: rate limiting is enabled without `getIp` — every client " + "shares ONE bucket, so one client can exhaust it for everyone. Provide " + "`getIp` for per-client limits (or use a global limit deliberately).");
 }
 
 // src/ingress/packing/header-packing.ts
@@ -7622,6 +8095,11 @@ class BufferPool {
     this.estimate = options.adaptive === true ? new AdaptiveEstimate({ alpha: 0.25, min: this.initialSize }) : null;
     this.free.push(new Uint8Array(this.initialSize));
     this.created = 1;
+    const prefill = Math.min(Math.max(0, Math.floor(options.prefill ?? 0)), this.maxBuffers - 1, options.prefillBytes !== undefined ? Math.max(0, Math.floor(options.prefillBytes / this.initialSize)) : Number.POSITIVE_INFINITY);
+    for (let i = 0;i < prefill; i++) {
+      this.free.push(new Uint8Array(this.initialSize));
+      this.created++;
+    }
   }
   get freeCount() {
     return this.free.length;
@@ -7629,6 +8107,9 @@ class BufferPool {
   get createdCount() {
     return this.created;
   }
+  shrink() {
+    this.free.length = 0;
+  }
   acquire(minSize = 0) {
     if (this.maxInFlight > 0 && this.inFlight >= this.maxInFlight) {
       throw new RangeError(`BufferPool: maxInFlight (${this.maxInFlight}) exceeded — too many ` + "buffers borrowed at once (unreleased zero-copy responses?). " + "Raise maxInFlight or consume/release responses faster.");
@@ -7655,7 +8136,9 @@ class BufferPool {
     for (let i = 0;i < this.free.length; i++) {
       const candidate = this.free[i];
       if (candidate.byteLength >= minSize) {
-        this.free.splice(i, 1);
+        const last = this.free.pop();
+        if (i < this.free.length)
+          this.free[i] = last;
         return candidate;
       }
     }
@@ -7670,7 +8153,9 @@ class BufferPool {
       }
     }
     if (largestBuf !== null) {
-      this.free.splice(largest, 1);
+      const last = this.free.pop();
+      if (largest < this.free.length)
+        this.free[largest] = last;
       this.created++;
       return new Uint8Array(target);
     }
@@ -7679,16 +8164,15 @@ class BufferPool {
   }
   releaseBuffer(buffer) {
     if (this.free.length >= this.maxBuffers) {
-      let smallestBuf = null;
       let smallest = 0;
-      for (let i = 0;i < this.free.length; i++) {
-        const candidate = this.free[i];
-        if (smallestBuf === null || candidate.byteLength < smallestBuf.byteLength) {
-          smallestBuf = candidate;
+      for (let i = 1;i < this.free.length; i++) {
+        if (this.free[i].byteLength < this.free[smallest].byteLength) {
           smallest = i;
         }
       }
-      this.free.splice(smallest, 1);
+      const last = this.free.pop();
+      if (smallest < this.free.length)
+        this.free[smallest] = last;
     }
     this.free.push(buffer);
   }
@@ -7748,8 +8232,8 @@ function createStructuredLogger(stream = process.stderr, env = process.env) {
 
 // src/ingress/decode/baked-result.ts
 class BakedIngressResult extends IngressResultBase {
-  refresh(buf, body, view) {
-    if (buf.byteLength < OUT_DATA_START) {
+  refresh(buf, body, view, len = buf.byteLength) {
+    if (len < OUT_DATA_START) {
       this.setInternalError();
       return;
     }
@@ -7762,7 +8246,7 @@ class BakedIngressResult extends IngressResultBase {
     const queryLenRaw = view.getUint32(OUT_QUERY_JSON_LEN, true);
     const headerVariant = view.getUint8(OUT_HEADER_VARIANT);
     const bodyJsonLenRaw = view.getUint32(OUT_BODY_JSON_LEN, true);
-    const layout = sectionLayout(buf.byteLength, cookiesLenRaw, queryLenRaw, bodyJsonLenRaw);
+    const layout = sectionLayout(len, cookiesLenRaw, queryLenRaw, bodyJsonLenRaw);
     if (h0 === 0 && h1 === 0) {
       this.verdict = 1;
       this.errorCode = ERR_CODE_INTERNAL;
@@ -7777,7 +8261,7 @@ class BakedIngressResult extends IngressResultBase {
     this.rateRemaining = h3;
     this.setRateWindow(h2, (flags & FLAG_RATE_LIMITED) !== 0, view);
     this.headerVariant = headerVariant;
-    this.setSections(buf, layout, layout.safeBodyJsonLen);
+    this.setSections(buf, layout, layout.safeBodyJsonLen, len);
     this.updateOkTerminal();
     this.isPreflight = (flags & FLAG_IS_PREFLIGHT) !== 0;
     this.corsAllowed = (flags & FLAG_CORS_ALLOWED) !== 0;
@@ -7800,8 +8284,16 @@ class BakedIngressResult extends IngressResultBase {
     this.ok = false;
   }
   bodyJson(copy) {
+    if (copy) {
+      if (this._bodyJsonLen === 0)
+        return this._buf.slice(0, 0);
+      const end = this._bodyJsonStart + this._bodyJsonLen;
+      if (end > this._len)
+        return this._buf.slice(0, 0);
+      return this._buf.slice(this._bodyJsonStart, end);
+    }
     const slice = this.bodyJsonSlice();
-    return copy ? slice.slice() : slice;
+    return slice;
   }
 }
 
@@ -7925,6 +8417,13 @@ function cachedOriginBlock(origin) {
   ORIGIN_BLOCK_CACHE.set(origin, block);
   return block;
 }
+function prewarmOriginBlocks(origins) {
+  for (const origin of origins) {
+    if (typeof origin === "string" && origin.length > 0 && origin.length <= MAX_SMALL_HEADER_BYTES && !origin.includes("*")) {
+      cachedOriginBlock(origin);
+    }
+  }
+}
 
 // src/ingress/response/baked-response.ts
 init_bytes();
@@ -7977,6 +8476,12 @@ function pooledBodyResponse(handle, bytes, init = {}, timeoutMs = 0) {
 
 // src/ingress/response/baked-response.ts
 var EMPTY_BODY4 = new Uint8Array(0);
+var ORIGIN_HEADER_CACHE_MAX = 64;
+function prewarmOriginHeaders(responseHeaders, origins, variant) {
+  for (const origin of origins) {
+    memoizedHeaders(responseHeaders(variant, null, origin));
+  }
+}
 function buildBakedResponseBuilders(deps) {
   const {
     headerTemplates,
@@ -7986,6 +8491,45 @@ function buildBakedResponseBuilders(deps) {
     originHeaderCache,
     state
   } = deps;
+  function originBaseEntries(variant, origin) {
+    const key = `${variant & 31}\x00${origin}`;
+    const cached = originHeaderCache.get(key);
+    if (cached !== undefined) {
+      return cached;
+    }
+    const template = headerTemplates[variant & 31] ?? headerTemplates[0] ?? [];
+    const entries = new Array(template.length + 1);
+    let i = 0;
+    for (const pair of template) {
+      entries[i++] = pair;
+    }
+    entries[i] = ["access-control-allow-origin", origin];
+    if (originHeaderCache.size >= ORIGIN_HEADER_CACHE_MAX) {
+      const oldest = originHeaderCache.keys().next().value;
+      if (oldest !== undefined)
+        originHeaderCache.delete(oldest);
+    }
+    originHeaderCache.set(key, entries);
+    return entries;
+  }
+  function successHeaders(variant, requestIdHeader, origin, rateRemaining, rateResetSecs) {
+    const needsRequestId = emitRequestIdHeader && requestIdHeader !== null;
+    const needsOrigin = ((variant & HV_CORS_SIMPLE) !== 0 || (variant & HV_CORS_PREFLIGHT) !== 0) && origin !== null;
+    const needsRate = (variant & HV_RATE_ACTIVE) !== 0;
+    const base = needsOrigin ? memoizedHeaders(originBaseEntries(variant, origin)) : memoizedHeaders(headerTemplates[variant & 31] ?? headerTemplates[0] ?? []);
+    if (!needsRequestId && !needsRate) {
+      return base;
+    }
+    const headers = new Headers(base);
+    if (needsRequestId) {
+      headers.set("x-request-id", requestIdHeader);
+    }
+    if (needsRate) {
+      headers.set("ratelimit-remaining", String(rateRemaining ?? 0));
+      headers.set("ratelimit-reset", String(rateResetSecs ?? 0));
+    }
+    return headers;
+  }
   function responseHeaders(variant, requestIdHeader, origin, rateRemaining, rateResetSecs, retryAfterSecs) {
     const template = headerTemplates[variant & 31] ?? headerTemplates[0] ?? [];
     const needsRequestId = emitRequestIdHeader && requestIdHeader !== null;
@@ -7996,19 +8540,7 @@ function buildBakedResponseBuilders(deps) {
       return template;
     }
     if (!needsRequestId && !needsRate && !needsRetry && needsOrigin) {
-      const key = `${variant & 31}\x00${origin}`;
-      const cached = originHeaderCache.get(key);
-      if (cached !== undefined) {
-        return cached;
-      }
-      const entries = new Array(template.length + 1);
-      let i = 0;
-      for (const pair of template) {
-        entries[i++] = pair;
-      }
-      entries[i] = ["access-control-allow-origin", origin];
-      originHeaderCache.set(key, entries);
-      return entries;
+      return originBaseEntries(variant, origin);
     }
     let extra = 0;
     if (needsRequestId)
@@ -8069,27 +8601,27 @@ function buildBakedResponseBuilders(deps) {
     if (preflightAllowed) {
       return new Response(null, {
         status: 204,
-        headers: responseHeaders(result.headerVariant, ctx.requestIdHeader, ctx.origin, result.rateRemaining, result.rateResetMs > 0 ? secondsFromMs(result.rateResetMs) : undefined, result.retryAfterMs > 0 ? secondsFromMs(result.retryAfterMs) : undefined)
+        headers: memoizedHeaders(responseHeaders(result.headerVariant, ctx.requestIdHeader, ctx.origin, result.rateRemaining, result.rateResetMs > 0 ? secondsFromMs(result.rateResetMs) : undefined, result.retryAfterMs > 0 ? secondsFromMs(result.retryAfterMs) : undefined))
       });
     }
     const status = safeTerminalStatus(result);
     const body = result.errorCode === ERR_CODE_RATE_LIMITED ? rateLimitedBody(result.retryAfterMs) : ERROR_CODE_BODIES[result.errorCode] ?? ERROR_BODIES.internal ?? EMPTY_BODY4;
     return new Response(body, {
       status,
-      headers: terminalHeaders(result.headerVariant, ctx, result)
+      headers: memoizedHeaders(terminalHeaders(result.headerVariant, ctx, result))
     });
   }
   function errorResponse(_req, result, status, code, message, ctx) {
     const body = ERROR_BODIES[code] ?? encoder.encode(JSON.stringify({ ok: false, error: { code, message } }));
     return new Response(body, {
       status,
-      headers: terminalHeaders(result?.headerVariant ?? HV_JSON, ctx, result)
+      headers: memoizedHeaders(terminalHeaders(result?.headerVariant ?? HV_JSON, ctx, result))
     });
   }
   function internalErrorResponse(ctx, result) {
     return new Response(ERROR_BODIES.internal, {
       status: 500,
-      headers: terminalHeaders(result?.headerVariant ?? HV_JSON, ctx, result ?? null)
+      headers: memoizedHeaders(terminalHeaders(result?.headerVariant ?? HV_JSON, ctx, result ?? null))
     });
   }
   function withContentType(headers, contentType) {
@@ -8110,6 +8642,7 @@ function buildBakedResponseBuilders(deps) {
   }
   return {
     responseHeaders,
+    successHeaders,
     terminalHeaders,
     terminalResponse,
     errorResponse,
@@ -8124,6 +8657,8 @@ var EMPTY_BODY5 = new Uint8Array(0);
 var EMPTY_IP = "0.0.0.0";
 var RATE_LIMIT_U32_MAX = 4294967295;
 var MAX_FFI_FAILURES = 3;
+var PREWARM_POOL_BUFFERS = 16;
+var PREWARM_POOL_BYTES = 4 * 1024 * 1024;
 function pathForLog(req) {
   try {
     return new URL(req.url).pathname;
@@ -8160,14 +8695,24 @@ function createIngressHandler(options = {}, runtime = {}) {
   const outputBufferSize = clampIngressBufferSize(runtime.outputBufferSize ?? DEFAULT_BAKED_OUTPUT_BUFFER_SIZE, OUT_DATA_START);
   const logger = runtime.logger ?? (runtime.structuredLog === true ? createStructuredLogger() : null);
   const needRequestIdString = !!(emitRequestIdHeader || runtime.onRequest || runtime.onError || runtime.onResponse || logger);
+  const hasOnRequest = runtime.onRequest !== undefined;
+  const hasOnResponse = runtime.onResponse !== undefined;
   const outputPool = new BufferPool({
     initialSize: outputBufferSize,
-    maxInFlight: runtime.maxInFlight
+    maxInFlight: runtime.maxInFlight,
+    prefill: PREWARM_POOL_BUFFERS,
+    prefillBytes: PREWARM_POOL_BYTES
   });
   const inputPacker = new IngressInputPacker;
   const responseState = { currentHandle: null, responseBorrowsBuffer: false };
   let ffiFailures = 0;
   let ffiDisabled = false;
+  const noteFfiFailure = () => {
+    ffiFailures++;
+    if (ffiFailures >= MAX_FFI_FAILURES) {
+      ffiDisabled = true;
+    }
+  };
   const originHeaderCache = new Map;
   const cors = options.cors;
   const securityEntries = runtime.enableSecurityHeaders === false ? Object.freeze([]) : Object.freeze(buildBakedSecurityEntries(options.security, options.https, runtime.securityHeaders));
@@ -8193,6 +8738,17 @@ function createIngressHandler(options = {}, runtime = {}) {
     originHeaderCache,
     state: responseState
   });
+  if (headerPlan.cors && typeof cors?.allowOrigin === "object") {
+    const exactOrigins = [];
+    for (const origin of cors.allowOrigin) {
+      if (typeof origin === "string" && origin.length > 0 && origin.length <= 512 && !origin.includes("*")) {
+        exactOrigins.push(origin);
+      }
+    }
+    prewarmOriginBlocks(exactOrigins);
+    const successVariant = HV_JSON | HV_CORS_SIMPLE | (rateEnabled ? HV_RATE_ACTIVE : 0);
+    prewarmOriginHeaders(responseBuilders.responseHeaders, exactOrigins, successVariant);
+  }
   const result = new BakedIngressResult;
   const ctx = {
     requestIdHeader: null,
@@ -8205,7 +8761,8 @@ function createIngressHandler(options = {}, runtime = {}) {
     const requestIdStr = needRequestIdString ? decoder.decode(ridBytes) : "";
     ctx.requestIdHeader = emitRequestIdHeader ? requestIdStr : null;
     ctx.origin = headerPlan.cors ? req.headers.get("origin") : null;
-    runtime.onRequest?.(req, requestIdStr, ip);
+    if (hasOnRequest)
+      runtime.onRequest?.(req, requestIdStr, ip);
     const ipStr = ip ?? EMPTY_IP;
     let handle = null;
     responseState.currentHandle = null;
@@ -8223,10 +8780,7 @@ function createIngressHandler(options = {}, runtime = {}) {
             written = bunFFI.ingressHandleComponents(ingressPtr, methodKind, packUrl, packIp ?? "", ridBytes, packedHeaders, body, handle.buffer);
             ffiFailures = 0;
           } catch {
-            ffiFailures++;
-            if (ffiFailures >= MAX_FFI_FAILURES) {
-              ffiDisabled = true;
-            }
+            noteFfiFailure();
             const input = inputPacker.packParts(methodKind, packUrl, packIp, ridBytes, packedHeaders);
             written = handler.handleRequestPacked(input, body, handle.buffer);
           }
@@ -8236,18 +8790,14 @@ function createIngressHandler(options = {}, runtime = {}) {
             written = bunFFI.ingressHandlePacked(ingressPtr, input, body, handle.buffer);
             ffiFailures = 0;
           } catch {
-            ffiFailures++;
-            if (ffiFailures >= MAX_FFI_FAILURES) {
-              ffiDisabled = true;
-            }
+            noteFfiFailure();
             written = handler.handleRequestPacked(input, body, handle.buffer);
           }
         } else {
           const input = inputPacker.packParts(methodKind, packUrl, packIp, ridBytes, packedHeaders);
           written = handler.handleRequestPacked(input, body, handle.buffer);
         }
-        const used = handle.buffer.subarray(0, written);
-        result.refresh(used, body ?? EMPTY_BODY5, viewForArrayBuffer(used.buffer, used.byteOffset));
+        result.refresh(handle.buffer, body ?? EMPTY_BODY5, viewForArrayBuffer(handle.buffer.buffer, handle.buffer.byteOffset), written);
       } catch (err) {
         result.setInternalError();
         const error = err instanceof Error ? err : new Error(String(err));
@@ -8263,17 +8813,20 @@ function createIngressHandler(options = {}, runtime = {}) {
       try {
         const out = fn(result, ctx);
         assertSyncCallback(out, "createIngressHandler().run()");
-        const status = out instanceof Response ? out.status : safeTerminalStatus(result);
-        runtime.onResponse?.(req, result, status, requestIdStr);
-        if (logger) {
-          logger.request({
-            requestId: requestIdStr,
-            method: req.method,
-            path: pathForLog(req),
-            status,
-            durationMs: Math.round((performance.now() - startedAt) * 1000) / 1000,
-            ip: ipStr
-          });
+        if (hasOnResponse || logger !== null) {
+          const status = out instanceof Response ? out.status : safeTerminalStatus(result);
+          if (hasOnResponse)
+            runtime.onResponse?.(req, result, status, requestIdStr);
+          if (logger !== null) {
+            logger.request({
+              requestId: requestIdStr,
+              method: req.method,
+              path: pathForLog(req),
+              status,
+              durationMs: Math.round((performance.now() - startedAt) * 1000) / 1000,
+              ip: ipStr
+            });
+          }
         }
         return out;
       } finally {
@@ -8321,6 +8874,9 @@ function jsonResponse(status, body) {
 function livenessHandler() {
   return (_req) => jsonResponse(200, { status: "ok" });
 }
+function staticLiveness() {
+  return jsonResponse(200, { status: "ok" });
+}
 function readinessHandler(check) {
   return async (_req) => {
     if (!check)
@@ -8354,6 +8910,8 @@ var DEFAULT_BUCKETS = [
   5,
   10
 ];
+var MAX_SERIES_PER_METRIC = 1e4;
+var SERIES_DROPPED_METRIC = "castrum_metrics_series_dropped_total";
 function labelKey(names, values) {
   if (names.length === 0)
     return "";
@@ -8366,10 +8924,25 @@ function labelKey(names, values) {
 function escapeLabel(v) {
   return v.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n");
 }
+function evictOldestHalf2(map) {
+  if (map.size < MAX_SERIES_PER_METRIC)
+    return [];
+  const drop = Math.ceil(map.size / 2);
+  const dropped = [];
+  for (const key of map.keys()) {
+    if (dropped.length >= drop)
+      break;
+    dropped.push(key);
+  }
+  for (const key of dropped)
+    map.delete(key);
+  return dropped;
+}
 function createMetrics() {
   const counters = new Map;
   const gauges = new Map;
   const histograms = new Map;
+  let seriesDropped = 0;
   const bucketUpper = (buckets) => [
     ...buckets.map((b) => b),
     Number.POSITIVE_INFINITY
@@ -8414,6 +8987,11 @@ function createMetrics() {
       out.push(...renderGauge(e));
     for (const e of histograms.values())
       out.push(...renderHistogram(e));
+    if (seriesDropped > 0 && !counters.has(SERIES_DROPPED_METRIC) && !gauges.has(SERIES_DROPPED_METRIC) && !histograms.has(SERIES_DROPPED_METRIC)) {
+      out.push(`# HELP ${SERIES_DROPPED_METRIC} Total metric series evicted by the per-family cardinality cap.`);
+      out.push(`# TYPE ${SERIES_DROPPED_METRIC} counter`);
+      out.push(`${SERIES_DROPPED_METRIC} ${seriesDropped}`);
+    }
     return `${out.join(`
 `)}
 `;
@@ -8422,6 +9000,7 @@ function createMetrics() {
     counters.clear();
     gauges.clear();
     histograms.clear();
+    seriesDropped = 0;
   };
   return {
     counter(name, help, labelNames = []) {
@@ -8438,7 +9017,13 @@ function createMetrics() {
       return {
         inc(labels, by = 1) {
           const key = labelKey(names, names.map((n) => labels?.[n] ?? ""));
-          entry.values.set(key, (entry.values.get(key) ?? 0) + by);
+          const prev = entry.values.get(key);
+          if (prev === undefined) {
+            seriesDropped += evictOldestHalf2(entry.values).length;
+            entry.values.set(key, by);
+          } else {
+            entry.values.set(key, prev + by);
+          }
         }
       };
     },
@@ -8454,14 +9039,27 @@ function createMetrics() {
         gauges.set(name, entry);
       const names = entry.labelNames;
       const keyOf = (labels) => labelKey(names, names.map((n) => labels?.[n] ?? ""));
+      const add = (labels, delta) => {
+        const key = keyOf(labels);
+        const prev = entry.values.get(key);
+        if (prev === undefined) {
+          seriesDropped += evictOldestHalf2(entry.values).length;
+          entry.values.set(key, delta);
+        } else {
+          entry.values.set(key, prev + delta);
+        }
+      };
       return {
         inc(labels, by = 1) {
-          entry.values.set(keyOf(labels), (entry.values.get(keyOf(labels)) ?? 0) + by);
+          add(labels, by);
         },
         dec(labels, by = 1) {
-          entry.values.set(keyOf(labels), (entry.values.get(keyOf(labels)) ?? 0) - by);
+          add(labels, -by);
         },
         set(labels, value) {
+          if (!entry.values.has(keyOf(labels))) {
+            seriesDropped += evictOldestHalf2(entry.values).length;
+          }
           entry.values.set(keyOf(labels), value);
         }
       };
@@ -8484,6 +9082,10 @@ function createMetrics() {
           const key = labelKey(names, names.map((n) => labels?.[n] ?? ""));
           let counts = entry.counts.get(key);
           if (!counts) {
+            const dropped = evictOldestHalf2(entry.counts);
+            for (const k of dropped)
+              entry.sums.delete(k);
+            seriesDropped += dropped.length;
             counts = new Array(entry.buckets.length + 1).fill(0);
             entry.counts.set(key, counts);
           }
@@ -8568,6 +9170,14 @@ function createIngressRouter(options) {
   if (options.copyBody !== undefined)
     baseOpts.copyBody = options.copyBody;
   for (const [path, spec] of Object.entries(options.routes)) {
+    if (spec.static !== undefined) {
+      bakedRoutes[path] = {
+        static: spec.static,
+        maxBodyBytes: spec.maxBodyBytes,
+        bodyTimeoutMs: spec.bodyTimeoutMs
+      };
+      continue;
+    }
     if (spec.raw) {
       bakedRoutes[path] = { read: spec.raw };
       continue;
@@ -8587,6 +9197,10 @@ function createIngressRouter(options) {
     }
     const handler = createIngressHandler(spec.options ?? {}, runtime);
     compiled[path] = handler;
+    const routeLimit = spec.options?.rateLimit?.limit;
+    if (typeof routeLimit === "number" && routeLimit > 0 && routeLimit !== RATE_LIMIT_U32_MAX && options.getIp === undefined) {
+      warnRateLimitWithoutGetIp();
+    }
     if (spec.responder) {
       bakedRoutes[path] = {
         responder: {
@@ -8638,6 +9252,9 @@ function createIngressRouter(options) {
     if (typeof methodHandler === "function") {
       return methodHandler(req, srv, matched.params);
     }
+    if (methodHandler instanceof Response) {
+      return methodHandler.clone();
+    }
     if (req.method === "OPTIONS" && typeof matched.methods.OPTIONS === "function") {
       return matched.methods.OPTIONS(req, srv, matched.params);
     }
@@ -8811,6 +9428,22 @@ function createIngress(options = {}) {
     }
   };
 }
+// src/native/ingress-binding.ts
+init_ffi();
+var cached2;
+function getIngressBinding() {
+  if (cached2 !== undefined)
+    return cached2;
+  const ffi = getBunFFI();
+  const addonPath = ffiAddonPath();
+  cached2 = ffi && addonPath ? {
+    addonPath,
+    ingressHandleComponents: ffi.ingressHandleComponents,
+    ingressHandlePacked: ffi.ingressHandlePacked,
+    ingressLayout: ffi.ingressLayout
+  } : null;
+  return cached2;
+}
 // src/loader/index.ts
 init_rust_ffi();
 init_bytes();
@@ -9921,6 +10554,9 @@ function createPipeline(opts = {}) {
       try {
         body = await readBodyWithLimit(req, maxBodyBytes, true, bodyTimeoutMs);
       } catch (err) {
+        if (isAbortError(err)) {
+          return { terminal: true, response: abortResponse(), result: null, ctx };
+        }
         return {
           terminal: true,
           response: bodyErrorResponse(ingress, req, requestId, err),
@@ -10088,6 +10724,19 @@ function cancelledError() {
   err.name = "TaskCancelledError";
   return err;
 }
+var TASK_SUBMIT_ACCEPTED = 1;
+var TASK_SUBMIT_OVERLOADED = 2;
+function taskSubmitError(code) {
+  if (code === TASK_SUBMIT_ACCEPTED)
+    return null;
+  if (code === TASK_SUBMIT_OVERLOADED) {
+    const err = new Error("task rejected: native work queue is full");
+    err.name = "TaskOverloadedError";
+    err.code = "OVERLOADED";
+    return err;
+  }
+  return new Error("task rejected by the native runtime");
+}
 var shared = null;
 function createTaskRuntime(options = {}) {
   if (shared)
@@ -10228,14 +10877,17 @@ function createTaskRuntime(options = {}) {
     queueMicrotask(drainNow);
   }
   function submit(op, args, runOptions) {
+    ensureDoorbell();
     const id = nextId++;
     return new Promise((resolve, reject) => {
       inflight.set(id, { out: null, keep: null, resolve, reject });
       retain();
-      if (ffi.taskSubmit(op, args, id) === 0) {
+      const rejected = taskSubmitError(ffi.taskSubmit(op, args, id));
+      if (rejected) {
         inflight.delete(id);
-        release();
-        reject(new Error("task rejected by the native runtime"));
+        if (inflight.size === 0)
+          release();
+        reject(rejected);
         return;
       }
       const signal = runOptions?.signal;
@@ -10249,14 +10901,17 @@ function createTaskRuntime(options = {}) {
     });
   }
   function submitInto(op, args, output, runOptions) {
+    ensureDoorbell();
     const id = nextId++;
     return new Promise((resolve, reject) => {
       inflight.set(id, { out: output, keep: null, resolve, reject });
       retain();
-      if (ffi.taskSubmitOut(op, args, id, output) === 0) {
+      const rejected = taskSubmitError(ffi.taskSubmitOut(op, args, id, output));
+      if (rejected) {
         inflight.delete(id);
-        release();
-        reject(new Error("task rejected by the native runtime"));
+        if (inflight.size === 0)
+          release();
+        reject(rejected);
         return;
       }
       const signal = runOptions?.signal;
@@ -10270,14 +10925,17 @@ function createTaskRuntime(options = {}) {
     });
   }
   function submitSlice(op, hdr, data, runOptions) {
+    ensureDoorbell();
     const id = nextId++;
     return new Promise((resolve, reject) => {
       inflight.set(id, { out: null, keep: data, resolve, reject });
       retain();
-      if (ffi.taskSubmitSlice(op, hdr, data, id) === 0) {
+      const rejected = taskSubmitError(ffi.taskSubmitSlice(op, hdr, data, id));
+      if (rejected) {
         inflight.delete(id);
-        release();
-        reject(new Error("task rejected by the native runtime"));
+        if (inflight.size === 0)
+          release();
+        reject(rejected);
         return;
       }
       const signal = runOptions?.signal;
@@ -10291,11 +10949,16 @@ function createTaskRuntime(options = {}) {
     });
   }
   const { JSCallback } = __require("bun:ffi");
-  const cb = new JSCallback(() => {
-    drainNow();
-  }, { args: [], returns: "void", threadsafe: true });
-  doorbell = cb;
-  ffi.taskSetDoorbell(Number(cb.ptr));
+  function ensureDoorbell() {
+    if (doorbell !== null)
+      return;
+    const cb = new JSCallback(() => {
+      drainNow();
+    }, { args: [], returns: "void", threadsafe: true });
+    doorbell = cb;
+    ffi.taskSetDoorbell(Number(cb.ptr));
+  }
+  ensureDoorbell();
   schedule();
   const runtime = {
     gzipDecompress(data, runOptions) {
@@ -10339,6 +11002,7 @@ function createTaskRuntime(options = {}) {
         deferred.reject(cancelledError());
       }
       inflight.clear();
+      ffi.taskSetDoorbell(0);
       ffi.taskShutdown();
       release();
       doorbell?.close();
@@ -10373,12 +11037,30 @@ var opDecision = (op) => {
 
 // index.ts
 init_bytes();
+
+// src/shared/memory.ts
+init_rust_ffi();
+init_context();
+init_runtime();
+function flushMemory(options = {}) {
+  loader.clear();
+  clearMimeCaches();
+  try {
+    rust.clearSchemaCache();
+  } catch {}
+  if (options.gc !== false) {
+    forceGc2();
+  }
+}
+
+// index.ts
 init_packed();
 
 // src/shared/uuid.ts
 init_uuid();
 var uuidv7 = runtimeUuid.uuidv7;
 export {
+  ABORT_CODE,
   AdaptiveEstimate,
   BakedIngressResult,
   DEFAULT_BODY_TIMEOUT_MS,
@@ -10440,6 +11122,7 @@ export {
   TASK_STATUS_CANCELLED,
   TASK_STATUS_ERROR,
   TASK_STATUS_OK,
+  abortResponse,
   brotliCapacityGuess,
   buildResponseContext,
   buildTerminalResponse,
@@ -10474,12 +11157,15 @@ export {
   errorCodeName,
   errorMessage,
   fallbackHandler,
+  flushMemory,
   generateRequestId,
+  getIngressBinding,
   gracefulShutdown,
   gzipCompressUpperBound,
   headHandler,
   headersForResult,
   healthHandler,
+  isAbortError,
   isNativeOp,
   isProven,
   isValidResponseStatus,
@@ -10516,6 +11202,7 @@ export {
   safeTerminalStatus,
   serializeTraceParent,
   sseResponse,
+  staticLiveness,
   statusForErrorCode,
   unpackBitset,
   unpackByteResults,