@powerhousedao/reactor 5.0.3 → 5.0.5

package/dist/src/core/reactor.js

@@ -3,7 +3,7 @@ import { v4 as uuidv4 } from "uuid";
 import { createMutableShutdownStatus } from "../shared/factories.js";
 import { JobStatus } from "../shared/types.js";
 import { matchesScope } from "../shared/utils.js";
-import { filterByParentId, filterByType } from "./utils.js";
+import { filterByType, getSharedScope, toErrorInfo, topologicalSort, validateActionScopes, validateBatchRequest, } from "./utils.js";
 /**
  * This class implements the IReactor interface and serves as the main entry point
  * for the new Reactor architecture.
@@ -16,19 +16,33 @@ export class Reactor {
     queue;
     jobTracker;
     readModelCoordinator;
-    constructor(driveServer, documentStorage, queue, jobTracker, readModelCoordinator) {
+    features;
+    documentView;
+    _documentIndexer;
+    operationStore;
+    _syncManager;
+    constructor(driveServer, documentStorage, queue, jobTracker, readModelCoordinator, features, documentView, documentIndexer, operationStore) {
         // Store required dependencies
         this.driveServer = driveServer;
         this.documentStorage = documentStorage;
         this.queue = queue;
         this.jobTracker = jobTracker;
         this.readModelCoordinator = readModelCoordinator;
-        // Start the read model coordinator
-        this.readModelCoordinator.start();
+        this.features = features;
+        this.documentView = documentView;
+        this._documentIndexer = documentIndexer;
+        this.operationStore = operationStore;
         // Create mutable shutdown status using factory method
         const [status, setter] = createMutableShutdownStatus(false);
         this.shutdownStatus = status;
         this.setShutdown = setter;
+        this.readModelCoordinator.start();
+    }
+    get syncManager() {
+        return this._syncManager;
+    }
+    setSync(syncManager) {
+        this._syncManager = syncManager;
     }
     /**
      * Signals that the reactor should shutdown.
@@ -36,10 +50,14 @@ export class Reactor {
     kill() {
         // Mark the reactor as shutdown
         this.setShutdown(true);
+        // Stop the sync manager if enabled
+        if (this._syncManager) {
+            this._syncManager.shutdown();
+        }
         // Stop the read model coordinator
         this.readModelCoordinator.stop();
-        // TODO: Phase 3+ - Implement graceful shutdown for queue, executors, etc.
-        // For now, we just mark as shutdown and return status
+        // Stop the job tracker
+        this.jobTracker.shutdown();
         return this.shutdownStatus;
     }
     /**
@@ -72,99 +90,196 @@ export class Reactor {
     /**
      * Retrieves a specific PHDocument by id
      */
