@abloatai/ablo 0.36.0 → 0.37.1

package/dist/mutators/defineMutators.d.ts

@@ -1,60 +0,0 @@
-/**
- * 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 '../transaction/schema/schema.js';
-import type { Transaction } from './Transaction.js';
-import type { ResolveSchema } from '../transaction/types/global.js';
-/**
- * `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 declare 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 declare function defineMutators<const M extends MutatorDefs<RegisteredSchema>>(mutators: M): M;
-export {};

package/dist/mutators/defineMutators.js

@@ -1,18 +0,0 @@
-/**
- * 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.
- */
-export function defineMutators(schemaOrMutators, maybeMutators) {
-    // 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);
-}

package/dist/mutators/inverseOp.d.ts

@@ -1,126 +0,0 @@
-/**
- * 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';
-/**
- * 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 declare const inverseOpSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    kind: z.ZodLiteral<"create">;
-    modelKey: z.ZodString;
-    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-}, z.core.$strip>, z.ZodObject<{
-    kind: z.ZodLiteral<"update">;
-    modelKey: z.ZodString;
-    patch: z.ZodObject<{
-        id: z.ZodString;
-    }, z.core.$catchall<z.ZodUnknown>>;
-}, z.core.$strip>, z.ZodObject<{
-    kind: z.ZodLiteral<"delete">;
-    modelKey: z.ZodString;
-    id: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    kind: z.ZodLiteral<"createMany">;
-    modelKey: z.ZodString;
-    data: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>, z.ZodObject<{
-    kind: z.ZodLiteral<"updateMany">;
-    modelKey: z.ZodString;
-    patches: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-    }, z.core.$catchall<z.ZodUnknown>>>;
-}, z.core.$strip>, z.ZodObject<{
-    kind: z.ZodLiteral<"deleteMany">;
-    modelKey: z.ZodString;
-    ids: z.ZodArray<z.ZodString>;
-}, z.core.$strip>], "kind">;
-/** One undo entry = one mutator invocation's inverses + paired forwards. */
-export declare const undoEntrySchema: z.ZodObject<{
-    label: z.ZodOptional<z.ZodString>;
-    inverses: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"create">;
-        modelKey: z.ZodString;
-        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"update">;
-        modelKey: z.ZodString;
-        patch: z.ZodObject<{
-            id: z.ZodString;
-        }, z.core.$catchall<z.ZodUnknown>>;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"delete">;
-        modelKey: z.ZodString;
-        id: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"createMany">;
-        modelKey: z.ZodString;
-        data: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"updateMany">;
-        modelKey: z.ZodString;
-        patches: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-        }, z.core.$catchall<z.ZodUnknown>>>;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"deleteMany">;
-        modelKey: z.ZodString;
-        ids: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>], "kind">>;
-    forwards: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"create">;
-        modelKey: z.ZodString;
-        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"update">;
-        modelKey: z.ZodString;
-        patch: z.ZodObject<{
-            id: z.ZodString;
-        }, z.core.$catchall<z.ZodUnknown>>;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"delete">;
-        modelKey: z.ZodString;
-        id: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"createMany">;
-        modelKey: z.ZodString;
-        data: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"updateMany">;
-        modelKey: z.ZodString;
-        patches: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-        }, z.core.$catchall<z.ZodUnknown>>>;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"deleteMany">;
-        modelKey: z.ZodString;
-        ids: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>], "kind">>;
-}, z.core.$strip>;
-/** 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 declare function parseUndoEntry(value: unknown): UndoEntry;

package/dist/mutators/inverseOp.js

@@ -1,71 +0,0 @@
-/**
- * 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 '../transaction/errors.js';
-/** 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),
-});
-/**
- * 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) {
-    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/dist/mutators/mutateActions.d.ts

@@ -1,45 +0,0 @@
-import type { Schema, InferModel, InferCreate } from '../transaction/schema/schema.js';
-import type { SyncStoreContract } from '../react/context.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 declare function createMutateActions<S extends Schema, K extends keyof S['models'] & string>(schema: S, modelKey: K, store: SyncStoreContract, organizationId: string): MutateActions<S, K>;
-export {};

package/dist/mutators/mutateActions.js

@@ -1,105 +0,0 @@
-import { Model, modelAsRow } from '../Model.js';
-import { AbloValidationError } from '../transaction/errors.js';
-/** Builds the create, update, and delete actions for one model over a store. */
-export function createMutateActions(schema, modelKey, store, organizationId) {
-    const modelDef = schema.models[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, now) => {
-        const record = data;
-        const fullData = {
-            ...record,
-            __typename: typename,
-            id: record.id ?? Model.generateId(),
-            organizationId: record.organizationId ?? organizationId,
-            createdAt: record.createdAt ?? now,
-            updatedAt: record.updatedAt ?? 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, now) => {
-        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) => {
-            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(m));
-            }
-            const model = buildModelForCreate(data, now);
-            await store.save(model);
-            return modelAsRow(model);
-        }),
-        update: (async (patch) => {
-            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(m));
-            }
-            const model = applyPatch(patch, now);
-            await store.save(model);
-            return modelAsRow(model);
-        }),
-        delete: (async (idOrIds) => {
-            if (Array.isArray(idOrIds)) {
-                if (idOrIds.length === 0)
-                    return;
-                const models = [];
-                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/dist/mutators/readerActions.d.ts

@@ -1,33 +0,0 @@
-import type { Schema, InferModel } from '../transaction/schema/schema.js';
-import type { SyncStoreContract } from '../react/context.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 declare function createReaderActions<S extends Schema, K extends keyof S['models'] & string>(schema: S, modelKey: K, store: SyncStoreContract): ReaderActions<S, K>;

package/dist/mutators/readerActions.js

@@ -1,57 +0,0 @@
-/** Builds the read actions (`retrieve`, `list`, `count`) for one model over a store. */
-export function createReaderActions(schema, modelKey, store) {
-    const modelDef = schema.models[modelKey];
-    const typename = modelDef?.typename ?? modelKey;
-    function read(options) {
-        // Fast path: a single-field `where` on a registered foreign-key index is O(1).
-        let candidates;
-        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.filter((entity) => {
-                    for (const [field, value] of whereEntries) {
-                        if (entity[field] !== value)
-                            return false;
-                    }
-                    return true;
-                });
-            }
-        }
-        let results = candidates;
-        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[field];
-                const bv = b[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),
-        list: (options) => read(options),
-        count: (options) => read(options).length,
-    };
-}

package/dist/mutators/undoApply.d.ts

@@ -1,51 +0,0 @@
-/**
- * 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 '../react/context.js';
-import type { InverseOp } from './inverseOp.js';
-import { deepEqual } from '../transaction/utils/json.js';
-/**
- * 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 declare const DEFAULT_UNDO_CONFLICT_POLICY: UndoConflictPolicy;
-/**
- * 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 };
-/**
- * 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 declare function resolveOps(apply: InverseOp[], paired: InverseOp[], store: SyncStoreContract, policy: UndoConflictPolicy): InverseOp[];