@stone-js/edge-adapter 0.8.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright © 2026 Stone Foundation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,40 @@
+# Stone.js · Edge adapter
+
+[![npm](https://img.shields.io/npm/v/@stone-js/edge-adapter)](https://www.npmjs.com/package/@stone-js/edge-adapter)
+[![CI](https://github.com/stone-foundation/stone-js-framework/actions/workflows/ci.yml/badge.svg)](https://github.com/stone-foundation/stone-js-framework/actions/workflows/ci.yml)
+[![Quality Gate](https://sonarcloud.io/api/project_badges/measure?project=stone-foundation_stone-js-framework&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=stone-foundation_stone-js-framework)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![Conventional Commits](https://img.shields.io/badge/Conventional%20Commits-1.0.0-yellow.svg)](https://conventionalcommits.org)
+
+> Deploy a Stone.js app to any WinterCG/edge or JS runtime — Cloudflare Workers, Vercel Edge, Netlify Edge, Deno and Bun — with one-line serve helpers on top of @stone-js/fetch-adapter. Build once, deploy anywhere.
+
+Part of **[Stone.js](https://stonejs.dev)**, the reference implementation of the
+[Continuum Architecture](https://evens-stone.github.io/continuum-manifesto/manifesto): write your
+domain once, and the context (runtime, protocol, caller) applies to it at run time.
+
+## Install
+
+```bash
+npm i @stone-js/edge-adapter
+```
+
+## Usage
+
+```ts
+// One Stone.js domain, every WinterCG/edge runtime. Thin helpers over @stone-js/fetch-adapter.
+import { serveCloudflare } from '@stone-js/edge-adapter'
+import { Application } from './Application'
+
+// Cloudflare Workers entry point:
+export default serveCloudflare(Application)
+
+// Also: serveVercel, serveNetlify, serveFetch (generic WinterCG fetch handler).
+```
+
+## Documentation
+
+Full documentation: **[stonejs.dev/docs/adapters/fetch](https://stonejs.dev/docs/adapters/fetch)**.
+
+## License
+
+[MIT](https://opensource.org/licenses/MIT) © Evens Pierre ("Mr. Stone") and the Stone.js contributors.

package/dist/buildFetchHandler.d.ts

@@ -0,0 +1,12 @@
+import { EdgeAppOptions, FetchHandler } from './declarations';
+/**
+ * Boots a Stone.js app and returns its Web-standard fetch handler.
+ *
+ * This is the foundation the platform `serve*` helpers build on: it runs the real bootstrap via
+ * `StoneFactory` with the Fetch adapter forced current, yielding `(request, executionContext?)
+ * => Promise<Response>`.
+ *
+ * @param options - The modules/blueprint to boot.
+ * @returns The fetch handler.
+ */
+export declare function buildFetchHandler(options?: EdgeAppOptions): Promise<FetchHandler>;

package/dist/declarations.d.ts

@@ -0,0 +1,13 @@
+import { StoneBlueprint } from '@stone-js/core';
+/** A Web-standard fetch handler `(request, executionContext?) => Promise<Response>`. */
+export type FetchHandler = (request: Request, executionContext?: Record<string, unknown>) => Promise<Response>;
+/**
+ * What to boot: the app's modules (decorated classes and/or blueprints). The Fetch adapter is
+ * forced as the current adapter, so the same app deploys to any edge/runtime target.
+ */
+export interface EdgeAppOptions {
+    /** App modules to boot. */
+    modules?: unknown[];
+    /** A base blueprint to merge (shorthand for one blueprint module). */
+    blueprint?: Partial<StoneBlueprint>;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './buildFetchHandler';
+export * from './declarations';
+export * from './serve';

package/dist/index.js

@@ -0,0 +1,112 @@
+import { StoneFactory } from '@stone-js/core';
+import { fetchAdapterBlueprint } from '@stone-js/fetch-adapter';
+
+/**
+ * A blueprint fragment that forces the Fetch adapter to be the current adapter (`current: true`
+ * wins over any real platform adapter the app declares), and sets it directly so a minimal app
+ * still resolves an adapter.
+ *
+ * @returns The forced-fetch blueprint fragment.
+ */
+function forcedFetchBlueprint() {
+    /* v8 ignore next -- `?? {}` is defensive: the fetch adapter always declares its adapter entry. */
+    const base = fetchAdapterBlueprint.stone.adapters?.[0] ?? {};
+    const current = { ...base, current: true, default: true };
+    return { stone: { ...fetchAdapterBlueprint.stone, adapter: current, adapters: [current] } };
+}
+/**
+ * Boots a Stone.js app and returns its Web-standard fetch handler.
+ *
+ * This is the foundation the platform `serve*` helpers build on: it runs the real bootstrap via
+ * `StoneFactory` with the Fetch adapter forced current, yielding `(request, executionContext?)
+ * => Promise<Response>`.
+ *
+ * @param options - The modules/blueprint to boot.
+ * @returns The fetch handler.
+ */
+async function buildFetchHandler(options = {}) {
+    const modules = [
+        forcedFetchBlueprint(),
+        ...(options.blueprint !== undefined ? [options.blueprint] : []),
+        ...(options.modules ?? [])
+    ];
+    return await StoneFactory.create({ modules }).run();
+}
+
+/**
+ * Returns a Web-standard fetch handler that boots the app lazily on the first request (so it works
+ * as a module export). This is the generic target — Vercel Edge and any WinterCG host use it as-is.
+ *
+ * @param options - The app to boot.
+ * @returns A fetch handler.
+ */
+function serveFetch(options = {}) {
+    let handler;
+    return async (request, executionContext) => {
+        handler = handler ?? buildFetchHandler(options);
+        return await (await handler)(request, executionContext);
+    };
+}
+/**
+ * Cloudflare Workers entry: `export default serveCloudflare({ modules: [App] })`.
+ * The Worker's `env`/`ctx` are forwarded to the handler's execution context.
+ *
+ * @param options - The app to boot.
+ * @returns A Cloudflare module worker with a `fetch` method.
+ */
+function serveCloudflare(options = {}) {
+    const handler = serveFetch(options);
+    return {
+        fetch: async (request, env, ctx) => await handler(request, { env, ctx })
+    };
+}
+/**
+ * Vercel Edge Function entry: `export default serveVercel({ modules: [App] })`
+ * (add `export const config = { runtime: 'edge' }`).
+ *
+ * @param options - The app to boot.
+ * @returns A fetch handler.
+ */
+function serveVercel(options = {}) {
+    return serveFetch(options);
+}
+/**
+ * Netlify Edge Function entry: `export default serveNetlify({ modules: [App] })`.
+ * Netlify's context is forwarded to the handler's execution context.
+ *
+ * @param options - The app to boot.
+ * @returns A Netlify edge handler.
+ */
+function serveNetlify(options = {}) {
+    const handler = serveFetch(options);
+    return async (request, context) => await handler(request, { context });
+}
+/**
+ * Bun entry: `export default serveBun({ modules: [App] })` — a `Bun.serve` compatible object.
+ *
+ * @param options - The app to boot.
+ * @param serveOptions - Extra `Bun.serve` options (e.g. `port`).
+ * @returns A Bun server object with a `fetch` method.
+ */
+function serveBun(options = {}, serveOptions = {}) {
+    const handler = serveFetch(options);
+    return { ...serveOptions, fetch: async (request) => await handler(request) };
+}
+/**
+ * Deno entry: `serveDeno({ modules: [App] })` — starts `Deno.serve` immediately.
+ *
+ * @param options - The app to boot.
+ * @param serveOptions - Extra `Deno.serve` options (e.g. `{ port }`).
+ * @returns Whatever `Deno.serve` returns (the server).
+ * @throws {Error} When not running on Deno.
+ */
+function serveDeno(options = {}, serveOptions = {}) {
+    const deno = globalThis.Deno;
+    if (deno?.serve === undefined) {
+        throw new Error('serveDeno must run on the Deno runtime (`Deno.serve` was not found).');
+    }
+    const handler = serveFetch(options);
+    return deno.serve(serveOptions, async (request) => await handler(request));
+}
+
+export { buildFetchHandler, serveBun, serveCloudflare, serveDeno, serveFetch, serveNetlify, serveVercel };

package/dist/serve.d.ts

@@ -0,0 +1,52 @@
+import { EdgeAppOptions, FetchHandler } from './declarations';
+/**
+ * Returns a Web-standard fetch handler that boots the app lazily on the first request (so it works
+ * as a module export). This is the generic target — Vercel Edge and any WinterCG host use it as-is.
+ *
+ * @param options - The app to boot.
+ * @returns A fetch handler.
+ */
+export declare function serveFetch(options?: EdgeAppOptions): FetchHandler;
+/**
+ * Cloudflare Workers entry: `export default serveCloudflare({ modules: [App] })`.
+ * The Worker's `env`/`ctx` are forwarded to the handler's execution context.
+ *
+ * @param options - The app to boot.
+ * @returns A Cloudflare module worker with a `fetch` method.
+ */
+export declare function serveCloudflare(options?: EdgeAppOptions): {
+    fetch: (request: Request, env?: unknown, ctx?: unknown) => Promise<Response>;
+};
+/**
+ * Vercel Edge Function entry: `export default serveVercel({ modules: [App] })`
+ * (add `export const config = { runtime: 'edge' }`).
+ *
+ * @param options - The app to boot.
+ * @returns A fetch handler.
+ */
+export declare function serveVercel(options?: EdgeAppOptions): FetchHandler;
+/**
+ * Netlify Edge Function entry: `export default serveNetlify({ modules: [App] })`.
+ * Netlify's context is forwarded to the handler's execution context.
+ *
+ * @param options - The app to boot.
+ * @returns A Netlify edge handler.
+ */
+export declare function serveNetlify(options?: EdgeAppOptions): (request: Request, context?: unknown) => Promise<Response>;
+/**
+ * Bun entry: `export default serveBun({ modules: [App] })` — a `Bun.serve` compatible object.
+ *
+ * @param options - The app to boot.
+ * @param serveOptions - Extra `Bun.serve` options (e.g. `port`).
+ * @returns A Bun server object with a `fetch` method.
+ */
+export declare function serveBun(options?: EdgeAppOptions, serveOptions?: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Deno entry: `serveDeno({ modules: [App] })` — starts `Deno.serve` immediately.
+ *
+ * @param options - The app to boot.
+ * @param serveOptions - Extra `Deno.serve` options (e.g. `{ port }`).
+ * @returns Whatever `Deno.serve` returns (the server).
+ * @throws {Error} When not running on Deno.
+ */
+export declare function serveDeno(options?: EdgeAppOptions, serveOptions?: Record<string, unknown>): unknown;

package/package.json

@@ -0,0 +1,92 @@
+{
+  "name": "@stone-js/edge-adapter",
+  "version": "0.8.0",
+  "description": "Deploy a Stone.js app to any WinterCG/edge or JS runtime — Cloudflare Workers, Vercel Edge, Netlify Edge, Deno and Bun — with one-line serve helpers on top of @stone-js/fetch-adapter. Build once, deploy anywhere.",
+  "author": "Mr. Stone <evensstone@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/stone-foundation/stone-js-framework.git",
+    "directory": "stone-js-edge-adapter"
+  },
+  "homepage": "https://stonejs.dev",
+  "bugs": {
+    "url": "https://github.com/stone-foundation/stone-js-framework/issues"
+  },
+  "keywords": [
+    "StoneJS",
+    "adapter",
+    "edge",
+    "cloudflare",
+    "vercel",
+    "netlify",
+    "deno",
+    "bun",
+    "wintercg"
+  ],
+  "files": [
+    "/dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "engines": {
+    "node": ">=18.17.0"
+  },
+  "peerDependencies": {
+    "@stone-js/core": "0.8.0",
+    "@stone-js/fetch-adapter": "0.8.0"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^19.8.1",
+    "@commitlint/config-conventional": "^19.8.1",
+    "@rollup/plugin-commonjs": "^28.0.6",
+    "@rollup/plugin-multi-entry": "^6.0.1",
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-typescript": "^12.1.4",
+    "@types/node": "^24.0.7",
+    "@vitest/coverage-v8": "^3.2.4",
+    "husky": "^9.1.7",
+    "rimraf": "^6.0.1",
+    "rollup": "^4.44.1",
+    "rollup-plugin-node-externals": "^8.0.1",
+    "ts-standard": "^12.0.2",
+    "tslib": "^2.8.1",
+    "typedoc": "^0.28.6",
+    "typedoc-plugin-markdown": "^4.7.0",
+    "typescript": "^5.6.3",
+    "vitest": "^3.2.4",
+    "@stone-js/core": "0.8.0",
+    "@stone-js/fetch-adapter": "0.8.0",
+    "@stone-js/http-core": "0.8.0"
+  },
+  "ts-standard": {
+    "globals": [
+      "it",
+      "test",
+      "vi",
+      "expect",
+      "describe",
+      "beforeEach"
+    ]
+  },
+  "scripts": {
+    "lint": "ts-standard src",
+    "lint:fix": "ts-standard --fix src tests",
+    "predoc": "rimraf docs",
+    "doc": "typedoc",
+    "clean": "rimraf dist",
+    "build": "rollup -c",
+    "test": "vitest run",
+    "test:cvg": "npm run test -- --coverage",
+    "test:text": "npm run test:cvg -- --coverage.reporter=text",
+    "test:html": "npm run test:cvg -- --coverage.reporter=html",
+    "test:clover": "npm run test:cvg -- --coverage.reporter=clover"
+  }
+}