@lunora/vue 1.0.0-alpha.4 → 1.0.0-alpha.40

package/dist/index.mjs

@@ -1,11 +1,19 @@
-export { AuthLoading, Authenticated, Unauthenticated } from './packem_shared/AuthLoading-_6-uOycE.mjs';
-export { hydratePreloaded } from './packem_shared/hydratePreloaded-rVY68iFv.mjs';
-export { LUNORA_INJECTION_KEY, createLunora, provideLunora, useLunora } from './packem_shared/LUNORA_INJECTION_KEY-DtFXLDQ_.mjs';
-export { useAuth } from './packem_shared/useAuth-C2aEzXXH.mjs';
-export { default as useConnectionStatus } from './packem_shared/useConnectionStatus-CDgduQYe.mjs';
-export { useMutation } from './packem_shared/useMutation-DWubV5pv.mjs';
-export { useInfiniteQuery, usePaginatedQuery } from './packem_shared/useInfiniteQuery-CEfbw7Nw.mjs';
-export { usePresence } from './packem_shared/usePresence-BeN5xaZM.mjs';
-export { subscribeToQuery, useQuery } from './packem_shared/subscribeToQuery-Cv5YL-SI.mjs';
+export { AuthLoading, Authenticated, Unauthenticated } from './packem_shared/AuthLoading-DKra8yfG.mjs';
+export { hydratePreloaded } from './packem_shared/hydratePreloaded-Cnd2GmG1.mjs';
+export { LUNORA_INJECTION_KEY, createLunora, provideLunora, useLunora } from './packem_shared/LUNORA_INJECTION_KEY-DQM5MgsC.mjs';
+export { useAgent } from './packem_shared/useAgent-TEp9OWs3.mjs';
+export { useAgentChat } from './packem_shared/useAgentChat-DQmekE-E.mjs';
+export { useAgentState } from './packem_shared/useAgentState-CeDpLTib.mjs';
+export { useAgentToolEvents } from './packem_shared/useAgentToolEvents-DfCy9INR.mjs';
+export { useAuth } from './packem_shared/useAuth-yXaaF-ro.mjs';
+export { default as useConnectionStatus } from './packem_shared/useConnectionStatus-DM_TOaW5.mjs';
+export { useFlag, useFlags } from './packem_shared/useFlag-B8Gq7oUu.mjs';
+export { useMutation } from './packem_shared/useMutation-BKIwT8Jk.mjs';
+export { useMutator } from './packem_shared/useMutator-B_Ahs_ZN.mjs';
+export { useInfiniteQuery, usePaginatedQuery } from './packem_shared/useInfiniteQuery-CMAUPQyd.mjs';
+export { usePresence } from './packem_shared/usePresence-Bg671Pt0.mjs';
+export { subscribeToQuery, useQuery } from './packem_shared/subscribeToQuery-hVYyvgOD.mjs';
 export { useRateLimit } from './packem_shared/useRateLimit-DlPWjcX1.mjs';
-export { useSubscription } from './packem_shared/useSubscription-Ol0AZFUv.mjs';
+export { useStream } from './packem_shared/useStream-DK2TNPo4.mjs';
+export { useSubscription } from './packem_shared/useSubscription-B2s-lc5e.mjs';
+export { useVoiceAgent } from './packem_shared/useVoiceAgent-DuNU5TE_.mjs';

package/dist/packem_shared/{AuthLoading-_6-uOycE.mjs → AuthLoading-DKra8yfG.mjs}

@@ -1,5 +1,5 @@
 import { defineComponent, computed } from 'vue';
