@powerhousedao/reactor 5.0.3 → 5.0.5

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

@@ -1,6 +1,9 @@
-import { OperationEventTypes } from "../events/types.js";
+import { driveCollectionId } from "../cache/operation-index-types.js";
+import { OperationEventTypes, } from "../events/types.js";
 import { DocumentDeletedError } from "../shared/errors.js";
+import { reshuffleByTimestampAndIndex } from "../utils/reshuffle.js";
 import { applyDeleteDocumentAction, applyUpgradeDocumentAction, createDocumentFromAction, getNextIndexForScope, } from "./util.js";
+const MAX_SKIP_THRESHOLD = 100;
 /**
  * Simple job executor that processes a job by applying actions through document model reducers.
  *
@@ -15,13 +18,23 @@ export class SimpleJobExecutor {
     operationStore;
     eventBus;
     writeCache;
-    constructor(registry, documentStorage, operationStorage, operationStore, eventBus, writeCache) {
+    operationIndex;
+    config;
+    constructor(registry, documentStorage, operationStorage, operationStore, eventBus, writeCache, operationIndex, config) {
         this.registry = registry;
         this.documentStorage = documentStorage;
         this.operationStorage = operationStorage;
         this.operationStore = operationStore;
         this.eventBus = eventBus;
         this.writeCache = writeCache;
+        this.operationIndex = operationIndex;
+        this.config = {
+            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.
@@ -29,71 +42,137 @@ export class SimpleJobExecutor {
      */
     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) {
+                await this.operationIndex.commit(indexTxn);
+            }
+            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,
+            };
+        }
+        await this.operationIndex.commit(indexTxn);
+        if (result.operationsWithContext.length > 0) {
+            const event = {
+                jobId: job.id,
+                operations: result.operationsWithContext,
+            };
+            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) {
         const generatedOperations = [];
         const operationsWithContext = [];
-        // Process each action in the job sequentially
-        for (const action of job.actions) {
-            // Handle system actions specially (CREATE_DOCUMENT, DELETE_DOCUMENT, etc.)
+        let actionIndex = 0;
+        for (const action of actions) {
             if (action.type === "CREATE_DOCUMENT") {
-                const result = await this.executeCreateDocumentAction(job, action, startTime);
-                if (!result.success) {
-                    return result;
-                }
-                if (result.operations && result.operations.length > 0) {
-                    generatedOperations.push(...result.operations);
-                }
-                if (result.operationsWithContext) {
-                    operationsWithContext.push(...result.operationsWithContext);
+                const result = await this.executeCreateDocumentAction(job, action, startTime, indexTxn, skipValues?.[actionIndex]);
+                const error = this.accumulateResultOrReturnError(result, generatedOperations, operationsWithContext);
+                if (error !== null) {
+                    return {
+                        success: false,
+                        generatedOperations,
+                        operationsWithContext,
+                        error: error.error,
+                    };
                 }
+                actionIndex++;
                 continue;
             }
             if (action.type === "DELETE_DOCUMENT") {
-                const result = await this.executeDeleteDocumentAction(job, action, startTime);
-                if (!result.success) {
-                    return result;
-                }
-                if (result.operations && result.operations.length > 0) {
-                    generatedOperations.push(...result.operations);
-                }
-                if (result.operationsWithContext) {
-                    operationsWithContext.push(...result.operationsWithContext);
+                const result = await this.executeDeleteDocumentAction(job, action, startTime, indexTxn);
+                const error = this.accumulateResultOrReturnError(result, generatedOperations, operationsWithContext);
+                if (error !== null) {
+                    return {
+                        success: false,
+                        generatedOperations,
+                        operationsWithContext,
+                        error: error.error,
+                    };
                 }
+                actionIndex++;
                 continue;
             }
             if (action.type === "UPGRADE_DOCUMENT") {
-                const result = await this.executeUpgradeDocumentAction(job, action, startTime);
-                if (!result.success) {
-                    return result;
+                const result = await this.executeUpgradeDocumentAction(job, action, startTime, indexTxn, skipValues?.[actionIndex]);
+                const error = this.accumulateResultOrReturnError(result, generatedOperations, operationsWithContext);
+                if (error !== null) {
+                    return {
+                        success: false,
+                        generatedOperations,
+                        operationsWithContext,
+                        error: error.error,
+                    };
                 }
-                if (result.operations && result.operations.length > 0) {
-                    generatedOperations.push(...result.operations);
+                actionIndex++;
+                continue;
+            }
+            if (action.type === "ADD_RELATIONSHIP") {
+                const result = await this.executeAddRelationshipAction(job, action, startTime, indexTxn);
+                const error = this.accumulateResultOrReturnError(result, generatedOperations, operationsWithContext);
+                if (error !== null) {
+                    return {
+                        success: false,
+                        generatedOperations,
+                        operationsWithContext,
+                        error: error.error,
+                    };
                 }
-                if (result.operationsWithContext) {
-                    operationsWithContext.push(...result.operationsWithContext);
+                actionIndex++;
+                continue;
+            }
+            if (action.type === "REMOVE_RELATIONSHIP") {
+                const result = await this.executeRemoveRelationshipAction(job, action, startTime, indexTxn);
+                const error = this.accumulateResultOrReturnError(result, generatedOperations, operationsWithContext);
+                if (error !== null) {
+                    return {
+                        success: false,
+                        generatedOperations,
+                        operationsWithContext,
+                        error: error.error,
+                    };
                 }
+                actionIndex++;
                 continue;
             }
-            // For regular actions, load the document and apply through reducer
             let document;
             try {
                 document = await this.writeCache.getState(job.documentId, job.scope, job.branch);
             }
             catch (error) {
                 return {
-                    job,
                     success: false,
+                    generatedOperations,
+                    operationsWithContext,
                     error: error instanceof Error ? error : new Error(String(error)),
-                    duration: Date.now() - startTime,
                 };
             }
-            // Check if document is deleted
             const documentState = document.state.document;
             if (documentState.isDeleted) {
                 return {
-                    job,
                     success: false,
+                    generatedOperations,
+                    operationsWithContext,
                     error: new DocumentDeletedError(job.documentId, documentState.deletedAtUtcIso),
-                    duration: Date.now() - startTime,
                 };
             }
             let module;
@@ -102,10 +181,10 @@ export class SimpleJobExecutor {
             }
             catch (error) {
                 return {
-                    job,
                     success: false,
+                    generatedOperations,
+                    operationsWithContext,
                     error: error instanceof Error ? error : new Error(String(error)),
-                    duration: Date.now() - startTime,
                 };
             }
             let updatedDocument;
@@ -119,34 +198,41 @@ export class SimpleJobExecutor {
                     enhancedError.stack = `${contextMessage}\n\nOriginal stack trace:\n${error.stack}`;
                 }
                 return {
-                    job,
                     success: false,
+                    generatedOperations,
+                    operationsWithContext,
                     error: enhancedError,
-                    duration: Date.now() - startTime,
                 };
             }
             const scope = job.scope;
             const operations = updatedDocument.operations[scope];
             if (operations.length === 0) {
-                throw new Error("No operation generated from action");
-            }
-            const newOperation = operations[operations.length - 1];
-            generatedOperations.push(newOperation);
-            // Write the operation to legacy storage
-            try {
-                await this.operationStorage.addDocumentOperations(job.documentId, [newOperation], updatedDocument);
-            }
-            catch (error) {
                 return {
-                    job,
                     success: false,
-                    error: error instanceof Error ? error : new Error(String(error)),
-                    duration: Date.now() - startTime,
+                    generatedOperations,
+                    operationsWithContext,
+                    error: new Error("No operation generated from action"),
                 };
             }
-            // Compute resultingState for passing via context (not persisted)
+            const newOperation = operations[operations.length - 1];
+            if (skipValues && actionIndex < skipValues.length) {
+                newOperation.skip = skipValues[actionIndex];
+            }
+            generatedOperations.push(newOperation);
+            if (this.config.legacyStorageEnabled) {
+                try {
+                    await this.operationStorage.addDocumentOperations(job.documentId, [newOperation], updatedDocument);
+                }
+                catch (error) {
+                    return {
+                        success: false,
+                        generatedOperations,
+                        operationsWithContext,
+                        error: error instanceof Error ? error : new Error(String(error)),
+                    };
+                }
+            }
             const resultingState = JSON.stringify(updatedDocument.state);
-            // Write the operation to new IOperationStore (dual-writing)
             try {
                 await this.operationStore.apply(job.documentId, document.header.documentType, scope, job.branch, newOperation.index, (txn) => {
                     txn.addOperations(newOperation);
@@ -154,10 +240,10 @@ export class SimpleJobExecutor {
             }
             catch (error) {
                 return {
-                    job,
                     success: false,
+                    generatedOperations,
+                    operationsWithContext,
                     error: new Error(`Failed to write operation to IOperationStore: ${error instanceof Error ? error.message : String(error)}`),
-                    duration: Date.now() - startTime,
                 };
             }
             updatedDocument.header.revision = {
@@ -172,25 +258,15 @@ export class SimpleJobExecutor {
                     scope,
                     branch: job.branch,
                     documentType: document.header.documentType,
-                    resultingState, // Ephemeral, passed via events only
+                    resultingState,
                 },
             });
-        }
-        // Emit event for read models with all operations - non-blocking
-        if (operationsWithContext.length > 0) {
-            this.eventBus
-                .emit(OperationEventTypes.OPERATION_WRITTEN, {
-                operations: operationsWithContext,
-            })
-                .catch(() => {
-                // TODO: Log error
-            });
+            actionIndex++;
         }
         return {
-            job,
             success: true,
-            operations: generatedOperations,
-            duration: Date.now() - startTime,
+            generatedOperations,
+            operationsWithContext,
         };
     }
     /**
@@ -198,7 +274,7 @@ export class SimpleJobExecutor {
      * 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) {
+    async executeCreateDocumentAction(job, action, startTime, indexTxn, skip = 0) {
         if (job.scope !== "document") {
             return {
                 job,
@@ -209,36 +285,23 @@ export class SimpleJobExecutor {
         }
         const document = createDocumentFromAction(action);
         // Legacy: Store the document in storage
-        try {
-            await this.documentStorage.create(document);
-        }
-        catch (error) {
-            return {
-                job,
-                success: false,
-                error: new Error(`Failed to create document in storage: ${error instanceof Error ? error.message : String(error)}`),
-                duration: Date.now() - startTime,
-            };
+        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);
+            }
         }
-        // Create the operation with index 0 (first operation for a new document)
-        const operation = {
-            index: 0,
-            timestampUtcMs: action.timestampUtcMs || new Date().toISOString(),
-            hash: "", // Will be computed later
-            skip: 0, // Always 0 for new operations; skip > 0 only during reshuffle
-            action: action,
-        };
+        const operation = this.createOperation(action, 0, skip);
         // Legacy: Write the CREATE_DOCUMENT operation to legacy storage
-        try {
-            await this.operationStorage.addDocumentOperations(document.header.id, [operation], document);
-        }
-        catch (error) {
-            return {
-                job,
-                success: false,
-                error: new Error(`Failed to write CREATE_DOCUMENT operation to legacy storage: ${error instanceof Error ? error.message : String(error)}`),
-                duration: Date.now() - startTime,
-            };
+        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.)
@@ -248,59 +311,39 @@ export class SimpleJobExecutor {
             ...document.state,
         };
         const resultingState = JSON.stringify(resultingStateObj);
-        // Write the operation to new IOperationStore (dual-writing)
-        // Note: resultingState is NOT persisted in IOperationStore
-        try {
-            await this.operationStore.apply(document.header.id, document.header.documentType, job.scope, job.branch, operation.index, (txn) => {
-                txn.addOperations(operation);
-            });
+        const writeError = await this.writeOperationToStore(document.header.id, document.header.documentType, job.scope, job.branch, operation, job, startTime);
+        if (writeError !== null) {
+            return writeError;
         }
-        catch (error) {
-            return {
-                job,
-                success: false,
-                error: new Error(`Failed to write CREATE_DOCUMENT operation to IOperationStore: ${error instanceof Error ? error.message : String(error)}`),
-                duration: Date.now() - startTime,
-            };
+        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);
         }
-        document.header.revision = {
-            ...document.header.revision,
-            [job.scope]: operation.index + 1,
-        };
-        this.writeCache.putState(document.header.id, job.scope, job.branch, operation.index, document);
-        return {
-            job,
-            success: true,
-            operations: [operation],
-            operationsWithContext: [
-                {
-                    operation,
-                    context: {
-                        documentId: document.header.id,
-                        scope: job.scope,
-                        branch: job.branch,
-                        documentType: document.header.documentType,
-                        resultingState,
-                    },
-                },
-            ],
-            duration: Date.now() - startTime,
-        };
+        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) {
+    async executeDeleteDocumentAction(job, action, startTime, indexTxn) {
         const input = action.input;
         if (!input.documentId) {
-            return {
-                job,
-                success: false,
-                error: new Error("DELETE_DOCUMENT action requires a documentId in input"),
-                duration: Date.now() - startTime,
-            };
+            return this.buildErrorResult(job, new Error("DELETE_DOCUMENT action requires a documentId in input"), startTime);
         }
         const documentId = input.documentId;
         let document;
@@ -308,43 +351,22 @@ export class SimpleJobExecutor {
             document = await this.writeCache.getState(documentId, job.scope, job.branch);
         }
         catch (error) {
-            return {
-                job,
-                success: false,
-                error: new Error(`Failed to fetch document before deletion: ${error instanceof Error ? error.message : String(error)}`),
-                duration: Date.now() - startTime,
-            };
+            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 {
-                job,
-                success: false,
-                error: new DocumentDeletedError(documentId, documentState.deletedAtUtcIso),
-                duration: Date.now() - startTime,
-            };
+            return this.buildErrorResult(job, new DocumentDeletedError(documentId, documentState.deletedAtUtcIso), startTime);
         }
-        // Determine the next operation index for this scope only (per-scope indexing)
         const nextIndex = getNextIndexForScope(document, job.scope);
-        // Create the DELETE_DOCUMENT operation
-        const operation = {
-            index: nextIndex,
-            timestampUtcMs: action.timestampUtcMs || new Date().toISOString(),
-            hash: "", // Will be computed later
-            skip: 0, // Always 0 for new operations; skip > 0 only during reshuffle
-            action: action,
-        };
-        try {
-            await this.documentStorage.delete(documentId);
-        }
-        catch (error) {
-            return {
-                job,
-                success: false,
-                error: new Error(`Failed to delete document from legacy storage: ${error instanceof Error ? error.message : String(error)}`),
-                duration: Date.now() - startTime,
-            };
+        const operation = this.createOperation(action, nextIndex);
+        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);
@@ -355,131 +377,295 @@ export class SimpleJobExecutor {
             document: document.state.document,
         };
         const resultingState = JSON.stringify(resultingStateObj);
-        // Write the DELETE_DOCUMENT operation to IOperationStore
-        // Note: resultingState is NOT persisted in IOperationStore
-        try {
-            await this.operationStore.apply(documentId, document.header.documentType, job.scope, job.branch, operation.index, (txn) => {
-                txn.addOperations(operation);
-            });
+        const writeError = await this.writeOperationToStore(documentId, document.header.documentType, job.scope, job.branch, operation, job, startTime);
+        if (writeError !== null) {
+            return writeError;
         }
-        catch (error) {
-            return {
-                job,
-                success: false,
-                error: new Error(`Failed to write DELETE_DOCUMENT operation to IOperationStore: ${error instanceof Error ? error.message : String(error)}`),
-                duration: Date.now() - startTime,
-            };
-        }
-        return {
-            job,
-            success: true,
-            operations: [operation],
-            operationsWithContext: [
-                {
-                    operation,
-                    context: {
-                        documentId,
-                        scope: job.scope,
-                        branch: job.branch,
-                        documentType: document.header.documentType,
-                        resultingState,
-                    },
-                },
-            ],
-            duration: Date.now() - startTime,
-        };
+        indexTxn.write([
+            {
+                ...operation,
+                documentId: documentId,
+                documentType: document.header.documentType,
+                branch: job.branch,
+                scope: job.scope,
+            },
+        ]);
+        return this.buildSuccessResult(job, operation, documentId, document.header.documentType, resultingState, startTime);
     }
     /**
      * Execute an UPGRADE_DOCUMENT system action.
      * This sets the document's initial state from the upgrade action.
      * The operation index is determined from the document's current operation count.
      */
-    async executeUpgradeDocumentAction(job, action, startTime) {
+    async executeUpgradeDocumentAction(job, action, startTime, indexTxn, skip = 0) {
         const input = action.input;
         if (!input.documentId) {
-            return {
-                job,
-                success: false,
-                error: new Error("UPGRADE_DOCUMENT action requires a documentId in input"),
-                duration: Date.now() - startTime,
-            };
+            return this.buildErrorResult(job, new Error("UPGRADE_DOCUMENT action requires a documentId in input"), startTime);
         }
         const documentId = input.documentId;
-        // Load the document from write cache
         let document;
         try {
             document = await this.writeCache.getState(documentId, job.scope, job.branch);
         }
         catch (error) {
-            return {
-                job,
-                success: false,
-                error: new Error(`Failed to fetch document for upgrade: ${error instanceof Error ? error.message : String(error)}`),
-                duration: Date.now() - startTime,
-            };
+            return this.buildErrorResult(job, new Error(`Failed to fetch document for upgrade: ${error instanceof Error ? error.message : String(error)}`), startTime);
         }
-        // Check if document is deleted
         const documentState = document.state.document;
         if (documentState.isDeleted) {
-            return {
-                job,
-                success: false,
-                error: new DocumentDeletedError(documentId, documentState.deletedAtUtcIso),
-                duration: Date.now() - startTime,
-            };
+            return this.buildErrorResult(job, new DocumentDeletedError(documentId, documentState.deletedAtUtcIso), startTime);
         }
-        // Determine the next operation index for this scope only (per-scope indexing)
         const nextIndex = getNextIndexForScope(document, job.scope);
-        // Apply the initialState from the upgrade action
-        // The initialState from UPGRADE_DOCUMENT should be merged with the existing base state
-        // to preserve auth and document scopes while adding model-specific scopes (global, local, etc.)
         applyUpgradeDocumentAction(document, action);
-        // Create the UPGRADE_DOCUMENT operation with calculated index
-        const operation = {
-            index: nextIndex,
+        const operation = this.createOperation(action, nextIndex, skip);
+        // 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,
+            },
+        ]);
+        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);
+        }
+        let targetDoc;
+        try {
+            targetDoc = await this.writeCache.getState(input.targetId, "document", job.branch);
+        }
+        catch (error) {
+            return this.buildErrorResult(job, new Error(`ADD_RELATIONSHIP: target document ${input.targetId} not found: ${error instanceof Error ? error.message : String(error)}`), startTime);
+        }
+        const targetDocState = targetDoc.state.document;
+        if (targetDocState.isDeleted) {
+            return this.buildErrorResult(job, new Error(`ADD_RELATIONSHIP: target document ${input.targetId} is deleted`), startTime);
+        }
+        const nextIndex = getNextIndexForScope(sourceDoc, job.scope);
+        const operation = this.createOperation(action, nextIndex);
+        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);
+        }
+        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);
+        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);
+        }
+        return this.buildSuccessResult(job, operation, input.sourceId, sourceDoc.header.documentType, resultingState, startTime);
+    }
+    createOperation(action, index, skip = 0) {
+        return {
+            index: index,
             timestampUtcMs: action.timestampUtcMs || new Date().toISOString(),
-            hash: "", // Will be computed later
-            skip: 0, // Always 0 for new operations; skip > 0 only during reshuffle
+            hash: "",
+            skip: skip,
             action: action,
         };
-        // Write the updated document to legacy storage
+    }
+    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 {
-            await this.operationStorage.addDocumentOperations(documentId, [operation], document);
+            const revisions = await this.operationStore.getRevisions(job.documentId, job.branch);
+            latestRevision = revisions.revision[scope] ?? 0;
         }
