castrum 0.7.0 → 0.9.1

package/src/bench/tasks/token.ts

@@ -1,20 +0,0 @@
-import * as native from "../../baseline";
-import { rust } from "../../rust-ffi";
-import type { BenchTask } from "../types";
-
-export function tokenTasks(): BenchTask[] {
-  return [
-    {
-      name: "native:random_token",
-      run: () => native.nativeRandomToken(32).byteLength,
-      iterations: 1000,
-      warmup: 100,
-    },
-    {
-      name: "rust:random_token",
-      run: () => rust.randomToken(32).byteLength,
-      iterations: 1000,
-      warmup: 100,
-    },
-  ];
-}

package/src/bench/tasks/url.ts

@@ -1,34 +0,0 @@
-import * as native from "../../baseline";
-import { rust } from "../../rust-ffi";
-import type { BenchFixtures } from "../fixtures";
-import type { BenchTask } from "../types";
-
-export function urlTasks(f: BenchFixtures): BenchTask[] {
-  return [
-    {
-      name: "native:url_encode",
-      run: () => native.nativeUrlEncode("hello world & foo=bar").length,
-      iterations: 1000,
-      warmup: 100,
-    },
-    {
-      name: "rust:url_encode",
-      run: () => rust.urlEncode(f.urlEncodeInput).byteLength,
-      iterations: 1000,
-      warmup: 100,
-    },
-    {
-      name: "native:url_decode",
-      run: () =>
-        native.nativeUrlDecode("hello%20world%20%26%20foo%3Dbar").length,
-      iterations: 1000,
-      warmup: 100,
-    },
-    {
-      name: "rust:url_decode",
-      run: () => rust.urlDecode(f.urlDecodeInput).byteLength,
-      iterations: 1000,
-      warmup: 100,
-    },
-  ];
-}

package/src/bench/tasks/validation.ts

@@ -1,57 +0,0 @@
-import * as native from "../../baseline";
-import { rust } from "../../rust-ffi";
-import type { BenchFixtures } from "../fixtures";
-import type { BenchTask } from "../types";
-
-export function validationTasks(f: BenchFixtures): BenchTask[] {
-  return [
-    {
-      name: "native:validate_email",
-      run: () => (native.nativeValidateEmail(f.emailOk) ? 1 : 0),
-      iterations: 1000,
-      warmup: 100,
-    },
-    {
-      name: "rust:validate_email",
-      run: () => rust.validateEmail(f.emailOk),
-      iterations: 1000,
-      warmup: 100,
-    },
-    {
-      name: "native:validate_uuid",
-      run: () => (native.nativeValidateUuid(f.uuidOk) ? 1 : 0),
-      iterations: 1000,
-      warmup: 100,
-    },
-    {
-      name: "rust:validate_uuid",
-      run: () => rust.validateUuid(f.uuidOk),
-      iterations: 1000,
-      warmup: 100,
-    },
-    {
-      name: "native:validate_ipv4",
-      run: () => (native.nativeValidateIpv4(f.ipv4Ok) ? 1 : 0),
-      iterations: 1000,
-      warmup: 100,
-    },
-    {
-      name: "rust:validate_ipv4",
-      run: () => rust.validateIpv4(f.ipv4Ok),
-      iterations: 1000,
-      warmup: 100,
-    },
-    {
-      name: "native:validate_ipv6",
-      run: () => (native.nativeValidateIpv6(f.ipv6Ok) ? 1 : 0),
-      iterations: 1000,
-      warmup: 100,
-    },
-    {
-      name: "rust:validate_ipv6",
-      run: () => rust.validateIpv6(f.ipv6Ok),
-      iterations: 1000,
-      warmup: 100,
-    },
-  ];
-}

package/src/bench/tasks/websocket.ts

@@ -1,21 +0,0 @@
-import * as native from "../../baseline";
-import { rust } from "../../rust-ffi";
-import type { BenchFixtures } from "../fixtures";
-import type { BenchTask } from "../types";
-
-export function websocketTasks(f: BenchFixtures): BenchTask[] {
-  return [
-    {
-      name: "native:ws_accept_key",
-      run: () => native.nativeWsAcceptKey(f.wsKey).byteLength,
-      iterations: 1000,
-      warmup: 100,
-    },
-    {
-      name: "rust:ws_accept_key",
-      run: () => rust.wsAcceptKey(f.wsKeyBytes).byteLength,
-      iterations: 1000,
-      warmup: 100,
-    },
-  ];
-}

