@lunora/astro 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/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,90 @@ 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 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`.
+   */
   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/worker.ts`) where the
+ *   `withLunora(astroWorker, { shardDO: env.SHARD, … })` composition lives.
+ * - Checks, at `astro:config:done`, that `serverEntry` exists and contains an
+ *   actual `withLunora(...)` 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,90 @@ 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 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`.
+   */
   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/worker.ts`) where the
+ *   `withLunora(astroWorker, { shardDO: env.SHARD, … })` composition lives.
+ * - Checks, at `astro:config:done`, that `serverEntry` exists and contains an
+ *   actual `withLunora(...)` 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-D3tdDncx.mjs";import{withFrameworkWorker as t}from"@lunora/runtime";export{a as lunora,t as withLunora};

package/dist/packem_shared/lunora-D3tdDncx.mjs

@@ -0,0 +1,6 @@
+import{existsSync as h,readFileSync as c}from"node:fs";import{fileURLToPath as w}from"node:url";const i=['import { withLunora } from "@lunora/astro/server";',"","export default withLunora(astroWorker, { shardDO: env.SHARD /* , … */ });"].join(`
+`),d=/\bwithLunora\s*\(/u,y=(u={})=>{const o=(u.serverEntry??"src/worker.ts").trim();return{hooks:{"astro:config:done":(t={})=>{if(o.length===0)throw new TypeError("@lunora/astro: `serverEntry` must be a non-empty path.");const e=t.config?.root;if(e===void 0)return;const n=r=>{t.logger?.warn?t.logger.warn(r):console.warn(r)},a=w(new URL(o,e));if(!h(a)){n(`@lunora/astro: server entry "${o}" 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:
+
+${i}`);return}let s;try{s=c(a,"utf8")}catch(r){const l=r instanceof Error?r.message:String(r);n(`@lunora/astro: could not read server entry "${o}" (${l}) — skipping the \`withLunora\` check.`);return}d.test(s)||n(`@lunora/astro: couldn't find a \`withLunora(...)\` call in the server entry "${o}" — \`/_lunora/*\` (Lunora realtime) will be unrouted and subscriptions will silently 404. Wrap the Astro worker:
+
+${i}`)}},name:"@lunora/astro"}};export{y 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.9",
+  "version": "1.0.0-alpha.90",
   "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.4",
-    "@lunora/runtime": "1.0.0-alpha.7"
+    "@lunora/client": "1.0.0-alpha.57",
+    "@lunora/runtime": "1.0.0-alpha.72"
   },
   "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 };