-import { useAuth } from './useAuth-C2aEzXXH.mjs';
+import { useAuth } from './useAuth-yXaaF-ro.mjs';
 
 const Authenticated = defineComponent({
   name: "Authenticated",

package/dist/packem_shared/{LUNORA_INJECTION_KEY-DtFXLDQ_.mjs → LUNORA_INJECTION_KEY-DQM5MgsC.mjs}

@@ -1,3 +1,4 @@
+import { LunoraError } from '@lunora/errors';
 import { inject, provide } from 'vue';
 
 const LUNORA_INJECTION_KEY = /* @__PURE__ */ Symbol("lunora.client");
@@ -14,7 +15,10 @@ const provideLunora = (client) => {
 const useLunora = () => {
   const client = inject(LUNORA_INJECTION_KEY, void 0);
   if (!client) {
-    throw new Error("useLunora(): no LunoraClient provided — call app.use(createLunora(client)) or provideLunora(client) in a parent setup().");
+    throw new LunoraError(
+      "INTERNAL",
+      "useLunora(): no LunoraClient provided — call app.use(createLunora(client)) or provideLunora(client) in a parent setup()."
+    );
   }
   return client;
 };

package/dist/packem_shared/{hydratePreloaded-rVY68iFv.mjs → hydratePreloaded-Cnd2GmG1.mjs}

@@ -1,5 +1,5 @@
-import { useLunora } from './LUNORA_INJECTION_KEY-DtFXLDQ_.mjs';
-import { subscribeToQuery } from './subscribeToQuery-Cv5YL-SI.mjs';
+import { useLunora } from './LUNORA_INJECTION_KEY-DQM5MgsC.mjs';
+import { subscribeToQuery } from './subscribeToQuery-hVYyvgOD.mjs';
 
 const hydratePreloaded = (preloaded) => {
   const client = useLunora();

package/dist/packem_shared/stable-key-C8JHuJL7.mjs

@@ -0,0 +1,40 @@
+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/{subscribeToQuery-Cv5YL-SI.mjs → subscribeToQuery-hVYyvgOD.mjs}

@@ -1,6 +1,6 @@
 import { createQuerySubscription } from '@lunora/client/query';
 import { shallowRef, getCurrentScope, onScopeDispose, watch, toValue } from 'vue';
-import { useLunora } from './LUNORA_INJECTION_KEY-DtFXLDQ_.mjs';
+import { useLunora } from './LUNORA_INJECTION_KEY-DQM5MgsC.mjs';
 
 const subscribeToQuery = (client, function_, args, options = {}) => {
   const data = shallowRef(options.seed);

package/dist/packem_shared/useAgent-TEp9OWs3.mjs

@@ -0,0 +1,28 @@
+import { computed, toValue } from 'vue';
+import { useMutation } from './useMutation-BKIwT8Jk.mjs';
+import { useSubscription } from './useSubscription-B2s-lc5e.mjs';
+
+const NO_MUTATION_REF = { __lunoraRef: "" };
+const useAgent = (options) => {
+  const { api, cancel: cancelReference, run: runReference, runArgs, threadKey } = options;
+  const runMutation = useMutation(runReference);
+  const cancelMutation = useMutation(cancelReference ?? NO_MUTATION_REF);
+  const { data: threadData } = useSubscription(api.agents.agentThread, () => {
+    return { key: toValue(threadKey) };
+  });
+  const thread = computed(() => threadData.value);
+  const status = computed(() => thread.value?.status);
+  const run = async (input, arguments_) => {
+    await runMutation.mutate({ input, threadKey: toValue(threadKey), ...runArgs, ...arguments_ });
+  };
+  const cancel = async () => {
+    const instanceId = thread.value?.instanceId;
+    if (cancelReference === void 0 || instanceId === void 0) {
+      return;
+    }
+    await cancelMutation.mutate({ instanceId, threadKey: toValue(threadKey) });
+  };
+  return { cancel, pending: runMutation.pending, run, status, thread };
+};
+
+export { NO_MUTATION_REF, useAgent };

package/dist/packem_shared/useAgentChat-DQmekE-E.mjs

@@ -0,0 +1,108 @@
+import { ref, computed, toValue } from 'vue';
+import { NO_MUTATION_REF } from './useAgent-TEp9OWs3.mjs';
+import { useMutation } from './useMutation-BKIwT8Jk.mjs';
+import { useStream } from './useStream-DK2TNPo4.mjs';
+import { useSubscription } from './useSubscription-B2s-lc5e.mjs';
+
+const NO_STREAM_REF = { __lunoraRef: "" };
+const reconcileOptimistic = (optimistic, durable) => {
+  const durableUserRows = durable.filter((message) => message.role === "user");
+  const consumed = /* @__PURE__ */ new Set();
+  return optimistic.filter((pending) => {
+    for (let index = pending.durableUserCountAtSend; index < durableUserRows.length; index += 1) {
+      const row = durableUserRows[index];
+      if (row !== void 0 && !consumed.has(index) && row.content === pending.content) {
+        consumed.add(index);
+        return false;
+      }
+    }
+    return true;
+  });
+};
+const useAgentChat = (options) => {
+  const { api, cancel: cancelReference, limit, send: sendReference, sendArgs, stream: streamReference, threadKey } = options;
+  const { data: history } = useSubscription(api.agents.agentMessages, () => {
+    const key = toValue(threadKey);
+    return limit === void 0 ? { key } : { key, limit };
+  });
+  const { data: threadData } = useSubscription(api.agents.agentThread, () => {
+    return { key: toValue(threadKey) };
+  });
+  const streamArguments = streamReference === void 0 ? "skip" : () => {
+    return { key: toValue(threadKey) };
+  };
+  const { chunks } = useStream(streamReference ?? NO_STREAM_REF, streamArguments);
+  const sendMutation = useMutation(sendReference);
+  const cancelMutation = useMutation(cancelReference ?? NO_MUTATION_REF);
+  const approvalMutation = useMutation(api.agents.agentResolveApproval);
+  const optimistic = ref([]);
+  let nextId = 0;
+  const thread = computed(() => threadData.value);
+  const status = computed(() => thread.value?.status);
+  const durable = computed(() => history.value ?? []);
+  const messages = computed(() => {
+    const rows = durable.value;
+    const visible = reconcileOptimistic(optimistic.value, rows);
+    if (visible.length === 0) {
+      return rows;
+    }
+    let maxDurableSeq = -1;
+    for (const message of rows) {
+      if (message.seq > maxDurableSeq) {
+        maxDurableSeq = message.seq;
+      }
+    }
+    return [
+      ...rows,
+      ...visible.map((pending, index) => {
+        return {
+          content: pending.content,
+          optimistic: true,
+          role: "user",
+          seq: maxDurableSeq + 1 + index
+        };
+      })
+    ];
+  });
+  const streamingText = computed(() => {
+    const key = toValue(threadKey);
+    const assistantCount = durable.value.filter((message) => message.role === "assistant").length;
+    return chunks.value.filter((event) => event.kind !== "progress" && event.threadKey === key && event.turn >= assistantCount).map((delta) => delta.text).join("");
+  });
+  const send = async (input, arguments_) => {
+    const id = nextId;
+    nextId += 1;
+    const durableUserCountAtSend = durable.value.filter((message) => message.role === "user").length;
+    optimistic.value = [...reconcileOptimistic(optimistic.value, durable.value), { content: input, durableUserCountAtSend, id }];
+    try {
+      await sendMutation.mutate({ input, threadKey: toValue(threadKey), ...sendArgs, ...arguments_ });
+    } catch (error) {
+      optimistic.value = optimistic.value.filter((pending) => pending.id !== id);
+      throw error;
+    }
+  };
+  const approve = async (toolCallId, note) => {
+    const instanceId = thread.value?.instanceId;
+    if (instanceId === void 0) {
+      throw new Error("useAgentChat: cannot approve — no in-flight run (thread has no instanceId)");
+    }
+    await approvalMutation.mutate({ decision: "approve", instanceId, threadKey: toValue(threadKey), toolCallId, ...note === void 0 ? {} : { note } });
+  };
+  const reject = async (toolCallId, note) => {
+    const instanceId = thread.value?.instanceId;
+    if (instanceId === void 0) {
+      throw new Error("useAgentChat: cannot reject — no in-flight run (thread has no instanceId)");
+    }
+    await approvalMutation.mutate({ decision: "reject", instanceId, threadKey: toValue(threadKey), toolCallId, ...note === void 0 ? {} : { note } });
+  };
+  const cancel = async () => {
+    const instanceId = thread.value?.instanceId;
+    if (cancelReference === void 0 || instanceId === void 0) {
+      return;
+    }
+    await cancelMutation.mutate({ instanceId, threadKey: toValue(threadKey) });
+  };
+  return { approve, cancel, messages, reject, send, status, streamingText };
+};
+
+export { useAgentChat };

package/dist/packem_shared/useAgentState-CeDpLTib.mjs

@@ -0,0 +1,12 @@
+import { computed, toValue } from 'vue';
+import { useSubscription } from './useSubscription-B2s-lc5e.mjs';
+
+const useAgentState = (options) => {
+  const { data, error } = useSubscription(options.api.agents.agentState, () => {
+    return { key: toValue(options.threadKey) };
+  });
+  const state = computed(() => data.value);
+  return { error, state };
+};
+
+export { useAgentState };

package/dist/packem_shared/useAgentToolEvents-DfCy9INR.mjs

@@ -0,0 +1,62 @@
+import { computed, toValue } from 'vue';
+import { useStream } from './useStream-DK2TNPo4.mjs';
+import { useSubscription } from './useSubscription-B2s-lc5e.mjs';
+
+const NO_STREAM_REF = { __lunoraRef: "" };
+const EMPTY_MESSAGES = [];
+const toDurableEvent = (message) => {
+  if (message.role === "assistant" && message.toolCalls) {
+    return message.toolCalls.map((call) => {
+      return { input: call.input, seq: message.seq, toolCallId: call.id, toolName: call.name, type: "call" };
+    });
+  }
+  if (message.role !== "tool") {
+    return void 0;
+  }
+  if (message.status === "awaiting_approval") {
+    return [
+      {
+        seq: message.seq,
+        type: "awaiting-approval",
+        ...message.toolCallId === void 0 ? {} : { toolCallId: message.toolCallId },
+        ...message.toolName === void 0 ? {} : { toolName: message.toolName }
+      }
+    ];
+  }
+  return [
+    {
+      output: message.content,
+      seq: message.seq,
+      type: "result",
+      ...message.status === "approved" || message.status === "rejected" ? { status: message.status } : {},
+      ...message.toolCallId === void 0 ? {} : { toolCallId: message.toolCallId },
+      ...message.toolName === void 0 ? {} : { toolName: message.toolName }
+    }
+  ];
+};
+const useAgentToolEvents = (options) => {
+  const { api, limit, stream: streamReference, threadKey } = options;
+  const messagesArguments = () => {
+    const key = toValue(threadKey);
+    return limit === void 0 ? { key } : { key, limit };
+  };
+  const { data: history } = useSubscription(api.agents.agentMessages, messagesArguments);
+  const streamArguments = streamReference === void 0 ? "skip" : () => {
+    return { key: toValue(threadKey) };
+  };
+  const { chunks } = useStream(streamReference ?? NO_STREAM_REF, streamArguments);
+  const events = computed(() => {
+    const key = toValue(threadKey);
+    const durable = history.value ?? EMPTY_MESSAGES;
+    const derived = durable.flatMap((message) => toDurableEvent(message) ?? []);
+    for (const event of chunks.value) {
+      if (event.kind === "progress" && event.threadKey === key) {
+        derived.push({ data: event.data, toolCallId: event.toolCallId, type: "progress" });
+      }
+    }
+    return derived;
+  });
+  return { events };
+};
+
+export { useAgentToolEvents };

package/dist/packem_shared/{useAuth-C2aEzXXH.mjs → useAuth-yXaaF-ro.mjs}

@@ -1,6 +1,6 @@
 import { getIdentityStore } from '@lunora/client/auth';
 import { ref, onScopeDispose, readonly } from 'vue';
-import { useLunora } from './LUNORA_INJECTION_KEY-DtFXLDQ_.mjs';
+import { useLunora } from './LUNORA_INJECTION_KEY-DQM5MgsC.mjs';
 
 const useAuth = () => {
   const client = useLunora();

package/dist/packem_shared/{useConnectionStatus-CDgduQYe.mjs → useConnectionStatus-DM_TOaW5.mjs}

@@ -1,5 +1,5 @@
 import { shallowRef, getCurrentScope, onScopeDispose } from 'vue';
-import { useLunora } from './LUNORA_INJECTION_KEY-DtFXLDQ_.mjs';
+import { useLunora } from './LUNORA_INJECTION_KEY-DQM5MgsC.mjs';
 
 const useConnectionStatus = () => {
   const client = useLunora();

package/dist/packem_shared/useFlag-B8Gq7oUu.mjs

@@ -0,0 +1,70 @@
+import { shallowRef, watch, toValue } from 'vue';
+import { s as stableStringify } from './stable-key-C8JHuJL7.mjs';
+import { useLunora } from './LUNORA_INJECTION_KEY-DQM5MgsC.mjs';
+
+const FLAGS_EVAL_PATH = "__lunora_flags__:eval";
+const flagKind = (value) => {
+  const kind = typeof value;
+  if (kind === "boolean" || kind === "number" || kind === "string") {
+    return kind;
+  }
+  return "object";
+};
+const flagsReference = { __lunoraRef: FLAGS_EVAL_PATH };
+const serializeContext = (context) => context === void 0 ? "" : stableStringify(context);
+const useFlag = (key, defaultValue, context) => {
+  const client = useLunora();
+  const type = flagKind(defaultValue);
+  const value = shallowRef(defaultValue);
+  watch(
+    () => `${toValue(key)}\0${serializeContext(toValue(context))}`,
+    (_serialized, _previous, onCleanup) => {
+      const currentKey = toValue(key);
+      const currentContext = toValue(context);
+      value.value = defaultValue;
+      let unsubscribe;
+      try {
+        unsubscribe = client.subscribe(flagsReference, { context: currentContext, default: defaultValue, key: currentKey, type }, (next) => {
+          value.value = next;
+        });
+      } catch {
+        return;
+      }
+      onCleanup(unsubscribe);
+    },
+    { immediate: true }
+  );
+  return value;
+};
+const useFlags = (flags, context) => {
+  const client = useLunora();
+  const values = shallowRef(flags);
+  const spec = stableStringify(flags);
+  watch(
+    () => `${spec}\0${serializeContext(toValue(context))}`,
+    (_serialized, _previous, onCleanup) => {
+      const currentContext = toValue(context);
+      values.value = flags;
+      const unsubscribes = [];
+      for (const [key, defaultValue] of Object.entries(flags)) {
+        try {
+          unsubscribes.push(
+            client.subscribe(flagsReference, { context: currentContext, default: defaultValue, key, type: flagKind(defaultValue) }, (next) => {
+              values.value = { ...values.value, [key]: next };
+            })
+          );
+        } catch {
+        }
+      }
+      onCleanup(() => {
+        for (const unsubscribe of unsubscribes) {
+          unsubscribe();
+        }
+      });
+    },
+    { immediate: true }
+  );
+  return values;
+};
+
+export { useFlag, useFlags };

package/dist/packem_shared/{useInfiniteQuery-CEfbw7Nw.mjs → useInfiniteQuery-CMAUPQyd.mjs}

@@ -1,8 +1,109 @@
 import { shallowRef, watch, toValue, onScopeDispose, computed } from 'vue';
 import { initialPages, derivePaginationStatus, rebalance, applyLoadMore } from '@lunora/client/pagination';
-import { useLunora } from './LUNORA_INJECTION_KEY-DtFXLDQ_.mjs';
+import { s as stableStringify } from './stable-key-C8JHuJL7.mjs';
+import { useLunora } from './LUNORA_INJECTION_KEY-DQM5MgsC.mjs';
 
-const buildPageKey = (functionPath, pageArgs) => `${functionPath}::${JSON.stringify(pageArgs)}`;
+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));
+
+const buildPageKey = (functionPath, pageArgs) => `${functionPath}::${stableWireKey(pageArgs)}`;
 const buildPageArgs = (page, baseArgs) => {
   return {
     ...baseArgs,
@@ -14,6 +115,7 @@ const usePaginatedCore = (function_, args, options) => {
   const { initialNumItems, shardKey } = options;
   const pages = shallowRef(initialPages(initialNumItems));
   const pageResults = shallowRef([]);
+  let lastLoadMoreCursor;
   const activeSubs = /* @__PURE__ */ new Map();
   const resultsByKey = /* @__PURE__ */ new Map();
   const pendingPageKeys = /* @__PURE__ */ new Set();
@@ -49,6 +151,7 @@ const usePaginatedCore = (function_, args, options) => {
         entry.unsub();
         activeSubs.delete(originalKey);
         resultsByKey.delete(entry.currentKey);
+        pendingPageKeys.delete(entry.currentKey);
       }
     }
     const coveredKeys = new Set([...activeSubs.values()].map((subEntry) => subEntry.currentKey));
@@ -93,13 +196,16 @@ const usePaginatedCore = (function_, args, options) => {
     }
     activeSubs.clear();
     resultsByKey.clear();
+    pendingPageKeys.clear();
   };
   watch(
-    () => toValue(args),
-    (current) => {
+    () => stableWireKey(toValue(args)),
+    () => {
+      const current = toValue(args);
       teardownAll();
       pages.value = initialPages(initialNumItems);
       pageResults.value = [];
+      lastLoadMoreCursor = void 0;
       if (current !== "skip") {
         syncSubscriptions(pages.value, current);
         rebuildPageResults(pages.value, current);
@@ -135,10 +241,14 @@ const usePaginatedCore = (function_, args, options) => {
     if (currentStatus !== "CanLoadMore") {
       return;
     }
+    if (nextCursor === lastLoadMoreCursor) {
+      return;
+    }
     const next = applyLoadMore(pages.value, nextCursor, numberItems);
     if (!next) {
       return;
     }
+    lastLoadMoreCursor = nextCursor;
     const oldTail = pages.value.at(-1);
     const newPinnedPage = next.at(-2);
     if (oldTail && newPinnedPage) {

package/dist/packem_shared/{useMutation-DWubV5pv.mjs → useMutation-BKIwT8Jk.mjs}

@@ -1,6 +1,6 @@
 import { createMutationRunner } from '@lunora/client';
 import { shallowRef, ref } from 'vue';
-import { useLunora } from './LUNORA_INJECTION_KEY-DtFXLDQ_.mjs';
+import { useLunora } from './LUNORA_INJECTION_KEY-DQM5MgsC.mjs';
 
 const useMutation = (function_) => {
   const client = useLunora();

package/dist/packem_shared/useMutator-B_Ahs_ZN.mjs

@@ -0,0 +1,19 @@
+import { createMutatorRunner } from '@lunora/client';
+import { shallowRef, computed } from 'vue';
+
+const useMutator = (handle) => {
+  const error = shallowRef(void 0);
+  const pending = shallowRef(false);
+  const isError = computed(() => error.value !== void 0);
+  const { mutate, reset } = createMutatorRunner(handle, {
+    setError: (value) => {
+      error.value = value;
+    },
+    setPending: (value) => {
+      pending.value = value;
+    }
+  });
+  return { error, isError, mutate, pending, reset };
+};
+
+export { useMutator };