package/src/bench/types.ts

@@ -1,60 +0,0 @@
-export interface BenchResult {
-  name: string;
-  iterations: number;
-  avgMs: number;
-  p50Ms: number;
-  p95Ms: number;
-  opsPerSec: number;
-  checksum: string;
-}
-
-export interface ConcurrentBenchResult {
-  name: string;
-  iterations: number;
-  concurrency: number;
-  totalOps: number;
-  totalMs: number;
-  avgMs: number;
-  p50Ms: number;
-  p95Ms: number;
-  opsPerSec: number;
-  checksum: string;
-}
-
-export interface StressBenchResult {
-  name: string;
-  durationMs: number;
-  totalOps: number;
-  opsPerSec: number;
-  avgMs: number;
-  checksum: string;
-}
-
-export interface BenchTask {
-  name: string;
-  run: () => unknown;
-  iterations: number;
-  warmup: number;
-}
-
-export interface ConcurrentBenchTask {
-  name: string;
-  op: string;
-  payload: unknown;
-  concurrency: number;
-  iterationsPerSlot: number;
-  warmupPerSlot: number;
-}
-
-export interface StressBenchTask {
-  name: string;
-  run: () => unknown;
-  durationMs: number;
-  warmupMs: number;
-}
-
-export interface ComparisonReport {
-  label: string;
-  nativeName: string;
-  rustName: string;
-}

package/src/data/json-rows.ts

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

package/src/ingress/packed-input.ts

@@ -1,59 +0,0 @@
-export class IngressInputPacker {
-  private buf: Uint8Array;
-  private view: DataView;
-  private pos = 0;
-
-  constructor(initialSize = 65536) {
-    this.buf = new Uint8Array(Math.max(1024, initialSize));
-    this.view = new DataView(this.buf.buffer);
-  }
-
-  private ensure(additional: number): void {
-    const needed = this.pos + additional;
-    if (needed <= this.buf.byteLength) return;
-
-    let nextSize = this.buf.byteLength * 2;
-    while (nextSize < needed) {
-      nextSize *= 2;
-    }
-
-    const next = new Uint8Array(nextSize);
-    next.set(this.buf.subarray(0, this.pos));
-
-    this.buf = next;
-    this.view = new DataView(next.buffer);
-  }
-
-  private writeU8(value: number): void {
-    this.ensure(1);
-    this.buf[this.pos++] = value & 0xff;
-  }
-
-  private writeLenPrefixed(bytes: Uint8Array): void {
-    this.ensure(4 + bytes.byteLength);
-
-    this.view.setUint32(this.pos, bytes.byteLength, true);
-    this.pos += 4;
-
-    this.buf.set(bytes, this.pos);
-    this.pos += bytes.byteLength;
-  }
-
-  pack(
-    methodKind: number,
-    urlBytes: Uint8Array,
-    ipBytes: Uint8Array,
-    requestIdBytes: Uint8Array,
-    headers: Uint8Array,
-  ): Uint8Array {
-    this.pos = 0;
-
-    this.writeU8(methodKind);
-    this.writeLenPrefixed(urlBytes);
-    this.writeLenPrefixed(ipBytes);
-    this.writeLenPrefixed(requestIdBytes);
-    this.writeLenPrefixed(headers);
-
-    return this.buf.subarray(0, this.pos);
-  }
-}

package/src/shared/json.ts

@@ -1,18 +0,0 @@
-export function sortKeys(value: unknown): unknown {
-  if (value === null || typeof value !== "object") {
-    return value;
-  }
-
-  if (Array.isArray(value)) {
-    return value.map(sortKeys);
-  }
-
-  const record = value as Record<string, unknown>;
-  const sorted: Record<string, unknown> = {};
-
-  for (const key of Object.keys(record).sort()) {
-    sorted[key] = sortKeys(record[key]);
-  }
-
-  return sorted;
-}

package/src/shared/packed.ts

