@lunora/react 1.0.0-alpha.28 → 1.0.0-alpha.29

package/dist/packem_shared/query-options.d-CdgGQ9s4.d.mts

@@ -0,0 +1,38 @@
+import { FunctionReference, ReturnOf, LunoraClient, ArgsOf } from '@lunora/client';
+import { QueryKey } from '@tanstack/react-query';
+/**
+ * Pure, transport-free adapter between a Lunora function reference and a
+ * TanStack Query options object. No `"use client"` directive and only a
+ * type-level `@lunora/client` import, so it is safe to use on either side of an
+ * RSC boundary (the runtime transport is the `LunoraClient` you pass in).
+ *
+ * Use it when you want to drive a Lunora query through TanStack's own hooks —
+ * `useSuspenseQuery`, `useQueries`, or the server-side
+ * `queryClient.ensureQueryData` / `prefetchQuery` — rather than the first-class
+ * `useQuery` from `@lunora/react`.
+ */
+/** Shape returned by `lunoraQueryOptions`, spread into a TanStack hook. */
+interface LunoraQueryOptions<F extends FunctionReference> {
+  queryFn: () => Promise<ReturnOf<F>>;
+  queryKey: QueryKey;
+  staleTime: number;
+}
+/**
+ * Build a TanStack Query options object for a Lunora query, keyed identically
+ * to the first-class hooks (see `lunoraQueryKey`) so a value fetched through
+ * this adapter shares cache identity with anything `useQuery` /
+ * `prefetchQuery` reads or writes for the same `(fn, args, shardKey)` triple.
+ *
+ * ```ts
+ * const { data } = useSuspenseQuery(lunoraQueryOptions(client, api.posts.list, {}));
+ * ```
+ *
+ * This is a one-shot fetch: it resolves once and `staleTime` is infinite, so
+ * TanStack never refetches on its own. It does not open a WebSocket — for live
+ * updates that re-render on every server push, use `useQuery` from
+ * `@lunora/react`, which attaches a shared subscription to the same cache key.
+ */
+declare const lunoraQueryOptions: <F extends FunctionReference>(client: LunoraClient, function_: F, args: ArgsOf<F>, options?: {
+  shardKey?: string;
+}) => LunoraQueryOptions<F>;
+export { LunoraQueryOptions as L, lunoraQueryOptions as l };

package/dist/packem_shared/query-options.d-CdgGQ9s4.d.ts

@@ -0,0 +1,38 @@
+import { FunctionReference, ReturnOf, LunoraClient, ArgsOf } from '@lunora/client';
+import { QueryKey } from '@tanstack/react-query';
+/**
+ * Pure, transport-free adapter between a Lunora function reference and a
+ * TanStack Query options object. No `"use client"` directive and only a
+ * type-level `@lunora/client` import, so it is safe to use on either side of an
+ * RSC boundary (the runtime transport is the `LunoraClient` you pass in).
+ *
+ * Use it when you want to drive a Lunora query through TanStack's own hooks —
+ * `useSuspenseQuery`, `useQueries`, or the server-side
+ * `queryClient.ensureQueryData` / `prefetchQuery` — rather than the first-class
+ * `useQuery` from `@lunora/react`.
+ */
+/** Shape returned by `lunoraQueryOptions`, spread into a TanStack hook. */
+interface LunoraQueryOptions<F extends FunctionReference> {
+  queryFn: () => Promise<ReturnOf<F>>;
+  queryKey: QueryKey;
+  staleTime: number;
+}
+/**
+ * Build a TanStack Query options object for a Lunora query, keyed identically
+ * to the first-class hooks (see `lunoraQueryKey`) so a value fetched through
+ * this adapter shares cache identity with anything `useQuery` /
+ * `prefetchQuery` reads or writes for the same `(fn, args, shardKey)` triple.
+ *
+ * ```ts
+ * const { data } = useSuspenseQuery(lunoraQueryOptions(client, api.posts.list, {}));
+ * ```
+ *
+ * This is a one-shot fetch: it resolves once and `staleTime` is infinite, so
+ * TanStack never refetches on its own. It does not open a WebSocket — for live
+ * updates that re-render on every server push, use `useQuery` from
+ * `@lunora/react`, which attaches a shared subscription to the same cache key.
+ */
+declare const lunoraQueryOptions: <F extends FunctionReference>(client: LunoraClient, function_: F, args: ArgsOf<F>, options?: {
+  shardKey?: string;
+}) => LunoraQueryOptions<F>;
+export { LunoraQueryOptions as L, lunoraQueryOptions as l };

