@abloatai/humans 0.37.0

package/src/local/mutators/defineMutators.ts

@@ -0,0 +1,76 @@
+/**
+ * Declares a tree of named custom mutators grouped by model key. Each mutator is
+ * a plain async function that receives `{ tx, args }` and composes any number of
+ * `tx.mutations.*` and `tx.read.*` calls to carry out a named operation, such as
+ * `sections.createWithBlocks`.
+ *
+ * The function is purely a place for types to anchor and returns its input
+ * unchanged; the runtime that dispatches a mutator lives elsewhere — the
+ * transaction object it receives and the React hook that invokes it. Because
+ * `defineMutators(schema, { ... })` returns the exact object you wrote,
+ * `typeof mutators` carries every mutator's precise `args` and result types
+ * through to wherever they are invoked.
+ */
+
+import type { Schema } from '@abloatai/transaction/schema/schema';
+import type { Transaction } from './Transaction.js';
+import type { ResolveSchema } from '@abloatai/transaction/types/global';
+
+/**
+ * `ResolveSchema` narrowed to satisfy the `Schema` bound — mirrors
+ * {@link Ablo.RegisteredSchema}. When nothing is registered, `ResolveSchema`
+ * is a loose `{ models }` shape that doesn't extend `Schema`, so we fall back
+ * to `Schema` to keep the mutator tree typed rather than collapsing.
+ */
+type RegisteredSchema = ResolveSchema extends Schema ? ResolveSchema : Schema;
+
+/**
+ * The signature of a single custom mutator. The engine supplies `tx`; you control
+ * `args`, in whatever shape you like, and the resolved return value. `TArgs` and
+ * `TResult` are bounded by `unknown` rather than `any`, so a mixed tree of
+ * mutators can be typed together without falling back to `any`.
+ */
+export type MutatorFn<S extends Schema, TArgs, TResult = void> = (
+  options: { tx: Transaction<S>; args: TArgs },
+) => Promise<TResult>;
+
+/**
+ * The shape {@link defineMutators} accepts: an optional record per model key
+ * whose values are named mutator functions. The `unknown` bounds keep the public
+ * boundary type-safe without `any`; when you write your mutators inline,
+ * TypeScript still infers the concrete `args` and result of each function, so the
+ * `unknown` here is only a ceiling, not what you end up working with.
+ */
+export type MutatorDefs<S extends Schema> = {
+  [K in keyof S['models']]?: Record<string, MutatorFn<S, never, unknown>>;
+};
+
+/**
+ * Returns the mutators object unchanged while constraining its shape against the
+ * schema. The `S` generic pins the model keys, and the `M` generic is inferred as
+ * a `const`, so each mutator's literal signature survives. There is no runtime
+ * work here; the function exists purely as a place for type inference to anchor.
+ */
+export function defineMutators<
+  S extends Schema,
+  const M extends MutatorDefs<S>,
+>(_schema: S, mutators: M): M;
+/**
+ * Register-anchored overload: omit the schema value and the tree is typed
+ * against `ResolveSchema` (this app's registered schema). Shared product code
+ * used across apps that bind different schemas should use this form — it moves
+ * with each app's `Register` instead of pinning one concrete schema, so the
+ * mutator tree stays assignable at every consumer (which reads the same
+ * `Register`). See docs/plans/per-product-schema-projections.md.
+ */
+export function defineMutators<const M extends MutatorDefs<RegisteredSchema>>(
+  mutators: M,
+): M;
+export function defineMutators(
+  schemaOrMutators: Schema | MutatorDefs<Schema>,
+  maybeMutators?: MutatorDefs<Schema>,
+): MutatorDefs<Schema> {
+  // The schema argument is a type anchor only — never read at runtime. With one
+  // argument the mutator tree is in the first slot; with two it's in the second.
+  return (maybeMutators ?? schemaOrMutators) as MutatorDefs<Schema>;
+}

package/src/local/mutators/inverseOp.ts

