@powerhousedao/reactor 6.0.0-dev.7 → 6.0.0-dev.78

package/dist/src/executor/simple-job-executor.js

@@ -1,898 +0,0 @@
-import { deriveOperationId, isUndoRedo } from "document-model/core";
-import { driveCollectionId } from "../cache/operation-index-types.js";
-import { OperationEventTypes, } from "../events/types.js";
-import { DocumentDeletedError, InvalidSignatureError, } from "../shared/errors.js";
-import { reshuffleByTimestamp } from "../utils/reshuffle.js";
-import { applyDeleteDocumentAction, applyUpgradeDocumentAction, createDocumentFromAction, getNextIndexForScope, } from "./util.js";
-const MAX_SKIP_THRESHOLD = 100;
-const documentScopeActions = [
-    "CREATE_DOCUMENT",
-    "DELETE_DOCUMENT",
-    "UPGRADE_DOCUMENT",
-    "ADD_RELATIONSHIP",
-    "REMOVE_RELATIONSHIP",
-];
-/**
- * Simple job executor that processes a job by applying actions through document model reducers.
- *
- * @see docs/planning/Storage/IOperationStore.md for storage schema
- * @see docs/planning/Operations/index.md for operation structure
- * @see docs/planning/Jobs/reshuffle.md for skip mechanism details
- */
-export class SimpleJobExecutor {
-    logger;
-    registry;
-    documentStorage;
-    operationStorage;
-    operationStore;
-    eventBus;
-    writeCache;
-    operationIndex;
-    documentMetaCache;
-    signatureVerifier;
-    config;
-    constructor(logger, registry, documentStorage, operationStorage, operationStore, eventBus, writeCache, operationIndex, documentMetaCache, config, signatureVerifier) {
-        this.logger = logger;
-        this.registry = registry;
-        this.documentStorage = documentStorage;
-        this.operationStorage = operationStorage;
-        this.operationStore = operationStore;
-        this.eventBus = eventBus;
-        this.writeCache = writeCache;
-        this.operationIndex = operationIndex;
-        this.documentMetaCache = documentMetaCache;
-        this.signatureVerifier = signatureVerifier;
-        this.config = {
-            maxSkipThreshold: config.maxSkipThreshold ?? MAX_SKIP_THRESHOLD,
-            maxConcurrency: config.maxConcurrency ?? 1,
-            jobTimeoutMs: config.jobTimeoutMs ?? 30000,
-            retryBaseDelayMs: config.retryBaseDelayMs ?? 100,
-            retryMaxDelayMs: config.retryMaxDelayMs ?? 5000,
-            legacyStorageEnabled: config.legacyStorageEnabled ?? true,
-        };
-    }
-    /**
-     * Execute a single job by applying all its actions through the appropriate reducers.
-     * Actions are processed sequentially in order.
-     */
-    async executeJob(job) {
-        const startTime = Date.now();
-        const indexTxn = this.operationIndex.start();
-        if (job.kind === "load") {
-            const result = await this.executeLoadJob(job, startTime, indexTxn);
-            if (result.success && result.operationsWithContext) {
-                const ordinals = await this.operationIndex.commit(indexTxn);
-                for (let i = 0; i < result.operationsWithContext.length; i++) {
-                    result.operationsWithContext[i].context.ordinal = ordinals[i];
-                }
-                if (result.operationsWithContext.length > 0) {
-                    const event = {
-                        jobId: job.id,
-                        operations: result.operationsWithContext,
-                        jobMeta: job.meta,
-                    };
-                    this.eventBus
-                        .emit(OperationEventTypes.OPERATION_WRITTEN, event)
-                        .catch(() => {
-                        // TODO: Log error
-                    });
-                }
-            }
-            return result;
-        }
-        const result = await this.processActions(job, job.actions, startTime, indexTxn);
-        if (!result.success) {
-            return {
-                job,
-                success: false,
-                error: result.error,
-                duration: Date.now() - startTime,
-            };
-        }
-        const ordinals = await this.operationIndex.commit(indexTxn);
-        if (result.operationsWithContext.length > 0) {
-            for (let i = 0; i < result.operationsWithContext.length; i++) {
-                result.operationsWithContext[i].context.ordinal = ordinals[i];
-            }
-            const event = {
-                jobId: job.id,
-                operations: result.operationsWithContext,
-                jobMeta: job.meta,
-            };
-            this.eventBus
-                .emit(OperationEventTypes.OPERATION_WRITTEN, event)
-                .catch(() => {
-                // TODO: Log error
-            });
-        }
-        return {
-            job,
-            success: true,
-            operations: result.generatedOperations,
-            operationsWithContext: result.operationsWithContext,
-            duration: Date.now() - startTime,
-        };
-    }
-    async processActions(job, actions, startTime, indexTxn, skipValues, sourceOperations) {
-        const generatedOperations = [];
-        const operationsWithContext = [];
-        try {
-            await this.verifyActionSignatures(job, actions);
-        }
-        catch (error) {
-            return {
-                success: false,
-                generatedOperations,
-                operationsWithContext,
-                error: error instanceof Error ? error : new Error(String(error)),
-            };
-        }
-        for (let actionIndex = 0; actionIndex < actions.length; actionIndex++) {
-            const action = actions[actionIndex];
-            const skip = skipValues?.[actionIndex] ?? 0;
-            const sourceOperation = sourceOperations?.[actionIndex];
-            const isDocumentAction = documentScopeActions.includes(action.type);
-            const result = isDocumentAction
-                ? await this.executeDocumentAction(job, action, startTime, indexTxn, skip)
-                : await this.executeRegularAction(job, action, startTime, indexTxn, skip, sourceOperation);
-            const error = this.accumulateResultOrReturnError(result, generatedOperations, operationsWithContext);
-            if (error !== null) {
-                return {
-                    success: false,
-                    generatedOperations,
-                    operationsWithContext,
-                    error: error.error,
-                };
-            }
-        }
-        return {
-            success: true,
-            generatedOperations,
-            operationsWithContext,
-        };
-    }
-    /**
-     * Execute a document scope action (CREATE_DOCUMENT, DELETE_DOCUMENT, UPGRADE_DOCUMENT,
-     * ADD_RELATIONSHIP, REMOVE_RELATIONSHIP) by dispatching to the appropriate handler.
-     */
-    async executeDocumentAction(job, action, startTime, indexTxn, skip = 0) {
-        switch (action.type) {
-            case "CREATE_DOCUMENT":
-                return this.executeCreateDocumentAction(job, action, startTime, indexTxn, skip);
-            case "DELETE_DOCUMENT":
-                return this.executeDeleteDocumentAction(job, action, startTime, indexTxn);
-            case "UPGRADE_DOCUMENT":
-                return this.executeUpgradeDocumentAction(job, action, startTime, indexTxn, skip);
-            case "ADD_RELATIONSHIP":
-                return this.executeAddRelationshipAction(job, action, startTime, indexTxn);
-            case "REMOVE_RELATIONSHIP":
-                return this.executeRemoveRelationshipAction(job, action, startTime, indexTxn);
-            default:
-                return this.buildErrorResult(job, new Error(`Unknown document action type: ${action.type}`), startTime);
-        }
-    }
-    /**
-     * Execute a CREATE_DOCUMENT system action.
-     * This creates a new document in storage along with its initial operation.
-     * For a new document, the operation index is always 0.
-     */
-    async executeCreateDocumentAction(job, action, startTime, indexTxn, skip = 0) {
-        if (job.scope !== "document") {
-            return {
-                job,
-                success: false,
-                error: new Error(`CREATE_DOCUMENT must be in "document" scope, got "${job.scope}"`),
-                duration: Date.now() - startTime,
-            };
-        }
-        const document = createDocumentFromAction(action);
-        // Legacy: Store the document in storage
-        if (this.config.legacyStorageEnabled) {
-            try {
-                await this.documentStorage.create(document);
-            }
-            catch (error) {
-                return this.buildErrorResult(job, new Error(`Failed to create document in storage: ${error instanceof Error ? error.message : String(error)}`), startTime);
-            }
-        }
-        const operation = this.createOperation(action, 0, skip, {
-            documentId: document.header.id,
-            scope: job.scope,
-            branch: job.branch,
-        });
-        // Legacy: Write the CREATE_DOCUMENT operation to legacy storage
-        if (this.config.legacyStorageEnabled) {
-            try {
-                await this.operationStorage.addDocumentOperations(document.header.id, [operation], document);
-            }
-            catch (error) {
-                return this.buildErrorResult(job, new Error(`Failed to write CREATE_DOCUMENT operation to legacy storage: ${error instanceof Error ? error.message : String(error)}`), startTime);
-            }
-        }
-        // Compute resultingState for passing via context (not persisted)
-        // Include header and all scopes present in the document state (auth, document, etc.)
-        // but not global/local which aren't initialized by CREATE_DOCUMENT
-        const resultingStateObj = {
-            header: document.header,
-            ...document.state,
-        };
-        const resultingState = JSON.stringify(resultingStateObj);
-        const writeError = await this.writeOperationToStore(document.header.id, document.header.documentType, job.scope, job.branch, operation, job, startTime);
-        if (writeError !== null) {
-            return writeError;
-        }
-        this.updateDocumentRevision(document, job.scope, operation.index);
-        this.writeCacheState(document.header.id, job.scope, job.branch, operation.index, document);
-        indexTxn.write([
-            {
-                ...operation,
-                documentId: document.header.id,
-                documentType: document.header.documentType,
-                branch: job.branch,
-                scope: job.scope,
-            },
-        ]);
-        // collection membership has to be _after_ the write, as it requires the
-        // ordinal of the operation to be set
-        if (document.header.documentType === "powerhouse/document-drive") {
-            const collectionId = driveCollectionId(job.branch, document.header.id);
-            indexTxn.createCollection(collectionId);
-            indexTxn.addToCollection(collectionId, document.header.id);
-        }
-        this.documentMetaCache.putDocumentMeta(document.header.id, job.branch, {
-            state: document.state.document,
-            documentType: document.header.documentType,
-            documentScopeRevision: 1,
-        });
-        return this.buildSuccessResult(job, operation, document.header.id, document.header.documentType, resultingState, startTime);
-    }
-    /**
-     * Execute a DELETE_DOCUMENT system action.
-     * This deletes a document from legacy storage and writes the operation to IOperationStore.
-     * The operation index is determined from the document's current operation count.
-     */
-    async executeDeleteDocumentAction(job, action, startTime, indexTxn) {
-        const input = action.input;
-        if (!input.documentId) {
-            return this.buildErrorResult(job, new Error("DELETE_DOCUMENT action requires a documentId in input"), startTime);
-        }
-        const documentId = input.documentId;
-        let document;
-        try {
-            document = await this.writeCache.getState(documentId, job.scope, job.branch);
-        }
-        catch (error) {
-            return this.buildErrorResult(job, new Error(`Failed to fetch document before deletion: ${error instanceof Error ? error.message : String(error)}`), startTime);
-        }
-        // Check if document is already deleted
-        const documentState = document.state.document;
-        if (documentState.isDeleted) {
-            return this.buildErrorResult(job, new DocumentDeletedError(documentId, documentState.deletedAtUtcIso), startTime);
-        }
-        const nextIndex = getNextIndexForScope(document, job.scope);
-        const operation = this.createOperation(action, nextIndex, 0, {
-            documentId,
-            scope: job.scope,
-            branch: job.branch,
-        });
-        if (this.config.legacyStorageEnabled) {
-            try {
-                await this.documentStorage.delete(documentId);
-            }
-            catch (error) {
-                return this.buildErrorResult(job, new Error(`Failed to delete document from legacy storage: ${error instanceof Error ? error.message : String(error)}`), startTime);
-            }
-        }
-        // Mark the document as deleted in the state for read model indexing
-        applyDeleteDocumentAction(document, action);
-        // Compute resultingState for passing via context (not persisted)
-        // DELETE_DOCUMENT only affects header and document scopes
-        const resultingStateObj = {
-            header: document.header,
-            document: document.state.document,
-        };
-        const resultingState = JSON.stringify(resultingStateObj);
-        const writeError = await this.writeOperationToStore(documentId, document.header.documentType, job.scope, job.branch, operation, job, startTime);
-        if (writeError !== null) {
-            return writeError;
-        }
-        indexTxn.write([
-            {
-                ...operation,
-                documentId: documentId,
-                documentType: document.header.documentType,
-                branch: job.branch,
-                scope: job.scope,
-            },
-        ]);
-        this.documentMetaCache.putDocumentMeta(documentId, job.branch, {
-            state: document.state.document,
-            documentType: document.header.documentType,
-            documentScopeRevision: operation.index + 1,
-        });
-        return this.buildSuccessResult(job, operation, documentId, document.header.documentType, resultingState, startTime);
-    }
-    /**
-     * Execute an UPGRADE_DOCUMENT system action.
-     * Handles initial upgrades (version 0 to N), same-version no-ops, and multi-step upgrade chains.
-     * The operation index is determined from the document's current operation count.
-     */
-    async executeUpgradeDocumentAction(job, action, startTime, indexTxn, skip = 0) {
-        const input = action.input;
-        if (!input.documentId) {
-            return this.buildErrorResult(job, new Error("UPGRADE_DOCUMENT action requires a documentId in input"), startTime);
-        }
-        const documentId = input.documentId;
-        const fromVersion = input.fromVersion;
-        const toVersion = input.toVersion;
-        let document;
-        try {
-            document = await this.writeCache.getState(documentId, job.scope, job.branch);
-        }
-        catch (error) {
-            return this.buildErrorResult(job, new Error(`Failed to fetch document for upgrade: ${error instanceof Error ? error.message : String(error)}`), startTime);
-        }
-        const documentState = document.state.document;
-        if (documentState.isDeleted) {
-            return this.buildErrorResult(job, new DocumentDeletedError(documentId, documentState.deletedAtUtcIso), startTime);
-        }
-        const nextIndex = getNextIndexForScope(document, job.scope);
-        let upgradePath;
-        if (fromVersion > 0 && fromVersion < toVersion) {
-            try {
-                upgradePath = this.registry.computeUpgradePath(document.header.documentType, fromVersion, toVersion);
-            }
-            catch (error) {
-                return this.buildErrorResult(job, error instanceof Error ? error : new Error(String(error)), startTime);
-            }
-        }
-        if (fromVersion === toVersion && fromVersion > 0) {
-            return {
-                job,
-                success: true,
-                operations: [],
-                operationsWithContext: [],
-                duration: Date.now() - startTime,
-            };
-        }
-        try {
-            document = applyUpgradeDocumentAction(document, action, upgradePath);
-        }
-        catch (error) {
-            return this.buildErrorResult(job, error instanceof Error ? error : new Error(String(error)), startTime);
-        }
-        const operation = this.createOperation(action, nextIndex, skip, {
-            documentId,
-            scope: job.scope,
-            branch: job.branch,
-        });
-        // Write the updated document to legacy storage
-        if (this.config.legacyStorageEnabled) {
-            try {
-                await this.operationStorage.addDocumentOperations(documentId, [operation], document);
-            }
-            catch (error) {
-                return this.buildErrorResult(job, new Error(`Failed to write UPGRADE_DOCUMENT operation to legacy storage: ${error instanceof Error ? error.message : String(error)}`), startTime);
-            }
-        }
-        // Compute resultingState for passing via context (not persisted)
-        const resultingStateObj = {
-            header: document.header,
-            ...document.state,
-        };
-        const resultingState = JSON.stringify(resultingStateObj);
-        const writeError = await this.writeOperationToStore(documentId, document.header.documentType, job.scope, job.branch, operation, job, startTime);
-        if (writeError !== null) {
-            return writeError;
-        }
-        this.updateDocumentRevision(document, job.scope, operation.index);
-        this.writeCacheState(documentId, job.scope, job.branch, operation.index, document);
-        indexTxn.write([
-            {
-                ...operation,
-                documentId: documentId,
-                documentType: document.header.documentType,
-                branch: job.branch,
-                scope: job.scope,
-            },
-        ]);
-        this.documentMetaCache.putDocumentMeta(documentId, job.branch, {
-            state: document.state.document,
-            documentType: document.header.documentType,
-            documentScopeRevision: operation.index + 1,
-        });
-        return this.buildSuccessResult(job, operation, documentId, document.header.documentType, resultingState, startTime);
-    }
-    async executeAddRelationshipAction(job, action, startTime, indexTxn) {
-        if (job.scope !== "document") {
-            return this.buildErrorResult(job, new Error(`ADD_RELATIONSHIP must be in "document" scope, got "${job.scope}"`), startTime);
-        }
-        const input = action.input;
-        if (!input.sourceId || !input.targetId || !input.relationshipType) {
-            return this.buildErrorResult(job, new Error("ADD_RELATIONSHIP action requires sourceId, targetId, and relationshipType in input"), startTime);
-        }
-        if (input.sourceId === input.targetId) {
-            return this.buildErrorResult(job, new Error("ADD_RELATIONSHIP: sourceId and targetId cannot be the same (self-relationships not allowed)"), startTime);
-        }
-        let sourceDoc;
-        try {
-            sourceDoc = await this.writeCache.getState(input.sourceId, "document", job.branch);
-        }
-        catch (error) {
-            return this.buildErrorResult(job, new Error(`ADD_RELATIONSHIP: source document ${input.sourceId} not found: ${error instanceof Error ? error.message : String(error)}`), startTime);
-        }
-        const nextIndex = getNextIndexForScope(sourceDoc, job.scope);
-        const operation = this.createOperation(action, nextIndex, 0, {
-            documentId: input.sourceId,
-            scope: job.scope,
-            branch: job.branch,
-        });
-        const writeError = await this.writeOperationToStore(input.sourceId, sourceDoc.header.documentType, job.scope, job.branch, operation, job, startTime);
-        if (writeError !== null) {
-            return writeError;
-        }
-        sourceDoc.header.lastModifiedAtUtcIso =
-            operation.timestampUtcMs || new Date().toISOString();
-        this.updateDocumentRevision(sourceDoc, job.scope, operation.index);
-        sourceDoc.operations = {
-            ...sourceDoc.operations,
-            [job.scope]: [...(sourceDoc.operations[job.scope] ?? []), operation],
-        };
-        const scopeState = sourceDoc.state[job.scope];
-        const resultingStateObj = {
-            header: structuredClone(sourceDoc.header),
-            [job.scope]: scopeState === undefined ? {} : structuredClone(scopeState),
-        };
-        const resultingState = JSON.stringify(resultingStateObj);
-        this.writeCacheState(input.sourceId, job.scope, job.branch, operation.index, sourceDoc);
-        indexTxn.write([
-            {
-                ...operation,
-                documentId: input.sourceId,
-                documentType: sourceDoc.header.documentType,
-                branch: job.branch,
-                scope: job.scope,
-            },
-        ]);
-        // collection membership has to be _after_ the write, as it requires the
-        // ordinal of the operation to be set
-        if (sourceDoc.header.documentType === "powerhouse/document-drive") {
-            const collectionId = driveCollectionId(job.branch, input.sourceId);
-            indexTxn.addToCollection(collectionId, input.targetId);
-        }
-        this.documentMetaCache.putDocumentMeta(input.sourceId, job.branch, {
-            state: sourceDoc.state.document,
-            documentType: sourceDoc.header.documentType,
-            documentScopeRevision: operation.index + 1,
-        });
-        return this.buildSuccessResult(job, operation, input.sourceId, sourceDoc.header.documentType, resultingState, startTime);
-    }
-    async executeRemoveRelationshipAction(job, action, startTime, indexTxn) {
-        if (job.scope !== "document") {
-            return this.buildErrorResult(job, new Error(`REMOVE_RELATIONSHIP must be in "document" scope, got "${job.scope}"`), startTime);
-        }
-        const input = action.input;
-        if (!input.sourceId || !input.targetId || !input.relationshipType) {
-            return this.buildErrorResult(job, new Error("REMOVE_RELATIONSHIP action requires sourceId, targetId, and relationshipType in input"), startTime);
-        }
-        let sourceDoc;
-        try {
-            sourceDoc = await this.writeCache.getState(input.sourceId, "document", job.branch);
-        }
-        catch (error) {
-            return this.buildErrorResult(job, new Error(`REMOVE_RELATIONSHIP: source document ${input.sourceId} not found: ${error instanceof Error ? error.message : String(error)}`), startTime);
-        }
-        const nextIndex = getNextIndexForScope(sourceDoc, job.scope);
-        const operation = this.createOperation(action, nextIndex, 0, {
-            documentId: input.sourceId,
-            scope: job.scope,
-            branch: job.branch,
-        });
-        const writeError = await this.writeOperationToStore(input.sourceId, sourceDoc.header.documentType, job.scope, job.branch, operation, job, startTime);
-        if (writeError !== null) {
-            return writeError;
-        }
-        sourceDoc.header.lastModifiedAtUtcIso =
-            operation.timestampUtcMs || new Date().toISOString();
-        this.updateDocumentRevision(sourceDoc, job.scope, operation.index);
-        sourceDoc.operations = {
-            ...sourceDoc.operations,
-            [job.scope]: [...(sourceDoc.operations[job.scope] ?? []), operation],
-        };
-        const scopeState = sourceDoc.state[job.scope];
-        const resultingStateObj = {
-            header: structuredClone(sourceDoc.header),
-            [job.scope]: scopeState === undefined ? {} : structuredClone(scopeState),
-        };
-        const resultingState = JSON.stringify(resultingStateObj);
-        this.writeCacheState(input.sourceId, job.scope, job.branch, operation.index, sourceDoc);
-        indexTxn.write([
-            {
-                ...operation,
-                documentId: input.sourceId,
-                documentType: sourceDoc.header.documentType,
-                branch: job.branch,
-                scope: job.scope,
-            },
-        ]);
-        // collection membership has to be _after_ the write, as it requires the
-        // ordinal of the operation to be set
-        if (sourceDoc.header.documentType === "powerhouse/document-drive") {
-            const collectionId = driveCollectionId(job.branch, input.sourceId);
-            indexTxn.removeFromCollection(collectionId, input.targetId);
-        }
-        this.documentMetaCache.putDocumentMeta(input.sourceId, job.branch, {
-            state: sourceDoc.state.document,
-            documentType: sourceDoc.header.documentType,
-            documentScopeRevision: operation.index + 1,
-        });
-        return this.buildSuccessResult(job, operation, input.sourceId, sourceDoc.header.documentType, resultingState, startTime);
-    }
-    /**
-     * Execute a regular document action by applying it through the document model reducer.
-     * If sourceOperation is provided (for load jobs), its id and timestamp are preserved.
-     */
-    async executeRegularAction(job, action, startTime, indexTxn, skip = 0, sourceOperation) {
-        let docMeta;
-        try {
-            docMeta = await this.documentMetaCache.getDocumentMeta(job.documentId, job.branch);
-        }
-        catch (error) {
-            return this.buildErrorResult(job, error instanceof Error ? error : new Error(String(error)), startTime);
-        }
-        if (docMeta.state.isDeleted) {
-            return this.buildErrorResult(job, new DocumentDeletedError(job.documentId, docMeta.state.deletedAtUtcIso), startTime);
-        }
-        let document;
-        try {
-            document = await this.writeCache.getState(job.documentId, job.scope, job.branch);
-        }
-        catch (error) {
-            return this.buildErrorResult(job, error instanceof Error ? error : new Error(String(error)), startTime);
-        }
-        let module;
-        try {
-            // Use document version to get the correct module
-            // Version 0 means not yet upgraded - use latest version
-            const moduleVersion = docMeta.state.version === 0 ? undefined : docMeta.state.version;
-            module = this.registry.getModule(document.header.documentType, moduleVersion);
-        }
-        catch (error) {
-            return this.buildErrorResult(job, error instanceof Error ? error : new Error(String(error)), startTime);
-        }
-        let updatedDocument;
-        try {
-            const protocolVersion = document.header.protocolVersions?.["base-reducer"] ?? 1;
-            const reducerOptions = sourceOperation
-                ? {
-                    skip,
-                    branch: job.branch,
-                    replayOptions: { operation: sourceOperation },
-                    protocolVersion,
-                }
-                : { skip, branch: job.branch, protocolVersion };
-            updatedDocument = module.reducer(document, action, undefined, reducerOptions);
-        }
-        catch (error) {
-            const contextMessage = `Failed to apply action to document:\n  Action type: ${action.type}\n  Document ID: ${job.documentId}\n  Document type: ${document.header.documentType}\n  Scope: ${job.scope}\n  Original error: ${error instanceof Error ? error.message : String(error)}`;
-            const enhancedError = new Error(contextMessage);
-            if (error instanceof Error && error.stack) {
-                enhancedError.stack = `${contextMessage}\n\nOriginal stack trace:\n${error.stack}`;
-            }
-            return this.buildErrorResult(job, enhancedError, startTime);
-        }
-        const scope = job.scope;
-        const operations = updatedDocument.operations[scope];
-        if (operations.length === 0) {
-            return this.buildErrorResult(job, new Error("No operation generated from action"), startTime);
-        }
-        const newOperation = operations[operations.length - 1];
-        if (!isUndoRedo(action)) {
-            newOperation.skip = skip;
-        }
-        if (this.config.legacyStorageEnabled) {
-            try {
-                await this.operationStorage.addDocumentOperations(job.documentId, [newOperation], updatedDocument);
-            }
-            catch (error) {
-                return this.buildErrorResult(job, error instanceof Error ? error : new Error(String(error)), startTime);
-            }
-        }
-        const resultingState = JSON.stringify({
-            ...updatedDocument.state,
-            header: updatedDocument.header,
-        });
-        const writeFailResult = await this.writeOperationToStore(job.documentId, document.header.documentType, scope, job.branch, newOperation, job, startTime);
-        if (writeFailResult !== null) {
-            return writeFailResult;
-        }
-        updatedDocument.header.revision = {
-            ...updatedDocument.header.revision,
-            [scope]: newOperation.index + 1,
-        };
-        this.writeCache.putState(job.documentId, scope, job.branch, newOperation.index, updatedDocument);
-        indexTxn.write([
-            {
-                ...newOperation,
-                documentId: job.documentId,
-                documentType: document.header.documentType,
-                branch: job.branch,
-                scope,
-            },
-        ]);
-        return {
-            job,
-            success: true,
-            operations: [newOperation],
-            operationsWithContext: [
-                {
-                    operation: newOperation,
-                    context: {
-                        documentId: job.documentId,
-                        scope,
-                        branch: job.branch,
-                        documentType: document.header.documentType,
-                        resultingState,
-                        ordinal: 0,
-                    },
-                },
-            ],
-            duration: Date.now() - startTime,
-        };
-    }
-    createOperation(action, index, skip = 0, context) {
-        const id = deriveOperationId(context.documentId, context.scope, context.branch, action.id);
-        return {
-            id,
-            index: index,
-            timestampUtcMs: action.timestampUtcMs || new Date().toISOString(),
-            hash: "",
-            skip: skip,
-            action: action,
-        };
-    }
-    async executeLoadJob(job, startTime, indexTxn) {
-        if (job.operations.length === 0) {
-            return this.buildErrorResult(job, new Error("Load job must include at least one operation"), startTime);
-        }
-        const scope = job.scope;
-        let latestRevision = 0;
-        try {
-            const revisions = await this.operationStore.getRevisions(job.documentId, job.branch);
-            latestRevision = revisions.revision[scope] ?? 0;
-        }
-        catch {
-            latestRevision = 0;
-        }
-        let minIncomingIndex = Number.POSITIVE_INFINITY;
-        let minIncomingTimestamp = job.operations[0]?.timestampUtcMs || "";
-        for (const operation of job.operations) {
-            minIncomingIndex = Math.min(minIncomingIndex, operation.index);
-            const ts = operation.timestampUtcMs || "";
-            if (ts < minIncomingTimestamp) {
-                minIncomingTimestamp = ts;
-            }
-        }
-        let conflictingOps = [];
-        try {
-            const conflictingResult = await this.operationStore.getConflicting(job.documentId, scope, job.branch, minIncomingTimestamp, { limit: this.config.maxSkipThreshold + 1 });
-            if (conflictingResult.hasMore) {
-                return {
-                    job,
-                    success: false,
-                    error: new Error(`Excessive reshuffle detected: more than ${this.config.maxSkipThreshold} conflicting operations found. ` +
-                        `This indicates a significant divergence between local and incoming operations.`),
-                    duration: Date.now() - startTime,
-                };
-            }
-            conflictingOps = conflictingResult.items;
-        }
-        catch {
-            conflictingOps = [];
-        }
-        // Filter out operations that have been superseded by later operations with skip values.
-        // An operation at index N is superseded if there exists an operation at index M > N
-        // where (M - skip_M) <= N, meaning the later operation's logical index covers N.
-        const nonSupersededOps = conflictingOps.filter((op) => {
-            for (const laterOp of conflictingOps) {
-                if (laterOp.index > op.index && laterOp.skip > 0) {
-                    const logicalIndex = laterOp.index - laterOp.skip;
-                    if (logicalIndex <= op.index) {
-                        return false;
-                    }
-                }
-            }
-            return true;
-        });
-        // All non-superseded conflicting operations need to be reshuffled
-        const existingOpsToReshuffle = nonSupersededOps;
-        // Skip count is the number of existing operations that need to be rewound
-        const skipCount = existingOpsToReshuffle.length;
-        if (skipCount > this.config.maxSkipThreshold) {
-            return {
-                job,
-                success: false,
-                error: new Error(`Excessive reshuffle detected: skip count of ${skipCount} exceeds threshold of ${this.config.maxSkipThreshold}. ` +
-                    `This indicates a significant divergence between local and incoming operations.`),
-                duration: Date.now() - startTime,
-            };
-        }
-        // Filter out incoming operations that are duplicates (action already exists locally
-        // or appears multiple times in incoming)
-        const existingActionIds = new Set(nonSupersededOps.map((op) => op.action.id));
-        const seenIncomingActionIds = new Set();
-        const incomingOpsToApply = job.operations.filter((op) => {
-            if (existingActionIds.has(op.action.id))
-                return false;
-            if (seenIncomingActionIds.has(op.action.id))
-                return false;
-            seenIncomingActionIds.add(op.action.id);
-            return true;
-        });
-        const reshuffledOperations = reshuffleByTimestamp({
-            index: latestRevision,
-            skip: skipCount,
-        }, existingOpsToReshuffle, incomingOpsToApply.map((operation) => ({
-            ...operation,
-            id: operation.id,
-        })));
-        // For v2, all NOOPs have skip=1 - consecutive NOOPs are handled during state rebuild
-        for (const operation of reshuffledOperations) {
-            if (operation.action.type === "NOOP") {
-                operation.skip = 1;
-            }
-        }
-        const actions = reshuffledOperations.map((operation) => operation.action);
-        const skipValues = reshuffledOperations.map((operation) => operation.skip);
-        const result = await this.processActions(job, actions, startTime, indexTxn, skipValues, reshuffledOperations);
-        if (!result.success) {
-            return {
-                job,
-                success: false,
-                error: result.error,
-                duration: Date.now() - startTime,
-            };
-        }
-        this.writeCache.invalidate(job.documentId, scope, job.branch);
-        if (scope === "document") {
-            this.documentMetaCache.invalidate(job.documentId, job.branch);
-        }
-        return {
-            job,
-            success: true,
-            operations: result.generatedOperations,
-            operationsWithContext: result.operationsWithContext,
-            duration: Date.now() - startTime,
-        };
-    }
-    async writeOperationToStore(documentId, documentType, scope, branch, operation, job, startTime) {
-        try {
-            await this.operationStore.apply(documentId, documentType, scope, branch, operation.index, (txn) => {
-                txn.addOperations(operation);
-            });
-            return null;
-        }
-        catch (error) {
-            this.logger.error("Error writing @Operation to IOperationStore: @Error", operation, error);
-            this.writeCache.invalidate(documentId, scope, branch);
-            return {
-                job,
-                success: false,
-                error: new Error(`Failed to write operation to IOperationStore: ${error instanceof Error ? error.message : String(error)}`),
-                duration: Date.now() - startTime,
-            };
-        }
-    }
-    updateDocumentRevision(document, scope, operationIndex) {
-        document.header.revision = {
-            ...document.header.revision,
-            [scope]: operationIndex + 1,
-        };
-    }
-    writeCacheState(documentId, scope, branch, operationIndex, document) {
-        this.writeCache.putState(documentId, scope, branch, operationIndex, document);
-    }
-    buildSuccessResult(job, operation, documentId, documentType, resultingState, startTime) {
-        return {
-            job,
-            success: true,
-            operations: [operation],
-            operationsWithContext: [
-                {
-                    operation,
-                    context: {
-                        documentId: documentId,
-                        scope: job.scope,
-                        branch: job.branch,
-                        documentType: documentType,
-                        resultingState,
-                        ordinal: 0,
-                    },
-                },
-            ],
-            duration: Date.now() - startTime,
-        };
-    }
-    buildErrorResult(job, error, startTime) {
-        return {
-            job,
-            success: false,
-            error: error,
-            duration: Date.now() - startTime,
-        };
-    }
-    async verifyOperationSignatures(job, operations) {
-        if (!this.signatureVerifier) {
-            return;
-        }
-        for (let i = 0; i < operations.length; i++) {
-            const operation = operations[i];
-            const signer = operation.action.context?.signer;
-            if (!signer) {
-                continue;
-            }
-            if (signer.signatures.length === 0) {
-                throw new InvalidSignatureError(job.documentId, `Operation ${operation.id} at index ${operation.index} has signer but no signatures`);
-            }
-            const publicKey = signer.app.key;
-            let isValid = false;
-            try {
-                isValid = await this.signatureVerifier(operation, publicKey);
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                throw new InvalidSignatureError(job.documentId, `Operation ${operation.id} at index ${operation.index} verification failed: ${errorMessage}`);
-            }
-            if (!isValid) {
-                throw new InvalidSignatureError(job.documentId, `Operation ${operation.id} at index ${operation.index} signature verification returned false`);
-            }
-        }
-    }
-    async verifyActionSignatures(job, actions) {
-        if (!this.signatureVerifier) {
-            return;
-        }
-        for (const action of actions) {
-            const signer = action.context?.signer;
-            if (!signer) {
-                continue;
-            }
-            if (signer.signatures.length === 0) {
-                throw new InvalidSignatureError(job.documentId, `Action ${action.id} has signer but no signatures`);
-            }
-            const publicKey = signer.app.key;
-            let isValid = false;
-            try {
-                const tempOperation = {
-                    id: deriveOperationId(job.documentId, action.scope, job.branch, action.id),
-                    index: 0,
-                    timestampUtcMs: action.timestampUtcMs || new Date().toISOString(),
-                    hash: "",
-                    skip: 0,
-                    action: action,
-                };
-                isValid = await this.signatureVerifier(tempOperation, publicKey);
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                throw new InvalidSignatureError(job.documentId, `Action ${action.id} verification failed: ${errorMessage}`);
-            }
-            if (!isValid) {
-                throw new InvalidSignatureError(job.documentId, `Action ${action.id} signature verification returned false`);
-            }
-        }
-    }
-    accumulateResultOrReturnError(result, generatedOperations, operationsWithContext) {
-        if (!result.success) {
-            return result;
-        }
-        if (result.operations && result.operations.length > 0) {
-            generatedOperations.push(...result.operations);
-        }
-        if (result.operationsWithContext) {
-            operationsWithContext.push(...result.operationsWithContext);
-        }
-        return null;
-    }
-}
-//# sourceMappingURL=simple-job-executor.js.map