@nextrush/adapter-edge 1.0.0-beta.0

package/dist/index.d.ts

@@ -0,0 +1,287 @@
+import { Application } from '@nextrush/core';
+import { WebContextBase } from '@nextrush/runtime';
+export { BodyConsumedError, BodyTooLargeError, EdgeRuntimeInfo, EmptyBodySource, WebBodySource, createEmptyBodySource, createWebBodySource, detectEdgeRuntime, parseQueryString } from '@nextrush/runtime';
+export { HttpError } from '@nextrush/errors';
+export { BodySource, Context, HttpMethod, Middleware, Runtime, RuntimeCapabilities } from '@nextrush/types';
+
+/**
+ * @nextrush/adapter-edge - Context Implementation
+ *
+ * Edge-specific Context implementation for Cloudflare Workers, Vercel Edge, etc.
+ *
+ * @remarks
+ * Extends the shared {@link WebContextBase} (F-08, ADR-0010), which owns the
+ * response-building logic (json/send/html/redirect/set/getResponse and body
+ * suppression, composed from {@link WebResponseBuilder}), the lazy `raw`/
+ * `signal`/`triggerTimeout`, the streaming methods, and
+ * `get`/`next`/`throw`/`assert` — defined once across the Web adapters rather
+ * than copy-pasted per runtime. This file supplies only what is genuinely
+ * Edge-specific: `cf-connecting-ip`-aware IP resolution, platform bindings
+ * (`env`), and `waitUntil`/`executionContext`.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Edge execution context interface
+ *
+ * @remarks
+ * Provides access to edge-specific features like `waitUntil` and `passThroughOnException`.
+ */
+interface EdgeExecutionContext {
+    /** Extend request lifetime for async operations */
+    waitUntil(promise: Promise<unknown>): void;
+    /** Pass through to origin on exception */
+    passThroughOnException?(): void;
+}
+/**
+ * Edge Context implementation
+ *
+ * @remarks
+ * Works with any edge runtime that implements the Web Fetch API:
+ * - Cloudflare Workers
+ * - Vercel Edge Functions
+ * - Netlify Edge Functions
+ *
+ * The response is built internally (via the inherited {@link WebResponseBuilder}
+ * composition) and returned via `getResponse()`.
+ *
+ * @example
+ * ```typescript
+ * const ctx = new EdgeContext(request);
+ * ctx.json({ message: 'Hello from Edge!' });
+ * const response = ctx.getResponse();
+ * ```
+ */
+declare class EdgeContext<Env = unknown> extends WebContextBase {
+    /** Edge execution context (for waitUntil, etc.) */
+    readonly executionContext?: EdgeExecutionContext;
+    /**
+     * Platform bindings passed by the runtime (audit F-03).
+     *
+     * @remarks
+     * On Cloudflare Workers this is the `env` argument of
+     * `fetch(request, env, ctx)` — KV, D1, R2, Durable Objects, Queues, secrets.
+     * `undefined` on runtimes that do not supply bindings (e.g. Vercel Edge).
+     */
+    readonly env?: Env;
+    constructor(request: Request, executionContext?: EdgeExecutionContext, trustProxy?: boolean, env?: Env);
+    /**
+     * Extend request lifetime for async operations
+     *
+     * @remarks
+     * Use this for fire-and-forget operations that should complete
+     * after the response is sent (logging, analytics, etc.)
+     */
+    waitUntil(promise: Promise<unknown>): void;
+}
+/**
+ * Create a new EdgeContext
+ */
+declare function createEdgeContext<Env = unknown>(request: Request, executionContext?: EdgeExecutionContext, trustProxy?: boolean, env?: Env): EdgeContext<Env>;
+
+/**
+ * @nextrush/adapter-edge - Edge Runtime Adapter
+ *
+ * Connects NextRush Application to Edge runtimes via fetch handlers.
+ *
+ * @remarks
+ * **Size optimization**: Edge runtimes have strict bundle-size constraints
+ * (e.g. Cloudflare Workers 1 MB limit). Import only the packages you need:
+ *
+ * - Import `@nextrush/core` and `@nextrush/adapter-edge` only.
+ * - Avoid `@nextrush/di` unless you need DI (adds `reflect-metadata`).
+ * - Tree-shake unused middleware — each middleware is a separate package.
+ * - Use `@nextrush/router` only if you have dynamic routes; for simple
+ *   handlers, use the application directly.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Default request timeout applied when the caller specifies none (F-07,
+ * ADR-0010), converging Edge's default contract with Node/Bun/Deno (which all
+ * default to a bounded timeout rather than none).
+ *
+ * @remarks
+ * 25 000 ms — below the tightest common edge-platform wall limit (Vercel Edge
+ * Functions: 25 s), comfortably above typical handler durations, so the
+ * framework's clean `504` fires before the platform terminates the isolate.
+ * Pass `timeout: 0` to disable the framework timeout entirely (platform limit
+ * alone applies) or a positive value to override the default.
+ */
+declare const DEFAULT_EDGE_TIMEOUT_MS = 25000;
+/**
+ * Options for the fetch handler
+ */
+interface FetchHandlerOptions {
+    /**
+     * Custom error handler
+     */
+    onError?: (error: Error, ctx: EdgeContext) => Response | Promise<Response>;
+    /**
+     * Request timeout in milliseconds. The handler races the application logic
+     * against a timer and returns a 504 Gateway Timeout if the timer fires
+     * first, cancelling the still-running handler via `ctx.signal`.
+     *
+     * @remarks
+     * Defaults to {@link DEFAULT_EDGE_TIMEOUT_MS} (25 000 ms) when omitted
+     * (F-07/ADR-0010) — below the tightest common edge-platform wall limit
+     * (Vercel Edge: 25 s), so the framework's clean `504` fires before the
+     * platform terminates the isolate. Pass `0` to disable the framework
+     * timeout entirely (the platform's own limit still applies).
+     *
+     * Per-platform CPU/wall limits for context when overriding:
+     * - Cloudflare Workers: 30 000 (30 s CPU limit)
+     * - Vercel Edge:        25 000 (25 s wall limit)
+     *
+     * @default DEFAULT_EDGE_TIMEOUT_MS (25000)
+     */
+    timeout?: number;
+}
+/**
+ * Standard edge fetch handler type
+ */
+type FetchHandler = (request: Request, ctx?: EdgeExecutionContext) => Response | Promise<Response>;
+/**
+ * Create a fetch handler for Edge runtimes
+ *
+ * @param app - NextRush Application instance
+ * @param options - Handler options
+ * @returns Fetch handler function
+ *
+ * @example
+ * ```typescript
+ * // Cloudflare Workers
+ * import { createApp } from '@nextrush/core';
+ * import { createFetchHandler } from '@nextrush/adapter-edge';
+ *
+ * const app = createApp();
+ * const handler = createFetchHandler(app);
+ *
+ * export default {
+ *   fetch: handler
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Vercel Edge Functions
+ * import { createApp } from '@nextrush/core';
+ * import { createFetchHandler } from '@nextrush/adapter-edge';
+ *
+ * const app = createApp();
+ * export const config = { runtime: 'edge' };
+ * export default createFetchHandler(app);
+ * ```
+ */
+declare function createFetchHandler(app: Application, options?: FetchHandlerOptions): FetchHandler;
+/**
+ * Cloudflare Workers fetch handler type
+ *
+ * Cloudflare's module format passes `(request, env, ctx)` where:
+ * - `env` contains bindings (KV, D1, R2, secrets, etc.)
+ * - `ctx` provides `waitUntil()` and `passThroughOnException()`
+ *
+ * @typeParam Env - The shape of the Worker's bindings.
+ */
+type CloudflareFetchHandler<Env = Record<string, unknown>> = (request: Request, env: Env, ctx: EdgeExecutionContext) => Response | Promise<Response>;
+/**
+ * Create Cloudflare Workers module export
+ *
+ * @param app - NextRush Application instance
+ * @param options - Handler options
+ * @returns Cloudflare Workers module export object with correct `(request, env, ctx)` signature
+ *
+ * @remarks
+ * The Cloudflare `env` argument (KV, D1, R2, Durable Objects, Queues, secrets)
+ * is threaded onto the context as `ctx.env` (audit F-03). Pass a binding type
+ * as the generic to make `ctx.env` fully typed inside handlers.
+ *
+ * @example
+ * ```typescript
+ * interface Env { MY_KV: KVNamespace }
+ * export default createCloudflareHandler<Env>(app);
+ * // inside a handler: ctx.env.MY_KV.get('key')
+ * ```
+ */
+declare function createCloudflareHandler<Env = Record<string, unknown>>(app: Application, options?: FetchHandlerOptions): {
+    fetch: CloudflareFetchHandler<Env>;
+};
+/**
+ * Create Vercel Edge Function handler
+ *
+ * @param app - NextRush Application instance
+ * @param options - Handler options
+ * @returns Vercel Edge Function handler
+ *
+ * @example
+ * ```typescript
+ * // api/hello.ts
+ * import { createApp } from '@nextrush/core';
+ * import { createVercelHandler } from '@nextrush/adapter-edge';
+ *
+ * const app = createApp();
+ *
+ * app.use(async (ctx) => {
+ *   ctx.json({
+ *     message: 'Hello from Vercel Edge!',
+ *     region: process.env.VERCEL_REGION
+ *   });
+ * });
+ *
+ * export const config = { runtime: 'edge' };
+ * export default createVercelHandler(app);
+ * ```
+ */
+declare function createVercelHandler(app: Application, options?: FetchHandlerOptions): FetchHandler;
+/**
+ * Create Netlify Edge Function handler
+ *
+ * @param app - NextRush Application instance
+ * @param options - Handler options
+ * @returns Netlify Edge Function handler
+ *
+ * @example
+ * ```typescript
+ * // netlify/edge-functions/api.ts
+ * import { createApp } from '@nextrush/core';
+ * import { createNetlifyHandler } from '@nextrush/adapter-edge';
+ *
+ * const app = createApp();
+ *
+ * app.use(async (ctx) => {
+ *   ctx.json({ message: 'Hello from Netlify Edge!' });
+ * });
+ *
+ * export default createNetlifyHandler(app);
+ * ```
+ */
+declare function createNetlifyHandler(app: Application, options?: FetchHandlerOptions): FetchHandler;
+declare const createHandler: typeof createFetchHandler;
+
+/**
+ * @nextrush/adapter-edge - Utility Functions
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Get Content-Type header value
+ *
+ * @deprecated F-09: unused internally (superseded by `@nextrush/body-parser`'s
+ * own content-type parsing). Kept for backward compatibility per the public-API
+ * contract (deprecate-before-remove); will be removed in a future major.
+ */
+declare function getContentType(headers: Headers): string | undefined;
+/**
+ * Get Content-Length header as number
+ *
+ * @deprecated F-09: unused internally (superseded by `@nextrush/body-parser`'s
+ * own content-length handling). Kept for backward compatibility per the
+ * public-API contract (deprecate-before-remove); will be removed in a future
+ * major.
+ */
+declare function getContentLength(headers: Headers): number | undefined;
+
+export { type CloudflareFetchHandler, DEFAULT_EDGE_TIMEOUT_MS, EdgeContext, type EdgeExecutionContext, type FetchHandler, type FetchHandlerOptions, createCloudflareHandler, createEdgeContext, createFetchHandler, createHandler, createNetlifyHandler, createVercelHandler, getContentLength, getContentType };

