@koolbase/react-native 9.2.0 → 10.0.1

package/dist/cache-store.d.ts

@@ -1,50 +0,0 @@
-import { KoolbaseRecord, LegacyPendingWrite, QueryResult } from './types';
-export declare function hashQuery(collection: string, options: Record<string, unknown>): string;
-export declare function getCached(userId: string, collection: string, queryHash: string): Promise<QueryResult | null>;
-export declare function setCached(userId: string, collection: string, queryHash: string, result: QueryResult): Promise<void>;
-export declare function invalidateCache(userId: string, collection: string): Promise<void>;
-/**
- * Drops everything cached for a user.
- *
- * Deliberately spares the write queue. The prefix covers every key for this
- * user, and the queue lives under one of them — so clearing the cache used to
- * delete offline writes the user believes are saved, silently and
- * irrecoverably. A cache is what can be refetched; queued writes are not that.
- */
-export declare function clearUserCache(userId: string): Promise<void>;
-/**
- * A record as the SDK last saw it, with the revision it was read at.
- *
- * Separate from the query cache, which answers "what did this query return".
- * This answers "what is the latest copy of this record" — and an offline
- * mutation composes against the second. Scanning query blobs for one would mean
- * the same record appearing in several snapshots at different revisions, with no
- * principled way to choose.
- *
- * Keyed with `record` where a collection name would sit, so invalidateCache —
- * which scopes to a collection and runs after every write — cannot reach these.
- * A user's own edit must not remove the baseline they need for the next one.
- */
-export interface CachedRecord {
-    collection: string;
-    data: Record<string, unknown>;
-    revision?: number;
-    cachedAt: string;
-}
-export declare function getCachedRecord(userId: string, recordId: string): Promise<CachedRecord | null>;
-/**
- * Stores a record, refusing to move it backwards.
- *
- * Query responses can arrive out of order — a slow request from an earlier
- * screen resolving after a fresh one — and an older copy overwriting a newer
- * would compose the next mutation against a stale revision, producing a conflict
- * the user never caused. False conflicts teach people to force-overwrite, which
- * is worse than none.
- */
-export declare function cacheRecord(userId: string, collection: string, recordId: string, data: Record<string, unknown>, revision?: number): Promise<void>;
-export declare function removeCachedRecord(userId: string, recordId: string): Promise<void>;
-export declare function getWriteQueue(userId: string): Promise<LegacyPendingWrite[]>;
-export declare function addToWriteQueue(userId: string, write: Omit<LegacyPendingWrite, 'retries' | 'createdAt'>): Promise<void>;
-export declare function removeFromWriteQueue(userId: string, writeId: string): Promise<void>;
-export declare function incrementWriteRetry(userId: string, writeId: string): Promise<void>;
-export declare function optimisticallyInsert(userId: string, collection: string, record: KoolbaseRecord): Promise<void>;

package/dist/cache-store.js

