castrum 0.9.3 → 0.9.6

package/src/native/ffi/build/metrics.ts

@@ -0,0 +1,247 @@
+// src/native/ffi/build/metrics.ts — metrics-registry BunFFI methods.
+//
+// Wraps the `castrum_metrics_*` caller-owned-handle surface (route-stack
+// ownership model): create returns a native `Box<MetricsRegistry>` handle,
+// declare fns cross name/label-keys as cstring ARGS and return the u32 series
+// id, and record/set/render take packed byte slices. Receives the raw dlopen'd
+// symbols from `build()`.
+
+import { decodeUtf8, encodeUtf8 } from '../../../shared/codec'
+import type { BunFFI, Raw0, Raw3, Raw4, Raw5 } from '../types'
+import type { BuildCtx } from './util'
+import { hasNul } from './util'
+
+/**
+ * Declare-time NUL guard: a metric NAME or label-key set containing `U+0000`
+ * would be truncated by the `cstring` arg, silently colliding two series. This
+ * runs once at declaration, so failing fast costs nothing on the hot path.
+ */
+function throwIfNul(value: string, what: string): void {
+  if (hasNul(value)) {
+    throw new Error(`metrics: ${what} must not contain a NUL character (U+0000)`)
+  }
+}
+
+/**
+ * Sentinel returned by the declare fns (`u32::MAX`) on invalid input — fits
+ * f64 exactly and can never collide with a real dense family id.
+ */
+export const METRICS_DECLARE_ERR = 0xffffffff
+
+/** Empty label-values view (zero-label families). */
+const EMPTY = new Uint8Array(0)
+
+/**
+ * Build the metrics-registry methods of the BunFFI surface.
+ */
+export function buildMetrics(
+  sym: Record<string, (...a: unknown[]) => unknown>,
+  ctx: BuildCtx,
+): Partial<BunFFI> {
+  const { lenOrView } = ctx
+  const metricsCreateRaw = sym.castrum_metrics_create as Raw0
+  const metricsCounterRaw = sym.castrum_metrics_counter as Raw3
+  const metricsGaugeRaw = sym.castrum_metrics_gauge as Raw3
+  const metricsHistogramRaw = sym.castrum_metrics_histogram as Raw4
+  const metricsRecordRaw = sym.castrum_metrics_record as Raw5
+  const metricsGaugeSetRaw = sym.castrum_metrics_gauge_set as Raw5
+  // Zero-encode siblings: joined values cross as a cstring ARG.
+  const metricsRecordStrRaw = sym.castrum_metrics_record_str as (...a: unknown[]) => number | bigint
+  const metricsGaugeSetStrRaw = sym.castrum_metrics_gauge_set_str as (
+    ...a: unknown[]
+  ) => number | bigint
+  const metricsRenderRaw = sym.castrum_metrics_render as Raw3
+  const metricsSnapshotRaw = sym.castrum_metrics_snapshot as Raw3
+  const metricsRecordBatchRaw = sym.castrum_metrics_record_batch as Raw3
+  const metricsDestroyRaw = sym.castrum_metrics_destroy as (h: unknown) => void
+
+  /** Declare helper: maps the C sentinel to a throw (fail fast at declare). */
+  const declareOrThrow = (id: number | bigint, what: string): number => {
+    const n = Number(id)
+    if (n === METRICS_DECLARE_ERR) {
+      throw new Error(`metrics: failed to declare ${what} (invalid name/labels/buckets)`)
+    }
+    return n
+  }
+
+  return {
+    metricsCreate() {
+      const h = Number(metricsCreateRaw())
+      if (h === 0) throw new Error('metrics: registry allocation failed')
+      return h
+    },
+    metricsCounter(handle, name, labelKeys) {
+      throwIfNul(name, 'counter name')
+      throwIfNul(labelKeys, 'counter label keys')
+      return declareOrThrow(metricsCounterRaw(handle, name, labelKeys), `counter "${name}"`)
+    },
+    metricsGauge(handle, name, labelKeys) {
+      throwIfNul(name, 'gauge name')
+      throwIfNul(labelKeys, 'gauge label keys')
+      return declareOrThrow(metricsGaugeRaw(handle, name, labelKeys), `gauge "${name}"`)
+    },
+    metricsHistogram(handle, name, labelKeys, bucketsCsv) {
+      throwIfNul(name, 'histogram name')
+      throwIfNul(labelKeys, 'histogram label keys')
+      return declareOrThrow(
+        metricsHistogramRaw(handle, name, labelKeys, bucketsCsv),
+        `histogram "${name}"`,
+      )
+    },
+    metricsRecord(handle, series, values, amount) {
+      // Packed `\x1f`-separated values cross as `(ptr,len)`; u8 verdict.
+      return Number(metricsRecordRaw(handle, series, values, lenOrView(values), amount)) === 1
+    },
+    metricsGaugeSet(handle, series, values, value) {
+      return Number(metricsGaugeSetRaw(handle, series, values, lenOrView(values), value)) === 1
+    },
+    metricsRecordStr(handle, series, values, amount) {
+      // `values` is the JOINED `\x1f` string — engine-transcoded (zero encode).
+      // Label values come from user data, so a NUL would truncate the join and
+      // silently record the WRONG series (the native side rejects a NUL value,
+      // but only if it ever sees it). Fail loudly and say why.
+      throwIfNul(values, 'label values')
+      return Number(metricsRecordStrRaw(handle, series, values, amount)) === 1
+    },
+    metricsGaugeSetStr(handle, series, values, value) {
+      throwIfNul(values, 'label values')
+      return Number(metricsGaugeSetStrRaw(handle, series, values, value)) === 1
+    },
+    metricsRender(handle, output) {
+      // Needed-size convention (routeRun parity): `0` = real error → throw;
+      // `> output.length` = the EXACT required size (caller grows once and
+      // retries — never a doubling re-run loop).
+      const w = Number(metricsRenderRaw(handle, output, lenOrView(output)))
+      if (w === 0) throw new Error('metrics render: registry handle invalid or render failed')
+      return w
+    },
+    metricsSnapshot(handle, output) {
+      // Needed-size convention (routeRun parity): 0 throws; > length = exact.
+      const w = Number(metricsSnapshotRaw(handle, output, lenOrView(output)))
+      if (w === 0) throw new Error('metrics snapshot: registry handle invalid')
+      return w
+    },
+    metricsRecordBatch(handle, packed) {
+      return Number(metricsRecordBatchRaw(handle, packed, lenOrView(packed))) === 1
+    },
+    metricsDestroy(handle) {
+      metricsDestroyRaw(handle)
+    },
+  }
+}
+
+/**
+ * Bind-time self-test for the metrics surface (unique `ct.selftest.*` names).
+ * Exercises every symbol's ABI at bind time; `false` disables the ffi layer
+ * and forces the napi fallback.
+ */
+export function selfTestMetrics(b: BunFFI): boolean {
+  let handle = 0
+  try {
+    handle = b.metricsCreate()
+    if (handle === 0) return false
+
+    const counter = b.metricsCounter(handle, 'ct_selftest_hits', 'route\u001fstatus')
+    if (!Number.isInteger(counter) || counter < 0 || counter === METRICS_DECLARE_ERR) {
+      console.error('FAIL: declare')
+      return false
+    }
+    if (!b.metricsRecord(handle, counter, encodeUtf8('/a\u001f200'), 2)) {
+      console.error('FAIL: record1')
+      return false
+    }
+    if (!b.metricsRecord(handle, counter, encodeUtf8('/a\u001f200'), 1)) {
+      console.error('FAIL: record2')
+      return false
+    }
+    if (!b.metricsRecordStr(handle, counter, '/b\u001f200', 2)) {
+      console.error('FAIL: recordStr')
+      return false
+    }
+
+    console.error('CK: counter')
+    const gauge = b.metricsGauge(handle, 'ct_selftest_depth', 'q')
+    if (gauge === METRICS_DECLARE_ERR) return false
+    if (!b.metricsGaugeSet(handle, gauge, encodeUtf8('jobs'), 4)) return false
+    if (!b.metricsGaugeSetStr(handle, gauge, 'io', 6)) return false
+
+    console.error('CK: gauge')
+    const hist = b.metricsHistogram(handle, 'ct_selftest_latency', '', '0.1,0.5')
+    if (hist === METRICS_DECLARE_ERR) return false
+    if (!b.metricsRecord(handle, hist, EMPTY, 0.25)) return false
+    if (b.metricsRecord(handle, hist, EMPTY, -1)) return false // negatives rejected
+
+    console.error('CK: hist')
+    // Arity mismatch must fail safely.
+    if (b.metricsRecord(handle, counter, encodeUtf8('/a'), 1)) return false
+
+    console.error('CK: arity')
+    // Render: probe with a small buffer → exact required size; then render.
+    const probe = new Uint8Array(16)
+    const needed = b.metricsRender(handle, probe)
+    if (needed <= probe.length) return false
+    const out = new Uint8Array(needed)
+    const written = b.metricsRender(handle, out)
+    if (written !== needed) return false
+    const text = decodeUtf8(out.subarray(0, written))
+    if (
+      !text.includes('ct_selftest_hits{route="/a",status="200"} 3\n') ||
+      !text.includes('ct_selftest_hits{route="/b",status="200"} 2\n') ||
+      !text.includes('ct_selftest_depth{q="jobs"} 4\n') ||
+      !text.includes('ct_selftest_depth{q="io"} 6\n') ||
+      !text.includes('ct_selftest_latency_bucket{le="0.5"} 1\n') ||
+      !text.includes('ct_selftest_latency_count 1\n')
+    ) {
+      return false
+    }
+
+    console.error('CK: render')
+    // Snapshot: packed dump starts with version=1 + familyCount>=3.
+    {
+      const probe2 = new Uint8Array(16)
+      const need = b.metricsSnapshot(handle, probe2)
+      if (need <= probe2.length) return false
+      const snap = new Uint8Array(need)
+      if (b.metricsSnapshot(handle, snap) !== need) return false
+      const sv = new DataView(snap.buffer)
+      if (sv.getUint32(0, true) !== 1) return false
+      if (sv.getUint32(4, true) < 3) return false
+    }
+
+    console.error('CK: snapshot')
+    // Batch: two entries in ONE crossing.
+    {
+      const c2 = b.metricsCounter(handle, 'ct_selftest_batch', 'k')
+      const buf = new Uint8Array(64)
+      const dv = new DataView(buf.buffer)
+      dv.setUint32(0, 1, true)
+      dv.setUint32(4, c2, true)
+      dv.setUint32(8, 1, true)
+      buf[12] = 'v'.charCodeAt(0)
+      dv.setFloat64(13, 4, true)
+      if (!b.metricsRecordBatch(handle, buf.subarray(0, 21))) return false
+      const probe3 = new Uint8Array(16)
+      const need3 = b.metricsRender(handle, probe3)
+      const out3 = new Uint8Array(need3)
+      b.metricsRender(handle, out3)
+      if (!decodeUtf8(out3.subarray(0, need3)).includes('ct_selftest_batch{k="v"} 4')) {
+        return false
+      }
+    }
+
+    console.error('CK: batch')
+    // A null handle must throw on declare (never dereference freed state).
+    try {
+      b.metricsCounter(0, 'ct_selftest_x', '')
+      return false
+    } catch {
+      // expected
+    }
+    return true
+  } catch (err) {
+    console.error('METRICS SELFTEST THROW:', err)
+    return false
+  } finally {
+    b.metricsDestroy(handle)
+  }
+}

