@lunora/nuxt 1.0.0-alpha.29 → 1.0.0-alpha.290

package/README.md

@@ -79,19 +79,20 @@ export { ShardDO } from "./lunora/server";
 `lunora/server.ts` is your built Lunora app (`defineApp().build()`) — its default
 export is the worker (a `fetch` entrypoint), and it re-exports `ShardDO`. The
 module aliases the `#lunora/app` virtual to it (configurable via the `lunora.appEntry`
-option, default `~/lunora/server`) and serves it at the `/_lunora/**` route
-(prefix configurable via `lunora.prefix`).
+option, default `~/lunora/server`) and serves it at the `/_lunora/**` route.
 
 ## Options
 
 | Option     | Default           | Description                                               |
 | ---------- | ----------------- | --------------------------------------------------------- |
 | `appEntry` | `~/lunora/server` | Module specifier of the Lunora app entry (`#lunora/app`). |
-| `prefix`   | `/_lunora`        | URL prefix the Lunora realtime plane is mounted at.       |
+
+The `/_lunora/**` mount is fixed: the worker routes on those exact paths and the
+generated client calls them.
 
 ## How it works
 
-- **The route** (`addServerHandler` at `prefix/**`): reconstructs a Web `Request`
+- **The route** (`addServerHandler` at `/_lunora/**`): reconstructs a Web `Request`
   from the H3 event, resolves the Cloudflare `env`/`ExecutionContext` off it
   (tolerating both `event.context.cloudflare` and `event.req.runtime.cloudflare`),
   and forwards to your app's `fetch`. A missing Cloudflare runtime answers a clear 500.

package/dist/module.d.mts

@@ -1,9 +1,78 @@
-import * as nuxt_schema from 'nuxt/schema';
-
+import { defineNuxtModule } from '@nuxt/kit';
+/**
+ * Check that `worker.ts` at the project root actually re-exports `ShardDO` —
+ * not just that the file exists. Extracted from `setup()` so it is testable
+ * without booting Nuxt (`defineNuxtModule`'s `setup` needs full Nuxt Kit
+ * scaffolding to invoke; this plain function does not).
+ *
+ * All three outcomes — missing file, unreadable file, present-but-no-`ShardDO`-
+ * export — WARN and return; none of them throws. Matches the module's existing
+ * stance ("we can't write the user's file, so warn... rather than fail an
+ * otherwise-valid build") and the `@lunora/astro` precedent this mirrors.
+ */
+declare const checkWorkerEntry: (rootDirectory: string, warn: (message: string) => void) => void;
+/**
+ * One entry of Nuxt's resolved plugin list (`app.plugins` at `app:resolve`):
+ * an absolute `src` plus the `mode` Nuxt derived for it. Declared structurally
+ * for the same reason as {@link LunoraNuxtModule} — `@nuxt/schema`, which owns
+ * `NuxtPlugin`, is not a resolvable dependency here — and `NuxtPlugin[]`
+ * satisfies it.
+ */
+interface ResolvedNuxtPlugin {
+  mode?: "all" | "client" | "server";
+  src: string;
+}
+/**
+ * Warn when the project's ONLY `LunoraClient` provider is a client-only plugin.
+ *
+ * `@lunora/vue`'s composables call `useLunora()` unconditionally — ahead of
+ * their own browser guard — and it throws when nothing is injected. A
+ * `plugins/lunora.client.ts` by definition never runs on the server, so the
+ * first server-rendered page touching Lunora answers 500 with
+ * `useLunora(): no LunoraClient provided`. The fix is dropping `.client` from
+ * the filename plus a universal way to read the origin, which the warning says.
+ *
+ * Takes Nuxt's own resolved plugin list (`app.plugins`, from the `app:resolve`
+ * hook) rather than scanning `plugins/` itself. That is the whole point: Nuxt
+ * loads plugins with a two-pattern, ONE-level glob — top-level entries plus a
+ * subdirectory's `index` file — over every layer's configured plugins dir, so
+ * a filesystem scan of its own has to mirror the glob, the extension list,
+ * `dir.plugins` and every layer — and gets the answer WRONG in both directions
+ * when it doesn't. A recursive scan counts `plugins/lib/make-client.ts` (an
+ * ordinary colocated helper Nuxt never loads) as a universal provider and goes
+ * silent on a genuinely broken app. Reading `mode` off the resolved entry also
+ * drops the `.client` filename rule, since that is what Nuxt derived it from.
+ *
+ * Detection of the provider itself is the same shape as
+ * {@link looksLikeShardDoExport}: a documented keyword test, not a TS parse,
+ * because the outcome is a build-time warning. Its imprecision is a
+ * `createLunora` mention inside a comment, whose only cost is a warning
+ * pointing at a file that is already about the client.
+ *
+ * Silence requires a provider Nuxt loads on the server — `mode` `"all"` or
+ * `"server"` — not merely a working app: an app that confines every Lunora
+ * usage to `<ClientOnly>` is correct with a client-only provider and still
+ * warns, which is why the message names that case as a reason to ignore it.
+ */
+declare const checkClientOnlyProvider: (plugins: ReadonlyArray<ResolvedNuxtPlugin>, warn: (message: string) => void) => void;
+/** Options for the `@lunora/nuxt` module (configurable under the `lunora` key in `nuxt.config`). */
 interface ModuleOptions {
-    appEntry: string;
-    prefix: string;
+  /**
+   * Module specifier of the Lunora app entry — its default export is the built
+   * worker (`defineApp().build()` / `createWorker(...)`) and it re-exports
+   * `ShardDO`. Aliased to the `#lunora/app` virtual the server route imports.
+   */
+  appEntry: string;
 }
-declare const _default: nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
-
-export { _default as default };
+/**
+ * Return type of `defineNuxtModule<ModuleOptions>({...})` — the value overload of
+ * `defineNuxtModule` (the one taking a definition), extracted structurally so the
+ * default export has a locally-nameable type under `isolatedDeclarations` without
+ * importing `NuxtModule` from `@nuxt/schema` (not a resolvable dependency here).
+ */
+type LunoraNuxtModule = typeof defineNuxtModule<ModuleOptions> extends {
+  (definition: infer _Definition): infer Result;
+  (): unknown;
+} ? Result : never;
+declare const lunoraNuxtModule: LunoraNuxtModule;
+export { ModuleOptions, ResolvedNuxtPlugin, checkClientOnlyProvider, checkWorkerEntry, lunoraNuxtModule as default };

package/dist/module.d.ts