@@ -1,197 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hashQuery = hashQuery;
-exports.getCached = getCached;
-exports.setCached = setCached;
-exports.invalidateCache = invalidateCache;
-exports.clearUserCache = clearUserCache;
-exports.getCachedRecord = getCachedRecord;
-exports.cacheRecord = cacheRecord;
-exports.removeCachedRecord = removeCachedRecord;
-exports.getWriteQueue = getWriteQueue;
-exports.addToWriteQueue = addToWriteQueue;
-exports.removeFromWriteQueue = removeFromWriteQueue;
-exports.incrementWriteRetry = incrementWriteRetry;
-exports.optimisticallyInsert = optimisticallyInsert;
-const async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
-const CACHE_VERSION = 'v1';
-function cacheKey(userId, collection, queryHash) {
-    return `koolbase:${CACHE_VERSION}:${userId}:${collection}:${queryHash}`;
-}
-function writeQueueKey(userId) {
-    return `koolbase:${CACHE_VERSION}:${userId}:write_queue`;
-}
-function hashQuery(collection, options) {
-    return `${collection}:${JSON.stringify(options)}`;
-}
-// ─── Cache ──────────────────────────────────────────────────────────────────
-async function getCached(userId, collection, queryHash) {
-    try {
-        const raw = await async_storage_1.default.getItem(cacheKey(userId, collection, queryHash));
-        if (!raw)
-            return null;
-        return JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-}
-async function setCached(userId, collection, queryHash, result) {
-    try {
-        await async_storage_1.default.setItem(cacheKey(userId, collection, queryHash), JSON.stringify(result));
-    }
-    catch {
-        // ignore storage errors
-    }
-}
-async function invalidateCache(userId, collection) {
-    try {
-        const keys = await async_storage_1.default.getAllKeys();
-        const prefix = `koolbase:${CACHE_VERSION}:${userId}:${collection}:`;
-        const toDelete = keys.filter(k => k.startsWith(prefix));
-        for (const key of toDelete) {
-            await async_storage_1.default.removeItem(key);
-        }
-    }
-    catch {
-        // ignore
-    }
-}
-/**
- * Drops everything cached for a user.
- *
- * Deliberately spares the write queue. The prefix covers every key for this
- * user, and the queue lives under one of them — so clearing the cache used to
- * delete offline writes the user believes are saved, silently and
- * irrecoverably. A cache is what can be refetched; queued writes are not that.
- */
-async function clearUserCache(userId) {
-    try {
-        const keys = await async_storage_1.default.getAllKeys();
-        const prefix = `koolbase:${CACHE_VERSION}:${userId}:`;
-        const queueKey = writeQueueKey(userId);
-        const toDelete = keys.filter(k => k.startsWith(prefix) && k !== queueKey);
-        for (const key of toDelete) {
-            await async_storage_1.default.removeItem(key);
-        }
-    }
-    catch {
-        // ignore
-    }
-}
-function recordCacheKey(userId, recordId) {
-    return `koolbase:${CACHE_VERSION}:${userId}:record:${recordId}`;
-}
-async function getCachedRecord(userId, recordId) {
-    try {
-        const raw = await async_storage_1.default.getItem(recordCacheKey(userId, recordId));
-        return raw ? JSON.parse(raw) : null;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Stores a record, refusing to move it backwards.
- *
- * Query responses can arrive out of order — a slow request from an earlier
- * screen resolving after a fresh one — and an older copy overwriting a newer
- * would compose the next mutation against a stale revision, producing a conflict
- * the user never caused. False conflicts teach people to force-overwrite, which
- * is worse than none.
- */
-async function cacheRecord(userId, collection, recordId, data, revision) {
-    try {
-        const existing = await getCachedRecord(userId, recordId);
-        if (existing?.revision !== undefined &&
-            revision !== undefined &&
-            revision < existing.revision) {
-            return;
-        }
-        const entry = {
-            collection,
-            data,
-            revision,
-            cachedAt: new Date().toISOString(),
-        };
-        await async_storage_1.default.setItem(recordCacheKey(userId, recordId), JSON.stringify(entry));
-    }
-    catch {
-        // ignore
-    }
-}
-async function removeCachedRecord(userId, recordId) {
-    try {
-        await async_storage_1.default.removeItem(recordCacheKey(userId, recordId));
-    }
-    catch {
-        // ignore
-    }
-}
-// ─── Write Queue ────────────────────────────────────────────────────────────
-async function getWriteQueue(userId) {
-    try {
-        const raw = await async_storage_1.default.getItem(writeQueueKey(userId));
-        if (!raw)
-            return [];
-        return JSON.parse(raw);
-    }
-    catch {
-        return [];
-    }
-}
-async function addToWriteQueue(userId, write) {
-    try {
-        const queue = await getWriteQueue(userId);
-        queue.push({ ...write, retries: 0, createdAt: new Date().toISOString() });
-        await async_storage_1.default.setItem(writeQueueKey(userId), JSON.stringify(queue));
-    }
-    catch {
-        // ignore
-    }
-}
-async function removeFromWriteQueue(userId, writeId) {
-    try {
-        const queue = await getWriteQueue(userId);
-        const updated = queue.filter(w => w.id !== writeId);
-        await async_storage_1.default.setItem(writeQueueKey(userId), JSON.stringify(updated));
-    }
-    catch {
-        // ignore
-    }
-}
-async function incrementWriteRetry(userId, writeId) {
-    try {
-        const queue = await getWriteQueue(userId);
-        const updated = queue.map(w => w.id === writeId ? { ...w, retries: w.retries + 1 } : w);
-        // Drop writes that have exceeded 3 retries
-        const filtered = updated.filter(w => w.retries <= 3);
-        await async_storage_1.default.setItem(writeQueueKey(userId), JSON.stringify(filtered));
-    }
-    catch {
-        // ignore
-    }
-}
-// ─── Optimistic cache update ─────────────────────────────────────────────────
-async function optimisticallyInsert(userId, collection, record) {
-    try {
-        const keys = await async_storage_1.default.getAllKeys();
-        const prefix = `koolbase:${CACHE_VERSION}:${userId}:${collection}:`;
-        const collectionKeys = keys.filter(k => k.startsWith(prefix));
-        for (const key of collectionKeys) {
-            const raw = await async_storage_1.default.getItem(key);
-            if (!raw)
-                continue;
-            const cached = JSON.parse(raw);
-            cached.records = [record, ...cached.records];
-            cached.total = cached.total + 1;
-            await async_storage_1.default.setItem(key, JSON.stringify(cached));
-        }
-    }
-    catch {
-        // ignore
-    }
-}

package/dist/code-push.d.ts

@@ -1,59 +0,0 @@
-import { KoolbaseConfig } from './types';
-export interface BundlePayload {
-    config: Record<string, unknown>;
-    flags: Record<string, boolean>;
-    directives: Record<string, unknown>;
-    assets: {
-        images: string[];
-        json: string[];
-        fonts: string[];
-    };
-    screens?: Record<string, string>;
-    flows?: Record<string, unknown>;
-}
-export interface BundleManifest {
-    bundle_id: string;
-    app_id: string;
-    version: number;
-    base_app_version: string;
-    max_app_version: string;
-    platform: string;
-    channel: string;
-    checksum: string;
-    signature: string;
-    size_bytes: number;
-    payload: BundlePayload;
-    mandatory?: boolean;
-}
-export declare class KoolbaseCodePush {
-    private config;
-    private channel;
-    private activeManifest;
-    private mandatoryPending;
-    constructor(config: KoolbaseConfig, channel?: string);
-    init(options: {
-        appVersion: string;
-        platform: string;
-        deviceId: string;
-    }): Promise<void>;
-    private promotePendingIfAvailable;
-    private loadActive;
-    private checkInBackground;
-    private download;
-    private handleRollback;
-    get hasActiveBundle(): boolean;
-    /**
-     * True when a mandatory bundle has been staged this session and is awaiting
-     * application (it activates on the next cold launch). Gate your UI on this to
-     * prompt the user to restart so the required update takes effect.
-     */
-    get hasMandatoryUpdate(): boolean;
-    get manifest(): BundleManifest | null;
-    getBundleConfig(key: string): unknown | undefined;
-    getBundleFlag(key: string): boolean | undefined;
-    getBundleDirective(key: string): unknown | undefined;
-    private directiveHandlers;
-    onDirective(key: string, handler: (value: unknown) => void): void;
-    applyDirectives(): void;
-    clearBundle(): Promise<void>;
-}

package/dist/code-push.js

@@ -1,255 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.KoolbaseCodePush = void 0;
-const async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
-const STORAGE_KEY_ACTIVE = 'koolbase:codepush:active';
-const STORAGE_KEY_PENDING = 'koolbase:codepush:pending';
-// ─── Pure JS sha256 for checksum verification ────────────────────────────────
-async function sha256Hex(data) {
-    // Use SubtleCrypto if available (modern RN / Hermes)
-    if (typeof crypto !== 'undefined' && crypto.subtle) {
-        const hashBuffer = await crypto.subtle.digest('SHA-256', data);
-        const hashArray = Array.from(new Uint8Array(hashBuffer));
-        return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
-    }
-    // Fallback — skip verification (dev only)
-    return '';
-}
-// ─── Zip manifest extraction ─────────────────────────────────────────────────
-async function extractManifestFromZip(data) {
-    try {
-        // Dynamically import JSZip — must be installed as a dependency
-        const JSZip = (await Promise.resolve().then(() => __importStar(require('jszip')))).default;
-        const zip = await JSZip.loadAsync(data);
-        const manifestFile = zip.file('manifest.json');
-        if (!manifestFile)
-            return null;
-        const json = await manifestFile.async('string');
-        return JSON.parse(json);
-    }
-    catch (e) {
-        console.warn('[KoolbaseCodePush] manifest extraction failed:', e);
-        return null;
-    }
-}
-// ─── KoolbaseCodePush ────────────────────────────────────────────────────────
-class KoolbaseCodePush {
-    constructor(config, channel = 'stable') {
-        this.activeManifest = null;
-        this.mandatoryPending = false;
-        // ─── Directive handling ──────────────────────────────────────────────────
-        this.directiveHandlers = new Map();
-        this.config = config;
-        this.channel = channel;
-    }
-    // Called inside Koolbase.initialize() — loads cached bundle then checks in background
-    async init(options) {
-        // Step 1 — promote pending → active if available
-        await this.promotePendingIfAvailable();
-        // Step 2 — load active manifest into memory
-        this.activeManifest = await this.loadActive();
-        if (this.activeManifest) {
-            console.log(`[KoolbaseCodePush] bundle v${this.activeManifest.version} active`);
-        }
-        else {
-            console.log('[KoolbaseCodePush] no active bundle — using app defaults');
-        }
-        // Step 3 — check for updates in background (non-blocking)
-        this.checkInBackground(options);
-    }
-    async promotePendingIfAvailable() {
-        try {
-            const pending = await async_storage_1.default.getItem(STORAGE_KEY_PENDING);
-            if (!pending)
-                return;
-            // Archive current active → just overwrite, we keep one version
-            await async_storage_1.default.setItem(STORAGE_KEY_ACTIVE, pending);
-            await async_storage_1.default.removeItem(STORAGE_KEY_PENDING);
-            console.log('[KoolbaseCodePush] promoted pending bundle to active');
-        }
-        catch (e) {
-            console.warn('[KoolbaseCodePush] promotion failed:', e);
-            // One re-check will be triggered naturally by background check
-        }
-    }
-    async loadActive() {
-        try {
-            const stored = await async_storage_1.default.getItem(STORAGE_KEY_ACTIVE);
-            if (!stored)
-                return null;
-            return JSON.parse(stored);
-        }
-        catch {
-            return null;
-        }
-    }
-    checkInBackground(options) {
-        // Fire and forget
-        (async () => {
-            try {
-                const currentVersion = this.activeManifest?.version ?? 0;
-                const res = await fetch(`${this.config.baseUrl}/v1/code-push/check` +
-                    `?app_version=${options.appVersion}` +
-                    `&platform=${options.platform}` +
-                    `&channel=${this.channel}` +
-                    `&device_id=${options.deviceId}` +
-                    `&current_bundle=${currentVersion}`, { headers: { 'x-api-key': this.config.publicKey } });
-                if (!res.ok)
-                    return;
-                const body = await res.json();
-                switch (body.status) {
-                    case 'update_available':
-                        await this.download(body.bundle);
-                        break;
-                    case 'rollback':
-                        await this.handleRollback(body.revert_to ?? '0');
-                        break;
-                    case 'no_update':
-                        console.log('[KoolbaseCodePush] no update available');
-                        break;
-                }
-            }
-            catch (e) {
-                // Server unreachable — continue silently
-                console.log('[KoolbaseCodePush] check failed silently:', e);
-            }
-        })();
-    }
-    async download(ref) {
-        try {
-            console.log(`[KoolbaseCodePush] downloading bundle v${ref.version}...`);
-            const res = await fetch(ref.download_url);
-            if (!res.ok) {
-                console.warn('[KoolbaseCodePush] download failed:', res.status);
-                return;
-            }
-            const data = await res.arrayBuffer();
-            console.log(`[KoolbaseCodePush] downloaded ${data.byteLength} bytes`);
-            // Verify checksum
-            if (ref.checksum !== 'placeholder' && ref.checksum !== 'pending') {
-                const actual = `sha256:${await sha256Hex(data)}`;
-                if (actual !== ref.checksum && actual !== 'sha256:') {
-                    console.warn('[KoolbaseCodePush] checksum mismatch — bundle rejected');
-                    return;
-                }
-                console.log('[KoolbaseCodePush] checksum verified');
-            }
-            else {
-                console.log('[KoolbaseCodePush] checksum skipped (dev mode)');
-            }
-            // Extract manifest
-            const manifest = await extractManifestFromZip(data);
-            if (!manifest) {
-                console.warn('[KoolbaseCodePush] manifest extraction failed');
-                return;
-            }
-            // Carry the mandatory flag from the check response onto the staged manifest
-            manifest.mandatory = ref.mandatory;
-            // Store as pending — activates on next launch
-            await async_storage_1.default.setItem(STORAGE_KEY_PENDING, JSON.stringify(manifest));
-            console.log(`[KoolbaseCodePush] bundle v${manifest.version} ready for next launch`);
-            if (ref.mandatory) {
-                this.mandatoryPending = true;
-                console.log('[KoolbaseCodePush] staged bundle is mandatory — notifying app');
-                try {
-                    this.config.onMandatoryUpdate?.({ version: manifest.version, bundleId: manifest.bundle_id });
-                }
-                catch (cbErr) {
-                    console.warn('[KoolbaseCodePush] onMandatoryUpdate handler threw:', cbErr);
-                }
-            }
-        }
-        catch (e) {
-            console.warn('[KoolbaseCodePush] download error:', e);
-        }
-    }
-    async handleRollback(revertTo) {
-        console.log(`[KoolbaseCodePush] rollback to v${revertTo}`);
-        await async_storage_1.default.removeItem(STORAGE_KEY_ACTIVE);
-        await async_storage_1.default.removeItem(STORAGE_KEY_PENDING);
-        this.activeManifest = null;
-        console.log('[KoolbaseCodePush] reverted to app defaults');
-    }
-    // ─── Public accessors ────────────────────────────────────────────────────
-    get hasActiveBundle() {
-        return this.activeManifest !== null;
-    }
-    /**
-     * True when a mandatory bundle has been staged this session and is awaiting
-     * application (it activates on the next cold launch). Gate your UI on this to
-     * prompt the user to restart so the required update takes effect.
-     */
-    get hasMandatoryUpdate() {
-        return this.mandatoryPending;
-    }
-    get manifest() {
-        return this.activeManifest;
-    }
-    getBundleConfig(key) {
-        return this.activeManifest?.payload.config[key];
-    }
-    getBundleFlag(key) {
-        return this.activeManifest?.payload.flags[key];
-    }
-    getBundleDirective(key) {
-        return this.activeManifest?.payload.directives[key];
-    }
-    onDirective(key, handler) {
-        this.directiveHandlers.set(key, handler);
-    }
-    applyDirectives() {
-        if (!this.activeManifest?.payload.directives)
-            return;
-        for (const [key, value] of Object.entries(this.activeManifest.payload.directives)) {
-            const handler = this.directiveHandlers.get(key);
-            if (handler) {
-                console.log(`[KoolbaseCodePush] directive: ${key} = ${value}`);
-                handler(value);
-            }
-        }
-    }
-    // ─── Cache management ────────────────────────────────────────────────────
-    async clearBundle() {
-        await async_storage_1.default.removeItem(STORAGE_KEY_ACTIVE);
-        await async_storage_1.default.removeItem(STORAGE_KEY_PENDING);
-        this.activeManifest = null;
-        console.log('[KoolbaseCodePush] bundle cache cleared');
-    }
-}
-exports.KoolbaseCodePush = KoolbaseCodePush;

package/dist/conflict.d.ts

@@ -1,80 +0,0 @@
-import { ConflictReason } from './offline-state';
-/** Resolves conflicts by id. */
-export interface ConflictResolver {
-    resolveWithLocal(conflictId: string): Promise<void>;
-    resolveWithServer(conflictId: string): Promise<void>;
-    resolveWithMerge(conflictId: string, data: Record<string, unknown>): Promise<void>;
-    abandon(conflictId: string): Promise<void>;
-}
-/**
- * A queued offline write that could not be applied, waiting for a decision.
- *
- * Not an error to dismiss and not a write to retry: retrying cannot help, and
- * discarding it would lose a change the user believes is saved. It waits, and
- * keeps waiting across restarts, until the application decides.
- *
- * Only the application can decide. Whether a later edit should win depends on
- * what the data means, and a platform that chooses for everyone is wrong for
- * someone.
- */
-export declare class KoolbaseConflict {
-    readonly id: string;
-    readonly reason: ConflictReason;
-    readonly operation: 'insert' | 'update' | 'delete';
-    readonly collection: string;
-    readonly recordId: string;
-    /** The change the user made, still unapplied. */
-    readonly local: Record<string, unknown> | undefined;
-    /** The record as it was when the change was composed, where that is known. */
-    readonly baseline: Record<string, unknown> | undefined;
-    /**
-     * The record as the server held it when the write was refused, captured with
-     * the refusal so deciding needs no fetch and cannot race one.
-     *
-     * Undefined when the reason is `baseline_unavailable` — nothing was ever
-     * sent, so the server never answered.
-     */
-    readonly server: Record<string, unknown> | undefined;
-    readonly baseRevision: number | undefined;
-    readonly serverRevision: number | undefined;
-    readonly createdAt: string;
-    private readonly resolver;
-    constructor(id: string, reason: ConflictReason, operation: 'insert' | 'update' | 'delete', collection: string, recordId: string, 
-    /** The change the user made, still unapplied. */
-    local: Record<string, unknown> | undefined, 
-    /** The record as it was when the change was composed, where that is known. */
-    baseline: Record<string, unknown> | undefined, 
-    /**
-     * The record as the server held it when the write was refused, captured with
-     * the refusal so deciding needs no fetch and cannot race one.
-     *
-     * Undefined when the reason is `baseline_unavailable` — nothing was ever
-     * sent, so the server never answered.
-     */
-    server: Record<string, unknown> | undefined, baseRevision: number | undefined, serverRevision: number | undefined, createdAt: string, resolver: ConflictResolver);
-    /**
-     * Fields where the user's change and the server's version disagree.
-     *
-     * Only the fields the change touches: a record accumulates values the write
-     * never asserted, and listing those would bury the real disagreement. Empty
-     * when there is no server version to compare against.
-     */
-    get divergentFields(): string[];
-    /** How long this has been waiting. Metadata, not a deletion rule. */
-    get ageMs(): number;
-    /**
-     * Reapplies the user's change to the record as it stands now.
-     *
-     * An explicit decision to overwrite the server's version of the fields that
-     * disagree. Conditional where a revision is known, so a record that moved
-     * again while someone was deciding produces a new conflict rather than an
-     * unnoticed overwrite.
-     */
-    resolveWithLocal(): Promise<void>;
-    /** Keeps the server's version and discards the user's change, as a decision. */
-    resolveWithServer(): Promise<void>;
-    /** Applies something the application composed from both versions. */
-    resolveWithMerge(data: Record<string, unknown>): Promise<void>;
-    /** Drops the change without claiming either version won. */
-    abandon(): Promise<void>;
-}