@lunora/angular 0.0.1 → 1.0.0-alpha.10

package/dist/index.mjs

@@ -0,0 +1,19 @@
+export { agent } from './packem_shared/agent-DDKvrG4u.mjs';
+export { agentChat } from './packem_shared/agentChat-DDZlxK1v.mjs';
+export { agentState } from './packem_shared/agentState-C8GWf3t3.mjs';
+export { agentToolEvents } from './packem_shared/agentToolEvents-sXgYggvi.mjs';
+export { auth } from './packem_shared/auth-Df9N87Z4.mjs';
+export { LUNORA_CLIENT, injectLunoraClient, provideLunora } from './packem_shared/LUNORA_CLIENT-DHUfNu9x.mjs';
+export { connectionStatus } from './packem_shared/connectionStatus-BlLodleK.mjs';
+export { flag, flags } from './packem_shared/flag-CGBo90HJ.mjs';
+export { hydratePreloaded } from './packem_shared/hydratePreloaded-DIpD1cAM.mjs';
+export { liveQuery } from './packem_shared/liveQuery-DVxKidjM.mjs';
+export { mutate } from './packem_shared/mutate-D3rEHwbb.mjs';
+export { mutator } from './packem_shared/mutator-BHL8bakL.mjs';
+export { infiniteQuery, paginatedQuery } from './packem_shared/infiniteQuery-nboKfr5E.mjs';
+export { presence } from './packem_shared/presence-BTuq19dS.mjs';
+export { rateLimit } from './packem_shared/rateLimit-I4kRT9qV.mjs';
+export { stream } from './packem_shared/stream-PL64AghO.mjs';
+export { subscription } from './packem_shared/subscription-oZ-WTmpp.mjs';
+export { voiceAgent } from './packem_shared/voiceAgent-DwbrDnB9.mjs';
+export { SKIP } from '@lunora/client/query';

package/dist/packem_shared/LUNORA_CLIENT-DHUfNu9x.mjs

@@ -0,0 +1,23 @@
+import { InjectionToken, makeEnvironmentProviders, inject } from '@angular/core';
+import { LunoraClient } from '@lunora/client';
+
+const sameOriginUrl = () => globalThis.location?.origin ?? "";
+const LUNORA_CLIENT = new InjectionToken("lunora.client", {
+  factory: () => new LunoraClient({ url: sameOriginUrl() }),
+  providedIn: "root"
+});
+const provideLunora = (optionsOrClient = {}) => makeEnvironmentProviders([
+  {
+    provide: LUNORA_CLIENT,
+    useFactory: () => {
+      if (optionsOrClient instanceof LunoraClient) {
+        return optionsOrClient;
+      }
+      return new LunoraClient({ ...optionsOrClient, url: optionsOrClient.url ?? sameOriginUrl() });
+    }
+  }
+]);
+const injectLunoraClient = () => inject(LUNORA_CLIENT);
+const resolveLunoraClient = (client) => client ?? injectLunoraClient();
+
+export { LUNORA_CLIENT, injectLunoraClient, provideLunora, resolveLunoraClient };

package/dist/packem_shared/agent-DDKvrG4u.mjs

@@ -0,0 +1,31 @@
+import { inject, DestroyRef, computed, signal } from '@angular/core';
+import { resolveLunoraClient } from './LUNORA_CLIENT-DHUfNu9x.mjs';
+import { subscription } from './subscription-oZ-WTmpp.mjs';
+
+const agent = (options) => {
+  const { api, cancel: cancelReference, run: runReference, runArgs, threadKey } = options;
+  const client = resolveLunoraClient(options.client);
+  const destroyRef = options.destroyRef ?? inject(DestroyRef);
+  const { data: threadData } = subscription(api.agents.agentThread, { key: threadKey }, { client, destroyRef });
+  const thread = computed(() => threadData());
+  const status = computed(() => thread()?.status);
+  const pending = signal(false);
+  const run = async (input, arguments_) => {
+    pending.set(true);
+    try {
+      await client.mutation(runReference, { input, threadKey, ...runArgs, ...arguments_ });
+    } finally {
+      pending.set(false);
+    }
+  };
+  const cancel = async () => {
+    const instanceId = thread()?.instanceId;
+    if (cancelReference === void 0 || instanceId === void 0) {
+      return;
+    }
+    await client.mutation(cancelReference, { instanceId, threadKey });
+  };
+  return { cancel, pending: pending.asReadonly(), run, status, thread };
+};
+
+export { agent };