@@ -0,0 +1,83 @@
+/**
+ * The reversible-operation model for the undo system, expressed as Zod schemas.
+ *
+ * These schemas serve two roles. First, the {@link InverseOp} and
+ * {@link UndoEntry} TypeScript types are derived from them with `z.infer`, so
+ * the runtime shape and the static type stay in step. Second, they form a
+ * validation boundary: an inverse operation is stored as a plain JSON record
+ * (a model key plus row data) so the undo manager can replay it without knowing
+ * your schema. {@link parseUndoEntry} validates an untrusted value at that
+ * boundary — for example, an entry restored from persisted history — before it
+ * re-enters the replay path.
+ *
+ * The operation kinds match the mutator surface one for one — single
+ * (`create`, `update`, `delete`) and batch (`createMany`, `updateMany`,
+ * `deleteMany`) — so a recorded entry mirrors the call that produced it.
+ */
+
+import { z } from 'zod';
+import { AbloValidationError } from '@abloatai/transaction/errors';
+
+/** A row payload — JSON-shaped record used by create/createMany inverses. */
+const rowDataSchema = z.record(z.string(), z.unknown());
+
+/**
+ * An update patch: an `id` plus the changed fields. Modeled as an object with
+ * a required `id` and an open `catchall`, so `z.infer` yields
+ * `{ id: string } & { [k: string]: unknown }` — the exact shape the recorder
+ * builds and the replayer consumes.
+ */
+const patchSchema = z.object({ id: z.string() }).catchall(z.unknown());
+
+/**
+ * A single reversible operation. Discriminated on `kind` so a malformed op
+ * fails fast with a precise path (e.g. `inverses[2].patch.id`) rather than a
+ * vague union mismatch. Model keys/data are strings/records — the manager is
+ * schema-agnostic; the transaction it replays through is schema-typed.
+ */
+export const inverseOpSchema = z.discriminatedUnion('kind', [
+  z.object({ kind: z.literal('create'), modelKey: z.string(), data: rowDataSchema }),
+  z.object({ kind: z.literal('update'), modelKey: z.string(), patch: patchSchema }),
+  z.object({ kind: z.literal('delete'), modelKey: z.string(), id: z.string() }),
+  z.object({ kind: z.literal('createMany'), modelKey: z.string(), data: z.array(rowDataSchema) }),
+  z.object({ kind: z.literal('updateMany'), modelKey: z.string(), patches: z.array(patchSchema) }),
+  z.object({ kind: z.literal('deleteMany'), modelKey: z.string(), ids: z.array(z.string()) }),
+]);
+
+/** One undo entry = one mutator invocation's inverses + paired forwards. */
+export const undoEntrySchema = z.object({
+  /** Optional label for diagnostics / UI ("Move block", "Delete section", etc). */
+  label: z.string().optional(),
+  /** Applied (in array order) to reverse the invocation. */
+  inverses: z.array(inverseOpSchema),
+  /**
+   * Paired forward ops, captured at record time so redo can replay them
+   * without re-running the user's mutator (which may have non-idempotent
+   * side effects like generating new IDs).
+   */
+  forwards: z.array(inverseOpSchema),
+});
+
+/** A single reversible operation (schema-derived). */
+export type InverseOp = z.infer<typeof inverseOpSchema>;
+
+/** One undo/redo stack entry (schema-derived). */
+export type UndoEntry = z.infer<typeof undoEntrySchema>;
+
+/**
+ * Validate an untrusted value as an `UndoEntry`. Use at any boundary where an
+ * entry crosses out of internal construction — deserialization from
+ * persistence, or a defensive check at the recording ingestion point. Throws
+ * `AbloValidationError` (code `undo_entry_invalid`) with the failing Zod path
+ * in `details` so the offending op is obvious.
+ */
+export function parseUndoEntry(value: unknown): UndoEntry {
+  const result = undoEntrySchema.safeParse(value);
+  if (!result.success) {
+    throw new AbloValidationError('Undo entry failed inverse-op schema validation.', {
+      code: 'undo_entry_invalid',
+      details: { issues: result.error.issues },
+    });
+  }
+  return result.data;
+}

package/src/local/mutators/mutateActions.ts

