@powerhousedao/reactor 6.0.0-dev.4 → 6.0.0-dev.41

package/dist/src/core/reactor.js

@@ -1,78 +1,77 @@
-import { addRelationshipAction, createDocumentAction, deleteDocumentAction, removeRelationshipAction, upgradeDocumentAction, } from "#actions/index.js";
-import { AbortError } from "document-drive";
+import { AbortError } from "document-drive/utils/errors";
 import { v4 as uuidv4 } from "uuid";
+import { addRelationshipAction, createDocumentAction, deleteDocumentAction, removeRelationshipAction, upgradeDocumentAction, } from "../actions/index.js";
+import { ReactorEventTypes, } from "../events/types.js";
 import { createMutableShutdownStatus } from "../shared/factories.js";
 import { JobStatus } from "../shared/types.js";
 import { matchesScope } from "../shared/utils.js";
-import { filterByType, getSharedScope, signAction, signActions, toErrorInfo, topologicalSort, validateActionScopes, validateBatchRequest, } from "./utils.js";
+import { buildSingleJobMeta, filterByType, getSharedActionScope, getSharedOperationScope, signAction, signActions, toErrorInfo, topologicalSort, validateActionScopes, validateBatchLoadRequest, validateBatchRequest, validateOperationScopes, } from "./utils.js";
 /**
  * This class implements the IReactor interface and serves as the main entry point
  * for the new Reactor architecture.
  */
 export class Reactor {
     logger;
-    driveServer;
-    documentStorage;
+    documentModelRegistry;
     shutdownStatus;
     setShutdown;
+    setCompleted;
     queue;
     jobTracker;
     readModelCoordinator;
     features;
     documentView;
-    _documentIndexer;
+    documentIndexer;
     operationStore;
-    constructor(logger, driveServer, documentStorage, queue, jobTracker, readModelCoordinator, features, documentView, documentIndexer, operationStore) {
-        // Store required dependencies
+    eventBus;
+    executorManager;
+    constructor(logger, documentModelRegistry, queue, jobTracker, readModelCoordinator, features, documentView, documentIndexer, operationStore, eventBus, executorManager) {
         this.logger = logger;
-        this.driveServer = driveServer;
-        this.documentStorage = documentStorage;
+        this.documentModelRegistry = documentModelRegistry;
         this.queue = queue;
         this.jobTracker = jobTracker;
         this.readModelCoordinator = readModelCoordinator;
         this.features = features;
         this.documentView = documentView;
-        this._documentIndexer = documentIndexer;
+        this.documentIndexer = documentIndexer;
         this.operationStore = operationStore;
-        // Create mutable shutdown status using factory method
-        const [status, setter] = createMutableShutdownStatus(false);
+        this.eventBus = eventBus;
+        this.executorManager = executorManager;
+        const [status, setShutdown, setCompleted] = createMutableShutdownStatus(false);
         this.shutdownStatus = status;
-        this.setShutdown = setter;
-        this.logger.verbose("Reactor({ legacyStorage: @legacy })", features.legacyStorageEnabled);
+        this.setShutdown = setShutdown;
+        this.setCompleted = setCompleted;
+        this.eventBus.subscribe(ReactorEventTypes.JOB_FAILED, (_type, event) => {
+            this.logger.error("Job @JobId failed with @Message: @Job", event.jobId, event.error.message, event.job);
+        });
         this.readModelCoordinator.start();
     }
-    /**
-     * Signals that the reactor should shutdown.
-     */
     kill() {
         this.logger.verbose("kill()");
-        // Mark the reactor as shutdown
+        if (this.shutdownStatus.isShutdown) {
+            return this.shutdownStatus;
+        }
         this.setShutdown(true);
-        // Stop the read model coordinator
-        this.readModelCoordinator.stop();
-        // Stop the job tracker
-        this.jobTracker.shutdown();
+        const shutdownAsync = async () => {
+            await this.executorManager.stop(true);
+            this.readModelCoordinator.stop();
+            this.jobTracker.shutdown();
+        };
+        this.setCompleted(shutdownAsync());
         return this.shutdownStatus;
     }
-    /**
-     * Retrieves a list of document model specifications
-     */
     getDocumentModels(namespace, paging, signal) {
         this.logger.verbose("getDocumentModels(@namespace, @paging)", namespace, paging);
-        // Get document model modules from the drive server + filter
-        const modules = this.driveServer.getDocumentModelModules();
+        if (signal?.aborted) {
+            throw new AbortError();
+        }
+        const modules = this.documentModelRegistry.getAllModules();
         const filteredModels = modules.filter((module) => !namespace || module.documentModel.global.id.startsWith(namespace));
-        // Apply paging
         const startIndex = paging ? parseInt(paging.cursor) || 0 : 0;
         const limit = paging?.limit || filteredModels.length;
         const pagedModels = filteredModels.slice(startIndex, startIndex + limit);
-        // Create paged results
         const hasMore = startIndex + limit < filteredModels.length;
         const nextCursor = hasMore ? String(startIndex + limit) : undefined;
-        // even thought this is currently synchronous, they could have passed in an already-aborted signal
-        if (signal?.aborted) {
-            throw new AbortError();
-        }
         return Promise.resolve({
             results: pagedModels,
             options: paging || { cursor: "0", limit: filteredModels.length },
@@ -82,190 +81,70 @@ export class Reactor {
                 : undefined,
         });
     }
-    /**
-     * Retrieves a specific PHDocument by id
-     */
     async get(id, view, consistencyToken, signal) {
         this.logger.verbose("get(@id, @view)", id, view);
-        if (this.features.legacyStorageEnabled) {
-            const document = await this.documentStorage.get(id, consistencyToken, signal);
-            if (signal?.aborted) {
-                throw new AbortError();
-            }
-            const childIds = await this.documentStorage.getChildren(id, consistencyToken, signal);
-            if (signal?.aborted) {
-                throw new AbortError();
-            }
-            for (const scope in document.state) {
-                if (!matchesScope(view, scope)) {
-                    delete document.state[scope];
-                }
-            }
-            return {
-                document,
-                childIds,
-            };
-        }
-        else {
-            const document = await this.documentView.get(id, view, consistencyToken, signal);
-            if (signal?.aborted) {
-                throw new AbortError();
-            }
-            const relationships = await this._documentIndexer.getOutgoing(id, ["child"], consistencyToken, signal);
-            if (signal?.aborted) {
-                throw new AbortError();
-            }
-            const childIds = relationships.map((rel) => rel.targetId);
-            return {
-                document,
-                childIds,
-            };
-        }
+        return await this.documentView.get(id, view, consistencyToken, signal);
     }
-    /**
-     * Retrieves a specific PHDocument by slug
-     */
     async getBySlug(slug, view, consistencyToken, signal) {
         this.logger.verbose("getBySlug(@slug, @view)", slug, view);
-        if (this.features.legacyStorageEnabled) {
-            let ids;
-            try {
-                ids = await this.documentStorage.resolveIds([slug], consistencyToken, signal);
-            }
-            catch (error) {
-                if (error instanceof Error && error.message.includes("not found")) {
-                    throw new Error(`Document not found with slug: ${slug}`);
-                }
-                throw error;
-            }
-            if (ids.length === 0 || !ids[0]) {
-                throw new Error(`Document not found with slug: ${slug}`);
-            }
-            return await this.get(ids[0], view, consistencyToken, signal);
-        }
-        else {
-            const documentId = await this.documentView.resolveSlug(slug, view, consistencyToken, signal);
-            if (!documentId) {
-                throw new Error(`Document not found with slug: ${slug}`);
-            }
-            return await this.get(documentId, view, consistencyToken, signal);
+        const documentId = await this.documentView.resolveSlug(slug, view, consistencyToken, signal);
+        if (!documentId) {
+            throw new Error(`Document not found with slug: ${slug}`);
         }
+        return await this.get(documentId, view, consistencyToken, signal);
     }
-    /**
-     * Retrieves a specific PHDocument by identifier (either id or slug)
-     */
     async getByIdOrSlug(identifier, view, consistencyToken, signal) {
         this.logger.verbose("getByIdOrSlug(@identifier, @view)", identifier, view);
-        if (this.features.legacyStorageEnabled) {
-            try {
-                return await this.get(identifier, view, consistencyToken, signal);
-            }
-            catch {
-                try {
-                    const ids = await this.documentStorage.resolveIds([identifier], consistencyToken, signal);
-                    if (ids.length === 0 || !ids[0]) {
-                        throw new Error(`Document not found: ${identifier}`);
-                    }
-                    return await this.get(ids[0], view, consistencyToken, signal);
-                }
-                catch {
-                    throw new Error(`Document not found: ${identifier}`);
-                }
-            }
+        return await this.documentView.getByIdOrSlug(identifier, view, consistencyToken, signal);
+    }
+    async getChildren(documentId, consistencyToken, signal) {
+        const relationships = await this.documentIndexer.getOutgoing(documentId, ["child"], undefined, consistencyToken, signal);
+        if (signal?.aborted) {
+            throw new AbortError();
         }
-        else {
-            const document = await this.documentView.getByIdOrSlug(identifier, view, consistencyToken, signal);
-            if (signal?.aborted) {
-                throw new AbortError();
-            }
-            const relationships = await this._documentIndexer.getOutgoing(document.header.id, ["child"], consistencyToken, signal);
-            if (signal?.aborted) {
-                throw new AbortError();
-            }
-            const childIds = relationships.map((rel) => rel.targetId);
-            return {
-                document,
-                childIds,
-            };
+        return relationships.results.map((rel) => rel.targetId);
+    }
+    async getParents(childId, consistencyToken, signal) {
+        const relationships = await this.documentIndexer.getIncoming(childId, ["parent"], undefined, consistencyToken, signal);
+        if (signal?.aborted) {
+            throw new AbortError();
         }
+        return relationships.results.map((rel) => rel.sourceId);
     }
-    /**
-     * Retrieves the operations for a document
-     */
-    async getOperations(documentId, view, paging, consistencyToken, signal) {
-        this.logger.verbose("getOperations(@documentId, @view, @paging)", documentId, view, paging);
-        if (this.features.legacyStorageEnabled) {
-            // Use storage directly to get the document
-            const document = await this.documentStorage.get(documentId, consistencyToken, signal);
-            if (signal?.aborted) {
-                throw new AbortError();
-            }
-            const operations = document.operations;
-            const result = {};
-            // apply view filter, per scope -- this will be removed when we pass the viewfilter along
-            // to the underlying store, but is here now for the interface.
-            for (const scope in operations) {
-                if (matchesScope(view, scope)) {
-                    const scopeOperations = operations[scope];
-                    // apply paging too
-                    const startIndex = paging ? parseInt(paging.cursor) || 0 : 0;
-                    const limit = paging?.limit || scopeOperations.length;
-                    const pagedOperations = scopeOperations.slice(startIndex, startIndex + limit);
-                    result[scope] = {
-                        results: pagedOperations,
-                        options: { cursor: String(startIndex + limit), limit },
-                    };
-                }
-            }
-            return Promise.resolve(result);
+    async getOperations(documentId, view, filter, paging, consistencyToken, signal) {
+        this.logger.verbose("getOperations(@documentId, @view, @filter, @paging)", documentId, view, filter, paging);
+        const branch = view?.branch || "main";
+        const revisions = await this.operationStore.getRevisions(documentId, branch, signal);
+        if (signal?.aborted) {
+            throw new AbortError();
         }
-        else {
-            // Use operation store to get operations
-            const branch = view?.branch || "main";
-            // Get all scopes for this document
-            const revisions = await this.operationStore.getRevisions(documentId, branch, signal);
+        const allScopes = Object.keys(revisions.revision);
+        const result = {};
+        for (const scope of allScopes) {
+            if (!matchesScope(view, scope)) {
+                continue;
+            }
             if (signal?.aborted) {
                 throw new AbortError();
             }
-            const allScopes = Object.keys(revisions.revision);
-            const result = {};
-            // Filter scopes based on view filter and query operations for each
-            for (const scope of allScopes) {
-                if (!matchesScope(view, scope)) {
-                    continue;
-                }
-                if (signal?.aborted) {
-                    throw new AbortError();
-                }
-                // Get operations for this scope
-                const scopeResult = await this.operationStore.getSince(documentId, scope, branch, -1, paging, signal);
-                // Transform to Reactor's PagedResults format
-                const currentCursor = paging?.cursor ? parseInt(paging.cursor) : 0;
-                const currentLimit = paging?.limit || 100;
-                result[scope] = {
-                    results: scopeResult.items,
-                    options: {
-                        cursor: scopeResult.nextCursor || String(currentCursor),
-                        limit: currentLimit,
-                    },
-                    nextCursor: scopeResult.nextCursor,
-                    next: scopeResult.hasMore
-                        ? async () => {
-                            const nextPage = await this.getOperations(documentId, view, {
-                                cursor: scopeResult.nextCursor,
-                                limit: currentLimit,
-                            }, consistencyToken, signal);
-                            return nextPage[scope];
-                        }
-                        : undefined,
-                };
-            }
-            return result;
+            const scopeResult = await this.operationStore.getSince(documentId, scope, branch, -1, filter, paging, signal);
+            result[scope] = {
+                results: scopeResult.results,
+                options: scopeResult.options,
+                nextCursor: scopeResult.nextCursor,
+                next: scopeResult.next
+                    ? async () => {
+                        const nextPage = await this.getOperations(documentId, view, filter, {
+                            cursor: scopeResult.nextCursor,
+                            limit: scopeResult.options.limit,
+                        }, consistencyToken, signal);
+                        return nextPage[scope];
+                    }
+                    : undefined,
+            };
         }
+        return result;
     }
-    /**
-     * Filters documents by criteria and returns a list of them
-     */
     async find(search, view, paging, consistencyToken, signal) {
         this.logger.verbose("find(@search, @view, @paging)", search, view, paging);
         let results;
@@ -285,7 +164,7 @@ export class Reactor {
             }
         }
         else if (search.parentId) {
-            results = await this.findByParentId(search.parentId, view, paging, signal);
+            results = await this.findByParentId(search.parentId, view, paging, consistencyToken, signal);
             if (search.type) {
                 results = filterByType(results, search.type);
             }
@@ -301,9 +180,6 @@ export class Reactor {
         }
         return results;
     }
-    /**
-     * Creates a document
-     */
     async create(document, signer, signal, meta) {
         this.logger.verbose("create(@id, @type, @slug)", document.header.id, document.header.documentType, document.header.slug);
         const createdAtUtcIso = new Date().toISOString();
@@ -337,14 +213,14 @@ export class Reactor {
             toVersion: document.state.document.version,
             initialState: document.state,
         });
-        // Sign actions if signer is provided
         let actions = [createAction, upgradeAction];
         if (signer) {
             actions = await signActions(actions, signer, signal);
         }
-        // Create a single job with both CREATE_DOCUMENT and UPGRADE_DOCUMENT actions
+        const jobId = uuidv4();
+        const jobMeta = buildSingleJobMeta(jobId, meta);
         const job = {
-            id: uuidv4(),
+            id: jobId,
             kind: "mutation",
             documentId: document.header.id,
             scope: "document",
@@ -355,11 +231,10 @@ export class Reactor {
             queueHint: [],
             maxRetries: 3,
             errorHistory: [],
-            meta,
+            meta: jobMeta,
         };
-        // Create job info and register with tracker
         const jobInfo = {
-            id: job.id,
+            id: jobId,
             status: JobStatus.PENDING,
             createdAtUtcIso,
             consistencyToken: {
@@ -367,16 +242,13 @@ export class Reactor {
                 createdAtUtcIso,
                 coordinates: [],
             },
-            meta,
+            meta: jobMeta,
         };
         this.jobTracker.registerJob(jobInfo);
-        // Enqueue the job
+        this.emitJobPending(jobInfo.id, jobMeta);
         await this.queue.enqueue(job);
         return jobInfo;
     }
-    /**
-     * Deletes a document
-     */
     async deleteDocument(id, signer, signal, meta) {
         this.logger.verbose("deleteDocument(@id)", id);
         const createdAtUtcIso = new Date().toISOString();
@@ -384,12 +256,13 @@ export class Reactor {
             throw new AbortError();
         }
         let action = deleteDocumentAction(id);
-        // Sign action if signer is provided
         if (signer) {
             action = await signAction(action, signer, signal);
         }
+        const jobId = uuidv4();
+        const jobMeta = buildSingleJobMeta(jobId, meta);
         const job = {
-            id: uuidv4(),
+            id: jobId,
             kind: "mutation",
             documentId: id,
             scope: "document",
@@ -400,10 +273,10 @@ export class Reactor {
             queueHint: [],
             maxRetries: 3,
             errorHistory: [],
-            meta,
+            meta: jobMeta,
         };
         const jobInfo = {
-            id: job.id,
+            id: jobId,
             status: JobStatus.PENDING,
             createdAtUtcIso,
             consistencyToken: {
@@ -411,26 +284,24 @@ export class Reactor {
                 createdAtUtcIso,
                 coordinates: [],
             },
-            meta,
+            meta: jobMeta,
         };
         this.jobTracker.registerJob(jobInfo);
+        this.emitJobPending(jobInfo.id, jobMeta);
         await this.queue.enqueue(job);
         return jobInfo;
     }
-    /**
-     * Applies a list of actions to a document
-     */
     async execute(docId, branch, actions, signal, meta) {
         this.logger.verbose("execute(@docId, @branch, @actions)", docId, branch, actions);
         if (signal?.aborted) {
             throw new AbortError();
         }
         const createdAtUtcIso = new Date().toISOString();
-        // Determine scope from first action (all actions should have the same scope)
-        const scope = actions.length > 0 ? actions[0].scope || "global" : "global";
-        // Create a single job with all actions
+        const scope = getSharedActionScope(actions);
+        const jobId = uuidv4();
+        const jobMeta = buildSingleJobMeta(jobId, meta);
         const job = {
-            id: uuidv4(),
+            id: jobId,
             kind: "mutation",
             documentId: docId,
             scope: scope,
@@ -441,11 +312,10 @@ export class Reactor {
             queueHint: [],
             maxRetries: 3,
             errorHistory: [],
-            meta,
+            meta: jobMeta,
         };
-        // Create job info and register with tracker
         const jobInfo = {
-            id: job.id,
+            id: jobId,
             status: JobStatus.PENDING,
             createdAtUtcIso,
             consistencyToken: {
@@ -453,21 +323,16 @@ export class Reactor {
                 createdAtUtcIso,
                 coordinates: [],
             },
-            meta,
+            meta: jobMeta,
         };
         this.jobTracker.registerJob(jobInfo);
-        // Enqueue the job
+        this.emitJobPending(jobInfo.id, jobMeta);
         await this.queue.enqueue(job);
         if (signal?.aborted) {
             throw new AbortError();
         }
         return jobInfo;
     }
-    /**
-     * Imports pre-existing operations that were produced by another reactor.
-     * This function may cause a reshuffle, which will generate additional
-     * operations.
-     */
     async load(docId, branch, operations, signal, meta) {
         this.logger.verbose("load(@docId, @branch, @count, @operations)", docId, branch, operations.length, operations);
         if (signal?.aborted) {
@@ -476,16 +341,12 @@ export class Reactor {
         if (operations.length === 0) {
             throw new Error("load requires at least one operation");
         }
-        // validate the operations
-        const scope = getSharedScope(operations);
-        operations.forEach((operation, index) => {
-            if (!operation.timestampUtcMs) {
-                throw new Error(`Operation at position ${index} is missing timestampUtcMs`);
-            }
-        });
+        const scope = getSharedOperationScope(operations);
         const createdAtUtcIso = new Date().toISOString();
+        const jobId = uuidv4();
+        const jobMeta = buildSingleJobMeta(jobId, meta);
         const job = {
-            id: uuidv4(),
+            id: jobId,
             kind: "load",
             documentId: docId,
             scope,
@@ -496,10 +357,10 @@ export class Reactor {
             queueHint: [],
             maxRetries: 3,
             errorHistory: [],
-            meta,
+            meta: jobMeta,
         };
         const jobInfo = {
-            id: job.id,
+            id: jobId,
             status: JobStatus.PENDING,
             createdAtUtcIso,
             consistencyToken: {
@@ -507,18 +368,16 @@ export class Reactor {
                 createdAtUtcIso,
                 coordinates: [],
             },
-            meta,
+            meta: jobMeta,
         };
         this.jobTracker.registerJob(jobInfo);
+        this.emitJobPending(jobInfo.id, jobMeta);
         await this.queue.enqueue(job);
         if (signal?.aborted) {
             throw new AbortError();
         }
         return jobInfo;
     }
-    /**
-     * Applies multiple mutations across documents with dependency management
-     */
     async executeBatch(request, signal, meta) {
         this.logger.verbose("executeBatch(@count jobs)", request.jobs.length);
         if (signal?.aborted) {
@@ -533,6 +392,13 @@ export class Reactor {
         for (const jobPlan of request.jobs) {
             planKeyToJobId.set(jobPlan.key, uuidv4());
         }
+        const batchId = uuidv4();
+        const batchJobIds = [...planKeyToJobId.values()];
+        const batchMeta = {
+            ...meta,
+            batchId,
+            batchJobIds,
+        };
         const jobInfos = new Map();
         for (const jobPlan of request.jobs) {
             const jobId = planKeyToJobId.get(jobPlan.key);
@@ -545,9 +411,10 @@ export class Reactor {
                     createdAtUtcIso,
                     coordinates: [],
                 },
-                meta,
+                meta: batchMeta,
             };
             this.jobTracker.registerJob(jobInfo);
+            this.emitJobPending(jobInfo.id, batchMeta);
             jobInfos.set(jobPlan.key, jobInfo);
         }
         const sortedKeys = topologicalSort(request.jobs);
@@ -572,7 +439,94 @@ export class Reactor {
                     queueHint,
                     maxRetries: 3,
                     errorHistory: [],
-                    meta,
+                    meta: batchMeta,
+                };
+                await this.queue.enqueue(job);
+                enqueuedKeys.push(key);
+            }
+        }
+        catch (error) {
+            for (const key of enqueuedKeys) {
+                const jobId = planKeyToJobId.get(key);
+                try {
+                    await this.queue.remove(jobId);
+                }
+                catch {
+                    // Ignore removal errors during cleanup
+                }
+            }
+            for (const jobInfo of jobInfos.values()) {
+                this.jobTracker.markFailed(jobInfo.id, toErrorInfo("Batch enqueue failed"));
+            }
+            throw error;
+        }
+        const result = {
+            jobs: Object.fromEntries(jobInfos),
+        };
+        return result;
+    }
+    async loadBatch(request, signal, meta) {
+        this.logger.verbose("loadBatch(@count jobs)", request.jobs.length);
+        if (signal?.aborted) {
+            throw new AbortError();
+        }
+        validateBatchLoadRequest(request.jobs);
+        for (const jobPlan of request.jobs) {
+            validateOperationScopes(jobPlan);
+        }
+        const createdAtUtcIso = new Date().toISOString();
+        const planKeyToJobId = new Map();
+        for (const jobPlan of request.jobs) {
+            planKeyToJobId.set(jobPlan.key, uuidv4());
+        }
+        const batchId = uuidv4();
+        const batchJobIds = [...planKeyToJobId.values()];
+        const batchMeta = {
+            ...meta,
+            batchId,
+            batchJobIds,
+        };
+        const jobInfos = new Map();
+        for (const jobPlan of request.jobs) {
+            const jobId = planKeyToJobId.get(jobPlan.key);
+            const jobInfo = {
+                id: jobId,
+                status: JobStatus.PENDING,
+                createdAtUtcIso,
+                consistencyToken: {
+                    version: 1,
+                    createdAtUtcIso,
+                    coordinates: [],
+                },
+                meta: batchMeta,
+            };
+            this.jobTracker.registerJob(jobInfo);
+            this.emitJobPending(jobInfo.id, batchMeta);
+            jobInfos.set(jobPlan.key, jobInfo);
+        }
+        const sortedKeys = topologicalSort(request.jobs);
+        const enqueuedKeys = [];
+        try {
+            for (const key of sortedKeys) {
+                if (signal?.aborted) {
+                    throw new AbortError();
+                }
+                const jobPlan = request.jobs.find((j) => j.key === key);
+                const jobId = planKeyToJobId.get(key);
+                const queueHint = jobPlan.dependsOn.map((depKey) => planKeyToJobId.get(depKey));
+                const job = {
+                    id: jobId,
+                    kind: "load",
+                    documentId: jobPlan.documentId,
+                    scope: jobPlan.scope,
+                    branch: jobPlan.branch,
+                    actions: [],
+                    operations: jobPlan.operations,
+                    createdAt: createdAtUtcIso,
+                    queueHint,
+                    maxRetries: 3,
+                    errorHistory: [],
+                    meta: batchMeta,
                 };
                 await this.queue.enqueue(job);
                 enqueuedKeys.push(key);
@@ -598,39 +552,28 @@ export class Reactor {
         };
         return result;
     }
-    /**
-     * Adds multiple documents as children to another
-     */
     async addChildren(parentId, documentIds, branch = "main", signer, signal) {
         this.logger.verbose("addChildren(@parentId, @count children, @branch)", parentId, documentIds.length, branch);
         if (signal?.aborted) {
             throw new AbortError();
         }
         let actions = documentIds.map((childId) => addRelationshipAction(parentId, childId, "child"));
-        // Sign actions if signer is provided
         if (signer) {
             actions = await signActions(actions, signer, signal);
         }
         return await this.execute(parentId, branch, actions, signal);
     }
-    /**
-     * Removes multiple documents as children from another
-     */
     async removeChildren(parentId, documentIds, branch = "main", signer, signal) {
         this.logger.verbose("removeChildren(@parentId, @count children, @branch)", parentId, documentIds.length, branch);
         if (signal?.aborted) {
             throw new AbortError();
         }
         let actions = documentIds.map((childId) => removeRelationshipAction(parentId, childId, "child"));
-        // Sign actions if signer is provided
         if (signer) {
             actions = await signActions(actions, signer, signal);
         }
         return await this.execute(parentId, branch, actions, signal);
     }
-    /**
-     * Retrieves the status of a job
-     */
     getJobStatus(jobId, signal) {
         this.logger.verbose("getJobStatus(@jobId)", jobId);
         if (signal?.aborted) {
@@ -638,7 +581,6 @@ export class Reactor {
         }
         const jobInfo = this.jobTracker.getJobStatus(jobId);
         if (!jobInfo) {
-            // Job not found - return FAILED status with appropriate error
             const now = new Date().toISOString();
             return Promise.resolve({
                 id: jobId,
@@ -651,331 +593,48 @@ export class Reactor {
                     createdAtUtcIso: now,
                     coordinates: [],
                 },
+                meta: { batchId: jobId, batchJobIds: [jobId] },
             });
         }
         return Promise.resolve(jobInfo);
     }
-    /**
-     * Finds documents by their IDs
-     */
     async findByIds(ids, view, paging, consistencyToken, signal) {
         this.logger.verbose("findByIds(@count ids)", ids.length);
-        if (consistencyToken) {
-            await this.documentView.waitForConsistency(consistencyToken, undefined, signal);
-        }
-        if (this.features.legacyStorageEnabled) {
-            const documents = [];
-            // Fetch each document by ID using storage directly
-            for (const id of ids) {
-                if (signal?.aborted) {
-                    throw new AbortError();
-                }
-                let document;
-                try {
-                    document = await this.documentStorage.get(id, consistencyToken, signal);
-                }
-                catch {
-                    // Skip documents that don't exist or can't be accessed
-                    // This matches the behavior expected from a search operation
-                    continue;
-                }
-                // Apply view filter - This will be removed when we pass the viewfilter along
-                // to the underlying store, but is here now for the interface.
-                for (const scope in document.state) {
-                    if (!matchesScope(view, scope)) {
-                        delete document.state[scope];
-                    }
-                }
-                documents.push(document);
-            }
-            if (signal?.aborted) {
-                throw new AbortError();
-            }
-            // Apply paging
-            const startIndex = paging ? parseInt(paging.cursor) || 0 : 0;
-            const limit = paging?.limit || documents.length;
-            const pagedDocuments = documents.slice(startIndex, startIndex + limit);
-            // Create paged results
-            const hasMore = startIndex + limit < documents.length;
-            const nextCursor = hasMore ? String(startIndex + limit) : undefined;
-            return {
-                results: pagedDocuments,
-                options: paging || { cursor: "0", limit: documents.length },
-                nextCursor,
-                next: hasMore
-                    ? () => this.findByIds(ids, view, { cursor: nextCursor, limit }, consistencyToken, signal)
-                    : undefined,
-            };
-        }
-        else {
-            const documents = [];
-            // Fetch each document by ID using documentView
-            for (const id of ids) {
-                if (signal?.aborted) {
-                    throw new AbortError();
-                }
-                try {
-                    const document = await this.documentView.get(id, view, undefined, signal);
-                    documents.push(document);
-                }
-                catch {
-                    // Skip documents that don't exist or can't be accessed
-                    continue;
-                }
-            }
-            if (signal?.aborted) {
-                throw new AbortError();
-            }
-            // Apply paging
-            const startIndex = paging ? parseInt(paging.cursor) || 0 : 0;
-            const limit = paging?.limit || documents.length;
-            const pagedDocuments = documents.slice(startIndex, startIndex + limit);
-            // Create paged results
-            const hasMore = startIndex + limit < documents.length;
-            const nextCursor = hasMore ? String(startIndex + limit) : undefined;
-            return {
-                results: pagedDocuments,
-                options: paging || { cursor: "0", limit: documents.length },
-                nextCursor,
-                next: hasMore
-                    ? () => this.findByIds(ids, view, { cursor: nextCursor, limit }, consistencyToken, signal)
-                    : undefined,
-            };
-        }
+        const startIndex = paging?.cursor ? parseInt(paging.cursor) || 0 : 0;
+        const limit = paging?.limit || ids.length;
+        const pagedIds = ids.slice(startIndex, startIndex + limit);
+        const results = await this.documentView.getMany(pagedIds, view, consistencyToken, signal);
+        const hasMore = startIndex + limit < ids.length;
+        const nextCursor = hasMore ? String(startIndex + limit) : undefined;
+        return {
+            results,
+            options: paging || { cursor: "0", limit: ids.length },
+            nextCursor,
+        };
     }
-    /**
-     * Finds documents by their slugs
-     */
     async findBySlugs(slugs, view, paging, consistencyToken, signal) {
         this.logger.verbose("findBySlugs(@count slugs)", slugs.length);
-        if (consistencyToken) {
-            await this.documentView.waitForConsistency(consistencyToken, undefined, signal);
-        }
-        if (this.features.legacyStorageEnabled) {
-            const documents = [];
-            // Use storage to resolve slugs to IDs
-            let ids;
-            try {
-                ids = await this.documentStorage.resolveIds(slugs, consistencyToken, signal);
-            }
-            catch {
-                // If slug resolution fails, return empty results
-                // This matches the behavior expected from a search operation
-                ids = [];
-            }
-            // Fetch each document by resolved ID
-            for (const id of ids) {
-                if (signal?.aborted) {
-                    throw new AbortError();
-                }
-                let document;
-                try {
-                    document = await this.documentStorage.get(id, consistencyToken, signal);
-                }
-                catch {
-                    // Skip documents that don't exist or can't be accessed
-                    continue;
-                }
-                // Apply view filter - This will be removed when we pass the viewfilter along
-                // to the underlying store, but is here now for the interface.
-                for (const scope in document.state) {
-                    if (!matchesScope(view, scope)) {
-                        delete document.state[scope];
-                    }
-                }
-                documents.push(document);
-            }
-            if (signal?.aborted) {
-                throw new AbortError();
-            }
-            // Apply paging - this will be removed when we pass the paging along
-            // to the underlying store, but is here now for the interface.
-            const startIndex = paging ? parseInt(paging.cursor) || 0 : 0;
-            const limit = paging?.limit || documents.length;
-            const pagedDocuments = documents.slice(startIndex, startIndex + limit);
-            // Create paged results
-            const hasMore = startIndex + limit < documents.length;
-            const nextCursor = hasMore ? String(startIndex + limit) : undefined;
-            return {
-                results: pagedDocuments,
-                options: paging || { cursor: "0", limit: documents.length },
-                nextCursor,
-                next: hasMore
-                    ? () => this.findBySlugs(slugs, view, { cursor: nextCursor, limit }, consistencyToken, signal)
-                    : undefined,
-            };
-        }
-        else {
-            const documents = [];
-            // Resolve each slug to a document ID
-            const documentIds = [];
-            for (const slug of slugs) {
-                if (signal?.aborted) {
-                    throw new AbortError();
-                }
-                const documentId = await this.documentView.resolveSlug(slug, view, undefined, signal);
-                if (documentId) {
-                    documentIds.push(documentId);
-                }
-            }
-            // Fetch each document
-            for (const documentId of documentIds) {
-                if (signal?.aborted) {
-                    throw new AbortError();
-                }
-                try {
-                    const document = await this.documentView.get(documentId, view, undefined, signal);
-                    documents.push(document);
-                }
-                catch {
-                    // Skip documents that don't exist or can't be accessed
-                    continue;
-                }
-            }
-            if (signal?.aborted) {
-                throw new AbortError();
-            }
-            // Apply paging
-            const startIndex = paging ? parseInt(paging.cursor) || 0 : 0;
-            const limit = paging?.limit || documents.length;
-            const pagedDocuments = documents.slice(startIndex, startIndex + limit);
-            // Create paged results
-            const hasMore = startIndex + limit < documents.length;
-            const nextCursor = hasMore ? String(startIndex + limit) : undefined;
-            return {
-                results: pagedDocuments,
-                options: paging || { cursor: "0", limit: documents.length },
-                nextCursor,
-                next: hasMore
-                    ? () => this.findBySlugs(slugs, view, { cursor: nextCursor, limit }, consistencyToken, signal)
-                    : undefined,
-            };
-        }
+        const ids = await this.documentView.resolveSlugs(slugs, view, consistencyToken, signal);
+        return await this.findByIds(ids, view, paging, consistencyToken, signal);
     }
-    /**
-     * Finds documents by parent ID
-     */
-    async findByParentId(parentId, view, paging, signal) {
+    async findByParentId(parentId, view, paging, consistencyToken, signal) {
         this.logger.verbose("findByParentId(@parentId)", parentId);
-        // Get child relationships from indexer
-        const relationships = await this._documentIndexer.getOutgoing(parentId, ["child"], undefined, signal);
-        if (signal?.aborted) {
-            throw new AbortError();
-        }
-        const documents = [];
-        // Fetch each child document using the appropriate storage method
-        for (const relationship of relationships) {
-            if (signal?.aborted) {
-                throw new AbortError();
-            }
-            try {
-                let document;
-                if (this.features.legacyStorageEnabled) {
-                    document = await this.documentStorage.get(relationship.targetId);
-                    // Apply view filter for legacy storage
-                    for (const scope in document.state) {
-                        if (!matchesScope(view, scope)) {
-                            delete document.state[scope];
-                        }
-                    }
-                }
-                else {
-                    document = await this.documentView.get(relationship.targetId, view, undefined, signal);
-                }
-                documents.push(document);
-            }
-            catch {
-                // Skip documents that don't exist or can't be accessed
-                continue;
-            }
-        }
-        if (signal?.aborted) {
-            throw new AbortError();
-        }
-        // Apply paging
-        const startIndex = paging ? parseInt(paging.cursor) || 0 : 0;
-        const limit = paging?.limit || documents.length;
-        const pagedDocuments = documents.slice(startIndex, startIndex + limit);
-        // Create paged results
-        const hasMore = startIndex + limit < documents.length;
-        const nextCursor = hasMore ? String(startIndex + limit) : undefined;
-        return {
-            results: pagedDocuments,
-            options: paging || { cursor: "0", limit: documents.length },
-            nextCursor,
-            next: hasMore
-                ? () => this.findByParentId(parentId, view, { cursor: nextCursor, limit }, signal)
-                : undefined,
-        };
+        const relationships = await this.documentIndexer.getOutgoing(parentId, ["child"], paging, consistencyToken, signal);
+        const ids = relationships.results.map((rel) => rel.targetId);
+        return await this.findByIds(ids, view, paging, undefined, signal);
     }
-    /**
-     * Finds documents by type
-     */
     async findByType(type, view, paging, consistencyToken, signal) {
         this.logger.verbose("findByType(@type)", type);
-        if (consistencyToken) {
-            await this.documentView.waitForConsistency(consistencyToken, undefined, signal);
-        }
-        if (this.features.legacyStorageEnabled) {
-            const documents = [];
-            // Use storage's findByType method directly
-            const cursor = paging?.cursor;
-            const limit = paging?.limit || 100;
-            // Get document IDs of the specified type
-            const { documents: documentIds, nextCursor } = await this.documentStorage.findByType(type, limit, cursor, consistencyToken, signal);
-            if (signal?.aborted) {
-                throw new AbortError();
-            }
-            // Fetch each document by its ID
-            for (const documentId of documentIds) {
-                if (signal?.aborted) {
-                    throw new AbortError();
-                }
-                let document;
-                try {
-                    document = await this.documentStorage.get(documentId, consistencyToken, signal);
-                }
-                catch {
-                    // Skip documents that can't be retrieved
-                    continue;
-                }
-                // Apply view filter
-                for (const scope in document.state) {
-                    if (!matchesScope(view, scope)) {
-                        delete document.state[scope];
-                    }
-                }
-                documents.push(document);
-            }
-            if (signal?.aborted) {
-                throw new AbortError();
-            }
-            // Results are already paged from the storage layer
-            return {
-                results: documents,
-                options: paging || { cursor: cursor || "0", limit },
-                nextCursor,
-                next: nextCursor
-                    ? async () => this.findByType(type, view, { cursor: nextCursor, limit }, consistencyToken, signal)
-                    : undefined,
-            };
-        }
-        else {
-            const result = await this.documentView.findByType(type, view, paging, consistencyToken, signal);
-            if (signal?.aborted) {
-                throw new AbortError();
-            }
-            const cursor = paging?.cursor;
-            const limit = paging?.limit || 100;
-            return {
-                results: result.items,
-                options: paging || { cursor: cursor || "0", limit },
-                nextCursor: result.nextCursor,
-                next: result.nextCursor
-                    ? async () => this.findByType(type, view, { cursor: result.nextCursor, limit }, consistencyToken, signal)
-                    : undefined,
-            };
-        }
+        return await this.documentView.findByType(type, view, paging, consistencyToken, signal);
+    }
+    emitJobPending(jobId, meta) {
+        const event = {
+            jobId,
+            jobMeta: meta,
+        };
+        this.eventBus.emit(ReactorEventTypes.JOB_PENDING, event).catch(() => {
+            // Ignore event emission errors
+        });
     }
 }
 //# sourceMappingURL=reactor.js.map