-    async get(id, view, signal) {
-        const document = await this.documentStorage.get(id);
-        if (signal?.aborted) {
-            throw new AbortError();
-        }
-        const childIds = await this.documentStorage.getChildren(id);
-        if (signal?.aborted) {
-            throw new AbortError();
+    async get(id, view, consistencyToken, signal) {
+        if (this.features.legacyStorageEnabled) {
+            const document = await this.documentStorage.get(id);
+            if (signal?.aborted) {
+                throw new AbortError();
+            }
+            const childIds = await this.documentStorage.getChildren(id);
+            if (signal?.aborted) {
+                throw new AbortError();
+            }
+            for (const scope in document.state) {
+                if (!matchesScope(view, scope)) {
+                    delete document.state[scope];
+                }
+            }
+            return {
+                document,
+                childIds,
+            };
         }
-        // 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];
+        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 {
-            document,
-            childIds,
-        };
     }
     /**
      * Retrieves a specific PHDocument by slug
      */
-    async getBySlug(slug, view, signal) {
-        // Use the storage layer to resolve slug to ID
-        let ids;
-        try {
-            ids = await this.documentStorage.resolveIds([slug], signal);
+    async getBySlug(slug, view, consistencyToken, signal) {
+        if (this.features.legacyStorageEnabled) {
+            let ids;
+            try {
+                ids = await this.documentStorage.resolveIds([slug], 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);
         }
-        catch (error) {
-            // If the error is from resolveIds (document not found), wrap it with our message
-            if (error instanceof Error && error.message.includes("not found")) {
+        else {
+            const documentId = await this.documentView.resolveSlug(slug, view, consistencyToken, signal);
+            if (!documentId) {
                 throw new Error(`Document not found with slug: ${slug}`);
             }
-            throw error;
+            return await this.get(documentId, view, consistencyToken, signal);
         }
-        if (ids.length === 0 || !ids[0]) {
-            throw new Error(`Document not found with slug: ${slug}`);
+    }
+    /**
+     * Retrieves a specific PHDocument by identifier (either id or slug)
+     */
+    async getByIdOrSlug(identifier, view, consistencyToken, signal) {
+        if (this.features.legacyStorageEnabled) {
+            try {
+                return await this.get(identifier, view, consistencyToken, signal);
+            }
+            catch {
+                try {
+                    const ids = await this.documentStorage.resolveIds([identifier], 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}`);
+                }
+            }
+        }
+        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,
+            };
         }
-        // Now get the document by its resolved ID
-        return await this.get(ids[0], view, signal);
     }
     /**
      * Retrieves the operations for a document
      */
-    async getOperations(documentId, view, paging, signal) {
-        // Use storage directly to get the document
-        const document = await this.documentStorage.get(documentId);
-        if (signal?.aborted) {
-            throw new AbortError();
+    async getOperations(documentId, view, paging, consistencyToken, signal) {
+        if (this.features.legacyStorageEnabled) {
+            // Use storage directly to get the document
+            const document = await this.documentStorage.get(documentId);
+            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);
         }
-        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);
+        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);
+            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: pagedOperations,
-                    options: { cursor: String(startIndex + limit), limit },
+                    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;
         }
-        return Promise.resolve(result);
     }
     /**
      * Filters documents by criteria and returns a list of them
      */
-    async find(search, view, paging, signal) {
+    async find(search, view, paging, consistencyToken, signal) {
         let results;
         if (search.ids) {
             if (search.slugs && search.slugs.length > 0) {
                 throw new Error("Cannot use both ids and slugs in the same search");
             }
-            results = await this.findByIds(search.ids, view, paging, signal);
-            if (search.parentId) {
-                results = filterByParentId(results, search.parentId);
-            }
+            results = await this.findByIds(search.ids, view, paging, consistencyToken, signal);
             if (search.type) {
                 results = filterByType(results, search.type);
             }
         }
         else if (search.slugs) {
-            results = await this.findBySlugs(search.slugs, view, paging, signal);
-            if (search.parentId) {
-                results = filterByParentId(results, search.parentId);
-            }
+            results = await this.findBySlugs(search.slugs, view, paging, consistencyToken, signal);
             if (search.type) {
                 results = filterByType(results, search.type);
             }
@@ -176,7 +291,7 @@ export class Reactor {
             }
         }
         else if (search.type) {
-            results = await this.findByType(search.type, view, paging, signal);
+            results = await this.findByType(search.type, view, paging, consistencyToken, signal);
         }
         else {
             throw new Error("No search criteria provided");
@@ -238,10 +353,12 @@ export class Reactor {
         // Create a single job with both CREATE_DOCUMENT and UPGRADE_DOCUMENT actions
         const job = {
             id: uuidv4(),
+            kind: "mutation",
             documentId: document.header.id,
             scope: "document",
             branch: "main",
             actions: [createAction, upgradeAction],
+            operations: [],
             createdAt: new Date().toISOString(),
             queueHint: [],
             maxRetries: 3,
@@ -252,6 +369,11 @@ export class Reactor {
             id: job.id,
             status: JobStatus.PENDING,
             createdAtUtcIso,
+            consistencyToken: {
+                version: 1,
+                createdAtUtcIso,
+                coordinates: [],
+            },
         };
         this.jobTracker.registerJob(jobInfo);
         // Enqueue the job
@@ -279,10 +401,12 @@ export class Reactor {
         };
         const job = {
             id: uuidv4(),
+            kind: "mutation",
             documentId: id,
             scope: "document",
             branch: "main",
             actions: [action],
+            operations: [],
             createdAt: new Date().toISOString(),
             queueHint: [],
             maxRetries: 3,
@@ -292,6 +416,11 @@ export class Reactor {
             id: job.id,
             status: JobStatus.PENDING,
             createdAtUtcIso,
+            consistencyToken: {
+                version: 1,
+                createdAtUtcIso,
+                coordinates: [],
+            },
         };
         this.jobTracker.registerJob(jobInfo);
         await this.queue.enqueue(job);
@@ -300,17 +429,22 @@ export class Reactor {
     /**
      * Applies a list of actions to a document
      */
-    async mutate(id, actions) {
+    async mutate(docId, branch, actions, signal) {
+        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 job = {
             id: uuidv4(),
-            documentId: id,
+            kind: "mutation",
+            documentId: docId,
             scope: scope,
-            branch: "main", // Default to main branch
+            branch: branch,
             actions: actions,
+            operations: [],
             createdAt: new Date().toISOString(),
             queueHint: [],
             maxRetries: 3,
@@ -321,103 +455,190 @@ export class Reactor {
             id: job.id,
             status: JobStatus.PENDING,
             createdAtUtcIso,
+            consistencyToken: {
+                version: 1,
+                createdAtUtcIso,
+                coordinates: [],
+            },
         };
         this.jobTracker.registerJob(jobInfo);
         // Enqueue the job
         await this.queue.enqueue(job);
+        if (signal?.aborted) {
+            throw new AbortError();
+        }
         return jobInfo;
     }
     /**
-     * Adds multiple documents as children to another
+     * Imports pre-existing operations that were produced by another reactor.
+     * This function may cause a reshuffle, which will generate additional
+     * operations.
      */
-    async addChildren(parentId, documentIds, view, signal) {
-        const createdAtUtcIso = new Date().toISOString();
-        const jobId = uuidv4();
-        // Check abort signal before starting
+    async load(docId, branch, operations, signal) {
         if (signal?.aborted) {
             throw new AbortError();
         }
-        // TODO: Implement when drive server supports hierarchical documents
-        // For now, this is a placeholder implementation
-        // Verify parent exists
-        try {
-            await this.driveServer.getDocument(parentId);
+        if (operations.length === 0) {
+            throw new Error("load requires at least one operation");
         }
-        catch (error) {
-            return {
-                id: jobId,
-                status: JobStatus.FAILED,
+        // 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 createdAtUtcIso = new Date().toISOString();
+        const job = {
+            id: uuidv4(),
+            kind: "load",
+            documentId: docId,
+            scope,
+            branch,
+            actions: [],
+            operations,
+            createdAt: createdAtUtcIso,
+            queueHint: [],
+            maxRetries: 3,
+            errorHistory: [],
+        };
+        const jobInfo = {
+            id: job.id,
+            status: JobStatus.PENDING,
+            createdAtUtcIso,
+            consistencyToken: {
+                version: 1,
                 createdAtUtcIso,
-                error: this.toErrorInfo(error instanceof Error ? error : "Unknown error"),
-            };
+                coordinates: [],
+            },
+        };
+        this.jobTracker.registerJob(jobInfo);
+        await this.queue.enqueue(job);
+        if (signal?.aborted) {
+            throw new AbortError();
         }
-        // Check abort signal after parent verification
+        return jobInfo;
+    }
+    /**
+     * Applies multiple mutations across documents with dependency management
+     */
+    async mutateBatch(request, signal) {
         if (signal?.aborted) {
             throw new AbortError();
         }
-        // Verify all children exist
-        for (const childId of documentIds) {
-            try {
-                await this.driveServer.getDocument(childId);
-            }
-            catch (error) {
-                return {
-                    id: jobId,
-                    status: JobStatus.FAILED,
+        validateBatchRequest(request.jobs);
+        for (const jobPlan of request.jobs) {
+            validateActionScopes(jobPlan);
+        }
+        const createdAtUtcIso = new Date().toISOString();
+        const planKeyToJobId = new Map();
+        for (const jobPlan of request.jobs) {
+            planKeyToJobId.set(jobPlan.key, uuidv4());
+        }
+        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,
-                    error: this.toErrorInfo(error instanceof Error ? error : "Unknown error"),
+                    coordinates: [],
+                },
+            };
+            this.jobTracker.registerJob(jobInfo);
+            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: "mutation",
+                    documentId: jobPlan.documentId,
+                    scope: jobPlan.scope,
+                    branch: jobPlan.branch,
+                    actions: jobPlan.actions,
+                    operations: [],
+                    createdAt: createdAtUtcIso,
+                    queueHint,
+                    maxRetries: 3,
+                    errorHistory: [],
                 };
+                await this.queue.enqueue(job);
+                enqueuedKeys.push(key);
             }
-            // Check abort signal after each child verification
-            if (signal?.aborted) {
-                throw new AbortError();
+        }
+        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;
         }
-        // TODO: Actually establish parent-child relationships
-        // Return success job info
-        return {
-            id: jobId,
-            status: JobStatus.COMPLETED,
-            createdAtUtcIso,
-            completedAtUtcIso: new Date().toISOString(),
+        const result = {
+            jobs: Object.fromEntries(jobInfos),
         };
+        return result;
     }
     /**
-     * Removes multiple documents as children from another
+     * Adds multiple documents as children to another
      */
-    async removeChildren(parentId, documentIds, view, signal) {
-        const createdAtUtcIso = new Date().toISOString();
-        const jobId = uuidv4();
-        // Check abort signal before starting
+    async addChildren(parentId, documentIds, _view, signal) {
         if (signal?.aborted) {
             throw new AbortError();
         }
-        // TODO: Implement when drive server supports hierarchical documents
-        // For now, this is a placeholder implementation
-        // Verify parent exists
-        try {
-            await this.driveServer.getDocument(parentId);
-        }
-        catch (error) {
-            return {
-                id: jobId,
-                status: JobStatus.FAILED,
-                createdAtUtcIso,
-                error: this.toErrorInfo(error instanceof Error ? error : "Unknown error"),
-            };
-        }
-        // Check abort signal after parent verification
+        const actions = documentIds.map((childId) => ({
+            id: uuidv4(),
+            type: "ADD_RELATIONSHIP",
+            scope: "document",
+            timestampUtcMs: new Date().toISOString(),
+            input: {
+                sourceId: parentId,
+                targetId: childId,
+                relationshipType: "child",
+            },
+        }));
+        const branch = _view?.branch || "main";
+        return await this.mutate(parentId, branch, actions, signal);
+    }
+    /**
+     * Removes multiple documents as children from another
+     */
+    async removeChildren(parentId, documentIds, _view, signal) {
         if (signal?.aborted) {
             throw new AbortError();
         }
-        // TODO: Actually remove parent-child relationships
-        // Return success job info
-        return {
-            id: jobId,
-            status: JobStatus.COMPLETED,
-            createdAtUtcIso,
-            completedAtUtcIso: new Date().toISOString(),
-        };
+        const actions = documentIds.map((childId) => ({
+            id: uuidv4(),
+            type: "REMOVE_RELATIONSHIP",
+            scope: "document",
+            timestampUtcMs: new Date().toISOString(),
+            input: {
+                sourceId: parentId,
+                targetId: childId,
+                relationshipType: "child",
+            },
+        }));
+        const branch = _view?.branch || "main";
+        return await this.mutate(parentId, branch, actions, signal);
     }
     /**
      * Retrieves the status of a job
@@ -429,12 +650,18 @@ 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,
                 status: JobStatus.FAILED,
-                createdAtUtcIso: new Date().toISOString(),
-                completedAtUtcIso: new Date().toISOString(),
-                error: this.toErrorInfo("Job not found"),
+                createdAtUtcIso: now,
+                completedAtUtcIso: now,
+                error: toErrorInfo("Job not found"),
+                consistencyToken: {
+                    version: 1,
+                    createdAtUtcIso: now,
+                    coordinates: [],
+                },
             });
         }
         return Promise.resolve(jobInfo);
@@ -442,139 +669,233 @@ export class Reactor {
     /**
      * Finds documents by their IDs
      */
-    async findByIds(ids, view, paging, signal) {
-        const documents = [];
-        // Fetch each document by ID using storage directly
-        for (const id of ids) {
+    async findByIds(ids, view, paging, consistencyToken, signal) {
+        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);
+                }
+                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();
             }
-            let document;
-            try {
-                document = await this.documentStorage.get(id);
-            }
-            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];
+            // 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 }, undefined, 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;
                 }
             }
-            documents.push(document);
-        }
-        if (signal?.aborted) {
-            throw new AbortError();
+            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 }, undefined, signal)
+                    : undefined,
+            };
         }
-        // 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 }, signal)
-                : undefined,
-        };
     }
     /**
      * Finds documents by their slugs
      */
-    async findBySlugs(slugs, view, paging, signal) {
-        const documents = [];
-        // Use storage to resolve slugs to IDs
-        let ids;
-        try {
-            ids = await this.documentStorage.resolveIds(slugs, 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;
+    async findBySlugs(slugs, view, paging, consistencyToken, signal) {
+        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 {
-                document = await this.documentStorage.get(id);
+                ids = await this.documentStorage.resolveIds(slugs, signal);
             }
             catch {
-                // Skip documents that don't exist or can't be accessed
-                continue;
+                // If slug resolution fails, return empty results
+                // This matches the behavior expected from a search operation
+                ids = [];
             }
-            // 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];
+            // 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);
+                }
+                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);
             }
-            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 }, undefined, signal)
+                    : undefined,
+            };
         }
-        if (signal?.aborted) {
-            throw new AbortError();
+        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 }, undefined, signal)
+                    : undefined,
+            };
         }
-        // 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 }, signal)
-                : undefined,
-        };
     }
     /**
      * Finds documents by parent ID
      */
     async findByParentId(parentId, view, paging, signal) {
-        // Get child document IDs from storage
-        const childIds = await this.documentStorage.getChildren(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
-        for (const childId of childIds) {
+        // Fetch each child document using the appropriate storage method
+        for (const relationship of relationships) {
             if (signal?.aborted) {
                 throw new AbortError();
             }
-            let document;
             try {
-                document = await this.documentStorage.get(childId);
+                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
-                // 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();
@@ -598,61 +919,70 @@ export class Reactor {
     /**
      * Finds documents by type
      */
-    async findByType(type, view, paging, signal) {
-        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);
-        if (signal?.aborted) {
-            throw new AbortError();
-        }
-        // Fetch each document by its ID
-        for (const documentId of documentIds) {
+    async findByType(type, view, paging, consistencyToken, signal) {
+        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);
             if (signal?.aborted) {
                 throw new AbortError();
             }
-            let document;
-            try {
-                document = await this.documentStorage.get(documentId);
-            }
-            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];
+            // 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);
+                }
+                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);
             }
-            documents.push(document);
-        }
-        if (signal?.aborted) {
-            throw new AbortError();
+            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 }, undefined, signal)
+                    : undefined,
+            };
         }
-        // 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 }, signal)
-                : undefined,
-        };
-    }
-    toErrorInfo(error) {
-        if (error instanceof Error) {
+        else {
+            const result = await this.documentView.findByType(type, view, paging, undefined, signal);
+            if (signal?.aborted) {
+                throw new AbortError();
+            }
+            const cursor = paging?.cursor;
+            const limit = paging?.limit || 100;
             return {
-                message: error.message,
-                stack: error.stack || new Error().stack || "",
+                results: result.items,
+                options: paging || { cursor: cursor || "0", limit },
+                nextCursor: result.nextCursor,
+                next: result.nextCursor
+                    ? async () => this.findByType(type, view, { cursor: result.nextCursor, limit }, undefined, signal)
+                    : undefined,
             };
         }
-        return {
-            message: error,
-            stack: new Error().stack || "",
-        };
     }
 }
 //# sourceMappingURL=reactor.js.map