@lunora/astro 1.0.0-alpha.15 → 1.0.0-alpha.150

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

@@ -70,7 +70,7 @@ export default defineConfig({
 ```
 
 ```ts
-// src/worker.ts — the composed worker's `export default`.
+// src/server.ts — the composed worker's `export default`.
 import { handle } from "@astrojs/cloudflare/handler";
 import { withLunora } from "@lunora/astro";
 
@@ -81,7 +81,7 @@ export default withLunora(
 );
 ```
 
-Set `"main": "src/worker.ts"` in `wrangler.jsonc` so wrangler bundles this entry. `withLunora` reserves `/_lunora/rpc`, `/_lunora/ws`, and `/_lunora/admin/*` for the realtime plane; every other request falls through to Astro's SSR handler. An Astro render that throws is contained at the seam as a plain 500 — it can't take down realtime.
+Set `"main": "src/server.ts"` in `wrangler.jsonc` so wrangler bundles this entry. `withLunora` reserves `/_lunora/rpc`, `/_lunora/ws`, and `/_lunora/admin/*` for the realtime plane; every other request falls through to Astro's SSR handler. An Astro render that throws is contained at the seam as a plain 500 — it can't take down realtime.
 
 Reactivity comes from the island adapter you hydrate with, not from this package. Preload a query in `.astro` frontmatter or a server endpoint with `@lunora/astro/server`, then hand the token to that adapter's `hydratePreloaded`:
 
@@ -91,11 +91,22 @@ Reactivity comes from the island adapter you hydrate with, not from this package
 import { createServerClient, preloadQuery, serializePreloaded } from "@lunora/astro/server";
 import { api } from "../lunora/_generated/api";
 
-const client = createServerClient({ url: Astro.url.origin + "/_lunora/rpc" });
+const client = createServerClient({ url: Astro.url.origin });
 const preloaded = await preloadQuery(client, api.messages.list, {});
 ---
 
-<my-island data-preloaded={serializePreloaded(preloaded)}></my-island>
+<script id="preloaded" type="application/json" set:html={serializePreloaded(preloaded)}></script>
+<my-island></my-island>
+```
+
+The island has to pick the token up explicitly — no adapter discovers `#preloaded` on its own:
+
+```ts
+import { hydratePreloaded } from "@lunora/react";
+import { deserializePreloaded } from "@lunora/astro/server";
+
+const preloaded = deserializePreloaded(document.querySelector("#preloaded")!.textContent!);
+const initial = hydratePreloaded(preloaded); // seeds the first paint, then goes live
 ```
 
 ### Feature flags
@@ -108,7 +119,7 @@ const preloaded = await preloadQuery(client, api.messages.list, {});
 import { createServerClient, preloadQuery, preloadedQueryResult } from "@lunora/astro/server";
 import { api } from "../lunora/_generated/api";
 
-const client = createServerClient({ url: Astro.url.origin + "/_lunora/rpc" });
+const client = createServerClient({ url: Astro.url.origin });
 const preloaded = await preloadQuery(client, api.homepage.heroFlag, {}); // a query that returns ctx.flags.boolean(...)
 const newHero = preloadedQueryResult(preloaded);
 ---

package/dist/index.d.mts

@@ -1,27 +1,12 @@
 export { type FrameworkHostHandler as AstroWorkerHandler, type LunoraWorker as ComposedWorker, type FrameworkWorkerOptions as LunoraOptions, withFrameworkWorker as withLunora } from '@lunora/runtime';
 /**
-* The Lunora Astro **integration** — an `AstroIntegration` object
-* (`{ name, hooks }`) added to `astro.config.*`'s `integrations` array.
-*
-* Astro is multi-framework at the UI layer, so this integration is **not** a new
-* reactive runtime. Its job is the *composition* seam (PLAN4 class-B): make the
-* Worker `@astrojs/cloudflare` emits mount Lunora realtime under `/_lunora/*`
-* via `withLunora`, and surface the framework-neutral server helpers
-* (`@lunora/astro/server`) to Astro server endpoints / `.astro` frontmatter.
-*
-* Reactivity itself comes from whichever island adapter the app hydrates with —
-* `@lunora/react`, `@lunora/solid`, `@lunora/svelte`, or `@lunora/vue` — each of
-* which ships its own `hydratePreloaded(preloaded)` for the SSR-seed → live
-* handoff. This package owns the server/composition half only.
-*/
-/**
-* Structural subset of Astro's `AstroIntegration`. Declared locally (rather than
-* importing `astro`'s type) so `@lunora/astro`'s public surface stays decoupled
-* from a specific Astro major and type-checks even when `astro` is not installed
-* — `astro` is an *optional* peer here (only the host Astro app pulls it in).
-* The shape is assignable to/from Astro's real `AstroIntegration`, so adding the
-* returned object to `integrations` type-checks in a real Astro project.
-*/
+ * Structural subset of Astro's `AstroIntegration`. Declared locally (rather than
+ * importing `astro`'s type) so `@lunora/astro`'s public surface stays decoupled
+ * from a specific Astro major and type-checks even when `astro` is not installed
+ * — `astro` is an *optional* peer here (only the host Astro app pulls it in).
+ * The shape is assignable to/from Astro's real `AstroIntegration`, so adding the
+ * returned object to `integrations` type-checks in a real Astro project.
+ */
 interface AstroIntegrationLike {
   readonly hooks: {
     readonly [hook: string]: ((...arguments_: never[]) => unknown) | undefined;
@@ -31,41 +16,95 @@ interface AstroIntegrationLike {
 /** Options for the `lunora` integration. */
 interface LunoraIntegrationOptions {
   /**
-  * Path (or specifier) of the module that calls `withLunora` and is the
-  * composed worker's `export default`. Documented for the wiring story; when
-  * omitted the integration assumes the conventional `src/worker.ts`.
-  */
+   * Path (or specifier) of the module that composes the Lunora plane with the
+   * Astro handler and is the composed worker's `export default`. Documented for
+   * the wiring story; when omitted the integration assumes the conventional
+   * `src/server.ts` — deliberately NOT `src/worker.ts`, which `lunora deploy`
+   * treats as a SvelteKit-shaped entry to pass to wrangler positionally, and
+   * which the `@astrojs/cloudflare` redirect's `no_bundle: true` then uploads
+   * untranspiled.
+   */
   readonly serverEntry?: string;
 }
 /**
-* The Lunora Astro integration. Add it to `astro.config.*`:
-*
-* ```ts
-* import cloudflare from "@astrojs/cloudflare";
-* import { defineConfig } from "astro/config";
-* import { lunora } from "@lunora/astro";
-*
-* export default defineConfig({
-*   output: "server",
-*   adapter: cloudflare(),
-*   integrations: [lunora()],
-* });
-* ```
-*
-* What it does:
-*
-* - Marks the build so the `@astrojs/cloudflare` server entry is wrapped with
-*   `withLunora` — the composed worker reserves `/_lunora/*` for Lunora realtime
-*   and forwards everything else to Astro's SSR handler (one worker, one deploy).
-* - Documents the `serverEntry` (default `src/worker.ts`) where the
-*   `withLunora(astroWorker, { shardDO: env.SHARD, … })` composition lives.
-*
-* The hook is intentionally minimal here: the load-bearing composition is the
-* `withLunora` wrapper at the server-entry boundary (see `withLunora` for the
-* `@astrojs/cloudflare` injection point). The integration object exists so the
-* wiring is declared in `astro.config` the idiomatic Astro way, and so future
-* build-time hooks (binding reconcile, dev middleware) have a home without
-* changing the public surface.
-*/
+ * The Lunora Astro integration. Add it to `astro.config.*`:
+ *
+ * ```ts
+ * import cloudflare from "@astrojs/cloudflare";
+ * import { defineConfig } from "astro/config";
+ * import { lunora } from "@lunora/astro";
+ *
+ * export default defineConfig({
+ *   output: "server",
+ *   adapter: cloudflare(),
+ *   integrations: [lunora()],
+ * });
+ * ```
+ *
+ * What it does:
+ *
+ * - Documents the `serverEntry` (default `src/server.ts`) where the
+ *   `withLunora(astroWorker, { shardDO: env.SHARD, … })` composition — or the
+ *   generated builder's `.buildFrameworkWorker(host)` — lives.
+ * - Checks, at `astro:config:done`, that `serverEntry` exists and contains an
+ *   actual composition CALL (not merely an import of it) — and warns
+ *   (does not fail the build) when it doesn't, so a missing wrapper is caught
+ *   at build time instead of shipping a worker where `/_lunora/*` is unrouted
+ *   and realtime silently 404s.
+ *
+ * This integration does NOT wrap the server entry itself — no file is written
+ * or modified. The load-bearing composition is the `withLunora` call the
+ * project author writes at the server-entry boundary (see `withLunora` for the
+ * `@astrojs/cloudflare` injection point); this object exists so the wiring is
+ * declared in `astro.config` the idiomatic Astro way, checked once at build
+ * time, and has a home for future build-time hooks (binding reconcile, dev
+ * middleware) without changing the public surface.
+ */
 declare const lunora: (options?: LunoraIntegrationOptions) => AstroIntegrationLike;
-export { type AstroIntegrationLike, type LunoraIntegrationOptions, lunora };
+export {
+/**
+ * `@lunora/astro` — the Astro integration for Lunora (PLAN4 class-B:
+ * own-CF-adapter, hook-injection composition).
+ *
+ * Astro is multi-framework at the UI layer, so this package is **not** a new
+ * reactive layer. Reactivity comes from whichever island adapter the app
+ * hydrates with (`@lunora/react`, `@lunora/solid`, `@lunora/svelte`,
+ * `@lunora/vue`). `@lunora/astro` owns two server-side seams instead.
+ *
+ * Seam 1 — single-worker composition: `withLunora` wraps the Worker
+ * `@astrojs/cloudflare` emits so Lunora realtime (`/_lunora/rpc`, `/_lunora/ws`,
+ * `/_lunora/admin/*` + `ShardDO`) is mounted *inside* it, while everything else
+ * falls through to Astro's SSR handler — one worker, one deploy. `lunora` is the
+ * matching `astro.config` integration.
+ *
+ * Seam 2 — reactive-loader server helpers: the framework-neutral `@lunora/client/ssr`
+ * contract (`createServerClient`, `preloadQuery`, `getServerSession`,
+ * `serializePreloaded`) is re-exported from `@lunora/astro/server` for use in
+ * Astro server endpoints / `.astro` frontmatter. Preload a query there, then
+ * hand the `Preloaded` token to your island adapter's `hydratePreloaded` for the
+ * "your loaders are live" SSR-seed → live handoff.
+ */
+type AstroIntegrationLike,
+/**
+ * `@lunora/astro` — the Astro integration for Lunora (PLAN4 class-B:
+ * own-CF-adapter, hook-injection composition).
+ *
+ * Astro is multi-framework at the UI layer, so this package is **not** a new
+ * reactive layer. Reactivity comes from whichever island adapter the app
+ * hydrates with (`@lunora/react`, `@lunora/solid`, `@lunora/svelte`,
+ * `@lunora/vue`). `@lunora/astro` owns two server-side seams instead.
+ *
+ * Seam 1 — single-worker composition: `withLunora` wraps the Worker
+ * `@astrojs/cloudflare` emits so Lunora realtime (`/_lunora/rpc`, `/_lunora/ws`,
+ * `/_lunora/admin/*` + `ShardDO`) is mounted *inside* it, while everything else
+ * falls through to Astro's SSR handler — one worker, one deploy. `lunora` is the
+ * matching `astro.config` integration.
+ *
+ * Seam 2 — reactive-loader server helpers: the framework-neutral `@lunora/client/ssr`
+ * contract (`createServerClient`, `preloadQuery`, `getServerSession`,
+ * `serializePreloaded`) is re-exported from `@lunora/astro/server` for use in
+ * Astro server endpoints / `.astro` frontmatter. Preload a query there, then
+ * hand the `Preloaded` token to your island adapter's `hydratePreloaded` for the
+ * "your loaders are live" SSR-seed → live handoff.
+ */
+type LunoraIntegrationOptions, lunora };

package/dist/index.d.ts

@@ -1,27 +1,12 @@
 export { type FrameworkHostHandler as AstroWorkerHandler, type LunoraWorker as ComposedWorker, type FrameworkWorkerOptions as LunoraOptions, withFrameworkWorker as withLunora } from '@lunora/runtime';
 /**
-* The Lunora Astro **integration** — an `AstroIntegration` object
-* (`{ name, hooks }`) added to `astro.config.*`'s `integrations` array.
-*
-* Astro is multi-framework at the UI layer, so this integration is **not** a new
-* reactive runtime. Its job is the *composition* seam (PLAN4 class-B): make the
-* Worker `@astrojs/cloudflare` emits mount Lunora realtime under `/_lunora/*`
-* via `withLunora`, and surface the framework-neutral server helpers
-* (`@lunora/astro/server`) to Astro server endpoints / `.astro` frontmatter.
-*
-* Reactivity itself comes from whichever island adapter the app hydrates with —
-* `@lunora/react`, `@lunora/solid`, `@lunora/svelte`, or `@lunora/vue` — each of
-* which ships its own `hydratePreloaded(preloaded)` for the SSR-seed → live
-* handoff. This package owns the server/composition half only.
-*/
-/**
-* Structural subset of Astro's `AstroIntegration`. Declared locally (rather than
-* importing `astro`'s type) so `@lunora/astro`'s public surface stays decoupled
-* from a specific Astro major and type-checks even when `astro` is not installed
-* — `astro` is an *optional* peer here (only the host Astro app pulls it in).
-* The shape is assignable to/from Astro's real `AstroIntegration`, so adding the
-* returned object to `integrations` type-checks in a real Astro project.
-*/
+ * Structural subset of Astro's `AstroIntegration`. Declared locally (rather than
+ * importing `astro`'s type) so `@lunora/astro`'s public surface stays decoupled
+ * from a specific Astro major and type-checks even when `astro` is not installed
+ * — `astro` is an *optional* peer here (only the host Astro app pulls it in).
+ * The shape is assignable to/from Astro's real `AstroIntegration`, so adding the
+ * returned object to `integrations` type-checks in a real Astro project.
+ */
 interface AstroIntegrationLike {
   readonly hooks: {
     readonly [hook: string]: ((...arguments_: never[]) => unknown) | undefined;
@@ -31,41 +16,95 @@ interface AstroIntegrationLike {
 /** Options for the `lunora` integration. */
 interface LunoraIntegrationOptions {
   /**
-  * Path (or specifier) of the module that calls `withLunora` and is the
-  * composed worker's `export default`. Documented for the wiring story; when
-  * omitted the integration assumes the conventional `src/worker.ts`.
-  */
+   * Path (or specifier) of the module that composes the Lunora plane with the
+   * Astro handler and is the composed worker's `export default`. Documented for
+   * the wiring story; when omitted the integration assumes the conventional
+   * `src/server.ts` — deliberately NOT `src/worker.ts`, which `lunora deploy`
+   * treats as a SvelteKit-shaped entry to pass to wrangler positionally, and
+   * which the `@astrojs/cloudflare` redirect's `no_bundle: true` then uploads
+   * untranspiled.
+   */
   readonly serverEntry?: string;
 }
 /**
-* The Lunora Astro integration. Add it to `astro.config.*`:
-*
-* ```ts
-* import cloudflare from "@astrojs/cloudflare";
-* import { defineConfig } from "astro/config";
-* import { lunora } from "@lunora/astro";
-*
-* export default defineConfig({
-*   output: "server",
-*   adapter: cloudflare(),
-*   integrations: [lunora()],
-* });
-* ```
-*
-* What it does:
-*
-* - Marks the build so the `@astrojs/cloudflare` server entry is wrapped with
-*   `withLunora` — the composed worker reserves `/_lunora/*` for Lunora realtime
-*   and forwards everything else to Astro's SSR handler (one worker, one deploy).
-* - Documents the `serverEntry` (default `src/worker.ts`) where the
-*   `withLunora(astroWorker, { shardDO: env.SHARD, … })` composition lives.
-*
-* The hook is intentionally minimal here: the load-bearing composition is the
-* `withLunora` wrapper at the server-entry boundary (see `withLunora` for the
-* `@astrojs/cloudflare` injection point). The integration object exists so the
-* wiring is declared in `astro.config` the idiomatic Astro way, and so future
-* build-time hooks (binding reconcile, dev middleware) have a home without
-* changing the public surface.
-*/
+ * The Lunora Astro integration. Add it to `astro.config.*`:
+ *
+ * ```ts
+ * import cloudflare from "@astrojs/cloudflare";
+ * import { defineConfig } from "astro/config";
+ * import { lunora } from "@lunora/astro";
+ *
+ * export default defineConfig({
+ *   output: "server",
+ *   adapter: cloudflare(),
+ *   integrations: [lunora()],
+ * });
+ * ```
+ *
+ * What it does:
+ *
+ * - Documents the `serverEntry` (default `src/server.ts`) where the
+ *   `withLunora(astroWorker, { shardDO: env.SHARD, … })` composition — or the
+ *   generated builder's `.buildFrameworkWorker(host)` — lives.
+ * - Checks, at `astro:config:done`, that `serverEntry` exists and contains an
+ *   actual composition CALL (not merely an import of it) — and warns
+ *   (does not fail the build) when it doesn't, so a missing wrapper is caught
+ *   at build time instead of shipping a worker where `/_lunora/*` is unrouted
+ *   and realtime silently 404s.
+ *
+ * This integration does NOT wrap the server entry itself — no file is written
+ * or modified. The load-bearing composition is the `withLunora` call the
+ * project author writes at the server-entry boundary (see `withLunora` for the
+ * `@astrojs/cloudflare` injection point); this object exists so the wiring is
+ * declared in `astro.config` the idiomatic Astro way, checked once at build
+ * time, and has a home for future build-time hooks (binding reconcile, dev
+ * middleware) without changing the public surface.
+ */
 declare const lunora: (options?: LunoraIntegrationOptions) => AstroIntegrationLike;
-export { type AstroIntegrationLike, type LunoraIntegrationOptions, lunora };
+export {
+/**
+ * `@lunora/astro` — the Astro integration for Lunora (PLAN4 class-B:
+ * own-CF-adapter, hook-injection composition).
+ *
+ * Astro is multi-framework at the UI layer, so this package is **not** a new
+ * reactive layer. Reactivity comes from whichever island adapter the app
+ * hydrates with (`@lunora/react`, `@lunora/solid`, `@lunora/svelte`,
+ * `@lunora/vue`). `@lunora/astro` owns two server-side seams instead.
+ *
+ * Seam 1 — single-worker composition: `withLunora` wraps the Worker
+ * `@astrojs/cloudflare` emits so Lunora realtime (`/_lunora/rpc`, `/_lunora/ws`,
+ * `/_lunora/admin/*` + `ShardDO`) is mounted *inside* it, while everything else
+ * falls through to Astro's SSR handler — one worker, one deploy. `lunora` is the
+ * matching `astro.config` integration.
+ *
+ * Seam 2 — reactive-loader server helpers: the framework-neutral `@lunora/client/ssr`
+ * contract (`createServerClient`, `preloadQuery`, `getServerSession`,
+ * `serializePreloaded`) is re-exported from `@lunora/astro/server` for use in
+ * Astro server endpoints / `.astro` frontmatter. Preload a query there, then
+ * hand the `Preloaded` token to your island adapter's `hydratePreloaded` for the
+ * "your loaders are live" SSR-seed → live handoff.
+ */
+type AstroIntegrationLike,
+/**
+ * `@lunora/astro` — the Astro integration for Lunora (PLAN4 class-B:
+ * own-CF-adapter, hook-injection composition).
+ *
+ * Astro is multi-framework at the UI layer, so this package is **not** a new
+ * reactive layer. Reactivity comes from whichever island adapter the app
+ * hydrates with (`@lunora/react`, `@lunora/solid`, `@lunora/svelte`,
+ * `@lunora/vue`). `@lunora/astro` owns two server-side seams instead.
+ *
+ * Seam 1 — single-worker composition: `withLunora` wraps the Worker
+ * `@astrojs/cloudflare` emits so Lunora realtime (`/_lunora/rpc`, `/_lunora/ws`,
+ * `/_lunora/admin/*` + `ShardDO`) is mounted *inside* it, while everything else
+ * falls through to Astro's SSR handler — one worker, one deploy. `lunora` is the
+ * matching `astro.config` integration.
+ *
+ * Seam 2 — reactive-loader server helpers: the framework-neutral `@lunora/client/ssr`
+ * contract (`createServerClient`, `preloadQuery`, `getServerSession`,
+ * `serializePreloaded`) is re-exported from `@lunora/astro/server` for use in
+ * Astro server endpoints / `.astro` frontmatter. Preload a query there, then
+ * hand the `Preloaded` token to your island adapter's `hydratePreloaded` for the
+ * "your loaders are live" SSR-seed → live handoff.
+ */
+type LunoraIntegrationOptions, lunora };

package/dist/index.mjs

@@ -1,2 +1 @@
-export { lunora } from './packem_shared/lunora-DCkPGEVa.mjs';
-export { withFrameworkWorker as withLunora } from '@lunora/runtime';
+import{lunora as a}from"./packem_shared/lunora-DnV2_atg.mjs";import{withFrameworkWorker as t}from"@lunora/runtime";export{a as lunora,t as withLunora};

package/dist/packem_shared/lunora-DnV2_atg.mjs

@@ -0,0 +1,6 @@
+import{existsSync as u,readFileSync as E}from"node:fs";import{fileURLToPath as c}from"node:url";const p=String.raw`\/\*[\s\S]*?\*\/`,L=String.raw`\/\/[^\n]*`,f=String.raw`"(?:[^"\\\n]|\\.)*"`,m=String.raw`'(?:[^'\\\n]|\\.)*'`,v=String.raw`\x60(?:[^\x60\\$]|\\.|\$(?!\{))*\x60`,y=new RegExp([p,L,f,m,v].join("|"),"gu"),_=/[^\n]/gu,g=e=>e.replaceAll(_," "),R=e=>e.replaceAll(y,g),d=["// src/server.ts",'import { handle } from "@astrojs/cloudflare/handler";','import { withLunora } from "@lunora/astro";',"","// `shardDO` lives on `env` (per request), so pass an `(env) => options` factory.","export default withLunora(","  (req, env, ctx) => handle(req, env, ctx),","  (env) => ({ shardDO: env.SHARD /* , … */ }),",");"].join(`
+`),S=/\b(?:withLunora|withFrameworkWorker|buildFrameworkWorker)\s*\(/u,h="src/server.ts",s="src/worker.ts",k=(e={})=>{const n=(e.serverEntry??h).trim();return{hooks:{"astro:config:done":(o={})=>{if(n.length===0)throw new TypeError("@lunora/astro: `serverEntry` must be a non-empty path.");const t=o.config?.root;if(t===void 0)return;const a=r=>{o.logger?.warn?o.logger.warn(r):console.warn(r)},l=c(new URL(n,t));if(!u(l)){const r=e.serverEntry===void 0&&u(c(new URL(s,t)));a(r?`@lunora/astro: the default server entry is now "${h}", and this project still composes in "${s}". Rename it — \`lunora deploy\` passes a file at that exact path to wrangler positionally, and @astrojs/cloudflare's \`no_bundle\` redirect then uploads it untranspiled — or keep the old name with \`lunora({ serverEntry: "${s}" })\`.`:`@lunora/astro: server entry "${n}" not found — add it (or point \`lunora({ serverEntry })\` at the right path) and wrap the Astro worker with \`withLunora\`, or \`/_lunora/*\` (Lunora realtime) will be unrouted:
+
+${d}`);return}let i;try{i=E(l,"utf8")}catch(r){const w=r instanceof Error?r.message:String(r);a(`@lunora/astro: could not read server entry "${n}" (${w}) — skipping the \`withLunora\` check.`);return}S.test(R(i))||a(`@lunora/astro: couldn't find a \`withLunora(...)\` or \`.buildFrameworkWorker(...)\` call in the server entry "${n}" — \`/_lunora/*\` (Lunora realtime) will be unrouted and subscriptions will silently 404. Compose the Astro worker:
+
+${d}`)}},name:"@lunora/astro"}};export{k as lunora};

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/astro",
-  "version": "1.0.0-alpha.15",
+  "version": "1.0.0-alpha.150",
   "description": "Astro integration for Lunora — single-worker composition plus reactive-loader server helpers",
   "keywords": [
     "astro",
@@ -50,11 +50,11 @@
     "access": "public"
   },
   "dependencies": {
-    "@lunora/client": "1.0.0-alpha.9",
-    "@lunora/runtime": "1.0.0-alpha.9"
+    "@lunora/client": "1.0.0-alpha.117",
+    "@lunora/runtime": "1.0.0-alpha.130"
   },
   "peerDependencies": {
-    "astro": "^6.0.0"
+    "astro": ">=6.0.0"
   },
   "peerDependenciesMeta": {
     "astro": {

package/dist/packem_shared/lunora-DCkPGEVa.mjs

@@ -1,15 +0,0 @@
-const lunora = (options = {}) => {
-  const serverEntry = options.serverEntry ?? "src/worker.ts";
-  return {
-    hooks: {
-      "astro:config:done": () => {
-        if (serverEntry.length === 0) {
-          throw new Error("@lunora/astro: `serverEntry` must be a non-empty path.");
-        }
-      }
-    },
-    name: "@lunora/astro"
-  };
-};
-
-export { lunora };