package/dist/packem_shared/agentChat-DDZlxK1v.mjs

@@ -0,0 +1,111 @@
+import { inject, DestroyRef, signal, computed } from '@angular/core';
+import { resolveLunoraClient } from './LUNORA_CLIENT-DHUfNu9x.mjs';
+import { stream } from './stream-PL64AghO.mjs';
+import { subscription } from './subscription-oZ-WTmpp.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 agentChat = (options) => {
+  const { api, cancel: cancelReference, limit, send: sendReference, sendArgs, stream: streamReference, threadKey } = options;
+  const client = resolveLunoraClient(options.client);
+  const destroyRef = options.destroyRef ?? inject(DestroyRef);
+  const messagesArguments = limit === void 0 ? { key: threadKey } : { key: threadKey, limit };
+  const { data: history } = subscription(api.agents.agentMessages, messagesArguments, { client, destroyRef });
+  const { data: threadData } = subscription(api.agents.agentThread, { key: threadKey }, { client, destroyRef });
+  const streamArguments = streamReference === void 0 ? "skip" : { key: threadKey };
+  const { chunks } = stream(streamReference ?? NO_STREAM_REF, streamArguments, { client, destroyRef });
+  const optimistic = signal([]);
+  let nextId = 0;
+  const thread = computed(() => threadData());
+  const status = computed(() => thread()?.status);
+  const durable = computed(() => history() ?? []);
+  const messages = computed(() => {
+    const rows = durable();
+    const visible = reconcileOptimistic(optimistic(), 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 assistantCount = durable().filter((message) => message.role === "assistant").length;
+    return chunks().filter((event) => event.kind !== "progress" && event.threadKey === threadKey && event.turn >= assistantCount).map((delta) => delta.text).join("");
+  });
+  const send = async (input, arguments_) => {
+    const id = nextId;
+    nextId += 1;
+    const durableUserCountAtSend = durable().filter((message) => message.role === "user").length;
+    optimistic.set([...reconcileOptimistic(optimistic(), durable()), { content: input, durableUserCountAtSend, id }]);
+    try {
+      await client.mutation(sendReference, { input, threadKey, ...sendArgs, ...arguments_ });
+    } catch (error) {
+      optimistic.set(optimistic().filter((pending) => pending.id !== id));
+      throw error;
+    }
+  };
+  const approve = async (toolCallId, note) => {
+    const instanceId = thread()?.instanceId;
+    if (instanceId === void 0) {
+      throw new Error("agentChat: cannot approve — no in-flight run (thread has no instanceId)");
+    }
+    await client.mutation(api.agents.agentResolveApproval, {
+      decision: "approve",
+      instanceId,
+      threadKey,
+      toolCallId,
+      ...note === void 0 ? {} : { note }
+    });
+  };
+  const reject = async (toolCallId, note) => {
+    const instanceId = thread()?.instanceId;
+    if (instanceId === void 0) {
+      throw new Error("agentChat: cannot reject — no in-flight run (thread has no instanceId)");
+    }
+    await client.mutation(api.agents.agentResolveApproval, {
+      decision: "reject",
+      instanceId,
+      threadKey,
+      toolCallId,
+      ...note === void 0 ? {} : { note }
+    });
+  };
+  const cancel = async () => {
+    const instanceId = thread()?.instanceId;
+    if (cancelReference === void 0 || instanceId === void 0) {
+      return;
+    }
+    await client.mutation(cancelReference, { instanceId, threadKey });
+  };
+  return { approve, cancel, messages, reject, send, status, streamingText };
+};
+
+export { agentChat };

package/dist/packem_shared/agentState-C8GWf3t3.mjs

@@ -0,0 +1,10 @@
+import { computed } from '@angular/core';
+import { subscription } from './subscription-oZ-WTmpp.mjs';
+
+const agentState = (options) => {
+  const { data, error } = subscription(options.api.agents.agentState, { key: options.threadKey }, { client: options.client, destroyRef: options.destroyRef });
+  const state = computed(() => data());
+  return { error, state };
+};
+
+export { agentState };

