@tschk/moonshine-deploy-cloudflare 0.4.1 → 0.4.4

package/README.md

@@ -18,3 +18,29 @@ Cache API limits apply.
 
 See [docs/DEPLOYMENT.md](../../docs/DEPLOYMENT.md) and
 [docs/MANIFEST.md](../../docs/MANIFEST.md).
+
+Native apps use `renderer: "native"`, `runtime: "cloudflare"`, and
+`adapter: "cloudflare"`. The adapter emits a bundled `server.js`, public assets,
+and `wrangler.jsonc`. Run the generated artifact locally with an installed
+Wrangler:
+
+```bash
+wrangler dev --local --config .moonshine/wrangler.jsonc
+```
+
+The native worker uses the bundled module table and independent renderer, without
+React, Solid, a global module registry, or source-file imports. SSR, static output,
+API routes and SPA routes with explicit `clientFile` use this path. Public files
+are served through the `ASSETS` binding. The generated config invokes the worker
+first, enables Node compatibility for shared server imports, and uses the build
+date as its compatibility date. A recent Wrangler/workerd is required; older local
+runtimes may require an isolated test configuration with an older supported date.
+
+Native hydration/islands, opt-in request context, and route caching/revalidation
+are rejected explicitly. The legacy `cloudflareFetch` helper and React renderer
+remain available for existing apps; native apps use the generated worker.
+
+The optional native artifact test discovers an existing Wrangler/Miniflare
+installation and runs real workerd. It skips when that tool is unavailable and
+does not install it. The installed 2026-06-16 emulator baseline was verified with
+explicit Node compatibility; this does not establish production deployment.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tschk/moonshine-deploy-cloudflare",
-  "version": "0.4.1",
+  "version": "0.4.4",
   "license": "ISC",
   "type": "module",
   "main": "./src/index.ts",
@@ -15,18 +15,24 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@tschk/moonshine-compiler": "^0.4.1",
-    "@tschk/moonshine-framework": "^0.4.1",
-    "@tschk/moonshine-react": "^0.4.1",
-    "@tschk/moonshine-router": "^0.4.1",
-    "@tschk/moonshine-server": "^0.4.1"
+    "@tschk/moonshine-framework": "^0.4.4",
+    "@tschk/moonshine-router": "^0.4.4",
+    "@tschk/moonshine-server": "^0.4.4"
   },
   "devDependencies": {
     "@types/bun": "1.3.14",
     "typescript": "7.0.2",
-    "@tschk/moonshine-adapter-conformance": "^0.4.1"
+    "@tschk/moonshine-adapter-conformance": "^0.4.4"
   },
   "files": [
     "src"
-  ]
+  ],
+  "peerDependencies": {
+    "@tschk/moonshine-react": "^0.4.4"
+  },
+  "peerDependenciesMeta": {
+    "@tschk/moonshine-react": {
+      "optional": true
+    }
+  }
 }

package/src/index.ts

@@ -1,17 +1,20 @@
-import { copyFile, mkdir, writeFile } from "node:fs/promises";
-import { dirname, isAbsolute, resolve } from "node:path";
+import { writeFile, mkdir } from "node:fs/promises";
+import { resolve } from "node:path";
 import {
   createRequestHandler,
   tryServeStatic,
   type RouteModule,
 } from "@tschk/moonshine-server";