@@ -1,316 +0,0 @@
-import { decoder, encoder } from "./bytes";
-import addon from "../native";
-import type { SchemaValidatorInstance } from "../native";
-
-export type SchemaValidator = SchemaValidatorInstance;
-
-function dataView(bytes: Uint8Array): DataView {
-  return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-}
-
-function readU32(dv: DataView, offset: number): number {
-  if (offset + 4 > dv.byteLength) {
-    throw new RangeError("packed buffer: truncated u32");
-  }
-
-  return dv.getUint32(offset, true);
-}
-
-function readSlice(bytes: Uint8Array, offset: number, len: number): Uint8Array {
-  if (len < 0 || offset + len > bytes.byteLength) {
-    throw new RangeError("packed buffer: truncated bytes");
-  }
-
-  return bytes.subarray(offset, offset + len);
-}
-
-export function unpackU32Array(bytes: Uint8Array): Uint32Array {
-  if (bytes.byteLength < 4) {
-    return new Uint32Array(0);
-  }
-
-  const dv = dataView(bytes);
-  const count = readU32(dv, 0);
-
-  if (count > Math.floor((bytes.byteLength - 4) / 4)) {
-    throw new RangeError("packed buffer: invalid u32 count");
-  }
-
-  const out = new Uint32Array(count);
-
-  for (let i = 0; i < count; i++) {
-    out[i] = readU32(dv, 4 + i * 4);
-  }
-
-  return out;
-}
-
-export function unpackBitset(bytes: Uint8Array): Uint8Array {
-  if (bytes.byteLength < 4) {
-    return new Uint8Array(0);
-  }
-
-  const dv = dataView(bytes);
-  const count = readU32(dv, 0);
-  const expectedBytes = Math.ceil(count / 8);
-
-  if (bytes.byteLength < 4 + expectedBytes) {
-    throw new RangeError("packed buffer: truncated bitset");
-  }
-
-  const bits = bytes.subarray(4);
-  const out = new Uint8Array(count);
-
-  for (let i = 0; i < count; i++) {
-    const byte = bits[i >> 3] ?? 0;
-    out[i] = (byte >> (i & 7)) & 1;
-  }
-
-  return out;
-}
-
-export function unpackI64ArrayAsBigInt(bytes: Uint8Array): BigInt64Array {
-  if (bytes.byteLength < 4) {
-    return new BigInt64Array(0);
-  }
-
-  const dv = dataView(bytes);
-  const count = readU32(dv, 0);
-
-  if (count > Math.floor((bytes.byteLength - 4) / 8)) {
-    throw new RangeError("packed buffer: invalid i64 count");
-  }
-
-  const out = new BigInt64Array(count);
-
-  for (let i = 0; i < count; i++) {
-    out[i] = dv.getBigInt64(4 + i * 8, true);
-  }
-
-  return out;
-}
-
-export function unpackByteResults(bytes: Uint8Array): Uint8Array[] {
-  if (bytes.byteLength < 4) {
-    return [];
-  }
-
-  const dv = dataView(bytes);
-  const count = readU32(dv, 0);
-
-  const out: Uint8Array[] = [];
-  let offset = 4;
-
-  for (let i = 0; i < count; i++) {
-    const len = readU32(dv, offset);
-    offset += 4;
-
-    const slice = readSlice(bytes, offset, len);
-    offset += len;
-
-    out.push(slice);
-  }
-
-  return out;
-}
-
-export type Pair = [string, string];
-
-export function readPairsPacked(bytes: Uint8Array): Pair[] {
-  if (bytes.byteLength < 4) {
-    return [];
-  }
-
-  const dv = dataView(bytes);
-  const count = readU32(dv, 0);
-
-  if (count === 0) {
-    return [];
-  }
-
-  const out: Pair[] = [];
-  let offset = 4;
-
-  for (let i = 0; i < count; i++) {
-    const keyLen = readU32(dv, offset);
-    offset += 4;
-
-    const keyBytes = readSlice(bytes, offset, keyLen);
-    offset += keyLen;
-
-    const valueLen = readU32(dv, offset);
-    offset += 4;
-
-    const valueBytes = readSlice(bytes, offset, valueLen);
-    offset += valueLen;
-
-    out.push([decoder.decode(keyBytes), decoder.decode(valueBytes)]);
-  }
-
-  return out;
-}
-
-export function pairsToObject(
-  pairs: Pair[],
-): Record<string, string | string[]> {
-  const out: Record<string, string | string[]> = {};
-
-  for (const [key, value] of pairs) {
-    const existing = out[key];
-
-    if (existing === undefined) {
-      out[key] = value;
-    } else if (Array.isArray(existing)) {
-      existing.push(value);
-    } else {
-      out[key] = [existing, value];
-    }
-  }
-
-  return out;
-}
-
-export interface ParsedHttpRequestPacked {
-  method: string;
-  path: string;
-  version: string;
-  headers: Record<string, string>;
-}
-
-export function readHttpPacked(bytes: Uint8Array): ParsedHttpRequestPacked {
-  const dv = dataView(bytes);
-  let offset = 0;
-
-  const methodLen = readU32(dv, offset);
-  offset += 4;
-  const method = decoder.decode(readSlice(bytes, offset, methodLen));
-  offset += methodLen;
-
-  const pathLen = readU32(dv, offset);
-  offset += 4;
-  const path = decoder.decode(readSlice(bytes, offset, pathLen));
-  offset += pathLen;
-
-  const versionLen = readU32(dv, offset);
-  offset += 4;
-  const version = decoder.decode(readSlice(bytes, offset, versionLen));
-  offset += versionLen;
-
-  const headerCount = readU32(dv, offset);
-  offset += 4;
-
-  const headers: Record<string, string> = {};
-
-  for (let i = 0; i < headerCount; i++) {
-    const nameLen = readU32(dv, offset);
-    offset += 4;
-    const name = decoder.decode(readSlice(bytes, offset, nameLen));
-    offset += nameLen;
-
-    const valueLen = readU32(dv, offset);
-    offset += 4;
-    const value = decoder.decode(readSlice(bytes, offset, valueLen));
-    offset += valueLen;
-
-    headers[name] = value;
-  }
-
-  return {
-    method,
-    path,
-    version,
-    headers,
-  };
-}
-
-export function packBatch(items: Uint8Array[]): Uint8Array {
-  let total = 4;
-
-  for (const item of items) {
-    total += 4 + item.byteLength;
-  }
-
-  const out = new Uint8Array(total);
-  const dv = new DataView(out.buffer);
-
-  dv.setUint32(0, items.length, true);
-
-  let offset = 4;
-
-  for (const item of items) {
-    dv.setUint32(offset, item.byteLength, true);
-    offset += 4;
-
-    out.set(item, offset);
-    offset += item.byteLength;
-  }
-
-  return out;
-}
-
-export function packPairs(pairs: Array<[string, string]>): Uint8Array {
-  const encoded = pairs.map(
-    ([key, value]) => [encoder.encode(key), encoder.encode(value)] as const,
-  );
-
-  let total = 4;
-
-  for (const [key, value] of encoded) {
-    total += 8 + key.byteLength + value.byteLength;
-  }
-
-  const out = new Uint8Array(total);
-  const dv = new DataView(out.buffer);
-
-  dv.setUint32(0, encoded.length, true);
-
-  let offset = 4;
-
-  for (const [key, value] of encoded) {
-    dv.setUint32(offset, key.byteLength, true);
-    offset += 4;
-    out.set(key, offset);
-    offset += key.byteLength;
-
-    dv.setUint32(offset, value.byteLength, true);
-    offset += 4;
-    out.set(value, offset);
-    offset += value.byteLength;
-  }
-
-  return out;
-}
-
-export function schemaValidateBatch(
-  validator: SchemaValidator,
-  items: Uint8Array[],
-): Uint8Array {
-  return unpackBitset(validator.validateBatchPackedBitset(packBatch(items)));
-}
-
-export function schemaValidateBatchCount(
-  validator: SchemaValidator,
-  items: Uint8Array[],
-): number {
-  return validator.validateBatchPackedCount(packBatch(items));
-}
-
-// ── High-level string parsers (convenience) ──────────────────────
-// Wrap the native packed parsers + decoders for ergonomic use, so consumers
-// don't have to hand-pack buffers or decode packed pairs:
-//   parseQueryString("a=1&b=2")    // { a: "1", b: "2" }
-//   parseCookieHeader("a=1; b=2")  // { a: "1", b: "2" }
-
-export function parseQueryString(
-  query: string,
-): Record<string, string | string[]> {
-  const packed = addon.queryParsePacked(encoder.encode(query));
-  return pairsToObject(readPairsPacked(packed));
-}
-
-export function parseCookieHeader(
-  header: string,
-): Record<string, string | string[]> {
-  const packed = addon.cookieParsePacked(encoder.encode(header));
-  return pairsToObject(readPairsPacked(packed));
-}