@lunora/nuxt 1.0.0-alpha.14 → 1.0.0-alpha.140

package/LICENSE.md

@@ -103,3 +103,9 @@ Unless required by applicable law or agreed to in writing, software distributed
 under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 CONDITIONS OF ANY KIND, either express or implied. See the License for the
 specific language governing permissions and limitations under the License.
+
+<!-- DEPENDENCIES -->
+<!-- /DEPENDENCIES -->
+
+<!-- TYPE_DEPENDENCIES -->
+<!-- /TYPE_DEPENDENCIES -->

package/README.md

@@ -59,37 +59,47 @@ export default defineNuxtConfig({
 });
 ```
 
-Add `exports.cloudflare.ts` to the project root so the `ShardDO` Durable Object
-class is exported from the emitted worker entry:
+Add a `worker.ts` wrapper at the project root and point `wrangler.jsonc`'s `main`
+at it, so the `ShardDO` Durable Object class is exported from the deployed worker.
+Nitro's `cloudflare_module` output exports only the SSR handler, so `main` must
+point at the wrapper — not the raw `.output/server/index.mjs` — or `wrangler deploy`
+fails on the missing DO class:
 
 ```ts
-// exports.cloudflare.ts
+// worker.ts
+export { default } from "./.output/server/index.mjs";
 export { ShardDO } from "./lunora/server";
 ```
 
+```jsonc
+// wrangler.jsonc
+{ "main": "worker.ts" }
+```
+
 `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.
 - **`#lunora/app` alias**: points the route's worker import at your app entry,
   forwarded into the Nitro server bundle via `nuxt.options.alias`.
-- **`ShardDO`** rides to the worker entry through your root `exports.cloudflare.ts`
-  (the `cloudflare_module` preset appends its exports).
+- **`ShardDO`** rides to the deployed worker through your root `worker.ts` wrapper
+  (`wrangler.jsonc`'s `main`), which re-exports Nitro's SSR handler and `ShardDO`.
 
 ## Verify before deploy
 
@@ -102,11 +112,12 @@ Single-worker composition rides on two Nitro behaviours that vary across version
    subscriptions never connect while RPC does, Nitro is normalising the upgrade
    response and `/_lunora/ws` needs a deploy-boundary handoff instead of the H3
    route return.
-2. **`exports.cloudflare.ts` hook.** The `cloudflare_module` preset must append
-   this file's exports onto the worker entry. If `wrangler deploy` fails with
-   "ShardDO class not exported", your Nitro version may use a different hook
-   (`nitro.cloudflare.additionalModules`, or a `rollupConfig` output export). The
-   module `warn()`s when the file is missing but can't verify the hook fires.
+2. **`worker.ts` wrapper.** `wrangler.jsonc`'s `main` must point at a root
+   `worker.ts` that re-exports Nitro's SSR handler _and_ `ShardDO` — Nitro's
+   `cloudflare_module` output exports only the SSR handler. If `wrangler deploy`
+   fails with "ShardDO class not exported", check that `main` points at the
+   wrapper and that it re-exports `ShardDO`. The module `warn()`s when
+   `worker.ts` is missing but can't verify wrangler's `main` points at it.
 
 ## Server data-loading
 

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.13",
-  "builder": {
-    "@nuxt/module-builder": "1.0.2",
-    "unbuild": "unknown"
-  }
-}
+  "version": "1.0.0-alpha.139"
+}

package/dist/module.mjs

@@ -1,29 +1 @@
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { defineNuxtModule, createResolver, addServerHandler, useLogger } from '@nuxt/kit';
-
-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"] = options.appEntry;
-    addServerHandler({
-      handler: resolver.resolve("./runtime/server/lunora"),
-      route: `${options.prefix}/**`
-    });
-    if (!existsSync(join(nuxt.options.rootDir, "exports.cloudflare.ts"))) {
-      useLogger("@lunora/nuxt").warn(
-        'missing exports.cloudflare.ts at the project root \u2014 add `export { ShardDO } from "./lunora/server";` so the SHARD Durable Object is exported from the 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,36 @@
+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,36 @@
-import type { ExecutionContextLike } from "../../../../shared/execution-context.js";
+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 "../../../../shared/execution-context.js";
+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,19 @@
+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,19 @@
-import type { ExecutionContextLike } from "../../../../shared/execution-context.js";
+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 "../../../../shared/execution-context.js";
+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,92 @@
+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,92 @@
-import * as h3 from "h3";
-declare const _default: h3.EventHandler<h3.EventHandlerRequest, Promise<Response>>;
-export default _default;
+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.14",
+  "version": "1.0.0-alpha.140",
   "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,12 +51,13 @@
     "access": "public"
   },
   "dependencies": {
-    "@lunora/client": "1.0.0-alpha.12",
-    "@nuxt/kit": "^4.4.8"
+    "@lunora/client": "1.0.0-alpha.114",
+    "@lunora/runtime": "1.0.0-alpha.128",
+    "@nuxt/kit": "^4.5.2"
   },
   "peerDependencies": {
-    "h3": "^1.0.0 || ^2.0.0",
-    "nuxt": "^4.0.0"
+    "h3": "^1.15.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 "../../../../shared/execution-context";
-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 "../../../../shared/execution-context";

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'