@spikard/wasm 0.6.2 → 0.7.1

package/dist/node.js

@@ -0,0 +1,2401 @@
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+var zlib = require('zlib');
+var fflate = require('fflate');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var path__default = /*#__PURE__*/_interopDefault(path);
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/streaming.ts
+var STREAM_HANDLE_PROP = /* @__PURE__ */ Symbol.for("spikard.streaming.handle");
+var StreamingResponse = class {
+  statusCode;
+  headers;
+  [STREAM_HANDLE_PROP];
+  __spikard_streaming__;
+  constructor(stream, init) {
+    this[STREAM_HANDLE_PROP] = toAsyncIterator(stream);
+    this.statusCode = init?.statusCode ?? 200;
+    this.headers = init?.headers ?? {};
+    this.__spikard_streaming__ = true;
+  }
+  async collect() {
+    const chunks = [];
+    for await (const chunk of this[STREAM_HANDLE_PROP]) {
+      chunks.push(normalizeChunk(chunk));
+    }
+    return concatChunks(chunks);
+  }
+};
+function isStreamingResponse(value) {
+  return Boolean(value) && value instanceof StreamingResponse;
+}
+function toAsyncIterator(source) {
+  if (!source || typeof source !== "object") {
+    throw new TypeError("StreamingResponse requires an async iterator or generator");
+  }
+  if (typeof source.next === "function") {
+    const iterator = source;
+    if (typeof iterator[Symbol.asyncIterator] === "function") {
+      return iterator;
+    }
+    return wrapIterator(iterator);
+  }
+  if (typeof source[Symbol.asyncIterator] === "function") {
+    return source[Symbol.asyncIterator]();
+  }
+  throw new TypeError("StreamingResponse requires an async iterator or generator");
+}
+function wrapIterator(iterator) {
+  return {
+    next: iterator.next.bind(iterator),
+    ...iterator.throw ? { throw: iterator.throw.bind(iterator) } : {},
+    ...iterator.return ? { return: iterator.return.bind(iterator) } : {},
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+  };
+}
+function normalizeChunk(chunk) {
+  if (typeof chunk === "string") {
+    return new TextEncoder().encode(chunk);
+  }
+  if (chunk instanceof Uint8Array) {
+    return chunk;
+  }
+  if (ArrayBuffer.isView(chunk)) {
+    const view = chunk;
+    return new Uint8Array(view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength));
+  }
+  if (chunk instanceof ArrayBuffer) {
+    return new Uint8Array(chunk);
+  }
+  if (chunk == null) {
+    return new Uint8Array();
+  }
+  return new TextEncoder().encode(typeof chunk === "object" ? JSON.stringify(chunk) : String(chunk));
+}
+function concatChunks(chunks) {
+  if (chunks.length === 1) {
+    return chunks[0] ?? new Uint8Array();
+  }
+  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
+var globalAny = globalThis;
+var wasmBindingsPromise = null;
+async function loadWasmBindings() {
+  if (wasmBindingsPromise) {
+    return wasmBindingsPromise;
+  }
+  wasmBindingsPromise = (async () => {
+    const distPath = "./spikard_wasm.js";
+    const runtimePath = "../runtime/spikard_wasm.js";
+    const webFallback = "../../../crates/spikard-wasm/dist-web/spikard_wasm.js";
+    const nodeFallback = "../../../crates/spikard-wasm/dist-node/spikard_wasm.js";
+    const preferNode = isNodeLikeEnvironment();
+    const candidates = preferNode ? [distPath, nodeFallback, runtimePath, webFallback] : [distPath, runtimePath, webFallback, nodeFallback];
+    for (const candidate of candidates) {
+      try {
+        return await import(candidate);
+      } catch {
+      }
+    }
+    throw new Error("Failed to load WASM bindings (dist, runtime, dist-web, dist-node).");
+  })();
+  return wasmBindingsPromise;
+}
+var defaultNativeClientFactory = async (routesJson, handlers, config, lifecycleHooks, dependencies) => {
+  const bindings = await loadWasmBindings();
+  if (typeof bindings.default === "function") {
+    await bindings.default();
+  }
+  await Promise.resolve(bindings.init());
+  return new bindings.TestClient(routesJson, handlers, config, lifecycleHooks, dependencies);
+};
+var nativeClientFactory = defaultNativeClientFactory;
+var textDecoder = new TextDecoder();
+var textEncoder = new TextEncoder();
+var RAW_REQUEST_KEY = "__spikard_raw_request__";
+var ABORT_SIGNAL_KEY = "__spikard_abort_signal__";
+var EMPTY_HOOKS = {
+  onRequest: [],
+  preValidation: [],
+  preHandler: [],
+  onResponse: [],
+  onError: []
+};
+var gunzipImplementation = null;
+function __setGunzipImplementation(fn) {
+  gunzipImplementation = fn;
+}
+var TestResponse = class {
+  constructor(status, headersMap, body) {
+    this.status = status;
+    this.headersMap = headersMap;
+    this.bodyBytes = toUint8Array(body);
+  }
+  bodyBytes;
+  decodedBody = null;
+  get statusCode() {
+    return this.status;
+  }
+  headers() {
+    return { ...this.headersMap };
+  }
+  text() {
+    return textDecoder.decode(this.getDecodedBody());
+  }
+  json() {
+    const body = this.getDecodedBody();
+    if (body.length === 0) {
+      return null;
+    }
+    const textValue = textDecoder.decode(body);
+    try {
+      return JSON.parse(textValue);
+    } catch {
+      return textValue;
+    }
+  }
+  bytes() {
+    const decoded = this.getDecodedBody();
+    const bufferCtor = globalAny.Buffer;
+    if (bufferCtor) {
+      return bufferCtor.from(decoded);
+    }
+    return decoded.slice();
+  }
+  raw() {
+    return this.bodyBytes.slice();
+  }
+  getDecodedBody() {
+    if (this.decodedBody) {
+      return this.decodedBody;
+    }
+    const encoding = this.getHeaderValue("content-encoding");
+    if (encoding && encoding.toLowerCase() === "gzip") {
+      this.decodedBody = gunzipBytes(this.bodyBytes);
+      return this.decodedBody;
+    }
+    this.decodedBody = this.bodyBytes;
+    return this.decodedBody;
+  }
+  getHeaderValue(name) {
+    for (const [key, value] of Object.entries(this.headersMap)) {
+      if (key.toLowerCase() === name.toLowerCase()) {
+        return value;
+      }
+    }
+    return void 0;
+  }
+};
+var TestClient = class {
+  routes;
+  websocketRoutes;
+  websocketHandlers;
+  nativeClientPromise;
+  constructor(app) {
+    if (!app || !Array.isArray(app.routes)) {
+      throw new Error("Invalid Spikard app: missing routes");
+    }
+    this.routes = app.routes;
+    this.websocketRoutes = app.websocketRoutes ?? [];
+    const httpHandlers = app.handlers ?? {};
+    this.websocketHandlers = app.websocketHandlers ?? httpHandlers;
+    const routesJson = JSON.stringify(app.routes);
+    const lifecycleHooks = normalizeLifecycleHooks(app.lifecycleHooks);
+    const wrappedHandlers = wrapHandlers(httpHandlers);
+    const dependencies = app.dependencies ?? null;
+    const nativeLifecycleHooks = createNativeLifecycleHooks(lifecycleHooks);
+    this.nativeClientPromise = (async () => {
+      const resolvedApp = await withStaticManifest(app);
+      const configString = resolvedApp.config && Object.keys(resolvedApp.config).length > 0 ? JSON.stringify(resolvedApp.config) : null;
+      return nativeClientFactory(routesJson, wrappedHandlers, configString, nativeLifecycleHooks, dependencies);
+    })();
+  }
+  async get(path2, headers) {
+    const native = await this.nativeClientPromise;
+    const snapshot = await this.dispatchWithHeaders(native, "GET", path2, headers);
+    return this.responseFromNative(snapshot);
+  }
+  async delete(path2, headers) {
+    const native = await this.nativeClientPromise;
+    const snapshot = await this.dispatchWithHeaders(native, "DELETE", path2, headers);
+    return this.responseFromNative(snapshot);
+  }
+  async head(path2, headers) {
+    const native = await this.nativeClientPromise;
+    const snapshot = await this.dispatchWithHeaders(native, "HEAD", path2, headers);
+    return this.responseFromNative(snapshot);
+  }
+  async options(path2, headers) {
+    const native = await this.nativeClientPromise;
+    const snapshot = await this.dispatchWithHeaders(native, "OPTIONS", path2, headers);
+    return this.responseFromNative(snapshot);
+  }
+  async trace(path2, headers) {
+    const native = await this.nativeClientPromise;
+    const snapshot = await this.dispatchWithHeaders(native, "TRACE", path2, headers);
+    return this.responseFromNative(snapshot);
+  }
+  async post(path2, options) {
+    const native = await this.nativeClientPromise;
+    const snapshot = await native.post(path2, this.buildNativeOptions(options));
+    return this.responseFromNative(snapshot);
+  }
+  async put(path2, options) {
+    const native = await this.nativeClientPromise;
+    const snapshot = await native.put(path2, this.buildNativeOptions(options));
+    return this.responseFromNative(snapshot);
+  }
+  async patch(path2, options) {
+    const native = await this.nativeClientPromise;
+    const snapshot = await native.patch(path2, this.buildNativeOptions(options));
+    return this.responseFromNative(snapshot);
+  }
+  async websocketConnect(path2) {
+    await this.nativeClientPromise;
+    const route2 = this.findWebSocketRoute(path2);
+    if (!route2) {
+      throw new Error(`WebSocket route not found for ${path2}`);
+    }
+    const handler = this.websocketHandlers[route2.metadata.handler_name];
+    if (!handler) {
+      throw new Error(`Handler ${route2.metadata.handler_name} not registered`);
+    }
+    return WebSocketTestConnection.connect(handler);
+  }
+  responseFromNative(snapshot) {
+    const rawHeaders = normalizeRecord(snapshot.headers);
+    const normalizedHeaders = lowerCaseHeaderKeys(rawHeaders);
+    const bodyBytes = toUint8Array(snapshot.body);
+    const unwrapped = tryUnwrapStructuredSnapshot(bodyBytes);
+    if (unwrapped) {
+      const flattened = flattenStructuredResponse(unwrapped);
+      const status = flattened.status ?? flattened.statusCode ?? snapshot.status;
+      const headers = lowerCaseHeaderKeys({
+        ...normalizeRecord(flattened.headers ?? {}),
+        ...normalizedHeaders
+      });
+      const body = flattened.body ?? null;
+      return new TestResponse(status, headers, encodeBodyBytes(body));
+    }
+    return new TestResponse(snapshot.status, normalizedHeaders, bodyBytes);
+  }
+  dispatchWithHeaders(native, method, path2, headers) {
+    const normalizedHeaders = normalizeHeaderInput(headers);
+    if (!normalizedHeaders) {
+      switch (method) {
+        case "GET":
+          return native.get(path2, null);
+        case "DELETE":
+          return native.delete(path2, null);
+        case "HEAD":
+          return native.head(path2, null);
+        case "OPTIONS":
+          return native.options(path2, null);
+        case "TRACE":
+          return native.trace(path2, null);
+        default:
+          return native.get(path2, null);
+      }
+    }
+    const maybeHandleRequest = native.handle_request;
+    if (typeof maybeHandleRequest === "function") {
+      return native.handle_request(JSON.stringify({ method, path: path2, headers: normalizedHeaders }));
+    }
+    switch (method) {
+      case "GET":
+        return native.get(path2, normalizedHeaders);
+      case "DELETE":
+        return native.delete(path2, normalizedHeaders);
+      case "HEAD":
+        return native.head(path2, normalizedHeaders);
+      case "OPTIONS":
+        return native.options(path2, normalizedHeaders);
+      case "TRACE":
+        return native.trace(path2, normalizedHeaders);
+      default:
+        return native.get(path2, normalizedHeaders);
+    }
+  }
+  buildNativeOptions(options) {
+    if (!options) {
+      return null;
+    }
+    const native = {};
+    const headers = this.buildHeaders(options);
+    if (headers) {
+      native.headers = headers;
+    }
+    if (options.multipart) {
+      native.multipart = {
+        fields: options.multipart.fields ?? {},
+        files: options.multipart.files ?? []
+      };
+      return native;
+    }
+    if (options.form && typeof options.form === "object") {
+      native.form = options.form;
+      return native;
+    }
+    if (typeof options.form === "string") {
+      native.formRaw = options.form;
+      return native;
+    }
+    if (options.formRaw) {
+      native.formRaw = options.formRaw;
+      return native;
+    }
+    if ("json" in options) {
+      native.json = options.json == null ? null : normalizeJsonValue(options.json);
+    }
+    if (options.binary) {
+      native.binary = options.binary;
+    }
+    return Object.keys(native).length === 0 ? null : native;
+  }
+  buildHeaders(options) {
+    if (!options?.headers || Object.keys(options.headers).length === 0) {
+      return null;
+    }
+    return normalizeHeaderInput(options.headers);
+  }
+  findRoute(method, targetPath) {
+    for (const metadata of this.routes) {
+      if (!methodsMatch(metadata.method, method)) {
+        continue;
+      }
+      const params = matchPath(metadata.path, targetPath);
+      if (params) {
+        return { metadata, params };
+      }
+    }
+    return void 0;
+  }
+  findWebSocketRoute(targetPath) {
+    for (const metadata of this.websocketRoutes ?? []) {
+      const params = matchPath(metadata.path, targetPath);
+      if (params) {
+        return { metadata, params };
+      }
+    }
+    return this.findRoute("GET", targetPath);
+  }
+};
+function normalizeHeaderInput(headers) {
+  if (!headers) {
+    return null;
+  }
+  const normalized = {};
+  for (const [key, value] of Object.entries(headers)) {
+    normalized[key] = String(value);
+  }
+  return normalized;
+}
+async function withStaticManifest(app) {
+  const config = app.config;
+  if (!config || !config.staticFiles || config.staticFiles.length === 0) {
+    return app;
+  }
+  if (Array.isArray(config.__wasmStaticManifest) && config.__wasmStaticManifest.length > 0) {
+    return app;
+  }
+  const manifest = await buildStaticManifest(config.staticFiles);
+  if (manifest.length === 0) {
+    return app;
+  }
+  return {
+    ...app,
+    config: {
+      ...config,
+      __wasmStaticManifest: manifest
+    }
+  };
+}
+function isNodeLikeEnvironment() {
+  const processValue = globalThis["process"];
+  if (!processValue || typeof processValue !== "object") {
+    return false;
+  }
+  const versionsValue = processValue["versions"];
+  if (!versionsValue || typeof versionsValue !== "object") {
+    return false;
+  }
+  return typeof versionsValue["node"] === "string";
+}
+function hasDeno() {
+  return typeof globalThis["Deno"] === "object";
+}
+function normalizeRoute(route2) {
+  let normalized = route2.replaceAll("\\", "/");
+  while (normalized.includes("//")) {
+    normalized = normalized.replaceAll("//", "/");
+  }
+  if (!normalized.startsWith("/")) {
+    normalized = `/${normalized}`;
+  }
+  return normalized;
+}
+function contentTypeForPath(path2) {
+  const lower = path2.toLowerCase();
+  if (lower.endsWith(".html")) {
+    return "text/html";
+  }
+  if (lower.endsWith(".txt")) {
+    return "text/plain";
+  }
+  if (lower.endsWith(".css")) {
+    return "text/css";
+  }
+  if (lower.endsWith(".js") || lower.endsWith(".mjs")) {
+    return "application/javascript";
+  }
+  if (lower.endsWith(".json")) {
+    return "application/json";
+  }
+  if (lower.endsWith(".svg")) {
+    return "image/svg+xml";
+  }
+  if (lower.endsWith(".png")) {
+    return "image/png";
+  }
+  if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) {
+    return "image/jpeg";
+  }
+  return "application/octet-stream";
+}
+function buildStaticHeaders(filePath, cacheControl) {
+  const headers = {
+    "content-type": contentTypeForPath(filePath)
+  };
+  if (cacheControl) {
+    headers["cache-control"] = cacheControl;
+  }
+  return headers;
+}
+async function buildStaticManifest(configs) {
+  if (isNodeLikeEnvironment()) {
+    const fs2 = await import('fs');
+    const path2 = await import('path');
+    const manifest = [];
+    for (const config of configs) {
+      if (!config.directory || !config.routePrefix) {
+        continue;
+      }
+      if (!fs2.existsSync(config.directory)) {
+        continue;
+      }
+      const stack = [config.directory];
+      while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current) {
+          continue;
+        }
+        const stats = fs2.statSync(current);
+        if (stats.isDirectory()) {
+          for (const child of fs2.readdirSync(current)) {
+            stack.push(path2.join(current, child));
+          }
+          continue;
+        }
+        const relative = path2.relative(config.directory, current).split(path2.sep).join("/");
+        let prefix = config.routePrefix;
+        while (prefix.endsWith("/")) {
+          prefix = prefix.slice(0, -1);
+        }
+        const route2 = normalizeRoute(`${prefix}/${relative}`);
+        const headers = buildStaticHeaders(current, config.cacheControl ?? null);
+        const body = bufferToBase64(new Uint8Array(fs2.readFileSync(current)));
+        manifest.push({ route: route2, headers, body });
+      }
+      if (config.indexFile ?? true) {
+        const indexPath = path2.join(config.directory, "index.html");
+        if (fs2.existsSync(indexPath)) {
+          const headers = buildStaticHeaders(indexPath, config.cacheControl ?? null);
+          const body = bufferToBase64(new Uint8Array(fs2.readFileSync(indexPath)));
+          const prefix = normalizeRoute(config.routePrefix);
+          manifest.push({ route: prefix, headers: { ...headers }, body });
+          if (!prefix.endsWith("/")) {
+            manifest.push({ route: `${prefix}/`, headers: { ...headers }, body });
+          }
+        }
+      }
+    }
+    return manifest;
+  }
+  if (hasDeno()) {
+    const deno = globalThis["Deno"];
+    const manifest = [];
+    for (const config of configs) {
+      if (!config.directory || !config.routePrefix) {
+        continue;
+      }
+      const root = config.directory.replaceAll("\\", "/").replace(/\/+$/, "");
+      const stack = [root];
+      while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current) {
+          continue;
+        }
+        for await (const entry of deno.readDir(current)) {
+          const entryPath = `${current}/${entry.name}`;
+          if (entry.isDirectory) {
+            stack.push(entryPath);
+            continue;
+          }
+          if (!entry.isFile) {
+            continue;
+          }
+          const relative = entryPath.startsWith(`${root}/`) ? entryPath.slice(root.length + 1) : entry.name;
+          let prefix = config.routePrefix;
+          while (prefix.endsWith("/")) {
+            prefix = prefix.slice(0, -1);
+          }
+          const route2 = normalizeRoute(`${prefix}/${relative}`);
+          const headers = buildStaticHeaders(entryPath, config.cacheControl ?? null);
+          const body = bufferToBase64(await deno.readFile(entryPath));
+          manifest.push({ route: route2, headers, body });
+        }
+      }
+      if (config.indexFile ?? true) {
+        const indexPath = `${root}/index.html`;
+        try {
+          const bytes = await deno.readFile(indexPath);
+          const headers = buildStaticHeaders(indexPath, config.cacheControl ?? null);
+          const body = bufferToBase64(bytes);
+          const prefix = normalizeRoute(config.routePrefix);
+          manifest.push({ route: prefix, headers: { ...headers }, body });
+          if (!prefix.endsWith("/")) {
+            manifest.push({ route: `${prefix}/`, headers: { ...headers }, body });
+          }
+        } catch {
+        }
+      }
+    }
+    return manifest;
+  }
+  return [];
+}
+var WebSocketServerSocketImpl = class {
+  constructor(enqueue, onClose) {
+    this.enqueue = enqueue;
+    this.onClose = onClose;
+  }
+  closed = false;
+  async sendText(message) {
+    this.ensureOpen();
+    this.enqueue({ kind: "text", payload: message });
+  }
+  async sendJson(payload) {
+    this.ensureOpen();
+    this.enqueue({ kind: "json", payload });
+  }
+  async sendBytes(payload) {
+    this.ensureOpen();
+    this.enqueue({ kind: "binary", payload: toUint8Array(payload) });
+  }
+  async close(code, reason) {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    await this.onClose(code, reason);
+  }
+  async broadcast(payload) {
+    if (typeof payload === "string") {
+      await this.sendText(payload);
+      return;
+    }
+    await this.sendJson(payload);
+  }
+  isClosed() {
+    return this.closed;
+  }
+  ensureOpen() {
+    if (this.closed) {
+      throw new Error("WebSocket connection is closed");
+    }
+  }
+};
+var WebSocketTestConnection = class _WebSocketTestConnection {
+  constructor(handler) {
+    this.handler = handler;
+    this.socket = new WebSocketServerSocketImpl(
+      (message) => {
+        this.pending.push(message);
+      },
+      async (code, reason) => {
+        this.closed = true;
+        if (isWebSocketHandler(this.handler) && this.handler.onClose) {
+          await this.handler.onClose(this.socket, code, reason);
+        }
+      }
+    );
+  }
+  pending = [];
+  socket;
+  closed = false;
+  static async connect(handler) {
+    const connection = new _WebSocketTestConnection(handler);
+    if (isWebSocketHandler(handler) && handler.onOpen) {
+      await handler.onOpen(connection.socket);
+    }
+    return connection;
+  }
+  async sendJson(payload) {
+    this.ensureOpen();
+    await this.dispatchMessage(payload);
+  }
+  async sendText(payload) {
+    this.ensureOpen();
+    await this.dispatchMessage(payload);
+  }
+  async sendBytes(payload) {
+    this.ensureOpen();
+    await this.dispatchMessage(payload);
+  }
+  async receiveJson() {
+    const message = this.shiftMessage();
+    if (message.kind === "json") {
+      return message.payload;
+    }
+    if (message.kind === "binary") {
+      const text = textDecoder.decode(message.payload);
+      const parsed2 = safeParseJson(text);
+      if (parsed2 === null) {
+        throw new Error("WebSocket binary message is not valid JSON");
+      }
+      return parsed2;
+    }
+    const parsed = safeParseJson(message.payload);
+    if (parsed === null) {
+      throw new Error("WebSocket text message is not valid JSON");
+    }
+    return parsed;
+  }
+  async receiveText() {
+    const message = this.shiftMessage();
+    if (message.kind === "text") {
+      return message.payload;
+    }
+    if (message.kind === "binary") {
+      return textDecoder.decode(message.payload);
+    }
+    return JSON.stringify(message.payload);
+  }
+  async receiveBytes() {
+    const message = this.shiftMessage();
+    if (message.kind === "binary") {
+      return message.payload;
+    }
+    if (message.kind === "text") {
+      return textEncoder.encode(message.payload);
+    }
+    return textEncoder.encode(JSON.stringify(message.payload));
+  }
+  async close(code, reason) {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    this.pending.length = 0;
+    await this.socket.close(code, reason);
+  }
+  async dispatchMessage(payload) {
+    const result = await (isWebSocketHandler(this.handler) ? this.handler.onMessage?.(this.socket, payload) : this.handler(payload));
+    if (result === void 0) {
+      return;
+    }
+    if (isStreamingResponse(result)) {
+      throw new Error("WebSocket handlers cannot return streaming responses");
+    }
+    const message = normalizeWebSocketResult(result);
+    if (message) {
+      this.pending.push(message);
+    }
+  }
+  shiftMessage() {
+    if (this.pending.length === 0) {
+      throw new Error("No WebSocket messages available");
+    }
+    const message = this.pending.shift();
+    if (!message) {
+      throw new Error("No WebSocket messages available");
+    }
+    return message;
+  }
+  ensureOpen() {
+    if (this.closed) {
+      throw new Error("WebSocket connection is closed");
+    }
+  }
+};
+function isWebSocketHandler(handler) {
+  if (typeof handler !== "object" || handler === null) {
+    return false;
+  }
+  const candidate = handler;
+  return typeof candidate.onMessage === "function" || typeof candidate.onOpen === "function" || typeof candidate.onClose === "function";
+}
+function normalizeWebSocketResult(result) {
+  if (result === null || result === void 0) {
+    return null;
+  }
+  if (typeof result === "string") {
+    const parsed = safeParseJson(result);
+    if (parsed === null) {
+      return { kind: "text", payload: result };
+    }
+    return { kind: "json", payload: parsed };
+  }
+  if (isBinaryLike(result)) {
+    return { kind: "binary", payload: toUint8Array(result) };
+  }
+  return { kind: "json", payload: result };
+}
+function safeParseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+function isBinaryLike(value) {
+  return value instanceof ArrayBuffer || ArrayBuffer.isView(value);
+}
+function normalizeRecord(record) {
+  if (!record) {
+    return {};
+  }
+  if (isMapLike(record)) {
+    return Object.fromEntries(record.entries());
+  }
+  return record;
+}
+function normalizeValueRecord(record) {
+  if (!record) {
+    return {};
+  }
+  if (record instanceof Map) {
+    return Object.fromEntries(record.entries());
+  }
+  return record;
+}
+function isMapLike(record) {
+  return Boolean(record) && record instanceof Map;
+}
+function normalizeLifecycleHooks(hooks) {
+  if (!hooks) {
+    return EMPTY_HOOKS;
+  }
+  return {
+    onRequest: [...hooks.onRequest ?? []],
+    preValidation: [...hooks.preValidation ?? []],
+    preHandler: [...hooks.preHandler ?? []],
+    onResponse: [...hooks.onResponse ?? []],
+    onError: [...hooks.onError ?? []]
+  };
+}
+function hasLifecycleHooks(hooks) {
+  return hooks.onRequest.length > 0 || hooks.preValidation.length > 0 || hooks.preHandler.length > 0 || hooks.onResponse.length > 0 || hooks.onError.length > 0;
+}
+function createNativeLifecycleHooks(hooks) {
+  if (!hasLifecycleHooks(hooks)) {
+    return null;
+  }
+  return {
+    onRequest: hooks.onRequest.map((hook) => wrapNativeRequestHook(hook)),
+    preValidation: hooks.preValidation.map((hook) => wrapNativeRequestHook(hook)),
+    preHandler: hooks.preHandler.map((hook) => wrapNativeRequestHook(hook)),
+    onResponse: hooks.onResponse.map((hook) => wrapNativeResponseHook(hook)),
+    onError: hooks.onError.map((hook) => wrapNativeResponseHook(hook))
+  };
+}
+function wrapNativeRequestHook(hook) {
+  return async (payload) => {
+    const wrapped = maybeWrapRequestPayload(payload);
+    if (!isWasmRequest(wrapped)) {
+      throw new Error("Invalid lifecycle request payload");
+    }
+    const request = wrapped;
+    const result = await hook(request);
+    const maybeRequest = ensureWasmRequest(result);
+    if (maybeRequest) {
+      return { type: "request", payload: serializeWasmRequest(maybeRequest) };
+    }
+    const response = await normalizeStructuredResponse(result);
+    return { type: "response", payload: response };
+  };
+}
+function wrapNativeResponseHook(hook) {
+  return async (payload) => {
+    const current = await normalizeStructuredResponse(payload);
+    const result = await hook(current);
+    const maybeRequest = ensureWasmRequest(result);
+    if (maybeRequest) {
+      return { type: "response", payload: current };
+    }
+    const updated = await normalizeStructuredResponse(result, current);
+    return { type: "response", payload: updated };
+  };
+}
+function serializeWasmRequest(request) {
+  return request.toPayload();
+}
+function normalizeJsonValue(value) {
+  if (value instanceof Map) {
+    const result = {};
+    for (const [key, entry] of value.entries()) {
+      result[key] = normalizeJsonValue(entry);
+    }
+    return result;
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => normalizeJsonValue(entry));
+  }
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "object" && value) {
+    const result = {};
+    for (const [key, entry] of Object.entries(value)) {
+      result[key] = normalizeJsonValue(entry);
+    }
+    return result;
+  }
+  return value;
+}
+function lowerCaseHeaderKeys(headers) {
+  const lowered = {};
+  for (const [key, value] of Object.entries(headers)) {
+    lowered[key.toLowerCase()] = value;
+  }
+  return lowered;
+}
+function tryUnwrapStructuredSnapshot(body) {
+  if (body.length === 0) {
+    return null;
+  }
+  const text = textDecoder.decode(body);
+  try {
+    const parsed = JSON.parse(text);
+    if (!isStructuredResponseLike(parsed)) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function flattenStructuredResponse(response) {
+  let current = response;
+  let mergedHeaders = normalizeRecord(current.headers ?? {});
+  while (current.body && typeof current.body === "object" && isStructuredResponseLike(current.body)) {
+    const next = current.body;
+    mergedHeaders = {
+      ...mergedHeaders,
+      ...normalizeRecord(next.headers ?? {})
+    };
+    current = next;
+  }
+  return {
+    ...current,
+    headers: mergedHeaders
+  };
+}
+function encodeBodyBytes(body) {
+  if (body == null) {
+    return new Uint8Array();
+  }
+  if (typeof body === "string") {
+    return textEncoder.encode(body);
+  }
+  return textEncoder.encode(JSON.stringify(body));
+}
+function toUint8Array(value) {
+  if (value instanceof Uint8Array) {
+    return value;
+  }
+  if (value instanceof ArrayBuffer) {
+    return new Uint8Array(value);
+  }
+  if (ArrayBuffer.isView(value)) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  if (typeof Blob !== "undefined" && value instanceof Blob) {
+    throw new Error("Blob payloads are not supported synchronously");
+  }
+  if (isArrayLike(value)) {
+    return Uint8Array.from(value);
+  }
+  throw new Error("Unsupported binary payload");
+}
+function isArrayLike(value) {
+  if (typeof value === "object" && value !== null) {
+    const length = value.length;
+    return typeof length === "number";
+  }
+  return false;
+}
+function gunzipBytes(data) {
+  if (gunzipImplementation) {
+    try {
+      return gunzipImplementation(data);
+    } catch {
+      return data;
+    }
+  }
+  try {
+    return fflate.gunzipSync(data);
+  } catch {
+    return data;
+  }
+}
+function bufferToBase64(bytes) {
+  const bufferCtor = globalAny.Buffer;
+  if (bufferCtor) {
+    return bufferCtor.from(bytes).toString("base64");
+  }
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  if (typeof btoa === "function") {
+    return btoa(binary);
+  }
+  throw new Error("Base64 encoding is not supported in this environment");
+}
+function isAbortSignalLike(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.aborted === "boolean" && typeof candidate.addEventListener === "function" && typeof candidate.removeEventListener === "function";
+}
+function wrapHandlers(handlers) {
+  const wrapped = {};
+  for (const [name, handler] of Object.entries(handlers)) {
+    const looksLikeStringHandler = handler.toString().includes("JSON.parse");
+    wrapped[name] = async (request) => {
+      const rawJson = request && typeof request === "object" && RAW_REQUEST_KEY in request ? String(request[RAW_REQUEST_KEY] ?? "") : JSON.stringify(request);
+      const maybeSignal = request && typeof request === "object" && ABORT_SIGNAL_KEY in request ? request[ABORT_SIGNAL_KEY] : void 0;
+      const context = isAbortSignalLike(maybeSignal) ? { signal: maybeSignal } : void 0;
+      const normalizedRequest = maybeWrapRequestPayload(request);
+      return looksLikeStringHandler ? handler(rawJson, context) : handler(normalizedRequest, context);
+    };
+  }
+  return wrapped;
+}
+var WasmRequest = class {
+  method;
+  path;
+  queryString;
+  headers;
+  params;
+  pathParams;
+  query;
+  files;
+  rawJson;
+  bodyKind;
+  bodyJson;
+  formData;
+  textBody;
+  bodyMetadata = null;
+  bodyDirty = false;
+  _body;
+  constructor(payload, rawJson) {
+    this.rawJson = rawJson;
+    this.method = payload.method;
+    this.path = payload.path;
+    this.params = normalizeValueRecord(payload.params);
+    this.pathParams = normalizeValueRecord(payload.pathParams);
+    this.query = normalizeValueRecord(payload.query);
+    this.headers = normalizeRecord(payload.headers);
+    this.queryString = buildQueryString(payload.rawQuery);
+    const normalizedBody = payload.body == null ? null : normalizeJsonValue(payload.body);
+    let metadata = payload.__spikard_body_metadata__ ?? null;
+    if ((!metadata || metadata.kind === "none") && normalizedBody != null) {
+      metadata = buildBodyMetadata(normalizedBody);
+    }
+    if (metadata) {
+      metadata.kind = normalizeRequestBodyKind(metadata.kind);
+    }
+    this.bodyMetadata = metadata ?? null;
+    const applied = applyBodyMetadata(this.bodyMetadata, normalizedBody);
+    this.bodyKind = applied.kind;
+    this.bodyJson = applied.jsonValue;
+    this.formData = applied.formValue;
+    this.textBody = applied.textValue;
+    if (applied.files !== void 0) {
+      this.files = applied.files;
+    }
+    this._body = applied.buffer;
+  }
+  get body() {
+    return this._body;
+  }
+  set body(value) {
+    this._body = value;
+    this.bodyDirty = true;
+  }
+  json() {
+    let value;
+    if (this.bodyKind === "json" && this.bodyJson !== void 0) {
+      value = this.bodyJson;
+    } else if (this.bodyKind === "text" && this.textBody !== void 0) {
+      try {
+        value = JSON.parse(this.textBody);
+      } catch {
+        throw new Error("Request body is not valid JSON");
+      }
+    } else {
+      throw new Error("Request body is not JSON");
+    }
+    return normalizeJsonValue(value);
+  }
+  form() {
+    if (this.formData) {
+      return { ...this.formData };
+    }
+    throw new Error("Request body is not form data");
+  }
+  toPayload() {
+    const bodyValue = this.buildBodyValue();
+    const metadata = this.getOrBuildBodyMetadata(bodyValue);
+    const payload = {
+      method: this.method,
+      path: this.path,
+      pathParams: { ...this.pathParams },
+      params: { ...this.params },
+      query: { ...this.query },
+      rawQuery: buildRawQueryMap(this.queryString),
+      headers: { ...this.headers },
+      cookies: {},
+      body: bodyValue
+    };
+    if (metadata) {
+      payload.__spikard_body_metadata__ = metadata;
+    }
+    return payload;
+  }
+  buildBodyValue() {
+    const currentBody = this.body;
+    if (!currentBody) {
+      switch (this.bodyKind) {
+        case "json":
+          return this.bodyJson ?? null;
+        case "text":
+          return this.textBody ?? null;
+        case "form":
+          return this.formData ? { __spikard_form__: this.formData } : null;
+        case "multipart":
+          return this.formData || this.files ? {
+            __spikard_multipart__: {
+              fields: this.formData ?? {},
+              files: this.files ?? []
+            }
+          } : null;
+        case "binary":
+          if (this.bodyMetadata?.rawBase64) {
+            return { __spikard_base64__: this.bodyMetadata.rawBase64 };
+          }
+          return null;
+        default:
+          return null;
+      }
+    }
+    if (currentBody instanceof Uint8Array) {
+      return { __spikard_base64__: bufferToBase64(currentBody) };
+    }
+    return normalizeJsonValue(currentBody);
+  }
+  getOrBuildBodyMetadata(bodyValue) {
+    if (!this.bodyDirty && this.bodyMetadata) {
+      return this.bodyMetadata;
+    }
+    const metadata = buildBodyMetadata(bodyValue ?? null);
+    if (metadata) {
+      metadata.kind = normalizeRequestBodyKind(metadata.kind);
+    }
+    this.bodyMetadata = metadata;
+    this.bodyDirty = false;
+    return metadata;
+  }
+  toString() {
+    return this.rawJson;
+  }
+  valueOf() {
+    return this.rawJson;
+  }
+  [Symbol.toPrimitive]() {
+    return this.rawJson;
+  }
+  toJSON() {
+    try {
+      return JSON.parse(this.rawJson);
+    } catch {
+      return {
+        method: this.method,
+        path: this.path
+      };
+    }
+  }
+};
+function isWasmRequest(value) {
+  return value instanceof WasmRequest;
+}
+function maybeWrapRequestPayload(payload) {
+  if (!payload || typeof payload !== "object") {
+    return payload;
+  }
+  if (!("method" in payload) || !("path" in payload)) {
+    return payload;
+  }
+  const candidate = payload;
+  const rawJson = typeof candidate[RAW_REQUEST_KEY] === "string" ? candidate[RAW_REQUEST_KEY] : JSON.stringify(candidate);
+  return new WasmRequest(candidate, rawJson);
+}
+function buildQueryString(raw) {
+  if (!raw) {
+    return "";
+  }
+  const queryRecord = raw instanceof Map ? Object.fromEntries(raw.entries()) : raw;
+  const params = new URLSearchParams();
+  for (const [key, values] of Object.entries(queryRecord)) {
+    for (const value of values ?? []) {
+      params.append(key, value);
+    }
+  }
+  return params.toString();
+}
+function buildRawQueryMap(queryString) {
+  if (!queryString) {
+    return {};
+  }
+  const params = new URLSearchParams(queryString);
+  const record = {};
+  for (const [key, value] of params.entries()) {
+    if (!record[key]) {
+      record[key] = [];
+    }
+    record[key].push(value);
+  }
+  return record;
+}
+function base64ToUint8Array(base64) {
+  const bufferCtor = globalAny.Buffer;
+  if (bufferCtor) {
+    const buf = bufferCtor.from(base64, "base64");
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+  }
+  if (typeof atob === "function") {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i += 1) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+  }
+  throw new Error("Base64 decoding is not supported in this environment");
+}
+function decodeFormValues(values) {
+  const form = {};
+  for (const [key, value] of Object.entries(values)) {
+    if (value == null) {
+      form[key] = "";
+    } else if (typeof value === "string") {
+      form[key] = value;
+    } else {
+      form[key] = JSON.stringify(value);
+    }
+  }
+  return form;
+}
+function buildBuffer(bytes) {
+  if (!bytes) {
+    return null;
+  }
+  const bufferCtor = globalAny.Buffer;
+  if (bufferCtor) {
+    const buf = bufferCtor.from(bytes);
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+  }
+  return bytes;
+}
+function applyBodyMetadata(metadata, payloadBody) {
+  const kind = normalizeRequestBodyKind(metadata?.kind);
+  let buffer = null;
+  if (metadata?.rawBase64) {
+    buffer = buildBuffer(base64ToUint8Array(metadata.rawBase64));
+  }
+  let jsonValue;
+  let formValue;
+  let textValue;
+  const files = metadata?.files;
+  switch (kind) {
+    case "json":
+      jsonValue = metadata?.json ?? payloadBody;
+      if (!buffer && payloadBody != null) {
+        const text = JSON.stringify(payloadBody);
+        buffer = buildBuffer(textEncoder.encode(text));
+      }
+      break;
+    case "form":
+    case "multipart":
+      formValue = metadata?.form ?? void 0;
+      break;
+    case "text":
+      textValue = metadata?.text ?? void 0;
+      if (!buffer && textValue !== void 0) {
+        buffer = buildBuffer(textEncoder.encode(textValue));
+      }
+      break;
+  }
+  return {
+    kind,
+    buffer,
+    jsonValue,
+    formValue,
+    textValue,
+    files
+  };
+}
+function buildBodyMetadata(body) {
+  if (body == null) {
+    return { kind: "none" };
+  }
+  if (typeof body === "string") {
+    const bytes = textEncoder.encode(body);
+    return {
+      kind: "text",
+      text: body,
+      rawBase64: bufferToBase64(bytes)
+    };
+  }
+  if (typeof body === "number" || typeof body === "boolean") {
+    const text = JSON.stringify(body);
+    return {
+      kind: "json",
+      json: body,
+      rawBase64: bufferToBase64(textEncoder.encode(text))
+    };
+  }
+  if (typeof body === "object") {
+    const payload = body;
+    if (typeof payload.__spikard_base64__ === "string") {
+      return {
+        kind: "binary",
+        rawBase64: payload.__spikard_base64__
+      };
+    }
+    if (payload.__spikard_form__ && typeof payload.__spikard_form__ === "object") {
+      const formSource = normalizeValueRecord(
+        payload.__spikard_form__
+      );
+      const formValue = decodeFormValues(formSource);
+      return {
+        kind: "form",
+        form: formValue,
+        rawBase64: bufferToBase64(textEncoder.encode(new URLSearchParams(formValue).toString()))
+      };
+    }
+    if (payload.__spikard_multipart__ && typeof payload.__spikard_multipart__ === "object") {
+      const multipart = payload.__spikard_multipart__;
+      const fields = normalizeValueRecord(multipart.fields);
+      const formValue = decodeFormValues(fields);
+      return {
+        kind: "multipart",
+        form: formValue,
+        files: multipart.files ?? [],
+        rawBase64: bufferToBase64(textEncoder.encode(new URLSearchParams(formValue).toString()))
+      };
+    }
+    return {
+      kind: "json",
+      json: normalizeJsonValue(payload),
+      rawBase64: bufferToBase64(textEncoder.encode(JSON.stringify(payload)))
+    };
+  }
+  return {
+    kind: "json",
+    json: body,
+    rawBase64: bufferToBase64(textEncoder.encode(JSON.stringify(body)))
+  };
+}
+function normalizeRequestBodyKind(value) {
+  switch ((value ?? "none").toLowerCase()) {
+    case "json":
+      return "json";
+    case "form":
+      return "form";
+    case "multipart":
+      return "multipart";
+    case "binary":
+      return "binary";
+    case "text":
+      return "text";
+    default:
+      return "none";
+  }
+}
+function ensureWasmRequest(value) {
+  if (value instanceof WasmRequest) {
+    return value;
+  }
+  if (value && typeof value === "object" && "method" in value && "path" in value) {
+    const rawJson = typeof value[RAW_REQUEST_KEY] === "string" ? value[RAW_REQUEST_KEY] : JSON.stringify(value);
+    return new WasmRequest(value, rawJson);
+  }
+  return null;
+}
+async function normalizeStructuredResponse(value, defaultResponse) {
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value);
+      return normalizeStructuredResponse(parsed);
+    } catch {
+      return {
+        status: 200,
+        headers: {},
+        body: value
+      };
+    }
+  }
+  if (value instanceof WasmRequest) {
+    return defaultResponse ?? {
+      status: 200,
+      headers: {},
+      body: null
+    };
+  }
+  if (isStructuredResponseLike(value)) {
+    const headers = normalizeRecord(value.headers ?? {});
+    const status = value.status ?? value.statusCode ?? 200;
+    const body = value.body === void 0 ? null : typeof value.body === "object" && value.body !== null ? value.body : value.body;
+    return {
+      status,
+      headers,
+      body
+    };
+  }
+  return {
+    status: 200,
+    headers: {},
+    body: value == null ? null : value
+  };
+}
+function isStructuredResponseLike(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const hasStatus = "status" in value || "statusCode" in value;
+  if (!hasStatus) {
+    return false;
+  }
+  return "headers" in value || "body" in value;
+}
+function matchPath(template, actual) {
+  const params = {};
+  const actualPath = actual.split("?")[0] ?? actual;
+  const templateSegments = template.split("/").filter(Boolean);
+  const actualSegments = actualPath.split("/").filter(Boolean);
+  if (templateSegments.length !== actualSegments.length) {
+    return null;
+  }
+  for (let i = 0; i < templateSegments.length; i += 1) {
+    const templateSegment = templateSegments[i];
+    const actualSegment = actualSegments[i];
+    if (templateSegment === void 0 || actualSegment === void 0) {
+      return null;
+    }
+    if (templateSegment.startsWith("{") && templateSegment.endsWith("}")) {
+      const key = templateSegment.slice(1, -1);
+      params[key] = decodeURIComponent(actualSegment);
+    } else if (templateSegment !== actualSegment) {
+      return null;
+    }
+  }
+  return params;
+}
+function methodsMatch(routeMethod, actualMethod) {
+  return routeMethod.toUpperCase() === actualMethod.toUpperCase();
+}
+
+// src/server.ts
+function createFetchHandler(app) {
+  const client = new TestClient(app);
+  return async (request) => {
+    const websocketResponse = await maybeHandleWebSocketUpgrade(app, request);
+    if (websocketResponse) {
+      return websocketResponse;
+    }
+    const url = new URL(request.url);
+    const path2 = `${url.pathname}${url.search}`;
+    const headers = headersToRecord(request.headers);
+    const method = request.method.toUpperCase();
+    const options = await buildRequestOptions(request);
+    let response;
+    switch (method) {
+      case "GET":
+        response = await client.get(path2, headers);
+        break;
+      case "DELETE":
+        response = await client.delete(path2, headers);
+        break;
+      case "HEAD":
+        response = await client.head(path2, headers);
+        break;
+      case "OPTIONS":
+        response = await client.options(path2, headers);
+        break;
+      case "TRACE":
+        response = await client.trace(path2, headers);
+        break;
+      case "POST":
+        response = await client.post(path2, mergeHeaders(options, headers));
+        break;
+      case "PUT":
+        response = await client.put(path2, mergeHeaders(options, headers));
+        break;
+      case "PATCH":
+        response = await client.patch(path2, mergeHeaders(options, headers));
+        break;
+      default:
+        return new Response("Method Not Allowed", { status: 405 });
+    }
+    return responseToFetch(response);
+  };
+}
+function runServer(app, config = {}) {
+  const handler = createFetchHandler(app);
+  const options = resolveServerOptions(config);
+  if (isBun()) {
+    const bun = globalThis.Bun;
+    bun.serve({
+      fetch: (req, server) => {
+        const upgradeResult = maybeUpgradeBunWebSocket(req, server, app);
+        if (upgradeResult) {
+          return upgradeResult;
+        }
+        return handler(req);
+      },
+      websocket: createBunWebSocketHandlers(),
+      hostname: options.host ?? "0.0.0.0",
+      port: options.port ?? 0
+    });
+    return;
+  }
+  const globalAny2 = globalThis;
+  if (globalAny2.Deno && typeof globalAny2.Deno.serve === "function") {
+    globalAny2.Deno.serve(
+      {
+        hostname: options.host ?? "0.0.0.0",
+        port: options.port ?? 0
+      },
+      handler
+    );
+    return;
+  }
+  if (typeof globalAny2.addEventListener === "function") {
+    globalAny2.addEventListener(
+      "fetch",
+      (event) => {
+        event.respondWith(handler(event.request));
+      }
+    );
+    return;
+  }
+  throw new Error("Unsupported runtime: unable to start WASM HTTP server");
+}
+function isBun() {
+  const globalAny2 = globalThis;
+  return typeof globalAny2.Bun === "object" && typeof globalAny2.Bun?.serve === "function";
+}
+function headersToRecord(headers) {
+  const record = {};
+  for (const [key, value] of headers.entries()) {
+    record[key] = value;
+  }
+  return record;
+}
+async function buildRequestOptions(request) {
+  const method = request.method.toUpperCase();
+  if (method === "GET" || method === "HEAD") {
+    return void 0;
+  }
+  const contentType = request.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    const text = await request.text();
+    if (!text) {
+      return { json: null };
+    }
+    try {
+      return { json: JSON.parse(text) };
+    } catch {
+      return { json: text };
+    }
+  }
+  if (contentType.includes("application/x-www-form-urlencoded")) {
+    const text = await request.text();
+    return text ? { formRaw: text } : void 0;
+  }
+  if (contentType.includes("multipart/form-data") && typeof request.formData === "function") {
+    const formData = await request.formData();
+    const fields = {};
+    const files = [];
+    for (const [key, value] of formData.entries()) {
+      if (typeof value === "string") {
+        fields[key] = value;
+      } else {
+        const buffer2 = new Uint8Array(await value.arrayBuffer());
+        const file = {
+          name: key,
+          content: bufferToBase642(buffer2),
+          ...value.name ? { filename: value.name } : {},
+          ...value.type ? { contentType: value.type } : {}
+        };
+        files.push(file);
+      }
+    }
+    return { multipart: { fields, files } };
+  }
+  const buffer = new Uint8Array(await request.arrayBuffer());
+  if (buffer.length === 0) {
+    return void 0;
+  }
+  return { binary: bufferToBase642(buffer) };
+}
+function mergeHeaders(options, headers) {
+  if (options) {
+    return {
+      ...options,
+      headers: {
+        ...options.headers,
+        ...headers
+      }
+    };
+  }
+  return { headers };
+}
+function responseToFetch(response) {
+  const headers = new Headers(response.headers());
+  return new Response(response.raw(), {
+    status: response.statusCode,
+    headers
+  });
+}
+function bufferToBase642(bytes) {
+  const globalAny2 = globalThis;
+  if (globalAny2.Buffer) {
+    return globalAny2.Buffer.from(bytes).toString("base64");
+  }
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  if (typeof btoa === "function") {
+    return btoa(binary);
+  }
+  throw new Error("Base64 encoding is not supported in this runtime");
+}
+function resolveServerOptions(config) {
+  if ("host" in config || "port" in config) {
+    const options = config;
+    const resolved = {};
+    if (options.host !== void 0) {
+      resolved.host = options.host;
+    }
+    if (options.port !== void 0) {
+      resolved.port = options.port;
+    }
+    return resolved;
+  }
+  return {};
+}
+async function maybeHandleWebSocketUpgrade(app, request) {
+  if (!isWebSocketUpgrade(request)) {
+    return null;
+  }
+  const url = new URL(request.url);
+  const match = findWebSocketRoute(app, url.pathname);
+  if (!match) {
+    return new Response("WebSocket route not found", { status: 404 });
+  }
+  const denoUpgrade = getDenoUpgrade();
+  if (denoUpgrade) {
+    const { socket, response } = denoUpgrade(request);
+    startWebSocketSession(socket, match.handler);
+    return response;
+  }
+  const webSocketPair = getWebSocketPair();
+  if (webSocketPair) {
+    const pair = new webSocketPair();
+    const [clientSocket, serverSocket] = pair;
+    const serverSocketWithAccept = serverSocket;
+    serverSocketWithAccept.accept?.();
+    startWebSocketSession(serverSocket, match.handler);
+    const responseInit = {
+      status: 101,
+      webSocket: clientSocket
+    };
+    return new Response(null, responseInit);
+  }
+  return new Response("WebSocket upgrade not supported in this runtime", { status: 501 });
+}
+function buildWebSocketRegistry(app) {
+  return {
+    routes: app.websocketRoutes ?? [],
+    handlers: app.websocketHandlers ?? app.handlers ?? {}
+  };
+}
+function findWebSocketRoute(app, path2) {
+  const registry = buildWebSocketRegistry(app);
+  const routeMatch = findRouteByPath(registry.routes, path2);
+  if (routeMatch) {
+    const handler = registry.handlers[routeMatch.metadata.handler_name];
+    if (handler) {
+      return { metadata: routeMatch.metadata, handler };
+    }
+  }
+  const fallback = findRouteByPath(app.routes ?? [], path2);
+  if (fallback) {
+    const handler = registry.handlers[fallback.metadata.handler_name];
+    if (handler) {
+      return { metadata: fallback.metadata, handler };
+    }
+  }
+  return null;
+}
+function findRouteByPath(routes, targetPath) {
+  for (const metadata of routes) {
+    if (metadata.method !== "GET") {
+      continue;
+    }
+    const params = matchPath2(metadata.path, targetPath);
+    if (params) {
+      return { metadata, params };
+    }
+  }
+  return null;
+}
+function isWebSocketUpgrade(request) {
+  const upgrade = request.headers.get("upgrade");
+  if (!upgrade || upgrade.toLowerCase() !== "websocket") {
+    return false;
+  }
+  const connection = request.headers.get("connection")?.toLowerCase();
+  return !connection || connection.includes("upgrade");
+}
+function getDenoUpgrade() {
+  const denoGlobal = globalThis.Deno;
+  return denoGlobal?.upgradeWebSocket ?? null;
+}
+function getWebSocketPair() {
+  const pairCtor = globalThis.WebSocketPair;
+  return pairCtor ?? null;
+}
+function startWebSocketSession(socket, handler) {
+  const runtimeSocket = createRuntimeSocket(socket);
+  if (isWebSocketHandler2(handler) && handler.onOpen) {
+    void handler.onOpen(runtimeSocket);
+  }
+  socket.addEventListener("message", (event) => {
+    void handleWebSocketMessage(runtimeSocket, handler, event.data).catch(() => {
+      closeSocket(runtimeSocket, 1011, "WebSocket handler error");
+    });
+  });
+  socket.addEventListener("close", (event) => {
+    if (isWebSocketHandler2(handler) && handler.onClose) {
+      void handler.onClose(runtimeSocket, event.code, event.reason);
+    }
+    runtimeSocket.close(event.code, event.reason);
+  });
+}
+async function handleWebSocketMessage(socket, handler, data) {
+  const payload = decodeWebSocketMessage(data);
+  const result = isWebSocketHandler2(handler) ? await handler.onMessage?.(socket, payload) : await handler(payload);
+  if (result === void 0) {
+    return;
+  }
+  if (isStreamingResponse(result)) {
+    throw new Error("WebSocket handlers cannot return streaming responses");
+  }
+  await sendWebSocketResult(socket, result);
+}
+async function sendWebSocketResult(socket, result) {
+  if (result === null || result === void 0) {
+    return;
+  }
+  if (typeof result === "string") {
+    await socket.sendText(result);
+    return;
+  }
+  if (isBinaryLike2(result)) {
+    await socket.sendBytes?.(result);
+    return;
+  }
+  await socket.sendJson(result);
+}
+function decodeWebSocketMessage(data) {
+  if (typeof data === "string") {
+    const parsed = safeParseJson2(data);
+    return parsed ?? data;
+  }
+  if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
+    return data;
+  }
+  if (typeof Blob !== "undefined" && data instanceof Blob) {
+    return data;
+  }
+  return data;
+}
+function safeParseJson2(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+function isBinaryLike2(value) {
+  if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+    return true;
+  }
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function createRuntimeSocket(socket) {
+  let closed = false;
+  return {
+    sendText(message) {
+      if (closed) {
+        throw new Error("WebSocket connection is closed");
+      }
+      socket.send(message);
+    },
+    sendJson(payload) {
+      if (closed) {
+        throw new Error("WebSocket connection is closed");
+      }
+      socket.send(JSON.stringify(payload));
+    },
+    sendBytes(payload) {
+      if (closed) {
+        throw new Error("WebSocket connection is closed");
+      }
+      socket.send(payload);
+    },
+    close(code, reason) {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      socket.close(code, reason);
+    },
+    isClosed() {
+      return closed || socket.readyState === 3;
+    }
+  };
+}
+function closeSocket(socket, code, reason) {
+  try {
+    socket.close(code, reason);
+  } catch {
+  }
+}
+function isWebSocketHandler2(handler) {
+  if (typeof handler !== "object" || handler === null) {
+    return false;
+  }
+  const candidate = handler;
+  return typeof candidate.onOpen === "function" || typeof candidate.onMessage === "function" || typeof candidate.onClose === "function";
+}
+function matchPath2(template, actual) {
+  const templateParts = template.split("/").filter(Boolean);
+  const actualParts = actual.split("/").filter(Boolean);
+  if (templateParts.length !== actualParts.length) {
+    return null;
+  }
+  const params = {};
+  for (let i = 0; i < templateParts.length; i++) {
+    const templatePart = templateParts[i];
+    const actualPart = actualParts[i];
+    if (!templatePart || actualPart === void 0) {
+      return null;
+    }
+    if (templatePart.startsWith(":")) {
+      params[templatePart.slice(1)] = decodeURIComponent(actualPart);
+    } else if (templatePart !== actualPart) {
+      return null;
+    }
+  }
+  return params;
+}
+function maybeUpgradeBunWebSocket(request, server, app) {
+  if (!server || !isWebSocketUpgrade(request)) {
+    return null;
+  }
+  const url = new URL(request.url);
+  const match = findWebSocketRoute(app, url.pathname);
+  if (!match) {
+    return null;
+  }
+  const upgraded = server.upgrade(request, { data: { handler: match.handler, path: url.pathname } });
+  if (upgraded) {
+    return new Response(null, { status: 101 });
+  }
+  return null;
+}
+function createBunWebSocketHandlers() {
+  return {
+    open(ws) {
+      const handler = ws.data?.handler;
+      if (!handler) {
+        return;
+      }
+      const runtimeSocket = createBunRuntimeSocket(ws);
+      ws.data = { handler, socket: runtimeSocket };
+      if (isWebSocketHandler2(handler) && handler.onOpen) {
+        void handler.onOpen(runtimeSocket);
+      }
+    },
+    async message(ws, message) {
+      const handler = ws.data?.handler;
+      const runtimeSocket = ws.data?.socket;
+      if (!handler || !runtimeSocket) {
+        return;
+      }
+      try {
+        await handleWebSocketMessage(runtimeSocket, handler, message);
+      } catch {
+        closeSocket(runtimeSocket, 1011, "WebSocket handler error");
+      }
+    },
+    close(ws, code, reason) {
+      const handler = ws.data?.handler;
+      const runtimeSocket = ws.data?.socket;
+      if (!handler || !runtimeSocket) {
+        return;
+      }
+      if (isWebSocketHandler2(handler) && handler.onClose) {
+        void handler.onClose(runtimeSocket, code, reason);
+      }
+    }
+  };
+}
+function createBunRuntimeSocket(ws) {
+  let closed = false;
+  return {
+    sendText(message) {
+      if (closed) {
+        throw new Error("WebSocket connection is closed");
+      }
+      ws.send(message);
+    },
+    sendJson(payload) {
+      if (closed) {
+        throw new Error("WebSocket connection is closed");
+      }
+      ws.send(JSON.stringify(payload));
+    },
+    sendBytes(payload) {
+      if (closed) {
+        throw new Error("WebSocket connection is closed");
+      }
+      ws.send(payload);
+    },
+    close(code, reason) {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      ws.close?.(code, reason);
+    },
+    isClosed() {
+      return closed;
+    }
+  };
+}
+
+// src/app.ts
+var Spikard = class {
+  routes = [];
+  handlers = {};
+  websocketRoutes = [];
+  websocketHandlers = {};
+  lifecycleHooks = {
+    onRequest: [],
+    preValidation: [],
+    preHandler: [],
+    onResponse: [],
+    onError: []
+  };
+  dependencies = {};
+  /**
+   * Add a route to the application
+   *
+   * @param metadata - Route configuration metadata
+   * @param handler - Handler function (sync or async)
+   */
+  addRoute(metadata, handler) {
+    this.routes.push(metadata);
+    this.handlers[metadata.handler_name] = handler;
+  }
+  /**
+   * Register a WebSocket route (message-based)
+   */
+  websocket(path2, handler, options = {}) {
+    const handlerName = options.handlerName ?? `ws_${this.websocketRoutes.length}_${path2}`.replace(/[^a-zA-Z0-9_]/g, "_");
+    const route2 = {
+      method: "GET",
+      path: path2,
+      handler_name: handlerName,
+      request_schema: options.messageSchema,
+      response_schema: options.responseSchema,
+      is_async: true
+    };
+    this.websocketRoutes.push(route2);
+    this.websocketHandlers[handlerName] = handler;
+  }
+  /**
+   * Run the server
+   *
+   * @param options - Server configuration
+   */
+  run(options = {}) {
+    runServer(this, options);
+  }
+  /**
+   * Register a dependency value or factory
+   *
+   * Dependencies are normalized to `snake_case` so fixtures and cross-language
+   * bindings stay aligned.
+   */
+  provide(key, valueOrFactory, options) {
+    const normalizedKey = normalizeDependencyKey(key);
+    const isFactory = typeof valueOrFactory === "function";
+    const dependsOn = options?.dependsOn?.map((depKey) => normalizeDependencyKey(depKey)) ?? (isFactory ? inferFactoryDependencies(valueOrFactory) : []);
+    this.dependencies[normalizedKey] = {
+      isFactory,
+      value: isFactory ? void 0 : valueOrFactory,
+      factory: isFactory ? wrapFactory(valueOrFactory) : void 0,
+      dependsOn,
+      singleton: options?.singleton ?? false,
+      cacheable: options?.cacheable ?? !isFactory
+    };
+    return this;
+  }
+  /**
+   * Register an onRequest lifecycle hook
+   *
+   * Runs before routing. Can inspect/modify the request or short-circuit with a response.
+   *
+   * @param hook - Async function that receives a request and returns either:
+   *               - The (possibly modified) request to continue processing
+   *               - A Response object to short-circuit the request pipeline
+   * @returns The hook function (for decorator usage)
+   *
+   * @example
+   * ```typescript
+   * app.onRequest(async (request) => {
+   *   console.log(`Request: ${request.method} ${request.path}`);
+   *   return request;
+   * });
+   * ```
+   */
+  onRequest(hook) {
+    this.lifecycleHooks.onRequest.push(hook);
+    return hook;
+  }
+  /**
+   * Register a preValidation lifecycle hook
+   *
+   * Runs after routing but before validation. Useful for rate limiting.
+   *
+   * @param hook - Async function that receives a request and returns either:
+   *               - The (possibly modified) request to continue processing
+   *               - A Response object to short-circuit the request pipeline
+   * @returns The hook function (for decorator usage)
+   *
+   * @example
+   * ```typescript
+   * app.preValidation(async (request) => {
+   *   if (tooManyRequests()) {
+   *     return { error: "Rate limit exceeded", status: 429 };
+   *   }
+   *   return request;
+   * });
+   * ```
+   */
+  preValidation(hook) {
+    this.lifecycleHooks.preValidation.push(hook);
+    return hook;
+  }
+  /**
+   * Register a preHandler lifecycle hook
+   *
+   * Runs after validation but before the handler. Ideal for authentication/authorization.
+   *
+   * @param hook - Async function that receives a request and returns either:
+   *               - The (possibly modified) request to continue processing
+   *               - A Response object to short-circuit the request pipeline
+   * @returns The hook function (for decorator usage)
+   *
+   * @example
+   * ```typescript
+   * app.preHandler(async (request) => {
+   *   if (!validToken(request.headers.authorization)) {
+   *     return { error: "Unauthorized", status: 401 };
+   *   }
+   *   return request;
+   * });
+   * ```
+   */
+  preHandler(hook) {
+    this.lifecycleHooks.preHandler.push(hook);
+    return hook;
+  }
+  /**
+   * Register an onResponse lifecycle hook
+   *
+   * Runs after the handler executes. Can modify the response.
+   *
+   * @param hook - Async function that receives a response and returns the (possibly modified) response
+   * @returns The hook function (for decorator usage)
+   *
+   * @example
+   * ```typescript
+   * app.onResponse(async (response) => {
+   *   response.headers["X-Frame-Options"] = "DENY";
+   *   return response;
+   * });
+   * ```
+   */
+  onResponse(hook) {
+    this.lifecycleHooks.onResponse.push(hook);
+    return hook;
+  }
+  /**
+   * Register an onError lifecycle hook
+   *
+   * Runs when an error occurs. Can customize error responses.
+   *
+   * @param hook - Async function that receives an error response and returns a (possibly modified) response
+   * @returns The hook function (for decorator usage)
+   *
+   * @example
+   * ```typescript
+   * app.onError(async (response) => {
+   *   response.headers["Content-Type"] = "application/json";
+   *   return response;
+   * });
+   * ```
+   */
+  onError(hook) {
+    this.lifecycleHooks.onError.push(hook);
+    return hook;
+  }
+  /**
+   * Get all registered lifecycle hooks
+   *
+   * @returns Dictionary of hook lists by type
+   */
+  getLifecycleHooks() {
+    return {
+      onRequest: [...this.lifecycleHooks.onRequest],
+      preValidation: [...this.lifecycleHooks.preValidation],
+      preHandler: [...this.lifecycleHooks.preHandler],
+      onResponse: [...this.lifecycleHooks.onResponse],
+      onError: [...this.lifecycleHooks.onError]
+    };
+  }
+};
+function normalizeDependencyKey(key) {
+  if (key.startsWith("__spikard_")) {
+    return key;
+  }
+  const trimmed = key.replace(/^_+/, "");
+  if (trimmed.includes("_")) {
+    return trimmed.toLowerCase();
+  }
+  return trimmed.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toLowerCase();
+}
+function inferFactoryDependencies(factory) {
+  const params = getFactoryParameterNames(factory);
+  return params.map((name) => normalizeDependencyKey(name));
+}
+function getFactoryParameterNames(factory) {
+  const source = factory.toString().trim();
+  const openParen = source.indexOf("(");
+  if (openParen === -1) {
+    return [];
+  }
+  const closeParen = source.indexOf(")", openParen + 1);
+  if (closeParen === -1) {
+    return [];
+  }
+  const raw = source.slice(openParen + 1, closeParen).trim();
+  if (!raw) {
+    return [];
+  }
+  return raw.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0).map(
+    (entry) => entry.replace(/^\.\.\./, "").split("=")[0]?.trim() ?? ""
+  ).filter((entry) => entry.length > 0 && !entry.startsWith("{") && !entry.startsWith("["));
+}
+var DI_REQUEST_ID_KEY = "__spikard_request_id__";
+var globalDi = globalThis;
+function registerDependencyGenerator(requestId, generator) {
+  let registry = globalDi.__spikard_di_generators__;
+  if (!registry) {
+    registry = {};
+    globalDi.__spikard_di_generators__ = registry;
+  }
+  let generators = registry[requestId];
+  if (!generators) {
+    generators = [];
+    registry[requestId] = generators;
+  }
+  generators.push(generator);
+}
+async function cleanupDependencyGenerators(requestId) {
+  const registry = globalDi.__spikard_di_generators__;
+  if (!registry) {
+    return;
+  }
+  const generators = registry[requestId];
+  if (!generators || generators.length === 0) {
+    return;
+  }
+  for (let idx = generators.length - 1; idx >= 0; idx -= 1) {
+    const generator = generators[idx];
+    if (!generator) {
+      continue;
+    }
+    try {
+      if (typeof generator.return === "function") {
+        await generator.return(void 0);
+      }
+    } catch {
+    }
+  }
+  delete registry[requestId];
+}
+if (!globalDi.__spikard_di_cleanup__) {
+  globalDi.__spikard_di_cleanup__ = cleanupDependencyGenerators;
+}
+function wrapFactory(factory) {
+  return async (dependenciesJson) => {
+    const depsUnknown = JSON.parse(dependenciesJson);
+    const deps = typeof depsUnknown === "object" && depsUnknown ? depsUnknown : {};
+    const requestId = typeof deps[DI_REQUEST_ID_KEY] === "string" ? deps[DI_REQUEST_ID_KEY] : null;
+    const paramNames = getFactoryParameterNames(factory);
+    const args = paramNames.map((name) => deps[normalizeDependencyKey(name)]);
+    const result = await factory(...args);
+    if (result && typeof result === "object" && Symbol.asyncIterator in result) {
+      const generator = result;
+      const first = await generator.next();
+      const value = first.value;
+      if (requestId) {
+        registerDependencyGenerator(requestId, generator);
+      } else {
+        try {
+          if (typeof generator.return === "function") {
+            await generator.return(void 0);
+          }
+        } catch {
+        }
+      }
+      return JSON.stringify(value ?? null);
+    }
+    return JSON.stringify(result ?? null);
+  };
+}
+
+// src/background.ts
+var background_exports = {};
+__export(background_exports, {
+  run: () => run
+});
+function run(work) {
+  void Promise.resolve().then(() => work());
+}
+
+// src/routing.ts
+function route(path2, options = {}) {
+  return (handler) => {
+    const methods = options.methods ? Array.isArray(options.methods) ? options.methods : [options.methods] : ["GET"];
+    const metadata = {
+      method: methods.join(","),
+      path: path2,
+      handler_name: handler.name || "anonymous",
+      ...options.bodySchema !== void 0 && { request_schema: options.bodySchema },
+      ...options.responseSchema !== void 0 && { response_schema: options.responseSchema },
+      ...options.parameterSchema !== void 0 && { parameter_schema: options.parameterSchema },
+      ...options.cors !== void 0 && { cors: options.cors },
+      is_async: true
+    };
+    handler.__route_metadata__ = metadata;
+    return handler;
+  };
+}
+function get(path2, options = {}) {
+  return route(path2, { ...options, methods: ["GET"] });
+}
+function post(path2, options = {}) {
+  return route(path2, { ...options, methods: ["POST"] });
+}
+function put(path2, options = {}) {
+  return route(path2, { ...options, methods: ["PUT"] });
+}
+function del(path2, options = {}) {
+  return route(path2, { ...options, methods: ["DELETE"] });
+}
+function patch(path2, options = {}) {
+  return route(path2, { ...options, methods: ["PATCH"] });
+}
+
+// src/node.ts
+__setGunzipImplementation((bytes) => new Uint8Array(zlib.gunzipSync(bytes)));
+var NodeTestClient = class extends TestClient {
+  constructor(app) {
+    super(withStaticManifest2(app));
+  }
+};
+var TestClient2 = NodeTestClient;
+function withStaticManifest2(app) {
+  const config = app.config;
+  if (!config || !config.staticFiles || config.staticFiles.length === 0) {
+    return app;
+  }
+  const manifest = buildStaticManifest2(config.staticFiles);
+  if (manifest.length === 0) {
+    return app;
+  }
+  return {
+    ...app,
+    config: {
+      ...config,
+      __wasmStaticManifest: manifest
+    }
+  };
+}
+function buildStaticManifest2(configs) {
+  const manifest = [];
+  for (const config of configs) {
+    if (!config.directory || !config.routePrefix) {
+      continue;
+    }
+    if (!fs__default.default.existsSync(config.directory)) {
+      continue;
+    }
+    const files = listFiles(config.directory);
+    for (const filePath of files) {
+      const relative = path__default.default.relative(config.directory, filePath).split(path__default.default.sep).join("/");
+      let normalizedPrefix = config.routePrefix;
+      while (normalizedPrefix.endsWith("/")) {
+        normalizedPrefix = normalizedPrefix.slice(0, -1);
+      }
+      const route2 = normalizeRoute2(`${normalizedPrefix}/${relative}`);
+      const headers = buildStaticHeaders2(filePath, config.cacheControl);
+      const body = fs__default.default.readFileSync(filePath).toString("base64");
+      manifest.push({ route: route2, headers, body });
+    }
+    if (config.indexFile ?? true) {
+      const indexPath = path__default.default.join(config.directory, "index.html");
+      if (fs__default.default.existsSync(indexPath)) {
+        const headers = buildStaticHeaders2(indexPath, config.cacheControl);
+        const body = fs__default.default.readFileSync(indexPath).toString("base64");
+        const prefix = normalizeRoute2(config.routePrefix);
+        manifest.push({ route: prefix, headers: { ...headers }, body });
+        if (!prefix.endsWith("/")) {
+          manifest.push({ route: `${prefix}/`, headers: { ...headers }, body });
+        }
+      }
+    }
+  }
+  return manifest;
+}
+function listFiles(root) {
+  const entries = [];
+  const stack = [root];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current) {
+      continue;
+    }
+    const stats = fs__default.default.statSync(current);
+    if (stats.isDirectory()) {
+      for (const child of fs__default.default.readdirSync(current)) {
+        stack.push(path__default.default.join(current, child));
+      }
+    } else {
+      entries.push(current);
+    }
+  }
+  return entries;
+}
+function buildStaticHeaders2(filePath, cacheControl) {
+  const headers = {
+    "content-type": lookupContentType(filePath)
+  };
+  if (cacheControl) {
+    headers["cache-control"] = cacheControl;
+  }
+  return headers;
+}
+function lookupContentType(filePath) {
+  const ext = path__default.default.extname(filePath).toLowerCase();
+  switch (ext) {
+    case ".html":
+    case ".htm":
+      return "text/html";
+    case ".txt":
+      return "text/plain";
+    case ".json":
+      return "application/json";
+    case ".js":
+      return "application/javascript";
+    case ".css":
+      return "text/css";
+    default:
+      return "application/octet-stream";
+  }
+}
+function normalizeRoute2(route2) {
+  const normalized = route2.replace(/\/+/g, "/");
+  return normalized.startsWith("/") ? normalized : `/${normalized}`;
+}
+
+exports.Spikard = Spikard;
+exports.StreamingResponse = StreamingResponse;
+exports.TestClient = TestClient2;
+exports.background = background_exports;
+exports.createFetchHandler = createFetchHandler;
+exports.del = del;
+exports.get = get;
+exports.patch = patch;
+exports.post = post;
+exports.put = put;
+exports.route = route;
+exports.runServer = runServer;
+//# sourceMappingURL=node.js.map
+//# sourceMappingURL=node.js.map