@lunora/angular 1.0.0-alpha.3 → 1.0.0-alpha.5

package/dist/index.d.mts

@@ -1,7 +1,39 @@
-import { InjectionToken, EnvironmentProviders, DestroyRef, Signal } from '@angular/core';
-import { LunoraClient, LunoraClientOptions, ConnectionStatus, SubscriptionError, FunctionReference, ArgsOf, ReturnOf, MutationCallOptions } from '@lunora/client';
-export type { ArgsOf, ConnectionStatus, FunctionReference, LunoraClient, LunoraClientOptions, MutationCallOptions, ReturnOf, SubscriptionError, Unsubscribe } from '@lunora/client';
+import { DestroyRef, Signal, InjectionToken, EnvironmentProviders } from '@angular/core';
+import { LunoraClient, User, LunoraClientOptions, ConnectionStatus, SubscriptionError, Preloaded, FunctionReference, ArgsOf, ReturnOf, MutationCallOptions, MutatorHandle } from '@lunora/client';
+export type { ArgsOf, ConnectionStatus, FunctionReference, LunoraClient, LunoraClientOptions, MutationCallOptions, Preloaded, ReturnOf, SubscriptionError, Unsubscribe } from '@lunora/client';
+import { PaginationStatus } from '@lunora/client/pagination';
+import { RateLimitStatus, RateLimitConfig } from '@lunora/ratelimit';
 export { SKIP } from '@lunora/client/query';
+interface AuthOptions {
+  /** Client to bind to. Defaults to the injected `LUNORA_CLIENT`. */
+  client?: LunoraClient;
+  /** `DestroyRef` whose `onDestroy` removes the listeners. Defaults to `inject(DestroyRef)`. */
+  destroyRef?: DestroyRef;
+}
+interface AuthResult {
+  /** Set the auth token (sign-in / sign-out). */
+  setToken: (token: string | null) => void;
+  /** The current auth token, or `null`. */
+  token: Signal<string | null>;
+  /** The resolved user from `store.getUser()`, or `null`. */
+  user: Signal<User | null>;
+}
+/**
+* Token + identity plumbing for Angular. `token` is a signal tracking the
+* client's auth token; `user` is a signal resolved from `getCurrentUser()`
+* whenever the token changes. `setToken(jwt)` after sign-in makes subsequent
+* RPC calls carry the `Authorization` header.
+*
+* Multiple `auth` instances on the same client share a single per-client
+* identity store (from `@lunora/client/auth`) — a `setToken` from one component
+* re-renders every watcher with the freshly-resolved user.
+*
+* Call from an injection context (component/service field or constructor):
+* ```ts
+* const { token, user, setToken } = auth();
+* ```
+*/
+declare const auth: (options?: AuthOptions) => AuthResult;
 /**
 * DI token carrying the framework-neutral {@link LunoraClient}. Every reactive
 * primitive in this adapter (`liveQuery`, `mutate`, `connectionStatus`) reads the
@@ -68,6 +100,94 @@ interface ConnectionStatusOptions {
 * injection context (component/service field or constructor).
 */
 declare const connectionStatus: (options?: ConnectionStatusOptions) => Signal<ConnectionStatus>;
