velocious 1.0.701 → 1.0.702

package/build/src/sync/sync-offline-session.js

@@ -0,0 +1,617 @@
+// @ts-check
+import { createSignedMutation, generateSyncSigningKeyPair, mutationIdempotencyKey, verifyDeviceCertificate } from "./device-identity.js";
+import { exportPeerMutationBundle, importPeerMutationBundle } from "./peer-mutation-bundle.js";
+import { replayResultLocalStatus } from "./conflict-strategy.js";
+/**
+ * Stored device signing identity: the backend-signed certificate plus the
+ * device private key matching the certificate's public key.
+ * @typedef {object} SyncOfflineDeviceIdentity
+ * @property {import("./device-identity.js").DeviceCertificate} certificate - Backend-signed device certificate.
+ * @property {import("./device-identity.js").SyncJsonWebKey} privateKey - Device private signing key (JWK).
+ */
+/**
+ * Result of one offline session replay pass over the durable mutation logs.
+ * @typedef {object} SyncOfflineReplayResult
+ * @property {number} conflictCount - Records left in `conflict`.
+ * @property {number} pendingCount - Records still pending (blocked dependencies or unacknowledged).
+ * @property {number} rejectedCount - Records the backend rejected.
+ * @property {Array<{clientMutationId: string, idempotencyKey: string, mutation: import("./device-identity.js").SyncMutation, recordId: string, serverResult: Record<string, ReturnType<typeof JSON.parse>> | null, status: import("./local-mutation-log.js").LocalMutationStatus}>} results - Per-mutation mapped results in replay order.
+ * @property {number} syncedCount - Records acknowledged by the backend.
+ */
+/**
+ * Session summary returned by start/refresh.
+ * @typedef {object} SyncOfflineSessionSummary
+ * @property {string} actorDeviceId - Certificate device identity.
+ * @property {string} actorUserId - Certificate user identity.
+ * @property {string} expiresAt - Live grant expiry.
+ * @property {string} grantId - Live grant id.
+ */
+/**
+ * Framework-owned long-offline session behind SyncClient: device identity
+ * lifecycle, backend-issued offline grants, mutation signing, signed replay,
+ * and peer bundle transfer. SyncClient owns the public API; this class owns the
+ * session state. The app only provides durable storage adapters, the
+ * enrollment hook, and the grant scopes callback.
+ */
+export default class SyncOfflineSession {
+    /**
+     * Builds an offline session from the normalized `sync.client.offline` block.
+     * @param {object} args - Session args.
+     * @param {() => string | Promise<string>} args.authenticationToken - Resolves the auth token sent with bootstrap/replay requests.
+     * @param {import("../configuration-types.js").NormalizedVelociousSyncClientOfflineConfiguration} args.config - Normalized offline configuration.
+     * @param {Array<import("./local-mutation-log.js").default>} args.mutationLogs - Durable local mutation logs the session signs, replays, resigns, and exports.
+     * @param {(path: string, payload: Record<string, ReturnType<typeof JSON.parse>>, options?: {signal?: AbortSignal}) => Promise<ReturnType<typeof JSON.parse>>} args.post - Framework POSTer over the configured transport.
+     */
+    constructor({ authenticationToken, config, mutationLogs, post }) {
+        if (!Array.isArray(mutationLogs) || mutationLogs.length === 0)
+            throw new Error("SyncOfflineSession requires at least one mutation log");
+        this.authenticationToken = authenticationToken;
+        this.config = config;
+        this.mutationLogs = mutationLogs;
+        this.post = post;
+        /** @type {SyncOfflineDeviceIdentity | null} */
+        this._identity = null;
+        /** @type {Map<string, import("./offline-grant.js").SignedOfflineGrant>} */
+        this._grants = new Map();
+        this._grantsLoaded = false;
+        /** @type {import("./offline-grant.js").SignedOfflineGrant | null} */
+        this._activeGrant = null;
+        /** @type {Record<string, import("../configuration-types.js").NormalizedFrontendModelResourceSyncConfiguration> | null} */
+        this._syncManifest = null;
+        /** @type {Promise<SyncOfflineSessionSummary> | null} */
+        this._startPromise = null;
+        /** @type {Promise<SyncOfflineReplayResult> | null} */
+        this._replayPromise = null;
+    }
+    /**
+     * Whether the session currently has a usable device identity and live grant.
+     * @returns {boolean} - Whether the session is active.
+     */
+    isActive() {
+        return Boolean(this._identity && this._liveGrant());
+    }
+    /**
+     * Resolves the device signing identity (generating and enrolling a key pair
+     * when the app-owned storage has none) and bootstraps a live offline grant.
+     * Idempotent and single-flighted: concurrent starts share one bootstrap.
+     * @returns {Promise<SyncOfflineSessionSummary>} - Session summary.
+     */
+    async start() {
+        if (this._identity && this._liveGrant())
+            return this.sessionSummary();
+        if (!this._startPromise) {
+            this._startPromise = this._startSession().then((summary) => {
+                this._startPromise = null;
+                return summary;
+            }, (error) => {
+                this._startPromise = null;
+                throw error;
+            });
+        }
+        return await this._startPromise;
+    }
+    /**
+     * Drops the in-memory session (identity and grants stay in the app-owned
+     * durable storage; pending mutations stay in the durable mutation logs).
+     * @returns {Promise<void>} - Resolves after the session is dropped.
+     */
+    async stop() {
+        if (this._replayPromise)
+            await this._replayPromise.catch(() => undefined);
+        this._identity = null;
+        this._activeGrant = null;
+        this._syncManifest = null;
+        this._grantsLoaded = false;
+    }
+    /**
+     * Runs one start attempt: identity first, then grant bootstrap.
+     * @returns {Promise<SyncOfflineSessionSummary>} - Session summary.
+     */
+    async _startSession() {
+        await this._ensureIdentity();
+        await this._loadRetainedGrants();
+        await this._ensureLiveGrant();
+        return this.sessionSummary();
+    }
+    /**
+     * Returns the current session summary.
+     * @returns {SyncOfflineSessionSummary} - Session summary.
+     */
+    sessionSummary() {
+        const identity = this._requireIdentity();
+        const grant = this._requireLiveGrant();
+        return {
+            actorDeviceId: identity.certificate.certificate.actorDeviceId,
+            actorUserId: identity.certificate.certificate.actorUserId,
+            expiresAt: grant.grant.expiresAt,
+            grantId: grant.grant.grantId
+        };
+    }
+    /**
+     * Resolves the device identity: load it from the app-owned storage, or
+     * generate a key pair, run the app-owned enrollment hook, verify the returned
+     * certificate against the configured backend public key, and store it.
+     * @returns {Promise<SyncOfflineDeviceIdentity>} - Device signing identity.
+     */
+    async _ensureIdentity() {
+        if (this._identity)
+            return this._identity;
+        const stored = await this.config.deviceIdentityStorage.load();
+        if (stored) {
+            this._identity = await this._verifiedIdentity(stored);
+            return this._identity;
+        }
+        const keyPair = await generateSyncSigningKeyPair();
+        const certificate = await this.config.enrollDevice({
+            configuration: this.config.configuration,
+            publicKey: keyPair.publicKey
+        });
+        const identity = await this._verifiedIdentity({ certificate, privateKey: keyPair.privateKey });
+        await this.config.deviceIdentityStorage.save(/** @type {SyncOfflineDeviceIdentity} */ (cloneJson(identity, "device identity")));
+        this._identity = identity;
+        return identity;
+    }
+    /**
+     * Verifies a stored/enrolled certificate against the configured backend
+     * public key (when one is configured) and returns the identity.
+     * @param {SyncOfflineDeviceIdentity} identity - Candidate identity.
+     * @returns {Promise<SyncOfflineDeviceIdentity>} - Verified identity.
+     */
+    async _verifiedIdentity(identity) {
+        if (!identity || typeof identity !== "object" || Array.isArray(identity)) {
+            throw new Error("sync.client.offline device identity storage must provide {certificate, privateKey} or null");
+        }
+        if (!identity.certificate || !identity.privateKey)
+            throw new Error("sync.client.offline device identity requires a certificate and a privateKey");
+        if (this.config.backendPublicKey) {
+            await verifyDeviceCertificate({
+                backendPublicKey: this.config.backendPublicKey,
+                certificate: identity.certificate
+            });
+        }
+        return identity;
+    }
+    /**
+     * Loads app-retained grants once so a restarted device can still replay
+     * mutations that were signed under an older grant (peer-forwarded mutations
+     * keep the grant their original signer used).
+     * @returns {Promise<void>} - Resolves after retention is loaded.
+     */
+    async _loadRetainedGrants() {
+        if (this._grantsLoaded)
+            return;
+        this._grantsLoaded = true;
+        if (!this.config.grantStorage)
+            return;
+        const retained = await this.config.grantStorage.load();
+        if (!Array.isArray(retained))
+            throw new Error("sync.client.offline grantStorage.load must resolve an array of signed offline grants");
+        for (const signedGrant of retained) {
+            if (!signedGrant || typeof signedGrant !== "object" || !signedGrant.grant || typeof signedGrant.grant.grantId !== "string")
+                continue;
+            this._grants.set(signedGrant.grant.grantId, signedGrant);
+        }
+    }
+    /**
+     * Returns the active grant when it is still live, otherwise null. Expiry is
+     * checked by timestamp only: the grant's HMAC signature is backend-only and
+     * can never be verified on the device.
+     * @param {Date} [now] - Check time.
+     * @returns {import("./offline-grant.js").SignedOfflineGrant | null} - Live grant or null.
+     */
+    _liveGrant(now = this._now()) {
+        if (!this._activeGrant)
+            return null;
+        if (new Date(this._activeGrant.grant.expiresAt).getTime() <= now.getTime())
+            return null;
+        return this._activeGrant;
+    }
+    /**
+     * Ensures a live grant exists, bootstrapping a new one when the current grant
+     * is missing or expired. A refreshed grant re-signs this device's pending
+     * records so the backend always sees the grant an intent is replayed under.
+     * @returns {Promise<import("./offline-grant.js").SignedOfflineGrant>} - Live grant.
+     */
+    async _ensureLiveGrant() {
+        const live = this._liveGrant();
+        if (live)
+            return live;
+        const granted = await this.bootstrapGrant();
+        await this._resignPendingRecords(granted);
+        return granted;
+    }
+    /**
+     * Requests a fresh offline grant from the built-in sync bootstrap endpoint
+     * and retains it under its grant id together with the sync manifest whose
+     * policy hashes mutations are signed against.
+     * @returns {Promise<import("./offline-grant.js").SignedOfflineGrant>} - Newly issued grant.
+     */
+    async bootstrapGrant() {
+        const identity = await this._ensureIdentity();
+        const authenticationToken = await this.authenticationToken();
+        const scopes = await this.config.grantScopes({ configuration: this.config.configuration });
+        if (!scopes || typeof scopes !== "object" || Array.isArray(scopes))
+            throw new Error("sync.client.offline.grantScopes must resolve a plain object of grant scopes");
+        const response = await this.post(this.config.bootstrapPath, {
+            authenticationToken,
+            deviceId: identity.certificate.certificate.actorDeviceId,
+            scopes
+        });
+        if (!response || typeof response !== "object" || Array.isArray(response)) {
+            throw new Error(`Sync offline bootstrap did not return a response object (${this.config.bootstrapPath})`);
+        }
+        const responseRecord = /** @type {Record<string, unknown>} */ (response);
+        const signedGrant = /** @type {import("./offline-grant.js").SignedOfflineGrant | undefined} */ (responseRecord.offlineGrant);
+        if (!signedGrant || typeof signedGrant !== "object" || !signedGrant.grant || typeof signedGrant.grant.grantId !== "string") {
+            throw new Error(`Sync offline bootstrap did not return a signed offline grant (${this.config.bootstrapPath})`);
+        }
+        const manifest = /** @type {Record<string, import("../configuration-types.js").NormalizedFrontendModelResourceSyncConfiguration> | undefined} */ (responseRecord.syncManifest);
+        if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) {
+            throw new Error(`Sync offline bootstrap did not return a sync manifest (${this.config.bootstrapPath})`);
+        }
+        this._grants.set(signedGrant.grant.grantId, signedGrant);
+        this._activeGrant = signedGrant;
+        this._syncManifest = manifest;
+        await this._persistGrants();
+        return signedGrant;
+    }
+    /**
+     * Forces a grant refresh: bootstrap a new grant and re-sign this device's
+     * pending records under it.
+     * @returns {Promise<SyncOfflineSessionSummary>} - Refreshed session summary.
+     */
+    async refreshGrant() {
+        await this._ensureIdentity();
+        await this._loadRetainedGrants();
+        const granted = await this.bootstrapGrant();
+        await this._resignPendingRecords(granted);
+        return this.sessionSummary();
+    }
+    /**
+     * Re-signs this device's still-pending records under a new grant. Safe
+     * because the replay idempotency key is
+     * `actorUserId:actorDeviceId:clientMutationId` and never carries the grant
+     * id. Records signed by another device (peer-forwarded mutations) keep their
+     * original signed envelope and original grant - they must always replay with
+     * the grant their signer used.
+     * @param {import("./offline-grant.js").SignedOfflineGrant} signedGrant - Grant the records are re-signed under.
+     * @returns {Promise<void>} - Resolves after pending records are re-signed.
+     */
+    async _resignPendingRecords(signedGrant) {
+        this._requireIdentity();
+        for (const mutationLog of this.mutationLogs) {
+            for (const record of await mutationLog.pendingRecords()) {
+                if (!this._isOwnRecord(record))
+                    continue;
+                if (record.mutation.offlineGrantId === signedGrant.grant.grantId && record.signedMutation)
+                    continue;
+                const signedMutation = await this.signMutation(record.mutation);
+                await mutationLog.updateMutation({ id: record.id, mutation: signedMutation.mutation, signedMutation });
+            }
+        }
+    }
+    /**
+     * Checks whether a log record was signed/queued by this device's identity
+     * (or has no identity yet and can adopt it).
+     * @param {import("./local-mutation-log.js").LocalMutationLogRecord} record - Durable record.
+     * @returns {boolean} - Whether the record belongs to this device.
+     */
+    _isOwnRecord(record) {
+        const identity = this._requireIdentity();
+        if (record.signedMutation) {
+            return record.signedMutation.mutation.actorDeviceId === identity.certificate.certificate.actorDeviceId &&
+                record.signedMutation.mutation.actorUserId === identity.certificate.certificate.actorUserId;
+        }
+        return !record.mutation.actorDeviceId || (record.mutation.actorDeviceId === identity.certificate.certificate.actorDeviceId &&
+            record.mutation.actorUserId === identity.certificate.certificate.actorUserId);
+    }
+    /**
+     * Signs one mutation payload with the device key under the live grant,
+     * filling the actor/grant/policy-hash identity from the session.
+     * @param {Omit<import("./device-identity.js").SyncMutation, "actorDeviceId" | "actorUserId" | "offlineGrantId" | "policyHash">} mutation - Mutation payload to sign (the session supplies the rotating identity fields).
+     * @returns {Promise<import("./device-identity.js").SignedSyncMutation>} - Signed mutation envelope.
+     */
+    async signMutation(mutation) {
+        const identity = await this._ensureIdentity();
+        const grant = await this._grantForSigning();
+        return await createSignedMutation({
+            deviceCertificate: identity.certificate,
+            devicePrivateKey: identity.privateKey,
+            mutation: {
+                ...mutation,
+                actorDeviceId: identity.certificate.certificate.actorDeviceId,
+                actorUserId: identity.certificate.certificate.actorUserId,
+                offlineGrantId: grant.grant.grantId,
+                policyHash: this.policyHashFor(mutation.model)
+            }
+        });
+    }
+    /**
+     * Returns the grant a new mutation is signed under: the live grant when one
+     * exists, otherwise the newest retained grant (queueing stays possible while
+     * offline - the replay pass refreshes the grant and re-signs the pending
+     * records), and only bootstraps when no grant has ever been retained.
+     * @returns {Promise<import("./offline-grant.js").SignedOfflineGrant>} - Grant to sign under.
+     */
+    async _grantForSigning() {
+        const live = this._liveGrant();
+        if (live)
+            return live;
+        if (this._activeGrant)
+            return this._activeGrant;
+        await this._loadRetainedGrants();
+        const retained = Array.from(this._grants.values()).sort((left, right) => new Date(right.grant.issuedAt).getTime() - new Date(left.grant.issuedAt).getTime());
+        if (retained.length > 0) {
+            this._activeGrant = retained[0];
+            return this._activeGrant;
+        }
+        return await this.bootstrapGrant();
+    }
+    /**
+     * Returns the policy hash the live session's sync manifest carries for one model.
+     * @param {string} model - Model/resource name.
+     * @returns {string} - Policy hash.
+     */
+    policyHashFor(model) {
+        const manifest = this._syncManifest || this._activeGrant?.grant.resources;
+        if (!manifest)
+            throw new Error("Sync offline session has no sync manifest - call startOfflineSession() first");
+        const entry = /** @type {Record<string, unknown> | undefined} */ (manifest[model]);
+        const policyHash = entry && typeof entry === "object" && !Array.isArray(entry) ? /** @type {Record<string, unknown>} */ (entry).policyHash : undefined;
+        if (typeof policyHash !== "string" || policyHash.length === 0) {
+            throw new Error(`Sync offline session has no policy hash for model '${model}' - is it sync-enabled on the backend?`);
+        }
+        return policyHash;
+    }
+    /**
+     * Drains the durable mutation logs through the built-in signed replay
+     * endpoint. Pending records are batched, each signed mutation travels with
+     * the signed grant it was signed under, and per-mutation results are mapped
+     * back onto the log records as synced/conflict/rejected.
+     * @param {object} [options] - Replay options.
+     * @param {number} [options.batchSize] - Max mutations per request.
+     * @param {AbortSignal} [options.signal] - Lifecycle cancellation signal.
+     * @returns {Promise<SyncOfflineReplayResult>} - Mapped replay result.
+     */
+    async replayPending(options = {}) {
+        if (this._replayPromise)
+            return await this._replayPromise;
+        this._replayPromise = this._replayPass(options).finally(() => {
+            this._replayPromise = null;
+        });
+        return await this._replayPromise;
+    }
+    /**
+     * Runs one signed replay pass.
+     * @param {object} options - Pass options.
+     * @param {number} [options.batchSize] - Max mutations per request.
+     * @param {AbortSignal} [options.signal] - Lifecycle cancellation signal.
+     * @returns {Promise<SyncOfflineReplayResult>} - Mapped replay result.
+     */
+    async _replayPass({ batchSize, signal } = {}) {
+        throwIfAborted(signal);
+        if (!this.isActive())
+            await this.start();
+        const maxBatchSize = typeof batchSize === "number" && batchSize >= 1 ? Math.floor(batchSize) : 100;
+        /** @type {SyncOfflineReplayResult["results"]} */
+        const results = [];
+        let syncedCount = 0;
+        let conflictCount = 0;
+        let rejectedCount = 0;
+        for (let pass = 0; pass < 10; pass += 1) {
+            throwIfAborted(signal);
+            await this._ensureLiveGrant();
+            /** @type {Array<{mutationLog: import("./local-mutation-log.js").default, record: import("./local-mutation-log.js").LocalMutationLogRecord}>} */
+            const entries = [];
+            for (const mutationLog of this.mutationLogs) {
+                for (const record of await mutationLog.pendingRecords()) {
+                    if (!record.signedMutation)
+                        continue;
+                    // A record can only replay with the grant it was signed under. Records
+                    // whose grant the session does not retain (e.g. peer imports without
+                    // their signer's grant) stay pending instead of blocking the batch.
+                    if (!this._grants.has(record.mutation.offlineGrantId))
+                        continue;
+                    entries.push({ mutationLog, record });
+                }
+            }
+            if (entries.length === 0)
+                break;
+            const batch = entries.slice(0, maxBatchSize);
+            const authenticationToken = await this.authenticationToken();
+            const mutations = batch.map((entry) => this._replayMutation(entry.record));
+            const response = await this.post(this.config.replayPath, { authenticationToken, mutations }, { signal });
+            throwIfAborted(signal);
+            const resultsByIdempotencyKey = this._replayResultsById(response);
+            for (const { mutationLog, record } of batch) {
+                throwIfAborted(signal);
+                const idempotencyKey = mutationIdempotencyKey(/** @type {import("./device-identity.js").SignedSyncMutation} */ (record.signedMutation));
+                const result = resultsByIdempotencyKey.get(idempotencyKey);
+                if (!result)
+                    throw new Error(`Signed sync replay response is missing a result for mutation ${record.mutation.clientMutationId}`);
+                const status = replayResultLocalStatus(/** @type {Record<string, import("./conflict-strategy.js").SyncJsonValue>} */ (result));
+                const serverResult = cloneJson(result, "sync replay result");
+                const updated = await mutationLog.updateStatus({
+                    id: record.id,
+                    status,
+                    syncResult: /** @type {Record<string, import("../frontend-models/base.js").FrontendModelTransportValue>} */ (serverResult)
+                });
+                results.push({
+                    clientMutationId: record.mutation.clientMutationId,
+                    idempotencyKey,
+                    mutation: /** @type {import("./device-identity.js").SyncMutation} */ (cloneJson(record.mutation, "mutation")),
+                    recordId: updated.id,
+                    serverResult,
+                    status: updated.status
+                });
+                if (updated.status === "synced")
+                    syncedCount += 1;
+                if (updated.status === "conflict")
+                    conflictCount += 1;
+                if (updated.status === "rejected")
+                    rejectedCount += 1;
+            }
+        }
+        let pendingCount = 0;
+        for (const mutationLog of this.mutationLogs) {
+            pendingCount += (await mutationLog.pendingRecords()).length;
+        }
+        return { conflictCount, pendingCount, rejectedCount, results, syncedCount };
+    }
+    /**
+     * Builds one signed replay mutation: the signed envelope plus the signed
+     * grant the mutation was signed under. Fails closed when the session does
+     * not retain that grant.
+     * @param {import("./local-mutation-log.js").LocalMutationLogRecord} record - Durable record.
+     * @returns {Record<string, ReturnType<typeof JSON.parse>>} - Replay mutation payload.
+     */
+    _replayMutation(record) {
+        const signedMutation = /** @type {import("./device-identity.js").SignedSyncMutation} */ (record.signedMutation);
+        const signedGrant = this._grants.get(signedMutation.mutation.offlineGrantId);
+        if (!signedGrant)
+            throw new Error(`Sync offline session has no retained grant '${signedMutation.mutation.offlineGrantId}' for mutation ${signedMutation.mutation.clientMutationId}`);
+        return { ...cloneJson(signedMutation, "signed mutation"), signedOfflineGrant: cloneJson(signedGrant, "signed offline grant") };
+    }
+    /**
+     * Normalizes a signed replay response into results keyed by idempotency key.
+     * @param {ReturnType<typeof JSON.parse>} response - Raw replay response.
+     * @returns {Map<string, Record<string, ReturnType<typeof JSON.parse>>>} - Results by idempotency key.
+     */
+    _replayResultsById(response) {
+        if (!response || typeof response !== "object" || Array.isArray(response))
+            throw new Error("Signed sync replay response must be an object");
+        const responseRecord = /** @type {Record<string, unknown>} */ (response);
+        if (responseRecord.status === "error")
+            throw new Error(typeof responseRecord.errorMessage === "string" ? responseRecord.errorMessage : "Signed sync replay failed");
+        if (!Array.isArray(responseRecord.results))
+            throw new Error("Signed sync replay response is missing results");
+        /** @type {Map<string, Record<string, ReturnType<typeof JSON.parse>>>} */
+        const byKey = new Map();
+        for (const result of responseRecord.results) {
+            if (!result || typeof result !== "object" || Array.isArray(result))
+                continue;
+            const resultRecord = /** @type {Record<string, unknown>} */ (result);
+            if (typeof resultRecord.idempotencyKey !== "string")
+                continue;
+            byKey.set(resultRecord.idempotencyKey, /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (resultRecord));
+        }
+        return byKey;
+    }
+    /**
+     * Exports the durable non-terminal mutations of every session log as one
+     * signed peer bundle.
+     * @param {object} [options] - Export options.
+     * @param {import("./local-mutation-log.js").LocalMutationStatus[]} [options.statuses] - Statuses to export.
+     * @param {() => Date} [options.now] - Export clock.
+     * @returns {Promise<import("./peer-mutation-bundle.js").PeerMutationBundle>} - Signed peer bundle.
+     */
+    async exportBundle(options = {}) {
+        const identity = await this._ensureIdentity();
+        /** @type {import("./peer-mutation-bundle.js").PeerMutationBundle["mutations"]} */
+        const mutations = [];
+        let bundle = null;
+        for (const mutationLog of this.mutationLogs) {
+            const logBundle = await exportPeerMutationBundle({
+                deviceCertificate: identity.certificate,
+                devicePrivateKey: identity.privateKey,
+                mutationLog,
+                ...options
+            });
+            if (!bundle)
+                bundle = logBundle;
+            else
+                mutations.push(...logBundle.mutations);
+        }
+        if (!bundle) {
+            throw new Error("Sync offline session export produced no bundle");
+        }
+        bundle.mutations = mutations.length > 0 ? [...bundle.mutations, ...mutations].sort((left, right) => (left.localSequence || 0) - (right.localSequence || 0)) : bundle.mutations;
+        return bundle;
+    }
+    /**
+     * Imports a peer bundle: every entry is verified against the configured
+     * backend public key before it is appended to a local mutation log. Entries
+     * already present by idempotency key are skipped as duplicates.
+     * @param {object} args - Import args.
+     * @param {import("./peer-mutation-bundle.js").PeerMutationBundle} args.bundle - Peer bundle to import.
+     * @param {Array<import("./offline-grant.js").SignedOfflineGrant>} [args.signedOfflineGrants] - Grants the peer signed its mutations under. They are retained so imported mutations replay with the grant their signer used.
+     * @param {import("./local-mutation-log.js").default} [args.mutationLog] - Target log. Defaults to the first session log.
+     * @returns {Promise<import("./peer-mutation-bundle.js").PeerMutationBundleImportResult>} - Import result.
+     */
+    async importBundle({ bundle, mutationLog, signedOfflineGrants = [] }) {
+        if (!this.config.backendPublicKey)
+            throw new Error("sync.client.offline.backendPublicKey is required to import a peer mutation bundle");
+        if (!Array.isArray(signedOfflineGrants))
+            throw new Error("sync offline import signedOfflineGrants must be an array of signed offline grants");
+        for (const signedGrant of signedOfflineGrants) {
+            if (!signedGrant || typeof signedGrant !== "object" || !signedGrant.grant || typeof signedGrant.grant.grantId !== "string") {
+                throw new Error("sync offline import requires signed offline grant envelopes with grant payloads");
+            }
+            this._grants.set(signedGrant.grant.grantId, signedGrant);
+        }
+        if (signedOfflineGrants.length > 0)
+            await this._persistGrants();
+        return await importPeerMutationBundle({
+            backendPublicKey: this.config.backendPublicKey,
+            bundle,
+            mutationLog: mutationLog || this.mutationLogs[0]
+        });
+    }
+    /**
+     * Persists retained grants through the optional app-owned grant storage.
+     * @returns {Promise<void>} - Resolves after retention is persisted.
+     */
+    async _persistGrants() {
+        if (!this.config.grantStorage)
+            return;
+        await this.config.grantStorage.save(Array.from(this._grants.values()));
+    }
+    /**
+     * Returns the session clock.
+     * @returns {Date} - Current time.
+     */
+    _now() {
+        return this.config.now();
+    }
+    /**
+     * Returns the device identity or fails closed.
+     * @returns {SyncOfflineDeviceIdentity} - Device identity.
+     */
+    _requireIdentity() {
+        if (!this._identity)
+            throw new Error("Sync offline session has no device identity - call startOfflineSession() first");
+        return this._identity;
+    }
+    /**
+     * Returns the live grant or fails closed.
+     * @returns {import("./offline-grant.js").SignedOfflineGrant} - Live grant.
+     */
+    _requireLiveGrant() {
+        const grant = this._liveGrant();
+        if (!grant)
+            throw new Error("Sync offline session has no live offline grant - call startOfflineSession() or refreshOfflineGrant()");
+        return grant;
+    }
+}
+/**
+ * Clones a JSON object.
+ * @param {unknown} value - Value.
+ * @param {string} label - Diagnostic label.
+ * @returns {Record<string, ReturnType<typeof JSON.parse>>} - Cloned object.
+ */
+function cloneJson(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error(`Expected sync offline ${label} object`);
+    return /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (JSON.parse(JSON.stringify(value)));
+}
+/**
+ * Throws the exact abort reason at lifecycle boundaries.
+ * @param {AbortSignal | undefined} signal - Lifecycle signal.
+ * @returns {void} - No return value.
+ */
+function throwIfAborted(signal) {
+    if (!signal?.aborted)
+        return;
+    throw signal.reason instanceof Error ? signal.reason : new Error("Sync offline replay aborted");
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-offline-session.js","sourceRoot":"","sources":["../../../src/sync/sync-offline-session.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,EACL,oBAAoB,EACpB,0BAA0B,EAC1B,sBAAsB,EACtB,uBAAuB,EACxB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAC,wBAAwB,EAAE,wBAAwB,EAAC,MAAM,2BAA2B,CAAA;AAC5F,OAAO,EAAC,uBAAuB,EAAC,MAAM,wBAAwB,CAAA;AAE9D;;;;;;GAMG;AACH;;;;;;;;GAQG;AACH;;;;;;;GAOG;AAEH;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,OAAO,kBAAkB;IACrC;;;;;;;OAOG;IACH,YAAY,EAAC,mBAAmB,EAAE,MAAM,EAAE,YAAY,EAAE,IAAI,EAAC;QAC3D,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAA;QAEvI,IAAI,CAAC,mBAAmB,GAAG,mBAAmB,CAAA;QAC9C,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;QACpB,IAAI,CAAC,YAAY,GAAG,YAAY,CAAA;QAChC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QAEhB,+CAA+C;QAC/C,IAAI,CAAC,SAAS,GAAG,IAAI,CAAA;QACrB,2EAA2E;QAC3E,IAAI,CAAC,OAAO,GAAG,IAAI,GAAG,EAAE,CAAA;QACxB,IAAI,CAAC,aAAa,GAAG,KAAK,CAAA;QAC1B,qEAAqE;QACrE,IAAI,CAAC,YAAY,GAAG,IAAI,CAAA;QACxB,0HAA0H;QAC1H,IAAI,CAAC,aAAa,GAAG,IAAI,CAAA;QACzB,wDAAwD;QACxD,IAAI,CAAC,aAAa,GAAG,IAAI,CAAA;QACzB,sDAAsD;QACtD,IAAI,CAAC,cAAc,GAAG,IAAI,CAAA;IAC5B,CAAC;IAED;;;OAGG;IACH,QAAQ;QACN,OAAO,OAAO,CAAC,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC,CAAA;IACrD,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,KAAK;QACT,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,UAAU,EAAE;YAAE,OAAO,IAAI,CAAC,cAAc,EAAE,CAAA;QAErE,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;YACxB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE;gBACzD,IAAI,CAAC,aAAa,GAAG,IAAI,CAAA;gBAEzB,OAAO,OAAO,CAAA;YAChB,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE;gBACX,IAAI,CAAC,aAAa,GAAG,IAAI,CAAA;gBAEzB,MAAM,KAAK,CAAA;YACb,CAAC,CAAC,CAAA;QACJ,CAAC;QAED,OAAO,MAAM,IAAI,CAAC,aAAa,CAAA;IACjC,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,IAAI;QACR,IAAI,IAAI,CAAC,cAAc;YAAE,MAAM,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAA;QAEzE,IAAI,CAAC,SAAS,GAAG,IAAI,CAAA;QACrB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAA;QACxB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAA;QACzB,IAAI,CAAC,aAAa,GAAG,KAAK,CAAA;IAC5B,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,aAAa;QACjB,MAAM,IAAI,CAAC,eAAe,EAAE,CAAA;QAC5B,MAAM,IAAI,CAAC,mBAAmB,EAAE,CAAA;QAChC,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAA;QAE7B,OAAO,IAAI,CAAC,cAAc,EAAE,CAAA;IAC9B,CAAC;IAED;;;OAGG;IACH,cAAc;QACZ,MAAM,QAAQ,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAA;QACxC,MAAM,KAAK,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAA;QAEtC,OAAO;YACL,aAAa,EAAE,QAAQ,CAAC,WAAW,CAAC,WAAW,CAAC,aAAa;YAC7D,WAAW,EAAE,QAAQ,CAAC,WAAW,CAAC,WAAW,CAAC,WAAW;YACzD,SAAS,EAAE,KAAK,CAAC,KAAK,CAAC,SAAS;YAChC,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,OAAO;SAC7B,CAAA;IACH,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,eAAe;QACnB,IAAI,IAAI,CAAC,SAAS;YAAE,OAAO,IAAI,CAAC,SAAS,CAAA;QAEzC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,qBAAqB,CAAC,IAAI,EAAE,CAAA;QAE7D,IAAI,MAAM,EAAE,CAAC;YACX,IAAI,CAAC,SAAS,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAA;YAErD,OAAO,IAAI,CAAC,SAAS,CAAA;QACvB,CAAC;QAED,MAAM,OAAO,GAAG,MAAM,0BAA0B,EAAE,CAAA;QAClD,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC;YACjD,aAAa,EAAE,IAAI,CAAC,MAAM,CAAC,aAAa;YACxC,SAAS,EAAE,OAAO,CAAC,SAAS;SAC7B,CAAC,CAAA;QACF,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,EAAC,WAAW,EAAE,UAAU,EAAE,OAAO,CAAC,UAAU,EAAC,CAAC,CAAA;QAE5F,MAAM,IAAI,CAAC,MAAM,CAAC,qBAAqB,CAAC,IAAI,CAAC,wCAAwC,CAAC,CAAC,SAAS,CAAC,QAAQ,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAA;QAE/H,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAA;QAEzB,OAAO,QAAQ,CAAA;IACjB,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,iBAAiB,CAAC,QAAQ;QAC9B,IAAI,CAAC,QAAQ,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;YACzE,MAAM,IAAI,KAAK,CAAC,4FAA4F,CAAC,CAAA;QAC/G,CAAC;QACD,IAAI,CAAC,QAAQ,CAAC,WAAW,IAAI,CAAC,QAAQ,CAAC,UAAU;YAAE,MAAM,IAAI,KAAK,CAAC,6EAA6E,CAAC,CAAA;QAEjJ,IAAI,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC;YACjC,MAAM,uBAAuB,CAAC;gBAC5B,gBAAgB,EAAE,IAAI,CAAC,MAAM,CAAC,gBAAgB;gBAC9C,WAAW,EAAE,QAAQ,CAAC,WAAW;aAClC,CAAC,CAAA;QACJ,CAAC;QAED,OAAO,QAAQ,CAAA;IACjB,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,mBAAmB;QACvB,IAAI,IAAI,CAAC,aAAa;YAAE,OAAM;QAE9B,IAAI,CAAC,aAAa,GAAG,IAAI,CAAA;QACzB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,YAAY;YAAE,OAAM;QAErC,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,CAAA;QAEtD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,sFAAsF,CAAC,CAAA;QAErI,KAAK,MAAM,WAAW,IAAI,QAAQ,EAAE,CAAC;YACnC,IAAI,CAAC,WAAW,IAAI,OAAO,WAAW,KAAK,QAAQ,IAAI,CAAC,WAAW,CAAC,KAAK,IAAI,OAAO,WAAW,CAAC,KAAK,CAAC,OAAO,KAAK,QAAQ;gBAAE,SAAQ;YAEpI,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,KAAK,CAAC,OAAO,EAAE,WAAW,CAAC,CAAA;QAC1D,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACH,UAAU,CAAC,GAAG,GAAG,IAAI,CAAC,IAAI,EAAE;QAC1B,IAAI,CAAC,IAAI,CAAC,YAAY;YAAE,OAAO,IAAI,CAAA;QACnC,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,IAAI,GAAG,CAAC,OAAO,EAAE;YAAE,OAAO,IAAI,CAAA;QAEvF,OAAO,IAAI,CAAC,YAAY,CAAA;IAC1B,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,gBAAgB;QACpB,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,EAAE,CAAA;QAE9B,IAAI,IAAI;YAAE,OAAO,IAAI,CAAA;QAErB,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,cAAc,EAAE,CAAA;QAE3C,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAA;QAEzC,OAAO,OAAO,CAAA;IAChB,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,cAAc;QAClB,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,eAAe,EAAE,CAAA;QAC7C,MAAM,mBAAmB,GAAG,MAAM,IAAI,CAAC,mBAAmB,EAAE,CAAA;QAC5D,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,EAAC,aAAa,EAAE,IAAI,CAAC,MAAM,CAAC,aAAa,EAAC,CAAC,CAAA;QAExF,IAAI,CAAC,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,6EAA6E,CAAC,CAAA;QAElK,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE;YAC1D,mBAAmB;YACnB,QAAQ,EAAE,QAAQ,CAAC,WAAW,CAAC,WAAW,CAAC,aAAa;YACxD,MAAM;SACP,CAAC,CAAA;QAEF,IAAI,CAAC,QAAQ,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;YACzE,MAAM,IAAI,KAAK,CAAC,4DAA4D,IAAI,CAAC,MAAM,CAAC,aAAa,GAAG,CAAC,CAAA;QAC3G,CAAC;QAED,MAAM,cAAc,GAAG,sCAAsC,CAAC,CAAC,QAAQ,CAAC,CAAA;QACxE,MAAM,WAAW,GAAG,0EAA0E,CAAC,CAAC,cAAc,CAAC,YAAY,CAAC,CAAA;QAE5H,IAAI,CAAC,WAAW,IAAI,OAAO,WAAW,KAAK,QAAQ,IAAI,CAAC,WAAW,CAAC,KAAK,IAAI,OAAO,WAAW,CAAC,KAAK,CAAC,OAAO,KAAK,QAAQ,EAAE,CAAC;YAC3H,MAAM,IAAI,KAAK,CAAC,iEAAiE,IAAI,CAAC,MAAM,CAAC,aAAa,GAAG,CAAC,CAAA;QAChH,CAAC;QAED,MAAM,QAAQ,GAAG,+HAA+H,CAAC,CAAC,cAAc,CAAC,YAAY,CAAC,CAAA;QAE9K,IAAI,CAAC,QAAQ,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;YACzE,MAAM,IAAI,KAAK,CAAC,0DAA0D,IAAI,CAAC,MAAM,CAAC,aAAa,GAAG,CAAC,CAAA;QACzG,CAAC;QAED,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,KAAK,CAAC,OAAO,EAAE,WAAW,CAAC,CAAA;QACxD,IAAI,CAAC,YAAY,GAAG,WAAW,CAAA;QAC/B,IAAI,CAAC,aAAa,GAAG,QAAQ,CAAA;QAC7B,MAAM,IAAI,CAAC,cAAc,EAAE,CAAA;QAE3B,OAAO,WAAW,CAAA;IACpB,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,YAAY;QAChB,MAAM,IAAI,CAAC,eAAe,EAAE,CAAA;QAC5B,MAAM,IAAI,CAAC,mBAAmB,EAAE,CAAA;QAEhC,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,cAAc,EAAE,CAAA;QAE3C,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAA;QAEzC,OAAO,IAAI,CAAC,cAAc,EAAE,CAAA;IAC9B,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK,CAAC,qBAAqB,CAAC,WAAW;QACrC,IAAI,CAAC,gBAAgB,EAAE,CAAA;QAEvB,KAAK,MAAM,WAAW,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YAC5C,KAAK,MAAM,MAAM,IAAI,MAAM,WAAW,CAAC,cAAc,EAAE,EAAE,CAAC;gBACxD,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC;oBAAE,SAAQ;gBACxC,IAAI,MAAM,CAAC,QAAQ,CAAC,cAAc,KAAK,WAAW,CAAC,KAAK,CAAC,OAAO,IAAI,MAAM,CAAC,cAAc;oBAAE,SAAQ;gBAEnG,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;gBAE/D,MAAM,WAAW,CAAC,cAAc,CAAC,EAAC,EAAE,EAAE,MAAM,CAAC,EAAE,EAAE,QAAQ,EAAE,cAAc,CAAC,QAAQ,EAAE,cAAc,EAAC,CAAC,CAAA;YACtG,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,YAAY,CAAC,MAAM;QACjB,MAAM,QAAQ,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAA;QAExC,IAAI,MAAM,CAAC,cAAc,EAAE,CAAC;YAC1B,OAAO,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,aAAa,KAAK,QAAQ,CAAC,WAAW,CAAC,WAAW,CAAC,aAAa;gBACpG,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,WAAW,KAAK,QAAQ,CAAC,WAAW,CAAC,WAAW,CAAC,WAAW,CAAA;QAC/F,CAAC;QAED,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa,IAAI,CACvC,MAAM,CAAC,QAAQ,CAAC,aAAa,KAAK,QAAQ,CAAC,WAAW,CAAC,WAAW,CAAC,aAAa;YAChF,MAAM,CAAC,QAAQ,CAAC,WAAW,KAAK,QAAQ,CAAC,WAAW,CAAC,WAAW,CAAC,WAAW,CAC7E,CAAA;IACH,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,YAAY,CAAC,QAAQ;QACzB,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,eAAe,EAAE,CAAA;QAC7C,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAA;QAE3C,OAAO,MAAM,oBAAoB,CAAC;YAChC,iBAAiB,EAAE,QAAQ,CAAC,WAAW;YACvC,gBAAgB,EAAE,QAAQ,CAAC,UAAU;YACrC,QAAQ,EAAE;gBACR,GAAG,QAAQ;gBACX,aAAa,EAAE,QAAQ,CAAC,WAAW,CAAC,WAAW,CAAC,aAAa;gBAC7D,WAAW,EAAE,QAAQ,CAAC,WAAW,CAAC,WAAW,CAAC,WAAW;gBACzD,cAAc,EAAE,KAAK,CAAC,KAAK,CAAC,OAAO;gBACnC,UAAU,EAAE,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC;aAC/C;SACF,CAAC,CAAA;IACJ,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,gBAAgB;QACpB,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,EAAE,CAAA;QAE9B,IAAI,IAAI;YAAE,OAAO,IAAI,CAAA;QACrB,IAAI,IAAI,CAAC,YAAY;YAAE,OAAO,IAAI,CAAC,YAAY,CAAA;QAE/C,MAAM,IAAI,CAAC,mBAAmB,EAAE,CAAA;QAEhC,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,OAAO,EAAE,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,OAAO,EAAE,CAAC,CAAA;QAE5J,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACxB,IAAI,CAAC,YAAY,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAA;YAE/B,OAAO,IAAI,CAAC,YAAY,CAAA;QAC1B,CAAC;QAED,OAAO,MAAM,IAAI,CAAC,cAAc,EAAE,CAAA;IACpC,CAAC;IAED;;;;OAIG;IACH,aAAa,CAAC,KAAK;QACjB,MAAM,QAAQ,GAAG,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,YAAY,EAAE,KAAK,CAAC,SAAS,CAAA;QAEzE,IAAI,CAAC,QAAQ;YAAE,MAAM,IAAI,KAAK,CAAC,8EAA8E,CAAC,CAAA;QAE9G,MAAM,KAAK,GAAG,kDAAkD,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAA;QAClF,MAAM,UAAU,GAAG,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,sCAAsC,CAAC,CAAC,KAAK,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAA;QAEtJ,IAAI,OAAO,UAAU,KAAK,QAAQ,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC9D,MAAM,IAAI,KAAK,CAAC,sDAAsD,KAAK,wCAAwC,CAAC,CAAA;QACtH,CAAC;QAED,OAAO,UAAU,CAAA;IACnB,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK,CAAC,aAAa,CAAC,OAAO,GAAG,EAAE;QAC9B,IAAI,IAAI,CAAC,cAAc;YAAE,OAAO,MAAM,IAAI,CAAC,cAAc,CAAA;QAEzD,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE;YAC3D,IAAI,CAAC,cAAc,GAAG,IAAI,CAAA;QAC5B,CAAC,CAAC,CAAA;QAEF,OAAO,MAAM,IAAI,CAAC,cAAc,CAAA;IAClC,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,WAAW,CAAC,EAAC,SAAS,EAAE,MAAM,EAAC,GAAG,EAAE;QACxC,cAAc,CAAC,MAAM,CAAC,CAAA;QAEtB,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;YAAE,MAAM,IAAI,CAAC,KAAK,EAAE,CAAA;QAExC,MAAM,YAAY,GAAG,OAAO,SAAS,KAAK,QAAQ,IAAI,SAAS,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,CAAA;QAClG,iDAAiD;QACjD,MAAM,OAAO,GAAG,EAAE,CAAA;QAClB,IAAI,WAAW,GAAG,CAAC,CAAA;QACnB,IAAI,aAAa,GAAG,CAAC,CAAA;QACrB,IAAI,aAAa,GAAG,CAAC,CAAA;QAErB,KAAK,IAAI,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,EAAE,EAAE,IAAI,IAAI,CAAC,EAAE,CAAC;YACxC,cAAc,CAAC,MAAM,CAAC,CAAA;YACtB,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAA;YAE7B,gJAAgJ;YAChJ,MAAM,OAAO,GAAG,EAAE,CAAA;YAElB,KAAK,MAAM,WAAW,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;gBAC5C,KAAK,MAAM,MAAM,IAAI,MAAM,WAAW,CAAC,cAAc,EAAE,EAAE,CAAC;oBACxD,IAAI,CAAC,MAAM,CAAC,cAAc;wBAAE,SAAQ;oBACpC,uEAAuE;oBACvE,qEAAqE;oBACrE,oEAAoE;oBACpE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,cAAc,CAAC;wBAAE,SAAQ;oBAE/D,OAAO,CAAC,IAAI,CAAC,EAAC,WAAW,EAAE,MAAM,EAAC,CAAC,CAAA;gBACrC,CAAC;YACH,CAAC;YAED,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;gBAAE,MAAK;YAE/B,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,YAAY,CAAC,CAAA;YAC5C,MAAM,mBAAmB,GAAG,MAAM,IAAI,CAAC,mBAAmB,EAAE,CAAA;YAC5D,MAAM,SAAS,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAA;YAC1E,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,EAAC,mBAAmB,EAAE,SAAS,EAAC,EAAE,EAAC,MAAM,EAAC,CAAC,CAAA;YAEpG,cAAc,CAAC,MAAM,CAAC,CAAA;YAEtB,MAAM,uBAAuB,GAAG,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAA;YAEjE,KAAK,MAAM,EAAC,WAAW,EAAE,MAAM,EAAC,IAAI,KAAK,EAAE,CAAC;gBAC1C,cAAc,CAAC,MAAM,CAAC,CAAA;gBACtB,MAAM,cAAc,GAAG,sBAAsB,CAAC,gEAAgE,CAAC,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,CAAA;gBACvI,MAAM,MAAM,GAAG,uBAAuB,CAAC,GAAG,CAAC,cAAc,CAAC,CAAA;gBAE1D,IAAI,CAAC,MAAM;oBAAE,MAAM,IAAI,KAAK,CAAC,gEAAgE,MAAM,CAAC,QAAQ,CAAC,gBAAgB,EAAE,CAAC,CAAA;gBAEhI,MAAM,MAAM,GAAG,uBAAuB,CAAC,6EAA6E,CAAC,CAAC,MAAM,CAAC,CAAC,CAAA;gBAC9H,MAAM,YAAY,GAAG,SAAS,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAA;gBAC5D,MAAM,OAAO,GAAG,MAAM,WAAW,CAAC,YAAY,CAAC;oBAC7C,EAAE,EAAE,MAAM,CAAC,EAAE;oBACb,MAAM;oBACN,UAAU,EAAE,+FAA+F,CAAC,CAAC,YAAY,CAAC;iBAC3H,CAAC,CAAA;gBAEF,OAAO,CAAC,IAAI,CAAC;oBACX,gBAAgB,EAAE,MAAM,CAAC,QAAQ,CAAC,gBAAgB;oBAClD,cAAc;oBACd,QAAQ,EAAE,0DAA0D,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;oBAC7G,QAAQ,EAAE,OAAO,CAAC,EAAE;oBACpB,YAAY;oBACZ,MAAM,EAAE,OAAO,CAAC,MAAM;iBACvB,CAAC,CAAA;gBAEF,IAAI,OAAO,CAAC,MAAM,KAAK,QAAQ;oBAAE,WAAW,IAAI,CAAC,CAAA;gBACjD,IAAI,OAAO,CAAC,MAAM,KAAK,UAAU;oBAAE,aAAa,IAAI,CAAC,CAAA;gBACrD,IAAI,OAAO,CAAC,MAAM,KAAK,UAAU;oBAAE,aAAa,IAAI,CAAC,CAAA;YACvD,CAAC;QACH,CAAC;QAED,IAAI,YAAY,GAAG,CAAC,CAAA;QAEpB,KAAK,MAAM,WAAW,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YAC5C,YAAY,IAAI,CAAC,MAAM,WAAW,CAAC,cAAc,EAAE,CAAC,CAAC,MAAM,CAAA;QAC7D,CAAC;QAED,OAAO,EAAC,aAAa,EAAE,YAAY,EAAE,aAAa,EAAE,OAAO,EAAE,WAAW,EAAC,CAAA;IAC3E,CAAC;IAED;;;;;;OAMG;IACH,eAAe,CAAC,MAAM;QACpB,MAAM,cAAc,GAAG,gEAAgE,CAAC,CAAC,MAAM,CAAC,cAAc,CAAC,CAAA;QAC/G,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAA;QAE5E,IAAI,CAAC,WAAW;YAAE,MAAM,IAAI,KAAK,CAAC,+CAA+C,cAAc,CAAC,QAAQ,CAAC,cAAc,kBAAkB,cAAc,CAAC,QAAQ,CAAC,gBAAgB,EAAE,CAAC,CAAA;QAEpL,OAAO,EAAC,GAAG,SAAS,CAAC,cAAc,EAAE,iBAAiB,CAAC,EAAE,kBAAkB,EAAE,SAAS,CAAC,WAAW,EAAE,sBAAsB,CAAC,EAAC,CAAA;IAC9H,CAAC;IAED;;;;OAIG;IACH,kBAAkB,CAAC,QAAQ;QACzB,IAAI,CAAC,QAAQ,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAA;QAE1I,MAAM,cAAc,GAAG,sCAAsC,CAAC,CAAC,QAAQ,CAAC,CAAA;QAExE,IAAI,cAAc,CAAC,MAAM,KAAK,OAAO;YAAE,MAAM,IAAI,KAAK,CAAC,OAAO,cAAc,CAAC,YAAY,KAAK,QAAQ,CAAC,CAAC,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC,CAAC,2BAA2B,CAAC,CAAA;QACnK,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,cAAc,CAAC,OAAO,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAA;QAE7G,yEAAyE;QACzE,MAAM,KAAK,GAAG,IAAI,GAAG,EAAE,CAAA;QAEvB,KAAK,MAAM,MAAM,IAAI,cAAc,CAAC,OAAO,EAAE,CAAC;YAC5C,IAAI,CAAC,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC;gBAAE,SAAQ;YAE5E,MAAM,YAAY,GAAG,sCAAsC,CAAC,CAAC,MAAM,CAAC,CAAA;YAEpE,IAAI,OAAO,YAAY,CAAC,cAAc,KAAK,QAAQ;gBAAE,SAAQ;YAE7D,KAAK,CAAC,GAAG,CAAC,YAAY,CAAC,cAAc,EAAE,4DAA4D,CAAC,CAAC,YAAY,CAAC,CAAC,CAAA;QACrH,CAAC;QAED,OAAO,KAAK,CAAA;IACd,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,YAAY,CAAC,OAAO,GAAG,EAAE;QAC7B,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,eAAe,EAAE,CAAA;QAC7C,kFAAkF;QAClF,MAAM,SAAS,GAAG,EAAE,CAAA;QACpB,IAAI,MAAM,GAAG,IAAI,CAAA;QAEjB,KAAK,MAAM,WAAW,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YAC5C,MAAM,SAAS,GAAG,MAAM,wBAAwB,CAAC;gBAC/C,iBAAiB,EAAE,QAAQ,CAAC,WAAW;gBACvC,gBAAgB,EAAE,QAAQ,CAAC,UAAU;gBACrC,WAAW;gBACX,GAAG,OAAO;aACX,CAAC,CAAA;YAEF,IAAI,CAAC,MAAM;gBAAE,MAAM,GAAG,SAAS,CAAA;;gBAC1B,SAAS,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC,SAAS,CAAC,CAAA;QAC7C,CAAC;QAED,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAA;QACnE,CAAC;QAED,MAAM,CAAC,SAAS,GAAG,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,SAAS,EAAE,GAAG,SAAS,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,aAAa,IAAI,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,aAAa,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAA;QAE9K,OAAO,MAAM,CAAA;IACf,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK,CAAC,YAAY,CAAC,EAAC,MAAM,EAAE,WAAW,EAAE,mBAAmB,GAAG,EAAE,EAAC;QAChE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,gBAAgB;YAAE,MAAM,IAAI,KAAK,CAAC,mFAAmF,CAAC,CAAA;QACvI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,mBAAmB,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,mFAAmF,CAAC,CAAA;QAE7I,KAAK,MAAM,WAAW,IAAI,mBAAmB,EAAE,CAAC;YAC9C,IAAI,CAAC,WAAW,IAAI,OAAO,WAAW,KAAK,QAAQ,IAAI,CAAC,WAAW,CAAC,KAAK,IAAI,OAAO,WAAW,CAAC,KAAK,CAAC,OAAO,KAAK,QAAQ,EAAE,CAAC;gBAC3H,MAAM,IAAI,KAAK,CAAC,iFAAiF,CAAC,CAAA;YACpG,CAAC;YAED,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,KAAK,CAAC,OAAO,EAAE,WAAW,CAAC,CAAA;QAC1D,CAAC;QAED,IAAI,mBAAmB,CAAC,MAAM,GAAG,CAAC;YAAE,MAAM,IAAI,CAAC,cAAc,EAAE,CAAA;QAE/D,OAAO,MAAM,wBAAwB,CAAC;YACpC,gBAAgB,EAAE,IAAI,CAAC,MAAM,CAAC,gBAAgB;YAC9C,MAAM;YACN,WAAW,EAAE,WAAW,IAAI,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC;SACjD,CAAC,CAAA;IACJ,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,cAAc;QAClB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,YAAY;YAAE,OAAM;QAErC,MAAM,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,CAAA;IACxE,CAAC;IAED;;;OAGG;IACH,IAAI;QACF,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAA;IAC1B,CAAC;IAED;;;OAGG;IACH,gBAAgB;QACd,IAAI,CAAC,IAAI,CAAC,SAAS;YAAE,MAAM,IAAI,KAAK,CAAC,gFAAgF,CAAC,CAAA;QAEtH,OAAO,IAAI,CAAC,SAAS,CAAA;IACvB,CAAC;IAED;;;OAGG;IACH,iBAAiB;QACf,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,EAAE,CAAA;QAE/B,IAAI,CAAC,KAAK;YAAE,MAAM,IAAI,KAAK,CAAC,sGAAsG,CAAC,CAAA;QAEnI,OAAO,KAAK,CAAA;IACd,CAAC;CACF;AAED;;;;;GAKG;AACH,SAAS,SAAS,CAAC,KAAK,EAAE,KAAK;IAC7B,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,yBAAyB,KAAK,SAAS,CAAC,CAAA;IAEzH,OAAO,4DAA4D,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;AACzG,CAAC;AAED;;;;GAIG;AACH,SAAS,cAAc,CAAC,MAAM;IAC5B,IAAI,CAAC,MAAM,EAAE,OAAO;QAAE,OAAM;IAE5B,MAAM,MAAM,CAAC,MAAM,YAAY,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAA;AACjG,CAAC","sourcesContent":["// @ts-check\n\nimport {\n  createSignedMutation,\n  generateSyncSigningKeyPair,\n  mutationIdempotencyKey,\n  verifyDeviceCertificate\n} from \"./device-identity.js\"\nimport {exportPeerMutationBundle, importPeerMutationBundle} from \"./peer-mutation-bundle.js\"\nimport {replayResultLocalStatus} from \"./conflict-strategy.js\"\n\n/**\n * Stored device signing identity: the backend-signed certificate plus the\n * device private key matching the certificate's public key.\n * @typedef {object} SyncOfflineDeviceIdentity\n * @property {import(\"./device-identity.js\").DeviceCertificate} certificate - Backend-signed device certificate.\n * @property {import(\"./device-identity.js\").SyncJsonWebKey} privateKey - Device private signing key (JWK).\n */\n/**\n * Result of one offline session replay pass over the durable mutation logs.\n * @typedef {object} SyncOfflineReplayResult\n * @property {number} conflictCount - Records left in `conflict`.\n * @property {number} pendingCount - Records still pending (blocked dependencies or unacknowledged).\n * @property {number} rejectedCount - Records the backend rejected.\n * @property {Array<{clientMutationId: string, idempotencyKey: string, mutation: import(\"./device-identity.js\").SyncMutation, recordId: string, serverResult: Record<string, ReturnType<typeof JSON.parse>> | null, status: import(\"./local-mutation-log.js\").LocalMutationStatus}>} results - Per-mutation mapped results in replay order.\n * @property {number} syncedCount - Records acknowledged by the backend.\n */\n/**\n * Session summary returned by start/refresh.\n * @typedef {object} SyncOfflineSessionSummary\n * @property {string} actorDeviceId - Certificate device identity.\n * @property {string} actorUserId - Certificate user identity.\n * @property {string} expiresAt - Live grant expiry.\n * @property {string} grantId - Live grant id.\n */\n\n/**\n * Framework-owned long-offline session behind SyncClient: device identity\n * lifecycle, backend-issued offline grants, mutation signing, signed replay,\n * and peer bundle transfer. SyncClient owns the public API; this class owns the\n * session state. The app only provides durable storage adapters, the\n * enrollment hook, and the grant scopes callback.\n */\nexport default class SyncOfflineSession {\n  /**\n   * Builds an offline session from the normalized `sync.client.offline` block.\n   * @param {object} args - Session args.\n   * @param {() => string | Promise<string>} args.authenticationToken - Resolves the auth token sent with bootstrap/replay requests.\n   * @param {import(\"../configuration-types.js\").NormalizedVelociousSyncClientOfflineConfiguration} args.config - Normalized offline configuration.\n   * @param {Array<import(\"./local-mutation-log.js\").default>} args.mutationLogs - Durable local mutation logs the session signs, replays, resigns, and exports.\n   * @param {(path: string, payload: Record<string, ReturnType<typeof JSON.parse>>, options?: {signal?: AbortSignal}) => Promise<ReturnType<typeof JSON.parse>>} args.post - Framework POSTer over the configured transport.\n   */\n  constructor({authenticationToken, config, mutationLogs, post}) {\n    if (!Array.isArray(mutationLogs) || mutationLogs.length === 0) throw new Error(\"SyncOfflineSession requires at least one mutation log\")\n\n    this.authenticationToken = authenticationToken\n    this.config = config\n    this.mutationLogs = mutationLogs\n    this.post = post\n\n    /** @type {SyncOfflineDeviceIdentity | null} */\n    this._identity = null\n    /** @type {Map<string, import(\"./offline-grant.js\").SignedOfflineGrant>} */\n    this._grants = new Map()\n    this._grantsLoaded = false\n    /** @type {import(\"./offline-grant.js\").SignedOfflineGrant | null} */\n    this._activeGrant = null\n    /** @type {Record<string, import(\"../configuration-types.js\").NormalizedFrontendModelResourceSyncConfiguration> | null} */\n    this._syncManifest = null\n    /** @type {Promise<SyncOfflineSessionSummary> | null} */\n    this._startPromise = null\n    /** @type {Promise<SyncOfflineReplayResult> | null} */\n    this._replayPromise = null\n  }\n\n  /**\n   * Whether the session currently has a usable device identity and live grant.\n   * @returns {boolean} - Whether the session is active.\n   */\n  isActive() {\n    return Boolean(this._identity && this._liveGrant())\n  }\n\n  /**\n   * Resolves the device signing identity (generating and enrolling a key pair\n   * when the app-owned storage has none) and bootstraps a live offline grant.\n   * Idempotent and single-flighted: concurrent starts share one bootstrap.\n   * @returns {Promise<SyncOfflineSessionSummary>} - Session summary.\n   */\n  async start() {\n    if (this._identity && this._liveGrant()) return this.sessionSummary()\n\n    if (!this._startPromise) {\n      this._startPromise = this._startSession().then((summary) => {\n        this._startPromise = null\n\n        return summary\n      }, (error) => {\n        this._startPromise = null\n\n        throw error\n      })\n    }\n\n    return await this._startPromise\n  }\n\n  /**\n   * Drops the in-memory session (identity and grants stay in the app-owned\n   * durable storage; pending mutations stay in the durable mutation logs).\n   * @returns {Promise<void>} - Resolves after the session is dropped.\n   */\n  async stop() {\n    if (this._replayPromise) await this._replayPromise.catch(() => undefined)\n\n    this._identity = null\n    this._activeGrant = null\n    this._syncManifest = null\n    this._grantsLoaded = false\n  }\n\n  /**\n   * Runs one start attempt: identity first, then grant bootstrap.\n   * @returns {Promise<SyncOfflineSessionSummary>} - Session summary.\n   */\n  async _startSession() {\n    await this._ensureIdentity()\n    await this._loadRetainedGrants()\n    await this._ensureLiveGrant()\n\n    return this.sessionSummary()\n  }\n\n  /**\n   * Returns the current session summary.\n   * @returns {SyncOfflineSessionSummary} - Session summary.\n   */\n  sessionSummary() {\n    const identity = this._requireIdentity()\n    const grant = this._requireLiveGrant()\n\n    return {\n      actorDeviceId: identity.certificate.certificate.actorDeviceId,\n      actorUserId: identity.certificate.certificate.actorUserId,\n      expiresAt: grant.grant.expiresAt,\n      grantId: grant.grant.grantId\n    }\n  }\n\n  /**\n   * Resolves the device identity: load it from the app-owned storage, or\n   * generate a key pair, run the app-owned enrollment hook, verify the returned\n   * certificate against the configured backend public key, and store it.\n   * @returns {Promise<SyncOfflineDeviceIdentity>} - Device signing identity.\n   */\n  async _ensureIdentity() {\n    if (this._identity) return this._identity\n\n    const stored = await this.config.deviceIdentityStorage.load()\n\n    if (stored) {\n      this._identity = await this._verifiedIdentity(stored)\n\n      return this._identity\n    }\n\n    const keyPair = await generateSyncSigningKeyPair()\n    const certificate = await this.config.enrollDevice({\n      configuration: this.config.configuration,\n      publicKey: keyPair.publicKey\n    })\n    const identity = await this._verifiedIdentity({certificate, privateKey: keyPair.privateKey})\n\n    await this.config.deviceIdentityStorage.save(/** @type {SyncOfflineDeviceIdentity} */ (cloneJson(identity, \"device identity\")))\n\n    this._identity = identity\n\n    return identity\n  }\n\n  /**\n   * Verifies a stored/enrolled certificate against the configured backend\n   * public key (when one is configured) and returns the identity.\n   * @param {SyncOfflineDeviceIdentity} identity - Candidate identity.\n   * @returns {Promise<SyncOfflineDeviceIdentity>} - Verified identity.\n   */\n  async _verifiedIdentity(identity) {\n    if (!identity || typeof identity !== \"object\" || Array.isArray(identity)) {\n      throw new Error(\"sync.client.offline device identity storage must provide {certificate, privateKey} or null\")\n    }\n    if (!identity.certificate || !identity.privateKey) throw new Error(\"sync.client.offline device identity requires a certificate and a privateKey\")\n\n    if (this.config.backendPublicKey) {\n      await verifyDeviceCertificate({\n        backendPublicKey: this.config.backendPublicKey,\n        certificate: identity.certificate\n      })\n    }\n\n    return identity\n  }\n\n  /**\n   * Loads app-retained grants once so a restarted device can still replay\n   * mutations that were signed under an older grant (peer-forwarded mutations\n   * keep the grant their original signer used).\n   * @returns {Promise<void>} - Resolves after retention is loaded.\n   */\n  async _loadRetainedGrants() {\n    if (this._grantsLoaded) return\n\n    this._grantsLoaded = true\n    if (!this.config.grantStorage) return\n\n    const retained = await this.config.grantStorage.load()\n\n    if (!Array.isArray(retained)) throw new Error(\"sync.client.offline grantStorage.load must resolve an array of signed offline grants\")\n\n    for (const signedGrant of retained) {\n      if (!signedGrant || typeof signedGrant !== \"object\" || !signedGrant.grant || typeof signedGrant.grant.grantId !== \"string\") continue\n\n      this._grants.set(signedGrant.grant.grantId, signedGrant)\n    }\n  }\n\n  /**\n   * Returns the active grant when it is still live, otherwise null. Expiry is\n   * checked by timestamp only: the grant's HMAC signature is backend-only and\n   * can never be verified on the device.\n   * @param {Date} [now] - Check time.\n   * @returns {import(\"./offline-grant.js\").SignedOfflineGrant | null} - Live grant or null.\n   */\n  _liveGrant(now = this._now()) {\n    if (!this._activeGrant) return null\n    if (new Date(this._activeGrant.grant.expiresAt).getTime() <= now.getTime()) return null\n\n    return this._activeGrant\n  }\n\n  /**\n   * Ensures a live grant exists, bootstrapping a new one when the current grant\n   * is missing or expired. A refreshed grant re-signs this device's pending\n   * records so the backend always sees the grant an intent is replayed under.\n   * @returns {Promise<import(\"./offline-grant.js\").SignedOfflineGrant>} - Live grant.\n   */\n  async _ensureLiveGrant() {\n    const live = this._liveGrant()\n\n    if (live) return live\n\n    const granted = await this.bootstrapGrant()\n\n    await this._resignPendingRecords(granted)\n\n    return granted\n  }\n\n  /**\n   * Requests a fresh offline grant from the built-in sync bootstrap endpoint\n   * and retains it under its grant id together with the sync manifest whose\n   * policy hashes mutations are signed against.\n   * @returns {Promise<import(\"./offline-grant.js\").SignedOfflineGrant>} - Newly issued grant.\n   */\n  async bootstrapGrant() {\n    const identity = await this._ensureIdentity()\n    const authenticationToken = await this.authenticationToken()\n    const scopes = await this.config.grantScopes({configuration: this.config.configuration})\n\n    if (!scopes || typeof scopes !== \"object\" || Array.isArray(scopes)) throw new Error(\"sync.client.offline.grantScopes must resolve a plain object of grant scopes\")\n\n    const response = await this.post(this.config.bootstrapPath, {\n      authenticationToken,\n      deviceId: identity.certificate.certificate.actorDeviceId,\n      scopes\n    })\n\n    if (!response || typeof response !== \"object\" || Array.isArray(response)) {\n      throw new Error(`Sync offline bootstrap did not return a response object (${this.config.bootstrapPath})`)\n    }\n\n    const responseRecord = /** @type {Record<string, unknown>} */ (response)\n    const signedGrant = /** @type {import(\"./offline-grant.js\").SignedOfflineGrant | undefined} */ (responseRecord.offlineGrant)\n\n    if (!signedGrant || typeof signedGrant !== \"object\" || !signedGrant.grant || typeof signedGrant.grant.grantId !== \"string\") {\n      throw new Error(`Sync offline bootstrap did not return a signed offline grant (${this.config.bootstrapPath})`)\n    }\n\n    const manifest = /** @type {Record<string, import(\"../configuration-types.js\").NormalizedFrontendModelResourceSyncConfiguration> | undefined} */ (responseRecord.syncManifest)\n\n    if (!manifest || typeof manifest !== \"object\" || Array.isArray(manifest)) {\n      throw new Error(`Sync offline bootstrap did not return a sync manifest (${this.config.bootstrapPath})`)\n    }\n\n    this._grants.set(signedGrant.grant.grantId, signedGrant)\n    this._activeGrant = signedGrant\n    this._syncManifest = manifest\n    await this._persistGrants()\n\n    return signedGrant\n  }\n\n  /**\n   * Forces a grant refresh: bootstrap a new grant and re-sign this device's\n   * pending records under it.\n   * @returns {Promise<SyncOfflineSessionSummary>} - Refreshed session summary.\n   */\n  async refreshGrant() {\n    await this._ensureIdentity()\n    await this._loadRetainedGrants()\n\n    const granted = await this.bootstrapGrant()\n\n    await this._resignPendingRecords(granted)\n\n    return this.sessionSummary()\n  }\n\n  /**\n   * Re-signs this device's still-pending records under a new grant. Safe\n   * because the replay idempotency key is\n   * `actorUserId:actorDeviceId:clientMutationId` and never carries the grant\n   * id. Records signed by another device (peer-forwarded mutations) keep their\n   * original signed envelope and original grant - they must always replay with\n   * the grant their signer used.\n   * @param {import(\"./offline-grant.js\").SignedOfflineGrant} signedGrant - Grant the records are re-signed under.\n   * @returns {Promise<void>} - Resolves after pending records are re-signed.\n   */\n  async _resignPendingRecords(signedGrant) {\n    this._requireIdentity()\n\n    for (const mutationLog of this.mutationLogs) {\n      for (const record of await mutationLog.pendingRecords()) {\n        if (!this._isOwnRecord(record)) continue\n        if (record.mutation.offlineGrantId === signedGrant.grant.grantId && record.signedMutation) continue\n\n        const signedMutation = await this.signMutation(record.mutation)\n\n        await mutationLog.updateMutation({id: record.id, mutation: signedMutation.mutation, signedMutation})\n      }\n    }\n  }\n\n  /**\n   * Checks whether a log record was signed/queued by this device's identity\n   * (or has no identity yet and can adopt it).\n   * @param {import(\"./local-mutation-log.js\").LocalMutationLogRecord} record - Durable record.\n   * @returns {boolean} - Whether the record belongs to this device.\n   */\n  _isOwnRecord(record) {\n    const identity = this._requireIdentity()\n\n    if (record.signedMutation) {\n      return record.signedMutation.mutation.actorDeviceId === identity.certificate.certificate.actorDeviceId &&\n        record.signedMutation.mutation.actorUserId === identity.certificate.certificate.actorUserId\n    }\n\n    return !record.mutation.actorDeviceId || (\n      record.mutation.actorDeviceId === identity.certificate.certificate.actorDeviceId &&\n      record.mutation.actorUserId === identity.certificate.certificate.actorUserId\n    )\n  }\n\n  /**\n   * Signs one mutation payload with the device key under the live grant,\n   * filling the actor/grant/policy-hash identity from the session.\n   * @param {Omit<import(\"./device-identity.js\").SyncMutation, \"actorDeviceId\" | \"actorUserId\" | \"offlineGrantId\" | \"policyHash\">} mutation - Mutation payload to sign (the session supplies the rotating identity fields).\n   * @returns {Promise<import(\"./device-identity.js\").SignedSyncMutation>} - Signed mutation envelope.\n   */\n  async signMutation(mutation) {\n    const identity = await this._ensureIdentity()\n    const grant = await this._grantForSigning()\n\n    return await createSignedMutation({\n      deviceCertificate: identity.certificate,\n      devicePrivateKey: identity.privateKey,\n      mutation: {\n        ...mutation,\n        actorDeviceId: identity.certificate.certificate.actorDeviceId,\n        actorUserId: identity.certificate.certificate.actorUserId,\n        offlineGrantId: grant.grant.grantId,\n        policyHash: this.policyHashFor(mutation.model)\n      }\n    })\n  }\n\n  /**\n   * Returns the grant a new mutation is signed under: the live grant when one\n   * exists, otherwise the newest retained grant (queueing stays possible while\n   * offline - the replay pass refreshes the grant and re-signs the pending\n   * records), and only bootstraps when no grant has ever been retained.\n   * @returns {Promise<import(\"./offline-grant.js\").SignedOfflineGrant>} - Grant to sign under.\n   */\n  async _grantForSigning() {\n    const live = this._liveGrant()\n\n    if (live) return live\n    if (this._activeGrant) return this._activeGrant\n\n    await this._loadRetainedGrants()\n\n    const retained = Array.from(this._grants.values()).sort((left, right) => new Date(right.grant.issuedAt).getTime() - new Date(left.grant.issuedAt).getTime())\n\n    if (retained.length > 0) {\n      this._activeGrant = retained[0]\n\n      return this._activeGrant\n    }\n\n    return await this.bootstrapGrant()\n  }\n\n  /**\n   * Returns the policy hash the live session's sync manifest carries for one model.\n   * @param {string} model - Model/resource name.\n   * @returns {string} - Policy hash.\n   */\n  policyHashFor(model) {\n    const manifest = this._syncManifest || this._activeGrant?.grant.resources\n\n    if (!manifest) throw new Error(\"Sync offline session has no sync manifest - call startOfflineSession() first\")\n\n    const entry = /** @type {Record<string, unknown> | undefined} */ (manifest[model])\n    const policyHash = entry && typeof entry === \"object\" && !Array.isArray(entry) ? /** @type {Record<string, unknown>} */ (entry).policyHash : undefined\n\n    if (typeof policyHash !== \"string\" || policyHash.length === 0) {\n      throw new Error(`Sync offline session has no policy hash for model '${model}' - is it sync-enabled on the backend?`)\n    }\n\n    return policyHash\n  }\n\n  /**\n   * Drains the durable mutation logs through the built-in signed replay\n   * endpoint. Pending records are batched, each signed mutation travels with\n   * the signed grant it was signed under, and per-mutation results are mapped\n   * back onto the log records as synced/conflict/rejected.\n   * @param {object} [options] - Replay options.\n   * @param {number} [options.batchSize] - Max mutations per request.\n   * @param {AbortSignal} [options.signal] - Lifecycle cancellation signal.\n   * @returns {Promise<SyncOfflineReplayResult>} - Mapped replay result.\n   */\n  async replayPending(options = {}) {\n    if (this._replayPromise) return await this._replayPromise\n\n    this._replayPromise = this._replayPass(options).finally(() => {\n      this._replayPromise = null\n    })\n\n    return await this._replayPromise\n  }\n\n  /**\n   * Runs one signed replay pass.\n   * @param {object} options - Pass options.\n   * @param {number} [options.batchSize] - Max mutations per request.\n   * @param {AbortSignal} [options.signal] - Lifecycle cancellation signal.\n   * @returns {Promise<SyncOfflineReplayResult>} - Mapped replay result.\n   */\n  async _replayPass({batchSize, signal} = {}) {\n    throwIfAborted(signal)\n\n    if (!this.isActive()) await this.start()\n\n    const maxBatchSize = typeof batchSize === \"number\" && batchSize >= 1 ? Math.floor(batchSize) : 100\n    /** @type {SyncOfflineReplayResult[\"results\"]} */\n    const results = []\n    let syncedCount = 0\n    let conflictCount = 0\n    let rejectedCount = 0\n\n    for (let pass = 0; pass < 10; pass += 1) {\n      throwIfAborted(signal)\n      await this._ensureLiveGrant()\n\n      /** @type {Array<{mutationLog: import(\"./local-mutation-log.js\").default, record: import(\"./local-mutation-log.js\").LocalMutationLogRecord}>} */\n      const entries = []\n\n      for (const mutationLog of this.mutationLogs) {\n        for (const record of await mutationLog.pendingRecords()) {\n          if (!record.signedMutation) continue\n          // A record can only replay with the grant it was signed under. Records\n          // whose grant the session does not retain (e.g. peer imports without\n          // their signer's grant) stay pending instead of blocking the batch.\n          if (!this._grants.has(record.mutation.offlineGrantId)) continue\n\n          entries.push({mutationLog, record})\n        }\n      }\n\n      if (entries.length === 0) break\n\n      const batch = entries.slice(0, maxBatchSize)\n      const authenticationToken = await this.authenticationToken()\n      const mutations = batch.map((entry) => this._replayMutation(entry.record))\n      const response = await this.post(this.config.replayPath, {authenticationToken, mutations}, {signal})\n\n      throwIfAborted(signal)\n\n      const resultsByIdempotencyKey = this._replayResultsById(response)\n\n      for (const {mutationLog, record} of batch) {\n        throwIfAborted(signal)\n        const idempotencyKey = mutationIdempotencyKey(/** @type {import(\"./device-identity.js\").SignedSyncMutation} */ (record.signedMutation))\n        const result = resultsByIdempotencyKey.get(idempotencyKey)\n\n        if (!result) throw new Error(`Signed sync replay response is missing a result for mutation ${record.mutation.clientMutationId}`)\n\n        const status = replayResultLocalStatus(/** @type {Record<string, import(\"./conflict-strategy.js\").SyncJsonValue>} */ (result))\n        const serverResult = cloneJson(result, \"sync replay result\")\n        const updated = await mutationLog.updateStatus({\n          id: record.id,\n          status,\n          syncResult: /** @type {Record<string, import(\"../frontend-models/base.js\").FrontendModelTransportValue>} */ (serverResult)\n        })\n\n        results.push({\n          clientMutationId: record.mutation.clientMutationId,\n          idempotencyKey,\n          mutation: /** @type {import(\"./device-identity.js\").SyncMutation} */ (cloneJson(record.mutation, \"mutation\")),\n          recordId: updated.id,\n          serverResult,\n          status: updated.status\n        })\n\n        if (updated.status === \"synced\") syncedCount += 1\n        if (updated.status === \"conflict\") conflictCount += 1\n        if (updated.status === \"rejected\") rejectedCount += 1\n      }\n    }\n\n    let pendingCount = 0\n\n    for (const mutationLog of this.mutationLogs) {\n      pendingCount += (await mutationLog.pendingRecords()).length\n    }\n\n    return {conflictCount, pendingCount, rejectedCount, results, syncedCount}\n  }\n\n  /**\n   * Builds one signed replay mutation: the signed envelope plus the signed\n   * grant the mutation was signed under. Fails closed when the session does\n   * not retain that grant.\n   * @param {import(\"./local-mutation-log.js\").LocalMutationLogRecord} record - Durable record.\n   * @returns {Record<string, ReturnType<typeof JSON.parse>>} - Replay mutation payload.\n   */\n  _replayMutation(record) {\n    const signedMutation = /** @type {import(\"./device-identity.js\").SignedSyncMutation} */ (record.signedMutation)\n    const signedGrant = this._grants.get(signedMutation.mutation.offlineGrantId)\n\n    if (!signedGrant) throw new Error(`Sync offline session has no retained grant '${signedMutation.mutation.offlineGrantId}' for mutation ${signedMutation.mutation.clientMutationId}`)\n\n    return {...cloneJson(signedMutation, \"signed mutation\"), signedOfflineGrant: cloneJson(signedGrant, \"signed offline grant\")}\n  }\n\n  /**\n   * Normalizes a signed replay response into results keyed by idempotency key.\n   * @param {ReturnType<typeof JSON.parse>} response - Raw replay response.\n   * @returns {Map<string, Record<string, ReturnType<typeof JSON.parse>>>} - Results by idempotency key.\n   */\n  _replayResultsById(response) {\n    if (!response || typeof response !== \"object\" || Array.isArray(response)) throw new Error(\"Signed sync replay response must be an object\")\n\n    const responseRecord = /** @type {Record<string, unknown>} */ (response)\n\n    if (responseRecord.status === \"error\") throw new Error(typeof responseRecord.errorMessage === \"string\" ? responseRecord.errorMessage : \"Signed sync replay failed\")\n    if (!Array.isArray(responseRecord.results)) throw new Error(\"Signed sync replay response is missing results\")\n\n    /** @type {Map<string, Record<string, ReturnType<typeof JSON.parse>>>} */\n    const byKey = new Map()\n\n    for (const result of responseRecord.results) {\n      if (!result || typeof result !== \"object\" || Array.isArray(result)) continue\n\n      const resultRecord = /** @type {Record<string, unknown>} */ (result)\n\n      if (typeof resultRecord.idempotencyKey !== \"string\") continue\n\n      byKey.set(resultRecord.idempotencyKey, /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (resultRecord))\n    }\n\n    return byKey\n  }\n\n  /**\n   * Exports the durable non-terminal mutations of every session log as one\n   * signed peer bundle.\n   * @param {object} [options] - Export options.\n   * @param {import(\"./local-mutation-log.js\").LocalMutationStatus[]} [options.statuses] - Statuses to export.\n   * @param {() => Date} [options.now] - Export clock.\n   * @returns {Promise<import(\"./peer-mutation-bundle.js\").PeerMutationBundle>} - Signed peer bundle.\n   */\n  async exportBundle(options = {}) {\n    const identity = await this._ensureIdentity()\n    /** @type {import(\"./peer-mutation-bundle.js\").PeerMutationBundle[\"mutations\"]} */\n    const mutations = []\n    let bundle = null\n\n    for (const mutationLog of this.mutationLogs) {\n      const logBundle = await exportPeerMutationBundle({\n        deviceCertificate: identity.certificate,\n        devicePrivateKey: identity.privateKey,\n        mutationLog,\n        ...options\n      })\n\n      if (!bundle) bundle = logBundle\n      else mutations.push(...logBundle.mutations)\n    }\n\n    if (!bundle) {\n      throw new Error(\"Sync offline session export produced no bundle\")\n    }\n\n    bundle.mutations = mutations.length > 0 ? [...bundle.mutations, ...mutations].sort((left, right) => (left.localSequence || 0) - (right.localSequence || 0)) : bundle.mutations\n\n    return bundle\n  }\n\n  /**\n   * Imports a peer bundle: every entry is verified against the configured\n   * backend public key before it is appended to a local mutation log. Entries\n   * already present by idempotency key are skipped as duplicates.\n   * @param {object} args - Import args.\n   * @param {import(\"./peer-mutation-bundle.js\").PeerMutationBundle} args.bundle - Peer bundle to import.\n   * @param {Array<import(\"./offline-grant.js\").SignedOfflineGrant>} [args.signedOfflineGrants] - Grants the peer signed its mutations under. They are retained so imported mutations replay with the grant their signer used.\n   * @param {import(\"./local-mutation-log.js\").default} [args.mutationLog] - Target log. Defaults to the first session log.\n   * @returns {Promise<import(\"./peer-mutation-bundle.js\").PeerMutationBundleImportResult>} - Import result.\n   */\n  async importBundle({bundle, mutationLog, signedOfflineGrants = []}) {\n    if (!this.config.backendPublicKey) throw new Error(\"sync.client.offline.backendPublicKey is required to import a peer mutation bundle\")\n    if (!Array.isArray(signedOfflineGrants)) throw new Error(\"sync offline import signedOfflineGrants must be an array of signed offline grants\")\n\n    for (const signedGrant of signedOfflineGrants) {\n      if (!signedGrant || typeof signedGrant !== \"object\" || !signedGrant.grant || typeof signedGrant.grant.grantId !== \"string\") {\n        throw new Error(\"sync offline import requires signed offline grant envelopes with grant payloads\")\n      }\n\n      this._grants.set(signedGrant.grant.grantId, signedGrant)\n    }\n\n    if (signedOfflineGrants.length > 0) await this._persistGrants()\n\n    return await importPeerMutationBundle({\n      backendPublicKey: this.config.backendPublicKey,\n      bundle,\n      mutationLog: mutationLog || this.mutationLogs[0]\n    })\n  }\n\n  /**\n   * Persists retained grants through the optional app-owned grant storage.\n   * @returns {Promise<void>} - Resolves after retention is persisted.\n   */\n  async _persistGrants() {\n    if (!this.config.grantStorage) return\n\n    await this.config.grantStorage.save(Array.from(this._grants.values()))\n  }\n\n  /**\n   * Returns the session clock.\n   * @returns {Date} - Current time.\n   */\n  _now() {\n    return this.config.now()\n  }\n\n  /**\n   * Returns the device identity or fails closed.\n   * @returns {SyncOfflineDeviceIdentity} - Device identity.\n   */\n  _requireIdentity() {\n    if (!this._identity) throw new Error(\"Sync offline session has no device identity - call startOfflineSession() first\")\n\n    return this._identity\n  }\n\n  /**\n   * Returns the live grant or fails closed.\n   * @returns {import(\"./offline-grant.js\").SignedOfflineGrant} - Live grant.\n   */\n  _requireLiveGrant() {\n    const grant = this._liveGrant()\n\n    if (!grant) throw new Error(\"Sync offline session has no live offline grant - call startOfflineSession() or refreshOfflineGrant()\")\n\n    return grant\n  }\n}\n\n/**\n * Clones a JSON object.\n * @param {unknown} value - Value.\n * @param {string} label - Diagnostic label.\n * @returns {Record<string, ReturnType<typeof JSON.parse>>} - Cloned object.\n */\nfunction cloneJson(value, label) {\n  if (!value || typeof value !== \"object\" || Array.isArray(value)) throw new Error(`Expected sync offline ${label} object`)\n\n  return /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (JSON.parse(JSON.stringify(value)))\n}\n\n/**\n * Throws the exact abort reason at lifecycle boundaries.\n * @param {AbortSignal | undefined} signal - Lifecycle signal.\n * @returns {void} - No return value.\n */\nfunction throwIfAborted(signal) {\n  if (!signal?.aborted) return\n\n  throw signal.reason instanceof Error ? signal.reason : new Error(\"Sync offline replay aborted\")\n}\n"]}