package/dist/server.d.mts

@@ -4,20 +4,20 @@ import { ServerClientOptions } from '@lunora/client/ssr';
 export { type AuthLike, type HeadersSource, type ServerClientOptions, type ServerSession, createServerClient, deserializePreloaded, getServerSession, serializePreloaded } from '@lunora/client/ssr';
 import { QueryClient } from '@tanstack/react-query';
 export { HydrationBoundary, dehydrate } from '@tanstack/react-query';
-export { type L as LunoraQueryOptions, l as lunoraQueryOptions } from "./packem_shared/query-options.d-D4okOpO8.mjs";
+export { type L as LunoraQueryOptions, l as lunoraQueryOptions } from "./packem_shared/query-options.d-CdgGQ9s4.mjs";
 /**
-* Run a query on the server and seed `queryClient` with the result under the
-* same key the client hooks use (see `lunoraQueryKey`), so a later
-* `useQuery(fn, args)` reads it straight from the hydrated cache — no loading
-* flash, no duplicate fetch on the client.
-*
-* Pair it with TanStack's `dehydrate` + `HydrationBoundary` (both re-exported
-* from this module): prefetch into a fresh `QueryClient`, `dehydrate` it, wrap
-* the client subtree in `HydrationBoundary`, and the client hooks pick the value
-* up from cache. Errors propagate — wrap the call if you'd rather render a
-* fallback than fail the server render. Drop the `await` for fire-and-forget
-* prefetch when you don't need the data present on the very first paint.
-*/
+ * Run a query on the server and seed `queryClient` with the result under the
+ * same key the client hooks use (see `lunoraQueryKey`), so a later
+ * `useQuery(fn, args)` reads it straight from the hydrated cache — no loading
+ * flash, no duplicate fetch on the client.
+ *
+ * Pair it with TanStack's `dehydrate` + `HydrationBoundary` (both re-exported
+ * from this module): prefetch into a fresh `QueryClient`, `dehydrate` it, wrap
+ * the client subtree in `HydrationBoundary`, and the client hooks pick the value
+ * up from cache. Errors propagate — wrap the call if you'd rather render a
+ * fallback than fail the server render. Drop the `await` for fire-and-forget
+ * prefetch when you don't need the data present on the very first paint.
+ */
 declare const prefetchQuery: <F extends FunctionReference>(queryClient: QueryClient, client: LunoraClient, function_: F, args: ArgsOf<F>, options?: {
   shardKey?: string;
 }) => Promise<void>;