@@ -0,0 +1,167 @@
+import { Model, modelAsRow } from '../Model.js';
+import { AbloValidationError } from '@abloatai/transaction/errors';
+import type { Schema, InferModel, InferCreate } from '@abloatai/transaction/schema/schema';
+import type { ModelDef } from '@abloatai/transaction/schema/model';
+// Type-only — `SyncStoreContract` is the store interface; importing the type
+// does not pull the React `context` module's runtime.
+import type { SyncStoreContract } from '../storeContract.js';
+
+/**
+ * The create, update, and delete actions for one model. Each action is
+ * overloaded: pass a single row to act on one entity, or an array to act on
+ * many within the same synchronous tick. An array call stages every entry
+ * together through `Promise.all`, so the microtask coalescer in
+ * `MutationQueue` collapses the whole batch into one commit on the wire.
+ *
+ * These are plain imperative actions with no React dependency. The transaction
+ * system (`Transaction` and `RecordingMutation`) and `BaseSyncedStore` build
+ * on them, and application code reaches them through `ablo.<model>.create`,
+ * `ablo.<model>.update`, and `ablo.<model>.delete`.
+ */
+type UpdatePatch<S extends Schema, K extends keyof S['models'] & string> =
+  { id: string } & Partial<InferModel<S, K>>;
+
+export interface MutateActions<S extends Schema, K extends keyof S['models'] & string> {
+  /**
+   * Create one entity, or an array of entities in a single tick. ID,
+   * createdAt, updatedAt, organizationId default automatically per row.
+   */
+  create(data: InferCreate<S, K>): Promise<InferModel<S, K>>;
+  create(data: InferCreate<S, K>[]): Promise<InferModel<S, K>[]>;
+  /**
+   * Update one row, or an array of rows in a single tick. Each patch is
+   * `{ id, ...changes }` — missing ids throw. Schema-generated models are
+   * MobX-observable, so direct assignment fires reactivity.
+   */
+  update(patch: UpdatePatch<S, K>): Promise<InferModel<S, K>>;
+  update(patches: UpdatePatch<S, K>[]): Promise<InferModel<S, K>[]>;
+  /**
+   * Delete one row by id, or an array of ids in a single tick. Missing ids
+   * are silently ignored.
+   */
+  delete(id: string): Promise<void>;
+  delete(ids: string[]): Promise<void>;
+  /** Soft-archive by ID. */
+  archive: (id: string) => Promise<void>;
+  /** Restore an archived entity by ID. */
+  unarchive: (id: string) => Promise<void>;
+}
+
+/** Builds the create, update, and delete actions for one model over a store. */
+export function createMutateActions<
+  S extends Schema,
+  K extends keyof S['models'] & string,
+>(
+  schema: S,
+  modelKey: K,
+  store: SyncStoreContract,
+  organizationId: string,
+): MutateActions<S, K> {
+  const modelDef = (schema.models as Record<string, ModelDef>)[modelKey];
+  const typename = modelDef?.typename ?? modelKey;
+
+  // Materialise one input row into a Model and stage a save. The default
+  // fields land here once so create-of-one and create-of-array share the
+  // same defaulting logic.
+  const buildModelForCreate = (data: InferCreate<S, K>, now: Date): Model => {
+    const record = data as Record<string, unknown>;
+    const fullData = {
+      ...record,
+      __typename: typename,
+      id: (record.id as string | undefined) ?? Model.generateId(),
+      organizationId:
+        (record.organizationId as string | undefined) ?? organizationId,
+      createdAt: (record.createdAt as Date | undefined) ?? now,
+      updatedAt: (record.updatedAt as Date | undefined) ?? now,
+    };
+    const model = store.pool.createFromData(fullData);
+    if (!model) {
+      throw new AbloValidationError(
+        `createMutateActions: failed to create ${typename} — no constructor in registry`,
+        { code: 'mutate_create_unknown_model' },
+      );
+    }
+    return model;
+  };
+
+  // Apply a patch onto an existing pool model. Returns the model.
+  const applyPatch = (patch: UpdatePatch<S, K>, now: Date): Model => {
+    const { id, ...changes } = patch;
+    const model = store.pool.get(id);
+    if (!model) {
+      throw new AbloValidationError(
+        `createMutateActions: ${typename} with id "${id}" not found in pool`,
+        { code: 'mutate_update_entity_not_found' },
+      );
+    }
+    // Schema-derived patch keys are validated at the call-site type signature
+    // (`UpdatePatch<S, K>`); writes here are dynamic-class field assignments.
+    // `Reflect.set` is the typed bridge — Model carries no index signature, but
+    // the dynamic field installation in `createDynamicModelClass` guarantees
+    // these keys resolve at runtime.
+    for (const [fieldName, value] of Object.entries(changes)) {
+      Reflect.set(model, fieldName, value);
+    }
+    Reflect.set(model, 'updatedAt', now);
+    return model;
+  };
+
+  return {
+    // Overloaded — runtime `Array.isArray` decides shape. Both branches stage
+    // via `Promise.all` so the microtask coalescer collapses N pushes into one
+    // wire commit.
+    create: (async (data: InferCreate<S, K> | InferCreate<S, K>[]) => {
+      const now = new Date();
+      if (Array.isArray(data)) {
+        if (data.length === 0) return [];
+        const models = data.map((d) => buildModelForCreate(d, now));
+        await Promise.all(models.map((m) => store.save(m)));
+        return models.map((m) => modelAsRow<InferModel<S, K>>(m));
+      }
+      const model = buildModelForCreate(data, now);
+      await store.save(model);
+      return modelAsRow<InferModel<S, K>>(model);
+    }) as MutateActions<S, K>['create'],
+
+    update: (async (patch: UpdatePatch<S, K> | UpdatePatch<S, K>[]) => {
+      const now = new Date();
+      if (Array.isArray(patch)) {
+        if (patch.length === 0) return [];
+        const models = patch.map((p) => applyPatch(p, now));
+        await Promise.all(models.map((m) => store.save(m)));
+        return models.map((m) => modelAsRow<InferModel<S, K>>(m));
+      }
+      const model = applyPatch(patch, now);
+      await store.save(model);
+      return modelAsRow<InferModel<S, K>>(model);
+    }) as MutateActions<S, K>['update'],
+
+    delete: (async (idOrIds: string | string[]) => {
+      if (Array.isArray(idOrIds)) {
+        if (idOrIds.length === 0) return;
+        const models: Model[] = [];
+        for (const id of idOrIds) {
+          const m = store.pool.get(id);
+          if (m) models.push(m);
+        }
+        await Promise.all(models.map((m) => store.delete(m)));
+        return;
+      }
+      const model = store.pool.get(idOrIds);
+      if (!model) return;
+      await store.delete(model);
+    }),
+
+    archive: async (id) => {
+      const model = store.pool.get(id);
+      if (!model) return;
+      await store.archive(model);
+    },
+
+    unarchive: async (id) => {
+      const model = store.pool.get(id);
+      if (!model) return;
+      await store.unarchive(model);
+    },
+  };
+}