@@ -0,0 +1,78 @@
+import { defineNuxtModule } from '@nuxt/kit';
+/**
+ * Check that `worker.ts` at the project root actually re-exports `ShardDO` —
+ * not just that the file exists. Extracted from `setup()` so it is testable
+ * without booting Nuxt (`defineNuxtModule`'s `setup` needs full Nuxt Kit
+ * scaffolding to invoke; this plain function does not).
+ *
+ * All three outcomes — missing file, unreadable file, present-but-no-`ShardDO`-
+ * export — WARN and return; none of them throws. Matches the module's existing
+ * stance ("we can't write the user's file, so warn... rather than fail an
+ * otherwise-valid build") and the `@lunora/astro` precedent this mirrors.
+ */
+declare const checkWorkerEntry: (rootDirectory: string, warn: (message: string) => void) => void;
+/**
+ * One entry of Nuxt's resolved plugin list (`app.plugins` at `app:resolve`):
+ * an absolute `src` plus the `mode` Nuxt derived for it. Declared structurally
+ * for the same reason as {@link LunoraNuxtModule} — `@nuxt/schema`, which owns
+ * `NuxtPlugin`, is not a resolvable dependency here — and `NuxtPlugin[]`
+ * satisfies it.
+ */
+interface ResolvedNuxtPlugin {
+  mode?: "all" | "client" | "server";
+  src: string;
+}
+/**
+ * Warn when the project's ONLY `LunoraClient` provider is a client-only plugin.
+ *
+ * `@lunora/vue`'s composables call `useLunora()` unconditionally — ahead of
+ * their own browser guard — and it throws when nothing is injected. A
+ * `plugins/lunora.client.ts` by definition never runs on the server, so the
+ * first server-rendered page touching Lunora answers 500 with
+ * `useLunora(): no LunoraClient provided`. The fix is dropping `.client` from
+ * the filename plus a universal way to read the origin, which the warning says.
+ *
+ * Takes Nuxt's own resolved plugin list (`app.plugins`, from the `app:resolve`
+ * hook) rather than scanning `plugins/` itself. That is the whole point: Nuxt
+ * loads plugins with a two-pattern, ONE-level glob — top-level entries plus a
+ * subdirectory's `index` file — over every layer's configured plugins dir, so
+ * a filesystem scan of its own has to mirror the glob, the extension list,
+ * `dir.plugins` and every layer — and gets the answer WRONG in both directions
+ * when it doesn't. A recursive scan counts `plugins/lib/make-client.ts` (an
+ * ordinary colocated helper Nuxt never loads) as a universal provider and goes
+ * silent on a genuinely broken app. Reading `mode` off the resolved entry also
+ * drops the `.client` filename rule, since that is what Nuxt derived it from.
+ *
+ * Detection of the provider itself is the same shape as
+ * {@link looksLikeShardDoExport}: a documented keyword test, not a TS parse,
+ * because the outcome is a build-time warning. Its imprecision is a
+ * `createLunora` mention inside a comment, whose only cost is a warning
+ * pointing at a file that is already about the client.
+ *
+ * Silence requires a provider Nuxt loads on the server — `mode` `"all"` or
+ * `"server"` — not merely a working app: an app that confines every Lunora
+ * usage to `<ClientOnly>` is correct with a client-only provider and still
+ * warns, which is why the message names that case as a reason to ignore it.
+ */
+declare const checkClientOnlyProvider: (plugins: ReadonlyArray<ResolvedNuxtPlugin>, warn: (message: string) => void) => void;
+/** Options for the `@lunora/nuxt` module (configurable under the `lunora` key in `nuxt.config`). */
+interface ModuleOptions {
+  /**
+   * Module specifier of the Lunora app entry — its default export is the built
+   * worker (`defineApp().build()` / `createWorker(...)`) and it re-exports
+   * `ShardDO`. Aliased to the `#lunora/app` virtual the server route imports.
+   */
+  appEntry: string;
+}
+/**
+ * Return type of `defineNuxtModule<ModuleOptions>({...})` — the value overload of
+ * `defineNuxtModule` (the one taking a definition), extracted structurally so the
+ * default export has a locally-nameable type under `isolatedDeclarations` without
+ * importing `NuxtModule` from `@nuxt/schema` (not a resolvable dependency here).
+ */
+type LunoraNuxtModule = typeof defineNuxtModule<ModuleOptions> extends {
+  (definition: infer _Definition): infer Result;
+  (): unknown;
+} ? Result : never;
+declare const lunoraNuxtModule: LunoraNuxtModule;
+export { ModuleOptions, ResolvedNuxtPlugin, checkClientOnlyProvider, checkWorkerEntry, lunoraNuxtModule as default };

package/dist/module.json

@@ -1,9 +1,5 @@
 {
   "configKey": "lunora",
   "name": "@lunora/nuxt",
-  "version": "1.0.0-alpha.28",
-  "builder": {
-    "@nuxt/module-builder": "1.0.2",
-    "unbuild": "unknown"
-  }
-}
+  "version": "1.0.0-alpha.289"
+}

package/dist/module.mjs