@@ -27,25 +27,25 @@ interface ServerCallOptions {
   shardKey?: string;
 }
 /**
-* Run a query once on the server and return its result — the standalone
-* counterpart to `prefetchQuery`/`preloadQuery` for when you just want the data
-* inline in a Server Component (e.g. to compute metadata or branch on a value)
-* rather than seed a cache or hand a `Preloaded` to the client.
-*
-* Builds a fresh request-scoped client per call (see `createServerClient`), so
-* pass `token` to run as the signed-in user. For several reads in one request,
-* prefer holding one `createServerClient` and calling `.query()` yourself to
-* avoid rebuilding the transport each time. Errors propagate.
-*/
+ * Run a query once on the server and return its result — the standalone
+ * counterpart to `prefetchQuery`/`preloadQuery` for when you just want the data
+ * inline in a Server Component (e.g. to compute metadata or branch on a value)
+ * rather than seed a cache or hand a `Preloaded` to the client.
+ *
+ * Builds a fresh request-scoped client per call (see `createServerClient`), so
+ * pass `token` to run as the signed-in user. For several reads in one request,
+ * prefer holding one `createServerClient` and calling `.query()` yourself to
+ * avoid rebuilding the transport each time. Errors propagate.
+ */
 declare const fetchQuery: <F extends FunctionReference>(options: ServerClientOptions, function_: F, args: ArgsOf<F>, callOptions?: ServerCallOptions) => Promise<ReturnOf<F>>;
 /**
-* Run a mutation once on the server and return its result. Server-side calls go
-* straight over HTTP RPC — the offline queue and optimistic-update machinery are
-* client-only and never engage here. Errors propagate.
-*/
+ * Run a mutation once on the server and return its result. Server-side calls go
+ * straight over HTTP RPC — the offline queue and optimistic-update machinery are
+ * client-only and never engage here. Errors propagate.
+ */
 declare const fetchMutation: <F extends FunctionReference>(options: ServerClientOptions, function_: F, args: ArgsOf<F>, callOptions?: ServerCallOptions) => Promise<ReturnOf<F>>;
 /**
-* Run an action once on the server and return its result. Errors propagate.
-*/
+ * Run an action once on the server and return its result. Errors propagate.
+ */
 declare const fetchAction: <F extends FunctionReference>(options: ServerClientOptions, function_: F, args: ArgsOf<F>, callOptions?: ServerCallOptions) => Promise<ReturnOf<F>>;
 export { ServerCallOptions, fetchAction, fetchMutation, fetchQuery, prefetchQuery };

package/dist/server.d.ts

@@ -4,20 +4,20 @@ import { ServerClientOptions } from '@lunora/client/ssr';
 export { type AuthLike, type HeadersSource, type ServerClientOptions, type ServerSession, createServerClient, deserializePreloaded, getServerSession, serializePreloaded } from '@lunora/client/ssr';
 import { QueryClient } from '@tanstack/react-query';
 export { HydrationBoundary, dehydrate } from '@tanstack/react-query';
-export { type L as LunoraQueryOptions, l as lunoraQueryOptions } from "./packem_shared/query-options.d-D4okOpO8.js";
+export { type L as LunoraQueryOptions, l as lunoraQueryOptions } from "./packem_shared/query-options.d-CdgGQ9s4.js";
 /**
-* Run a query on the server and seed `queryClient` with the result under the
-* same key the client hooks use (see `lunoraQueryKey`), so a later
-* `useQuery(fn, args)` reads it straight from the hydrated cache — no loading
-* flash, no duplicate fetch on the client.
-*
-* Pair it with TanStack's `dehydrate` + `HydrationBoundary` (both re-exported
-* from this module): prefetch into a fresh `QueryClient`, `dehydrate` it, wrap
-* the client subtree in `HydrationBoundary`, and the client hooks pick the value
-* up from cache. Errors propagate — wrap the call if you'd rather render a
-* fallback than fail the server render. Drop the `await` for fire-and-forget
-* prefetch when you don't need the data present on the very first paint.
-*/
+ * Run a query on the server and seed `queryClient` with the result under the
+ * same key the client hooks use (see `lunoraQueryKey`), so a later
+ * `useQuery(fn, args)` reads it straight from the hydrated cache — no loading
+ * flash, no duplicate fetch on the client.
+ *
+ * Pair it with TanStack's `dehydrate` + `HydrationBoundary` (both re-exported
+ * from this module): prefetch into a fresh `QueryClient`, `dehydrate` it, wrap
+ * the client subtree in `HydrationBoundary`, and the client hooks pick the value
+ * up from cache. Errors propagate — wrap the call if you'd rather render a
+ * fallback than fail the server render. Drop the `await` for fire-and-forget
+ * prefetch when you don't need the data present on the very first paint.
+ */
 declare const prefetchQuery: <F extends FunctionReference>(queryClient: QueryClient, client: LunoraClient, function_: F, args: ArgsOf<F>, options?: {
   shardKey?: string;
 }) => Promise<void>;