+/** The value kinds a flag resolves to — OpenFeature's boolean / number / string / structured (JSON) flags. */
+type FlagValue = boolean | number | string | Record<string, unknown> | unknown[] | null;
+/** Targeting context bag forwarded to the OpenFeature provider. */
+type FlagContext = Record<string, unknown>;
+interface FlagOptions {
+  /** Client to bind to. Defaults to the injected `LUNORA_CLIENT`. */
+  client?: LunoraClient;
+  /**
+  * Per-call targeting context merged on top of the app's default `identify`
+  * targeting key.
+  */
+  context?: FlagContext;
+  /** `DestroyRef` whose `onDestroy` tears down the subscription. Defaults to `inject(DestroyRef)`. */
+  destroyRef?: DestroyRef;
+}
+/**
+* Subscribe to a single feature flag, live over Lunora's WebSocket.
+*
+* The returned signal holds `defaultValue` until the first evaluation lands, then
+* the server's resolved value — re-pushed whenever the provider re-evaluates.
+* The flag's kind is inferred from `defaultValue`'s runtime type, so
+* `flag("dark", false)` reads a boolean and `flag("hero", "control")` a string.
+*
+* Evaluation runs through whatever OpenFeature provider the app wired in
+* `lunora/flags.ts`; the read never throws — a provider error resolves the
+* default (the same fail-open contract as server-side `ctx.flags`).
+*
+* Call from an injection context:
+* ```ts
+* readonly darkMode = flag("dark-mode", false);
+* ```
+*/
+declare const flag: <T extends FlagValue>(key: string, defaultValue: T, options?: FlagOptions) => Signal<T>;
+interface FlagsOptions {
+  /** Client to bind to. Defaults to the injected `LUNORA_CLIENT`. */
+  client?: LunoraClient;
+  /**
+  * Targeting context shared by every flag in the set, merged on top of the
+  * app's default `identify` targeting key.
+  */
+  context?: FlagContext;
+  /** `DestroyRef` whose `onDestroy` tears down the subscriptions. Defaults to `inject(DestroyRef)`. */
+  destroyRef?: DestroyRef;
+}
+/**
+* Subscribe to several feature flags at once, live over Lunora's WebSocket.
+*
+* Pass a record of `key → defaultValue`; each flag's kind is inferred from its
+* default, and the returned signal holds the same-shaped record with resolved
+* values (the defaults until each evaluation lands).
+*
+* Call from an injection context:
+* ```ts
+* readonly features = flags({ "dark-mode": false, "new-editor": false });
+* ```
+*/
+declare const flags: <T extends Record<string, FlagValue>>(flagDefaults: T, options?: FlagsOptions) => Signal<T>;
+interface HydratePreloadedOptions {
+  /** Client to bind to. Defaults to the injected `LUNORA_CLIENT`. */
+  client?: LunoraClient;
+  /** `DestroyRef` whose `onDestroy` tears the subscription down. Defaults to `inject(DestroyRef)`. */
+  destroyRef?: DestroyRef;
+}
+interface HydratePreloadedResult<T> {
+  /** The latest value pushed by the server. Seeded synchronously from the preloaded value. */
+  data: Signal<T | undefined>;
+  /** The latest subscription error, or `undefined`. */
+  error: Signal<SubscriptionError | undefined>;
+}
+/**
+* Hydrate a query from a {@link Preloaded} token produced by `preloadQuery`
+* during SSR, then keep it live — the Angular half of the reactive-loader
+* handoff.
+*
+* The returned signal is seeded **synchronously** from `preloaded.value`, so the
+* very first read (during hydration) shows the server value: no loading flash,
+* no hydration mismatch. After seeding it opens a WebSocket subscription on the
+* same `(functionPath, args, shardKey)` the SSR loader used, so every later
+* server delta updates the signal exactly like `liveQuery`.
+*
+* The subscription tears down when the owning `DestroyRef` fires.
+*
+* Call from an injection context:
+* ```ts
+* readonly { data, error } = hydratePreloaded(preloadedMessages);
+* ```
+*/
+declare const hydratePreloaded: <T>(preloaded: Preloaded<T>, options?: HydratePreloadedOptions) => HydratePreloadedResult<T>;
 interface LiveQueryOptions {
   /**
   * Client to bind to. Defaults to the injected `LUNORA_CLIENT`; pass one
@@ -143,4 +263,240 @@ interface MutateOptions<F extends FunctionReference> extends MutationCallOptions
 * resolve from the injector.
 */
 declare const mutate: <F extends FunctionReference>(reference: F, args: ArgsOf<F>, options?: MutateOptions<F>) => Promise<ReturnOf<F>>;
-export { type ConnectionStatusOptions, LUNORA_CLIENT, type LiveQueryOptions, type MutateOptions, type ProvideLunoraOptions, connectionStatus, injectLunoraClient, liveQuery, mutate, provideLunora };
+interface MutatorResult<TArgs> {
+  /** The latest invocation's error, or `undefined`. */
+  error: Signal<Error | undefined>;
+  /** `true` when the latest invocation rejected. */
+  isError: Signal<boolean>;
+  /** Run the mutator; resolves once the write is persisted, rejects on failure. */
+  mutate: (args: TArgs) => Promise<void>;
+  /** `true` while ANY invocation from this handle is in flight. */
+  pending: Signal<boolean>;
+  /** Clear the latest `error` back to idle. */
+  reset: () => void;
+}
+/**
+* Ergonomic `{ mutate, pending, error, isError, reset }` wrapper over a bound
+* custom-mutator handle from `` `@lunora/db` ``'s `bindMutators` — the Angular
+* equivalent of `` `@lunora/react` ``'s `useMutator`. The optimistic overlay and
+* server-authoritative push are owned by the bound handle; this function only
+* surfaces reactive state for the in-flight/error lifecycle.
+*
+* `pending` is ref-counted across overlapping invocations of THIS handle, so it
+* clears only once every concurrent call has settled.
+*
+* Does NOT require an injection context — it works with plain signals.
+*
+* ```ts
+* private readonly collection = bindMutators(collections);
+* readonly mutator = mutator(this.collection.insert);
+* ```
+*/
+declare const mutator: <TArgs = Record<string, unknown>>(handle: MutatorHandle<TArgs>) => MutatorResult<TArgs>;
+/** The args a paginated query exposes minus the framework-supplied page cursor. */
+type PaginatedArgs<F extends FunctionReference> = Omit<ArgsOfRaw<F>, "paginationOpts">;
+/** The element type of the `page` array a paginated query returns. */
+type PageItemOf<F extends FunctionReference> = ReturnTypeOf<F> extends {
+  page: (infer T)[];
+} ? T : unknown;
+type ArgsOfRaw<F extends FunctionReference> = F extends FunctionReference<"query", infer A> ? A : never;
+type ReturnTypeOf<F extends FunctionReference> = F extends FunctionReference<"query", unknown, infer R> ? R : never;
+interface PaginatedQueryOptions {
+  /** Client to bind to. Defaults to the injected `LUNORA_CLIENT`. */
+  client?: LunoraClient;
+  /** `DestroyRef` whose `onDestroy` tears down the subscriptions. Defaults to `inject(DestroyRef)`. */
+  destroyRef?: DestroyRef;
+  /** Page size for the first page (and the default for `loadMore`). */
+  initialNumItems: number;
+  /** Route to a specific shard when the target function is `.shardBy(...)`-partitioned. */
+  shardKey?: string;
+}
+interface PaginatedQueryResult<T> {
+  /** `true` while the first page or a `loadMore` page is in flight. */
+  isLoading: Signal<boolean>;
+  /** Request the next page. A no-op unless `status === "CanLoadMore"`. */
+  loadMore: (numberItems: number) => void;
+  /** Flattened items across every loaded page, in order. */
+  results: Signal<T[]>;
+  /** The pagination status. */
+  status: Signal<PaginationStatus>;
+}
+interface InfiniteQueryResult<T> {
+  /** Request the next page. A no-op unless `status === "CanLoadMore"`. */
+  fetchNextPage: (numberItems?: number) => void;
+  /** `true` when the loaded tail reports it can load another page. */
+  hasNextPage: Signal<boolean>;
+  /** `true` while a `fetchNextPage` page (beyond the first) is in flight. */
+  isFetchingNextPage: Signal<boolean>;
+  /** `true` while the first page is in flight. */
+  isLoading: Signal<boolean>;
+  /** One inner array per loaded page, in order; unresolved pages are omitted. */
+  pages: Signal<T[][]>;
+  /** The pagination status. */
+  status: Signal<PaginationStatus>;
+}
+/**
+* Subscribe to a reactively-paginated query and grow the feed page by page.
+*
+* The query function must accept a `paginationOpts: { numItems, cursor,
+* endCursor }` arg and return a `PaginationResult`. Pages are tracked as an
+* ordered list of stable boundary cursors; each loaded page is a live
+* subscription over a FIXED `(lower, upper]` range.
+*
+* `loadMore` appends the next page off the open-ended tail's `continueCursor`;
+* it is a no-op unless `status === "CanLoadMore"`.
+*
+* Call from an injection context:
+* ```ts
+* readonly messages = paginatedQuery(api.messages.list, {}, { initialNumItems: 20 });
+* ```
+*/
+declare const paginatedQuery: <F extends FunctionReference>(reference: F, args: PaginatedArgs<F> | "skip", options: PaginatedQueryOptions) => PaginatedQueryResult<PageItemOf<F>>;
+/**
+* Subscribe to a reactively-paginated query and expose its pages discretely.
+*
+* Shares `paginatedQuery`'s reactive-pagination engine but keeps each page as
+* its own inner array rather than flattening them, and adds the TanStack-Query-
+* style `fetchNextPage` / `hasNextPage` / `isFetchingNextPage` shape.
+*
+* Call from an injection context:
+* ```ts
+* readonly feed = infiniteQuery(api.messages.list, {}, { initialNumItems: 20 });
+* ```
+*/
+declare const infiniteQuery: <F extends FunctionReference>(reference: F, args: PaginatedArgs<F> | "skip", options: PaginatedQueryOptions) => InfiniteQueryResult<PageItemOf<F>>;
+type HeartbeatReference = FunctionReference<"mutation", {
+  data?: Record<string, unknown>;
+  roomId: string;
+  sessionId: string;
+}>;
+type ListPresentReference = FunctionReference<"query", {
+  roomId: string;
+}>;
+interface PresenceOptions<H extends HeartbeatReference, L extends ListPresentReference> {
+  /** Client to bind to. Defaults to the injected `LUNORA_CLIENT`. */
+  client?: LunoraClient;
+  /** Awareness blob for the first heartbeat (selection, cursor, name, color…). */
+  data?: Record<string, unknown>;
+  /** `DestroyRef` whose `onDestroy` cleans up. Defaults to `inject(DestroyRef)`. */
+  destroyRef?: DestroyRef;
+  /** The `api.*` reference for the presence heartbeat mutation. */
+  heartbeat: H;
+  /** Heartbeat cadence in ms. Defaults to 10s (10000). */
+  intervalMs?: number;
+  /** The `api.*` reference for the presence listPresent query. */
+  listPresent: L;
+  /**
+  * Stable id for this presence row. Defaults to a fresh per-call id.
+  * Pass a user/connection id to control deduping across tabs.
+  */
+  sessionId?: string;
+  /** Forwarded to the heartbeat mutation / listPresent subscription when sharding by room. */
+  shardKey?: string;
+}
+interface PresenceResult<L extends ListPresentReference> {
+  /** The present members for the room. `undefined` until the first push. */
+  present: Signal<ReturnOf<L> | undefined>;
+  /** This mount's session id (generated when not supplied). */
+  sessionId: string;
+  /** Replace the awareness `data` sent with subsequent heartbeats, and heartbeat immediately. */
+  setData: (data: Record<string, unknown> | undefined) => void;
+}
+/**
+* `presence` — collaborative-awareness primitive, the client half of the
+* `@lunora/server` `definePresence` preset.
+*
+* Drives the heartbeat mutation (on mount, interval, and tab re-focus) and
+* subscribes to the live `listPresent` query for the given room.
+*
+* Call from an injection context (component/service field or constructor):
+* ```ts
+* readonly roomPresence = presence("room:general", {
+*     heartbeat: api.presence.heartbeat,
+*     listPresent: api.presence.listPresent,
+* });
+* ```
+*/
+declare const presence: <H extends HeartbeatReference, L extends ListPresentReference>(roomId: string, options: PresenceOptions<H, L>) => PresenceResult<L>;
+interface RateLimitOptions {
+  /**
+  * `DestroyRef` whose `onDestroy` clears the interval. Defaults to
+  * `inject(DestroyRef)` — the calling component/service.
+  */
+  destroyRef?: DestroyRef;
+  /** Clock injection for tests. Defaults to `Date.now`. */
+  now?: () => number;
+  /**
+  * Re-render cadence in milliseconds while throttled, so `retryAfter` ticks
+  * down and `disabled` flips back automatically. Defaults to `1000`.
+  */
+  tickMs?: number;
+}
+interface RateLimitResult {
+  /** Would consuming `count` (default 1) succeed right now? Does not consume. */
+  check: (count?: number) => boolean;
+  /** Optimistically consume `count` (default 1) locally; mirrors the server algorithm. */
+  consume: (count?: number) => RateLimitStatus;
+  /** `true` while a single unit cannot be consumed — convenient for disabling a control. */
+  disabled: Signal<boolean>;
+  /** `true` while a single unit can be consumed. */
+  ok: Signal<boolean>;
+  /** Clear local accounting (e.g. after the server confirms a reset). */
+  reset: () => void;
+  /** Milliseconds until the next unit is available. `0` when `ok`. */
+  retryAfter: Signal<number>;
+}
+/**
+* Client-side mirror of a rate limit for instant UX — disable a button or show
+* a countdown without a round-trip. It runs the same token-bucket / fixed-window
+* math as `@lunora/ratelimit` on the server, so the prediction agrees with the
+* authoritative check; the server remains the source of truth.
+*
+* Requires an Angular injection context unless a `DestroyRef` is passed
+* explicitly via `options.destroyRef`.
+*
+* ```ts
+* readonly sendLimit = rateLimit({ kind: "token bucket", period: 1000, rate: 10 });
+* ```
+*/
+declare const rateLimit: (config: RateLimitConfig, options?: RateLimitOptions) => RateLimitResult;
+interface SubscriptionOptions {
+  /** Client to bind to. Defaults to the injected `LUNORA_CLIENT`. */
+  client?: LunoraClient;
+  /**
+  * `DestroyRef` whose `onDestroy` tears the subscription down. Defaults to
+  * `inject(DestroyRef)` — the calling component/service.
+  */
+  destroyRef?: DestroyRef;
+  /**
+  * Called when the subscription errors after the initial attach. Without it,
+  * a post-attach failure is dropped silently.
+  */
+  onError?: (error: SubscriptionError) => void;
+  /** Route to a specific shard when the target function is `.shardBy(...)`-partitioned. */
+  shardKey?: string;
+}
+interface SubscriptionResult<T> {
+  /** The latest value pushed by the server. `undefined` before the first frame. */
+  data: Signal<T | undefined>;
+  /** The latest error, or `undefined`. */
+  error: Signal<SubscriptionError | undefined>;
+}
+/**
+* Subscribe to a reactive server push stream. Returns `{ data, error }` signals
+* that update whenever the server emits a new value.
+*
+* Unlike `liveQuery`, which tracks a single value, `subscription` also
+* exposes an `error` signal for the async error channel. Use it for ephemeral,
+* high-frequency streams where you need error visibility.
+*
+* Pass `"skip"` as `args` to short-circuit — no network call, no socket.
+* The subscription tears down when the owning `DestroyRef` fires.
+*
+* Call from an injection context (component/service field or constructor):
+* ```ts
+* readonly stream = subscription(api.events.stream, { roomId: "general" });
+* ```
+*/
+declare const subscription: <F extends FunctionReference>(reference: F, args: ArgsOf<F> | "skip", options?: SubscriptionOptions) => SubscriptionResult<ReturnOf<F>>;
+export { type AuthOptions, type AuthResult, type ConnectionStatusOptions, type FlagContext, type FlagOptions, type FlagValue, type FlagsOptions, type HeartbeatReference, type HydratePreloadedOptions, type HydratePreloadedResult, type InfiniteQueryResult, LUNORA_CLIENT, type ListPresentReference, type LiveQueryOptions, type MutateOptions, type MutatorResult, type PaginatedQueryOptions, type PaginatedQueryResult, type PresenceOptions, type PresenceResult, type ProvideLunoraOptions, type RateLimitOptions, type RateLimitResult, type SubscriptionOptions, type SubscriptionResult, auth, connectionStatus, flag, flags, hydratePreloaded, infiniteQuery, injectLunoraClient, liveQuery, mutate, mutator, paginatedQuery, presence, provideLunora, rateLimit, subscription };

package/dist/index.d.ts

@@ -1,7 +1,39 @@
-import { InjectionToken, EnvironmentProviders, DestroyRef, Signal } from '@angular/core';
-import { LunoraClient, LunoraClientOptions, ConnectionStatus, SubscriptionError, FunctionReference, ArgsOf, ReturnOf, MutationCallOptions } from '@lunora/client';
-export type { ArgsOf, ConnectionStatus, FunctionReference, LunoraClient, LunoraClientOptions, MutationCallOptions, ReturnOf, SubscriptionError, Unsubscribe } from '@lunora/client';
+import { DestroyRef, Signal, InjectionToken, EnvironmentProviders } from '@angular/core';
+import { LunoraClient, User, LunoraClientOptions, ConnectionStatus, SubscriptionError, Preloaded, FunctionReference, ArgsOf, ReturnOf, MutationCallOptions, MutatorHandle } from '@lunora/client';
+export type { ArgsOf, ConnectionStatus, FunctionReference, LunoraClient, LunoraClientOptions, MutationCallOptions, Preloaded, ReturnOf, SubscriptionError, Unsubscribe } from '@lunora/client';
+import { PaginationStatus } from '@lunora/client/pagination';
+import { RateLimitStatus, RateLimitConfig } from '@lunora/ratelimit';
 export { SKIP } from '@lunora/client/query';
+interface AuthOptions {
+  /** Client to bind to. Defaults to the injected `LUNORA_CLIENT`. */
+  client?: LunoraClient;
+  /** `DestroyRef` whose `onDestroy` removes the listeners. Defaults to `inject(DestroyRef)`. */
+  destroyRef?: DestroyRef;
+}
+interface AuthResult {
+  /** Set the auth token (sign-in / sign-out). */
+  setToken: (token: string | null) => void;
+  /** The current auth token, or `null`. */
+  token: Signal<string | null>;
+  /** The resolved user from `store.getUser()`, or `null`. */
+  user: Signal<User | null>;
+}
+/**
+* Token + identity plumbing for Angular. `token` is a signal tracking the
+* client's auth token; `user` is a signal resolved from `getCurrentUser()`
+* whenever the token changes. `setToken(jwt)` after sign-in makes subsequent
+* RPC calls carry the `Authorization` header.
+*
+* Multiple `auth` instances on the same client share a single per-client
+* identity store (from `@lunora/client/auth`) — a `setToken` from one component
+* re-renders every watcher with the freshly-resolved user.
+*
+* Call from an injection context (component/service field or constructor):
+* ```ts
+* const { token, user, setToken } = auth();
+* ```
+*/
+declare const auth: (options?: AuthOptions) => AuthResult;
 /**
 * DI token carrying the framework-neutral {@link LunoraClient}. Every reactive
 * primitive in this adapter (`liveQuery`, `mutate`, `connectionStatus`) reads the
@@ -68,6 +100,94 @@ interface ConnectionStatusOptions {
 * injection context (component/service field or constructor).
 */
 declare const connectionStatus: (options?: ConnectionStatusOptions) => Signal<ConnectionStatus>;
+/** The value kinds a flag resolves to — OpenFeature's boolean / number / string / structured (JSON) flags. */
+type FlagValue = boolean | number | string | Record<string, unknown> | unknown[] | null;
+/** Targeting context bag forwarded to the OpenFeature provider. */
+type FlagContext = Record<string, unknown>;
+interface FlagOptions {
+  /** Client to bind to. Defaults to the injected `LUNORA_CLIENT`. */
+  client?: LunoraClient;
+  /**
+  * Per-call targeting context merged on top of the app's default `identify`
+  * targeting key.
+  */
+  context?: FlagContext;
+  /** `DestroyRef` whose `onDestroy` tears down the subscription. Defaults to `inject(DestroyRef)`. */
+  destroyRef?: DestroyRef;
+}
+/**
+* Subscribe to a single feature flag, live over Lunora's WebSocket.
+*
+* The returned signal holds `defaultValue` until the first evaluation lands, then
+* the server's resolved value — re-pushed whenever the provider re-evaluates.
+* The flag's kind is inferred from `defaultValue`'s runtime type, so
+* `flag("dark", false)` reads a boolean and `flag("hero", "control")` a string.
+*
+* Evaluation runs through whatever OpenFeature provider the app wired in
+* `lunora/flags.ts`; the read never throws — a provider error resolves the
+* default (the same fail-open contract as server-side `ctx.flags`).
+*
+* Call from an injection context:
+* ```ts
+* readonly darkMode = flag("dark-mode", false);
+* ```
+*/
+declare const flag: <T extends FlagValue>(key: string, defaultValue: T, options?: FlagOptions) => Signal<T>;
+interface FlagsOptions {
+  /** Client to bind to. Defaults to the injected `LUNORA_CLIENT`. */
+  client?: LunoraClient;
+  /**
+  * Targeting context shared by every flag in the set, merged on top of the
+  * app's default `identify` targeting key.
+  */
+  context?: FlagContext;
+  /** `DestroyRef` whose `onDestroy` tears down the subscriptions. Defaults to `inject(DestroyRef)`. */
+  destroyRef?: DestroyRef;
+}
+/**
+* Subscribe to several feature flags at once, live over Lunora's WebSocket.
+*
+* Pass a record of `key → defaultValue`; each flag's kind is inferred from its
+* default, and the returned signal holds the same-shaped record with resolved
+* values (the defaults until each evaluation lands).
+*
+* Call from an injection context:
+* ```ts
+* readonly features = flags({ "dark-mode": false, "new-editor": false });
+* ```
+*/
+declare const flags: <T extends Record<string, FlagValue>>(flagDefaults: T, options?: FlagsOptions) => Signal<T>;
+interface HydratePreloadedOptions {
+  /** Client to bind to. Defaults to the injected `LUNORA_CLIENT`. */
+  client?: LunoraClient;
+  /** `DestroyRef` whose `onDestroy` tears the subscription down. Defaults to `inject(DestroyRef)`. */
+  destroyRef?: DestroyRef;
+}
+interface HydratePreloadedResult<T> {
+  /** The latest value pushed by the server. Seeded synchronously from the preloaded value. */
+  data: Signal<T | undefined>;
+  /** The latest subscription error, or `undefined`. */
+  error: Signal<SubscriptionError | undefined>;
+}
+/**
+* Hydrate a query from a {@link Preloaded} token produced by `preloadQuery`
+* during SSR, then keep it live — the Angular half of the reactive-loader
+* handoff.
+*
+* The returned signal is seeded **synchronously** from `preloaded.value`, so the
+* very first read (during hydration) shows the server value: no loading flash,
+* no hydration mismatch. After seeding it opens a WebSocket subscription on the
+* same `(functionPath, args, shardKey)` the SSR loader used, so every later
+* server delta updates the signal exactly like `liveQuery`.
+*
+* The subscription tears down when the owning `DestroyRef` fires.
+*
+* Call from an injection context:
+* ```ts
+* readonly { data, error } = hydratePreloaded(preloadedMessages);
+* ```
+*/
+declare const hydratePreloaded: <T>(preloaded: Preloaded<T>, options?: HydratePreloadedOptions) => HydratePreloadedResult<T>;
 interface LiveQueryOptions {
   /**
   * Client to bind to. Defaults to the injected `LUNORA_CLIENT`; pass one
@@ -143,4 +263,240 @@ interface MutateOptions<F extends FunctionReference> extends MutationCallOptions
 * resolve from the injector.
 */
 declare const mutate: <F extends FunctionReference>(reference: F, args: ArgsOf<F>, options?: MutateOptions<F>) => Promise<ReturnOf<F>>;
-export { type ConnectionStatusOptions, LUNORA_CLIENT, type LiveQueryOptions, type MutateOptions, type ProvideLunoraOptions, connectionStatus, injectLunoraClient, liveQuery, mutate, provideLunora };
+interface MutatorResult<TArgs> {
+  /** The latest invocation's error, or `undefined`. */
+  error: Signal<Error | undefined>;
+  /** `true` when the latest invocation rejected. */
+  isError: Signal<boolean>;
+  /** Run the mutator; resolves once the write is persisted, rejects on failure. */
+  mutate: (args: TArgs) => Promise<void>;
+  /** `true` while ANY invocation from this handle is in flight. */
+  pending: Signal<boolean>;
+  /** Clear the latest `error` back to idle. */
+  reset: () => void;
+}
+/**
+* Ergonomic `{ mutate, pending, error, isError, reset }` wrapper over a bound
+* custom-mutator handle from `` `@lunora/db` ``'s `bindMutators` — the Angular
+* equivalent of `` `@lunora/react` ``'s `useMutator`. The optimistic overlay and
+* server-authoritative push are owned by the bound handle; this function only
+* surfaces reactive state for the in-flight/error lifecycle.
+*
+* `pending` is ref-counted across overlapping invocations of THIS handle, so it
+* clears only once every concurrent call has settled.
+*
+* Does NOT require an injection context — it works with plain signals.
+*
+* ```ts
+* private readonly collection = bindMutators(collections);
+* readonly mutator = mutator(this.collection.insert);
+* ```
+*/
+declare const mutator: <TArgs = Record<string, unknown>>(handle: MutatorHandle<TArgs>) => MutatorResult<TArgs>;
+/** The args a paginated query exposes minus the framework-supplied page cursor. */
+type PaginatedArgs<F extends FunctionReference> = Omit<ArgsOfRaw<F>, "paginationOpts">;
+/** The element type of the `page` array a paginated query returns. */
+type PageItemOf<F extends FunctionReference> = ReturnTypeOf<F> extends {
+  page: (infer T)[];
+} ? T : unknown;
+type ArgsOfRaw<F extends FunctionReference> = F extends FunctionReference<"query", infer A> ? A : never;
+type ReturnTypeOf<F extends FunctionReference> = F extends FunctionReference<"query", unknown, infer R> ? R : never;
+interface PaginatedQueryOptions {
+  /** Client to bind to. Defaults to the injected `LUNORA_CLIENT`. */
+  client?: LunoraClient;
+  /** `DestroyRef` whose `onDestroy` tears down the subscriptions. Defaults to `inject(DestroyRef)`. */
+  destroyRef?: DestroyRef;
+  /** Page size for the first page (and the default for `loadMore`). */
+  initialNumItems: number;
+  /** Route to a specific shard when the target function is `.shardBy(...)`-partitioned. */
+  shardKey?: string;
+}
+interface PaginatedQueryResult<T> {
+  /** `true` while the first page or a `loadMore` page is in flight. */
+  isLoading: Signal<boolean>;
+  /** Request the next page. A no-op unless `status === "CanLoadMore"`. */
+  loadMore: (numberItems: number) => void;
+  /** Flattened items across every loaded page, in order. */
+  results: Signal<T[]>;
+  /** The pagination status. */
+  status: Signal<PaginationStatus>;
+}
+interface InfiniteQueryResult<T> {
+  /** Request the next page. A no-op unless `status === "CanLoadMore"`. */
+  fetchNextPage: (numberItems?: number) => void;
+  /** `true` when the loaded tail reports it can load another page. */
+  hasNextPage: Signal<boolean>;
+  /** `true` while a `fetchNextPage` page (beyond the first) is in flight. */
+  isFetchingNextPage: Signal<boolean>;
+  /** `true` while the first page is in flight. */
+  isLoading: Signal<boolean>;
+  /** One inner array per loaded page, in order; unresolved pages are omitted. */
+  pages: Signal<T[][]>;
+  /** The pagination status. */
+  status: Signal<PaginationStatus>;
+}
+/**
+* Subscribe to a reactively-paginated query and grow the feed page by page.
+*
+* The query function must accept a `paginationOpts: { numItems, cursor,
+* endCursor }` arg and return a `PaginationResult`. Pages are tracked as an
+* ordered list of stable boundary cursors; each loaded page is a live
+* subscription over a FIXED `(lower, upper]` range.
+*
+* `loadMore` appends the next page off the open-ended tail's `continueCursor`;
+* it is a no-op unless `status === "CanLoadMore"`.
+*
+* Call from an injection context:
+* ```ts
+* readonly messages = paginatedQuery(api.messages.list, {}, { initialNumItems: 20 });
+* ```
+*/
+declare const paginatedQuery: <F extends FunctionReference>(reference: F, args: PaginatedArgs<F> | "skip", options: PaginatedQueryOptions) => PaginatedQueryResult<PageItemOf<F>>;
+/**
+* Subscribe to a reactively-paginated query and expose its pages discretely.
+*
+* Shares `paginatedQuery`'s reactive-pagination engine but keeps each page as
+* its own inner array rather than flattening them, and adds the TanStack-Query-
+* style `fetchNextPage` / `hasNextPage` / `isFetchingNextPage` shape.
+*
+* Call from an injection context:
+* ```ts
+* readonly feed = infiniteQuery(api.messages.list, {}, { initialNumItems: 20 });
+* ```
+*/
+declare const infiniteQuery: <F extends FunctionReference>(reference: F, args: PaginatedArgs<F> | "skip", options: PaginatedQueryOptions) => InfiniteQueryResult<PageItemOf<F>>;
+type HeartbeatReference = FunctionReference<"mutation", {
+  data?: Record<string, unknown>;
+  roomId: string;
+  sessionId: string;
+}>;
+type ListPresentReference = FunctionReference<"query", {
+  roomId: string;
+}>;
+interface PresenceOptions<H extends HeartbeatReference, L extends ListPresentReference> {
+  /** Client to bind to. Defaults to the injected `LUNORA_CLIENT`. */
+  client?: LunoraClient;
+  /** Awareness blob for the first heartbeat (selection, cursor, name, color…). */
+  data?: Record<string, unknown>;
+  /** `DestroyRef` whose `onDestroy` cleans up. Defaults to `inject(DestroyRef)`. */
+  destroyRef?: DestroyRef;
+  /** The `api.*` reference for the presence heartbeat mutation. */
+  heartbeat: H;
+  /** Heartbeat cadence in ms. Defaults to 10s (10000). */
+  intervalMs?: number;
+  /** The `api.*` reference for the presence listPresent query. */
+  listPresent: L;
+  /**
+  * Stable id for this presence row. Defaults to a fresh per-call id.
+  * Pass a user/connection id to control deduping across tabs.
+  */
+  sessionId?: string;
+  /** Forwarded to the heartbeat mutation / listPresent subscription when sharding by room. */
+  shardKey?: string;
+}
+interface PresenceResult<L extends ListPresentReference> {
+  /** The present members for the room. `undefined` until the first push. */
+  present: Signal<ReturnOf<L> | undefined>;
+  /** This mount's session id (generated when not supplied). */
+  sessionId: string;
+  /** Replace the awareness `data` sent with subsequent heartbeats, and heartbeat immediately. */
+  setData: (data: Record<string, unknown> | undefined) => void;
+}
+/**
+* `presence` — collaborative-awareness primitive, the client half of the
+* `@lunora/server` `definePresence` preset.
+*
+* Drives the heartbeat mutation (on mount, interval, and tab re-focus) and
+* subscribes to the live `listPresent` query for the given room.
+*
+* Call from an injection context (component/service field or constructor):
+* ```ts
+* readonly roomPresence = presence("room:general", {
+*     heartbeat: api.presence.heartbeat,
+*     listPresent: api.presence.listPresent,
+* });
+* ```
+*/
+declare const presence: <H extends HeartbeatReference, L extends ListPresentReference>(roomId: string, options: PresenceOptions<H, L>) => PresenceResult<L>;
+interface RateLimitOptions {
+  /**
+  * `DestroyRef` whose `onDestroy` clears the interval. Defaults to
+  * `inject(DestroyRef)` — the calling component/service.
+  */
+  destroyRef?: DestroyRef;
+  /** Clock injection for tests. Defaults to `Date.now`. */
+  now?: () => number;
+  /**
+  * Re-render cadence in milliseconds while throttled, so `retryAfter` ticks
+  * down and `disabled` flips back automatically. Defaults to `1000`.
+  */
+  tickMs?: number;
+}
+interface RateLimitResult {
+  /** Would consuming `count` (default 1) succeed right now? Does not consume. */
+  check: (count?: number) => boolean;
+  /** Optimistically consume `count` (default 1) locally; mirrors the server algorithm. */
+  consume: (count?: number) => RateLimitStatus;
+  /** `true` while a single unit cannot be consumed — convenient for disabling a control. */
+  disabled: Signal<boolean>;
+  /** `true` while a single unit can be consumed. */
+  ok: Signal<boolean>;
+  /** Clear local accounting (e.g. after the server confirms a reset). */
+  reset: () => void;
+  /** Milliseconds until the next unit is available. `0` when `ok`. */
+  retryAfter: Signal<number>;
+}
+/**
+* Client-side mirror of a rate limit for instant UX — disable a button or show
+* a countdown without a round-trip. It runs the same token-bucket / fixed-window
+* math as `@lunora/ratelimit` on the server, so the prediction agrees with the
+* authoritative check; the server remains the source of truth.
+*
+* Requires an Angular injection context unless a `DestroyRef` is passed
+* explicitly via `options.destroyRef`.
+*
+* ```ts
+* readonly sendLimit = rateLimit({ kind: "token bucket", period: 1000, rate: 10 });
+* ```
+*/
+declare const rateLimit: (config: RateLimitConfig, options?: RateLimitOptions) => RateLimitResult;
+interface SubscriptionOptions {
+  /** Client to bind to. Defaults to the injected `LUNORA_CLIENT`. */
+  client?: LunoraClient;
+  /**
+  * `DestroyRef` whose `onDestroy` tears the subscription down. Defaults to
+  * `inject(DestroyRef)` — the calling component/service.
+  */
+  destroyRef?: DestroyRef;
+  /**
+  * Called when the subscription errors after the initial attach. Without it,
+  * a post-attach failure is dropped silently.
+  */
+  onError?: (error: SubscriptionError) => void;
+  /** Route to a specific shard when the target function is `.shardBy(...)`-partitioned. */
+  shardKey?: string;
+}
+interface SubscriptionResult<T> {
+  /** The latest value pushed by the server. `undefined` before the first frame. */
+  data: Signal<T | undefined>;
+  /** The latest error, or `undefined`. */
+  error: Signal<SubscriptionError | undefined>;
+}
+/**
+* Subscribe to a reactive server push stream. Returns `{ data, error }` signals
+* that update whenever the server emits a new value.
+*
+* Unlike `liveQuery`, which tracks a single value, `subscription` also
+* exposes an `error` signal for the async error channel. Use it for ephemeral,
+* high-frequency streams where you need error visibility.
+*
+* Pass `"skip"` as `args` to short-circuit — no network call, no socket.
+* The subscription tears down when the owning `DestroyRef` fires.
+*
+* Call from an injection context (component/service field or constructor):
+* ```ts
+* readonly stream = subscription(api.events.stream, { roomId: "general" });
+* ```
+*/
+declare const subscription: <F extends FunctionReference>(reference: F, args: ArgsOf<F> | "skip", options?: SubscriptionOptions) => SubscriptionResult<ReturnOf<F>>;
+export { type AuthOptions, type AuthResult, type ConnectionStatusOptions, type FlagContext, type FlagOptions, type FlagValue, type FlagsOptions, type HeartbeatReference, type HydratePreloadedOptions, type HydratePreloadedResult, type InfiniteQueryResult, LUNORA_CLIENT, type ListPresentReference, type LiveQueryOptions, type MutateOptions, type MutatorResult, type PaginatedQueryOptions, type PaginatedQueryResult, type PresenceOptions, type PresenceResult, type ProvideLunoraOptions, type RateLimitOptions, type RateLimitResult, type SubscriptionOptions, type SubscriptionResult, auth, connectionStatus, flag, flags, hydratePreloaded, infiniteQuery, injectLunoraClient, liveQuery, mutate, mutator, paginatedQuery, presence, provideLunora, rateLimit, subscription };

package/dist/index.mjs

@@ -1,5 +1,13 @@
+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-ClRc-7rL.mjs';
 export { liveQuery } from './packem_shared/liveQuery-D5VQBOgf.mjs';
 export { mutate } from './packem_shared/mutate-D3rEHwbb.mjs';
+export { mutator } from './packem_shared/mutator-BHL8bakL.mjs';
+export { infiniteQuery, paginatedQuery } from './packem_shared/infiniteQuery-DUV60k-n.mjs';
+export { presence } from './packem_shared/presence-h2xonCZM.mjs';
+export { rateLimit } from './packem_shared/rateLimit-CKcAig4M.mjs';
+export { subscription } from './packem_shared/subscription-Dd9dQiBB.mjs';
 export { SKIP } from '@lunora/client/query';

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/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-ClRc-7rL.mjs

@@ -0,0 +1,29 @@
+import { inject, DestroyRef, signal } from '@angular/core';
+import { resolveLunoraClient } from './LUNORA_CLIENT-DHUfNu9x.mjs';
+
+const hydratePreloaded = (preloaded, options = {}) => {
+  const client = resolveLunoraClient(options.client);
+  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 };
+  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-DUV60k-n.mjs

@@ -0,0 +1,200 @@
+import { computed, inject, DestroyRef, signal } from '@angular/core';
+import { initialPages, rebalance, derivePaginationStatus, applyLoadMore } from '@lunora/client/pagination';
+import { resolveLunoraClient } from './LUNORA_CLIENT-DHUfNu9x.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 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 syncSubscriptions = (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);
+    }
+  };
+  if (baseArgs !== "skip") {
+    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/mutator-BHL8bakL.mjs

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

package/dist/packem_shared/presence-h2xonCZM.mjs

@@ -0,0 +1,59 @@
+import { inject, DestroyRef, signal } from '@angular/core';
+import { resolveLunoraClient } from './LUNORA_CLIENT-DHUfNu9x.mjs';
+
+const makeSessionId = () => crypto.randomUUID();
+const DEFAULT_INTERVAL_MS = 1e4;
+const presence = (roomId, options) => {
+  const client = resolveLunoraClient(options.client);
+  const destroyRef = options.destroyRef ?? inject(DestroyRef);
+  const { heartbeat, listPresent, shardKey } = options;
+  const intervalMs = options.intervalMs ?? DEFAULT_INTERVAL_MS;
+  const sessionId = options.sessionId ?? makeSessionId();
+  const present = signal(void 0);
+  if (!Number.isFinite(intervalMs) || intervalMs <= 0) {
+    throw new RangeError(`presence intervalMs must be a positive number, got ${String(intervalMs)}`);
+  }
+  let latestData = options.data;
+  const releaseConnectionContext = client.acquireConnectionContext({ roomId, sessionId }, { shardKey });
+  const sendHeartbeat = () => {
+    const args = { roomId, sessionId };
+    if (latestData !== void 0) {
+      args.data = latestData;
+    }
+    client.mutation(heartbeat, args, { shardKey }).catch(() => void 0);
+  };
+  const setData = (next) => {
+    latestData = next;
+    sendHeartbeat();
+  };
+  sendHeartbeat();
+  const intervalHandle = setInterval(sendHeartbeat, intervalMs);
+  const onVisible = () => {
+    if (typeof document !== "undefined" && document.visibilityState === "visible") {
+      sendHeartbeat();
+    }
+  };
+  if (typeof document !== "undefined") {
+    document.addEventListener("visibilitychange", onVisible);
+  }
+  const listArgs = { roomId };
+  const unsubscribe = client.subscribe(
+    listPresent,
+    listArgs,
+    (value) => {
+      present.set(value);
+    },
+    { shardKey }
+  );
+  destroyRef.onDestroy(() => {
+    clearInterval(intervalHandle);
+    if (typeof document !== "undefined") {
+      document.removeEventListener("visibilitychange", onVisible);
+    }
+    releaseConnectionContext();
+    unsubscribe();
+  });
+  return { present: present.asReadonly(), sessionId, setData };
+};
+
+export { presence };

package/dist/packem_shared/rateLimit-CKcAig4M.mjs

@@ -0,0 +1,60 @@
+import { inject, DestroyRef, signal, computed } from '@angular/core';
+import { evaluate } from '@lunora/ratelimit';
+
+const rateLimit = (config, options = {}) => {
+  const destroyRef = options.destroyRef ?? inject(DestroyRef);
+  const now = options.now ?? Date.now;
+  const tickMs = options.tickMs ?? 1e3;
+  let value;
+  const epoch = signal(0);
+  const computeStatus = () => evaluate(config, value, { consume: false, count: 1, now: now(), reserve: false }).status;
+  const status = signal(computeStatus());
+  const bump = () => {
+    epoch.update((v) => v + 1);
+    status.set(computeStatus());
+  };
+  let intervalHandle;
+  const stopInterval = () => {
+    if (intervalHandle !== void 0) {
+      clearInterval(intervalHandle);
+      intervalHandle = void 0;
+    }
+  };
+  const startIntervalIfThrottled = () => {
+    if (status().ok || intervalHandle !== void 0) {
+      return;
+    }
+    intervalHandle = setInterval(() => {
+      bump();
+      if (status().ok) {
+        stopInterval();
+      }
+    }, tickMs);
+  };
+  startIntervalIfThrottled();
+  destroyRef.onDestroy(() => {
+    stopInterval();
+  });
+  return {
+    check: (count = 1) => evaluate(config, value, { consume: false, count, now: now(), reserve: false }).status.ok,
+    consume: (count = 1) => {
+      const result = evaluate(config, value, { consume: true, count, now: now(), reserve: false });
+      if (result.value !== void 0) {
+        value = result.value;
+      }
+      bump();
+      startIntervalIfThrottled();
+      return result.status;
+    },
+    disabled: computed(() => !status().ok),
+    ok: computed(() => status().ok),
+    reset: () => {
+      value = void 0;
+      stopInterval();
+      bump();
+    },
+    retryAfter: computed(() => status().retryAfter)
+  };
+};
+
+export { rateLimit };

package/dist/packem_shared/subscription-Dd9dQiBB.mjs

@@ -0,0 +1,37 @@
+import { inject, DestroyRef, signal } from '@angular/core';
+import { createQuerySubscription } from '@lunora/client/query';
+import { resolveLunoraClient } from './LUNORA_CLIENT-DHUfNu9x.mjs';
+
+const subscription = (reference, args, options = {}) => {
+  const client = resolveLunoraClient(options.client);
+  const destroyRef = options.destroyRef ?? inject(DestroyRef);
+  const data = signal(void 0);
+  const error = signal(void 0);
+  if (args !== "skip") {
+    const userOnError = options.onError;
+    const unsubscribe = createQuerySubscription(
+      client,
+      reference,
+      args,
+      {
+        onData: (next) => {
+          data.set(next);
+          error.set(void 0);
+        },
+        onError: (error_) => {
+          error.set(error_);
+          data.set(void 0);
+          userOnError?.(error_);
+        },
+        onReset: () => {
+          data.set(void 0);
+        }
+      },
+      { shardKey: options.shardKey }
+    );
+    destroyRef.onDestroy(unsubscribe);
+  }
+  return { data: data.asReadonly(), error: error.asReadonly() };
+};
+
+export { subscription };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/angular",
-  "version": "1.0.0-alpha.3",
+  "version": "1.0.0-alpha.5",
   "description": "Angular reactive adapter for Lunora — signal-based live queries and mutations",
   "keywords": [
     "angular",
@@ -45,7 +45,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@lunora/client": "1.0.0-alpha.19"
+    "@lunora/client": "1.0.0-alpha.19",
+    "@lunora/ratelimit": "1.0.0-alpha.5"
   },
   "peerDependencies": {
     "@angular/core": "^19.2.0 || ^20.0.0 || ^21.0.0 || ^22.0.0"