@lunora/react 1.0.0-alpha.3 → 1.0.0-alpha.31

package/dist/packem_shared/useVoiceAgent-w7fzAMSB.mjs

@@ -0,0 +1,422 @@
+'use client';
+import { useState, useRef, useCallback, useEffect } from 'react';
+import { useLunora } from './LunoraProvider-BsuiW4Lk.mjs';
+
+const TARGET_SAMPLE_RATE = 16e3;
+const blockRms = (samples) => {
+  if (samples.length === 0) {
+    return 0;
+  }
+  let sum = 0;
+  for (const sample of samples) {
+    sum += sample * sample;
+  }
+  return Math.sqrt(sum / samples.length);
+};
+const toPcm16 = (samples, inputSampleRate) => {
+  const ratio = inputSampleRate / TARGET_SAMPLE_RATE;
+  const outLength = ratio > 1 ? Math.floor(samples.length / ratio) : samples.length;
+  const buffer = new ArrayBuffer(outLength * 2);
+  const view = new DataView(buffer);
+  for (let index = 0; index < outLength; index += 1) {
+    const sample = samples[Math.floor(index * ratio)] ?? 0;
+    const clamped = Math.max(-1, Math.min(1, sample));
+    view.setInt16(index * 2, clamped < 0 ? clamped * 32768 : clamped * 32767, true);
+  }
+  return new Uint8Array(buffer);
+};
+const createBrowserMicrophone = async (config) => {
+  const media = globalThis;
+  const getUserMedia = media.navigator?.mediaDevices?.getUserMedia.bind(media.navigator.mediaDevices);
+  const AudioContextClass = media.AudioContext ?? media.webkitAudioContext;
+  if (!getUserMedia || !AudioContextClass) {
+    throw new Error("useVoiceAgent: microphone capture requires getUserMedia + AudioContext (no browser audio available)");
+  }
+  const stream = await getUserMedia({
+    audio: {
+      channelCount: 1,
+      echoCancellation: true,
+      noiseSuppression: true
+    }
+  });
+  const context = new AudioContextClass();
+  const source = context.createMediaStreamSource(stream);
+  const processor = context.createScriptProcessor(4096, 1, 1);
+  let muted = false;
+  let sawSpeech = false;
+  let silentFor = 0;
+  let loudChunks = 0;
+  processor.onaudioprocess = (event) => {
+    const samples = event.inputBuffer.getChannelData(0);
+    const rms = muted ? 0 : blockRms(samples);
+    config.onLevel(rms);
+    if (muted) {
+      return;
+    }
+    config.onAudio(toPcm16(samples, context.sampleRate));
+    if (config.isSpeaking()) {
+      loudChunks = rms >= config.interruptThreshold ? loudChunks + 1 : 0;
+      if (loudChunks >= config.interruptChunks) {
+        loudChunks = 0;
+        config.onInterrupt();
+      }
+      return;
+    }
+    loudChunks = 0;
+    const chunkMs = samples.length / context.sampleRate * 1e3;
+    if (rms >= config.silenceThreshold) {
+      sawSpeech = true;
+      silentFor = 0;
+      return;
+    }
+    if (sawSpeech) {
+      silentFor += chunkMs;
+      if (silentFor >= config.silenceDurationMs) {
+        sawSpeech = false;
+        silentFor = 0;
+        config.onSilence();
+      }
+    }
+  };
+  source.connect(processor);
+  processor.connect(context.destination);
+  return {
+    setMuted: (next) => {
+      muted = next;
+    },
+    stop: () => {
+      processor.disconnect();
+      source.disconnect();
+      for (const track of stream.getTracks()) {
+        track.stop();
+      }
+      void context.close();
+    }
+  };
+};
+const createBrowserSpeaker = () => {
+  const media = globalThis;
+  const AudioContextClass = media.AudioContext ?? media.webkitAudioContext;
+  if (!AudioContextClass) {
+    throw new Error("useVoiceAgent: audio playback requires AudioContext (no browser audio available)");
+  }
+  const context = new AudioContextClass();
+  const sources = /* @__PURE__ */ new Set();
+  let playHead = 0;
+  let chain = Promise.resolve();
+  let generation = 0;
+  const scheduleChunk = async (bytes, scheduledGeneration) => {
+    if (scheduledGeneration !== generation) {
+      return;
+    }
+    let decoded;
+    try {
+      decoded = await context.decodeAudioData(bytes.buffer);
+    } catch {
+      return;
+    }
+    if (scheduledGeneration !== generation) {
+      return;
+    }
+    const node = context.createBufferSource();
+    node.buffer = decoded;
+    node.connect(context.destination);
+    const startAt = Math.max(context.currentTime, playHead);
+    node.start(startAt);
+    playHead = startAt + decoded.duration;
+    sources.add(node);
+    node.onended = () => {
+      sources.delete(node);
+    };
+  };
+  const enqueue = (audio) => {
+    const bytes = Uint8Array.from(audio);
+    const scheduledGeneration = generation;
+    chain = chain.then(() => scheduleChunk(bytes, scheduledGeneration));
+  };
+  const interrupt = () => {
+    generation += 1;
+    for (const node of sources) {
+      try {
+        node.stop();
+      } catch {
+      }
+    }
+    sources.clear();
+    playHead = context.currentTime;
+  };
+  return {
+    enqueue,
+    interrupt,
+    stop: () => {
+      interrupt();
+      void context.close();
+    }
+  };
+};
+
+const WS_OPEN = 1;
+const DEFAULT_SILENCE_THRESHOLD = 0.01;
+const DEFAULT_SILENCE_DURATION_MS = 1200;
+const DEFAULT_INTERRUPT_THRESHOLD = 0.15;
+const DEFAULT_INTERRUPT_CHUNKS = 3;
+const deriveWebSocketUrl = (url) => {
+  if (url.startsWith("https://")) {
+    return `wss://${url.slice("https://".length)}`;
+  }
+  if (url.startsWith("http://")) {
+    return `ws://${url.slice("http://".length)}`;
+  }
+  return url;
+};
+const agentNameFromReference = (voice) => {
+  const reference = voice["__lunoraRef"];
+  const withoutNamespace = reference.startsWith("agents:") ? reference.slice("agents:".length) : reference;
+  return withoutNamespace.endsWith("Voice") ? withoutNamespace.slice(0, -"Voice".length) : withoutNamespace;
+};
+const voiceSocketUrl = (baseUrl, agent, threadKey) => {
+  const base = deriveWebSocketUrl(baseUrl);
+  const trimmed = base.endsWith("/") ? base.slice(0, -1) : base;
+  const search = new URLSearchParams({
+    threadKey
+  });
+  return `${trimmed}/_lunora/voice/${encodeURIComponent(agent)}?${search.toString()}`;
+};
+const useVoiceAgent = (options) => {
+  const {
+    createMicrophone = createBrowserMicrophone,
+    createSpeaker = createBrowserSpeaker,
+    createSocket,
+    interruptChunks = DEFAULT_INTERRUPT_CHUNKS,
+    interruptThreshold = DEFAULT_INTERRUPT_THRESHOLD,
+    silenceDurationMs = DEFAULT_SILENCE_DURATION_MS,
+    silenceThreshold = DEFAULT_SILENCE_THRESHOLD,
+    threadKey,
+    voice
+  } = options;
+  const client = useLunora();
+  const [status, setStatus] = useState("idle");
+  const [connected, setConnected] = useState(false);
+  const [transcript, setTranscript] = useState("");
+  const [interimTranscript, setInterimTranscript] = useState("");
+  const [audioLevel, setAudioLevel] = useState(0);
+  const [isMuted, setIsMuted] = useState(false);
+  const [error, setError] = useState(void 0);
+  const connectionRef = useRef(void 0);
+  const startingRef = useRef(false);
+  const sendFrame = useCallback((frame) => {
+    const socket = connectionRef.current?.socket;
+    if (socket?.readyState === WS_OPEN) {
+      socket.send(JSON.stringify(frame));
+      return true;
+    }
+    return false;
+  }, []);
+  const teardown = useCallback(() => {
+    const connection = connectionRef.current;
+    connectionRef.current = void 0;
+    if (connection) {
+      connection.microphone?.stop();
+      connection.speaker?.stop();
+      try {
+        connection.socket.close();
+      } catch {
+      }
+    }
+    startingRef.current = false;
+    setConnected(false);
+    setStatus("idle");
+    setAudioLevel(0);
+  }, []);
+  const endCall = useCallback(() => {
+    teardown();
+  }, [teardown]);
+  const handleServerFrame = useCallback((frame_0) => {
+    const connection_0 = connectionRef.current;
+    switch (frame_0.type) {
+      case "assistant_delta": {
+        if (connection_0) {
+          connection_0.speaking = true;
+        }
+        setStatus("speaking");
+        setInterimTranscript((previous) => previous + frame_0.text);
+        break;
+      }
+      case "assistant_done": {
+        if (connection_0) {
+          connection_0.speaking = false;
+        }
+        setInterimTranscript(frame_0.text);
+        setStatus("listening");
+        break;
+      }
+      case "error": {
+        if (connection_0) {
+          connection_0.speaking = false;
+        }
+        setError(new Error(frame_0.message));
+        setStatus("listening");
+        break;
+      }
+      case "interrupted": {
+        if (connection_0) {
+          connection_0.speaking = false;
+          connection_0.suppressAudio = false;
+        }
+        connection_0?.speaker?.interrupt();
+        setStatus("listening");
+        break;
+      }
+      case "ready": {
+        if (connection_0) {
+          connection_0.audioFormat = frame_0.audioFormat;
+          connection_0.suppressAudio = false;
+        }
+        setConnected(true);
+        setStatus("listening");
+        break;
+      }
+      case "user_transcript": {
+        if (connection_0) {
+          connection_0.suppressAudio = false;
+        }
+        setTranscript(frame_0.text);
+        setInterimTranscript("");
+        setStatus("thinking");
+        break;
+      }
+    }
+  }, []);
+  const handleAudioChunk = useCallback((audio) => {
+    const connection_1 = connectionRef.current;
+    if (!connection_1 || connection_1.suppressAudio) {
+      return;
+    }
+    connection_1.speaker ??= createSpeaker({
+      audioFormat: connection_1.audioFormat
+    });
+    connection_1.speaking = true;
+    setStatus("speaking");
+    connection_1.speaker.enqueue(audio);
+  }, [createSpeaker]);
+  const startCall = useCallback(async () => {
+    if (connectionRef.current || startingRef.current) {
+      return;
+    }
+    startingRef.current = true;
+    setError(void 0);
+    setTranscript("");
+    setInterimTranscript("");
+    try {
+      const url = voiceSocketUrl(client.url, agentNameFromReference(voice), threadKey);
+      const openSocket = createSocket ?? ((target) => {
+        const WebSocketImpl = client.getWebSocketImpl();
+        if (!WebSocketImpl) {
+          throw new Error("useVoiceAgent: no WebSocket implementation available (pass createSocket explicitly)");
+        }
+        return new WebSocketImpl(target);
+      });
+      const socket_0 = openSocket(url);
+      socket_0.binaryType = "arraybuffer";
+      const connection_2 = {
+        audioFormat: "mp3",
+        microphone: void 0,
+        socket: socket_0,
+        speaker: void 0,
+        speaking: false,
+        suppressAudio: false
+      };
+      connectionRef.current = connection_2;
+      socket_0.onmessage = (event) => {
+        if (typeof event.data === "string") {
+          try {
+            handleServerFrame(JSON.parse(event.data));
+          } catch {
+          }
+          return;
+        }
+        handleAudioChunk(new Uint8Array(event.data));
+      };
+      socket_0.onerror = () => {
+        setError(new Error("useVoiceAgent: voice socket error"));
+      };
+      socket_0.onclose = () => {
+        if (connectionRef.current === connection_2) {
+          teardown();
+        }
+      };
+      const microphone = await createMicrophone({
+        interruptChunks,
+        interruptThreshold,
+        isSpeaking: () => connectionRef.current?.speaking ?? false,
+        onAudio: (pcm) => {
+          if (socket_0.readyState === WS_OPEN) {
+            socket_0.send(pcm);
+          }
+        },
+        onInterrupt: () => {
+          sendFrame({
+            type: "interrupt"
+          });
+          connectionRef.current?.speaker?.interrupt();
+          if (connectionRef.current) {
+            connectionRef.current.speaking = false;
+            connectionRef.current.suppressAudio = true;
+          }
+          setStatus("listening");
+        },
+        onLevel: setAudioLevel,
+        onSilence: () => {
+          sendFrame({
+            type: "commit"
+          });
+          setStatus("thinking");
+        },
+        silenceDurationMs,
+        silenceThreshold
+      });
+      if (connectionRef.current === connection_2) {
+        connection_2.microphone = microphone;
+        setIsMuted(false);
+        setStatus("listening");
+      } else {
+        microphone.stop();
+      }
+    } catch (error_) {
+      setError(error_ instanceof Error ? error_ : new Error(String(error_)));
+      teardown();
+    } finally {
+      startingRef.current = false;
+    }
+  }, [client, createMicrophone, createSocket, handleAudioChunk, handleServerFrame, interruptChunks, interruptThreshold, sendFrame, silenceDurationMs, silenceThreshold, teardown, threadKey, voice]);
+  const toggleMute = useCallback(() => {
+    const next = !isMuted;
+    connectionRef.current?.microphone?.setMuted(next);
+    setIsMuted(next);
+    return next;
+  }, [isMuted]);
+  const sendText = useCallback((text) => {
+    if (sendFrame({
+      text,
+      type: "text"
+    })) {
+      setStatus("thinking");
+    }
+  }, [sendFrame]);
+  useEffect(() => teardown, [teardown]);
+  return {
+    audioLevel,
+    connected,
+    endCall,
+    error,
+    interimTranscript,
+    isMuted,
+    sendText,
+    startCall,
+    status,
+    toggleMute,
+    transcript
+  };
+};
+
+export { useVoiceAgent };

