@powerhousedao/reactor 4.1.0-dev.101 → 4.1.0-dev.102

package/dist/src/core/reactor.js

@@ -16,13 +16,21 @@ export class Reactor {
     queue;
     jobTracker;
     readModelCoordinator;
-    constructor(driveServer, documentStorage, queue, jobTracker, readModelCoordinator) {
+    features;
+    documentView;
+    documentIndexer;
+    operationStore;
+    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;
+        this.features = features;
+        this.documentView = documentView;
+        this.documentIndexer = documentIndexer;
+        this.operationStore = operationStore;
         // Start the read model coordinator
         this.readModelCoordinator.start();
         // Create mutable shutdown status using factory method
@@ -72,87 +80,153 @@ 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);
-        }
-        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")) {
+    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}`);
             }
-            throw error;
+            return await this.get(ids[0], view, consistencyToken, signal);
         }
-        if (ids.length === 0 || !ids[0]) {
-            throw new Error(`Document not found with slug: ${slug}`);
+        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);
         }
-        // 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);
+            results = await this.findByIds(search.ids, view, paging, consistencyToken, signal);
             if (search.parentId) {
                 results = filterByParentId(results, search.parentId);
             }
@@ -161,7 +235,7 @@ export class Reactor {
             }
         }
         else if (search.slugs) {
-            results = await this.findBySlugs(search.slugs, view, paging, signal);
+            results = await this.findBySlugs(search.slugs, view, paging, consistencyToken, signal);
             if (search.parentId) {
                 results = filterByParentId(results, search.parentId);
             }
@@ -176,7 +250,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");
@@ -252,6 +326,11 @@ export class Reactor {
             id: job.id,
             status: JobStatus.PENDING,
             createdAtUtcIso,
+            consistencyToken: {
+                version: 1,
+                createdAtUtcIso,
+                coordinates: [],
+            },
         };
         this.jobTracker.registerJob(jobInfo);
         // Enqueue the job
@@ -292,6 +371,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);
@@ -321,6 +405,11 @@ export class Reactor {
             id: job.id,
             status: JobStatus.PENDING,
             createdAtUtcIso,
+            consistencyToken: {
+                version: 1,
+                createdAtUtcIso,
+                coordinates: [],
+            },
         };
         this.jobTracker.registerJob(jobInfo);
         // Enqueue the job
@@ -350,6 +439,11 @@ export class Reactor {
                 id: jobId,
                 status: JobStatus.PENDING,
                 createdAtUtcIso,
+                consistencyToken: {
+                    version: 1,
+                    createdAtUtcIso,
+                    coordinates: [],
+                },
             };
             this.jobTracker.registerJob(jobInfo);
             jobInfos.set(jobPlan.key, jobInfo);
@@ -385,7 +479,7 @@ export class Reactor {
                 try {
                     await this.queue.remove(jobId);
                 }
-                catch (removeError) {
+                catch {
                     // Ignore removal errors during cleanup
                 }
             }
@@ -402,7 +496,7 @@ export class Reactor {
     /**
      * Adds multiple documents as children to another
      */
-    async addChildren(parentId, documentIds, view, signal) {
+    async addChildren(parentId, documentIds, _view, signal) {
         if (signal?.aborted) {
             throw new AbortError();
         }
@@ -422,7 +516,7 @@ export class Reactor {
     /**
      * Removes multiple documents as children from another
      */
-    async removeChildren(parentId, documentIds, view, signal) {
+    async removeChildren(parentId, documentIds, _view, signal) {
         if (signal?.aborted) {
             throw new AbortError();
         }
@@ -449,12 +543,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(),
+                createdAtUtcIso: now,
+                completedAtUtcIso: now,
                 error: toErrorInfo("Job not found"),
+                consistencyToken: {
+                    version: 1,
+                    createdAtUtcIso: now,
+                    coordinates: [],
+                },
             });
         }
         return Promise.resolve(jobInfo);
@@ -462,205 +562,359 @@ 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);
+            }
+            if (signal?.aborted) {
+                throw new AbortError();
             }
-            documents.push(document);
+            // 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);
-        if (signal?.aborted) {
-            throw new AbortError();
-        }
-        const documents = [];
-        // Fetch each child document
-        for (const childId of childIds) {
+        if (this.features.legacyStorageEnabled) {
+            // Get child document IDs from storage
+            const childIds = await this.documentStorage.getChildren(parentId);
             if (signal?.aborted) {
                 throw new AbortError();
             }
-            let document;
-            try {
-                document = await this.documentStorage.get(childId);
+            const documents = [];
+            // Fetch each child document
+            for (const childId of childIds) {
+                if (signal?.aborted) {
+                    throw new AbortError();
+                }
+                let document;
+                try {
+                    document = await this.documentStorage.get(childId);
+                }
+                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);
             }
-            catch {
-                // Skip documents that don't exist or can't be accessed
-                // This matches the behavior expected from a search operation
-                continue;
+            if (signal?.aborted) {
+                throw new AbortError();
             }
-            // 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.findByParentId(parentId, view, { cursor: nextCursor, limit }, signal)
+                    : undefined,
+            };
+        }
+        else {
+            // 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 relationship of relationships) {
+                if (signal?.aborted) {
+                    throw new AbortError();
+                }
+                try {
+                    const 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;
                 }
             }
-            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.findByParentId(parentId, view, { cursor: nextCursor, limit }, 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.findByParentId(parentId, view, { cursor: nextCursor, limit }, signal)
-                : undefined,
-        };
     }
     /**
      * 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();
+            }
+            // 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,
+            };
         }
-        if (signal?.aborted) {
-            throw new AbortError();
+        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 {
+                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,
+            };
         }
-        // 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,
-        };
     }
 }
 //# sourceMappingURL=reactor.js.map