package/dist/packem_shared/agentToolEvents-sXgYggvi.mjs

@@ -0,0 +1,59 @@
+import { inject, DestroyRef, computed } from '@angular/core';
+import { resolveLunoraClient } from './LUNORA_CLIENT-DHUfNu9x.mjs';
+import { stream } from './stream-PL64AghO.mjs';
+import { subscription } from './subscription-oZ-WTmpp.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 agentToolEvents = (options) => {
+  const { api, limit, stream: streamReference, threadKey } = options;
+  const client = resolveLunoraClient(options.client);
+  const destroyRef = options.destroyRef ?? inject(DestroyRef);
+  const messagesArguments = limit === void 0 ? { key: threadKey } : { key: threadKey, limit };
+  const { data: history } = subscription(api.agents.agentMessages, messagesArguments, { client, destroyRef });
+  const streamArguments = streamReference === void 0 ? "skip" : { key: threadKey };
+  const { chunks } = stream(streamReference ?? NO_STREAM_REF, streamArguments, { client, destroyRef });
+  const events = computed(() => {
+    const durable = history() ?? EMPTY_MESSAGES;
+    const derived = durable.flatMap((message) => toDurableEvent(message) ?? []);
+    for (const event of chunks()) {
+      if (event.kind === "progress" && event.threadKey === threadKey) {
+        derived.push({ data: event.data, toolCallId: event.toolCallId, type: "progress" });
+      }
+    }
+    return derived;
+  });
+  return { events };
+};
+
+export { agentToolEvents };

package/dist/packem_shared/auth-Df9N87Z4.mjs

@@ -0,0 +1,27 @@
+import { inject, DestroyRef, signal } from '@angular/core';
+import { getIdentityStore } from '@lunora/client/auth';
+import { resolveLunoraClient } from './LUNORA_CLIENT-DHUfNu9x.mjs';
+
+const auth = (options = {}) => {
+  const client = resolveLunoraClient(options.client);
+  const destroyRef = options.destroyRef ?? inject(DestroyRef);
+  const store = getIdentityStore(client);
+  const token = signal(client.getAuthToken());
+  const user = signal(store.getUser());
+  const unsubToken = client.onAuthTokenChange(() => {
+    token.set(client.getAuthToken());
+  });
+  const unsubUser = store.subscribe(() => {
+    user.set(store.getUser());
+  });
+  destroyRef.onDestroy(() => {
+    unsubToken();
+    unsubUser();
+  });
+  const setToken = (next) => {
+    client.setAuthToken(next);
+  };
+  return { setToken, token: token.asReadonly(), user: user.asReadonly() };
+};
+
+export { auth };

package/dist/packem_shared/connectionStatus-BlLodleK.mjs

@@ -0,0 +1,15 @@
+import { inject, DestroyRef, signal } from '@angular/core';
+import { resolveLunoraClient } from './LUNORA_CLIENT-DHUfNu9x.mjs';
+
+const connectionStatus = (options = {}) => {
+  const client = resolveLunoraClient(options.client);
+  const destroyRef = options.destroyRef ?? inject(DestroyRef);
+  const status = signal(client.connectionStatus());
+  const unsubscribe = client.onConnectionStatus((next) => {
+    status.set(next);
+  });
+  destroyRef.onDestroy(unsubscribe);
+  return status.asReadonly();
+};
+
+export { connectionStatus };

package/dist/packem_shared/flag-CGBo90HJ.mjs

