@lunora/db 1.0.0-alpha.24 → 1.0.0-alpha.25

package/dist/collections/index.d.mts

@@ -1,5 +1,5 @@
-export { type C as CheckpointRegistry, type L as LunoraCollectionConfig, type a as LunoraCollectionOptions, c as createCheckpointRegistry, l as lunoraCollectionOptions } from "../packem_shared/collection-options.d-Cd6j65i-.mjs";
-export { type C as CollectionDef, type I as InsertBinding, type L as LunoraDb, d as defineCollections } from "../packem_shared/define-collections.d-CSpxihIj.mjs";
+export { type C as CheckpointRegistry, type L as LunoraCollectionConfig, type a as LunoraCollectionOptions, c as createCheckpointRegistry, l as lunoraCollectionOptions } from "../packem_shared/collection-options.d-BPVkj5FW.mjs";
+export { type C as CollectionDef, type I as InsertBinding, type L as LunoraDb, d as defineCollections } from "../packem_shared/define-collections.d-C9paBiXl.mjs";
 import '@lunora/client';
 import '@tanstack/db';
 import '@tanstack/offline-transactions';

package/dist/collections/index.d.ts

@@ -1,5 +1,5 @@
-export { type C as CheckpointRegistry, type L as LunoraCollectionConfig, type a as LunoraCollectionOptions, c as createCheckpointRegistry, l as lunoraCollectionOptions } from "../packem_shared/collection-options.d-Cd6j65i-.js";
-export { type C as CollectionDef, type I as InsertBinding, type L as LunoraDb, d as defineCollections } from "../packem_shared/define-collections.d-CNkWbDe0.js";
+export { type C as CheckpointRegistry, type L as LunoraCollectionConfig, type a as LunoraCollectionOptions, c as createCheckpointRegistry, l as lunoraCollectionOptions } from "../packem_shared/collection-options.d-BPVkj5FW.js";
+export { type C as CollectionDef, type I as InsertBinding, type L as LunoraDb, d as defineCollections } from "../packem_shared/define-collections.d-Dkzt5xPY.js";
 import '@lunora/client';
 import '@tanstack/db';
 import '@tanstack/offline-transactions';

package/dist/index.d.mts