@@ -1,72 +1 @@
-import { existsSync } from 'node:fs';
-import { join, resolve, dirname } from 'node:path';
-import { defineNuxtModule, createResolver, addServerHandler, useLogger } from '@nuxt/kit';
-
-const resolveTildePath = (specifier, rootDirectory, sourceDirectory) => {
-  if (specifier.startsWith("~~/")) {
-    return join(rootDirectory, specifier.slice(3));
-  }
-  if (specifier.startsWith("~/")) {
-    return join(sourceDirectory, specifier.slice(2));
-  }
-  if (specifier.startsWith("./") || specifier.startsWith("../")) {
-    return join(rootDirectory, specifier);
-  }
-  return specifier;
-};
-
-const JS_EXTENSION_SUFFIX = /\.js$/;
-const lunoraTsSourceResolver = (rootDirectory) => {
-  const lunoraDirectory = join(rootDirectory, "lunora");
-  return {
-    name: "lunora:nitro-ts-source-resolve",
-    resolveId: {
-      handler(source, importer) {
-        if (!source.endsWith(".js")) {
-          return void 0;
-        }
-        let absolute;
-        if (source.startsWith("#lunora/")) {
-          absolute = join(lunoraDirectory, source.slice("#lunora/".length));
-        } else if (source.startsWith(".") && importer !== void 0) {
-          absolute = resolve(dirname(importer), source);
-        }
-        if (absolute === void 0) {
-          return void 0;
-        }
-        const tsSource = absolute.replace(JS_EXTENSION_SUFFIX, ".ts");
-        return existsSync(tsSource) ? tsSource : void 0;
-      },
-      order: "pre"
-    }
-  };
-};
-const module$1 = defineNuxtModule({
-  defaults: {
-    appEntry: "~/lunora/server",
-    prefix: "/_lunora"
-  },
-  meta: {
-    configKey: "lunora",
-    name: "@lunora/nuxt"
-  },
-  setup(options, nuxt) {
-    const resolver = createResolver(import.meta.url);
-    nuxt.options.alias["#lunora/app"] = resolveTildePath(options.appEntry, nuxt.options.rootDir, nuxt.options.srcDir);
-    nuxt.hook("nitro:config", (nitroConfig) => {
-      const plugins = [...nitroConfig.rollupConfig?.plugins ?? [], lunoraTsSourceResolver(nuxt.options.rootDir)];
-      nitroConfig.rollupConfig = { ...nitroConfig.rollupConfig, plugins };
-    });
-    addServerHandler({
-      handler: resolver.resolve("./runtime/server/lunora"),
-      route: `${options.prefix}/**`
-    });
-    if (!existsSync(join(nuxt.options.rootDir, "worker.ts"))) {
-      useLogger("@lunora/nuxt").warn(
-        'missing worker.ts at the project root \u2014 add a wrapper that re-exports Nitro\'s handler and `ShardDO` (`export { default } from "./.output/server/index.mjs"; export { ShardDO } from "./lunora/server";`) and point wrangler\'s `main` at it, so the SHARD Durable Object is exported from the deployed worker.'
-      );
-    }
-  }
-});
-
-export { module$1 as default };
+import{existsSync as d,readFileSync as c}from"node:fs";import{join as s,resolve as m,dirname as E}from"node:path";import{defineNuxtModule as f,createResolver as g,addServerHandler as v,useLogger as u}from"@nuxt/kit";const S=String.raw`\/\*[\s\S]*?\*\/`,w=String.raw`\/\/[^\n]*`,R=String.raw`"(?:[^"\\\n]|\\.)*"`,O=String.raw`'(?:[^'\\\n]|\\.)*'`,T=String.raw`\x60(?:[^\x60\\$]|\\.|\$(?!\{))*\x60`,h=new RegExp([S,w,R,O,T].join("|"),"gu"),D=/[^\n]/gu,p=e=>e.replaceAll(D," "),i=e=>e.replaceAll(h,p),N=e=>e.replaceAll(h,r=>r.startsWith("//")||r.startsWith("/*")?p(r):r),_=(e,r,o)=>e.startsWith("~~/")?s(r,e.slice(3)):e.startsWith("~/")?s(o,e.slice(2)):e.startsWith("./")||e.startsWith("../")?s(r,e):e,x=/\.js$/,L=e=>{const r=s(e,"lunora");return{name:"lunora:nitro-ts-source-resolve",resolveId:{handler(o,t){if(!o.endsWith(".js"))return;let n;if(o.startsWith("#lunora/")?n=s(r,o.slice(8)):o.startsWith(".")&&t!==void 0&&(n=m(E(t),o)),n===void 0)return;const a=n.replace(x,".ts");return d(a)?a:void 0},order:"pre"}}},l='import nitro from "./.output/server/index.mjs"; import app, { ShardDO } from "./lunora/server"; export { ShardDO }; export default { ...nitro, email: (m, e, x) => app.email?.(m, e, x), queue: (b, e, x) => app.queue?.(b, e, x), scheduled: (c, e, x) => app.scheduled(c, e, x) };',k=/\bexport\b/u,y=/\bShardDO\b/u,A=/\bexport\s*\*\s*from\s*["'][^"']*lunora[^"']*["']/gu,b=e=>{const r=i(e);return[...N(e).matchAll(A)].some(({index:o})=>r[o]===e[o])},I=/\bscheduled\b/u,P=e=>{const r=i(e);return k.test(r)?y.test(r)||b(e):!1},C=(e,r)=>{const o=s(e,"worker.ts");if(!d(o)){r(`missing worker.ts at the project root — add a wrapper that re-exports Nitro's handler and \`ShardDO\` (\`${l}\`) and point wrangler's \`main\` at it, so the SHARD Durable Object is exported from the deployed worker.`);return}let t;try{t=c(o,"utf8")}catch(n){const a=n instanceof Error?n.message:String(n);r(`could not read worker.ts at the project root (${a}) — skipping the \`ShardDO\` export check.`);return}P(t)||r(`worker.ts at the project root does not appear to export \`ShardDO\` — add \`export { ShardDO } from "./lunora/server";\` (e.g. \`${l}\`) and point wrangler's \`main\` at it, so the SHARD Durable Object is exported from the deployed worker.`),I.test(i(t))||r(`worker.ts at the project root does not forward \`scheduled\` — re-exporting Nitro's \`default\` gives Cloudflare a \`scheduled\` entrypoint that only fires an empty \`cloudflare:scheduled\` hook, so a cron declared in \`lunora/crons.ts\` is provisioned and then runs nothing. Compose the two instead (\`${l}\`), which forwards \`queue\` and \`email\` too — Nitro's exports for those fire empty hooks the same way, and a queue consumer that returns without throwing ACKS its batch.`)},W=/\bcreateLunora\b/u,j=e=>{try{return W.test(i(c(e,"utf8")))}catch{return!1}},U=(e,r)=>{const o=e.filter(t=>j(t.src));o.length===0||o.some(t=>t.mode!=="client")||r(`the only plugin providing a \`LunoraClient\` is client-only (${o.map(t=>t.src).join(", ")}) — \`@lunora/vue\`'s composables resolve the client during SSR too and throw \`useLunora(): no LunoraClient provided\` without one, so the first server-rendered page that touches Lunora answers 500. Drop the \`.client\` from the filename to make the plugin universal, and read the origin with \`useRequestURL().origin\`, which resolves from the incoming request on the server and from \`window.location\` in the browser. Ignore this if every Lunora usage is confined to \`<ClientOnly>\`, which never renders on the server.`)},$="/_lunora",K=f({defaults:{appEntry:"~/lunora/server"},meta:{configKey:"lunora",name:"@lunora/nuxt"},setup(e,r){const o=g(import.meta.url);r.options.alias["#lunora/app"]=_(e.appEntry,r.options.rootDir,r.options.srcDir),r.hook("nitro:config",t=>{const n=[...t.rollupConfig?.plugins??[],L(r.options.rootDir)];t.rollupConfig={...t.rollupConfig,plugins:n}}),v({handler:o.resolve("./runtime/server/lunora"),route:`${$}/**`}),C(r.options.rootDir,t=>{u("@lunora/nuxt").warn(t)}),r.hook("app:resolve",t=>{U(t.plugins,n=>{u("@lunora/nuxt").warn(n)})})}});export{U as checkClientOnlyProvider,C as checkWorkerEntry,K as default};

package/dist/runtime/cloudflare.d.mts

@@ -0,0 +1,56 @@
+/**
+ * Resolve the Cloudflare per-request `env` (bindings) and `ExecutionContext`
+ * from a Nitro/H3 event, tolerating the two shapes Nitro has shipped.
+ *
+ * Legacy `event.context.cloudflare.{ env, context }` — surfaced by
+ * `nitro-cloudflare-dev` in `nuxt dev` and by older `cloudflare_module` builds,
+ * where `context` is the `ExecutionContext` (`waitUntil` / `passThroughOnException`).
+ *
+ * Newer `event.req.runtime.cloudflare.{ env, ctx }` — the Nitro runtime accessor
+ * (Nitro v2.10+ / Nuxt 4), where the `ExecutionContext` is `ctx`.
+ *
+ * Both are read defensively so the delegating handler works across the version
+ * range a scaffolded app might pin, in both dev and the deployed worker. When
+ * neither is present (no Cloudflare runtime — e.g. a Node preview), `env` is
+ * `undefined` and the caller surfaces a clear error.
+ *
+ * Typed against a structural `H3EventLike` rather than `nitropack`'s `H3Event`
+ * so this seam stays pure (no Nitro types needed) and unit-testable with a plain
+ * object — a real `H3Event` is still assignable here.
+ */
+import { ExecutionContextLike } from '@lunora/runtime';
+export type { ExecutionContextLike } from '@lunora/runtime';
+/** The `{ env, context|ctx }` payload Nitro attaches for the Cloudflare runtime. */
+interface CloudflareEventBag {
+  context?: ExecutionContextLike;
+  ctx?: ExecutionContextLike;
+  env?: Record<string, unknown>;
+}
+/**
+ * Structural view of the bits of an H3 event the resolver reads. Both legacy
+ * (`context.cloudflare`) and current (`req.runtime.cloudflare`) shapes are
+ * optional so a real H3 `H3Event` is assignable here.
+ */
+interface H3EventLike {
+  context?: {
+    cloudflare?: CloudflareEventBag;
+  };
+  req?: {
+    runtime?: {
+      cloudflare?: CloudflareEventBag;
+    };
+  };
+}
+/** Resolved Cloudflare runtime for one request: the bindings `env` and the optional `ExecutionContext`. */
+interface ResolvedCloudflare {
+  ctx?: ExecutionContextLike;
+  env?: Record<string, unknown>;
+}
+/**
+ * Pull the Cloudflare `env` + `ExecutionContext` off a Nitro/H3 event, checking
+ * the legacy `event.context.cloudflare` shape first (present under
+ * `nitro-cloudflare-dev` in dev) and the newer `event.req.runtime.cloudflare`
+ * shape second. Returns `{}` when neither is present.
+ */
+declare const resolveCloudflare: (event: H3EventLike) => ResolvedCloudflare;
+export { type H3EventLike, type ResolvedCloudflare, resolveCloudflare };

package/dist/runtime/cloudflare.d.ts

@@ -1,24 +1,56 @@
-import type { ExecutionContextLike } from "@lunora/runtime";
+/**
+ * Resolve the Cloudflare per-request `env` (bindings) and `ExecutionContext`
+ * from a Nitro/H3 event, tolerating the two shapes Nitro has shipped.
+ *
+ * Legacy `event.context.cloudflare.{ env, context }` — surfaced by
+ * `nitro-cloudflare-dev` in `nuxt dev` and by older `cloudflare_module` builds,
+ * where `context` is the `ExecutionContext` (`waitUntil` / `passThroughOnException`).
+ *
+ * Newer `event.req.runtime.cloudflare.{ env, ctx }` — the Nitro runtime accessor
+ * (Nitro v2.10+ / Nuxt 4), where the `ExecutionContext` is `ctx`.
+ *
+ * Both are read defensively so the delegating handler works across the version
+ * range a scaffolded app might pin, in both dev and the deployed worker. When
+ * neither is present (no Cloudflare runtime — e.g. a Node preview), `env` is
+ * `undefined` and the caller surfaces a clear error.
+ *
+ * Typed against a structural `H3EventLike` rather than `nitropack`'s `H3Event`
+ * so this seam stays pure (no Nitro types needed) and unit-testable with a plain
+ * object — a real `H3Event` is still assignable here.
+ */
+import { ExecutionContextLike } from '@lunora/runtime';
+export type { ExecutionContextLike } from '@lunora/runtime';
+/** The `{ env, context|ctx }` payload Nitro attaches for the Cloudflare runtime. */
 interface CloudflareEventBag {
-    context?: ExecutionContextLike;
-    ctx?: ExecutionContextLike;
-    env?: Record<string, unknown>;
+  context?: ExecutionContextLike;
+  ctx?: ExecutionContextLike;
+  env?: Record<string, unknown>;
 }
+/**
+ * Structural view of the bits of an H3 event the resolver reads. Both legacy
+ * (`context.cloudflare`) and current (`req.runtime.cloudflare`) shapes are
+ * optional so a real H3 `H3Event` is assignable here.
+ */
 interface H3EventLike {
-    context?: {
-        cloudflare?: CloudflareEventBag;
-    };
-    req?: {
-        runtime?: {
-            cloudflare?: CloudflareEventBag;
-        };
+  context?: {
+    cloudflare?: CloudflareEventBag;
+  };
+  req?: {
+    runtime?: {
+      cloudflare?: CloudflareEventBag;
     };
+  };
 }
+/** Resolved Cloudflare runtime for one request: the bindings `env` and the optional `ExecutionContext`. */
 interface ResolvedCloudflare {
-    ctx?: ExecutionContextLike;
-    env?: Record<string, unknown>;
+  ctx?: ExecutionContextLike;
+  env?: Record<string, unknown>;
 }
+/**
+ * Pull the Cloudflare `env` + `ExecutionContext` off a Nitro/H3 event, checking
+ * the legacy `event.context.cloudflare` shape first (present under
+ * `nitro-cloudflare-dev` in dev) and the newer `event.req.runtime.cloudflare`
+ * shape second. Returns `{}` when neither is present.
+ */
 declare const resolveCloudflare: (event: H3EventLike) => ResolvedCloudflare;
-export type { H3EventLike, ResolvedCloudflare };
-export { resolveCloudflare };
-export { type ExecutionContextLike } from "@lunora/runtime";
+export { type H3EventLike, type ResolvedCloudflare, resolveCloudflare };

package/dist/runtime/cloudflare.mjs

@@ -0,0 +1 @@
+const r=n=>{const e=n.context?.cloudflare;if(e?.env)return{ctx:e.context??e.ctx,env:e.env};const t=n.req?.runtime?.cloudflare;return t?.env?{ctx:t.ctx??t.context,env:t.env}:{}};export{r as resolveCloudflare};

package/dist/runtime/h3-request.d.mts

@@ -0,0 +1,18 @@
+/**
+ * Resolve the inbound web `Request` from an H3 event across the h3 v1 → v2 break.
+ *
+ * v1 exposes `toWebRequest(event)`; the v2 web-standards rewrite removed it and
+ * carries the web `Request` directly as `event.req`. The `@lunora/nuxt` peer is
+ * `h3: "^1.15.0"` (v1 — what Nuxt 4 / Nitro 2 run today); the v2 `event.req`
+ * branch is forward-compat for when a stable h3 v2 ships and the peer widens. We
+ * feature-detect `toWebRequest` at runtime rather than importing it statically —
+ * a named `import { toWebRequest }` would throw at module-eval under v2 (missing export).
+ *
+ * Kept as a pure helper (the `h3` namespace + event in, a `Request` out) so both
+ * branches are unit-tested without booting Nitro or installing a second h3 major.
+ */
+interface H3RequestNamespace {
+  toWebRequest?: unknown;
+}
+declare const resolveWebRequest: (h3: H3RequestNamespace, event: unknown) => Request;
+export { type H3RequestNamespace, resolveWebRequest };

package/dist/runtime/h3-request.d.ts

@@ -1,6 +1,18 @@
+/**
+ * Resolve the inbound web `Request` from an H3 event across the h3 v1 → v2 break.
+ *
+ * v1 exposes `toWebRequest(event)`; the v2 web-standards rewrite removed it and
+ * carries the web `Request` directly as `event.req`. The `@lunora/nuxt` peer is
+ * `h3: "^1.15.0"` (v1 — what Nuxt 4 / Nitro 2 run today); the v2 `event.req`
+ * branch is forward-compat for when a stable h3 v2 ships and the peer widens. We
+ * feature-detect `toWebRequest` at runtime rather than importing it statically —
+ * a named `import { toWebRequest }` would throw at module-eval under v2 (missing export).
+ *
+ * Kept as a pure helper (the `h3` namespace + event in, a `Request` out) so both
+ * branches are unit-tested without booting Nitro or installing a second h3 major.
+ */
 interface H3RequestNamespace {
-    toWebRequest?: unknown;
+  toWebRequest?: unknown;
 }
 declare const resolveWebRequest: (h3: H3RequestNamespace, event: unknown) => Request;
-export type { H3RequestNamespace };
-export { resolveWebRequest };
+export { type H3RequestNamespace, resolveWebRequest };

package/dist/runtime/h3-request.mjs

@@ -0,0 +1 @@
+const o=(e,t)=>typeof e.toWebRequest=="function"?e.toWebRequest(t):t.req;export{o as resolveWebRequest};

package/dist/runtime/handler.d.mts

@@ -0,0 +1,36 @@
+/**
+ * The Lunora ↔ Nitro delegation seam. Given a Lunora worker (the
+ * `defineApp().build()` app or a bare `createWorker(...)` result) and the
+ * Cloudflare runtime resolved off the request event, forward the inbound
+ * `Request` — RPC (`POST /_lunora/rpc`), WebSocket upgrade (`/_lunora/ws`), and
+ * the admin plane (`/_lunora/admin/*`) — straight to `worker.fetch`.
+ *
+ * This is the single-worker composition the void.cloud Nuxt approach uses,
+ * inverted: instead of Lunora owning the worker entry, Lunora is mounted
+ * inside* Nitro as a server route, and the `ShardDO` class is re-exported to
+ * the Cloudflare worker entrypoint via the project's root `worker.ts` wrapper.
+ *
+ * Kept framework-neutral (a `LunoraWorkerLike` + the resolved `env`/`ctx`, not
+ * an H3 event) so it can be unit-tested with a stub worker — no Nuxt or workerd
+ * boot required. The thin H3 adapter that reads `env`/`ctx` off the event and
+ * the raw `Request`/`Response` lives in the `[...].ts` route module.
+ */
+import { ExecutionContextLike } from '@lunora/runtime';
+export { NOOP_EXECUTION_CONTEXT } from '@lunora/runtime';
+/**
+ * Structural view of the Lunora worker the route delegates to — just the
+ * `fetch` entrypoint. Both `createWorker(...)` and the generated
+ * `defineApp().build()` app satisfy it (a `ComposedApp` is a superset). Declared
+ * locally so `@lunora/nuxt` doesn't hard-depend on `@lunora/runtime`'s worker type.
+ */
+interface LunoraWorkerLike {
+  fetch: (request: Request, env: unknown, context: ExecutionContextLike) => Promise<Response> | Response;
+}
+/**
+ * Forward one inbound request to the Lunora worker. `env` must be the Cloudflare
+ * bindings (carrying the `SHARD` Durable Object namespace); when it is missing
+ * the Cloudflare runtime wasn't available (e.g. a non-CF preview), so we answer
+ * a clear 500 rather than handing the worker an `undefined` env.
+ */
+declare const delegateToLunora: (worker: LunoraWorkerLike, request: Request, env: Record<string, unknown> | undefined, context?: ExecutionContextLike) => Promise<Response>;
+export { type LunoraWorkerLike, delegateToLunora };

package/dist/runtime/handler.d.ts

@@ -1,8 +1,36 @@
-import type { ExecutionContextLike } from "@lunora/runtime";
+/**
+ * The Lunora ↔ Nitro delegation seam. Given a Lunora worker (the
+ * `defineApp().build()` app or a bare `createWorker(...)` result) and the
+ * Cloudflare runtime resolved off the request event, forward the inbound
+ * `Request` — RPC (`POST /_lunora/rpc`), WebSocket upgrade (`/_lunora/ws`), and
+ * the admin plane (`/_lunora/admin/*`) — straight to `worker.fetch`.
+ *
+ * This is the single-worker composition the void.cloud Nuxt approach uses,
+ * inverted: instead of Lunora owning the worker entry, Lunora is mounted
+ * inside* Nitro as a server route, and the `ShardDO` class is re-exported to
+ * the Cloudflare worker entrypoint via the project's root `worker.ts` wrapper.
+ *
+ * Kept framework-neutral (a `LunoraWorkerLike` + the resolved `env`/`ctx`, not
+ * an H3 event) so it can be unit-tested with a stub worker — no Nuxt or workerd
+ * boot required. The thin H3 adapter that reads `env`/`ctx` off the event and
+ * the raw `Request`/`Response` lives in the `[...].ts` route module.
+ */
+import { ExecutionContextLike } from '@lunora/runtime';
+export { NOOP_EXECUTION_CONTEXT } from '@lunora/runtime';
+/**
+ * Structural view of the Lunora worker the route delegates to — just the
+ * `fetch` entrypoint. Both `createWorker(...)` and the generated
+ * `defineApp().build()` app satisfy it (a `ComposedApp` is a superset). Declared
+ * locally so `@lunora/nuxt` doesn't hard-depend on `@lunora/runtime`'s worker type.
+ */
 interface LunoraWorkerLike {
-    fetch: (request: Request, env: unknown, context: ExecutionContextLike) => Promise<Response> | Response;
+  fetch: (request: Request, env: unknown, context: ExecutionContextLike) => Promise<Response> | Response;
 }
+/**
+ * Forward one inbound request to the Lunora worker. `env` must be the Cloudflare
+ * bindings (carrying the `SHARD` Durable Object namespace); when it is missing
+ * the Cloudflare runtime wasn't available (e.g. a non-CF preview), so we answer
+ * a clear 500 rather than handing the worker an `undefined` env.
+ */
 declare const delegateToLunora: (worker: LunoraWorkerLike, request: Request, env: Record<string, unknown> | undefined, context?: ExecutionContextLike) => Promise<Response>;
-export type { LunoraWorkerLike };
-export { delegateToLunora };
-export { NOOP_EXECUTION_CONTEXT } from "@lunora/runtime";
+export { type LunoraWorkerLike, delegateToLunora };

package/dist/runtime/handler.mjs

@@ -0,0 +1 @@
+import{NOOP_EXECUTION_CONTEXT as n}from"@lunora/runtime";import{NOOP_EXECUTION_CONTEXT as l}from"@lunora/runtime";const s=async(o,r,e,t)=>e?o.fetch(r,e,t??n):Response.json({error:{code:"LUNORA_RUNTIME_UNAVAILABLE",message:"Lunora could not read the Cloudflare bindings from the request. The `/_lunora/**` route only works on the Cloudflare Workers runtime (deployed, or `nuxt dev` with `nitro-cloudflare-dev`)."}},{status:500});export{l as NOOP_EXECUTION_CONTEXT,s as delegateToLunora};

package/dist/runtime/server/lunora.d.mts

@@ -0,0 +1,113 @@
+/**
+ * Nitro server handler mounted at `/_lunora/**` by the `@lunora/nuxt` module
+ * (`addServerHandler`). It is the single-worker seam: every Lunora RPC,
+ * WebSocket upgrade, and admin request is forwarded to the project's Lunora
+ * worker, which runs *inside* the same Nitro/Cloudflare worker the rest of the
+ * Nuxt app deploys as.
+ *
+ * The worker instance is the project's composed app, imported through the
+ * `#lunora/app` virtual the module registers (it points at the app entry — by
+ * default `~/lunora/server`, where `defineApp().build()` lives and re-exports
+ * `ShardDO`). The same `ShardDO` is re-exported to the Cloudflare worker
+ * entrypoint via the project's root `worker.ts` wrapper (`wrangler.jsonc`'s
+ * `main`), so one deploy carries both the SSR handler and the Durable Object class.
+ *
+ * This file is only ever bundled by Nitro; `h3`'s `defineEventHandler` is its
+ * sole framework entry. We use a namespace import so the seam spans the h3
+ * v1 → v2 break: v1 exposes `toWebRequest(event)`, while the v2 web-standards
+ * rewrite removed it and carries the web `Request` directly as `event.req`. A
+ * static `import { toWebRequest }` would throw at module-eval under v2 (missing
+ * named export), so `resolveWebRequest` feature-detects it at runtime instead.
+ */
+import { QueryObject } from 'ufo';
+import { Hooks } from 'crossws';
+import { IncomingMessage, ServerResponse } from 'node:http';
+interface NodeEventContext {
+  req: IncomingMessage & {
+    originalUrl?: string;
+  };
+  res: ServerResponse;
+}
+interface WebEventContext {
+  request?: Request;
+  url?: URL;
+}
+declare class H3Event<_RequestT extends EventHandlerRequest = EventHandlerRequest> implements Pick<FetchEvent, "respondWith"> {
+  "__is_event__": boolean;
+  node: NodeEventContext;
+  web?: WebEventContext;
+  context: H3EventContext;
+  _method?: HTTPMethod;
+  _path?: string;
+  _headers?: Headers;
+  _requestBody?: BodyInit;
+  _handled: boolean;
+  _onBeforeResponseCalled: boolean | undefined;
+  _onAfterResponseCalled: boolean | undefined;
+  constructor(req: IncomingMessage, res: ServerResponse);
+  get method(): HTTPMethod;
+  get path(): string;
+  get headers(): Headers;
+  get handled(): boolean;
+  respondWith(response: Response | PromiseLike<Response>): Promise<void>;
+  toString(): string;
+  toJSON(): string;
+  /** @deprecated Please use `event.node.req` instead. */
+  get req(): IncomingMessage & {
+    originalUrl?: string;
+  };
+  /** @deprecated Please use `event.node.res` instead. */
+  get res(): ServerResponse<IncomingMessage>;
+}
+type SessionDataT = Record<string, any>;
+type SessionData<T extends SessionDataT = SessionDataT> = T;
+declare const getSessionPromise: unique symbol;
+interface Session<T extends SessionDataT = SessionDataT> {
+  id: string;
+  createdAt: number;
+  data: SessionData<T>;
+  [getSessionPromise]?: Promise<Session<T>>;
+}
+type RouterMethod = Lowercase<HTTPMethod>;
+interface RouteNode {
+  handlers: Partial<Record<RouterMethod | "all", EventHandler>>;
+  path: string;
+}
+type HTTPMethod = "GET" | "HEAD" | "PATCH" | "POST" | "PUT" | "DELETE" | "CONNECT" | "OPTIONS" | "TRACE";
+interface H3EventContext extends Record<string, any> {
+  params?: Record<string, string>;
+  /**
+   * Matched router Node
+   *
+   * @experimental The object structure may change in non-major version.
+   */
+  matchedRoute?: RouteNode;
+  sessions?: Record<string, Session>;
+  clientAddress?: string;
+}
+type EventHandlerResponse<T = any> = T | Promise<T>;
+interface EventHandlerRequest {
+  body?: any;
+  query?: QueryObject;
+  routerParams?: Record<string, string>;
+}
+type MaybePromise<T> = T | Promise<T>;
+type EventHandlerResolver = (path: string) => MaybePromise<undefined | {
+  route?: string;
+  handler: EventHandler;
+}>;
+interface EventHandler<Request extends EventHandlerRequest = EventHandlerRequest, Response extends EventHandlerResponse = EventHandlerResponse> {
+  __is_handler__?: true;
+  __resolve__?: EventHandlerResolver;
+  __websocket__?: Partial<Hooks>;
+  (event: H3Event<Request>): Response;
+}
+/**
+ * Forward `/_lunora/**` to the Lunora worker. We reconstruct a Web `Request`
+ * from the H3 event (Lunora speaks the Web Fetch contract — RPC bodies and the
+ * WebSocket `Upgrade` handshake), resolve the Cloudflare `env`/`ExecutionContext`
+ * off the event, and return the worker's `Response` verbatim (H3 streams it,
+ * including a `101 Switching Protocols` upgrade with its `webSocket`).
+ */
+declare const lunoraEventHandler: EventHandler;
+export { lunoraEventHandler as default };

package/dist/runtime/server/lunora.d.ts

@@ -1,3 +1,113 @@
-import * as h3 from "h3";
-declare const _default: h3.EventHandler<h3.EventHandlerRequest, Promise<Response>>;
-export default _default;
+/**
+ * Nitro server handler mounted at `/_lunora/**` by the `@lunora/nuxt` module
+ * (`addServerHandler`). It is the single-worker seam: every Lunora RPC,
+ * WebSocket upgrade, and admin request is forwarded to the project's Lunora
+ * worker, which runs *inside* the same Nitro/Cloudflare worker the rest of the
+ * Nuxt app deploys as.
+ *
+ * The worker instance is the project's composed app, imported through the
+ * `#lunora/app` virtual the module registers (it points at the app entry — by
+ * default `~/lunora/server`, where `defineApp().build()` lives and re-exports
+ * `ShardDO`). The same `ShardDO` is re-exported to the Cloudflare worker
+ * entrypoint via the project's root `worker.ts` wrapper (`wrangler.jsonc`'s
+ * `main`), so one deploy carries both the SSR handler and the Durable Object class.
+ *
+ * This file is only ever bundled by Nitro; `h3`'s `defineEventHandler` is its
+ * sole framework entry. We use a namespace import so the seam spans the h3
+ * v1 → v2 break: v1 exposes `toWebRequest(event)`, while the v2 web-standards
+ * rewrite removed it and carries the web `Request` directly as `event.req`. A
+ * static `import { toWebRequest }` would throw at module-eval under v2 (missing
+ * named export), so `resolveWebRequest` feature-detects it at runtime instead.
+ */
+import { QueryObject } from 'ufo';
+import { Hooks } from 'crossws';
+import { IncomingMessage, ServerResponse } from 'node:http';
+interface NodeEventContext {
+  req: IncomingMessage & {
+    originalUrl?: string;
+  };
+  res: ServerResponse;
+}
+interface WebEventContext {
+  request?: Request;
+  url?: URL;
+}
+declare class H3Event<_RequestT extends EventHandlerRequest = EventHandlerRequest> implements Pick<FetchEvent, "respondWith"> {
+  "__is_event__": boolean;
+  node: NodeEventContext;
+  web?: WebEventContext;
+  context: H3EventContext;
+  _method?: HTTPMethod;
+  _path?: string;
+  _headers?: Headers;
+  _requestBody?: BodyInit;
+  _handled: boolean;
+  _onBeforeResponseCalled: boolean | undefined;
+  _onAfterResponseCalled: boolean | undefined;
+  constructor(req: IncomingMessage, res: ServerResponse);
+  get method(): HTTPMethod;
+  get path(): string;
+  get headers(): Headers;
+  get handled(): boolean;
+  respondWith(response: Response | PromiseLike<Response>): Promise<void>;
+  toString(): string;
+  toJSON(): string;
+  /** @deprecated Please use `event.node.req` instead. */
+  get req(): IncomingMessage & {
+    originalUrl?: string;
+  };
+  /** @deprecated Please use `event.node.res` instead. */
+  get res(): ServerResponse<IncomingMessage>;
+}
+type SessionDataT = Record<string, any>;
+type SessionData<T extends SessionDataT = SessionDataT> = T;
+declare const getSessionPromise: unique symbol;
+interface Session<T extends SessionDataT = SessionDataT> {
+  id: string;
+  createdAt: number;
+  data: SessionData<T>;
+  [getSessionPromise]?: Promise<Session<T>>;
+}
+type RouterMethod = Lowercase<HTTPMethod>;
+interface RouteNode {
+  handlers: Partial<Record<RouterMethod | "all", EventHandler>>;
+  path: string;
+}
+type HTTPMethod = "GET" | "HEAD" | "PATCH" | "POST" | "PUT" | "DELETE" | "CONNECT" | "OPTIONS" | "TRACE";
+interface H3EventContext extends Record<string, any> {
+  params?: Record<string, string>;
+  /**
+   * Matched router Node
+   *
+   * @experimental The object structure may change in non-major version.
+   */
+  matchedRoute?: RouteNode;
+  sessions?: Record<string, Session>;
+  clientAddress?: string;
+}
+type EventHandlerResponse<T = any> = T | Promise<T>;
+interface EventHandlerRequest {
+  body?: any;
+  query?: QueryObject;
+  routerParams?: Record<string, string>;
+}
+type MaybePromise<T> = T | Promise<T>;
+type EventHandlerResolver = (path: string) => MaybePromise<undefined | {
+  route?: string;
+  handler: EventHandler;
+}>;
+interface EventHandler<Request extends EventHandlerRequest = EventHandlerRequest, Response extends EventHandlerResponse = EventHandlerResponse> {
+  __is_handler__?: true;
+  __resolve__?: EventHandlerResolver;
+  __websocket__?: Partial<Hooks>;
+  (event: H3Event<Request>): Response;
+}
+/**
+ * Forward `/_lunora/**` to the Lunora worker. We reconstruct a Web `Request`
+ * from the H3 event (Lunora speaks the Web Fetch contract — RPC bodies and the
+ * WebSocket `Upgrade` handshake), resolve the Cloudflare `env`/`ExecutionContext`
+ * off the event, and return the worker's `Response` verbatim (H3 streams it,
+ * including a `101 Switching Protocols` upgrade with its `webSocket`).
+ */
+declare const lunoraEventHandler: EventHandler;
+export { lunoraEventHandler as default };

package/dist/runtime/server/lunora.mjs

@@ -0,0 +1 @@
+import*as e from"h3";import a from"#lunora/app";import{resolveCloudflare as l}from"../cloudflare.mjs";import{resolveWebRequest as m}from"../h3-request.mjs";import{delegateToLunora as s}from"../handler.mjs";const i=e.defineEventHandler(async r=>{const{ctx:o,env:t}=l(r),n=m(e,r);return s(a,n,t,o)});export{i as default};

package/dist/server.d.mts

@@ -1 +1 @@
-export { ArgsOf, AuthLike, FunctionReference, HeadersSource, Preloaded, ReturnOf, ServerClientOptions, ServerSession, createServerClient, deserializePreloaded, getServerSession, preloadQuery, preloadedQueryResult, serializePreloaded } from '@lunora/client/ssr';
+export { type ArgsOf, type AuthLike, type FunctionReference, type HeadersSource, type Preloaded, type ReturnOf, type ServerClientOptions, type ServerSession, createServerClient, deserializePreloaded, getServerSession, preloadQuery, preloadedQueryResult, serializePreloaded } from '@lunora/client/ssr';

package/dist/server.d.ts

@@ -0,0 +1 @@
+export { type ArgsOf, type AuthLike, type FunctionReference, type HeadersSource, type Preloaded, type ReturnOf, type ServerClientOptions, type ServerSession, createServerClient, deserializePreloaded, getServerSession, preloadQuery, preloadedQueryResult, serializePreloaded } from '@lunora/client/ssr';

package/dist/server.mjs

@@ -1 +1 @@
-export { createServerClient, deserializePreloaded, getServerSession, preloadQuery, preloadedQueryResult, serializePreloaded } from '@lunora/client/ssr';
+import{createServerClient as d,deserializePreloaded as l,getServerSession as a,preloadQuery as o,preloadedQueryResult as i,serializePreloaded as s}from"@lunora/client/ssr";export{d as createServerClient,l as deserializePreloaded,a as getServerSession,o as preloadQuery,i as preloadedQueryResult,s as serializePreloaded};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/nuxt",
-  "version": "1.0.0-alpha.29",
+  "version": "1.0.0-alpha.290",
   "description": "Nuxt module for Lunora — single-worker composition (mounts /_lunora/* into Nitro) plus reactive-loader server helpers",
   "keywords": [
     "cloudflare",
@@ -35,14 +35,14 @@
   "sideEffects": false,
   "main": "./dist/module.mjs",
   "module": "./dist/module.mjs",
-  "types": "./dist/types.d.mts",
+  "types": "./dist/module.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/types.d.mts",
+      "types": "./dist/module.d.ts",
       "import": "./dist/module.mjs"
     },
     "./server": {
-      "types": "./dist/server.d.mts",
+      "types": "./dist/server.d.ts",
       "import": "./dist/server.mjs"
     },
     "./package.json": "./package.json"
@@ -51,13 +51,13 @@
     "access": "public"
   },
   "dependencies": {
-    "@lunora/client": "1.0.0-alpha.21",
-    "@lunora/runtime": "1.0.0-alpha.26",
-    "@nuxt/kit": "^4.4.8"
+    "@lunora/client": "1.0.0-alpha.273",
+    "@lunora/runtime": "1.0.0-alpha.263",
+    "@nuxt/kit": "^4.5.2"
   },
   "peerDependencies": {
     "h3": "^1.15.0",
-    "nuxt": "^4.0.0"
+    "nuxt": "^4.0.3"
   },
   "peerDependenciesMeta": {
     "h3": {

package/dist/runtime/cloudflare.js

@@ -1,12 +0,0 @@
-const resolveCloudflare = (event) => {
-  const fromContext = event.context?.cloudflare;
-  if (fromContext?.env) {
-    return { ctx: fromContext.context ?? fromContext.ctx, env: fromContext.env };
-  }
-  const fromRuntime = event.req?.runtime?.cloudflare;
-  if (fromRuntime?.env) {
-    return { ctx: fromRuntime.ctx ?? fromRuntime.context, env: fromRuntime.env };
-  }
-  return {};
-};
-export { resolveCloudflare };

package/dist/runtime/h3-request.js

@@ -1,2 +0,0 @@
-const resolveWebRequest = (h3, event) => typeof h3.toWebRequest === "function" ? h3.toWebRequest(event) : event.req;
-export { resolveWebRequest };

package/dist/runtime/handler.js

@@ -1,17 +0,0 @@
-import { NOOP_EXECUTION_CONTEXT } from "@lunora/runtime";
-const delegateToLunora = async (worker, request, env, context) => {
-  if (!env) {
-    return Response.json(
-      {
-        error: {
-          code: "LUNORA_RUNTIME_UNAVAILABLE",
-          message: "Lunora could not read the Cloudflare bindings from the request. The `/_lunora/**` route only works on the Cloudflare Workers runtime (deployed, or `nuxt dev` with `nitro-cloudflare-dev`)."
-        }
-      },
-      { status: 500 }
-    );
-  }
-  return worker.fetch(request, env, context ?? NOOP_EXECUTION_CONTEXT);
-};
-export { delegateToLunora };
-export { NOOP_EXECUTION_CONTEXT } from "@lunora/runtime";

package/dist/runtime/server/lunora.js

@@ -1,10 +0,0 @@
-import * as h3 from "h3";
-import lunoraApp from "#lunora/app";
-import { resolveCloudflare } from "../cloudflare.js";
-import { resolveWebRequest } from "../h3-request.js";
-import { delegateToLunora } from "../handler.js";
-export default h3.defineEventHandler(async (event) => {
-  const { ctx, env } = resolveCloudflare(event);
-  const request = resolveWebRequest(h3, event);
-  return delegateToLunora(lunoraApp, request, env, ctx);
-});

package/dist/types.d.mts

@@ -1,7 +0,0 @@
-import type { NuxtModule } from '@nuxt/schema'
-
-import type { default as Module } from './module.mjs'
-
-export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
-
-export { default } from './module.mjs'