@@ -0,0 +1,70 @@
+import { inject, DestroyRef, signal } from '@angular/core';
+import { resolveLunoraClient } from './LUNORA_CLIENT-DHUfNu9x.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 flag = (key, defaultValue, options = {}) => {
+  const client = resolveLunoraClient(options.client);
+  const destroyRef = options.destroyRef ?? inject(DestroyRef);
+  const type = flagKind(defaultValue);
+  const value = signal(defaultValue);
+  let unsubscribe;
+  try {
+    unsubscribe = client.subscribe(
+      flagsReference,
+      { context: options.context, default: defaultValue, key, type },
+      (next) => {
+        value.set(next);
+      },
+      {
+        onError: () => {
+          value.set(defaultValue);
+        }
+      }
+    );
+  } catch {
+  }
+  if (unsubscribe) {
+    destroyRef.onDestroy(unsubscribe);
+  }
+  return value.asReadonly();
+};
+const flags = (flagDefaults, options = {}) => {
+  const client = resolveLunoraClient(options.client);
+  const destroyRef = options.destroyRef ?? inject(DestroyRef);
+  const values = signal({ ...flagDefaults });
+  const unsubscribes = [];
+  for (const [key, defaultValue] of Object.entries(flagDefaults)) {
+    try {
+      const unsub = client.subscribe(
+        flagsReference,
+        { context: options.context, default: defaultValue, key, type: flagKind(defaultValue) },
+        (next) => {
+          values.set({ ...values(), [key]: next });
+        },
+        {
+          onError: () => {
+            values.set({ ...values(), [key]: defaultValue });
+          }
+        }
+      );
+      unsubscribes.push(unsub);
+    } catch {
+    }
+  }
+  destroyRef.onDestroy(() => {
+    for (const unsubscribe of unsubscribes) {
+      unsubscribe();
+    }
+  });
+  return values.asReadonly();
+};
+
+export { flag, flags };

package/dist/packem_shared/hydratePreloaded-DIpD1cAM.mjs

@@ -0,0 +1,33 @@
+import { inject, DestroyRef, signal } from '@angular/core';
+import { resolveLunoraClient } from './LUNORA_CLIENT-DHUfNu9x.mjs';
+import { s as shouldOpenSubscription } from './platform-Dg8Bppgq.mjs';
+
+const hydratePreloaded = (preloaded, options = {}) => {
+  const client = resolveLunoraClient(options.client);
+  const fromInjectionContext = options.destroyRef === void 0;
+  const destroyRef = options.destroyRef ?? inject(DestroyRef);
+  const { args, functionPath, shardKey, value } = preloaded;
+  const data = signal(value);
+  const error = signal(void 0);
+  const functionReference = { __lunoraRef: functionPath };
+  if (shouldOpenSubscription(fromInjectionContext)) {
+    const unsubscribe = client.subscribe(
+      functionReference,
+      args,
+      (next) => {
+        data.set(next);
+        error.set(void 0);
+      },
+      {
+        onError: (error_) => {
+          error.set(error_);
+        },
+        shardKey
+      }
+    );
+    destroyRef.onDestroy(unsubscribe);
+  }
+  return { data: data.asReadonly(), error: error.asReadonly() };
+};
+
+export { hydratePreloaded };

package/dist/packem_shared/infiniteQuery-nboKfr5E.mjs

