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

package/dist/index.mjs

@@ -1,17 +1,29 @@
 'use client';
-export { AuthLoading, Authenticated, Unauthenticated } from './packem_shared/AuthLoading-DtKgZT2Z.mjs';
-export { useAuthState } from './packem_shared/useAuthState-BiGhtSCs.mjs';
-export { LunoraProvider, useLunora } from './packem_shared/LunoraProvider-D38Xp16l.mjs';
-export { CheckoutButton, CustomerPortalButton, useCheckout } from './packem_shared/CheckoutButton-CVSry8U1.mjs';
-export { lunoraQueryOptions } from './packem_shared/lunoraQueryOptions-CsuWzjg1.mjs';
-export { default as useAuth } from './packem_shared/useAuth-CNUKtOOp.mjs';
-export { default as useConnectionStatus } from './packem_shared/useConnectionStatus-DRSY9ldm.mjs';
-export { default as useInfiniteQuery } from './packem_shared/useInfiniteQuery-MH0x4l8h.mjs';
-export { useMutation } from './packem_shared/useMutation-CrvMXRsk.mjs';
-export { usePaginatedQuery } from './packem_shared/usePaginatedQuery-D3PTDRGS.mjs';
-export { hydratePreloaded, default as usePreloadedQuery } from './packem_shared/hydratePreloaded-BlFL9FGq.mjs';
-export { usePresence } from './packem_shared/usePresence-D7jLuxj0.mjs';
-export { default as useQuery } from './packem_shared/useQuery-C5S0W-7K.mjs';
+export { AuthLoading, Authenticated, Unauthenticated } from './packem_shared/AuthLoading-DezUWNB2.mjs';
+export { useAuthState } from './packem_shared/useAuthState-CyF35qZR.mjs';
+export { LunoraProvider, useLunora } from './packem_shared/LunoraProvider-BsuiW4Lk.mjs';
+export { CheckoutButton, CustomerPortalButton, useCheckout } from './packem_shared/CheckoutButton-DUite8jJ.mjs';
+export { lunoraQueryOptions } from './packem_shared/lunoraQueryOptions-CefbPBId.mjs';
+export { useAgent } from './packem_shared/useAgent-BNLlIYHz.mjs';
+export { useAgentChat } from './packem_shared/useAgentChat-0cebQe7-.mjs';
+export { useAgentState } from './packem_shared/useAgentState-Cqyd3Dfy.mjs';
+export { useAgentToolEvents } from './packem_shared/useAgentToolEvents-gF7U4_KY.mjs';
+export { default as useAuth } from './packem_shared/useAuth-BSutjJaa.mjs';
+export { default as useClientQuery } from './packem_shared/useClientQuery-DIkNT4QA.mjs';
+export { default as useConnectionStatus } from './packem_shared/useConnectionStatus-PJ7vyCHy.mjs';
+export { useFlag, useFlags } from './packem_shared/useFlag-Beyeiq2b.mjs';
+export { useHttpStream } from './packem_shared/useHttpStream-oc4s1pMy.mjs';
+export { default as useInfiniteQuery } from './packem_shared/useInfiniteQuery-CJNw1XaZ.mjs';
+export { useMutation } from './packem_shared/useMutation-BeqeIjTr.mjs';
+export { useMutator } from './packem_shared/useMutator-IIrLtDiM.mjs';
+export { usePaginatedQuery } from './packem_shared/usePaginatedQuery-DWzydaVR.mjs';
+export { hydratePreloaded, default as usePreloadedQuery } from './packem_shared/hydratePreloaded-2omLtadR.mjs';
+export { usePresence } from './packem_shared/usePresence-Rnx1Fznc.mjs';
+export { default as useQuery } from './packem_shared/useQuery-CE8_QUgh.mjs';
 export { useRateLimit } from './packem_shared/useRateLimit-DTEffQEi.mjs';