package/src/local/mutators/readerActions.ts

@@ -0,0 +1,99 @@
+import type { Schema, InferModel } from '@abloatai/transaction/schema/schema';
+import type { ModelDef } from '@abloatai/transaction/schema/model';
+// Type-only — see the note in `mutateActions.ts`.
+import type { SyncStoreContract } from '../storeContract.js';
+
+/**
+ * Imperative, non-reactive reads over a store for one model. The `retrieve`,
+ * `list`, and `count` actions each return a one-time snapshot and do not
+ * subscribe to later changes; the transaction system and `BaseSyncedStore`
+ * build on them. For reactive reads inside a component, read through `useAblo`,
+ * for example `useAblo((ablo) => ablo.<model>.list(options))`.
+ */
+export interface ReaderFindOptions<T> {
+  /** Equality filter. Uses a foreign-key index when the field has one registered. */
+  where?: Partial<T>;
+  /** A predicate applied after the `where` filter. */
+  filter?: (entity: T) => boolean;
+  /** Sort field. */
+  orderBy?: keyof T & string;
+  /** Sort direction. Default: 'asc'. */
+  order?: 'asc' | 'desc';
+  /** Max results. */
+  limit?: number;
+  /** Skip N results. */
+  offset?: number;
+}
+
+export interface ReaderActions<S extends Schema, K extends keyof S['models'] & string> {
+  /** Get a single entity by id, or `undefined` if it is not loaded in the store. */
+  retrieve: (id: string) => InferModel<S, K> | undefined;
+  /** Read a collection with optional filters. Snapshot — not reactive. */
+  list: (options?: ReaderFindOptions<InferModel<S, K>>) => InferModel<S, K>[];
+  /** Count entities matching the options. */
+  count: (options?: ReaderFindOptions<InferModel<S, K>>) => number;
+}
+
+/** Builds the read actions (`retrieve`, `list`, `count`) for one model over a store. */
+export function createReaderActions<
+  S extends Schema,
+  K extends keyof S['models'] & string,
+>(schema: S, modelKey: K, store: SyncStoreContract): ReaderActions<S, K> {
+  const modelDef = (schema.models as Record<string, ModelDef>)[modelKey];
+  const typename = modelDef?.typename ?? modelKey;
+
+  function read(options?: ReaderFindOptions<InferModel<S, K>>): InferModel<S, K>[] {
+    // Fast path: a single-field `where` on a registered foreign-key index is O(1).
+    let candidates: unknown[];
+    const whereEntries = options?.where ? Object.entries(options.where) : [];
+    const singleWhere = whereEntries.length === 1 ? whereEntries[0] : undefined;
+
+    if (
+      singleWhere &&
+      typeof singleWhere[1] === 'string' &&
+      store.pool.hasForeignKeyIndex(typename, singleWhere[0])
+    ) {
+      candidates = store.pool.getByForeignKey(typename, singleWhere[0], singleWhere[1]);
+    } else {
+      candidates = store.pool.getByTypeName(typename);
+      if (options?.where) {
+        candidates = (candidates as Record<string, unknown>[]).filter((entity) => {
+          for (const [field, value] of whereEntries) {
+            if (entity[field] !== value) return false;
+          }
+          return true;
+        });
+      }
+    }
+
+    let results = candidates as InferModel<S, K>[];
+
+    if (options?.filter) {
+      results = results.filter(options.filter);
+    }
+
+    if (options?.orderBy) {
+      const field = options.orderBy;
+      const dir = options.order === 'desc' ? -1 : 1;
+      results = [...results].sort((a, b) => {
+        const av = (a as Record<string, unknown>)[field];
+        const bv = (b as Record<string, unknown>)[field];
+        if (av === bv) return 0;
+        if (av == null) return 1;
+        if (bv == null) return -1;
+        return av < bv ? -dir : dir;
+      });
+    }
+
+    if (options?.offset) results = results.slice(options.offset);
+    if (options?.limit !== undefined) results = results.slice(0, options.limit);
+
+    return results;
+  }
+
+  return {
+    retrieve: (id) => store.pool.get(id) as InferModel<S, K> | undefined,
+    list: (options) => read(options),
+    count: (options) => read(options).length,
+  };
+}

