@lunora/nuxt 1.0.0-alpha.9 → 1.0.0-alpha.90

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,14 +59,23 @@ 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`
@@ -88,8 +97,8 @@ option, default `~/lunora/server`) and serves it at the `/_lunora/**` route
   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 +111,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.ts

@@ -0,0 +1,36 @@
+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;
+/** 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;
+  /** URL prefix Lunora realtime is mounted at. */
+  prefix: 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, checkWorkerEntry, lunoraNuxtModule as default };

package/dist/module.js

@@ -0,0 +1 @@
+import{existsSync as i,readFileSync as u}from"node:fs";import{join as s,resolve as d,dirname as p}from"node:path";import{defineNuxtModule as h,createResolver as c,addServerHandler as f,useLogger as m}from"@nuxt/kit";const S=(r,t,o)=>r.startsWith("~~/")?s(t,r.slice(3)):r.startsWith("~/")?s(o,r.slice(2)):r.startsWith("./")||r.startsWith("../")?s(t,r):r,v=/\.js$/,D=r=>{const t=s(r,"lunora");return{name:"lunora:nitro-ts-source-resolve",resolveId:{handler(o,e){if(!o.endsWith(".js"))return;let n;if(o.startsWith("#lunora/")?n=s(t,o.slice(8)):o.startsWith(".")&&e!==void 0&&(n=d(p(e),o)),n===void 0)return;const a=n.replace(v,".ts");return i(a)?a:void 0},order:"pre"}}},l='export { default } from "./.output/server/index.mjs"; export { ShardDO } from "./lunora/server";',E=/\bexport\b/u,R=/\bShardDO\b/u,g=/\bexport\s*\*\s*from\s*["'][^"']*lunora[^"']*["']/u,x=r=>E.test(r)?R.test(r)||g.test(r):!1,O=(r,t)=>{const o=s(r,"worker.ts");if(!i(o)){t(`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 e;try{e=u(o,"utf8")}catch(n){const a=n instanceof Error?n.message:String(n);t(`could not read worker.ts at the project root (${a}) — skipping the \`ShardDO\` export check.`);return}x(e)||t(`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.`)},N=h({defaults:{appEntry:"~/lunora/server",prefix:"/_lunora"},meta:{configKey:"lunora",name:"@lunora/nuxt"},setup(r,t){const o=c(import.meta.url);t.options.alias["#lunora/app"]=S(r.appEntry,t.options.rootDir,t.options.srcDir),t.hook("nitro:config",e=>{const n=[...e.rollupConfig?.plugins??[],D(t.options.rootDir)];e.rollupConfig={...e.rollupConfig,plugins:n}}),f({handler:o.resolve("./runtime/server/lunora"),route:`${r.prefix}/**`}),O(t.options.rootDir,e=>{m("@lunora/nuxt").warn(e)})}});export{O as checkWorkerEntry,N as default};

package/dist/module.json

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

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.js

@@ -1,12 +1 @@
-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 };
+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.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.js

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

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.js

@@ -1,17 +1 @@
-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";
+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.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.js

@@ -1,10 +1 @@
-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);
-});
+import*as e from"h3";import a from"#lunora/app";import{resolveCloudflare as l}from"../cloudflare.js";import{resolveWebRequest as m}from"../h3-request.js";import{delegateToLunora as s}from"../handler.js";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.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.js

@@ -0,0 +1 @@
+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.9",
+  "version": "1.0.0-alpha.90",
   "description": "Nuxt module for Lunora — single-worker composition (mounts /_lunora/* into Nitro) plus reactive-loader server helpers",
   "keywords": [
     "cloudflare",
@@ -33,17 +33,17 @@
   ],
   "type": "module",
   "sideEffects": false,
-  "main": "./dist/module.mjs",
-  "module": "./dist/module.mjs",
-  "types": "./dist/types.d.mts",
+  "main": "./dist/module.js",
+  "module": "./dist/module.js",
+  "types": "./dist/module.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/types.d.mts",
-      "import": "./dist/module.mjs"
+      "types": "./dist/module.d.ts",
+      "import": "./dist/module.js"
     },
     "./server": {
-      "types": "./dist/server.d.mts",
-      "import": "./dist/server.mjs"
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
     },
     "./package.json": "./package.json"
   },
@@ -51,12 +51,13 @@
     "access": "public"
   },
   "dependencies": {
-    "@lunora/client": "1.0.0-alpha.7",
-    "@nuxt/kit": "^4.4.8"
+    "@lunora/client": "1.0.0-alpha.60",
+    "@lunora/runtime": "1.0.0-alpha.77",
+    "@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/module.d.mts

@@ -1,9 +0,0 @@
-import * as nuxt_schema from 'nuxt/schema';
-
-interface ModuleOptions {
-    appEntry: string;
-    prefix: string;
-}
-declare const _default: nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
-
-export { _default as default };

package/dist/module.mjs

@@ -1,29 +0,0 @@
-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 };

package/dist/server.d.mts

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

package/dist/server.mjs

@@ -1 +0,0 @@
-export { createServerClient, deserializePreloaded, getServerSession, preloadQuery, preloadedQueryResult, serializePreloaded } from '@lunora/client/ssr';

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'