package/dist/index.js

@@ -0,0 +1,178 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/adapter.ts
+import { jsonErrorResponse } from "@nextrush/runtime";
+
+// src/context.ts
+import { detectEdgeRuntime, getEdgeClientIp, WebContextBase } from "@nextrush/runtime";
+import { runNDJSONStream, runSSEStream, runTextStream } from "@nextrush/stream";
+var EdgeContext = class extends WebContextBase {
+  static {
+    __name(this, "EdgeContext");
+  }
+  /** Edge execution context (for waitUntil, etc.) */
+  executionContext;
+  /**
+  * Platform bindings passed by the runtime (audit F-03).
+  *
+  * @remarks
+  * On Cloudflare Workers this is the `env` argument of
+  * `fetch(request, env, ctx)` — KV, D1, R2, Durable Objects, Queues, secrets.
+  * `undefined` on runtimes that do not supply bindings (e.g. Vercel Edge).
+  */
+  env;
+  constructor(request, executionContext, trustProxy = false, env) {
+    const ip = trustProxy ? getEdgeClientIp(request, true) : "";
+    const runtime = detectEdgeRuntime().runtime;
+    super(request, ip, runtime, {
+      runTextStream,
+      runSSEStream,
+      runNDJSONStream
+    });
+    this.executionContext = executionContext;
+    this.env = env;
+  }
+  // ===========================================================================
+  // Edge-Specific Methods
+  // ===========================================================================
+  /**
+  * Extend request lifetime for async operations
+  *
+  * @remarks
+  * Use this for fire-and-forget operations that should complete
+  * after the response is sent (logging, analytics, etc.)
+  */
+  waitUntil(promise) {
+    if (this.executionContext?.waitUntil) {
+      this.executionContext.waitUntil(promise);
+    }
+  }
+};
+function createEdgeContext(request, executionContext, trustProxy = false, env) {
+  return new EdgeContext(request, executionContext, trustProxy, env);
+}
+__name(createEdgeContext, "createEdgeContext");
+
+// src/adapter.ts
+var DEFAULT_EDGE_TIMEOUT_MS = 25e3;
+function createFetchHandler(app, options = {}) {
+  const run = createRequestRunner(app, options);
+  return (request, executionContext) => run(request, executionContext);
+}
+__name(createFetchHandler, "createFetchHandler");
+function createRequestRunner(app, options) {
+  const timeout = options.timeout ?? DEFAULT_EDGE_TIMEOUT_MS;
+  const trustProxy = app.options.proxy ?? false;
+  const TIMEOUT_SENTINEL = /* @__PURE__ */ Symbol("timeout");
+  let bootPromise = null;
+  const ensureBooted = /* @__PURE__ */ __name(() => {
+    bootPromise ??= app.ready().then(() => {
+      const handler = app.callback();
+      app.start();
+      return handler;
+    });
+    return bootPromise;
+  }, "ensureBooted");
+  return async (request, executionContext, env) => {
+    const handler = await ensureBooted();
+    const ctx = createEdgeContext(request, executionContext, trustProxy, env);
+    try {
+      if (timeout > 0) {
+        let timerId;
+        try {
+          const result = await Promise.race([
+            handler(ctx).then(() => void 0),
+            new Promise((resolve) => {
+              timerId = setTimeout(() => {
+                resolve(TIMEOUT_SENTINEL);
+              }, timeout);
+            })
+          ]);
+          if (result === TIMEOUT_SENTINEL) {
+            ctx.triggerTimeout();
+            return jsonErrorResponse(504, "Gateway Timeout");
+          }
+        } finally {
+          if (timerId !== void 0) clearTimeout(timerId);
+        }
+      } else {
+        await handler(ctx);
+      }
+      if (!ctx.responded && ctx.status === 404) {
+        ctx.json({
+          error: "Not Found"
+        });
+      }
+      return ctx.getResponse();
+    } catch (error) {
+      if (options.onError) {
+        return options.onError(error, ctx);
+      }
+      app.logger.error("Request error:", error);
+      return jsonErrorResponse(500, "Internal Server Error");
+    }
+  };
+}
+__name(createRequestRunner, "createRequestRunner");
+function createCloudflareHandler(app, options = {}) {
+  const run = createRequestRunner(app, options);
+  return {
+    fetch: /* @__PURE__ */ __name((request, env, ctx) => run(request, ctx, env), "fetch")
+  };
+}
+__name(createCloudflareHandler, "createCloudflareHandler");
+function createVercelHandler(app, options = {}) {
+  return createFetchHandler(app, options);
+}
+__name(createVercelHandler, "createVercelHandler");
+function createNetlifyHandler(app, options = {}) {
+  return createFetchHandler(app, options);
+}
+__name(createNetlifyHandler, "createNetlifyHandler");
+var createHandler = createFetchHandler;
+
+// src/index.ts
+import { HttpError } from "@nextrush/errors";
+
+// src/body-source.ts
+import { createEmptyBodySource, createWebBodySource, EmptyBodySource, WebBodySource } from "@nextrush/runtime";
+
+// src/index.ts
+import { BodyConsumedError, BodyTooLargeError } from "@nextrush/runtime";
+
+// src/utils.ts
+import { detectEdgeRuntime as detectEdgeRuntime2, parseQueryString } from "@nextrush/runtime";
+function getContentType(headers) {
+  return headers.get("content-type") ?? void 0;
+}
+__name(getContentType, "getContentType");
+function getContentLength(headers) {
+  const value = headers.get("content-length");
+  if (value === null) return void 0;
+  const num = parseInt(value, 10);
+  return Number.isNaN(num) ? void 0 : num;
+}
+__name(getContentLength, "getContentLength");
+export {
+  BodyConsumedError,
+  BodyTooLargeError,
+  DEFAULT_EDGE_TIMEOUT_MS,
+  EdgeContext,
+  EmptyBodySource,
+  HttpError,
+  WebBodySource,
+  createCloudflareHandler,
+  createEdgeContext,
+  createEmptyBodySource,
+  createFetchHandler,
+  createHandler,
+  createNetlifyHandler,
+  createVercelHandler,
+  createWebBodySource,
+  detectEdgeRuntime2 as detectEdgeRuntime,
+  getContentLength,
+  getContentType,
+  parseQueryString
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/adapter.ts","../src/context.ts","../src/index.ts","../src/body-source.ts","../src/utils.ts"],"sourcesContent":["/**\n * @nextrush/adapter-edge - Edge Runtime Adapter\n *\n * Connects NextRush Application to Edge runtimes via fetch handlers.\n *\n * @remarks\n * **Size optimization**: Edge runtimes have strict bundle-size constraints\n * (e.g. Cloudflare Workers 1 MB limit). Import only the packages you need:\n *\n * - Import `@nextrush/core` and `@nextrush/adapter-edge` only.\n * - Avoid `@nextrush/di` unless you need DI (adds `reflect-metadata`).\n * - Tree-shake unused middleware — each middleware is a separate package.\n * - Use `@nextrush/router` only if you have dynamic routes; for simple\n *   handlers, use the application directly.\n *\n * @packageDocumentation\n */\n\nimport type { Application } from '@nextrush/core';\nimport { jsonErrorResponse } from '@nextrush/runtime';\nimport type { AdapterContextFactory, FetchAdapter } from '@nextrush/types';\nimport { createEdgeContext, EdgeContext, type EdgeExecutionContext } from './context';\n\n/**\n * Default request timeout applied when the caller specifies none (F-07,\n * ADR-0010), converging Edge's default contract with Node/Bun/Deno (which all\n * default to a bounded timeout rather than none).\n *\n * @remarks\n * 25 000 ms — below the tightest common edge-platform wall limit (Vercel Edge\n * Functions: 25 s), comfortably above typical handler durations, so the\n * framework's clean `504` fires before the platform terminates the isolate.\n * Pass `timeout: 0` to disable the framework timeout entirely (platform limit\n * alone applies) or a positive value to override the default.\n */\nexport const DEFAULT_EDGE_TIMEOUT_MS = 25_000;\n\n/**\n * Options for the fetch handler\n */\nexport interface FetchHandlerOptions {\n  /**\n   * Custom error handler\n   */\n  onError?: (error: Error, ctx: EdgeContext) => Response | Promise<Response>;\n\n  /**\n   * Request timeout in milliseconds. The handler races the application logic\n   * against a timer and returns a 504 Gateway Timeout if the timer fires\n   * first, cancelling the still-running handler via `ctx.signal`.\n   *\n   * @remarks\n   * Defaults to {@link DEFAULT_EDGE_TIMEOUT_MS} (25 000 ms) when omitted\n   * (F-07/ADR-0010) — below the tightest common edge-platform wall limit\n   * (Vercel Edge: 25 s), so the framework's clean `504` fires before the\n   * platform terminates the isolate. Pass `0` to disable the framework\n   * timeout entirely (the platform's own limit still applies).\n   *\n   * Per-platform CPU/wall limits for context when overriding:\n   * - Cloudflare Workers: 30 000 (30 s CPU limit)\n   * - Vercel Edge:        25 000 (25 s wall limit)\n   *\n   * @default DEFAULT_EDGE_TIMEOUT_MS (25000)\n   */\n  timeout?: number;\n}\n\n/**\n * Standard edge fetch handler type\n */\nexport type FetchHandler = (\n  request: Request,\n  ctx?: EdgeExecutionContext\n) => Response | Promise<Response>;\n\n/**\n * Create a fetch handler for Edge runtimes\n *\n * @param app - NextRush Application instance\n * @param options - Handler options\n * @returns Fetch handler function\n *\n * @example\n * ```typescript\n * // Cloudflare Workers\n * import { createApp } from '@nextrush/core';\n * import { createFetchHandler } from '@nextrush/adapter-edge';\n *\n * const app = createApp();\n * const handler = createFetchHandler(app);\n *\n * export default {\n *   fetch: handler\n * };\n * ```\n *\n * @example\n * ```typescript\n * // Vercel Edge Functions\n * import { createApp } from '@nextrush/core';\n * import { createFetchHandler } from '@nextrush/adapter-edge';\n *\n * const app = createApp();\n * export const config = { runtime: 'edge' };\n * export default createFetchHandler(app);\n * ```\n */\nexport function createFetchHandler(\n  app: Application,\n  options: FetchHandlerOptions = {}\n): FetchHandler {\n  const run = createRequestRunner(app, options);\n  return (request: Request, executionContext?: EdgeExecutionContext): Promise<Response> =>\n    run(request, executionContext);\n}\n\n/**\n * Internal request runner shared by every edge entry point.\n *\n * @remarks\n * Centralizes booting, context creation (threading Cloudflare `env` — F-03),\n * timeout racing with cooperative cancellation (F-08), the header-preserving\n * finalize path (F-02), and error handling — so Cloudflare/Vercel/Netlify\n * handlers cannot drift.\n */\nfunction createRequestRunner(\n  app: Application,\n  options: FetchHandlerOptions\n): (request: Request, executionContext?: EdgeExecutionContext, env?: unknown) => Promise<Response> {\n  // F-07/ADR-0010: default to DEFAULT_EDGE_TIMEOUT_MS when the caller specifies\n  // none (`undefined`); `0` remains an explicit opt-out (no framework timeout).\n  const timeout = options.timeout ?? DEFAULT_EDGE_TIMEOUT_MS;\n  const trustProxy = app.options.proxy ?? false;\n\n  /** Sentinel value returned by the timeout racer */\n  const TIMEOUT_SENTINEL = Symbol('timeout');\n\n  // Edge has no serve()/start() phase, so the deferred boot barrier runs lazily\n  // on the first request (idempotent). The boot promise caches the snapshotted\n  // request handler, so every request awaits and reuses the same one.\n  let bootPromise: Promise<ReturnType<Application['callback']>> | null = null;\n  const ensureBooted = (): Promise<ReturnType<Application['callback']>> => {\n    bootPromise ??= app.ready().then(() => {\n      const handler = app.callback();\n      // F-14: mark the app running so `app.isRunning` is consistent with the\n      // server adapters. Edge has no server lifetime, so close()/destroy() are\n      // intentionally never called — that no-teardown contract is documented\n      // on createFetchHandler.\n      app.start();\n      return handler;\n    });\n    return bootPromise;\n  };\n\n  return async (\n    request: Request,\n    executionContext?: EdgeExecutionContext,\n    env?: unknown\n  ): Promise<Response> => {\n    const handler = await ensureBooted();\n    const ctx = createEdgeContext(request, executionContext, trustProxy, env);\n\n    try {\n      if (timeout > 0) {\n        let timerId: ReturnType<typeof setTimeout> | undefined;\n        try {\n          const result = await Promise.race([\n            handler(ctx).then(() => undefined),\n            new Promise<typeof TIMEOUT_SENTINEL>((resolve) => {\n              timerId = setTimeout(() => {\n                resolve(TIMEOUT_SENTINEL);\n              }, timeout);\n            }),\n          ]);\n\n          if (result === TIMEOUT_SENTINEL) {\n            // F-08: cancel the still-running handler cooperatively via ctx.signal.\n            ctx.triggerTimeout();\n            return jsonErrorResponse(504, 'Gateway Timeout');\n          }\n        } finally {\n          // F-08: always clear the timer, on both handler-wins and timeout paths.\n          if (timerId !== undefined) clearTimeout(timerId);\n        }\n      } else {\n        await handler(ctx);\n      }\n\n      // F-02: finalize through the context so headers set via ctx.set() survive\n      // an implicit/empty response. The 404 default body is written through the\n      // same builder, preserving those headers too.\n      if (!ctx.responded && ctx.status === 404) {\n        ctx.json({ error: 'Not Found' });\n      }\n      return ctx.getResponse();\n    } catch (error) {\n      // Custom error handler\n      if (options.onError) {\n        return options.onError(error as Error, ctx);\n      }\n\n      // Default error handling\n      app.logger.error('Request error:', error);\n\n      return jsonErrorResponse(500, 'Internal Server Error');\n    }\n  };\n}\n\n/**\n * Cloudflare Workers fetch handler type\n *\n * Cloudflare's module format passes `(request, env, ctx)` where:\n * - `env` contains bindings (KV, D1, R2, secrets, etc.)\n * - `ctx` provides `waitUntil()` and `passThroughOnException()`\n *\n * @typeParam Env - The shape of the Worker's bindings.\n */\nexport type CloudflareFetchHandler<Env = Record<string, unknown>> = (\n  request: Request,\n  env: Env,\n  ctx: EdgeExecutionContext\n) => Response | Promise<Response>;\n\n/**\n * Create Cloudflare Workers module export\n *\n * @param app - NextRush Application instance\n * @param options - Handler options\n * @returns Cloudflare Workers module export object with correct `(request, env, ctx)` signature\n *\n * @remarks\n * The Cloudflare `env` argument (KV, D1, R2, Durable Objects, Queues, secrets)\n * is threaded onto the context as `ctx.env` (audit F-03). Pass a binding type\n * as the generic to make `ctx.env` fully typed inside handlers.\n *\n * @example\n * ```typescript\n * interface Env { MY_KV: KVNamespace }\n * export default createCloudflareHandler<Env>(app);\n * // inside a handler: ctx.env.MY_KV.get('key')\n * ```\n */\nexport function createCloudflareHandler<Env = Record<string, unknown>>(\n  app: Application,\n  options: FetchHandlerOptions = {}\n): { fetch: CloudflareFetchHandler<Env> } {\n  const run = createRequestRunner(app, options);\n\n  return {\n    fetch: (request: Request, env: Env, ctx: EdgeExecutionContext): Promise<Response> =>\n      run(request, ctx, env),\n  };\n}\n\n/**\n * Create Vercel Edge Function handler\n *\n * @param app - NextRush Application instance\n * @param options - Handler options\n * @returns Vercel Edge Function handler\n *\n * @example\n * ```typescript\n * // api/hello.ts\n * import { createApp } from '@nextrush/core';\n * import { createVercelHandler } from '@nextrush/adapter-edge';\n *\n * const app = createApp();\n *\n * app.use(async (ctx) => {\n *   ctx.json({\n *     message: 'Hello from Vercel Edge!',\n *     region: process.env.VERCEL_REGION\n *   });\n * });\n *\n * export const config = { runtime: 'edge' };\n * export default createVercelHandler(app);\n * ```\n */\nexport function createVercelHandler(\n  app: Application,\n  options: FetchHandlerOptions = {}\n): FetchHandler {\n  return createFetchHandler(app, options);\n}\n\n/**\n * Create Netlify Edge Function handler\n *\n * @param app - NextRush Application instance\n * @param options - Handler options\n * @returns Netlify Edge Function handler\n *\n * @example\n * ```typescript\n * // netlify/edge-functions/api.ts\n * import { createApp } from '@nextrush/core';\n * import { createNetlifyHandler } from '@nextrush/adapter-edge';\n *\n * const app = createApp();\n *\n * app.use(async (ctx) => {\n *   ctx.json({ message: 'Hello from Netlify Edge!' });\n * });\n *\n * export default createNetlifyHandler(app);\n * ```\n */\nexport function createNetlifyHandler(\n  app: Application,\n  options: FetchHandlerOptions = {}\n): FetchHandler {\n  return createFetchHandler(app, options);\n}\n\n// Alias for backwards compatibility and consistency\nexport const createHandler = createFetchHandler;\n\n// F-01: compile-time conformance guard. If the exported fetch-adapter shape\n// drifts from the shared `FetchAdapter` contract, this stops compiling.\nconst _edgeConformance: FetchAdapter<Application, EdgeExecutionContext> = { createFetchHandler };\nvoid _edgeConformance;\n\n// RFC-NEXTRUSH-ADAPTER-CONTRACT: prove the context factory produces an\n// AdapterContext over the shared Context contract. A drift in createEdgeContext's\n// return type stops compiling here.\nconst _edgeContextFactory: AdapterContextFactory<\n  [Request, EdgeExecutionContext?, boolean?, unknown?],\n  EdgeContext\n> = createEdgeContext;\nvoid _edgeContextFactory;\n","/**\n * @nextrush/adapter-edge - Context Implementation\n *\n * Edge-specific Context implementation for Cloudflare Workers, Vercel Edge, etc.\n *\n * @remarks\n * Extends the shared {@link WebContextBase} (F-08, ADR-0010), which owns the\n * response-building logic (json/send/html/redirect/set/getResponse and body\n * suppression, composed from {@link WebResponseBuilder}), the lazy `raw`/\n * `signal`/`triggerTimeout`, the streaming methods, and\n * `get`/`next`/`throw`/`assert` — defined once across the Web adapters rather\n * than copy-pasted per runtime. This file supplies only what is genuinely\n * Edge-specific: `cf-connecting-ip`-aware IP resolution, platform bindings\n * (`env`), and `waitUntil`/`executionContext`.\n *\n * @packageDocumentation\n */\n\nimport { detectEdgeRuntime, getEdgeClientIp, WebContextBase } from '@nextrush/runtime';\nimport { runNDJSONStream, runSSEStream, runTextStream } from '@nextrush/stream';\n\n/**\n * Edge execution context interface\n *\n * @remarks\n * Provides access to edge-specific features like `waitUntil` and `passThroughOnException`.\n */\nexport interface EdgeExecutionContext {\n  /** Extend request lifetime for async operations */\n  waitUntil(promise: Promise<unknown>): void;\n\n  /** Pass through to origin on exception */\n  passThroughOnException?(): void;\n}\n\n/**\n * Edge Context implementation\n *\n * @remarks\n * Works with any edge runtime that implements the Web Fetch API:\n * - Cloudflare Workers\n * - Vercel Edge Functions\n * - Netlify Edge Functions\n *\n * The response is built internally (via the inherited {@link WebResponseBuilder}\n * composition) and returned via `getResponse()`.\n *\n * @example\n * ```typescript\n * const ctx = new EdgeContext(request);\n * ctx.json({ message: 'Hello from Edge!' });\n * const response = ctx.getResponse();\n * ```\n */\nexport class EdgeContext<Env = unknown> extends WebContextBase {\n  /** Edge execution context (for waitUntil, etc.) */\n  readonly executionContext?: EdgeExecutionContext;\n\n  /**\n   * Platform bindings passed by the runtime (audit F-03).\n   *\n   * @remarks\n   * On Cloudflare Workers this is the `env` argument of\n   * `fetch(request, env, ctx)` — KV, D1, R2, Durable Objects, Queues, secrets.\n   * `undefined` on runtimes that do not supply bindings (e.g. Vercel Edge).\n   */\n  readonly env?: Env;\n\n  constructor(\n    request: Request,\n    executionContext?: EdgeExecutionContext,\n    trustProxy = false,\n    env?: Env\n  ) {\n    // Get client IP from CF headers or standard headers.\n    //\n    // HP-1 trim: Edge has no socket, so when `trustProxy` is false (default) the\n    // client IP is `''` — returned directly, with no per-request header-lookup\n    // closure and no `getEdgeClientIp` policy call (byte-identical to\n    // `getEdgeClientIp(request, false)`, whose `directIp` is `''`). When true,\n    // resolution still goes through `getEdgeClientIp`, preserving the Cloudflare\n    // `cf-connecting-ip` → `x-forwarded-for` → `x-real-ip` precedence.\n    const ip = trustProxy ? getEdgeClientIp(request, true) : '';\n\n    // Detect specific edge runtime\n    const runtime = detectEdgeRuntime().runtime;\n\n    super(request, ip, runtime, { runTextStream, runSSEStream, runNDJSONStream });\n\n    this.executionContext = executionContext;\n    this.env = env;\n  }\n\n  // ===========================================================================\n  // Edge-Specific Methods\n  // ===========================================================================\n\n  /**\n   * Extend request lifetime for async operations\n   *\n   * @remarks\n   * Use this for fire-and-forget operations that should complete\n   * after the response is sent (logging, analytics, etc.)\n   */\n  waitUntil(promise: Promise<unknown>): void {\n    if (this.executionContext?.waitUntil) {\n      this.executionContext.waitUntil(promise);\n    }\n  }\n}\n\n/**\n * Create a new EdgeContext\n */\nexport function createEdgeContext<Env = unknown>(\n  request: Request,\n  executionContext?: EdgeExecutionContext,\n  trustProxy = false,\n  env?: Env\n): EdgeContext<Env> {\n  return new EdgeContext<Env>(request, executionContext, trustProxy, env);\n}\n","/**\n * @nextrush/adapter-edge - Edge Runtime Adapter for NextRush\n *\n * Provides universal Edge runtime support for:\n * - Cloudflare Workers\n * - Vercel Edge Functions\n * - Netlify Edge Functions\n * - Any runtime supporting the Fetch API\n *\n * @packageDocumentation\n * @module @nextrush/adapter-edge\n */\n\n// Main adapter functions\nexport {\n  createCloudflareHandler,\n  createFetchHandler,\n  createHandler,\n  createNetlifyHandler,\n  createVercelHandler,\n  DEFAULT_EDGE_TIMEOUT_MS,\n  type CloudflareFetchHandler, // Alias\n  type FetchHandler,\n  type FetchHandlerOptions,\n} from './adapter';\n\n// Context exports\nexport { EdgeContext, createEdgeContext, type EdgeExecutionContext } from './context';\n\n// HttpError re-export (uniform across all adapters — audit F-10)\nexport { HttpError } from '@nextrush/errors';\n\n// Body source exports (F-10: previously only `EdgeBodySource` was exported;\n// the rest were dead. Now the full shared surface is wired up.)\nexport {\n  createEmptyBodySource,\n  createWebBodySource,\n  EmptyBodySource,\n  WebBodySource,\n} from './body-source';\n\n// Shared error classes (parity with node/bun/deno — audit F-10)\nexport { BodyConsumedError, BodyTooLargeError } from '@nextrush/runtime';\n\n// Utility exports\n/* eslint-disable @typescript-eslint/no-deprecated -- F-09: intentional compat re-export, not a usage site */\nexport {\n  detectEdgeRuntime,\n  getContentLength,\n  getContentType,\n  parseQueryString,\n  type EdgeRuntimeInfo,\n} from './utils';\n/* eslint-enable @typescript-eslint/no-deprecated */\n\n// Re-export types for convenience (parity with node/bun/deno — audit F-10)\nexport type {\n  BodySource,\n  Context,\n  HttpMethod,\n  Middleware,\n  Runtime,\n  RuntimeCapabilities,\n} from '@nextrush/types';\n","/**\n * @nextrush/adapter-edge - Body Source\n *\n * The bespoke `EdgeBodySource`/`EmptyBodySource`/`concatUint8Arrays` have been\n * collapsed onto the shared cross-runtime {@link WebBodySource} in\n * `@nextrush/runtime` (audit F-04a). Body-reading behavior is now identical\n * across the Web adapters (Bun/Deno/Edge) and fixed in one place.\n *\n * @packageDocumentation\n */\n\nimport {\n  createEmptyBodySource,\n  createWebBodySource,\n  EmptyBodySource,\n  WebBodySource,\n} from '@nextrush/runtime';\n\nexport { createEmptyBodySource, createWebBodySource, EmptyBodySource, WebBodySource };\n","/**\n * @nextrush/adapter-edge - Utility Functions\n *\n * @packageDocumentation\n */\n\nexport { detectEdgeRuntime, parseQueryString } from '@nextrush/runtime';\nexport type { EdgeRuntimeInfo } from '@nextrush/runtime';\n\n/**\n * Get Content-Type header value\n *\n * @deprecated F-09: unused internally (superseded by `@nextrush/body-parser`'s\n * own content-type parsing). Kept for backward compatibility per the public-API\n * contract (deprecate-before-remove); will be removed in a future major.\n */\nexport function getContentType(headers: Headers): string | undefined {\n  return headers.get('content-type') ?? undefined;\n}\n\n/**\n * Get Content-Length header as number\n *\n * @deprecated F-09: unused internally (superseded by `@nextrush/body-parser`'s\n * own content-length handling). Kept for backward compatibility per the\n * public-API contract (deprecate-before-remove); will be removed in a future\n * major.\n */\nexport function getContentLength(headers: Headers): number | undefined {\n  const value = headers.get('content-length');\n  if (value === null) return undefined;\n  const num = parseInt(value, 10);\n  return Number.isNaN(num) ? undefined : num;\n}\n"],"mappings":"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","names":["jsonErrorResponse","detectEdgeRuntime","getEdgeClientIp","WebContextBase","runNDJSONStream","runSSEStream","runTextStream","EdgeContext","WebContextBase","executionContext","env","request","trustProxy","ip","getEdgeClientIp","runtime","detectEdgeRuntime","runTextStream","runSSEStream","runNDJSONStream","waitUntil","promise","createEdgeContext","DEFAULT_EDGE_TIMEOUT_MS","createFetchHandler","app","options","run","createRequestRunner","request","executionContext","timeout","trustProxy","proxy","TIMEOUT_SENTINEL","Symbol","bootPromise","ensureBooted","ready","then","handler","callback","start","env","ctx","createEdgeContext","timerId","result","Promise","race","undefined","resolve","setTimeout","triggerTimeout","jsonErrorResponse","clearTimeout","responded","status","json","error","getResponse","onError","logger","createCloudflareHandler","fetch","createVercelHandler","createNetlifyHandler","createHandler","HttpError","createEmptyBodySource","createWebBodySource","EmptyBodySource","WebBodySource","BodyConsumedError","BodyTooLargeError","detectEdgeRuntime","parseQueryString","getContentType","headers","get","undefined","getContentLength","value","num","parseInt","Number","isNaN"]}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@nextrush/adapter-edge",
+  "version": "1.0.0-beta.0",
+  "description": "Edge runtime adapter for NextRush (Cloudflare Workers, Vercel Edge, etc.)",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
+  "dependencies": {
+    "@nextrush/core": "^4.0.0-beta.0",
+    "@nextrush/errors": "^4.0.0-beta.0",
+    "@nextrush/runtime": "^4.0.0-beta.0",
+    "@nextrush/stream": "^1.0.0-beta.0",
+    "@nextrush/types": "^4.0.0-beta.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.10"
+  },
+  "keywords": [
+    "nextrush",
+    "adapter",
+    "edge",
+    "cloudflare",
+    "workers",
+    "vercel",
+    "http",
+    "framework"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/0xTanzim/nextRush.git",
+    "directory": "packages/adapters/edge"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "homepage": "https://github.com/0xTanzim/nextRush/tree/main/packages/adapters/edge#readme",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "author": {
+    "name": "Tanzim Hossain",
+    "email": "tanzimhossain2@gmail.com",
+    "url": "https://github.com/0xTanzim"
+  },
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --ignore-pattern '**/__tests__/**'",
+    "clean": "rm -rf dist"
+  }
+}

package/src/__tests__/adapter.test.ts

@@ -0,0 +1,89 @@
+/**
+ * @nextrush/adapter-edge - Adapter behavior tests
+ *
+ * Regression guards for:
+ *  - F-02: headers set via ctx.set() survive an implicit/empty (and 404) response.
+ *  - F-03: Cloudflare `env` bindings are threaded onto ctx.env.
+ *  - F-14: app.isRunning becomes true after the first request boots the app.
+ */
+
+import { createApp } from '@nextrush/core';
+import { describe, expect, it } from 'vitest';
+import { createCloudflareHandler, createFetchHandler } from '../adapter';
+
+describe('edge adapter — F-02 header preservation', () => {
+  it('keeps headers set via ctx.set() on a header-only (no body method) response', async () => {
+    const app = createApp();
+    app.use(async (ctx) => {
+      ctx.set('X-Custom', 'kept');
+      ctx.set('Access-Control-Allow-Origin', '*');
+      ctx.status = 204;
+    });
+    const handler = createFetchHandler(app);
+
+    const res = await handler(new Request('http://localhost/'));
+    expect(res.status).toBe(204);
+    expect(res.headers.get('X-Custom')).toBe('kept');
+    expect(res.headers.get('Access-Control-Allow-Origin')).toBe('*');
+  });
+
+  it('keeps headers set via ctx.set() on the default 404 response', async () => {
+    const app = createApp();
+    app.use(async (ctx) => {
+      ctx.set('X-Trace', 'abc');
+      ctx.status = 404;
+    });
+    const handler = createFetchHandler(app);
+
+    const res = await handler(new Request('http://localhost/missing'));
+    expect(res.status).toBe(404);
+    expect(res.headers.get('X-Trace')).toBe('abc');
+    expect(await res.json()).toEqual({ error: 'Not Found' });
+  });
+
+  it('accumulates multiple Set-Cookie headers on an empty response', async () => {
+    const app = createApp();
+    app.use(async (ctx) => {
+      ctx.set('Set-Cookie', 'a=1; Path=/');
+      ctx.set('Set-Cookie', 'b=2; Path=/');
+      ctx.status = 204;
+    });
+    const handler = createFetchHandler(app);
+
+    const res = await handler(new Request('http://localhost/'));
+    expect(res.headers.getSetCookie()).toHaveLength(2);
+  });
+});
+
+describe('edge adapter — F-03 Cloudflare env', () => {
+  it('threads env onto ctx.env for the Cloudflare handler', async () => {
+    interface Env {
+      MY_SECRET: string;
+    }
+    const app = createApp();
+    app.use(async (ctx) => {
+      const env = ctx.env as Env | undefined;
+      ctx.json({ secret: env?.MY_SECRET ?? null });
+    });
+
+    const mod = createCloudflareHandler<Env>(app);
+    const res = await mod.fetch(
+      new Request('http://localhost/'),
+      { MY_SECRET: 'shhh' },
+      { waitUntil: () => undefined }
+    );
+    expect(await res.json()).toEqual({ secret: 'shhh' });
+  });
+});
+
+describe('edge adapter — F-14 lifecycle', () => {
+  it('marks the app running after the first request boots it', async () => {
+    const app = createApp();
+    app.use(async (ctx) => ctx.json({ ok: true }));
+    expect(app.isRunning).toBe(false);
+
+    const handler = createFetchHandler(app);
+    await handler(new Request('http://localhost/'));
+    expect(app.isRunning).toBe(true);
+  });
+});