@@ -1,6 +1,6 @@
-export { type C as CheckpointRegistry, type E as ExecutorOutboxSinkOptions, type L as LunoraCollectionConfig, type a as LunoraCollectionOptions, O as OUTBOX_MUTATION_FN_NAME, type b as OutboxExecutor, type d as OutboxMutationMetadata, type R as Row, type S as SyncWriter, c as createCheckpointRegistry, e as createExecutorOutboxSink, f as createOptimisticOnlineDetector, l as lunoraCollectionOptions, m as makeDiffEmit, r as runOutboxMutation, t as toMap } from "./packem_shared/collection-options.d-Cd6j65i-.mjs";
-export { type C as CollectionDef, type D as DefineCollectionsOptions, type I as InsertBinding, type L as LunoraDb, type W as WriteRejectedEvent, d as defineCollections } from "./packem_shared/define-collections.d-CSpxihIj.mjs";
-export { type B as BindMutatorsContext, type a as BoundMutators, type C as ClientMutatorContext, type b as ClientMutatorDef, c as bindMutators, d as defineMutator } from "./packem_shared/define-mutators.d-B4FIhFEy.mjs";
+export { type C as CheckpointRegistry, type E as ExecutorOutboxSinkOptions, type L as LunoraCollectionConfig, type a as LunoraCollectionOptions, O as OUTBOX_MUTATION_FN_NAME, type b as OutboxExecutor, type d as OutboxMutationMetadata, type R as Row, type S as SyncWriter, c as createCheckpointRegistry, e as createExecutorOutboxSink, f as createOptimisticOnlineDetector, l as lunoraCollectionOptions, m as makeDiffEmit, r as runOutboxMutation, t as toMap } from "./packem_shared/collection-options.d-BPVkj5FW.mjs";
+export { type C as CollectionDef, type D as DefineCollectionsOptions, type I as InsertBinding, type L as LunoraDb, type W as WriteRejectedEvent, d as defineCollections } from "./packem_shared/define-collections.d-C9paBiXl.mjs";
+export { type B as BindMutatorsContext, type a as BoundMutators, type C as ClientMutatorContext, type b as ClientMutatorDef, c as bindMutators, d as defineMutator } from "./packem_shared/define-mutators.d-DTU85KL6.mjs";
 import '@lunora/client';
 import '@tanstack/db';
 import '@tanstack/offline-transactions';

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-export { type C as CheckpointRegistry, type E as ExecutorOutboxSinkOptions, type L as LunoraCollectionConfig, type a as LunoraCollectionOptions, O as OUTBOX_MUTATION_FN_NAME, type b as OutboxExecutor, type d as OutboxMutationMetadata, type R as Row, type S as SyncWriter, c as createCheckpointRegistry, e as createExecutorOutboxSink, f as createOptimisticOnlineDetector, l as lunoraCollectionOptions, m as makeDiffEmit, r as runOutboxMutation, t as toMap } from "./packem_shared/collection-options.d-Cd6j65i-.js";
-export { type C as CollectionDef, type D as DefineCollectionsOptions, type I as InsertBinding, type L as LunoraDb, type W as WriteRejectedEvent, d as defineCollections } from "./packem_shared/define-collections.d-CNkWbDe0.js";
-export { type B as BindMutatorsContext, type a as BoundMutators, type C as ClientMutatorContext, type b as ClientMutatorDef, c as bindMutators, d as defineMutator } from "./packem_shared/define-mutators.d-Cg_oXn60.js";
+export { type C as CheckpointRegistry, type E as ExecutorOutboxSinkOptions, type L as LunoraCollectionConfig, type a as LunoraCollectionOptions, O as OUTBOX_MUTATION_FN_NAME, type b as OutboxExecutor, type d as OutboxMutationMetadata, type R as Row, type S as SyncWriter, c as createCheckpointRegistry, e as createExecutorOutboxSink, f as createOptimisticOnlineDetector, l as lunoraCollectionOptions, m as makeDiffEmit, r as runOutboxMutation, t as toMap } from "./packem_shared/collection-options.d-BPVkj5FW.js";
+export { type C as CollectionDef, type D as DefineCollectionsOptions, type I as InsertBinding, type L as LunoraDb, type W as WriteRejectedEvent, d as defineCollections } from "./packem_shared/define-collections.d-Dkzt5xPY.js";
+export { type B as BindMutatorsContext, type a as BoundMutators, type C as ClientMutatorContext, type b as ClientMutatorDef, c as bindMutators, d as defineMutator } from "./packem_shared/define-mutators.d-DukVT0Y3.js";
 import '@lunora/client';
 import '@tanstack/db';
 import '@tanstack/offline-transactions';

package/dist/mutators/index.d.mts

@@ -1,5 +1,5 @@
-export { type B as BindMutatorsContext, type a as BoundMutators, type C as ClientMutatorContext, type b as ClientMutatorDef, c as bindMutators, d as defineMutator } from "../packem_shared/define-mutators.d-B4FIhFEy.mjs";
+export { type B as BindMutatorsContext, type a as BoundMutators, type C as ClientMutatorContext, type b as ClientMutatorDef, c as bindMutators, d as defineMutator } from "../packem_shared/define-mutators.d-DTU85KL6.mjs";
 import '@lunora/client';
 import '@tanstack/db';
-import "../packem_shared/collection-options.d-Cd6j65i-.mjs";
+import "../packem_shared/collection-options.d-BPVkj5FW.mjs";
 import '@tanstack/offline-transactions';

package/dist/mutators/index.d.ts

@@ -1,5 +1,5 @@
-export { type B as BindMutatorsContext, type a as BoundMutators, type C as ClientMutatorContext, type b as ClientMutatorDef, c as bindMutators, d as defineMutator } from "../packem_shared/define-mutators.d-Cg_oXn60.js";
+export { type B as BindMutatorsContext, type a as BoundMutators, type C as ClientMutatorContext, type b as ClientMutatorDef, c as bindMutators, d as defineMutator } from "../packem_shared/define-mutators.d-DukVT0Y3.js";
 import '@lunora/client';
 import '@tanstack/db';
-import "../packem_shared/collection-options.d-Cd6j65i-.js";
+import "../packem_shared/collection-options.d-BPVkj5FW.js";
 import '@tanstack/offline-transactions';

package/dist/packem_shared/collection-options.d-BPVkj5FW.d.mts

