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

package/dist/packem_shared/{define-collections.d-Dkzt5xPY.d.ts → index.d-B_2dXw1Z.d.mts}

@@ -1,7 +1,7 @@
+import { R as Row } from "./collection-options.d-C2FdJw06.mjs";
 import { FunctionReference, SubscriptionError, LunoraClient } from '@lunora/client';
 import { Transaction, Collection } from '@tanstack/db';
 import { OfflineExecutor, StorageDiagnostic } from '@tanstack/offline-transactions';
-import { R as Row } from "./collection-options.d-BPVkj5FW.js";
 /** Element type of an array (the row type a `list` query returns). */
 type Element<T> = T extends ReadonlyArray<infer E> ? E : never;
 /** `true` for the `any` type, `false` otherwise. */
@@ -46,20 +46,31 @@ interface CollectionDef<TList extends FunctionReference, TInput = never> {
    * `loading` on error, and forwards the error here if supplied.
    */
   onError?: (error: SubscriptionError) => void;
-  /** A field that scopes the list (e.g. a shard key); makes the collection re-pointable via `scope`. */
+  /**
+   * The table's `.shardBy(...)` column; makes the collection re-pointable via
+   * `scope`. Unless `shardKey` pins a shard, its value is the shard key:
+   * `scope({ channelId })` subscribes to that channel's shard, and each
+   * `insert` goes to the shard its own row's value names, captured when queued
+   * so an offline write replays there even after the app re-scopes. Scope args
+   * or an inserted row without the field throw.
+   */
   scopeBy?: string;
   /**
-   * Routes the `list` subscription (and the confirmed-mutation watermark its
-   * frames advance the checkpoint gate from) to a specific shard's DO — so a
-   * sharded collection's overlay gate compares against that shard's mutator
-   * sequence line, not the default ("") watermark bucket.
+   * Pins the `list` subscription (and the confirmed-mutation watermark its
+   * frames advance the checkpoint gate from) to one shard's DO — so a sharded
+   * collection's overlay gate compares against that shard's mutator sequence
+   * line, not the default ("") watermark bucket. `insert` writes are routed
+   * with it too: subscriptions and the writes they observe have to land on the
+   * same Durable Object, and the server derives no shard from a mutation's args.
+   * Takes precedence over `scopeBy`; leave it unset when the shard should
+   * follow the scope.
    */
   shardKey?: string;
 }
 type AnyDef = CollectionDef<any, any>;
 /**
  * The public row type a collection exposes — the element type of its `list`
- * query's return, with no `& Row`: a `Collection&lt;T>` is invariant in `T`, so the
+ * query's return, with no `& Row`: a `Collection<T>` is invariant in `T`, so the
  * exposed type must be exactly the document type, not a subtype.
  */
 type RowOf<C extends AnyDef> = C["list"] extends FunctionReference<infer _K, infer _A, infer R> ? Element<R> : never;