-import { matchRoutes, createRouteGraph } from "@tschk/moonshine-router";
-import { reactRenderer, registerRouteModules } from "@tschk/moonshine-react";
-import type {
-  DeploymentAdapter,
-  MoonshineManifest,
-  Harness,
-  HarnessFactory,
+import { matchRoutes, createRouteGraph } from "@tschk/moonshine-router/graph";
+import {
+  type DeploymentAdapter,
+  type MoonshineManifest,
+  type Harness,
+  type HarnessFactory,
+  resolveManifestFiles,
+  copyAssets,
+  validateRuntime,
+  validateCapabilities,
 } from "@tschk/moonshine-framework";
 
 export type CloudflareEnv = {
@@ -41,6 +44,8 @@ export async function cloudflareFetch(
     if (assetRes.status !== 404) return assetRes;
   }
 
+  const { reactRenderer, registerRouteModules } =
+    await import("@tschk/moonshine-react");
   const graph = createRouteGraph(manifest.routes);
   const match = matchRoutes(graph, pathname);
   registerRouteModules(modules);
@@ -81,90 +86,64 @@ export async function cloudflareFetch(
 
 export default cloudflareFetch;
 
-function resolveManifestFiles(
+async function buildNativeWorker(
   manifest: MoonshineManifest,
-  projectRoot: string,
-): MoonshineManifest {
-  return {
-    ...manifest,
-    routes: manifest.routes.map((route) => ({
-      ...route,
-      file: isAbsolute(route.file)
-        ? route.file
-        : resolve(projectRoot, route.file),
-      ...(route.dataFile && {
-        dataFile: isAbsolute(route.dataFile)
-          ? route.dataFile
-          : resolve(projectRoot, route.dataFile),
-      }),
-      ...(route.layouts && {
-        layouts: route.layouts.map((layout) =>
-          isAbsolute(layout) ? layout : resolve(projectRoot, layout),
-        ),
-      }),
-      ...(route.middleware && {
-        middleware: route.middleware.map((middleware) =>
-          isAbsolute(middleware)
-            ? middleware
-            : resolve(projectRoot, middleware),
-        ),
-      }),
-      ...(route.errorBoundary && {
-        errorBoundary: isAbsolute(route.errorBoundary)
-          ? route.errorBoundary
-          : resolve(projectRoot, route.errorBoundary),
-      }),
-    })),
-  };
-}
-
-async function copyAssets(
-  assets: MoonshineManifest["assets"],
   outDir: string,
 ): Promise<void> {
-  await Promise.all(
-    assets.map(async (asset) => {
-      const source = isAbsolute(asset.file)
-        ? asset.file
-        : resolve(outDir, asset.file);
-      const target = resolve(
-        outDir,
-        (asset.path ?? asset.file).replace(/^\/+/, ""),
-      );
-      await mkdir(dirname(target), { recursive: true });
-      if (source !== target) {
-        await copyFile(source, target);
-      }
-    }),
+  await writeFile(
+    resolve(outDir, "manifest.json"),
+    JSON.stringify(manifest, null, 2) + "\n",
   );
-}
-
-function validateRuntime(
-  adapter: DeploymentAdapter,
-  manifest: MoonshineManifest,
-): void {
-  const errors: string[] = [];
-  for (const route of manifest.routes) {
-    if (!adapter.runtimes.includes(route.runtime)) {
-      errors.push(
-        `${adapter.name} adapter does not support route "${route.path}" with runtime "${route.runtime}"; supported runtimes: ${adapter.runtimes.join(", ")}`,
-      );
-    }
-  }
-  if (errors.length) throw new Error(errors.join("\n"));
-}
+  await copyAssets(manifest.assets, outDir);
+  await mkdir(resolve(outDir, "public"), { recursive: true });
+  const entry = `import { createRequestHandler } from "@tschk/moonshine-server";
+import { modules, renderer } from "./dist/server.js";
+import manifest from "./manifest.json" with { type: "json" };
 
-function validateCapabilities(
-  adapter: DeploymentAdapter,
-  manifest: MoonshineManifest,
-): void {
-  for (const capability of manifest.capabilities) {
-    if (!adapter.capabilities.includes(capability)) {
-      throw new Error(
-        `${adapter.name} adapter does not support capability "${capability}"; supported capabilities: ${adapter.capabilities.join(", ")}`,
-      );
+const handler = createRequestHandler({ manifest, modules, renderer });
+export default {
+  async fetch(request, env) {
+    if (env.ASSETS && (request.method === "GET" || request.method === "HEAD") && new URL(request.url).pathname !== "/") {
+      const response = await env.ASSETS.fetch(request);
+      if (response.status !== 404) return response;
+      if (response.body) void response.body.cancel().catch(() => {});
     }
-  }
+    return handler(request);
+  },
+};
+`;
+  const entryPath = resolve(outDir, "server.ts");
+  await writeFile(entryPath, entry);
+  const result = await Bun.build({
+    entrypoints: [entryPath],
+    outdir: outDir,
+    target: "browser",
+    external: ["node:*"],
+    packages: "bundle",
+  });
+  if (!result.success)
+    throw new AggregateError(
+      result.logs,
+      "Native Cloudflare worker bundle failed",
+    );
+  await writeFile(
+    resolve(outDir, "wrangler.jsonc"),
+    JSON.stringify(
+      {
+        name: "moonshine-native",
+        main: "server.js",
+        compatibility_date: new Date().toISOString().slice(0, 10),
+        compatibility_flags: ["nodejs_compat"],
+        assets: {
+          directory: "./public",
+          binding: "ASSETS",
+          run_worker_first: true,
+        },
+      },
+      null,
+      2,
+    ) + "\n",
+  );
 }
 
 export const cloudflareAdapter: DeploymentAdapter = {
@@ -172,10 +151,29 @@ export const cloudflareAdapter: DeploymentAdapter = {
   runtimes: ["cloudflare"],
   capabilities: ["streaming", "islands", "edge", "revalidation"],
   build: async (manifest, outDir) => {
+    if (manifest.requestContext)
+      throw new Error("Cloudflare request context is not supported");
+    if (
+      manifest.renderer === "native" &&
+      (manifest.routes.some((route) => route.cache) ||
+        manifest.capabilities.includes("revalidation"))
+    )
+      throw new Error(
+        "Native Cloudflare route caching/revalidation is not implemented",
+      );
+    if (
+      manifest.renderer === "native" &&
+      manifest.routes.some((route) => route.mode === "island")
+    )
+      throw new Error("Native island hydration is not implemented");
     validateRuntime(cloudflareAdapter, manifest);
     validateCapabilities(cloudflareAdapter, manifest);
 
     await mkdir(outDir, { recursive: true });
+    if (manifest.renderer === "native") {
+      await buildNativeWorker(manifest, outDir);
+      return;
+    }
     const projectRoot = resolve(outDir, "..");
     const resolvedManifest = resolveManifestFiles(manifest, projectRoot);
 
@@ -213,7 +211,12 @@ export const cloudflareHarness: HarnessFactory = (fetch, options) => {
         (request.method === "GET" || request.method === "HEAD") &&
         pathname !== "/"
       ) {
-        const res = await tryServeStatic(options.staticDir, pathname);
+        const res = await tryServeStatic(
+          options.staticDir,
+          pathname,
+          undefined,
+          request.method,
+        );
         if (res) return res;
       }
       return fetch(request);