@@ -0,0 +1,227 @@
+import { OutboxSink, LunoraClient, FunctionReference, SubscriptionError } from '@lunora/client';
+import { CollectionConfig } from '@tanstack/db';
+import { OnlineDetector } from '@tanstack/offline-transactions';
+/**
+ * Reserved `mutationFns` key the unified outbox routes raw `client.mutation`
+ * offline writes through. `defineCollections` registers a handler under this
+ * name that reads `transaction.metadata` (functionPath + args) and replays the
+ * write, so a db app's direct mutations ride the same durable executor as its
+ * collection inserts instead of the standalone {@link OutboxSink} fallback.
+ */
+declare const OUTBOX_MUTATION_FN_NAME = "__lunora_outbox__";
+/** The metadata an outbox-routed transaction carries so its replay can call `client.mutation`. */
+interface OutboxMutationMetadata extends Record<string, unknown> {
+  args: Record<string, unknown>;
+  clientId: string;
+  functionPath: string;
+  /** Stable `${clientId}:${mutationId}` replay key; passed back as the mutation id so a committed-but-unacked replay is server-idempotent. */
+  idempotencyKey: string;
+  /** Issuing identity fingerprint; the replay handler drops the write when it no longer matches. */
+  identity: string | null;
+  mutationId: number;
+  shardKey?: string;
+}
+/** A committable outbox transaction handle (the `OfflineTransaction` the executor mints). */
+interface OutboxTransaction {
+  commit?: () => Promise<unknown>;
+  mutate: (callback: () => void) => unknown;
+}
+/**
+ * The slice of the TanStack `OfflineExecutor` the {@link createExecutorOutboxSink}
+ * drives. Declared structurally so `@lunora/db`'s outbox glue doesn't widen its
+ * coupling to the executor's full surface (and stays unit-testable with a fake).
+ */
+interface OutboxExecutor {
+  createOfflineTransaction: (options: {
+    autoCommit?: boolean;
+    idempotencyKey?: string;
+    metadata?: Record<string, unknown>;
+    mutationFnName: string;
+  }) => OutboxTransaction;
+  getPendingCount: () => number;
+}
+/** Tuning for {@link createExecutorOutboxSink}. */
+interface ExecutorOutboxSinkOptions {
+  /** Max persisted-but-unconfirmed writes before `enqueue` rejects with `OFFLINE_QUEUE_OVERFLOW` (default 1000, matching `OfflineQueue`). */
+  maxItems?: number;
+  /** `mutationFns` key the replay handler is registered under (default {@link OUTBOX_MUTATION_FN_NAME}). */
+  mutationFnName?: string;
+}
+/**
+ * The blessed {@link OutboxSink} over the TanStack `OfflineExecutor` — the single
+ * durable write path for a `@lunora/db` app. It persists each offline write as an
+ * executor transaction carrying the `client.mutation` target in `metadata`, then
+ * ports the two semantics the executor lacks vs the built-in `OfflineQueue`.
+ *
+ * First: a `maxItems` cap that **rejects** a new write at capacity with an
+ * `OFFLINE_QUEUE_OVERFLOW`-coded error — the {@link OutboxSink} contract, matching
+ * `OfflineQueue`. Rejecting (rather than evicting the oldest) preserves the
+ * at-least-once promise: an already-persisted write is never silently dropped, and
+ * the caller surfaces back-pressure to the issuing mutation (which rolls its
+ * optimistic write back).
+ * Second: the identity guard lives in the replay handler (`defineCollections`), which drops a write whose captured `identity` no longer matches — see {@link OutboxMutationMetadata}.
+ */
+declare const createExecutorOutboxSink: (executor: OutboxExecutor, options?: ExecutorOutboxSinkOptions) => OutboxSink;
+/** A row carrying the Lunora document id. */
+type Row = Record<string, unknown> & {
+  _id: string;
+};
+/** The subset of a TanStack DB sync write channel that {@link makeDiffEmit} drives. */
+interface SyncWriter<T extends object> {
+  begin: () => void;
+  commit: () => void;
+  write: (message: {
+    type: "insert" | "update";
+    value: T;
+  } | {
+    key: string;
+    type: "delete";
+  }) => void;
+}
+/** Index a row list into a keyed map. */
+declare const toMap: <T extends object>(rows: ReadonlyArray<T>, getKey: (row: T) => string) => Map<string, T>;
+/**
+ * Build an `emit(next)` that diffs a desired keyed snapshot into a collection's
+ * sync channel — only changed rows are written, so a reconnect snapshot or a
+ * scope change never churns the synced view out from under a pending optimistic
+ * row. The last-synced base is tracked in `syncedJson`.
+ *
+ * Change detection compares rows by `JSON.stringify`, which is key-order
+ * sensitive — safe here because server snapshots have stable column order
+ * across reconnects (same query projection). A sync source with unstable key
+ * ordering would need a structural compare instead.
+ *
+ * `syncedJson` holds the JSON-serialized form of each last-synced row, keyed
+ * by row id. It is the **sole** synced-state map — no parallel row-object map
+ * is kept. Each incoming value is serialized exactly once per tick (for both
+ * comparison and cache update), so the previous value is never re-serialized.
+ *
+ * Lifecycle: `syncedJson` must be owned by the caller at the same scope as any
+ * other per-collection state (e.g. outside the `sync.sync` callback), so the
+ * cache persists correctly across sync restarts. A new `makeDiffEmit` closure
+ * created on restart receives the same map reference and starts from the
+ * committed synced state — no spurious diffs on reconnect.
+ */
+declare const makeDiffEmit: <T extends object>(syncedJson: Map<string, string>, writer: SyncWriter<T>) => (next: Map<string, T>) => void;
+/**
+ * Run a Lunora mutation under the outbox's retry policy.
+ *
+ * The retryable/permanent split keys on whether the failure carries a server
+ * application error `code` (set by `@lunora/client`'s rpc when the server returns
+ * a `{ error: { code, … } }` envelope — validation, conflict, etc.). A coded
+ * error is a definite verdict: surface it as a `NonRetriableError` so the executor
+ * stops and TanStack DB rolls the optimistic insert back. Everything without a
+ * code is transient — a `fetch` network failure (`TypeError`) or an HTTP/infra
+ * blip the rpc surfaces as a code-less `Error` (a 5xx gateway page, a non-JSON
+ * body) — so it's rethrown as-is and the durable outbox replays it. Keying on
+ * `error instanceof TypeError` alone would wrongly drop the latter.
+ */
+declare const runOutboxMutation: (mutate: () => Promise<unknown>) => Promise<void>;
+/**
+ * An "always attempt" online detector. We deliberately don't trust
+ * `navigator.onLine`: some environments (and Playwright's `setOffline` under
+ * Firefox) leave it stuck, which would freeze the outbox. Instead the executor
+ * always tries the send and {@link runOutboxMutation}'s transient-error retry
+ * handles real offline; the periodic tick nudges the executor to drain the outbox
+ * so a queued write replays promptly once connectivity returns.
+ *
+ * `isOnline` is therefore intentionally always `true` — it gates the executor's
+ * attempts, not a UI signal. A consumer that wants to show real connectivity
+ * should read `navigator.onLine` itself, separately from this detector.
+ */
+declare const createOptimisticOnlineDetector: () => OnlineDetector;
+/**
+ * Resolves the TanStack optimistic-overlay drop against the server's confirmed
+ * watermarks. A mutator's optimistic transaction returns `awaitMutationId(id)`
+ * (or `awaitCheckpoint(cursor)`); TanStack keeps the overlay until that promise
+ * settles, so the row de-duplicates exactly as the synced server value lands — no
+ * flash of the optimistic row disappearing then reappearing.
+ *
+ * `resolve` is called by whoever owns the watermark stream — a `data`/`delta`
+ * frame's `lastMutationId`, or a shape poke's `checkpoint` — to advance the gates.
+ */
+interface CheckpointRegistry {
+  /** Resolve once the server has acknowledged the op-log `cursor`. */
+  awaitCheckpoint: (cursor: number) => Promise<void>;
+  /** Resolve once the server has echoed a `lastMutationId >= id` for this client. */
+  awaitMutationId: (id: number) => Promise<void>;
+  /** Advance the gates from a frame's watermark; later callers past the mark settle immediately. */
+  resolve: (watermark: {
+    checkpoint?: number;
+    mutationId?: number;
+  }) => void;
+}
+/** A standalone checkpoint/mutation-id registry (also embedded in {@link lunoraCollectionOptions}). */
+declare const createCheckpointRegistry: () => CheckpointRegistry;
+/**
+ * A replication-shape sync source (the local-first partial-replication path).
+ * Mutually exclusive with {@link LunoraCollectionConfig.list}: the collection
+ * live-syncs the named shape's rowset via the client's poke protocol
+ * (`subscribeShape`) instead of a full-table `list` query subscription.
+ */
+interface ShapeSource {
+  /** Validated shape parameters (the partition selector — e.g. `{ channelId }`). */
+  args?: Record<string, unknown>;
+  /** The `defineShape` export name registered in `LUNORA_SHAPES`. */
+  name: string;
+  /** Routes the subscription to a specific shard's DO when the table is sharded. */
+  shardKey?: string;
+}
+/** Declarative inputs for {@link lunoraCollectionOptions}. */
+interface LunoraCollectionConfig<TRow extends Row> {
+  /** The Lunora client to subscribe through. */
+  client: LunoraClient;
+  /** Row key extractor — defaults to `row._id`. */
+  getKey?: (row: TRow) => string;
+  /** Collection id (TanStack identity) — defaults to the `list` function path (or `shape:` + the shape name). */
+  id?: string;
+  /** The Lunora query that lists the rows (the full-table sync source). Mutually exclusive with {@link LunoraCollectionConfig.shape}. */
+  list?: FunctionReference;
+  /**
+   * When the collection starts syncing. `"lazy"` (default) starts on the first
+   * `useLiveQuery` subscriber; `"eager"` starts at creation (TanStack's
+   * `startSync`) — for small "instant" reference data you want warm at boot.
+   * No effect on a `scopeBy` collection, which has nothing to sync until scoped.
+   * (Even eager, TanStack pauses sync while there are no subscribers, per its
+   * `gcTime` lifecycle — "warm while referenced", not pinned forever.)
+   */
+  load?: "eager" | "lazy";
+  /** Notified when the underlying subscription errors; the collection always leaves `loading` regardless. */
+  onError?: (error: SubscriptionError) => void;
+  /** When set, the collection stays empty until {@link LunoraCollectionOptions.scope} points it at args (sharded). */
+  scopeBy?: string;
+  /** A replication shape as the sync source (partial replication). Mutually exclusive with {@link LunoraCollectionConfig.list}. */
+  shape?: ShapeSource;
+  /**
+   * Routes the `list` subscription — and the confirmed-mutation watermark its
+   * data/`settled` frames advance the checkpoint gate from — to a specific
+   * shard's DO. Applies to the `list` source; a `shape` carries its own
+   * {@link ShapeSource.shardKey}. Without it the list path falls back to the
+   * default ("") watermark bucket, which must not be compared against a
+   * per-shard mutator's sequence line (it would drop a sharded overlay early or
+   * hang it forever).
+   */
+  shardKey?: string;
+}
+/** The result of {@link lunoraCollectionOptions}: a TanStack collection config plus its sync controls. */
+interface LunoraCollectionOptions<TRow extends Row> {
+  /** Resolves optimistic-overlay drops against the server's confirmed watermarks. */
+  checkpoints: CheckpointRegistry;
+  /** Pass to TanStack's `createCollection`. */
+  config: CollectionConfig<TRow, string>;
+  /** Re-point a `scopeBy` collection's subscription (omit `args` to detach). No-op for unscoped collections. */
+  scope: (args?: Record<string, unknown>) => void;
+}
+/**
+ * Build a TanStack DB collection config (+ sync controls) that live-syncs a
+ * Lunora `list` query through the client. This is the reusable core lifted out of
+ * {@link import("./define-collections").defineCollections}: the same `makeDiffEmit`
+ * diff-into-channel, `autoIndex:"eager"` + B-tree indexes, scoped-resubscribe, and
+ * fail-safe `markReady`-on-error behavior, exposed as a standalone
+ * collection-options creator so apps (and codegen) can compose it directly.
+ *
+ * The returned `checkpoints` registry lets a mutator runtime resolve optimistic
+ * overlays against confirmed server watermarks (see {@link CheckpointRegistry}).
+ */
+declare const lunoraCollectionOptions: <TRow extends Row>(options: LunoraCollectionConfig<TRow>) => LunoraCollectionOptions<TRow>;
+export { CheckpointRegistry as C, ExecutorOutboxSinkOptions as E, LunoraCollectionConfig as L, OUTBOX_MUTATION_FN_NAME as O, Row as R, SyncWriter as S, LunoraCollectionOptions as a, OutboxExecutor as b, createCheckpointRegistry as c, OutboxMutationMetadata as d, createExecutorOutboxSink as e, createOptimisticOnlineDetector as f, lunoraCollectionOptions as l, makeDiffEmit as m, runOutboxMutation as r, toMap as t };