-export { useStream } from './packem_shared/useStream-BRY9nemd.mjs';
-export { default as useSubscription } from './packem_shared/useSubscription-CHMCjyQg.mjs';
+export { useStream } from './packem_shared/useStream-GYNgc9J5.mjs';
+export { default as useSubscription } from './packem_shared/useSubscription-DcDlvVuI.mjs';
+export { useVoiceAgent } from './packem_shared/useVoiceAgent-w7fzAMSB.mjs';
+export { createClientQuery, getErrorCode, getRetryAfterMs, isConflictError, isForbiddenError, isRateLimitedError, isUnauthorizedError } from '@lunora/client';
+export { RestrictionError, UploadControl, UploadError } from '@visulima/storage-client';
+export { useChunkedRestUpload, useFileInput, useMultipartUpload, usePasteUpload, useTusUpload, useUpload } from '@visulima/storage-client/react';

package/dist/packem_shared/{AuthLoading-DtKgZT2Z.mjs → AuthLoading-DezUWNB2.mjs}

@@ -1,5 +1,5 @@
 'use client';
-import { useAuthState } from './useAuthState-BiGhtSCs.mjs';
+import { useAuthState } from './useAuthState-CyF35qZR.mjs';
 
 const Authenticated = (t0) => {
   const {

package/dist/packem_shared/{CheckoutButton-CVSry8U1.mjs → CheckoutButton-DUite8jJ.mjs}

@@ -3,6 +3,13 @@ import { c } from 'react/compiler-runtime';
 import { useState, useCallback } from 'react';
 import { jsxDEV } from 'react/jsx-dev-runtime';
 
+const safeRedirectHref = (url) => {
+  const parsed = new URL(url, globalThis.location.href);
+  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+    throw new Error(`refusing to redirect to a non-http(s) URL: ${parsed.protocol}`);
+  }
+  return parsed.href;
+};
 const useCheckout = (trigger) => {
   const [pending, setPending] = useState(false);
   const [error, setError] = useState(void 0);
@@ -11,10 +18,7 @@ const useCheckout = (trigger) => {
     setError(void 0);
     try {
       const target = await trigger();
-      const {
-        url
-      } = target;
-      globalThis.location.assign(url);
+      globalThis.location.assign(safeRedirectHref(target.url));
     } catch (error_) {
       const normalized = error_ instanceof Error ? error_ : new Error(String(error_));
       setError(normalized);

package/dist/packem_shared/{LunoraProvider-D38Xp16l.mjs → LunoraProvider-BsuiW4Lk.mjs}

@@ -1,5 +1,6 @@
 'use client';
 import { c } from 'react/compiler-runtime';
+import { LunoraError } from '@lunora/errors';
 import { QueryClientContext, QueryClientProvider, QueryClient } from '@tanstack/react-query';
 import { use, useState, createContext } from 'react';
 import { jsxDEV } from 'react/jsx-dev-runtime';
@@ -37,7 +38,7 @@ const LunoraProvider = (t0) => {
   const [internalClient] = useState(t1);
   const effectiveClient = queryClient ?? parentQueryClient ?? internalClient;
   if (!effectiveClient) {
-    throw new Error("LunoraProvider: failed to resolve a QueryClient");
+    throw new LunoraError("INTERNAL", "LunoraProvider: failed to resolve a QueryClient");
   }
   let t2;
   if ($[3] !== children || $[4] !== client) {
@@ -72,7 +73,7 @@ const LunoraProvider = (t0) => {
 const useLunora = () => {
   const client = use(LunoraContext);
   if (!client) {
-    throw new Error("useLunora must be used inside <LunoraProvider />");
+    throw new LunoraError("INTERNAL", "useLunora must be used inside <LunoraProvider />");
   }
   return client;
 };

package/dist/packem_shared/{cache-CItk3fgN.mjs → cache-JeuDAXfE.mjs}

@@ -1,4 +1,4 @@
-import { k as keyHash } from './query-key-C5rufkEE.mjs';
+import { k as keyHash } from './query-key-LGnArBTB.mjs';
 
 class LunoraSubscriptionRegistry {
   constructor(client) {
@@ -46,7 +46,12 @@ class LunoraSubscriptionRegistry {
       }
     }
     entry.refCount += 1;
+    let detached = false;
     return () => {
+      if (detached) {
+        return;
+      }
+      detached = true;
       const current = this.entries.get(key);
       if (!current) {
         return;

package/dist/packem_shared/hydratePreloaded-2omLtadR.mjs

@@ -0,0 +1,54 @@
+'use client';
+import { c } from 'react/compiler-runtime';
+import { useQueryClient, useQuery } from '@tanstack/react-query';
+import { useEffect } from 'react';
+import { g as getSubscriptionRegistry } from './cache-JeuDAXfE.mjs';
+import { useLunora } from './LunoraProvider-BsuiW4Lk.mjs';
+import { s as serializeQueryKey, l as lunoraQueryKey } from './query-key-LGnArBTB.mjs';
+
+const usePreloadedQuery = function(preloaded) {
+  const $ = c(4);
+  const client = useLunora();
+  const queryClient = useQueryClient();
+  const {
+    args,
+    functionPath,
+    shardKey,
+    value
+  } = preloaded;
+  const functionRef = {
+    __lunoraRef: functionPath
+  };
+  const queryKey = lunoraQueryKey(functionRef, args, shardKey);
+  const {
+    data
+  } = useQuery({
+    initialData: value,
+    queryFn: () => client.query(functionRef, args, {
+      shardKey
+    }),
+    queryKey,
+    staleTime: Number.POSITIVE_INFINITY
+  });
+  const t0 = serializeQueryKey(queryKey);
+  let t1;
+  if ($[0] !== client || $[1] !== queryClient || $[2] !== t0) {
+    t1 = [client, queryClient, t0];
+    $[0] = client;
+    $[1] = queryClient;
+    $[2] = t0;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  useEffect(() => {
+    const registry = getSubscriptionRegistry(client);
+    return registry.attach(queryClient, queryKey, functionRef, args, shardKey);
+  }, t1);
+  return data === void 0 ? value : data;
+};
+const hydratePreloaded = function(preloaded) {
+  return usePreloadedQuery(preloaded);
+};
+
+export { usePreloadedQuery as default, hydratePreloaded };

package/dist/packem_shared/{lunoraQueryOptions-CsuWzjg1.mjs → lunoraQueryOptions-CefbPBId.mjs}

@@ -1,4 +1,4 @@
-import { l as lunoraQueryKey } from './query-key-C5rufkEE.mjs';
+import { l as lunoraQueryKey } from './query-key-LGnArBTB.mjs';
 
 const lunoraQueryOptions = (client, function_, args, options = {}) => {
   const argsRecord = args ?? {};

package/dist/packem_shared/query-key-LGnArBTB.mjs

@@ -0,0 +1,13 @@
+import { s as stableWireKey } from './wire-key-Bg8BJ8YM.mjs';
+
+const keyHash = (queryKey) => stableWireKey(queryKey);
+const lunoraQueryKey = (function_, args, shardKey) => [
+  "lunora",
+  function_.__lunoraRef,
+  args,
+  // eslint-disable-next-line unicorn/no-null -- this literal is part of the JSON-serialized query key TanStack hashes for dedup; `null` keeps a stable, distinct slot from an absent shardKey across renders.
+  shardKey ?? null
+];
+const serializeQueryKey = (queryKey) => keyHash(queryKey);
+
+export { keyHash as k, lunoraQueryKey as l, serializeQueryKey as s };

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/packem_shared/stable-key-DePnevIy.mjs

@@ -0,0 +1,38 @@
+const compareKeys = (a, b) => {
+  if (a < b) {
+    return -1;
+  }
+  return a > b ? 1 : 0;
+};
+const stableStringify = (value) => {
+  if (value === void 0) {
+    return "null";
+  }
+  if (typeof value === "bigint") {
+    throw new TypeError("stableStringify: cannot use a bigint in a stable JSON cache key — pass it as a string, or use stableWireKey");
+  }
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== null && proto !== Object.prototype) {
+    const name = value.constructor?.name ?? "value";
+    throw new TypeError(`stableStringify: cannot use a ${name} in a stable JSON cache key — only plain objects, arrays, and JSON primitives are supported (wire-typed values key via stableWireKey)`);
+  }
+  const record = value;
+  const keys = Object.keys(record).toSorted(compareKeys);
+  const parts = [];
+  for (const key of keys) {
+    const raw = record[key];
+    if (raw === void 0) {
+      continue;
+    }
+    parts.push(`${JSON.stringify(key)}:${stableStringify(raw)}`);
+  }
+  return `{${parts.join(",")}}`;
+};
+
+export { stableStringify as s };

package/dist/packem_shared/{use-paginated-core-CoOfcc-p.mjs → use-paginated-core-xxvd1YA0.mjs}

@@ -2,9 +2,9 @@
 import { initialPages, rebalance, derivePaginationStatus, applyLoadMore } from '@lunora/client/pagination';
 import { useQueryClient } from '@tanstack/react-query';
 import { useRef, useReducer, useState, useEffect, useCallback } from 'react';
-import { g as getSubscriptionRegistry } from './cache-CItk3fgN.mjs';
-import { useLunora } from './LunoraProvider-D38Xp16l.mjs';
-import { s as serializeQueryKey, l as lunoraQueryKey } from './query-key-C5rufkEE.mjs';
+import { g as getSubscriptionRegistry } from './cache-JeuDAXfE.mjs';
+import { useLunora } from './LunoraProvider-BsuiW4Lk.mjs';
+import { s as serializeQueryKey, l as lunoraQueryKey } from './query-key-LGnArBTB.mjs';
 
 const useLazyRef = function(create) {
   const reference = useRef(void 0);
@@ -21,10 +21,9 @@ const usePaginatedCore = function(function_, args, options) {
   } = options;
   const skipped = args === "skip";
   const baseArgs = skipped ? {} : args;
-  const baseArgsKey = JSON.stringify(baseArgs);
   const [, forceRender] = useReducer((tick) => tick + 1, 0);
   const [pages, setPages] = useState(() => initialPages(initialNumItems));
-  const resetKey = `${function_.__lunoraRef}::${baseArgsKey}::${String(initialNumItems)}::${shardKey ?? ""}`;
+  const resetKey = `${serializeQueryKey(lunoraQueryKey(function_, baseArgs, shardKey))}::${String(initialNumItems)}`;
   const resetKeyRef = useRef(resetKey);
   if (resetKeyRef.current !== resetKey) {
     resetKeyRef.current = resetKey;
@@ -49,12 +48,14 @@ const usePaginatedCore = function(function_, args, options) {
     key: key_0
   }) => serializeQueryKey(key_0)).join("|");
   const desiredRef = useRef({
+    baseArgs,
     entries: [],
     fn: function_,
     shardKey
   });
   useEffect(() => {
     desiredRef.current = {
+      baseArgs,
       entries: pageEntries,
       fn: function_,
       shardKey
@@ -106,12 +107,16 @@ const usePaginatedCore = function(function_, args, options) {
       detaches.set(hash_0, registry.attach(queryClient, entry.key, desired.fn, entry.args, desired.shardKey));
     }
   }, [client, queryClient, pageKeysHash, skipped]);
-  useEffect(() => () => {
-    for (const detach_2 of detachesRef.current.values()) {
-      detach_2();
-    }
-    detachesRef.current.clear();
-  }, []);
+  useEffect(
+    () => () => {
+      for (const detach_2 of detachesRef.current.values()) {
+        detach_2();
+      }
+      detachesRef.current.clear();
+    },
+    // react-doctor-disable-next-line react-doctor/exhaustive-deps -- intentional: unmount-only cleanup. `detachesRef` is a stable ref, so the empty dep array is correct — the teardown must run once on unmount, not every render.
+    []
+  );
   useEffect(() => {
     const cache = queryClient.getQueryCache();
     const unsubscribe = cache.subscribe((event) => {
@@ -140,17 +145,30 @@ const usePaginatedCore = function(function_, args, options) {
     }
   });
   const {
-    nextCursor,
     status
   } = derivePaginationStatus(skipped, pageResults);
-  const nextCursorRef = useRef(void 0);
-  useEffect(() => {
-    nextCursorRef.current = status === "CanLoadMore" ? nextCursor : void 0;
-  });
   const loadMore = useCallback((numberItems) => {
-    const cursor = nextCursorRef.current;
-    setPages((current) => applyLoadMore(current, cursor, numberItems) ?? current);
-  }, []);
+    setPages((current) => {
+      const desired_0 = desiredRef.current;
+      const results = current.map((page_0) => {
+        const pageArgs_0 = {
+          ...desired_0.baseArgs,
+          paginationOpts: {
+            cursor: page_0.lower,
+            endCursor: page_0.upper,
+            numItems: page_0.numItems
+          }
+        };
+        return queryClient.getQueryData(lunoraQueryKey(desired_0.fn, pageArgs_0, desired_0.shardKey));
+      });
+      const {
+        nextCursor,
+        status: liveStatus
+      } = derivePaginationStatus(false, results);
+      const cursor = liveStatus === "CanLoadMore" ? nextCursor : void 0;
+      return applyLoadMore(current, cursor, numberItems) ?? current;
+    });
+  }, [queryClient]);
   return {
     loadMore,
     pageResults,

package/dist/packem_shared/useAgent-BNLlIYHz.mjs

@@ -0,0 +1,101 @@
+'use client';
+import { c } from 'react/compiler-runtime';
+import { useMutation } from './useMutation-BeqeIjTr.mjs';
+import useSubscription from './useSubscription-DcDlvVuI.mjs';
+
+const NO_MUTATION_REF = {
+  __lunoraRef: ""
+};
+const useAgent = (options) => {
+  const $ = c(17);
+  const {
+    api,
+    cancel: cancelReference,
+    run: runReference,
+    runArgs,
+    threadKey
+  } = options;
+  const runMutation = useMutation(runReference);
+  const cancelMutation = useMutation(cancelReference ?? NO_MUTATION_REF);
+  let t0;
+  if ($[0] !== threadKey) {
+    t0 = {
+      key: threadKey
+    };
+    $[0] = threadKey;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const {
+    data: threadData
+  } = useSubscription(api.agents.agentThread, t0);
+  const thread = threadData;
+  const status = thread?.status;
+  const instanceId = thread?.instanceId;
+  const {
+    mutate: runMutate
+  } = runMutation;
+  const {
+    mutate: cancelMutate
+  } = cancelMutation;
+  let t1;
+  if ($[2] !== runArgs || $[3] !== runMutate || $[4] !== threadKey) {
+    t1 = async (input, args) => {
+      await runMutate({
+        input,
+        threadKey,
+        ...runArgs,
+        ...args
+      });
+    };
+    $[2] = runArgs;
+    $[3] = runMutate;
+    $[4] = threadKey;
+    $[5] = t1;
+  } else {
+    t1 = $[5];
+  }
+  const run = t1;
+  let t2;
+  if ($[6] !== cancelMutate || $[7] !== cancelReference || $[8] !== instanceId || $[9] !== threadKey) {
+    t2 = async () => {
+      if (cancelReference === void 0 || instanceId === void 0) {
+        return;
+      }
+      await cancelMutate({
+        instanceId,
+        threadKey
+      });
+    };
+    $[6] = cancelMutate;
+    $[7] = cancelReference;
+    $[8] = instanceId;
+    $[9] = threadKey;
+    $[10] = t2;
+  } else {
+    t2 = $[10];
+  }
+  const cancel = t2;
+  let t3;
+  if ($[11] !== cancel || $[12] !== run || $[13] !== runMutation.pending || $[14] !== status || $[15] !== thread) {
+    t3 = {
+      cancel,
+      pending: runMutation.pending,
+      run,
+      status,
+      thread
+    };
+    $[11] = cancel;
+    $[12] = run;
+    $[13] = runMutation.pending;
+    $[14] = status;
+    $[15] = thread;
+    $[16] = t3;
+  } else {
+    t3 = $[16];
+  }
+  return t3;
+};
+
+export { useAgent };