@@ -0,0 +1,221 @@
+import { computed, inject, DestroyRef, signal } from '@angular/core';
+import { initialPages, derivePaginationStatus, applyLoadMore, rebalance } from '@lunora/client/pagination';
+import { resolveLunoraClient } from './LUNORA_CLIENT-DHUfNu9x.mjs';
+import { s as shouldOpenSubscription } from './platform-Dg8Bppgq.mjs';
+
+const buildPageKey = (functionPath, pageArgs) => `${functionPath}::${JSON.stringify(pageArgs)}`;
+const buildPageArgs = (page, baseArgs) => {
+  return {
+    ...baseArgs,
+    paginationOpts: { cursor: page.lower, endCursor: page.upper, numItems: page.numItems }
+  };
+};
+const usePaginatedCore = (reference, baseArgs, options) => {
+  const client = resolveLunoraClient(options.client);
+  const fromInjectionContext = options.destroyRef === void 0;
+  const destroyRef = options.destroyRef ?? inject(DestroyRef);
+  const { initialNumItems, shardKey } = options;
+  const functionPath = reference["__lunoraRef"];
+  const narrowedArgs = baseArgs === "skip" ? {} : baseArgs;
+  const pages = signal(initialPages(initialNumItems));
+  const pageResults = signal([]);
+  const status = signal("LoadingFirstPage");
+  const activeSubs = /* @__PURE__ */ new Map();
+  const resultsByKey = /* @__PURE__ */ new Map();
+  const pendingPageKeys = /* @__PURE__ */ new Set();
+  const doRebuildPageResults = () => {
+    const currentPages = pages();
+    const items = currentPages.map((page) => {
+      const key = buildPageKey(functionPath, buildPageArgs(page, narrowedArgs));
+      return resultsByKey.get(key);
+    });
+    pageResults.set(items);
+    const { status: derivedStatus } = derivePaginationStatus(baseArgs === "skip", items);
+    status.set(derivedStatus);
+  };
+  const migrateResultsForRebalance = (oldPages, newPages) => {
+    const keyOf = (page) => buildPageKey(functionPath, buildPageArgs(page, narrowedArgs));
+    for (const newPage of newPages) {
+      const newKey = keyOf(newPage);
+      if (resultsByKey.has(newKey)) {
+        continue;
+      }
+      const donor = oldPages.find((op) => op.lower === newPage.lower);
+      if (donor) {
+        const carried = resultsByKey.get(keyOf(donor));
+        if (carried) {
+          resultsByKey.set(newKey, carried);
+        }
+      }
+    }
+  };
+  const syncPass = (currentPages) => {
+    const wantedKeys = /* @__PURE__ */ new Set();
+    for (const page of currentPages) {
+      wantedKeys.add(buildPageKey(functionPath, buildPageArgs(page, narrowedArgs)));
+    }
+    for (const [originalKey, entry] of activeSubs) {
+      if (!wantedKeys.has(entry.currentKey)) {
+        entry.unsub();
+        activeSubs.delete(originalKey);
+        resultsByKey.delete(entry.currentKey);
+      }
+    }
+    const coveredKeys = new Set([...activeSubs.values()].map((subEntry) => subEntry.currentKey));
+    for (const page of currentPages) {
+      const pageArgs = buildPageArgs(page, narrowedArgs);
+      const key = buildPageKey(functionPath, pageArgs);
+      if (coveredKeys.has(key)) {
+        continue;
+      }
+      const entry = {
+        currentKey: key,
+        unsub: void 0
+      };
+      pendingPageKeys.add(key);
+      const unsub = client.subscribe(
+        reference,
+        pageArgs,
+        (value) => {
+          resultsByKey.set(entry.currentKey, value);
+          pendingPageKeys.delete(entry.currentKey);
+          doRebuildPageResults();
+          if (pendingPageKeys.size === 0) {
+            const latestPages = pages();
+            const next = rebalance(latestPages, pageResults());
+            if (next) {
+              migrateResultsForRebalance(latestPages, next);
+              pages.set(next);
+              syncSubscriptions(next);
+              doRebuildPageResults();
+            }
+          }
+        },
+        {
+          onError: () => {
+            pendingPageKeys.delete(entry.currentKey);
+            doRebuildPageResults();
+          },
+          shardKey
+        }
+      );
+      entry.unsub = unsub;
+      activeSubs.set(key, entry);
+      coveredKeys.add(key);
+    }
+  };
+  let syncing = false;
+  let resyncRequested = false;
+  const syncSubscriptions = (currentPages) => {
+    if (syncing) {
+      resyncRequested = true;
+      return;
+    }
+    syncing = true;
+    try {
+      let pagesToSync = currentPages;
+      do {
+        resyncRequested = false;
+        syncPass(pagesToSync);
+        pagesToSync = pages();
+      } while (resyncRequested);
+    } finally {
+      syncing = false;
+    }
+  };
+  if (baseArgs !== "skip" && shouldOpenSubscription(fromInjectionContext)) {
+    syncSubscriptions(pages());
+  }
+  doRebuildPageResults();
+  destroyRef.onDestroy(() => {
+    for (const entry of activeSubs.values()) {
+      entry.unsub();
+    }
+    activeSubs.clear();
+    resultsByKey.clear();
+  });
+  const loadMore = (numberItems) => {
+    if (baseArgs === "skip") {
+      return;
+    }
+    const { nextCursor, status: currentStatus } = derivePaginationStatus(false, pageResults());
+    if (currentStatus !== "CanLoadMore") {
+      return;
+    }
+    const next = applyLoadMore(pages(), nextCursor, numberItems);
+    if (!next) {
+      return;
+    }
+    const oldTail = pages().at(-1);
+    const newPinnedPage = next.at(-2);
+    if (oldTail && newPinnedPage) {
+      const oldKey = buildPageKey(functionPath, buildPageArgs(oldTail, narrowedArgs));
+      const newKey = buildPageKey(functionPath, buildPageArgs(newPinnedPage, narrowedArgs));
+      const entry = activeSubs.get(oldKey);
+      if (entry && oldKey !== newKey) {
+        const carried = resultsByKey.get(oldKey);
+        if (carried) {
+          resultsByKey.set(newKey, carried);
+        }
+        entry.unsub();
+        activeSubs.delete(oldKey);
+        resultsByKey.delete(oldKey);
+      }
+    }
+    pages.set(next);
+    syncSubscriptions(pages());
+    doRebuildPageResults();
+  };
+  return { loadMore, pageResults, status };
+};
+const paginatedQuery = (reference, args, options) => {
+  const core = usePaginatedCore(reference, args, options);
+  const results = computed(() => {
+    const items = [];
+    for (const result of core.pageResults()) {
+      if (result) {
+        items.push(...result.page);
+      }
+    }
+    return items;
+  });
+  const isLoading = computed(() => {
+    const statusValue = core.status();
+    return statusValue === "LoadingFirstPage" || statusValue === "LoadingMore";
+  });
+  return {
+    isLoading,
+    loadMore: core.loadMore,
+    results,
+    status: core.status
+  };
+};
+const infiniteQuery = (reference, args, options) => {
+  const { initialNumItems } = options;
+  const core = usePaginatedCore(reference, args, options);
+  const pages = computed(() => {
+    const resultArrays = [];
+    for (const page of core.pageResults()) {
+      if (page) {
+        resultArrays.push(page.page);
+      }
+    }
+    return resultArrays;
+  });
+  const isLoading = computed(() => core.status() === "LoadingFirstPage");
+  const hasNextPage = computed(() => core.status() === "CanLoadMore");
+  const isFetchingNextPage = computed(() => core.status() === "LoadingMore");
+  const fetchNextPage = (numberItems) => {
+    core.loadMore(numberItems ?? initialNumItems);
+  };
+  return {
+    fetchNextPage,
+    hasNextPage,
+    isFetchingNextPage,
+    isLoading,
+    pages,
+    status: core.status
+  };
+};
+
+export { infiniteQuery, paginatedQuery };

