document-drive 6.0.0-dev.105 → 6.0.0-dev.106

package/dist/src/server/base-server.js

@@ -1,2000 +0,0 @@
-import { isActionJob, isDocumentJob, isOperationJob, } from "document-drive/queue/utils";
-import { ReadModeServer } from "document-drive/read-mode/server";
-import { DefaultDrivesManager } from "document-drive/utils/default-drives-manager";
-import { requestPublicDriveWithTokenFromReactor } from "document-drive/utils/graphql";
-import { childLogger } from "document-drive/utils/logger";
-import { isDocumentDrive } from "document-drive/utils/misc";
-import { runAsap, runAsapAsync } from "document-drive/utils/run-asap";
-import { attachBranch, createPresignedHeader, defaultBaseState, deriveOperationId, diffOperations, garbageCollect, garbageCollectDocumentOperations, generateId, groupOperationsByScope, hashDocumentStateForScope, merge, precedes, removeExistingOperations, replayDocument, reshuffleByTimestamp, skipHeaderOperations, sortOperations, validateHeader, } from "document-model/core";
-import { ClientError } from "graphql-request";
-import { driveCreateDocument, driveCreateState, removeListener, removeTrigger, setSharingType, } from "../drive-document-model/index.js";
-import { ConflictOperationError, DocumentAlreadyExistsError, OperationError, } from "./error.js";
-import { DefaultListenerManagerOptions } from "./listener/constants.js";
-import { PullResponderTransmitter } from "./transmitter/pull-responder.js";
-import { SwitchboardPushTransmitter } from "./transmitter/switchboard-push.js";
-import { filterOperationsByRevision, isAtRevision, resolveCreateDocumentInput, } from "./utils.js";
-export class BaseDocumentDriveServer {
-    logger = childLogger(["BaseDocumentDriveServer"]);
-    // external dependencies
-    documentModelModules;
-    legacyStorage;
-    documentStorage;
-    cache;
-    queueManager;
-    eventEmitter;
-    options;
-    listenerManager;
-    synchronizationManager;
-    generateJwtHandler;
-    // internal dependencies
-    defaultDrivesManager;
-    defaultDrivesManagerDelegate = {
-        detachDrive: this.detachDrive.bind(this),
-        emit: (...args) => this.eventEmitter.emit("defaultRemoteDrive", ...args),
-    };
-    queueDelegate = {
-        exists: (documentId) => this.documentStorage.exists(documentId),
-        processOperationJob: async ({ documentId, operations, options, }) => {
-            const document = await this.getDocument(documentId);
-            return isDocumentDrive(document)
-                ? this.processDriveOperations(documentId, operations, options)
-                : this.processOperations(documentId, operations, options);
-        },
-        processActionJob: async ({ documentId, actions, options }) => {
-            const document = await this.getDocument(documentId);
-            return isDocumentDrive(document)
-                ? this.processDriveActions(documentId, actions, options)
-                : this.processActions(documentId, actions, options);
-        },
-        processDocumentJob: async ({ documentId, documentType, header: inputHeader, initialState, options, }) => {
-            const documentModelModule = this.getDocumentModelModule(documentType);
-            const document = documentModelModule.utils.createDocument(initialState);
-            // TODO: header must be included
-            const header = createPresignedHeader(documentId, documentType);
-            document.header.id = documentId;
-            document.header.sig = header.sig;
-            document.header.documentType = documentType;
-            if (inputHeader) {
-                document.header.meta = inputHeader.meta;
-            }
-            try {
-                const createdDocument = await this.createDocument({ document }, options?.source ?? { type: "local" }, document.header.meta);
-                return {
-                    status: "SUCCESS",
-                    operations: [],
-                    document: createdDocument,
-                    signals: [],
-                };
-            }
-            catch (error) {
-                const cause = error instanceof Error ? error : new Error(JSON.stringify(error));
-                return {
-                    status: "ERROR",
-                    error: new OperationError("ERROR", undefined, `Error creating document: ${cause.message}`, cause),
-                    operations: [],
-                    document: undefined,
-                    signals: [],
-                };
-            }
-        },
-        processJob: async (job) => {
-            if (isOperationJob(job)) {
-                return this.queueDelegate.processOperationJob(job);
-            }
-            else if (isActionJob(job)) {
-                return this.queueDelegate.processActionJob(job);
-            }
-            else if (isDocumentJob(job)) {
-                return this.queueDelegate.processDocumentJob(job);
-            }
-            else {
-                throw new Error("Unknown job type", job);
-            }
-        },
-    };
-    // internal state
-    triggerMap = new Map();
-    initializePromise;
-    enableDualActionCreate;
-    constructor(documentModelModules, storage, documentStorage, cache, queueManager, eventEmitter, synchronizationManager, listenerManager, options) {
-        this.documentModelModules = documentModelModules;
-        this.legacyStorage = storage;
-        this.documentStorage = documentStorage;
-        this.cache = cache;
-        this.queueManager = queueManager;
-        this.eventEmitter = eventEmitter;
-        this.synchronizationManager = synchronizationManager;
-        this.listenerManager = listenerManager;
-        this.options = {
-            ...options,
-            defaultDrives: {
-                ...options?.defaultDrives,
-            },
-            listenerManager: {
-                ...DefaultListenerManagerOptions,
-                ...options?.listenerManager,
-            },
-            jwtHandler: options?.jwtHandler === undefined
-                ? () => Promise.resolve("")
-                : options.jwtHandler,
-            taskQueueMethod: options?.taskQueueMethod === undefined
-                ? runAsap
-                : options.taskQueueMethod,
-            featureFlags: {
-                ...options?.featureFlags,
-            },
-        };
-        this.enableDualActionCreate =
-            options?.featureFlags?.enableDualActionCreate ?? false;
-        if (this.enableDualActionCreate) {
-            this.logger.warn("Dual action create is enabled.");
-        }
-        // todo: move to external dependencies
-        this.defaultDrivesManager = new DefaultDrivesManager(this, this.defaultDrivesManagerDelegate, options);
-        this.initializePromise = this._initialize();
-    }
-    // workaround for testing the ephemeral listeners -- we don't have DI in place yet
-    // todo: remove this once we have DI
-    get listeners() {
-        return this.listenerManager;
-    }
-    initialize() {
-        return this.initializePromise;
-    }
-    async _initialize() {
-        await this.listenerManager.initialize(this.handleListenerError.bind(this));
-        await this.queueManager.init(this.queueDelegate, (error) => {
-            this.logger.error("Error initializing queue manager: @error", error);
-            // errors.push(error);
-        });
-        try {
-            await this.defaultDrivesManager.removeOldremoteDrives();
-        }
-        catch (error) {
-            this.logger.error("@error", error);
-        }
-        const errors = [];
-        const drives = await this.getDrives();
-        for (const drive of drives) {
-            await this._initializeDrive(drive).catch((error) => {
-                this.logger.error("Error initializing drive @drive: @error", drive, error);
-                errors.push(error);
-            });
-        }
-        if (this.options.defaultDrives.loadOnInit !== false) {
-            await this.defaultDrivesManager.initializeDefaultRemoteDrives();
-        }
-        return errors.length === 0 ? null : errors;
-    }
-    setDocumentModelModules(modules) {
-        this.documentModelModules = [...modules];
-        this.synchronizationManager.setDocumentModelModules([...modules]);
-        this.eventEmitter.emit("documentModelModules", [...modules]);
-    }
-    initializeDefaultRemoteDrives() {
-        return this.defaultDrivesManager.initializeDefaultRemoteDrives();
-    }
-    getDefaultRemoteDrives() {
-        return this.defaultDrivesManager.getDefaultRemoteDrives();
-    }
-    setDefaultDriveAccessLevel(url, level) {
-        return this.defaultDrivesManager.setDefaultDriveAccessLevel(url, level);
-    }
-    setAllDefaultDrivesAccessLevel(level) {
-        return this.defaultDrivesManager.setAllDefaultDrivesAccessLevel(level);
-    }
-    getOperationSource(source) {
-        return source.type === "local" ? "push" : "pull";
-    }
-    handleListenerError(error, driveId, listener) {
-        this.logger.error("Listener @listenerId error: @error", listener.listener.label ?? listener.listener.listenerId, error);
-        const status = error instanceof OperationError ? error.status : "ERROR";
-        this.synchronizationManager.updateSyncStatus(driveId, { push: status }, error);
-    }
-    shouldSyncRemoteDrive(drive) {
-        return (drive.state.local.availableOffline &&
-            drive.state.local.triggers.length > 0);
-    }
-    async startSyncRemoteDrive(driveId) {
-        let driveTriggers = this.triggerMap.get(driveId);
-        const syncUnits = await this.synchronizationManager.getSynchronizationUnitsIds(driveId);
-        const drive = await this.getDrive(driveId);
-        for (const trigger of drive.state.local.triggers) {
-            if (driveTriggers?.get(trigger.id)) {
-                continue;
-            }
-            if (!driveTriggers) {
-                driveTriggers = new Map();
-            }
-            this.synchronizationManager.updateSyncStatus(driveId, {
-                pull: "SYNCING",
-            });
-            for (const syncUnit of syncUnits) {
-                this.synchronizationManager.updateSyncStatus(syncUnit, {
-                    pull: "SYNCING",
-                });
-            }
-            if (PullResponderTransmitter.isPullResponderTrigger(trigger)) {
-                let firstPull = true;
-                const cancelPullLoop = PullResponderTransmitter.setupPull(driveId, trigger, this.saveStrand.bind(this), (error) => {
-                    const statusError = error instanceof OperationError ? error.status : "ERROR";
-                    this.synchronizationManager.updateSyncStatus(driveId, { pull: statusError }, error);
-                    if (error instanceof ClientError) {
-                        this.eventEmitter.emit("clientStrandsError", driveId, trigger, error.response.status, error.message);
-                    }
-                }, async (revisions) => {
-                    const errorRevisions = revisions.filter((r) => r.status !== "SUCCESS");
-                    if (errorRevisions.length < 1) {
-                        this.synchronizationManager.updateSyncStatus(driveId, {
-                            pull: "SUCCESS",
-                        });
-                    }
-                    for (const revision of revisions) {
-                        const { documentId, scope, branch, status, error } = revision;
-                        this.synchronizationManager.updateSyncStatus({ documentId, scope, branch }, { pull: status }, error);
-                    }
-                    // if it is the first pull and returns empty
-                    // then updates drive documents to "SUCCESS" and
-                    // updates corresponding push transmitter
-                    if (firstPull) {
-                        firstPull = false;
-                        const syncUnitsIds = await this.synchronizationManager.getSynchronizationUnitsIds(driveId);
-                        const unchangedSyncUnits = syncUnitsIds.filter((syncUnit) => {
-                            return !revisions.find((revision) => {
-                                return (revision.documentId === syncUnit.documentId &&
-                                    revision.scope === syncUnit.scope &&
-                                    revision.branch === syncUnit.branch);
-                            });
-                        });
-                        unchangedSyncUnits.forEach((syncUnit) => {
-                            this.synchronizationManager.updateSyncStatus(syncUnit, {
-                                pull: "SUCCESS",
-                            });
-                        });
-                        const pushListener = drive.state.local.listeners.find((listener) => trigger.data.url === listener.callInfo?.data);
-                        if (pushListener) {
-                            for (const revision of revisions) {
-                                const { documentId, scope, branch } = revision;
-                                this.listenerManager
-                                    .updateListenerRevision(pushListener.listenerId, driveId, { documentId, scope, branch }, revision.revision)
-                                    .catch((e) => this.logger.error("@error", e));
-                            }
-                        }
-                    }
-                }, undefined, this.listeners);
-                driveTriggers.set(trigger.id, cancelPullLoop);
-                this.triggerMap.set(driveId, driveTriggers);
-            }
-        }
-    }
-    async stopSyncRemoteDrive(driveId) {
-        const triggers = this.triggerMap.get(driveId);
-        triggers?.forEach((cancel) => cancel());
-        this.synchronizationManager.updateSyncStatus(driveId, null);
-        const syncUnits = await this.synchronizationManager.getSynchronizationUnitsIds(driveId);
-        for (const syncUnit of syncUnits) {
-            this.synchronizationManager.updateSyncStatus(syncUnit, null);
-        }
-        return this.triggerMap.delete(driveId);
-    }
-    async _initializeDrive(driveId) {
-        const drive = await this.getDrive(driveId);
-        this.logger.verbose('[SYNC DEBUG] Initializing drive @driveId with slug "@slug"', driveId, drive.header.slug);
-        await this.synchronizationManager.initializeDriveSyncStatus(driveId, drive);
-        if (this.shouldSyncRemoteDrive(drive)) {
-            this.logger.verbose("[SYNC DEBUG] Starting sync for remote drive @driveId", driveId);
-            await this.startSyncRemoteDrive(driveId);
-        }
-        // add switchboard push listeners
-        this.logger.verbose("[SYNC DEBUG] Processing @count listeners for drive @driveId", drive.state.local.listeners.length, driveId);
-        for (const zodListener of drive.state.local.listeners) {
-            if (zodListener.callInfo?.transmitterType === "SwitchboardPush") {
-                this.logger.verbose("[SYNC DEBUG] Setting up SwitchboardPush listener @listenerId for drive @driveId", zodListener.listenerId, driveId);
-                const transmitter = new SwitchboardPushTransmitter(zodListener.callInfo.data ?? "", this.listeners);
-                this.logger.verbose("[SYNC DEBUG] Created SwitchboardPush transmitter with URL: @url", zodListener.callInfo.data || "none");
-                await this.listenerManager
-                    .setListener(driveId, {
-                    block: zodListener.block,
-                    driveId: drive.header.id,
-                    filter: {
-                        branch: zodListener.filter.branch ?? [],
-                        documentId: zodListener.filter.documentId ?? [],
-                        documentType: zodListener.filter.documentType ?? [],
-                        scope: zodListener.filter.scope ?? [],
-                    },
-                    listenerId: zodListener.listenerId,
-                    callInfo: zodListener.callInfo,
-                    system: zodListener.system,
-                    label: zodListener.label ?? "",
-                    transmitter,
-                })
-                    .then(() => {
-                    this.logger.verbose("[SYNC DEBUG] Successfully set up listener @listenerId for drive @driveId", zodListener.listenerId, driveId);
-                });
-            }
-            else if (zodListener.callInfo?.transmitterType === "PullResponder") {
-                this.logger.verbose("[SYNC DEBUG] Setting up PullResponder listener @listenerId for drive @driveId", zodListener.listenerId, driveId);
-                const pullResponderListener = {
-                    driveId,
-                    listenerId: zodListener.listenerId,
-                    block: false,
-                    filter: zodListener.filter,
-                    system: false,
-                    label: `PullResponder #${zodListener.listenerId}`,
-                    callInfo: {
-                        data: "",
-                        name: "PullResponder",
-                        transmitterType: "PullResponder",
-                    },
-                };
-                const pullResponder = new PullResponderTransmitter(pullResponderListener, this.listenerManager);
-                pullResponderListener.transmitter = pullResponder;
-                await this.listenerManager.setListener(driveId, pullResponderListener);
-            }
-            else {
-                this.logger.error("Skipping listener @listenerId with unsupported type @transmitterType", zodListener.listenerId, zodListener.callInfo?.transmitterType || "unknown");
-            }
-        }
-    }
-    getDocumentModelModule(documentType) {
-        const documentModelModule = this.documentModelModules.find((module) => module.documentModel.global.id === documentType);
-        if (!documentModelModule) {
-            throw new Error(`Document type ${documentType} not supported`);
-        }
-        return documentModelModule;
-    }
-    getDocumentModelModules() {
-        return [...this.documentModelModules];
-    }
-    addDocument(documentOrType, meta) {
-        const input = typeof documentOrType === "string"
-            ? { documentType: documentOrType }
-            : { document: documentOrType };
-        return this.createDocument(input, { type: "local" }, meta);
-    }
-    async addDrive(input, preferredEditor) {
-        // Create document with custom global and local state
-        const { global } = driveCreateState();
-        const document = driveCreateDocument({
-            global: {
-                ...global,
-                name: input.global.name ?? global.name,
-                icon: input.global.icon ?? global.icon,
-            },
-            local: {
-                availableOffline: input.local?.availableOffline ?? false,
-                sharingType: input.local?.sharingType ?? "public",
-                listeners: input.local?.listeners ?? [],
-                triggers: input.local?.triggers ?? [],
-            },
-        });
-        if (input.id && input.id.length > 0) {
-            document.header.id = input.id;
-        }
-        if (input.slug && input.slug.length > 0) {
-            document.header.slug = input.slug;
-        }
-        if (input.global.name) {
-            document.header.name = input.global.name;
-        }
-        const editorToUse = input.preferredEditor || preferredEditor;
-        if (editorToUse) {
-            document.header.meta = {
-                preferredEditor: editorToUse,
-            };
-        }
-        await this.documentStorage.create(document);
-        if (input.slug && input.slug.length > 0) {
-            await this.cache.deleteDriveBySlug(input.slug);
-        }
-        await this._initializeDrive(document.header.id);
-        this.eventEmitter.emit("driveAdded", document);
-        return document;
-    }
-    async addRemoteDrive(url, options) {
-        const token = await this.generateJwtHandler?.(url);
-        const headers = token
-            ? { Authorization: `Bearer ${token}` }
-            : {};
-        const { id, name, slug, icon, meta } = options.expectedDriveInfo ||
-            (await requestPublicDriveWithTokenFromReactor(url, this));
-        const { pullFilter, pullInterval, availableOffline, sharingType, listeners, triggers, } = options;
-        const pullTrigger = await PullResponderTransmitter.createPullResponderTrigger(id, url, {
-            pullFilter,
-            pullInterval,
-        }, this.listeners);
-        return await this.addDrive({
-            id,
-            slug,
-            global: {
-                name,
-                icon,
-            },
-            local: {
-                triggers: [...triggers, pullTrigger],
-                listeners: listeners,
-                availableOffline,
-                sharingType,
-            },
-        }, meta?.preferredEditor);
-    }
-    async deleteDrive(driveId) {
-        const result = await Promise.allSettled([
-            this.stopSyncRemoteDrive(driveId),
-            this.listenerManager.removeDrive(driveId),
-            this.cache.deleteDrive(driveId),
-            this.documentStorage.delete(driveId),
-        ]);
-        this.eventEmitter.emit("driveDeleted", driveId);
-        result.forEach((r) => {
-            if (r.status === "rejected") {
-                throw r.reason;
-            }
-        });
-    }
-    // TODO: paginate
-    async getDrives() {
-        const drives = [];
-        let cursor;
-        do {
-            const { documents, nextCursor } = await this.documentStorage.findByType("powerhouse/document-drive", 100, cursor);
-            drives.push(...documents);
-            cursor = nextCursor;
-        } while (cursor);
-        return drives;
-    }
-    // TODO: paginate, move into IReactorClient eventually
-    async getDrivesSlugs() {
-        const drives = await this.getDrives();
-        return this.documentStorage.resolveSlugs(drives);
-    }
-    async getDrive(driveId, options) {
-        let document;
-        try {
-            const cachedDocument = await this.cache.getDrive(driveId); // TODO support GetDocumentOptions
-            if (cachedDocument && isDocumentDrive(cachedDocument)) {
-                document = cachedDocument;
-                if (isAtRevision(document, options?.revisions)) {
-                    return document;
-                }
-            }
-        }
-        catch (e) {
-            this.logger.error("Error getting drive from cache: @error", e);
-        }
-        const driveStorage = document ?? (await this.documentStorage.get(driveId));
-        const result = this._buildDocument(driveStorage, options);
-        if (!isDocumentDrive(result)) {
-            throw new Error(`Document with id ${driveId} is not a Document Drive`);
-        }
-        else {
-            if (!options?.revisions) {
-                this.cache
-                    .setDocument(driveId, result)
-                    .catch((e) => this.logger.error("@error", e));
-                this.cache
-                    .setDrive(driveId, result)
-                    .catch((e) => this.logger.error("@error", e));
-            }
-            return result;
-        }
-    }
-    async getDriveBySlug(slug, options) {
-        try {
-            const drive = await this.cache.getDriveBySlug(slug);
-            if (drive) {
-                return drive;
-            }
-        }
-        catch (e) {
-            this.logger.error("Error getting drive from cache: @error", e);
-        }
-        const driveStorage = await this.documentStorage.getBySlug(slug);
-        const document = this._buildDocument(driveStorage, options);
-        if (!isDocumentDrive(document)) {
-            throw new Error(`Document with slug ${slug} is not a Document Drive`);
-        }
-        else {
-            this.cache
-                .setDriveBySlug(slug, document)
-                .catch((e) => this.logger.error("@error", e));
-            return document;
-        }
-    }
-    async getDriveIdBySlug(slug) {
-        try {
-            const drive = await this.cache.getDriveBySlug(slug);
-            if (drive) {
-                return drive.header.id;
-            }
-        }
-        catch (e) {
-            this.logger.error("Error getting drive from cache: @error", e);
-        }
-        const driveStorage = await this.documentStorage.getBySlug(slug);
-        return driveStorage.header.id;
-    }
-    getDocument(driveId, documentId, options) {
-        const id = typeof documentId === "string" ? documentId : driveId;
-        const resolvedOptions = typeof documentId === "object" ? documentId : options;
-        return this._getDocument(id, resolvedOptions);
-    }
-    async _getDocument(documentId, options) {
-        let cachedDocument;
-        try {
-            cachedDocument = await this.cache.getDocument(documentId); // TODO support GetDocumentOptions
-            if (cachedDocument && isAtRevision(cachedDocument, options?.revisions)) {
-                return cachedDocument;
-            }
-        }
-        catch (e) {
-            this.logger.error("Error getting document from cache: @error", e);
-        }
-        const documentStorage = cachedDocument ?? (await this.documentStorage.get(documentId));
-        const document = this._buildDocument(documentStorage, options);
-        if (!options?.revisions) {
-            this.cache
-                .setDocument(documentId, document)
-                .catch((e) => this.logger.error("@error", e));
-        }
-        return document;
-    }
-    getDocuments(driveId) {
-        return this.documentStorage.getChildren(driveId);
-    }
-    async addChild(parentId, documentId) {
-        // TODO: check if document exists? Should that be a concern here?
-        try {
-            await this.documentStorage.addChild(parentId, documentId);
-            // TODO: update listener manager?
-        }
-        catch (e) {
-            this.logger.error("Error adding child document: @error", e);
-            throw e;
-        }
-    }
-    async removeChild(parentId, documentId) {
-        // TODO: check if document exists? Should that be a concern here?
-        // cleanup child sync units state from the parent listeners
-        try {
-            const childSynUnits = await this.synchronizationManager.getSynchronizationUnitsIds(parentId, [
-                documentId,
-            ]);
-            await this.listenerManager.removeSyncUnits(parentId, childSynUnits);
-        }
-        catch (e) {
-            this.logger.warn("Error removing sync units of child: @error", e);
-        }
-        // remove child relationship from storage
-        try {
-            await this.documentStorage.removeChild(parentId, documentId);
-        }
-        catch (e) {
-            this.logger.error("Error adding child document: @error", e);
-            throw e;
-        }
-    }
-    async createDocument(input, source, meta) {
-        if (this.enableDualActionCreate) {
-            return this.createDocumentDualAction(input, source, meta);
-        }
-        else {
-            return this.createDocumentLegacy(input, source, meta);
-        }
-    }
-    async createDocumentLegacy(input, source, meta) {
-        const { documentType, document: inputDocument } = resolveCreateDocumentInput(input);
-        // if a document was provided then checks if it's valid
-        let state = undefined;
-        if (inputDocument) {
-            if ("documentType" in input &&
-                documentType !== inputDocument.header.documentType) {
-                throw new Error(`Provided document is not ${documentType}`);
-            }
-            const doc = this._buildDocument(inputDocument);
-            state = doc.state;
-        }
-        // if no document was provided then create a new one
-        const document = inputDocument ??
-            this.getDocumentModelModule(documentType).utils.createDocument(state);
-        // get the header
-        let header;
-        // handle the legacy case where an id is provided
-        if ("id" in input && input.id) {
-            if (inputDocument) {
-                header = document.header;
-                document.header.id = input.id;
-                this.logger.warn("Assigning an id to a document is deprecated. Use the header field instead.");
-            }
-            else {
-                this.logger.warn("Creating a document with an id is deprecated. Use the header field instead.");
-                header = createPresignedHeader(input.id, documentType);
-            }
-        }
-        else if ("header" in input) {
-            // validate the header passed in
-            await validateHeader(input.header);
-            header = input.header;
-        }
-        else if (inputDocument?.header) {
-            if (!inputDocument.header.id) {
-                throw new Error("Document header id is required");
-            }
-            if (!inputDocument.header.documentType) {
-                throw new Error("Document header documentType is required");
-            }
-            if (!inputDocument.header.createdAtUtcIso) {
-                throw new Error("Document header createdAtUtcIso is required");
-            }
-            if (!inputDocument.header.sig.nonce) {
-                this.logger.warn("Creating a document with an unsigned id is deprecated. Use createSignedHeaderForSigner.");
-                // throw new Error("Document header sig nonce is required"); TODO: uncomment when ready to enforce signed documents
-            }
-            else {
-                await validateHeader(inputDocument.header);
-            }
-            header = inputDocument.header;
-        }
-        else {
-            // otherwise, generate a header
-            header = createPresignedHeader(undefined, documentType);
-        }
-        if (meta) {
-            header.meta = { ...header.meta, ...meta };
-        }
-        // stores document information
-        const documentStorage = {
-            header,
-            operations: { global: [], local: [] },
-            initialState: document.initialState,
-            clipboard: [],
-            state: state ?? document.state,
-        };
-        await this.documentStorage.create(documentStorage);
-        // TODO set initial state for document sync units
-        // if (source.type === "trigger") {
-        //   for (const scope of Object.keys(document.state)) {
-        //     this.synchronizationManager.updateSyncStatus(
-        //       {
-        //         documentId: document.id,
-        //         scope,
-        //         branch: "main" /* TODO handle branches */,
-        //       },
-        //       {
-        //         pull: "INITIAL_SYNC",
-        //         push: this.listenerManager.driveHasListeners(driveId)
-        //           ? "SUCCESS"
-        //           : undefined,
-        //       },
-        //     );
-        //   }
-        // }
-        // if the document contains operations then
-        // stores the operations in the storage
-        const operations = Object.values(document.operations).flat();
-        if (operations.length) {
-            if (isDocumentDrive(document)) {
-                await this.legacyStorage.addDriveOperations(header.id, operations, document);
-            }
-            else {
-                await this.legacyStorage.addDocumentOperations(header.id, operations, document);
-            }
-        }
-        const addedDocument = await this.getDocument(documentStorage.header.id);
-        this.eventEmitter.emit("documentAdded", addedDocument);
-        return addedDocument;
-    }
-    async createDocumentDualAction(input, source, meta) {
-        const { documentType, document: inputDocument } = resolveCreateDocumentInput(input);
-        // if a document was provided then checks if it's valid
-        let state = undefined;
-        if (inputDocument) {
-            if ("documentType" in input &&
-                documentType !== inputDocument.header.documentType) {
-                throw new Error(`Provided document is not ${documentType}`);
-            }
-            const doc = this._buildDocument(inputDocument);
-            state = doc.state;
-        }
-        // if no document was provided then create a new one
-        const document = inputDocument ??
-            this.getDocumentModelModule(documentType).utils.createDocument(state);
-        // get the header
-        let header;
-        // handle the legacy case where an id is provided
-        let isSigned = false;
-        if ("id" in input && input.id) {
-            if (inputDocument) {
-                header = document.header;
-                document.header.id = input.id;
-                this.logger.warn("Assigning an id to a document is deprecated. Use the header field instead.");
-            }
-            else {
-                this.logger.warn("Creating a document with an id is deprecated. Use the header field instead.");
-                header = createPresignedHeader(input.id, documentType);
-            }
-        }
-        else if ("header" in input) {
-            // validate the header passed in
-            await validateHeader(input.header);
-            isSigned = true;
-            header = input.header;
-        }
-        else if (inputDocument?.header) {
-            if (!inputDocument.header.id) {
-                throw new Error("Document header id is required");
-            }
-            if (!inputDocument.header.documentType) {
-                throw new Error("Document header documentType is required");
-            }
-            if (!inputDocument.header.createdAtUtcIso) {
-                throw new Error("Document header createdAtUtcIso is required");
-            }
-            if (!inputDocument.header.sig.nonce) {
-                this.logger.warn("Creating a document with an unsigned id is deprecated. Use createSignedHeaderForSigner.");
-                // throw new Error("Document header sig nonce is required"); TODO: uncomment when ready to enforce signed documents
-            }
-            else {
-                await validateHeader(inputDocument.header);
-                isSigned = true;
-            }
-            header = inputDocument.header;
-        }
-        else {
-            // otherwise, generate a header
-            header = createPresignedHeader(undefined, documentType);
-            isSigned = false;
-        }
-        if (meta) {
-            header.meta = { ...header.meta, ...meta };
-        }
-        const currentVersion = 1;
-        // Get initial state from input or model's defaultState
-        const initialState = state ?? document.state;
-        // Check if the input document already has operations
-        const existingOperations = Object.values(document.operations).flat();
-        const shouldCreateOperations = existingOperations.length === 0;
-        let operations = [];
-        if (shouldCreateOperations) {
-            const timestampUtcMs = new Date().toISOString();
-            // Determine if this is a signed document
-            const signing = isSigned
-                ? {
-                    signature: header.id, // The document ID is the signature
-                    publicKey: header.sig.publicKey,
-                    nonce: header.sig.nonce,
-                    createdAtUtcIso: header.createdAtUtcIso,
-                    documentType: header.documentType,
-                }
-                : undefined;
-            // Create actions for CREATE_DOCUMENT and UPGRADE_DOCUMENT
-            const createDocumentInput = {
-                model: documentType,
-                version: 0,
-                documentId: header.id,
-                signing,
-            };
-            const createDocumentAction = {
-                id: generateId(),
-                type: "CREATE_DOCUMENT",
-                timestampUtcMs,
-                input: createDocumentInput,
-                scope: "document",
-            };
-            const upgradeDocumentInput = {
-                model: documentType,
-                fromVersion: 0,
-                toVersion: currentVersion,
-                documentId: header.id,
-                initialState,
-            };
-            const upgradeDocumentAction = {
-                id: generateId(),
-                type: "UPGRADE_DOCUMENT",
-                timestampUtcMs,
-                input: upgradeDocumentInput,
-                scope: "document",
-            };
-            // we need to create hashes for later verification
-            const baseState = defaultBaseState();
-            const createStateForHash = {
-                state: baseState,
-            };
-            const createHash = hashDocumentStateForScope(createStateForHash, "document");
-            const upgradeStateForHash = {
-                state: initialState,
-            };
-            const upgradeHash = hashDocumentStateForScope(upgradeStateForHash, "document");
-            // Create operations from actions with computed hashes
-            operations = [
-                {
-                    id: deriveOperationId(header.id, "document", "main", createDocumentAction.id),
-                    index: 0,
-                    skip: 0,
-                    hash: createHash,
-                    timestampUtcMs,
-                    action: createDocumentAction,
-                },
-                {
-                    id: deriveOperationId(header.id, "document", "main", upgradeDocumentAction.id),
-                    index: 1,
-                    skip: 0,
-                    hash: upgradeHash,
-                    timestampUtcMs,
-                    action: upgradeDocumentAction,
-                },
-            ];
-        }
-        else {
-            // Use existing operations from the input document
-            operations = existingOperations;
-        }
-        // Group operations by scope before storing
-        const groupedOps = groupOperationsByScope(operations);
-        // Ensure backward compatibility by initializing missing scopes
-        if (!groupedOps.header) {
-            groupedOps.header = [];
-        }
-        if (!groupedOps.document) {
-            groupedOps.document = [];
-        }
-        if (!groupedOps.global) {
-            groupedOps.global = [];
-        }
-        if (!groupedOps.local) {
-            groupedOps.local = [];
-        }
-        // After initialization, it's safe to treat as DocumentOperations
-        const operationsByScope = groupedOps;
-        // stores document information with operations
-        const documentToStore = {
-            header,
-            operations: operationsByScope,
-            initialState,
-            clipboard: [],
-            state: initialState,
-        };
-        await this.documentStorage.create(documentToStore);
-        // Force rebuild to ensure operations are properly merged
-        const addedDocument = await this.getDocument(documentToStore.header.id, {
-            checkHashes: true,
-        });
-        this.eventEmitter.emit("documentAdded", addedDocument);
-        return addedDocument;
-    }
-    async deleteDocument(documentId) {
-        try {
-            const syncUnits = await this.synchronizationManager.getSynchronizationUnitsIds(undefined, [documentId]);
-            // remove document sync units status when a document is deleted
-            for (const syncUnit of syncUnits) {
-                this.synchronizationManager.updateSyncStatus(syncUnit, null);
-            }
-            const parents = await this.documentStorage.getParents(documentId);
-            for (const parent of parents) {
-                this.listenerManager
-                    .removeSyncUnits(parent, syncUnits)
-                    .catch(this.logger.warn);
-            }
-        }
-        catch (error) {
-            this.logger.warn("Error deleting document: @error", error);
-        }
-        await Promise.allSettled([
-            this.cache.deleteDocument(documentId).catch(this.logger.warn),
-            this.documentStorage.delete(documentId).catch(this.logger.warn),
-        ]);
-        this.eventEmitter.emit("documentDeleted", documentId);
-    }
-    async _processOperations(documentId, documentStorage, operations) {
-        const operationsApplied = [];
-        const signals = [];
-        const documentStorageWithState = await this._addDocumentResultingStage(documentStorage, documentId);
-        let document = this._buildDocument(documentStorageWithState);
-        let error; // TODO: replace with an array of errors/consistency issues
-        const operationsByScope = groupOperationsByScope(operations);
-        for (const scope of Object.keys(operationsByScope)) {
-            const storageDocumentOperations = documentStorage.operations[scope] || [];
-            // TODO two equal operations done by two clients will be considered the same, ie: { type: "INCREMENT" }
-            const branch = removeExistingOperations(operationsByScope[scope] || [], storageDocumentOperations);
-            // No operations to apply
-            if (branch.length < 1) {
-                continue;
-            }
-            const trunk = garbageCollect(sortOperations(storageDocumentOperations));
-            const [invertedTrunk, tail] = attachBranch(trunk, branch);
-            const newHistory = tail.length < 1
-                ? invertedTrunk
-                : merge(trunk, invertedTrunk, reshuffleByTimestamp);
-            const newOperations = newHistory.filter((op) => trunk.length < 1 || precedes(trunk[trunk.length - 1], op));
-            for (const nextOperation of newOperations) {
-                let skipHashValidation = false;
-                // when dealing with a merge (tail.length > 0) we have to skip hash validation
-                // for the operations that were re-indexed (previous hash becomes invalid due the new position in the history)
-                if (tail.length > 0) {
-                    const sourceOperation = operations.find((op) => op.hash === nextOperation.hash);
-                    skipHashValidation =
-                        !sourceOperation ||
-                            sourceOperation.index !== nextOperation.index ||
-                            sourceOperation.skip !== nextOperation.skip;
-                }
-                try {
-                    // runs operation on next available tick, to avoid blocking the main thread
-                    const taskQueueMethod = this.options.taskQueueMethod;
-                    const task = () => this._performOperation(documentId, document, nextOperation, skipHashValidation);
-                    const appliedResult = await (taskQueueMethod
-                        ? runAsapAsync(task, taskQueueMethod)
-                        : task());
-                    document = appliedResult.document;
-                    signals.push(...appliedResult.signals);
-                    operationsApplied.push(appliedResult.operation);
-                    // TODO what to do if one of the applied operations has an error?
-                }
-                catch (e) {
-                    error =
-                        e instanceof OperationError
-                            ? e
-                            : new OperationError("ERROR", nextOperation, e.message, e.cause);
-                    // TODO: don't break on errors...
-                    break;
-                }
-            }
-        }
-        return {
-            document,
-            operationsApplied,
-            signals,
-            error,
-        };
-    }
-    async _addDocumentResultingStage(document, documentId, options) {
-        // apply skip header operations to all scopes
-        const operations = options?.revisions !== undefined
-            ? filterOperationsByRevision(document.operations, options.revisions)
-            : document.operations;
-        const documentOperations = garbageCollectDocumentOperations(operations);
-        for (const scope of Object.keys(documentOperations)) {
-            const scopeOps = documentOperations[scope];
-            if (!scopeOps) {
-                continue;
-            }
-            const lastRemainingOperation = scopeOps.at(-1);
-            // if the latest operation doesn't have a resulting state then tries
-            // to retrieve it from the db to avoid rerunning all the operations
-            if (lastRemainingOperation && !lastRemainingOperation.resultingState) {
-                lastRemainingOperation.resultingState = await (isDocumentDrive(document)
-                    ? this.legacyStorage.getOperationResultingState?.(documentId, lastRemainingOperation.index, lastRemainingOperation.action.scope, "main")
-                    : this.legacyStorage.getDriveOperationResultingState?.(documentId, lastRemainingOperation.index, lastRemainingOperation.action.scope, "main"));
-            }
-        }
-        return {
-            ...document,
-            operations: documentOperations,
-        };
-    }
-    _buildDocument(documentStorage, options) {
-        if (documentStorage.state &&
-            (!options || options.checkHashes === false) &&
-            isAtRevision(documentStorage, options?.revisions)) {
-            return documentStorage;
-        }
-        const documentModelModule = this.getDocumentModelModule(documentStorage.header.documentType);
-        const revisionOperations = options?.revisions !== undefined
-            ? filterOperationsByRevision(documentStorage.operations, options.revisions)
-            : documentStorage.operations;
-        const operations = garbageCollectDocumentOperations(revisionOperations);
-        // Get all scopes from operations
-        const allScopes = Object.keys(operations);
-        // Initialize with all scopes found in operations, plus global and local for backward compatibility
-        const scopesToInitialize = new Set([...allScopes, "global", "local"]);
-        const headerOperations = {};
-        const operationsToReplay = {};
-        for (const scope of scopesToInitialize) {
-            headerOperations[scope] = [];
-            operationsToReplay[scope] = [];
-        }
-        // Filter out CREATE_DOCUMENT and UPGRADE_DOCUMENT operations
-        // (these don't currently have reducers and should not be replayed)
-        for (const [scope, scopeOps] of Object.entries(operations)) {
-            if (!scopeOps) {
-                continue;
-            }
-            for (const op of scopeOps) {
-                if (op.action.type === "CREATE_DOCUMENT" ||
-                    op.action.type === "UPGRADE_DOCUMENT") {
-                    const headerOps = headerOperations[scope];
-                    if (headerOps) {
-                        headerOps.push(op);
-                    }
-                }
-                else {
-                    const replayOps = operationsToReplay[scope];
-                    if (replayOps) {
-                        replayOps.push(op);
-                    }
-                }
-            }
-        }
-        // If revisions filter is specified, compute header revision from filtered operations
-        // This ensures the returned document's header.revision reflects the requested revision,
-        // not the current storage state
-        let headerForReplay = documentStorage.header;
-        if (options?.revisions) {
-            const newRevision = {
-                ...documentStorage.header.revision,
-            };
-            // For each scope in the revision filter, compute actual revision from filtered ops
-            for (const scope of Object.keys(options.revisions)) {
-                const scopeOps = operations[scope] ?? [];
-                if (scopeOps.length === 0) {
-                    // No ops means revision should not exist for this scope
-                    delete newRevision[scope];
-                }
-                else {
-                    const lastOp = scopeOps.at(-1);
-                    newRevision[scope] = lastOp ? lastOp.index + 1 : 0;
-                }
-            }
-            headerForReplay = {
-                ...documentStorage.header,
-                revision: newRevision,
-            };
-        }
-        const replayed = replayDocument(documentStorage.initialState, operationsToReplay, documentModelModule.reducer, headerForReplay, undefined, {}, {
-            ...options,
-            checkHashes: options?.checkHashes ?? true,
-            reuseOperationResultingState: options?.checkHashes ?? true,
-        });
-        // merge header operations back into the result
-        // Include ALL scopes from input operations, header operations, and replayed operations
-        const allScopesForMerge = new Set([
-            ...Object.keys(operations), // From input storage
-            ...Object.keys(headerOperations),
-            ...Object.keys(replayed.operations),
-        ]);
-        const finalOperations = {};
-        for (const scope of allScopesForMerge) {
-            finalOperations[scope] = [
-                ...(headerOperations[scope] || []),
-                ...(replayed.operations[scope] || []),
-            ];
-        }
-        return {
-            ...replayed,
-            operations: finalOperations,
-            clipboard: documentStorage.clipboard ?? [],
-        };
-    }
-    async _performOperation(documentId, document, operation, skipHashValidation = false) {
-        const documentModelModule = this.getDocumentModelModule(document.header.documentType);
-        const signalResults = [];
-        let newDocument = document;
-        const scope = operation.action.scope;
-        const currentScopeOperations = document.operations[scope] || [];
-        const documentOperations = garbageCollectDocumentOperations({
-            ...document.operations,
-            [scope]: skipHeaderOperations(currentScopeOperations, operation),
-        });
-        const remainingScopeOps = documentOperations[scope];
-        const lastRemainingOperation = remainingScopeOps?.at(-1);
-        // if the latest operation doesn't have a resulting state then tries
-        // to retrieve it from the db to avoid rerunning all the operations
-        if (lastRemainingOperation && !lastRemainingOperation.resultingState) {
-            lastRemainingOperation.resultingState = await (isDocumentDrive(document)
-                ? this.legacyStorage.getOperationResultingState?.(documentId, lastRemainingOperation.index, lastRemainingOperation.action.scope, "main")
-                : this.legacyStorage.getDriveOperationResultingState?.(documentId, lastRemainingOperation.index, lastRemainingOperation.action.scope, "main"));
-        }
-        const operationsBeforeReducer = newDocument.operations[scope] || [];
-        const operationSignals = [];
-        newDocument = documentModelModule.reducer(newDocument, operation.action, (signal) => {
-            let handler = undefined;
-            switch (signal.type) {
-                case "CREATE_CHILD_DOCUMENT":
-                    handler = () => this.addChild(documentId, signal.input.id);
-                    break;
-                case "DELETE_CHILD_DOCUMENT":
-                    handler = () => this.removeChild(documentId, signal.input.id);
-                    break;
-                case "COPY_CHILD_DOCUMENT":
-                    handler = () => this.addChild(documentId, signal.input.newId);
-                    break;
-            }
-            if (handler) {
-                operationSignals.push(() => handler().then((result) => ({ signal, result })));
-            }
-        }, {
-            skip: operation.skip,
-            reuseOperationResultingState: true,
-            replayOptions: { operation },
-        });
-        // when we have NOOP operations with skip > 0 we need to populate the
-        // clipboard with the operations that were skipped to allow redo
-        if (operation.action.type === "NOOP" &&
-            operation.skip > 0 &&
-            newDocument.clipboard.length === 0) {
-            const scopeOperationsAfter = newDocument.operations[scope] || [];
-            // Get operations AFTER garbageCollect (with NOOP)
-            const afterOperations = garbageCollect(sortOperations(scopeOperationsAfter));
-            // Get operations BEFORE the reducer ran (before NOOP was applied)
-            const beforeOperations = garbageCollect(sortOperations(operationsBeforeReducer));
-            // Calculate what was removed by comparing before vs after
-            // The diff shows operations that were in "before" but not in "after"
-            const diff = diffOperations(beforeOperations, afterOperations);
-            // Populate clipboard with skipped operations (excluding NOOPs)
-            newDocument = {
-                ...newDocument,
-                clipboard: sortOperations(diff.filter((op) => op.action.type !== "NOOP")).reverse(),
-            };
-        }
-        const newDocScopeOperations = newDocument.operations[operation.action.scope];
-        if (!newDocScopeOperations) {
-            throw new OperationError("ERROR", operation, `No operations found for scope: ${operation.action.scope}`);
-        }
-        const appliedOperations = newDocScopeOperations.filter((op) => op.index == operation.index && op.skip == operation.skip);
-        const appliedOperation = appliedOperations.at(0);
-        if (!appliedOperation) {
-            throw new OperationError("ERROR", operation, `Operation with index ${operation.index}:${operation.skip} was not applied.`);
-        }
-        if (!appliedOperation.error &&
-            appliedOperation.hash !== operation.hash &&
-            !skipHashValidation) {
-            this.logger.warn("@appliedOperation", appliedOperation);
-            throw new ConflictOperationError(operation, appliedOperation);
-        }
-        for (const signalHandler of operationSignals) {
-            const result = await signalHandler();
-            signalResults.push(result);
-        }
-        return {
-            document: newDocument,
-            signals: signalResults,
-            operation: appliedOperation,
-        };
-    }
-    addOperation(driveIdOrDocumentId, documentIdOrOperation, operationOrOptions, maybeOptions) {
-        let documentId;
-        let operation;
-        let options;
-        if (typeof documentIdOrOperation === "string") {
-            // Deprecated overload: (driveId, documentId, operation, options)
-            documentId = documentIdOrOperation;
-            operation = operationOrOptions;
-            options = maybeOptions;
-        }
-        else {
-            // Standard overload: (documentId, operation, options)
-            documentId = driveIdOrDocumentId;
-            operation = documentIdOrOperation;
-            options = operationOrOptions;
-        }
-        return this.addOperations(documentId, [operation], options);
-    }
-    async _addOperations(documentId, callback) {
-        if (!this.legacyStorage.addDocumentOperationsWithTransaction) {
-            const documentStorage = await this.documentStorage.get(documentId);
-            const result = await callback(documentStorage);
-            // saves the applied operations to storage
-            if (result.operations.length > 0) {
-                await this.legacyStorage.addDocumentOperations(documentId, result.operations, result.document);
-            }
-        }
-        else {
-            await this.legacyStorage.addDocumentOperationsWithTransaction(documentId, callback);
-        }
-    }
-    async queueDocument(input, options) {
-        const { id, documentType, document } = resolveCreateDocumentInput(input);
-        if (!id) {
-            throw new Error("Document id is required", { cause: input });
-        }
-        if (!documentType) {
-            throw new Error("Document type is required", { cause: input });
-        }
-        const exists = await this.documentStorage.exists(id);
-        if (exists) {
-            throw new DocumentAlreadyExistsError(id);
-        }
-        // add listeners first
-        let jobId;
-        const promise = new Promise((resolve, reject) => {
-            const unsubscribe = this.queueManager.on("jobCompleted", (job, result) => {
-                if (job.jobId === jobId) {
-                    unsubscribe();
-                    unsubscribeError();
-                    resolve(result);
-                }
-            });
-            const unsubscribeError = this.queueManager.on("jobFailed", (job, error) => {
-                if (job.jobId === jobId) {
-                    unsubscribe();
-                    unsubscribeError();
-                    reject(error);
-                }
-            });
-        });
-        // now queue the job
-        try {
-            jobId = await this.queueManager.addJob({
-                documentId: id,
-                documentType,
-                initialState: document?.state,
-                header: document?.header,
-                options,
-            });
-        }
-        catch (error) {
-            this.logger.error("Error adding job: @error", error);
-            throw error;
-        }
-        return promise;
-    }
-    queueOperation(driveIdOrDocumentId, documentIdOrOperation, operationOrOptions, maybeOptions) {
-        let documentId;
-        let operation;
-        let options;
-        if (typeof documentIdOrOperation === "string") {
-            // Deprecated overload: (driveId, documentId, operation, options)
-            documentId = documentIdOrOperation;
-            operation = operationOrOptions;
-            options = maybeOptions;
-        }
-        else {
-            // Standard overload: (documentId, operation, options)
-            documentId = driveIdOrDocumentId;
-            operation = documentIdOrOperation;
-            options = operationOrOptions;
-        }
-        return this._queueOperations(documentId, [operation], options);
-    }
-    async resultIfExistingOperations(id, operations) {
-        try {
-            const document = await this.getDocument(id);
-            const newOperation = operations.find((op) => {
-                if (!op.id) {
-                    return true;
-                }
-                const scopeOps = document.operations[op.action.scope];
-                if (!scopeOps) {
-                    return true;
-                }
-                return !scopeOps.find((existingOp) => existingOp.id === op.id &&
-                    existingOp.index === op.index &&
-                    existingOp.action.type === op.action.type &&
-                    existingOp.hash === op.hash);
-            });
-            if (!newOperation) {
-                return {
-                    status: "SUCCESS",
-                    document,
-                    operations,
-                    signals: [],
-                };
-            }
-            else {
-                return undefined;
-            }
-        }
-        catch (error) {
-            if (!error.message.includes(`Document with id ${id} not found`)) {
-                console.error(error);
-            }
-            return undefined;
-        }
-    }
-    queueOperations(driveIdOrDocumentId, documentIdOrOperations, operationsOrOptions, maybeOptions) {
-        let documentId;
-        let operations;
-        let options;
-        if (typeof documentIdOrOperations === "string") {
-            // Deprecated overload: (driveId, documentId, operations, options)
-            documentId = documentIdOrOperations;
-            operations = operationsOrOptions;
-            options = maybeOptions;
-        }
-        else {
-            // Standard overload: (documentId, operations, options)
-            documentId = driveIdOrDocumentId;
-            operations = documentIdOrOperations;
-            options = operationsOrOptions;
-        }
-        return this._queueOperations(documentId, operations, options);
-    }
-    async _queueOperations(documentId, operations, options) {
-        // if operations are already stored then returns cached document
-        const result = await this.resultIfExistingOperations(documentId, operations);
-        if (result) {
-            return result;
-        }
-        // add listeners first
-        let jobId;
-        const promise = new Promise((resolve, reject) => {
-            const unsubscribe = this.queueManager.on("jobCompleted", (job, result) => {
-                if (job.jobId === jobId) {
-                    unsubscribe();
-                    unsubscribeError();
-                    resolve(result);
-                }
-            });
-            const unsubscribeError = this.queueManager.on("jobFailed", (job, error) => {
-                if (job.jobId === jobId) {
-                    unsubscribe();
-                    unsubscribeError();
-                    reject(error);
-                }
-            });
-        });
-        // now queue the job
-        try {
-            jobId = await this.queueManager.addJob({
-                documentId,
-                operations,
-                options,
-            });
-        }
-        catch (error) {
-            this.logger.error("Error adding job: @error", error);
-            throw error;
-        }
-        return promise;
-    }
-    queueAction(driveIdOrDocumentId, documentIdOrAction, actionOrOptions, maybeOptions) {
-        let documentId;
-        let action;
-        let options;
-        if (typeof documentIdOrAction === "string") {
-            // Deprecated overload: (driveId, documentId, action, options)
-            documentId = documentIdOrAction;
-            action = actionOrOptions;
-            options = maybeOptions;
-        }
-        else {
-            // Standard overload: (documentId, action, options)
-            documentId = driveIdOrDocumentId;
-            action = documentIdOrAction;
-            options = actionOrOptions;
-        }
-        return this._queueActions(documentId, [action], options);
-    }
-    queueActions(driveIdOrDocumentId, documentIdOrActions, actionsOrOptions, maybeOptions) {
-        let documentId;
-        let actions;
-        let options;
-        if (typeof documentIdOrActions === "string") {
-            // Deprecated overload: (driveId, documentId, actions, options)
-            documentId = documentIdOrActions;
-            actions = actionsOrOptions;
-            options = maybeOptions;
-        }
-        else {
-            // Standard overload: (documentId, actions, options)
-            documentId = driveIdOrDocumentId;
-            actions = documentIdOrActions;
-            options = actionsOrOptions;
-        }
-        return this._queueActions(documentId, actions, options);
-    }
-    async _queueActions(documentId, actions, options) {
-        try {
-            const jobId = await this.queueManager.addJob({
-                documentId,
-                actions,
-                options,
-            });
-            return await new Promise((resolve, reject) => {
-                const unsubscribe = this.queueManager.on("jobCompleted", (job, result) => {
-                    if (job.jobId === jobId) {
-                        unsubscribe();
-                        unsubscribeError();
-                        resolve(result);
-                    }
-                });
-                const unsubscribeError = this.queueManager.on("jobFailed", (job, error) => {
-                    if (job.jobId === jobId) {
-                        unsubscribe();
-                        unsubscribeError();
-                        reject(error);
-                    }
-                });
-            });
-        }
-        catch (error) {
-            this.logger.error("Error adding job: @error", error);
-            throw error;
-        }
-    }
-    /**
-     * @deprecated Use the {@link queueAction} method instead.
-     */
-    async queueDriveAction(driveId, action, options) {
-        return this.queueDriveActions(driveId, [action], options);
-    }
-    /**
-     * @deprecated Use the {@link queueActions} method instead.
-     */
-    async queueDriveActions(driveId, actions, options) {
-        try {
-            const jobId = await this.queueManager.addJob({
-                documentId: driveId,
-                actions,
-                options,
-            });
-            return await new Promise((resolve, reject) => {
-                const unsubscribe = this.queueManager.on("jobCompleted", (job, result) => {
-                    if (job.jobId === jobId) {
-                        unsubscribe();
-                        unsubscribeError();
-                        resolve(result);
-                    }
-                });
-                const unsubscribeError = this.queueManager.on("jobFailed", (job, error) => {
-                    if (job.jobId === jobId) {
-                        unsubscribe();
-                        unsubscribeError();
-                        reject(error);
-                    }
-                });
-            });
-        }
-        catch (error) {
-            this.logger.error("Error adding drive job: @error", error);
-            throw error;
-        }
-    }
-    addOperations(driveIdOrDocumentId, documentIdOrOperations, operationsOrOptions, maybeOptions) {
-        let documentId;
-        let operations;
-        let options;
-        if (typeof documentIdOrOperations === "string") {
-            // Deprecated overload: (driveId, documentId, operations, options)
-            documentId = documentIdOrOperations;
-            operations = operationsOrOptions;
-            options = maybeOptions;
-        }
-        else {
-            // Standard overload: (documentId, operations, options)
-            documentId = driveIdOrDocumentId;
-            operations = documentIdOrOperations;
-            options = operationsOrOptions;
-        }
-        return this._queueOperations(documentId, operations, options);
-    }
-    async processOperations(documentId, operations, options) {
-        // if operations are already stored then returns the result
-        const result = await this.resultIfExistingOperations(documentId, operations);
-        if (result) {
-            return result;
-        }
-        let document;
-        const operationsApplied = [];
-        const signals = [];
-        let error;
-        try {
-            await this._addOperations(documentId, async (documentStorage) => {
-                const result = await this._processOperations(documentId, documentStorage, operations);
-                if (!result.document) {
-                    this.logger.error("Invalid document");
-                    throw result.error ?? new Error("Invalid document");
-                }
-                document = result.document;
-                error = result.error;
-                signals.push(...result.signals);
-                operationsApplied.push(...result.operationsApplied);
-                return {
-                    operations: result.operationsApplied,
-                    document: result.document,
-                };
-            });
-            const syncUnits = new Array();
-            if (document) {
-                this.cache
-                    .setDocument(documentId, document)
-                    .catch((e) => this.logger.error("@error", e));
-                // creates array of unique sync units from the applied operations
-                for (const operation of operationsApplied) {
-                    const syncUnit = {
-                        documentId,
-                        documentType: document.header.documentType,
-                        scope: operation.action.scope,
-                        branch: "main", // TODO: handle branches
-                        revision: operation.index + 1,
-                        lastUpdated: operation.timestampUtcMs,
-                    };
-                    // checks if this sync unit was already added
-                    const exists = syncUnits.some((unit) => unit.documentId === syncUnit.documentId &&
-                        unit.scope === syncUnit.scope &&
-                        unit.branch === syncUnit.branch);
-                    if (!exists) {
-                        syncUnits.push(syncUnit);
-                    }
-                }
-            }
-            // checks if any of the provided operations where reshufled
-            const newOp = operationsApplied.find((appliedOp) => !operations.find((o) => o.id === appliedOp.id &&
-                o.index === appliedOp.index &&
-                o.skip === appliedOp.skip &&
-                o.hash === appliedOp.hash));
-            // if there are no new operations then reuses the provided source
-            // otherwise sets it to local so listeners know that there were
-            // new changes originating from this document drive server
-            const source = newOp
-                ? { type: "local" }
-                : (options?.source ?? { type: "local" });
-            // update listener cache
-            const operationSource = this.getOperationSource(source);
-            // TODO Decouple the operation processing from syncing it to the listeners?
-            // Listener manager should be the one keeping the sync status since it depends on the listeners
-            if (syncUnits.length) {
-                this.listenerManager
-                    .updateSynchronizationRevisions(syncUnits, source, () => {
-                    this.synchronizationManager.updateSyncStatus(documentId, {
-                        [operationSource]: "SYNCING",
-                    });
-                    for (const syncUnit of syncUnits) {
-                        this.synchronizationManager.updateSyncStatus(syncUnit, {
-                            [operationSource]: "SYNCING",
-                        });
-                    }
-                }, this.handleListenerError.bind(this), options?.forceSync ?? source.type === "local")
-                    .then((updates) => {
-                    if (updates.length) {
-                        this.synchronizationManager.updateSyncStatus(documentId, {
-                            [operationSource]: "SUCCESS",
-                        });
-                    }
-                    for (const syncUnit of syncUnits) {
-                        this.synchronizationManager.updateSyncStatus(syncUnit, {
-                            [operationSource]: "SUCCESS",
-                        });
-                    }
-                })
-                    .catch((error) => {
-                    this.logger.error("Non handled error updating sync revision: @error", error);
-                    this.synchronizationManager.updateSyncStatus(documentId, {
-                        [operationSource]: "ERROR",
-                    }, error);
-                    for (const syncUnit of syncUnits) {
-                        this.synchronizationManager.updateSyncStatus(syncUnit, {
-                            [operationSource]: "ERROR",
-                        }, error);
-                    }
-                });
-            }
-            // after applying all the valid operations,throws
-            // an error if there was an invalid operation
-            if (error) {
-                throw error;
-            }
-            this.eventEmitter.emit("documentOperationsAdded", documentId, operations);
-            this.eventEmitter.emit("operationsAdded", documentId, operations);
-            return {
-                status: "SUCCESS",
-                document,
-                operations: operationsApplied,
-                signals,
-            };
-        }
-        catch (error) {
-            const operationError = error instanceof OperationError
-                ? error
-                : new OperationError("ERROR", undefined, error.message, error.cause);
-            return {
-                status: operationError.status,
-                error: operationError,
-                document,
-                operations: operationsApplied,
-                signals,
-            };
-        }
-    }
-    /**
-     * @deprecated Use the {@link addOperation} method instead.
-     */
-    addDriveOperation(driveId, operation, options) {
-        return this.addDriveOperations(driveId, [operation], options);
-    }
-    async _addDriveOperations(driveId, callback) {
-        if (!this.legacyStorage.addDriveOperationsWithTransaction) {
-            const documentStorage = await this.documentStorage.get(driveId);
-            const result = await callback(documentStorage);
-            // saves the applied operations to storage
-            if (result.operations.length > 0) {
-                await this.legacyStorage.addDriveOperations(driveId, result.operations, result.document);
-            }
-            return result;
-        }
-        else {
-            return this.legacyStorage.addDriveOperationsWithTransaction(driveId, callback);
-        }
-    }
-    /**
-     * @deprecated Use the {@link queueOperation} method instead.
-     */
-    queueDriveOperation(driveId, operation, options) {
-        return this.queueDriveOperations(driveId, [operation], options);
-    }
-    async resultIfExistingDriveOperations(driveId, operations) {
-        try {
-            const drive = await this.getDrive(driveId);
-            const newOperation = operations.find((op) => {
-                if (!op.id) {
-                    return true;
-                }
-                const scopeOps = drive.operations[op.action.scope];
-                if (!scopeOps) {
-                    return true;
-                }
-                return !scopeOps.find((existingOp) => existingOp.id === op.id &&
-                    existingOp.index === op.index &&
-                    existingOp.action.type === op.action.type &&
-                    existingOp.hash === op.hash);
-            });
-            if (!newOperation) {
-                return {
-                    status: "SUCCESS",
-                    document: drive,
-                    operations: operations,
-                    signals: [],
-                };
-            }
-            else {
-                return undefined;
-            }
-        }
-        catch (error) {
-            console.error(error); // TODO error
-            return undefined;
-        }
-    }
-    /**
-     * @deprecated Use the {@link queueOperations} method instead.
-     */
-    async queueDriveOperations(driveId, operations, options) {
-        // if operations are already stored then returns cached document
-        const result = await this.resultIfExistingDriveOperations(driveId, operations);
-        if (result) {
-            return result;
-        }
-        try {
-            const jobId = await this.queueManager.addJob({
-                documentId: driveId,
-                operations,
-                options,
-            });
-            return await new Promise((resolve, reject) => {
-                const unsubscribe = this.queueManager.on("jobCompleted", (job, result) => {
-                    if (job.jobId === jobId) {
-                        unsubscribe();
-                        unsubscribeError();
-                        resolve(result);
-                    }
-                });
-                const unsubscribeError = this.queueManager.on("jobFailed", (job, error) => {
-                    if (job.jobId === jobId) {
-                        unsubscribe();
-                        unsubscribeError();
-                        reject(error);
-                    }
-                });
-            });
-        }
-        catch (error) {
-            this.logger.error("Error adding drive job: @error", error);
-            throw error;
-        }
-    }
-    /**
-     * @deprecated Use the {@link addOperations} method instead.
-     */
-    async addDriveOperations(driveId, operations, options) {
-        return this.queueDriveOperations(driveId, operations, options);
-    }
-    async processDriveOperations(driveId, operations, options) {
-        let document;
-        const operationsApplied = [];
-        const signals = [];
-        let error;
-        // if operations are already stored then returns cached drive
-        const result = await this.resultIfExistingDriveOperations(driveId, operations);
-        if (result) {
-            return result;
-        }
-        try {
-            await this._addDriveOperations(driveId, async (documentStorage) => {
-                const result = await this._processOperations(driveId, documentStorage, operations.slice());
-                document = result.document;
-                operationsApplied.push(...result.operationsApplied);
-                signals.push(...result.signals);
-                error = result.error;
-                return {
-                    operations: result.operationsApplied,
-                    document: result.document,
-                };
-            });
-            if (!document || !isDocumentDrive(document)) {
-                throw error ?? new Error("Invalid Document Drive document");
-            }
-            this.cache
-                .setDocument(driveId, document)
-                .catch((e) => this.logger.error("@error", e));
-            this.cache
-                .setDrive(driveId, document)
-                .catch((e) => this.logger.error("@error", e));
-            // update listener cache
-            const lastOperation = operationsApplied
-                .filter((op) => op.action.scope === "global")
-                .slice()
-                .pop();
-            if (lastOperation) {
-                // checks if any of the provided operations where reshufled
-                const newOp = operationsApplied.find((appliedOp) => !operations.find((o) => o.id === appliedOp.id &&
-                    o.index === appliedOp.index &&
-                    o.skip === appliedOp.skip &&
-                    o.hash === appliedOp.hash));
-                // if there are no new operations then reuses the provided source
-                // otherwise sets it to local so listeners know that there were
-                // new changes originating from this document drive server
-                const source = newOp
-                    ? { type: "local" }
-                    : (options?.source ?? { type: "local" });
-                const operationSource = this.getOperationSource(source);
-                this.listenerManager
-                    .updateSynchronizationRevisions([
-                    {
-                        documentId: driveId,
-                        documentType: document.header.documentType,
-                        scope: "global",
-                        branch: "main",
-                        lastUpdated: lastOperation.timestampUtcMs,
-                        revision: lastOperation.index,
-                    },
-                ], source, () => {
-                    this.synchronizationManager.updateSyncStatus(driveId, {
-                        [operationSource]: "SYNCING",
-                    });
-                }, this.handleListenerError.bind(this), options?.forceSync ?? source.type === "local")
-                    .then((updates) => {
-                    if (updates.length) {
-                        this.synchronizationManager.updateSyncStatus(driveId, {
-                            [operationSource]: "SUCCESS",
-                        });
-                    }
-                })
-                    .catch((error) => {
-                    this.logger.error("Non handled error updating sync revision: @error", error);
-                    this.synchronizationManager.updateSyncStatus(driveId, {
-                        [operationSource]: "ERROR",
-                    }, error);
-                });
-            }
-            if (this.shouldSyncRemoteDrive(document)) {
-                this.startSyncRemoteDrive(driveId).catch((e) => this.logger.error("@error", e));
-            }
-            else {
-                this.stopSyncRemoteDrive(driveId).catch((e) => this.logger.error("@error", e));
-            }
-            // after applying all the valid operations,throws
-            // an error if there was an invalid operation
-            if (error) {
-                throw error;
-            }
-            this.eventEmitter.emit("driveOperationsAdded", driveId, operations);
-            this.eventEmitter.emit("operationsAdded", driveId, operations);
-            return {
-                status: "SUCCESS",
-                document,
-                operations: operationsApplied,
-                signals,
-            };
-        }
-        catch (error) {
-            const operationError = error instanceof OperationError
-                ? error
-                : new OperationError("ERROR", undefined, error.message, error);
-            return {
-                status: operationError.status,
-                error: operationError,
-                document,
-                operations: operationsApplied,
-                signals,
-            };
-        }
-    }
-    _buildOperations(documentId, actions) {
-        const operations = [];
-        const { reducer } = this.getDocumentModelModule(documentId.header.documentType);
-        for (const action of actions) {
-            documentId = reducer(documentId, action);
-            const scopeOps = documentId.operations[action.scope];
-            if (!scopeOps) {
-                throw new Error(`No operations found for scope: ${action.scope}`);
-            }
-            const operation = scopeOps.slice().pop();
-            if (!operation) {
-                throw new Error("Error creating operations");
-            }
-            operations.push(operation);
-        }
-        return operations;
-    }
-    addAction(driveIdOrDocumentId, documentIdOrAction, actionOrOptions, maybeOptions) {
-        let documentId;
-        let action;
-        let options;
-        if (typeof documentIdOrAction === "string") {
-            // Deprecated overload: (driveId, documentId, action, options)
-            documentId = documentIdOrAction;
-            action = actionOrOptions;
-            options = maybeOptions;
-        }
-        else {
-            // Standard overload: (documentId, action, options)
-            documentId = driveIdOrDocumentId;
-            action = documentIdOrAction;
-            options = actionOrOptions;
-        }
-        return this._addAction(documentId, action, options);
-    }
-    async _addAction(documentId, action, options) {
-        return this.addActions(documentId, [action], options);
-    }
-    addActions(driveIdOrDocumentId, documentIdOrActions, actionsOrOptions, maybeOptions) {
-        let documentId;
-        let actions;
-        let options;
-        if (typeof documentIdOrActions === "string") {
-            // Deprecated overload: (driveId, documentId, actions, options)
-            documentId = documentIdOrActions;
-            actions = actionsOrOptions;
-            options = maybeOptions;
-        }
-        else {
-            // Standard overload: (documentId, actions, options)
-            documentId = driveIdOrDocumentId;
-            actions = documentIdOrActions;
-            options = actionsOrOptions;
-        }
-        return this._queueActions(documentId, actions, options);
-    }
-    async processActions(documentId, actions, options) {
-        const document = await this.getDocument(documentId);
-        const operations = this._buildOperations(document, actions);
-        return this.processOperations(documentId, operations, options);
-    }
-    /**
-     * @deprecated Use the {@link addAction} method instead.
-     */
-    async addDriveAction(driveId, action, options) {
-        if ("synchronizationUnits" in action.input) {
-            return this._legacyAddFileAction(driveId, action, options);
-        }
-        return this.addDriveActions(driveId, [action], options);
-    }
-    async _legacyAddFileAction(driveId, action, options) {
-        // create document before adding it to the drive
-        const document = this.getDocumentModelModule(action.input.documentType).utils.createDocument(action.input.document?.state || undefined);
-        document.header.id = action.input.id;
-        document.header.name = action.input.name;
-        document.header.documentType = action.input.documentType;
-        await this.queueDocument({ document }, { source: options?.source || { type: "local" } });
-        // create updated version of the ADD_FILE action
-        const newAction = {
-            ...action,
-            input: {
-                id: action.input.id,
-                documentType: document.header.documentType,
-                name: action.input.name,
-                parentFolder: action.input.parentFolder,
-            },
-        };
-        return (await this.addAction(driveId, newAction, options));
-    }
-    /**
-     * @deprecated Use the {@link addActions} method instead.
-     */
-    async addDriveActions(driveId, actions, options) {
-        return this.queueDriveActions(driveId, actions, options);
-    }
-    async processDriveActions(driveId, actions, options) {
-        const document = await this.getDrive(driveId);
-        const operations = this._buildOperations(document, actions);
-        return this.processDriveOperations(driveId, operations, options);
-    }
-    async detachDrive(driveId) {
-        const documentDrive = await this.getDrive(driveId);
-        const listeners = documentDrive.state.local.listeners || [];
-        const triggers = documentDrive.state.local.triggers || [];
-        for (const listener of listeners) {
-            await this.addDriveAction(driveId, removeListener({ listenerId: listener.listenerId }));
-        }
-        for (const trigger of triggers) {
-            await this.addDriveAction(driveId, removeTrigger({ triggerId: trigger.id }));
-        }
-        await this.addDriveAction(driveId, setSharingType({ type: "LOCAL" }));
-    }
-    getSyncStatus(documentId, scope, branch) {
-        return this.synchronizationManager.getSyncStatus(documentId, scope, branch);
-    }
-    on(event, cb) {
-        return this.eventEmitter.on(event, cb);
-    }
-    emit(event, ...args) {
-        return this.eventEmitter.emit(event, ...args);
-    }
-    // Add delegated methods to properly implement ISynchronizationManager
-    updateSyncStatus(syncUnitId, status, error) {
-        this.synchronizationManager.updateSyncStatus(syncUnitId, status, error);
-    }
-    initializeDriveSyncStatus(driveId, drive) {
-        return this.synchronizationManager.initializeDriveSyncStatus(driveId, drive);
-    }
-    getCombinedSyncUnitStatus(syncUnitStatus) {
-        return this.synchronizationManager.getCombinedSyncUnitStatus(syncUnitStatus);
-    }
-    // Add back the saveStrand method that was accidentally removed
-    async saveStrand(strand, source) {
-        const isNewDocument = !(await this.documentStorage.exists(strand.documentId));
-        let result = undefined;
-        if (isNewDocument) {
-            result = await this.queueDocument({
-                id: strand.documentId,
-                documentType: strand.documentType,
-            });
-        }
-        const operations = strand.operations.map((op) => ({
-            ...op,
-            id: op.id ??
-                deriveOperationId(strand.documentId, strand.scope, strand.branch, op.actionId),
-            action: {
-                id: op.actionId,
-                timestampUtcMs: op.timestampUtcMs,
-                type: op.type,
-                input: op.input,
-                context: op.context,
-                scope: strand.scope,
-            },
-            scope: strand.scope,
-            branch: strand.branch,
-        }));
-        // if document already existed or queueDocument
-        // was successful, queues the operations
-        if ((!isNewDocument || result?.status === "SUCCESS") && operations.length) {
-            try {
-                result = await this.queueOperations(strand.documentId, operations, {
-                    source,
-                });
-            }
-            catch (error) {
-                this.logger.error("Error queueing operations: @error", error);
-                throw error;
-            }
-        }
-        if (!result) {
-            this.logger.debug("Document @documentId already exists", strand.documentId);
-            return {
-                status: "SUCCESS",
-                document: await this.getDocument(strand.documentId),
-                operations: [],
-                signals: [],
-            };
-        }
-        if (result.status === "ERROR") {
-            const operationSource = this.getOperationSource(source);
-            this.synchronizationManager.updateSyncStatus({
-                documentId: strand.documentId || strand.driveId,
-                scope: strand.scope,
-                branch: strand.branch,
-            }, { [operationSource]: result.status }, result.error);
-        }
-        this.eventEmitter.emit("strandUpdate", strand);
-        return result;
-    }
-    setGenerateJwtHandler(handler) {
-        this.generateJwtHandler = handler;
-        this.listenerManager.setGenerateJwtHandler(handler);
-    }
-    removeJwtHandler() {
-        this.generateJwtHandler = undefined;
-        this.listenerManager.removeJwtHandler();
-    }
-}
-export const DocumentDriveServer = ReadModeServer(BaseDocumentDriveServer);
-//# sourceMappingURL=base-server.js.map