package/dist/packem_shared/collection-options.d-BPVkj5FW.d.ts

@@ -0,0 +1,227 @@
+import { OutboxSink, LunoraClient, FunctionReference, SubscriptionError } from '@lunora/client';
+import { CollectionConfig } from '@tanstack/db';
+import { OnlineDetector } from '@tanstack/offline-transactions';
+/**
+ * Reserved `mutationFns` key the unified outbox routes raw `client.mutation`
+ * offline writes through. `defineCollections` registers a handler under this
+ * name that reads `transaction.metadata` (functionPath + args) and replays the
+ * write, so a db app's direct mutations ride the same durable executor as its
+ * collection inserts instead of the standalone {@link OutboxSink} fallback.
+ */
+declare const OUTBOX_MUTATION_FN_NAME = "__lunora_outbox__";
+/** The metadata an outbox-routed transaction carries so its replay can call `client.mutation`. */
+interface OutboxMutationMetadata extends Record<string, unknown> {
+  args: Record<string, unknown>;
+  clientId: string;
+  functionPath: string;
+  /** Stable `${clientId}:${mutationId}` replay key; passed back as the mutation id so a committed-but-unacked replay is server-idempotent. */
+  idempotencyKey: string;
+  /** Issuing identity fingerprint; the replay handler drops the write when it no longer matches. */
+  identity: string | null;
+  mutationId: number;
+  shardKey?: string;
+}
+/** A committable outbox transaction handle (the `OfflineTransaction` the executor mints). */
+interface OutboxTransaction {
+  commit?: () => Promise<unknown>;
+  mutate: (callback: () => void) => unknown;
+}
+/**
+ * The slice of the TanStack `OfflineExecutor` the {@link createExecutorOutboxSink}
+ * drives. Declared structurally so `@lunora/db`'s outbox glue doesn't widen its
+ * coupling to the executor's full surface (and stays unit-testable with a fake).
+ */
+interface OutboxExecutor {
+  createOfflineTransaction: (options: {
+    autoCommit?: boolean;
+    idempotencyKey?: string;
+    metadata?: Record<string, unknown>;
+    mutationFnName: string;
+  }) => OutboxTransaction;
+  getPendingCount: () => number;
+}
+/** Tuning for {@link createExecutorOutboxSink}. */
+interface ExecutorOutboxSinkOptions {
+  /** Max persisted-but-unconfirmed writes before `enqueue` rejects with `OFFLINE_QUEUE_OVERFLOW` (default 1000, matching `OfflineQueue`). */
+  maxItems?: number;
+  /** `mutationFns` key the replay handler is registered under (default {@link OUTBOX_MUTATION_FN_NAME}). */
+  mutationFnName?: string;
+}
+/**
+ * The blessed {@link OutboxSink} over the TanStack `OfflineExecutor` — the single
+ * durable write path for a `@lunora/db` app. It persists each offline write as an
+ * executor transaction carrying the `client.mutation` target in `metadata`, then
+ * ports the two semantics the executor lacks vs the built-in `OfflineQueue`.
+ *
+ * First: a `maxItems` cap that **rejects** a new write at capacity with an
+ * `OFFLINE_QUEUE_OVERFLOW`-coded error — the {@link OutboxSink} contract, matching
+ * `OfflineQueue`. Rejecting (rather than evicting the oldest) preserves the
+ * at-least-once promise: an already-persisted write is never silently dropped, and
+ * the caller surfaces back-pressure to the issuing mutation (which rolls its
+ * optimistic write back).
+ * Second: the identity guard lives in the replay handler (`defineCollections`), which drops a write whose captured `identity` no longer matches — see {@link OutboxMutationMetadata}.
+ */
+declare const createExecutorOutboxSink: (executor: OutboxExecutor, options?: ExecutorOutboxSinkOptions) => OutboxSink;
+/** A row carrying the Lunora document id. */
+type Row = Record<string, unknown> & {
+  _id: string;
+};
+/** The subset of a TanStack DB sync write channel that {@link makeDiffEmit} drives. */
+interface SyncWriter<T extends object> {
+  begin: () => void;
+  commit: () => void;
+  write: (message: {
+    type: "insert" | "update";
+    value: T;
+  } | {
+    key: string;
+    type: "delete";
+  }) => void;
+}
+/** Index a row list into a keyed map. */
+declare const toMap: <T extends object>(rows: ReadonlyArray<T>, getKey: (row: T) => string) => Map<string, T>;
+/**
+ * Build an `emit(next)` that diffs a desired keyed snapshot into a collection's
+ * sync channel — only changed rows are written, so a reconnect snapshot or a
+ * scope change never churns the synced view out from under a pending optimistic
+ * row. The last-synced base is tracked in `syncedJson`.
+ *
+ * Change detection compares rows by `JSON.stringify`, which is key-order
+ * sensitive — safe here because server snapshots have stable column order
+ * across reconnects (same query projection). A sync source with unstable key
+ * ordering would need a structural compare instead.
+ *
+ * `syncedJson` holds the JSON-serialized form of each last-synced row, keyed
+ * by row id. It is the **sole** synced-state map — no parallel row-object map
+ * is kept. Each incoming value is serialized exactly once per tick (for both
+ * comparison and cache update), so the previous value is never re-serialized.
+ *
+ * Lifecycle: `syncedJson` must be owned by the caller at the same scope as any
+ * other per-collection state (e.g. outside the `sync.sync` callback), so the
+ * cache persists correctly across sync restarts. A new `makeDiffEmit` closure
+ * created on restart receives the same map reference and starts from the
+ * committed synced state — no spurious diffs on reconnect.
+ */
+declare const makeDiffEmit: <T extends object>(syncedJson: Map<string, string>, writer: SyncWriter<T>) => (next: Map<string, T>) => void;
+/**
+ * Run a Lunora mutation under the outbox's retry policy.
+ *
+ * The retryable/permanent split keys on whether the failure carries a server
+ * application error `code` (set by `@lunora/client`'s rpc when the server returns
+ * a `{ error: { code, … } }` envelope — validation, conflict, etc.). A coded
+ * error is a definite verdict: surface it as a `NonRetriableError` so the executor
+ * stops and TanStack DB rolls the optimistic insert back. Everything without a
+ * code is transient — a `fetch` network failure (`TypeError`) or an HTTP/infra
+ * blip the rpc surfaces as a code-less `Error` (a 5xx gateway page, a non-JSON
+ * body) — so it's rethrown as-is and the durable outbox replays it. Keying on
+ * `error instanceof TypeError` alone would wrongly drop the latter.
+ */
+declare const runOutboxMutation: (mutate: () => Promise<unknown>) => Promise<void>;
+/**
+ * An "always attempt" online detector. We deliberately don't trust
+ * `navigator.onLine`: some environments (and Playwright's `setOffline` under
+ * Firefox) leave it stuck, which would freeze the outbox. Instead the executor
+ * always tries the send and {@link runOutboxMutation}'s transient-error retry
+ * handles real offline; the periodic tick nudges the executor to drain the outbox
+ * so a queued write replays promptly once connectivity returns.
+ *
+ * `isOnline` is therefore intentionally always `true` — it gates the executor's
+ * attempts, not a UI signal. A consumer that wants to show real connectivity
+ * should read `navigator.onLine` itself, separately from this detector.
+ */
+declare const createOptimisticOnlineDetector: () => OnlineDetector;
+/**
+ * Resolves the TanStack optimistic-overlay drop against the server's confirmed
+ * watermarks. A mutator's optimistic transaction returns `awaitMutationId(id)`
+ * (or `awaitCheckpoint(cursor)`); TanStack keeps the overlay until that promise
+ * settles, so the row de-duplicates exactly as the synced server value lands — no
+ * flash of the optimistic row disappearing then reappearing.
+ *
+ * `resolve` is called by whoever owns the watermark stream — a `data`/`delta`
+ * frame's `lastMutationId`, or a shape poke's `checkpoint` — to advance the gates.
+ */
+interface CheckpointRegistry {
+  /** Resolve once the server has acknowledged the op-log `cursor`. */
+  awaitCheckpoint: (cursor: number) => Promise<void>;
+  /** Resolve once the server has echoed a `lastMutationId >= id` for this client. */
+  awaitMutationId: (id: number) => Promise<void>;
+  /** Advance the gates from a frame's watermark; later callers past the mark settle immediately. */
+  resolve: (watermark: {
+    checkpoint?: number;
+    mutationId?: number;
+  }) => void;
+}
+/** A standalone checkpoint/mutation-id registry (also embedded in {@link lunoraCollectionOptions}). */
+declare const createCheckpointRegistry: () => CheckpointRegistry;
+/**
+ * A replication-shape sync source (the local-first partial-replication path).
+ * Mutually exclusive with {@link LunoraCollectionConfig.list}: the collection
+ * live-syncs the named shape's rowset via the client's poke protocol
+ * (`subscribeShape`) instead of a full-table `list` query subscription.
+ */
+interface ShapeSource {
+  /** Validated shape parameters (the partition selector — e.g. `{ channelId }`). */
+  args?: Record<string, unknown>;
+  /** The `defineShape` export name registered in `LUNORA_SHAPES`. */
+  name: string;
+  /** Routes the subscription to a specific shard's DO when the table is sharded. */
+  shardKey?: string;
+}
+/** Declarative inputs for {@link lunoraCollectionOptions}. */
+interface LunoraCollectionConfig<TRow extends Row> {
+  /** The Lunora client to subscribe through. */
+  client: LunoraClient;
+  /** Row key extractor — defaults to `row._id`. */
+  getKey?: (row: TRow) => string;
+  /** Collection id (TanStack identity) — defaults to the `list` function path (or `shape:` + the shape name). */
+  id?: string;
+  /** The Lunora query that lists the rows (the full-table sync source). Mutually exclusive with {@link LunoraCollectionConfig.shape}. */
+  list?: FunctionReference;
+  /**
+   * When the collection starts syncing. `"lazy"` (default) starts on the first
+   * `useLiveQuery` subscriber; `"eager"` starts at creation (TanStack's
+   * `startSync`) — for small "instant" reference data you want warm at boot.
+   * No effect on a `scopeBy` collection, which has nothing to sync until scoped.
+   * (Even eager, TanStack pauses sync while there are no subscribers, per its
+   * `gcTime` lifecycle — "warm while referenced", not pinned forever.)
+   */
+  load?: "eager" | "lazy";
+  /** Notified when the underlying subscription errors; the collection always leaves `loading` regardless. */
+  onError?: (error: SubscriptionError) => void;
+  /** When set, the collection stays empty until {@link LunoraCollectionOptions.scope} points it at args (sharded). */
+  scopeBy?: string;
+  /** A replication shape as the sync source (partial replication). Mutually exclusive with {@link LunoraCollectionConfig.list}. */
+  shape?: ShapeSource;
+  /**
+   * Routes the `list` subscription — and the confirmed-mutation watermark its
+   * data/`settled` frames advance the checkpoint gate from — to a specific
+   * shard's DO. Applies to the `list` source; a `shape` carries its own
+   * {@link ShapeSource.shardKey}. Without it the list path falls back to the
+   * default ("") watermark bucket, which must not be compared against a
+   * per-shard mutator's sequence line (it would drop a sharded overlay early or
+   * hang it forever).
+   */
+  shardKey?: string;
+}
+/** The result of {@link lunoraCollectionOptions}: a TanStack collection config plus its sync controls. */
+interface LunoraCollectionOptions<TRow extends Row> {
+  /** Resolves optimistic-overlay drops against the server's confirmed watermarks. */
+  checkpoints: CheckpointRegistry;
+  /** Pass to TanStack's `createCollection`. */
+  config: CollectionConfig<TRow, string>;
+  /** Re-point a `scopeBy` collection's subscription (omit `args` to detach). No-op for unscoped collections. */
+  scope: (args?: Record<string, unknown>) => void;
+}
+/**
+ * Build a TanStack DB collection config (+ sync controls) that live-syncs a
+ * Lunora `list` query through the client. This is the reusable core lifted out of
+ * {@link import("./define-collections").defineCollections}: the same `makeDiffEmit`
+ * diff-into-channel, `autoIndex:"eager"` + B-tree indexes, scoped-resubscribe, and
+ * fail-safe `markReady`-on-error behavior, exposed as a standalone
+ * collection-options creator so apps (and codegen) can compose it directly.
+ *
+ * The returned `checkpoints` registry lets a mutator runtime resolve optimistic
+ * overlays against confirmed server watermarks (see {@link CheckpointRegistry}).
+ */
+declare const lunoraCollectionOptions: <TRow extends Row>(options: LunoraCollectionConfig<TRow>) => LunoraCollectionOptions<TRow>;
+export { CheckpointRegistry as C, ExecutorOutboxSinkOptions as E, LunoraCollectionConfig as L, OUTBOX_MUTATION_FN_NAME as O, Row as R, SyncWriter as S, LunoraCollectionOptions as a, OutboxExecutor as b, createCheckpointRegistry as c, OutboxMutationMetadata as d, createExecutorOutboxSink as e, createOptimisticOnlineDetector as f, lunoraCollectionOptions as l, makeDiffEmit as m, runOutboxMutation as r, toMap as t };