package/dist/packem_shared/liveQuery-DVxKidjM.mjs

@@ -0,0 +1,32 @@
+import { inject, DestroyRef, signal } from '@angular/core';
+import { createQuerySubscription } from '@lunora/client/query';
+import { resolveLunoraClient } from './LUNORA_CLIENT-DHUfNu9x.mjs';
+import { s as shouldOpenSubscription } from './platform-Dg8Bppgq.mjs';
+
+const liveQuery = (reference, args, options = {}) => {
+  const client = resolveLunoraClient(options.client);
+  const fromInjectionContext = options.destroyRef === void 0;
+  const destroyRef = options.destroyRef ?? inject(DestroyRef);
+  const value = signal(void 0);
+  if (shouldOpenSubscription(fromInjectionContext)) {
+    const unsubscribe = createQuerySubscription(
+      client,
+      reference,
+      args,
+      {
+        onData: (next) => {
+          value.set(next);
+        },
+        onError: options.onError,
+        onReset: () => {
+          value.set(void 0);
+        }
+      },
+      { shardKey: options.shardKey }
+    );
+    destroyRef.onDestroy(unsubscribe);
+  }
+  return value.asReadonly();
+};
+
+export { liveQuery };

package/dist/packem_shared/mutate-D3rEHwbb.mjs

@@ -0,0 +1,8 @@
+import { resolveLunoraClient } from './LUNORA_CLIENT-DHUfNu9x.mjs';
+
+const mutate = (reference, args, options = {}) => {
+  const { client, ...callOptions } = options;
+  return resolveLunoraClient(client).mutation(reference, args, callOptions);
+};
+
+export { mutate };