@@ -161,6 +172,11 @@ interface LunoraDb<D extends Record<string, AnyDef>> {
  *
  * This is the hand-written form; `@lunora/codegen` can emit a fully-typed call to
  * it from `schema.ts`, so an app writes nothing.
+ *
+ * Keep a single instance and treat the returned collections as the one source of
+ * truth per table — do not mirror rows into a parallel store, or derived indexes
+ * built from the copy can silently read stale data (see the `@lunora/db` docs,
+ * "One source of truth per table").
  */
 declare const defineCollections: <D extends Record<string, AnyDef>>(client: LunoraClient, defs: D, options?: DefineCollectionsOptions) => LunoraDb<D>;
 export { CollectionDef as C, DefineCollectionsOptions as D, InsertBinding as I, LunoraDb as L, WriteRejectedEvent as W, defineCollections as d };

package/dist/packem_shared/index.d-t0PhXOHV.d.ts

@@ -0,0 +1,245 @@
+import { LunoraClient } from '@lunora/client';
+import { Collection, Transaction } from '@tanstack/db';
+import { b as CheckpointRegistry } from "./collection-options.d-C2FdJw06.js";
+/**
+ * TanStack DB's "direct transaction" marker.
+ *
+ * A completed transaction's optimistic rows are discarded as **stale** unless
+ * either a synced transaction for the same key is already queued, or the
+ * transaction carried this flag (`CollectionStateManager.recomputeOptimisticState`
+ * → `pendingOptimisticDirectUpserts`). Marked rows instead survive until a sync
+ * operation for that key actually lands, which is precisely the semantics a Lunora
+ * custom mutator needs: the server is the linearization point, so the prediction
+ * must stay visible until the authoritative row arrives. Without it, a text edit
+ * visibly reverts to the last synced value the moment the push is acked.
+ *
+ * The literal is pinned here because `@tanstack/db` does not re-export the constant
+ * from its package root (it lives in the unexported
+ * `collection/transaction-metadata` module). `__tests__/define-mutators.test.ts`
+ * reads that module off disk and fails if the upstream value ever changes.
+ */
+declare const DIRECT_TRANSACTION_METADATA_KEY = "__tanstack_db_direct";
+/**
+ * A map of wired collections, keyed by the name the optimistic bodies address them
+ * by.
+ *
+ * The row type is `any` on purpose. `Collection<T, string>` is **invariant** in
+ * `T` (its methods both consume and produce rows), so a concrete
+ * `Collection<Doc<"nodes"> & Row>` is NOT assignable to `Collection<Row>` — which
+ * is why the previous `Record<string, Collection<Row, string>>` forced an
+ * `as never` cast on every entry, and left `context.collections.<name>` too
+ * untyped to be worth using. Projects recover the concrete types by binding them
+ * once through {@link initMutators}.
+ */
+type CollectionMap = Record<string, Collection<any, string>>;
+/** The local store a client mutator's optimistic body writes against. */
+interface ClientMutatorContext<TCollections extends CollectionMap = CollectionMap> {
+  /** The wired collections, keyed by name — apply optimistic inserts/updates/deletes here. */
+  collections: TCollections;
+}
+/**
+ * A generated mutator reference (`api.mutators.sendMessage`), accepted by
+ * {@link defineMutator} in place of a hand-written path string.
+ *
+ * Declared structurally rather than imported from `@lunora/client` so this module
+ * keeps its narrow dependency surface; the shape matches `FunctionReference`, and
+ * the phantom marker carries the server mutator's arg type so the client body's
+ * args are **inferred** instead of restated.
+ */
+interface MutatorReference<TArgs = unknown> {
+  readonly __lunoraPhantom?: {
+    args: TArgs;
+    kind: unknown;
+    returns: unknown;
+  };
+  readonly __lunoraRef: string;
+}
+/** A client-side custom mutator: an optimistic body plus the path of its authoritative server impl. */
+interface ClientMutatorDef<TArgs, TCollections extends CollectionMap = CollectionMap> {
+  /** Brand so codegen / `bindMutators` can recognize a mutator definition. */
+  __lunoraClientMutator: true;
+  /** The optimistic update applied to the local collections before the server confirms. */
+  apply: (context: ClientMutatorContext<TCollections>, args: TArgs) => void;
+  /** The Lunora function path of the server-authoritative mutator (`defineMutator` on the server). */
+  serverRef: string;
+}
+/**
+ * Declare a client-side custom mutator. `apply` runs optimistically against the
+ * local TanStack collections; `serverRef` names the authoritative server mutator
+ * the write is pushed to over the watermark protocol. The server impl is the
+ * linearization point — this body is a prediction the server can override.
+ *
+ * **Pass a generated reference, not a string.** `serverRef: api.mutators.sendMessage`
+ * both binds the path at compile time — a rename, a typo, or a moved file becomes a
+ * type error instead of a mutation that silently fails at runtime — and **infers
+ * `TArgs` from the server mutator's own validators**, so the arg type is declared
+ * once on the server rather than restated in every client body:
+ *
+ * ```ts
+ * // Typed + checked: args inferred from the server mutator.
+ * defineMutator({
+ *     apply: ({ collections }, args) => { … },   // args: { channelId: Id<"channels">; text: string }
+ *     serverRef: api.mutators.sendMessage,
+ * });
+ *
+ * // Escape hatch: a path string still works, but nothing checks it and you must
+ * // restate the args yourself.
+ * defineMutator<{ text: string }>({ apply, serverRef: "mutators:sendMessage" });
+ * ```
+ *
+ * `context.collections` is typed by whatever map it is bound to — which for this
+ * standalone form is the widest one. Bind the concrete collections once with
+ * {@link initMutators} to get `collections.<name>` typed inside `apply`.
+ */
+declare const defineMutator: {
+  <TArgs = Record<string, unknown>>(definition: {
+    apply: (context: ClientMutatorContext, args: TArgs) => void;
+    serverRef: string;
+  }): ClientMutatorDef<TArgs>;
+  <TArgs>(definition: {
+    apply: (context: ClientMutatorContext, args: TArgs) => void;
+    serverRef: MutatorReference<TArgs>;
+  }): ClientMutatorDef<TArgs>;
+};
+/**
+ * A mutator map whose defs are bound to `TCollections`, arg types erased — the
+ * `TCollections`-pinned counterpart of {@link AnyMutatorMap}, and `any` for the
+ * same variance reason.
+ */
+type MutatorMapFor<TCollections extends CollectionMap> = Record<string, ClientMutatorDef<any, TCollections>>;
+type AnyMutatorMap = Record<string, ClientMutatorDef<any, any>>;
+/** Args type of a mutator definition, whatever collections map it was bound to. */
+type ArgsOf<M> = M extends ClientMutatorDef<infer A, infer _C> ? A : never;
+/** A mutator write that was permanently rejected, passed to {@link BindMutatorsContext.onWriteRejected}. */
+interface MutatorRejectedEvent {
+  /** The args the rejected call was made with. */
+  args: unknown;
+  /**
+   * The machine-readable reason when the server supplied one (e.g. `CONFLICT`,
+   * `FORBIDDEN`). Mirrors {@link import("./define-collections").WriteRejectedEvent.code}.
+   */
+  code?: string;
+  /** The error that rejected the write. */
+  error: Error;
+  /** The bound mutator's key in the map passed to `bindMutators`. */
+  mutator: string;
+  /** The `namespace:fn` path the push targeted. */
+  serverRef: string;
+}
+interface BindMutatorsContext<TCollections extends CollectionMap = CollectionMap> {
+  /**
+   * Resolves the optimistic-overlay drop against confirmed server watermarks: a
+   * mutation's overlay is held until the sync stream echoes
+   * `lastMutationId >= clientSeq` (via {@link CheckpointRegistry.resolve}), so the
+   * row never flashes out and back.
+   *
+   * Defaults to the shared per-shard registry for `client` + {@link BindMutatorsContext.shardKey}
+   * ({@link getShardCheckpoints}) — the same one
+   * {@link import("./collection-options").lunoraCollectionOptions} defaults to, so
+   * a shard's collections and its mutators gate on one watermark line without the
+   * caller wiring them together. Pass `false` to drop the overlay as soon as the
+   * server accepts the write (the by-value sync diff then converges the synced row
+   * in place).
+   */
+  checkpoints?: CheckpointRegistry | false;
+  /** The wired collections the optimistic bodies write against. */
+  collections: TCollections;
+  /**
+   * Called when a mutator's server push is permanently rejected — the aggregate
+   * failure channel for writes, symmetric with
+   * {@link import("./define-collections").DefineCollectionsOptions.onWriteRejected}
+   * on the outbox path.
+   *
+   * Supplying it also makes a **fire-and-forget** call safe: a bound handle
+   * returns a `Transaction` whose `isPersisted` promise rejects on failure, so a
+   * caller that neither awaits it nor attaches a `.catch` leaves an unhandled
+   * rejection. With this hook set, `bindMutators` consumes that rejection itself
+   * after reporting it — a caller that DOES await still sees the rejection, so
+   * per-call handling is unaffected.
+   *
+   * A throwing listener is swallowed: reporting a failure must not manufacture a
+   * second one.
+   */
+  onWriteRejected?: (event: MutatorRejectedEvent) => void;
+  /**
+   * Route each call to the shard its own args name: the value of this field
+   * (the table's `.shardBy(...)` column) is the shard key, exactly as for a
+   * `scopeBy` collection's inserts — so `sendMessage({ channelId, … })` lands
+   * on that channel's shard. Required when `checkpoints` comes from a
+   * `scopeBy` collection, unless `shardKey` pins one shard; a call whose args
+   * lack the field throws.
+   * {@link BindMutatorsContext.shardKey} takes precedence.
+   */
+  scopeBy?: string;
+  /** Pins every push to one shard. Takes precedence over {@link BindMutatorsContext.scopeBy}. */
+  shardKey?: string;
+}
+/** Calling a bound mutator runs the optimistic body + pushes the server write; returns the TanStack transaction. */
+type BoundMutators<M extends AnyMutatorMap> = { [K in keyof M]: (args: ArgsOf<M[K]>) => Transaction; };
+/**
+ * Bind a set of client mutators to a client + local store. Each returned handle,
+ * when called, opens a TanStack optimistic transaction: the mutator's `apply`
+ * body writes the predicted rows into the collections, and the transaction's
+ * `mutationFn` pushes the authoritative write through
+ * {@link LunoraClient.callMutator} under a monotonic per-client `clientSeq`.
+ *
+ * Rebase-on-poke is free — TanStack DB re-derives every pending optimistic overlay
+ * over the latest synced base on each sync tick. The overlay is dropped when the
+ * server confirms the write (and, if `checkpoints` is supplied, once it echoes the
+ * matching watermark so the synced row has landed).
+ *
+ * The `clientSeq` generator is seeded from the server's echoed watermark
+ * ({@link LunoraClient.confirmedMutationWatermark}) on every issue, so a reload —
+ * which resets this in-memory counter while the server keeps a durable per-client
+ * watermark — never reissues a sequence the DO has already applied. As a backstop
+ * for the very first push of a fresh session (before any ack has taught the client
+ * the watermark), a push the DO swallows as a replay (`applied === false`) is
+ * reissued above the now-known watermark instead of being mistaken for a confirmed
+ * write — closing the silent-drop window without risking a double-apply (a fresh
+ * session's first stale push provably cannot be an honest replay).
+ *
+ * Pushes are **serialized per binding** (a FIFO chain): the DO rejects any push
+ * with `clientSeq > watermark + 1` as `OUT_OF_ORDER` and drops the write, so two
+ * mutators fired concurrently must not race the network into a gap. Each push
+ * waits for the previous one's ack and assigns its `clientSeq` *inside* the
+ * critical section — from the live watermark — so the sequence is always exactly
+ * `watermark + 1`. Because a failed mutation never advances the server watermark,
+ * a permanently-rejected predecessor can't wedge the chain: the next push simply
+ * reclaims the same `watermark + 1` instead of leaving a hole the DO waits on.
+ */
+declare const bindMutators: <M extends AnyMutatorMap, TCollections extends CollectionMap = CollectionMap>(client: LunoraClient, context: BindMutatorsContext<TCollections>, mutators: M) => BoundMutators<M>;
+/** `defineMutator` + `bindMutators`, both bound to one project's collections map. */
+interface BoundMutatorApi<TCollections extends CollectionMap> {
+  /** {@link bindMutators}, with `collections` pinned to `TCollections`. */
+  bindMutators: <M extends MutatorMapFor<TCollections>>(client: LunoraClient, context: BindMutatorsContext<TCollections>, mutators: M) => BoundMutators<M>;
+  /** {@link defineMutator}, with `context.collections` typed as `TCollections`. */
+  defineMutator: {
+    <TArgs = Record<string, unknown>>(definition: {
+      apply: (context: ClientMutatorContext<TCollections>, args: TArgs) => void;
+      serverRef: string;
+    }): ClientMutatorDef<TArgs, TCollections>;
+    <TArgs>(definition: {
+      apply: (context: ClientMutatorContext<TCollections>, args: TArgs) => void;
+      serverRef: MutatorReference<TArgs>;
+    }): ClientMutatorDef<TArgs, TCollections>;
+  };
+}
+/**
+ * Bind the mutator surface to **this project's** collections map, once.
+ *
+ * `Collection` is invariant in its row type, so a shared
+ * `Record<string, Collection<Row, string>>` could neither accept a generated
+ * collection without an `as never` cast nor hand a usable type back to `apply` —
+ * which is why optimistic bodies tended to ignore `context.collections` and close
+ * over module-scope collection variables instead. Declaring the map once here
+ * fixes both ends: `bindMutators` takes the concrete collections cast-free, and
+ * `apply` reads `collections.<name>` at its real row type.
+ *
+ * Runtime-identical to the standalone {@link defineMutator} / {@link bindMutators}
+ * (this returns those very functions); only the types narrow.
+ * @example
+ * const { bindMutators, defineMutator } = initMutators<{ nodes: typeof wholeOutlineCollection }>();
+ * const setText = defineMutator({ apply: ({ collections }, args) => collections.nodes.update(args.id, setter), serverRef: api.mutators.setText });
+ */
+declare const initMutators: <TCollections extends CollectionMap>() => BoundMutatorApi<TCollections>;
+export { BindMutatorsContext as B, ClientMutatorContext as C, DIRECT_TRANSACTION_METADATA_KEY as D, MutatorReference as M, BoundMutatorApi as a, BoundMutators as b, ClientMutatorDef as c, CollectionMap as d, MutatorRejectedEvent as e, bindMutators as f, defineMutator as g, initMutators as i };

package/dist/packem_shared/{define-collections.d-C9paBiXl.d.mts → index.d-ypscb9Qp.d.ts}

@@ -1,7 +1,7 @@
+import { R as Row } from "./collection-options.d-C2FdJw06.js";
 import { FunctionReference, SubscriptionError, LunoraClient } from '@lunora/client';
 import { Transaction, Collection } from '@tanstack/db';
 import { OfflineExecutor, StorageDiagnostic } from '@tanstack/offline-transactions';
-import { R as Row } from "./collection-options.d-BPVkj5FW.mjs";
 /** Element type of an array (the row type a `list` query returns). */
 type Element<T> = T extends ReadonlyArray<infer E> ? E : never;
 /** `true` for the `any` type, `false` otherwise. */
@@ -46,20 +46,31 @@ interface CollectionDef<TList extends FunctionReference, TInput = never> {
    * `loading` on error, and forwards the error here if supplied.
    */
   onError?: (error: SubscriptionError) => void;
-  /** A field that scopes the list (e.g. a shard key); makes the collection re-pointable via `scope`. */
+  /**
+   * The table's `.shardBy(...)` column; makes the collection re-pointable via
+   * `scope`. Unless `shardKey` pins a shard, its value is the shard key:
+   * `scope({ channelId })` subscribes to that channel's shard, and each
+   * `insert` goes to the shard its own row's value names, captured when queued
+   * so an offline write replays there even after the app re-scopes. Scope args
+   * or an inserted row without the field throw.
+   */
   scopeBy?: string;
   /**
-   * Routes the `list` subscription (and the confirmed-mutation watermark its
-   * frames advance the checkpoint gate from) to a specific shard's DO — so a
-   * sharded collection's overlay gate compares against that shard's mutator
-   * sequence line, not the default ("") watermark bucket.
+   * Pins the `list` subscription (and the confirmed-mutation watermark its
+   * frames advance the checkpoint gate from) to one shard's DO — so a sharded
+   * collection's overlay gate compares against that shard's mutator sequence
+   * line, not the default ("") watermark bucket. `insert` writes are routed
+   * with it too: subscriptions and the writes they observe have to land on the
+   * same Durable Object, and the server derives no shard from a mutation's args.
+   * Takes precedence over `scopeBy`; leave it unset when the shard should
+   * follow the scope.
    */
   shardKey?: string;
 }
 type AnyDef = CollectionDef<any, any>;
 /**
  * The public row type a collection exposes — the element type of its `list`
- * query's return, with no `& Row`: a `Collection&lt;T>` is invariant in `T`, so the
+ * query's return, with no `& Row`: a `Collection<T>` is invariant in `T`, so the
  * exposed type must be exactly the document type, not a subtype.
  */
 type RowOf<C extends AnyDef> = C["list"] extends FunctionReference<infer _K, infer _A, infer R> ? Element<R> : never;
@@ -161,6 +172,11 @@ interface LunoraDb<D extends Record<string, AnyDef>> {
  *
  * This is the hand-written form; `@lunora/codegen` can emit a fully-typed call to
  * it from `schema.ts`, so an app writes nothing.
+ *
+ * Keep a single instance and treat the returned collections as the one source of
+ * truth per table — do not mirror rows into a parallel store, or derived indexes
+ * built from the copy can silently read stale data (see the `@lunora/db` docs,
+ * "One source of truth per table").
  */
 declare const defineCollections: <D extends Record<string, AnyDef>>(client: LunoraClient, defs: D, options?: DefineCollectionsOptions) => LunoraDb<D>;
 export { CollectionDef as C, DefineCollectionsOptions as D, InsertBinding as I, LunoraDb as L, WriteRejectedEvent as W, defineCollections as d };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/db",
-  "version": "1.0.0-alpha.25",
+  "version": "1.0.0-alpha.250",
   "description": "TanStack DB binding: typed, live-synced collections and a durable offline outbox over the Lunora client",
   "keywords": [
     "cloudflare",
@@ -54,8 +54,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@lunora/client": "1.0.0-alpha.25",
-    "@lunora/errors": "1.0.0-alpha.6"
+    "@lunora/client": "1.0.0-alpha.249",
+    "@lunora/errors": ">=1.0.0-alpha.51 <2.0.0-0"
   },
   "peerDependencies": {
     "@tanstack/db": "^0.6.0",

package/dist/packem_shared/OUTBOX_MUTATION_FN_NAME-9fqK7rND.mjs

@@ -1,131 +0,0 @@
-import { createCollection, safeRandomUUID } from '@tanstack/db';
-import { NonRetriableError } from '@tanstack/offline-transactions';
-
-const OUTBOX_DRAIN_INTERVAL_MS = 1e3;
-const OUTBOX_MUTATION_FN_NAME = "__lunora_outbox__";
-const outboxCarriers = /* @__PURE__ */ new WeakMap();
-const createOutboxCarrier = () => createCollection({
-  // eslint-disable-next-line no-underscore-dangle -- `_id` is the Lunora document-id field
-  getKey: (row) => row._id,
-  id: `${OUTBOX_MUTATION_FN_NAME}:${safeRandomUUID()}`,
-  startSync: true,
-  sync: {
-    // Nothing syncs into the carrier — mark it ready immediately.
-    sync: (writer) => {
-      writer.markReady();
-      return () => void 0;
-    }
-  }
-});
-const registerOutboxCarrier = (executor, carrier) => {
-  outboxCarriers.set(executor, carrier);
-};
-let warnedMissingCarrier = false;
-const createExecutorOutboxSink = (executor, options = {}) => {
-  const maxItems = options.maxItems ?? 1e3;
-  const mutationFunctionName = options.mutationFnName ?? OUTBOX_MUTATION_FN_NAME;
-  return {
-    enqueue(mutation) {
-      if (executor.getPendingCount() >= maxItems) {
-        const error = new Error("offline outbox is full");
-        error.code = "OFFLINE_QUEUE_OVERFLOW";
-        return Promise.reject(error);
-      }
-      const metadata = {
-        args: mutation.args,
-        clientId: mutation.clientId,
-        functionPath: mutation.functionPath,
-        // Persist the stable replay key so a committed-but-unacked retry
-        // resends the same `x-lunora-mutation-id` and the server dedups it.
-        idempotencyKey: mutation.idempotencyKey,
-        identity: mutation.identity,
-        mutationId: mutation.mutationId,
-        shardKey: mutation.shardKey
-      };
-      const carrier = outboxCarriers.get(executor);
-      if (!carrier && !warnedMissingCarrier) {
-        warnedMissingCarrier = true;
-        console.warn(
-          "[@lunora/db] createExecutorOutboxSink: no outbox carrier is registered for this executor. On a TanStack OfflineExecutor a zero-mutation transaction is silently dropped, so offline writes may be lost — wire the sink to the executor returned by defineCollections()."
-        );
-      }
-      const transaction = executor.createOfflineTransaction({
-        autoCommit: false,
-        idempotencyKey: mutation.idempotencyKey,
-        metadata,
-        mutationFnName: mutationFunctionName
-      });
-      transaction.mutate(() => {
-        carrier?.insert({ _id: mutation.idempotencyKey });
-      });
-      transaction.commit?.().catch(() => void 0);
-      return Promise.resolve();
-    }
-  };
-};
-const toMap = (rows, getKey) => {
-  const map = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    map.set(getKey(row), row);
-  }
-  return map;
-};
-const makeDiffEmit = (syncedJson, writer) => (next) => {
-  writer.begin();
-  const nextJson = /* @__PURE__ */ new Map();
-  for (const [key, value] of next) {
-    const valueJson = JSON.stringify(value);
-    nextJson.set(key, valueJson);
-    if (!syncedJson.has(key)) {
-      writer.write({ type: "insert", value });
-    } else if (syncedJson.get(key) !== valueJson) {
-      writer.write({ type: "update", value });
-    }
-  }
-  for (const key of syncedJson.keys()) {
-    if (!next.has(key)) {
-      writer.write({ key, type: "delete" });
-    }
-  }
-  writer.commit();
-  syncedJson.clear();
-  for (const [key, valueJson] of nextJson) {
-    syncedJson.set(key, valueJson);
-  }
-};
-const runOutboxMutation = async (mutate) => {
-  try {
-    await mutate();
-  } catch (error) {
-    if (typeof error.code === "string") {
-      const nonRetriable = new NonRetriableError(error instanceof Error ? error.message : String(error));
-      nonRetriable.code = error.code;
-      throw nonRetriable;
-    }
-    throw error;
-  }
-};
-const createOptimisticOnlineDetector = () => {
-  const intervals = /* @__PURE__ */ new Set();
-  return {
-    dispose: () => {
-      for (const handle of intervals) {
-        clearInterval(handle);
-      }
-      intervals.clear();
-    },
-    isOnline: () => true,
-    notifyOnline: () => {
-    },
-    subscribe: (callback) => {
-      const handle = setInterval(callback, OUTBOX_DRAIN_INTERVAL_MS);
-      intervals.add(handle);
-      return () => {
-        clearInterval(handle);
-        intervals.delete(handle);
-      };
-    }
-  };
-};
-
-export { OUTBOX_MUTATION_FN_NAME, createExecutorOutboxSink, createOptimisticOnlineDetector, createOutboxCarrier, makeDiffEmit, registerOutboxCarrier, runOutboxMutation, toMap };

package/dist/packem_shared/bindMutators-B_RaNgel.mjs

@@ -1,70 +0,0 @@
-import { LunoraError } from '@lunora/errors';
-import { createTransaction } from '@tanstack/db';
-import { runOutboxMutation } from './OUTBOX_MUTATION_FN_NAME-9fqK7rND.mjs';
-
-const defineMutator = (definition) => {
-  return {
-    __lunoraClientMutator: true,
-    apply: definition.apply,
-    serverRef: definition.serverRef
-  };
-};
-const bindMutators = (client, context, mutators) => {
-  const maxReissues = 32;
-  let counter = 0;
-  const nextClientSeq = () => {
-    counter = Math.max(counter, client.confirmedMutationWatermark(context.shardKey)) + 1;
-    return counter;
-  };
-  let pushChain = Promise.resolve();
-  const pushSerialized = (serverRef, args) => {
-    const run = pushChain.then(async () => {
-      for (let attempt = 0; ; attempt += 1) {
-        const clientSeq = nextClientSeq();
-        const { applied } = await client.callMutator(serverRef, args, {
-          clientSeq,
-          shardKey: context.shardKey
-        });
-        if (applied) {
-          return clientSeq;
-        }
-        if (attempt >= maxReissues) {
-          throw new LunoraError(
-            "INTERNAL",
-            `lunora: custom mutator "${serverRef}" could not claim a fresh client sequence after ${String(maxReissues)} attempts`
-          );
-        }
-      }
-    });
-    pushChain = run.then(
-      () => void 0,
-      () => void 0
-    );
-    return run;
-  };
-  const bound = {};
-  for (const [name, mutator] of Object.entries(mutators)) {
-    bound[name] = (args) => {
-      const transaction = createTransaction({
-        autoCommit: true,
-        metadata: { serverRef: mutator.serverRef },
-        mutationFn: async () => {
-          let appliedSeq = 0;
-          await runOutboxMutation(async () => {
-            appliedSeq = await pushSerialized(mutator.serverRef, args);
-          });
-          if (context.checkpoints) {
-            await context.checkpoints.awaitMutationId(appliedSeq);
-          }
-        }
-      });
-      transaction.mutate(() => {
-        mutator.apply({ collections: context.collections }, args);
-      });
-      return transaction;
-    };
-  }
-  return bound;
-};
-
-export { bindMutators, defineMutator };