package/dist/packem_shared/wire-key-Bg8BJ8YM.mjs

@@ -0,0 +1,101 @@
+import { s as stableStringify } from './stable-key-DePnevIy.mjs';
+
+const toBase64 = (bytes) => {
+  let binary = "";
+  const chunk = 32768;
+  for (let index = 0; index < bytes.length; index += chunk) {
+    binary += String.fromCharCode(...bytes.subarray(index, index + chunk));
+  }
+  return btoa(binary);
+};
+
+const TAG = "$lunora.wire$";
+const MAX_DEPTH = 64;
+const encodeWire = (value, depth = 0) => {
+  if (depth > MAX_DEPTH) {
+    throw new RangeError(`wire-codec: value nesting exceeds the ${MAX_DEPTH}-level limit`);
+  }
+  if (value === void 0) {
+    return [TAG, "undefined"];
+  }
+  if (value === null) {
+    return null;
+  }
+  const kind = typeof value;
+  if (kind === "bigint") {
+    return [TAG, "bigint", value.toString()];
+  }
+  if (kind === "number") {
+    const numeric = value;
+    if (Number.isNaN(numeric)) {
+      return [TAG, "nan"];
+    }
+    if (numeric === Infinity) {
+      return [TAG, "inf"];
+    }
+    if (numeric === -Infinity) {
+      return [TAG, "-inf"];
+    }
+    return numeric;
+  }
+  if (kind !== "object") {
+    return value;
+  }
+  if (value instanceof Date) {
+    return [TAG, "date", encodeWire(value.getTime(), depth + 1)];
+  }
+  if (value instanceof Error) {
+    const error = value;
+    const properties = {};
+    for (const key of Object.keys(error)) {
+      if (error[key] !== void 0) {
+        properties[key] = encodeWire(error[key], depth + 1);
+      }
+    }
+    const encodedError = [TAG, "error", error.name, error.message, properties];
+    if (error.cause !== void 0) {
+      encodedError.push(encodeWire(error.cause, depth + 1));
+    }
+    return encodedError;
+  }
+  if (value instanceof URL) {
+    return [TAG, "url", value.href];
+  }
+  if (value instanceof Map) {
+    return [TAG, "map", [...value.entries()].map(([k, v]) => [encodeWire(k, depth + 1), encodeWire(v, depth + 1)])];
+  }
+  if (value instanceof Set) {
+    return [TAG, "set", [...value].map((item) => encodeWire(item, depth + 1))];
+  }
+  if (value instanceof ArrayBuffer) {
+    return [TAG, "bytes", toBase64(new Uint8Array(value)), "ArrayBuffer"];
+  }
+  if (ArrayBuffer.isView(value)) {
+    const view = value;
+    const ctorName = view.constructor.name;
+    const bytes = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+    return ctorName === "Uint8Array" ? [TAG, "bytes", toBase64(bytes)] : [TAG, "bytes", toBase64(bytes), ctorName];
+  }
+  if (Array.isArray(value)) {
+    const encoded = value.map((item) => encodeWire(item, depth + 1));
+    return encoded.length > 0 && encoded[0] === TAG ? [TAG, "arr", encoded] : encoded;
+  }
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== null && proto !== Object.prototype) {
+    const name = value.constructor?.name ?? "value";
+    throw new TypeError(`wire-codec: cannot encode a ${name} over the Lunora wire — only plain objects, arrays, and the supported built-ins (Date, Error, URL, Map, Set, ArrayBuffer/typed arrays, bigint) round-trip`);
+  }
+  const source = value;
+  const result = {};
+  for (const key of Object.keys(source)) {
+    const field = source[key];
+    if (field !== void 0) {
+      result[key] = encodeWire(field, depth + 1);
+    }
+  }
+  return result;
+};
+
+const stableWireKey = (value) => stableStringify(encodeWire(value));
+
+export { stableWireKey as s };

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/dist/server.mjs

@@ -1,7 +1,7 @@
 import { createServerClient } from '@lunora/client/ssr';
 export { createServerClient, deserializePreloaded, getServerSession, serializePreloaded } from '@lunora/client/ssr';
-import { l as lunoraQueryKey } from './packem_shared/query-key-C5rufkEE.mjs';
-export { lunoraQueryOptions } from './packem_shared/lunoraQueryOptions-CsuWzjg1.mjs';
+import { l as lunoraQueryKey } from './packem_shared/query-key-LGnArBTB.mjs';
+export { lunoraQueryOptions } from './packem_shared/lunoraQueryOptions-CefbPBId.mjs';
 export { preloadQuery, preloadedQueryResult } from '@lunora/client';
 export { HydrationBoundary, dehydrate } from '@tanstack/react-query';