package/src/local/mutators/undoApply.ts

@@ -0,0 +1,141 @@
+/**
+ * Conflict-aware replay of undo and redo operations, so undo reverts only your
+ * own changes.
+ *
+ * The undo stack is already per-client: only your local mutator calls record
+ * onto it through `UndoScope.record`, and a collaborator's edits arrive as
+ * inbound sync deltas that never enter it. This module adds the other half of
+ * per-user undo. When replaying a recorded operation, it touches a field only
+ * if that field's current value still equals the value this operation
+ * established. Undo therefore reverts your change where it still stands and
+ * leaves alone any field a collaborator has since overwritten — selective undo
+ * applied to a field-level, last-writer-wins model.
+ *
+ * {@link resolveOps} does the filtering. It takes the operations about to be
+ * replayed (`apply` — the inverses on undo, the forwards on redo) and their
+ * counterparts (`paired`), which carry the value each operation established: on
+ * undo the forwards say what you set, and on redo the inverses say what undo
+ * restored. For `update` and `updateMany` operations it drops any field whose
+ * live value no longer matches that established value. The `create` and
+ * `delete` families are structural and always applied — undoing a create
+ * removes the row you added, and undoing a delete restores it.
+ *
+ * When no collaborator is involved, the live value always equals what you set,
+ * so nothing is dropped and single-user undo behaves exactly as before.
+ */
+
+import type { SyncStoreContract } from '../storeContract.js';
+import type { InverseOp } from './inverseOp.js';
+import { deepEqual } from '@abloatai/transaction/utils/json';
+
+/**
+ * How undo and redo treat a field that a collaborator changed after your
+ * operation.
+ *
+ *   - `skip-stale` (the default): leave the field alone. Your change has
+ *     already been superseded, so reverting it would overwrite the
+ *     collaborator's value. This is what keeps undo scoped to your own edits.
+ *   - `last-writer-wins`: apply the operation verbatim, so your undo overwrites
+ *     the collaborator's change.
+ */
+export type UndoConflictPolicy = 'skip-stale' | 'last-writer-wins';
+
+export const DEFAULT_UNDO_CONFLICT_POLICY: UndoConflictPolicy = 'skip-stale';
+
+/**
+ * Structural equality for JSON-shaped values — scalars, arrays, and plain
+ * objects — ignoring object key order. Re-exported from the package's shared
+ * JSON helper so the undo path and your own code can share one implementation.
+ */
+export { deepEqual };
+
+/**
+ * Map `id → { field: establishedValue }` from the paired ops. Only update-family
+ * ops carry per-field values worth comparing.
+ */
+function buildEstablished(paired: InverseOp[]): Map<string, Record<string, unknown>> {
+  const map = new Map<string, Record<string, unknown>>();
+  for (const op of paired) {
+    if (op.kind === 'update') {
+      map.set(op.patch.id, op.patch);
+    } else if (op.kind === 'updateMany') {
+      for (const p of op.patches) map.set(p.id, p);
+    }
+  }
+  return map;
+}
+
+/** Read the live value of a field from the store's pool, or `undefined`. */
+function readCurrentField(store: SyncStoreContract, id: string, field: string): unknown {
+  const model = store.pool.get(id);
+  if (!model) return undefined;
+  const json = (model as { toJSON?: () => Record<string, unknown> }).toJSON?.();
+  return json ? json[field] : undefined;
+}
+
+type Patch = { id: string } & Record<string, unknown>;
+
+/**
+ * Keep only the fields whose live value still equals what this op established
+ * (`established[field]`). Returns `null` if nothing survives (the whole op is a
+ * no-op — every field was superseded by a collaborator).
+ */
+function filterStalePatch(
+  store: SyncStoreContract,
+  patch: Patch,
+  established: Record<string, unknown> | undefined,
+): Patch | null {
+  const out: Record<string, unknown> = { id: patch.id };
+  let kept = 0;
+  for (const field of Object.keys(patch)) {
+    if (field === 'id') continue;
+    if (established && field in established) {
+      // Apply only if the field still holds the value we established, meaning no
+      // collaborator has overwritten it since. Otherwise skip it, so the
+      // collaborator's change is left intact.
+      if (deepEqual(readCurrentField(store, patch.id, field), established[field])) {
+        out[field] = patch[field];
+        kept++;
+      }
+    } else {
+      // No paired value to compare against. The recorder always pairs fields,
+      // so this is theoretical; apply to preserve undo functionality.
+      out[field] = patch[field];
+      kept++;
+    }
+  }
+  return kept > 0 ? (out as Patch) : null;
+}
+
+/**
+ * Filter the ops to apply so they don't clobber concurrent collaborator edits.
+ * See the module docblock. `last-writer-wins` returns the ops unchanged.
+ */
+export function resolveOps(
+  apply: InverseOp[],
+  paired: InverseOp[],
+  store: SyncStoreContract,
+  policy: UndoConflictPolicy,
+): InverseOp[] {
+  if (policy === 'last-writer-wins') return apply;
+
+  const established = buildEstablished(paired);
+  const out: InverseOp[] = [];
+  for (const op of apply) {
+    if (op.kind === 'update') {
+      const filtered = filterStalePatch(store, op.patch, established.get(op.patch.id));
+      if (filtered) out.push({ kind: 'update', modelKey: op.modelKey, patch: filtered });
+    } else if (op.kind === 'updateMany') {
+      const patches = op.patches
+        .map((p) => filterStalePatch(store, p, established.get(p.id)))
+        .filter((p): p is Patch => p !== null);
+      if (patches.length > 0) {
+        out.push({ kind: 'updateMany', modelKey: op.modelKey, patches });
+      }
+    } else {
+      // create / createMany / delete / deleteMany — structural, applied as-is.
+      out.push(op);
+    }
+  }
+  return out;
+}

package/src/local/persistence.ts

@@ -0,0 +1,16 @@
+export type AbloPersistence = 'memory' | 'indexeddb';
+
+export interface PersistenceOptions {
+  readonly persistence?: AbloPersistence;
+  readonly inMemory?: boolean;
+  readonly offline?: boolean;
+}
+
+export function shouldUseInMemoryPersistence(
+  options: PersistenceOptions,
+): boolean {
+  if (typeof window === 'undefined') return true;
+  if (options.persistence) return options.persistence === 'memory';
+  if (typeof options.inMemory === 'boolean') return options.inMemory;
+  return options.offline !== true;
+}