-        catch (error) {
+        catch {
+            latestRevision = 0;
+        }
+        const minIncomingIndex = job.operations.reduce((min, operation) => Math.min(min, operation.index), Number.POSITIVE_INFINITY);
+        const skipCount = minIncomingIndex === Number.POSITIVE_INFINITY
+            ? 0
+            : Math.max(0, latestRevision - minIncomingIndex);
+        if (skipCount > MAX_SKIP_THRESHOLD) {
             return {
                 job,
                 success: false,
-                error: new Error(`Failed to write UPGRADE_DOCUMENT operation to legacy storage: ${error instanceof Error ? error.message : String(error)}`),
+                error: new Error(`Excessive reshuffle detected: skip count of ${skipCount} exceeds threshold of ${MAX_SKIP_THRESHOLD}. ` +
+                    `This indicates an attempt to insert an operation at index ${minIncomingIndex} when the latest revision is ${latestRevision}.`),
                 duration: Date.now() - startTime,
             };
         }
-        // Compute resultingState for passing via context (not persisted)
-        const resultingStateObj = {
-            header: document.header,
-            ...document.state,
+        const reshuffledOperations = reshuffleByTimestampAndIndex({
+            index: latestRevision,
+            skip: skipCount,
+        }, [], job.operations.map((operation) => ({
+            ...operation,
+            id: operation.id,
+        })));
+        const actions = reshuffledOperations.map((operation) => operation.action);
+        const skipValues = reshuffledOperations.map((operation) => operation.skip);
+        const result = await this.processActions(job, actions, startTime, indexTxn, skipValues);
+        if (!result.success) {
+            return {
+                job,
+                success: false,
+                error: result.error,
+                duration: Date.now() - startTime,
+            };
+        }
+        if (result.operationsWithContext.length > 0) {
+            const event = {
+                jobId: job.id,
+                operations: result.operationsWithContext,
+            };
+            this.eventBus
+                .emit(OperationEventTypes.OPERATION_WRITTEN, event)
+                .catch(() => {
+                // TODO: log error channel once logging is wired
+            });
+        }
+        this.writeCache.invalidate(job.documentId, scope, job.branch);
+        return {
+            job,
+            success: true,
+            operations: result.generatedOperations,
+            operationsWithContext: result.operationsWithContext,
+            duration: Date.now() - startTime,
         };
-        const resultingState = JSON.stringify(resultingStateObj);
-        // Write the operation to new IOperationStore (dual-writing)
-        // Note: resultingState is NOT persisted in IOperationStore
+    }
+    async writeOperationToStore(documentId, documentType, scope, branch, operation, job, startTime) {
         try {
-            await this.operationStore.apply(documentId, document.header.documentType, job.scope, job.branch, operation.index, (txn) => {
+            await this.operationStore.apply(documentId, documentType, scope, branch, operation.index, (txn) => {
                 txn.addOperations(operation);
             });
+            return null;
         }
         catch (error) {
             return {
                 job,
                 success: false,
-                error: new Error(`Failed to write UPGRADE_DOCUMENT operation to IOperationStore: ${error instanceof Error ? error.message : String(error)}`),
+                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,
-            [job.scope]: operation.index + 1,
+            [scope]: operationIndex + 1,
         };
-        this.writeCache.putState(documentId, job.scope, job.branch, operation.index, document);
+    }
+    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,
@@ -488,10 +674,10 @@ export class SimpleJobExecutor {
                 {
                     operation,
                     context: {
-                        documentId,
+                        documentId: documentId,
                         scope: job.scope,
                         branch: job.branch,
-                        documentType: document.header.documentType,
+                        documentType: documentType,
                         resultingState,
                     },
                 },
@@ -499,5 +685,25 @@ export class SimpleJobExecutor {
             duration: Date.now() - startTime,
         };
     }
+    buildErrorResult(job, error, startTime) {
+        return {
+            job,
+            success: false,
+            error: error,
+            duration: Date.now() - startTime,
+        };
+    }
+    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