package/src/native/ffi/build/parse.ts

@@ -11,12 +11,29 @@ import { decodeUtf8, encodeUtf8 } from '../../../shared/codec'
 import { EMPTY_VIEW, SELFTEST_HEX } from '../constants'
 import type { BunFFI, Raw3, Raw4, Raw6, Raw7, Raw10 } from '../types'
 import type { BuildCtx } from './util'
-import { flag, growExact } from './util'
+import { allocOut, flag, growExact } from './util'
 
 /**
  * Build the parser/wire-format methods of the BunFFI surface. `ctx` is
  * destructured so the method bodies read exactly as the original `build()`.
  */
+
+// ── SSE event/id encode memo ────────────────────────────────────────────────
+// SSE streams repeat the same event NAME constantly ('message'/'update') and
+// often repeat ids; re-encoding them per event is pure waste (~60ns each).
+// One memo slot each: a `===` hit returns the cached bytes, a miss re-encodes.
+// Per-Worker module state (single-threaded event loop), same safety model as
+// the pooled scratches in BuildCtx.
+const sseMemoEvent = { str: null as string | null, bytes: EMPTY_VIEW }
+const sseMemoId = { str: null as string | null, bytes: EMPTY_VIEW }
+function sseMemoEncode(slot: { str: string | null; bytes: Uint8Array }, s: string): Uint8Array {
+  if (s === slot.str) return slot.bytes
+  const bytes = encodeUtf8(s)
+  slot.str = s
+  slot.bytes = bytes
+  return bytes
+}
+
 export function buildParse(
   sym: Record<string, (...a: unknown[]) => unknown>,
   ctx: BuildCtx,
@@ -67,8 +84,9 @@ export function buildParse(
       return w
     },
     wsFrameEncode(opcode, payload, mask, fin) {
-      // Header (max 10) + payload + mask key (4).
-      const out = new Uint8Array(payload.length + 14)
+      // Header (max 10) + payload + mask key (4). allocOut skips the zeroing
+      // (the native write fills [0,w) and only that slice escapes).
+      const out = allocOut(payload.length + 14)
       const w = Number(
         wsFrameEncode(
           opcode,
@@ -182,15 +200,24 @@ export function buildParse(
     parseMediaType(input) {
       // Packed verdict: [u32 mediaTypeLen][mediaType][u32 charsetLen
       // (0xFFFFFFFF = none)][charset][u32 boundaryLen][boundary]
-      // [u32 paramCount]{[u32 keyLen][key][u32 valLen][val]}. 0 = invalid media
-      // type (real error → growExact throws); w > output.length = exact needed
-      // size (one exact retry).
-      return growExact(
-        (out) => Number(parseMediaTypeSym(input, lenOrView(input), out, lenOrView(out))),
-        Math.min(input.length + 64, 64 * 1024),
-        1024 * 1024,
-        'media type parse: invalid media type or output buffer too small',
-      )
+      // [u32 paramCount]{[u32 keyLen][key][u32 valLen][val]}.
+      // POOLED SCRATCH: the only consumer (the scalar `unpackMediaType`)
+      // decodes the verdict synchronously into a JS object before the next
+      // call, so the packed bytes never need to outlive this call — no
+      // growExact fresh-buffer per request. 0 = invalid media type (throw).
+      // 2x + 128 covers the worst-case packed expansion (every byte becomes a
+      // param key/value length prefix); a still-too-small write falls back to
+      // ONE exact-size buffer (needed-size convention).
+      let out = scratchFor(input.length * 2 + 128)
+      let w = Number(parseMediaTypeSym(input, lenOrView(input), out, lenOrView(out)))
+      if (w > out.length) {
+        out = new Uint8Array(w)
+        w = Number(parseMediaTypeSym(input, lenOrView(input), out, lenOrView(out)))
+      }
+      if (w === 0 || w > out.length) {
+        throw new Error('media type parse: invalid media type or output buffer too small')
+      }
+      return out.subarray(0, w)
     },
     parseHttpDate(input) {
       // Packed [u8 ok][i64 secs LE] (9 B) / 1 B (ok=0). A too-small buffer is
@@ -207,13 +234,18 @@ export function buildParse(
     },
     parseAcceptEncoding(input) {
       // Packed: [u32 count]{[u32 encLen][enc][f32 q][u32 order]} (empty header →
-      // count 0, 4 bytes). 0 = too small (real error → growExact throws).
-      return growExact(
-        (out) => Number(parseAcceptEncodingSym(input, lenOrView(input), out, lenOrView(out))),
-        Math.min(input.length + 64, 64 * 1024),
-        1024 * 1024,
-        'accept encoding parse: output buffer too small',
-      )
+      // count 0, 4 bytes). POOLED SCRATCH: consumed synchronously by the scalar
+      // `unpackAcceptEncoding` — never escapes as raw bytes. 0 = too small.
+      let out = scratchFor(input.length * 2 + 128)
+      let w = Number(parseAcceptEncodingSym(input, lenOrView(input), out, lenOrView(out)))
+      if (w > out.length) {
+        out = new Uint8Array(w)
+        w = Number(parseAcceptEncodingSym(input, lenOrView(input), out, lenOrView(out)))
+      }
+      if (w === 0 || w > out.length) {
+        throw new Error('accept encoding parse: output buffer too small')
+      }
+      return out.subarray(0, w)
     },
     urlEncodeQuery(input) {
       // Packed pairs `[u32 count]{[u32 keyLen][key][u32 valLen][val]}` (the JS
@@ -255,8 +287,12 @@ export function buildParse(
       // non-null (flag bits 1/2/4 = present) so a present-but-empty string is
       // distinct from absent (napi Option parity). growExact with the needed-size
       // convention; `data.length + 64` covers the common single-line case.
-      const ev = event === null ? EMPTY_VIEW : encodeUtf8(event)
-      const idv = id === null ? EMPTY_VIEW : encodeUtf8(id)
+      // NOTE (2026-08-24): cstring-ARG variants were once blamed for JIT
+      // crashes here — docs/FFI_BUN_GUIDE.md §14 traced every report to
+      // dev-loop ABI desync, not bun:ffi. The memo captures the win without
+      // an ABI change anyway.
+      const ev = event === null ? EMPTY_VIEW : sseMemoEncode(sseMemoEvent, event)
+      const idv = id === null ? EMPTY_VIEW : sseMemoEncode(sseMemoId, id)
       const flags = (event === null ? 0 : 1) | (id === null ? 0 : 2) | (retry === null ? 0 : 4)
       return growExact(
         (out) =>
@@ -283,8 +319,8 @@ export function buildParse(
       // Pooled sibling — caller-owned output buffer (sized ≥ `data.length + 64`
       // for the common single-line case). Needed-size convention: w > output.length
       // = exact required size → throw; w === 0 = real error (invalid UTF-8).
-      const ev = event === null ? EMPTY_VIEW : encodeUtf8(event)
-      const idv = id === null ? EMPTY_VIEW : encodeUtf8(id)
+      const ev = event === null ? EMPTY_VIEW : sseMemoEncode(sseMemoEvent, event)
+      const idv = id === null ? EMPTY_VIEW : sseMemoEncode(sseMemoId, id)
       const flags = (event === null ? 0 : 1) | (id === null ? 0 : 2) | (retry === null ? 0 : 4)
       const w = Number(
         sseEncodeIntoRaw(

package/src/native/ffi/build/task.ts

@@ -0,0 +1,79 @@
+// src/native/ffi/build/task.ts — off-thread task runtime BunFFI methods.
+//
+// The thinnest possible binding: `rust/task/` owns the pool, the result ring,
+// and the batched doorbell. This file only adapts the `(ptr,len)` ABI pair
+// (probe-gated `buffer`/`buffer_length` vs explicit lengths) and converts the
+// `u64_fast` byte counts to numbers.
+//
+// See docs/RND-CONCURRENCY.md for the design and the measured costs.
+
+import type { BunFFI, Raw0, Raw2, Raw4, Raw6 } from '../types'
+import type { BuildCtx } from './util'
+
+/** Raw 1-arg C-ABI symbol signature (a lone scalar arg or a bare pointer). */
+type Raw1 = (a: unknown) => number | bigint
+
+/**
+ * Build the off-thread task-runtime methods of the BunFFI surface. `ctx`
+ * supplies the probe-gated length adapter (`lenOrView`).
+ */
+export function buildTask(
+  sym: Record<string, (...a: unknown[]) => unknown>,
+  ctx: BuildCtx,
+): Partial<BunFFI> {
+  const { lenOrView } = ctx
+
+  const init = sym.castrum_task_init as Raw1
+  const submit = sym.castrum_task_submit as Raw4
+  const submitOut = sym.castrum_task_submit_out as Raw6
+  const submitSlice = sym.castrum_task_submit_slice as Raw6
+  const drain = sym.castrum_task_drain as Raw2
+  const pending = sym.castrum_task_pending as Raw0
+  const cancel = sym.castrum_task_cancel as Raw1
+  const setDoorbell = sym.castrum_task_set_doorbell as Raw1
+  const shutdown = sym.castrum_task_shutdown as Raw0
+  const threads = sym.castrum_task_threads as Raw0
+
+  return {
+    taskInit: (n) => Number(init(n)),
+    // `args` is copied onto the worker by Rust, so the caller's pooled buffer
+    // may be released as soon as this returns.
+    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))),
+    // Zero-copy INPUT: the header is copied by Rust, the payload is read in
+    // place — which is why the runtime must hold a reference to `data` for the
+    // whole task (see `Deferred.keep` in src/task/runtime.ts).
+    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()),
+  }
+}
+
+/**
+ * Bind-time self-test for the task symbols. The pool is intentionally NOT
+ * started here (no threads at import time) and no completion is produced;
+ * the full submit→drain→doorbell path is exercised by `test/unit/task/`.
+ */
+export function selfTestTask(b: BunFFI): boolean {
+  try {
+    if (typeof b.taskPending() !== 'number') return false
+    if (typeof b.taskThreads() !== 'number' || b.taskThreads() < 0) return false
+    // `0` disables the doorbell — safe at bind time (nothing is in flight).
+    if (b.taskSetDoorbell(0) !== 1) return false
+    // An empty ring → 0; exercises the drain symbol without allocating anything.
+    if (typeof b.taskDrain(new Uint8Array(4)) !== 'number') return false
+    // NOT called: submitting here would start the pool threads at bind time.
+    // The full submit/submit_out path is exercised by test/unit/task/.
+    if (typeof b.taskSubmitOut !== 'function') return false
+    if (typeof b.taskSubmitSlice !== 'function') return false
+    return true
+  } catch {
+    return false
+  }
+}

package/src/native/ffi/build/util.ts

@@ -42,6 +42,37 @@ export interface BuildCtx {
 /** Coerce an optional boolean to the C `u8` flag (1/0). */
 export const flag = (v?: boolean): number => (v ? 1 : 0)
 
+/**
+ * Does this string contain a NUL (`U+0000`)?
+ *
+ * `bun:ffi` transcodes a JS string passed to a `cstring` ARG into a
+ * NUL-TERMINATED UTF-8 buffer, so an embedded NUL SILENTLY TRUNCATES the value
+ * on the native side (Bun's docs describe the transcode; the truncation is the
+ * C convention it inherits). That is fine when the string is developer-supplied
+ * config or NUL-free by construction — and it is a real bug when the callee
+ * answers with a VERDICT (validators, query/cookie gates, batch validators: a
+ * truncated prefix passes where the full input fails) or when the exact bytes
+ * are the result (`regexEscape`, metric label values).
+ *
+ * Guard contract for every `cstring` ARG reachable from user input: either
+ * reject/short-circuit on NUL, or route to the `(ptr, usize)` byte form which
+ * carries the exact length. `test/unit/native/cstring-nul.test.ts` pins this.
+ */
+export { hasNul } from '../../../shared/bytes'
+
+/**
+ * Output-buffer allocation for the FFI wrappers. The native write fills
+ * `[0, w)` and only `subarray(0, w)` escapes, so zero-initialization is pure
+ * waste: `Buffer.allocUnsafe` skips it (measured ~2x at 4 KB, ~3.4x at 16 KB
+ * on Bun 1.4; small sizes stay on the plain constructor where it is faster).
+ */
+export function allocOut(n: number): Uint8Array {
+  if (n >= 512 && typeof Buffer !== 'undefined' && typeof Buffer.allocUnsafe === 'function') {
+    return Buffer.allocUnsafe(n)
+  }
+  return new Uint8Array(n)
+}
+
 /**
  * Write with the C ABI's "needed" convention. The C side returns the EXACT
  * total bytes the result requires: `0` = real error (throw immediately — no
@@ -59,7 +90,7 @@ export function growExact(
 ): Uint8Array {
   let cap = Math.min(Math.max(initial, 16), max)
   for (;;) {
-    const out = new Uint8Array(cap)
+    const out = allocOut(cap)
     const w = Number(write(out))
     if (w === 0) throw new Error(error)
     if (w <= out.length) return out.subarray(0, w)

package/src/native/ffi/build.ts

@@ -14,7 +14,9 @@
 import { buildCodecs } from './build/codecs'
 import { buildCompress } from './build/compress'
 import { buildInstances } from './build/instances'
+import { buildMetrics } from './build/metrics'
 import { buildParse } from './build/parse'
+import { buildTask } from './build/task'
 import type { BuildCtx } from './build/util'
 import type { BunFFI } from './types'
 
@@ -90,5 +92,7 @@ export function build(
     ...buildCompress(sym, ctx),
     ...buildParse(sym, ctx),
     ...buildInstances(sym, ctx),
+    ...buildMetrics(sym, ctx),
+    ...buildTask(sym, ctx),
   } as BunFFI
 }

package/src/native/ffi/selftest.ts

@@ -7,16 +7,25 @@
 // the safety net. New C-ABI symbols MUST be added to the self-test for their
 // domain: each check lives in the same `ffi/build/` file where the method is
 // bound (`selfTestCodecs` / `selfTestCompress` / `selfTestParse` /
-// `selfTestInstances`), and this entry point ANDs them together so any single
-// failure disables the whole layer.
+// `selfTestInstances` / `selfTestMetrics`), and this entry point ANDs them
+// together so any single failure disables the whole layer.
 
 import { selfTestCodecs } from './build/codecs'
 import { selfTestCompress } from './build/compress'
 import { selfTestInstances } from './build/instances'
+import { selfTestMetrics } from './build/metrics'
 import { selfTestParse } from './build/parse'
+import { selfTestTask } from './build/task'
 import type { BunFFI } from './types'
 
 /** Verify every bound function against known-good results; false disables ffi. */
 export function selfTest(b: BunFFI): boolean {
-  return selfTestCodecs(b) && selfTestCompress(b) && selfTestParse(b) && selfTestInstances(b)
+  return (
+    selfTestCodecs(b) &&
+    selfTestCompress(b) &&
+    selfTestParse(b) &&
+    selfTestInstances(b) &&
+    selfTestMetrics(b) &&
+    selfTestTask(b)
+  )
 }