@@ -27,25 +27,25 @@ interface ServerCallOptions {
   shardKey?: string;
 }
 /**
-* Run a query once on the server and return its result — the standalone
-* counterpart to `prefetchQuery`/`preloadQuery` for when you just want the data
-* inline in a Server Component (e.g. to compute metadata or branch on a value)
-* rather than seed a cache or hand a `Preloaded` to the client.
-*
-* Builds a fresh request-scoped client per call (see `createServerClient`), so
-* pass `token` to run as the signed-in user. For several reads in one request,
-* prefer holding one `createServerClient` and calling `.query()` yourself to
-* avoid rebuilding the transport each time. Errors propagate.
-*/
+ * Run a query once on the server and return its result — the standalone
+ * counterpart to `prefetchQuery`/`preloadQuery` for when you just want the data
+ * inline in a Server Component (e.g. to compute metadata or branch on a value)
+ * rather than seed a cache or hand a `Preloaded` to the client.
+ *
+ * Builds a fresh request-scoped client per call (see `createServerClient`), so
+ * pass `token` to run as the signed-in user. For several reads in one request,
+ * prefer holding one `createServerClient` and calling `.query()` yourself to
+ * avoid rebuilding the transport each time. Errors propagate.
+ */
 declare const fetchQuery: <F extends FunctionReference>(options: ServerClientOptions, function_: F, args: ArgsOf<F>, callOptions?: ServerCallOptions) => Promise<ReturnOf<F>>;
 /**
-* Run a mutation once on the server and return its result. Server-side calls go
-* straight over HTTP RPC — the offline queue and optimistic-update machinery are
-* client-only and never engage here. Errors propagate.
-*/
+ * Run a mutation once on the server and return its result. Server-side calls go
+ * straight over HTTP RPC — the offline queue and optimistic-update machinery are
+ * client-only and never engage here. Errors propagate.
+ */
 declare const fetchMutation: <F extends FunctionReference>(options: ServerClientOptions, function_: F, args: ArgsOf<F>, callOptions?: ServerCallOptions) => Promise<ReturnOf<F>>;
 /**
-* Run an action once on the server and return its result. Errors propagate.
-*/
+ * Run an action once on the server and return its result. Errors propagate.
+ */
 declare const fetchAction: <F extends FunctionReference>(options: ServerClientOptions, function_: F, args: ArgsOf<F>, callOptions?: ServerCallOptions) => Promise<ReturnOf<F>>;
 export { ServerCallOptions, fetchAction, fetchMutation, fetchQuery, prefetchQuery };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/react",
-  "version": "1.0.0-alpha.28",
+  "version": "1.0.0-alpha.29",
   "description": "React hooks for Lunora: useQuery, useMutation, useSubscription, and useAuth",
   "keywords": [
     "cloudflare",
@@ -49,9 +49,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@lunora/client": "1.0.0-alpha.24",
-    "@lunora/errors": "1.0.0-alpha.5",
-    "@lunora/ratelimit": "1.0.0-alpha.8"
+    "@lunora/client": "1.0.0-alpha.25",
+    "@lunora/errors": "1.0.0-alpha.6",
+    "@lunora/ratelimit": "1.0.0-alpha.9"
   },
   "peerDependencies": {
     "@tanstack/react-query": "^5.101.0",

package/dist/packem_shared/query-options.d-D4okOpO8.d.mts

@@ -1,38 +0,0 @@
-import { FunctionReference, ReturnOf, LunoraClient, ArgsOf } from '@lunora/client';
-import { QueryKey } from '@tanstack/react-query';
-/**
-* Pure, transport-free adapter between a Lunora function reference and a
-* TanStack Query options object. No `"use client"` directive and only a
-* type-level `@lunora/client` import, so it is safe to use on either side of an
-* RSC boundary (the runtime transport is the `LunoraClient` you pass in).
-*
-* Use it when you want to drive a Lunora query through TanStack's own hooks —
-* `useSuspenseQuery`, `useQueries`, or the server-side
-* `queryClient.ensureQueryData` / `prefetchQuery` — rather than the first-class
-* `useQuery` from `@lunora/react`.
-*/
-/** Shape returned by `lunoraQueryOptions`, spread into a TanStack hook. */
-interface LunoraQueryOptions<F extends FunctionReference> {
-  queryFn: () => Promise<ReturnOf<F>>;
-  queryKey: QueryKey;
-  staleTime: number;
-}
-/**
-* Build a TanStack Query options object for a Lunora query, keyed identically
-* to the first-class hooks (see `lunoraQueryKey`) so a value fetched through
-* this adapter shares cache identity with anything `useQuery` /
-* `prefetchQuery` reads or writes for the same `(fn, args, shardKey)` triple.
-*
-* ```ts
-* const { data } = useSuspenseQuery(lunoraQueryOptions(client, api.posts.list, {}));
-* ```
-*
-* This is a one-shot fetch: it resolves once and `staleTime` is infinite, so
-* TanStack never refetches on its own. It does not open a WebSocket — for live
-* updates that re-render on every server push, use `useQuery` from
-* `@lunora/react`, which attaches a shared subscription to the same cache key.
-*/
-declare const lunoraQueryOptions: <F extends FunctionReference>(client: LunoraClient, function_: F, args: ArgsOf<F>, options?: {
-  shardKey?: string;
-}) => LunoraQueryOptions<F>;
-export { LunoraQueryOptions as L, lunoraQueryOptions as l };

package/dist/packem_shared/query-options.d-D4okOpO8.d.ts

@@ -1,38 +0,0 @@
-import { FunctionReference, ReturnOf, LunoraClient, ArgsOf } from '@lunora/client';
-import { QueryKey } from '@tanstack/react-query';
-/**
-* Pure, transport-free adapter between a Lunora function reference and a
-* TanStack Query options object. No `"use client"` directive and only a
-* type-level `@lunora/client` import, so it is safe to use on either side of an
-* RSC boundary (the runtime transport is the `LunoraClient` you pass in).
-*
-* Use it when you want to drive a Lunora query through TanStack's own hooks —
-* `useSuspenseQuery`, `useQueries`, or the server-side
-* `queryClient.ensureQueryData` / `prefetchQuery` — rather than the first-class
-* `useQuery` from `@lunora/react`.
-*/
-/** Shape returned by `lunoraQueryOptions`, spread into a TanStack hook. */
-interface LunoraQueryOptions<F extends FunctionReference> {
-  queryFn: () => Promise<ReturnOf<F>>;
-  queryKey: QueryKey;
-  staleTime: number;
-}
-/**
-* Build a TanStack Query options object for a Lunora query, keyed identically
-* to the first-class hooks (see `lunoraQueryKey`) so a value fetched through
-* this adapter shares cache identity with anything `useQuery` /
-* `prefetchQuery` reads or writes for the same `(fn, args, shardKey)` triple.
-*
-* ```ts
-* const { data } = useSuspenseQuery(lunoraQueryOptions(client, api.posts.list, {}));
-* ```
-*
-* This is a one-shot fetch: it resolves once and `staleTime` is infinite, so
-* TanStack never refetches on its own. It does not open a WebSocket — for live
-* updates that re-render on every server push, use `useQuery` from
-* `@lunora/react`, which attaches a shared subscription to the same cache key.
-*/
-declare const lunoraQueryOptions: <F extends FunctionReference>(client: LunoraClient, function_: F, args: ArgsOf<F>, options?: {
-  shardKey?: string;
-}) => LunoraQueryOptions<F>;
-export { LunoraQueryOptions as L, lunoraQueryOptions as l };