@enbox/dwn-sdk-js 0.3.9 → 0.4.0

package/dist/esm/tests/handlers/messages-sync.spec.js

@@ -9,7 +9,7 @@ import { TestDataGenerator } from '../utils/test-data-generator.js';
 import { TestEventLog } from '../test-event-stream.js';
 import { TestStores } from '../test-stores.js';
 import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'bun:test';
-import { DataStream, Dwn, DwnErrorCode, DwnInterfaceName, DwnMethodName, Encoder, PermissionGrant, PermissionsProtocol, RECORDS_PROJECTION_ROOT_VERSION, RecordsProjection, Time } from '../../src/index.js';
+import { DataStream, Dwn, DwnErrorCode, DwnInterfaceName, DwnMethodName, Encoder, PermissionGrant, PermissionsProtocol, Time } from '../../src/index.js';
 import { DidKey, UniversalResolver } from '@enbox/dids';
 export function testMessagesSyncHandler() {
     describe('MessagesSyncHandler.handle()', () => {
@@ -232,126 +232,6 @@ export function testMessagesSyncHandler() {
                 expect(reply.entries).toContain(protocolCid);
                 expect(reply.entries).toContain(recordCid);
             });
-            it('returns projected record leaves without protocol configs or out-of-path records', async () => {
-                const alice = await TestDataGenerator.generateDidKeyPersona();
-                const protocolDefinition = { ...freeForAll, published: true };
-                const protocol = protocolDefinition.protocol;
-                const { message: protocolMessage } = await TestDataGenerator.generateProtocolsConfigure({
-                    author: alice,
-                    protocolDefinition,
-                });
-                expect((await dwn.processMessage(alice.did, protocolMessage)).status.code).toBe(202);
-                const { message: postMessage, dataStream: postDataStream } = await TestDataGenerator.generateRecordsWrite({
-                    author: alice,
-                    protocol,
-                    protocolPath: 'post',
-                    schema: protocolDefinition.types.post.schema,
-                });
-                expect((await dwn.processMessage(alice.did, postMessage, { dataStream: postDataStream })).status.code).toBe(202);
-                const { message: attachmentMessage, dataStream: attachmentDataStream } = await TestDataGenerator.generateRecordsWrite({
-                    author: alice,
-                    protocol,
-                    protocolPath: 'post/attachment',
-                    parentContextId: postMessage.contextId,
-                });
-                expect((await dwn.processMessage(alice.did, attachmentMessage, { dataStream: attachmentDataStream })).status.code).toBe(202);
-                const { message } = await MessagesSync.create({
-                    signer: Jws.createSigner(alice),
-                    action: 'leaves',
-                    prefix: '',
-                    projectionRootVersion: RECORDS_PROJECTION_ROOT_VERSION,
-                    projectionScopes: [{ protocol, protocolPath: 'post' }],
-                });
-                const reply = await dwn.processMessage(alice.did, message);
-                expect(reply.status.code).toBe(200);
-                expect(reply.entries).toEqual([await Message.getCid(postMessage)]);
-                expect(reply.entries).not.toContain(await Message.getCid(protocolMessage));
-                expect(reply.entries).not.toContain(await Message.getCid(attachmentMessage));
-            });
-            it('excludes infrastructure protocols from records-primary projection leaves', async () => {
-                const alice = await TestDataGenerator.generateDidKeyPersona();
-                const bob = await TestDataGenerator.generateDidKeyPersona();
-                const { message: permissionGrantMessage, dataStream: permissionGrantDataStream } = await TestDataGenerator.generateGrantCreate({
-                    author: alice,
-                    grantedTo: bob,
-                    scope: {
-                        interface: DwnInterfaceName.Messages,
-                        method: DwnMethodName.Read,
-                        protocol: 'http://projected-sync-app-protocol',
-                    },
-                });
-                expect((await dwn.processMessage(alice.did, permissionGrantMessage, { dataStream: permissionGrantDataStream })).status.code).toBe(202);
-                const keyDeliverySchema = 'https://identity.foundation/schemas/key-delivery/context-key';
-                const keyDeliveryProtocolDefinition = {
-                    protocol: KEY_DELIVERY_PROTOCOL_URI,
-                    published: false,
-                    types: {
-                        contextKey: {
-                            schema: keyDeliverySchema,
-                            dataFormats: ['application/json'],
-                        },
-                    },
-                    structure: {
-                        contextKey: {},
-                    },
-                };
-                const { message: keyDeliveryConfigureMessage } = await TestDataGenerator.generateProtocolsConfigure({
-                    author: alice,
-                    protocolDefinition: keyDeliveryProtocolDefinition,
-                });
-                expect((await dwn.processMessage(alice.did, keyDeliveryConfigureMessage)).status.code).toBe(202);
-                const { message: keyDeliveryMessage, dataStream: keyDeliveryDataStream } = await TestDataGenerator.generateRecordsWrite({
-                    author: alice,
-                    protocol: KEY_DELIVERY_PROTOCOL_URI,
-                    protocolPath: 'contextKey',
-                    schema: keyDeliverySchema,
-                });
-                expect((await dwn.processMessage(alice.did, keyDeliveryMessage, { dataStream: keyDeliveryDataStream })).status.code).toBe(202);
-                for (const protocol of [PermissionsProtocol.uri, KEY_DELIVERY_PROTOCOL_URI]) {
-                    const { message } = await MessagesSync.create({
-                        signer: Jws.createSigner(alice),
-                        action: 'leaves',
-                        prefix: '',
-                        projectionRootVersion: RECORDS_PROJECTION_ROOT_VERSION,
-                        projectionScopes: [{ protocol }],
-                    });
-                    const reply = await dwn.processMessage(alice.did, message);
-                    expect(reply.status.code).toBe(200);
-                    expect(reply.entries).toEqual([]);
-                }
-            });
-            it('returns projected roots from the Records projection algorithm', async () => {
-                const alice = await TestDataGenerator.generateDidKeyPersona();
-                const protocolDefinition = { ...freeForAll, published: true };
-                const protocol = protocolDefinition.protocol;
-                const projectionScopes = [{ protocol, protocolPath: 'post' }];
-                const { message: protocolMessage } = await TestDataGenerator.generateProtocolsConfigure({
-                    author: alice,
-                    protocolDefinition,
-                });
-                expect((await dwn.processMessage(alice.did, protocolMessage)).status.code).toBe(202);
-                const { message: postMessage, dataStream: postDataStream } = await TestDataGenerator.generateRecordsWrite({
-                    author: alice,
-                    protocol,
-                    protocolPath: 'post',
-                    schema: protocolDefinition.types.post.schema,
-                });
-                expect((await dwn.processMessage(alice.did, postMessage, { dataStream: postDataStream })).status.code).toBe(202);
-                const expectedRoot = await RecordsProjection.getRootHex({
-                    tenant: alice.did,
-                    messageStore: messageStore,
-                    scopes: projectionScopes,
-                });
-                const { message } = await MessagesSync.create({
-                    signer: Jws.createSigner(alice),
-                    action: 'root',
-                    projectionRootVersion: RECORDS_PROJECTION_ROOT_VERSION,
-                    projectionScopes,
-                });
-                const reply = await dwn.processMessage(alice.did, message);
-                expect(reply.status.code).toBe(200);
-                expect(reply.root).toBe(expectedRoot);
-            });
         });
         describe('authorization', () => {
             it('returns 401 if tenant is not the author', async () => {
@@ -770,427 +650,6 @@ export function testMessagesSyncHandler() {
                         expect(reply.status.detail).toContain(DwnErrorCode.MessagesGrantAuthorizationMismatchedProtocol);
                     }
                 });
-                it('allows projected sync with a matching protocolPath Messages.Read grant', async () => {
-                    const alice = await TestDataGenerator.generateDidKeyPersona();
-                    const bob = await TestDataGenerator.generateDidKeyPersona();
-                    const protocolDefinition = { ...freeForAll, published: true };
-                    const protocol = protocolDefinition.protocol;
-                    const { message: protocolMessage } = await TestDataGenerator.generateProtocolsConfigure({
-                        author: alice,
-                        protocolDefinition,
-                    });
-                    expect((await dwn.processMessage(alice.did, protocolMessage)).status.code).toBe(202);
-                    const { message: postMessage, dataStream: postDataStream } = await TestDataGenerator.generateRecordsWrite({
-                        author: alice,
-                        protocol,
-                        protocolPath: 'post',
-                        schema: protocolDefinition.types.post.schema,
-                    });
-                    expect((await dwn.processMessage(alice.did, postMessage, { dataStream: postDataStream })).status.code).toBe(202);
-                    const { message: attachmentMessage, dataStream: attachmentDataStream } = await TestDataGenerator.generateRecordsWrite({
-                        author: alice,
-                        protocol,
-                        protocolPath: 'post/attachment',
-                        parentContextId: postMessage.contextId,
-                    });
-                    expect((await dwn.processMessage(alice.did, attachmentMessage, { dataStream: attachmentDataStream })).status.code).toBe(202);
-                    const { message: grantMessage, dataStream: grantDataStream } = await TestDataGenerator.generateGrantCreate({
-                        author: alice,
-                        grantedTo: bob,
-                        scope: {
-                            interface: DwnInterfaceName.Messages,
-                            method: DwnMethodName.Read,
-                            protocol,
-                            protocolPath: 'post',
-                        },
-                    });
-                    expect((await dwn.processMessage(alice.did, grantMessage, { dataStream: grantDataStream })).status.code).toBe(202);
-                    const { message: diffMsg } = await MessagesSync.create({
-                        signer: Jws.createSigner(bob),
-                        action: 'diff',
-                        hashes: {},
-                        depth: 2,
-                        projectionRootVersion: RECORDS_PROJECTION_ROOT_VERSION,
-                        projectionScopes: [{ protocol, protocolPath: 'post' }],
-                        permissionGrantIds: [grantMessage.recordId],
-                    });
-                    const reply = await dwn.processMessage(alice.did, diffMsg);
-                    expect(reply.status.code).toBe(200);
-                    const protocolCid = await Message.getCid(protocolMessage);
-                    const postCid = await Message.getCid(postMessage);
-                    const remoteCids = reply.onlyRemote.map(entry => entry.messageCid);
-                    expect(remoteCids).toContain(postCid);
-                    expect(remoteCids).not.toContain(protocolCid);
-                    expect(remoteCids).not.toContain(await Message.getCid(attachmentMessage));
-                    expect(reply.dependencies).toEqual([{
-                            dependencyClass: 'protocolsConfigure',
-                            messageCid: protocolCid,
-                            message: protocolMessage,
-                            rootMessageCid: postCid,
-                        }]);
-                });
-                it('returns the governing protocol config dependency for projected sync', async () => {
-                    const alice = await TestDataGenerator.generateDidKeyPersona();
-                    const bob = await TestDataGenerator.generateDidKeyPersona();
-                    const protocol = 'http://projected-sync-config-history';
-                    const protocolDefinition = {
-                        ...freeForAll,
-                        protocol,
-                        published: true,
-                    };
-                    const { message: firstProtocolMessage } = await TestDataGenerator.generateProtocolsConfigure({
-                        author: alice,
-                        messageTimestamp: '2026-01-01T00:00:00.000000Z',
-                        protocolDefinition,
-                    });
-                    expect((await dwn.processMessage(alice.did, firstProtocolMessage)).status.code).toBe(202);
-                    const { message: secondProtocolMessage } = await TestDataGenerator.generateProtocolsConfigure({
-                        author: alice,
-                        messageTimestamp: '2026-01-02T00:00:00.000000Z',
-                        protocolDefinition,
-                    });
-                    expect((await dwn.processMessage(alice.did, secondProtocolMessage)).status.code).toBe(202);
-                    const { message: postMessage, dataStream: postDataStream } = await TestDataGenerator.generateRecordsWrite({
-                        author: alice,
-                        dateCreated: '2026-01-03T00:00:00.000000Z',
-                        messageTimestamp: '2026-01-03T00:00:00.000000Z',
-                        protocol,
-                        protocolPath: 'post',
-                        schema: protocolDefinition.types.post.schema,
-                    });
-                    expect((await dwn.processMessage(alice.did, postMessage, { dataStream: postDataStream })).status.code).toBe(202);
-                    const { message: futureProtocolMessage } = await TestDataGenerator.generateProtocolsConfigure({
-                        author: alice,
-                        messageTimestamp: '2026-01-04T00:00:00.000000Z',
-                        protocolDefinition,
-                    });
-                    expect((await dwn.processMessage(alice.did, futureProtocolMessage)).status.code).toBe(202);
-                    const { message: grantMessage, dataStream: grantDataStream } = await TestDataGenerator.generateGrantCreate({
-                        author: alice,
-                        grantedTo: bob,
-                        scope: {
-                            interface: DwnInterfaceName.Messages,
-                            method: DwnMethodName.Read,
-                            protocol,
-                            protocolPath: 'post',
-                        },
-                    });
-                    expect((await dwn.processMessage(alice.did, grantMessage, { dataStream: grantDataStream })).status.code).toBe(202);
-                    const { message: diffMsg } = await MessagesSync.create({
-                        signer: Jws.createSigner(bob),
-                        action: 'diff',
-                        hashes: {},
-                        depth: 2,
-                        projectionRootVersion: RECORDS_PROJECTION_ROOT_VERSION,
-                        projectionScopes: [{ protocol, protocolPath: 'post' }],
-                        permissionGrantIds: [grantMessage.recordId],
-                    });
-                    const reply = await dwn.processMessage(alice.did, diffMsg);
-                    expect(reply.status.code).toBe(200);
-                    const postCid = await Message.getCid(postMessage);
-                    expect(reply.onlyRemote.map(entry => entry.messageCid)).toContain(postCid);
-                    expect(reply.dependencies.map(entry => entry.messageCid)).not.toContain(await Message.getCid(firstProtocolMessage));
-                    expect(reply.dependencies.map(entry => entry.messageCid)).not.toContain(await Message.getCid(futureProtocolMessage));
-                    expect(reply.dependencies).toEqual([
-                        {
-                            dependencyClass: 'protocolsConfigure',
-                            messageCid: await Message.getCid(secondProtocolMessage),
-                            message: secondProtocolMessage,
-                            rootMessageCid: postCid,
-                        },
-                    ]);
-                });
-                it('returns initial write and protocol config dependencies for projected delete tombstones', async () => {
-                    const alice = await TestDataGenerator.generateDidKeyPersona();
-                    const bob = await TestDataGenerator.generateDidKeyPersona();
-                    const protocolDefinition = { ...freeForAll, protocol: 'http://projected-sync-delete-hints', published: true };
-                    const unrelatedDefinition = { ...freeForAll, protocol: 'http://projected-sync-delete-hints-unrelated', published: true };
-                    const protocol = protocolDefinition.protocol;
-                    const { message: protocolMessage } = await TestDataGenerator.generateProtocolsConfigure({
-                        author: alice,
-                        protocolDefinition,
-                    });
-                    expect((await dwn.processMessage(alice.did, protocolMessage)).status.code).toBe(202);
-                    const { message: unrelatedProtocolMessage } = await TestDataGenerator.generateProtocolsConfigure({
-                        author: alice,
-                        protocolDefinition: unrelatedDefinition,
-                    });
-                    expect((await dwn.processMessage(alice.did, unrelatedProtocolMessage)).status.code).toBe(202);
-                    const { message: postMessage, dataStream: postDataStream } = await TestDataGenerator.generateRecordsWrite({
-                        author: alice,
-                        protocol,
-                        protocolPath: 'post',
-                        schema: protocolDefinition.types.post.schema,
-                    });
-                    expect((await dwn.processMessage(alice.did, postMessage, { dataStream: postDataStream })).status.code).toBe(202);
-                    const { message: deleteMessage } = await TestDataGenerator.generateRecordsDelete({
-                        author: alice,
-                        recordId: postMessage.recordId,
-                    });
-                    expect((await dwn.processMessage(alice.did, deleteMessage)).status.code).toBe(202);
-                    const { message: grantMessage, dataStream: grantDataStream } = await TestDataGenerator.generateGrantCreate({
-                        author: alice,
-                        grantedTo: bob,
-                        scope: {
-                            interface: DwnInterfaceName.Messages,
-                            method: DwnMethodName.Read,
-                            protocol,
-                            protocolPath: 'post',
-                        },
-                    });
-                    expect((await dwn.processMessage(alice.did, grantMessage, { dataStream: grantDataStream })).status.code).toBe(202);
-                    const { message: diffMsg } = await MessagesSync.create({
-                        signer: Jws.createSigner(bob),
-                        action: 'diff',
-                        hashes: {},
-                        depth: 2,
-                        projectionRootVersion: RECORDS_PROJECTION_ROOT_VERSION,
-                        projectionScopes: [{ protocol, protocolPath: 'post' }],
-                        permissionGrantIds: [grantMessage.recordId],
-                    });
-                    const reply = await dwn.processMessage(alice.did, diffMsg);
-                    expect(reply.status.code).toBe(200);
-                    const deleteCid = await Message.getCid(deleteMessage);
-                    const postCid = await Message.getCid(postMessage);
-                    const protocolCid = await Message.getCid(protocolMessage);
-                    expect(reply.onlyRemote.map(entry => entry.messageCid)).toEqual([deleteCid]);
-                    expect(reply.dependencies.map(entry => entry.messageCid)).not.toContain(await Message.getCid(unrelatedProtocolMessage));
-                    expect(reply.dependencies).toEqual([
-                        {
-                            dependencyClass: 'recordsInitialWrite',
-                            messageCid: postCid,
-                            message: postMessage,
-                            rootMessageCid: deleteCid,
-                        },
-                        {
-                            dependencyClass: 'protocolsConfigure',
-                            messageCid: protocolCid,
-                            message: protocolMessage,
-                            rootMessageCid: deleteCid,
-                        },
-                    ]);
-                    const initialWriteDependency = reply.dependencies.find(entry => entry.dependencyClass === 'recordsInitialWrite');
-                    expect(initialWriteDependency.encodedData).toBeUndefined();
-                    expect('encodedData' in initialWriteDependency.message).toBe(false);
-                });
-                it('returns composed protocol config dependencies for projected sync', async () => {
-                    const alice = await TestDataGenerator.generateDidKeyPersona();
-                    const bob = await TestDataGenerator.generateDidKeyPersona();
-                    const socialDefinition = {
-                        ...freeForAll,
-                        protocol: 'http://projected-sync-composed-social',
-                        published: true,
-                    };
-                    const profileDefinition = {
-                        ...freeForAll,
-                        protocol: 'http://projected-sync-composed-profile',
-                        published: true,
-                        uses: { social: socialDefinition.protocol },
-                    };
-                    const unrelatedDefinition = {
-                        ...freeForAll,
-                        protocol: 'http://projected-sync-composed-unrelated',
-                        published: true,
-                    };
-                    const { message: socialProtocolMessage } = await TestDataGenerator.generateProtocolsConfigure({
-                        author: alice,
-                        protocolDefinition: socialDefinition,
-                    });
-                    expect((await dwn.processMessage(alice.did, socialProtocolMessage)).status.code).toBe(202);
-                    const { message: profileProtocolMessage } = await TestDataGenerator.generateProtocolsConfigure({
-                        author: alice,
-                        protocolDefinition: profileDefinition,
-                    });
-                    expect((await dwn.processMessage(alice.did, profileProtocolMessage)).status.code).toBe(202);
-                    const { message: unrelatedProtocolMessage } = await TestDataGenerator.generateProtocolsConfigure({
-                        author: alice,
-                        protocolDefinition: unrelatedDefinition,
-                    });
-                    expect((await dwn.processMessage(alice.did, unrelatedProtocolMessage)).status.code).toBe(202);
-                    const { message: postMessage, dataStream: postDataStream } = await TestDataGenerator.generateRecordsWrite({
-                        author: alice,
-                        protocol: profileDefinition.protocol,
-                        protocolPath: 'post',
-                        schema: profileDefinition.types.post.schema,
-                    });
-                    expect((await dwn.processMessage(alice.did, postMessage, { dataStream: postDataStream })).status.code).toBe(202);
-                    const { message: grantMessage, dataStream: grantDataStream } = await TestDataGenerator.generateGrantCreate({
-                        author: alice,
-                        grantedTo: bob,
-                        scope: {
-                            interface: DwnInterfaceName.Messages,
-                            method: DwnMethodName.Read,
-                            protocol: profileDefinition.protocol,
-                            protocolPath: 'post',
-                        },
-                    });
-                    expect((await dwn.processMessage(alice.did, grantMessage, { dataStream: grantDataStream })).status.code).toBe(202);
-                    const { message: diffMsg } = await MessagesSync.create({
-                        signer: Jws.createSigner(bob),
-                        action: 'diff',
-                        hashes: {},
-                        depth: 2,
-                        projectionRootVersion: RECORDS_PROJECTION_ROOT_VERSION,
-                        projectionScopes: [{ protocol: profileDefinition.protocol, protocolPath: 'post' }],
-                        permissionGrantIds: [grantMessage.recordId],
-                    });
-                    const reply = await dwn.processMessage(alice.did, diffMsg);
-                    expect(reply.status.code).toBe(200);
-                    const postCid = await Message.getCid(postMessage);
-                    expect(reply.onlyRemote.map(entry => entry.messageCid)).toContain(postCid);
-                    expect(reply.dependencies.map(entry => entry.messageCid)).not.toContain(await Message.getCid(unrelatedProtocolMessage));
-                    expect(reply.dependencies).toEqual([
-                        {
-                            dependencyClass: 'protocolsConfigure',
-                            messageCid: await Message.getCid(profileProtocolMessage),
-                            message: profileProtocolMessage,
-                            rootMessageCid: postCid,
-                        },
-                        {
-                            dependencyClass: 'protocolsConfigure',
-                            messageCid: await Message.getCid(socialProtocolMessage),
-                            message: socialProtocolMessage,
-                            rootMessageCid: postCid,
-                        },
-                    ]);
-                });
-                it('terminates cyclic composed protocol dependencies for projected sync', async () => {
-                    const alice = await TestDataGenerator.generateDidKeyPersona();
-                    const bob = await TestDataGenerator.generateDidKeyPersona();
-                    const protocolA = 'http://projected-sync-cycle-a';
-                    const protocolB = 'http://projected-sync-cycle-b';
-                    const protocolBBaseDefinition = {
-                        ...freeForAll,
-                        protocol: protocolB,
-                        published: true,
-                    };
-                    const protocolADefinition = {
-                        ...freeForAll,
-                        protocol: protocolA,
-                        published: true,
-                        uses: { b: protocolB },
-                    };
-                    const protocolBCycleDefinition = {
-                        ...freeForAll,
-                        protocol: protocolB,
-                        published: true,
-                        uses: { a: protocolA },
-                    };
-                    const { message: protocolBBaseMessage } = await TestDataGenerator.generateProtocolsConfigure({
-                        author: alice,
-                        messageTimestamp: '2026-01-01T00:00:00.000000Z',
-                        protocolDefinition: protocolBBaseDefinition,
-                    });
-                    expect((await dwn.processMessage(alice.did, protocolBBaseMessage)).status.code).toBe(202);
-                    const { message: protocolAMessage } = await TestDataGenerator.generateProtocolsConfigure({
-                        author: alice,
-                        messageTimestamp: '2026-01-02T00:00:00.000000Z',
-                        protocolDefinition: protocolADefinition,
-                    });
-                    expect((await dwn.processMessage(alice.did, protocolAMessage)).status.code).toBe(202);
-                    const { message: protocolBCycleMessage } = await TestDataGenerator.generateProtocolsConfigure({
-                        author: alice,
-                        messageTimestamp: '2026-01-03T00:00:00.000000Z',
-                        protocolDefinition: protocolBCycleDefinition,
-                    });
-                    expect((await dwn.processMessage(alice.did, protocolBCycleMessage)).status.code).toBe(202);
-                    const { message: postMessage, dataStream: postDataStream } = await TestDataGenerator.generateRecordsWrite({
-                        author: alice,
-                        dateCreated: '2026-01-04T00:00:00.000000Z',
-                        messageTimestamp: '2026-01-04T00:00:00.000000Z',
-                        protocol: protocolA,
-                        protocolPath: 'post',
-                        schema: protocolADefinition.types.post.schema,
-                    });
-                    expect((await dwn.processMessage(alice.did, postMessage, { dataStream: postDataStream })).status.code).toBe(202);
-                    const { message: grantMessage, dataStream: grantDataStream } = await TestDataGenerator.generateGrantCreate({
-                        author: alice,
-                        grantedTo: bob,
-                        scope: {
-                            interface: DwnInterfaceName.Messages,
-                            method: DwnMethodName.Read,
-                            protocol: protocolA,
-                            protocolPath: 'post',
-                        },
-                    });
-                    expect((await dwn.processMessage(alice.did, grantMessage, { dataStream: grantDataStream })).status.code).toBe(202);
-                    const { message: diffMsg } = await MessagesSync.create({
-                        signer: Jws.createSigner(bob),
-                        action: 'diff',
-                        hashes: {},
-                        depth: 2,
-                        projectionRootVersion: RECORDS_PROJECTION_ROOT_VERSION,
-                        projectionScopes: [{ protocol: protocolA, protocolPath: 'post' }],
-                        permissionGrantIds: [grantMessage.recordId],
-                    });
-                    const reply = await dwn.processMessage(alice.did, diffMsg);
-                    expect(reply.status.code).toBe(200);
-                    const postCid = await Message.getCid(postMessage);
-                    const dependencyCids = reply.dependencies.map(entry => entry.messageCid);
-                    expect(reply.onlyRemote.map(entry => entry.messageCid)).toContain(postCid);
-                    expect(dependencyCids.sort()).toEqual([
-                        await Message.getCid(protocolAMessage),
-                        await Message.getCid(protocolBCycleMessage),
-                    ].sort());
-                    expect(dependencyCids).not.toContain(await Message.getCid(protocolBBaseMessage));
-                    expect(reply.dependencies.every(entry => entry.rootMessageCid === postCid)).toBe(true);
-                });
-                it('rejects projected sync when no grant covers a requested projection scope', async () => {
-                    const alice = await TestDataGenerator.generateDidKeyPersona();
-                    const bob = await TestDataGenerator.generateDidKeyPersona();
-                    const protocol = 'http://projected-sync-scope-mismatch';
-                    const { message: grantMessage, dataStream: grantDataStream } = await TestDataGenerator.generateGrantCreate({
-                        author: alice,
-                        grantedTo: bob,
-                        scope: {
-                            interface: DwnInterfaceName.Messages,
-                            method: DwnMethodName.Read,
-                            protocol,
-                            protocolPath: 'post',
-                        },
-                    });
-                    expect((await dwn.processMessage(alice.did, grantMessage, { dataStream: grantDataStream })).status.code).toBe(202);
-                    const { message: syncMsg } = await MessagesSync.create({
-                        signer: Jws.createSigner(bob),
-                        action: 'root',
-                        projectionRootVersion: RECORDS_PROJECTION_ROOT_VERSION,
-                        projectionScopes: [{ protocol }],
-                        permissionGrantIds: [grantMessage.recordId],
-                    });
-                    const reply = await dwn.processMessage(alice.did, syncMsg);
-                    expect(reply.status.code).toBe(401);
-                    expect(reply.status.detail).toContain(DwnErrorCode.MessagesGrantAuthorizationProjectionScopeMismatch);
-                });
-                it('rejects projected sync when any requested projection scope is uncovered', async () => {
-                    const alice = await TestDataGenerator.generateDidKeyPersona();
-                    const bob = await TestDataGenerator.generateDidKeyPersona();
-                    const coveredProtocol = 'http://projected-sync-covered-scope';
-                    const uncoveredProtocol = 'http://projected-sync-uncovered-scope';
-                    const { message: grantMessage, dataStream: grantDataStream } = await TestDataGenerator.generateGrantCreate({
-                        author: alice,
-                        grantedTo: bob,
-                        scope: {
-                            interface: DwnInterfaceName.Messages,
-                            method: DwnMethodName.Read,
-                            protocol: coveredProtocol,
-                            protocolPath: 'post',
-                        },
-                    });
-                    expect((await dwn.processMessage(alice.did, grantMessage, { dataStream: grantDataStream })).status.code).toBe(202);
-                    const { message: syncMsg } = await MessagesSync.create({
-                        signer: Jws.createSigner(bob),
-                        action: 'root',
-                        projectionRootVersion: RECORDS_PROJECTION_ROOT_VERSION,
-                        projectionScopes: [
-                            { protocol: coveredProtocol, protocolPath: 'post' },
-                            { protocol: uncoveredProtocol, protocolPath: 'post' },
-                        ],
-                        permissionGrantIds: [grantMessage.recordId],
-                    });
-                    const reply = await dwn.processMessage(alice.did, syncMsg);
-                    expect(reply.status.code).toBe(401);
-                    expect(reply.status.detail).toContain(DwnErrorCode.MessagesGrantAuthorizationProjectionScopeMismatch);
-                });
                 it('rejects delegated MessagesSync of infrastructure protocols', async () => {
                     const alice = await TestDataGenerator.generateDidKeyPersona();
                     const bob = await TestDataGenerator.generateDidKeyPersona();
@@ -1256,77 +715,6 @@ export function testMessagesSyncHandler() {
                             expect(syncReply.status.detail).toContain(DwnErrorCode.MessagesGrantAuthorizationProtocolSyncInfrastructureProtocol);
                         }
                     }
-                    for (const { protocol, grantId } of infrastructureProtocolGrants) {
-                        const { message: projectedSyncMessage } = await MessagesSync.create({
-                            signer: Jws.createSigner(bob),
-                            action: 'diff',
-                            hashes: {},
-                            depth: 2,
-                            projectionRootVersion: RECORDS_PROJECTION_ROOT_VERSION,
-                            projectionScopes: [{ protocol }],
-                            permissionGrantIds: [grantId],
-                        });
-                        const projectedSyncReply = await dwn.processMessage(alice.did, projectedSyncMessage);
-                        expect(projectedSyncReply.status.code).toBe(401);
-                        expect(projectedSyncReply.status.detail).toContain(DwnErrorCode.MessagesGrantAuthorizationProjectionInfrastructureProtocol);
-                    }
-                });
-                it('allows projected sync with a matching contextId Messages.Read grant', async () => {
-                    const alice = await TestDataGenerator.generateDidKeyPersona();
-                    const bob = await TestDataGenerator.generateDidKeyPersona();
-                    const protocolDefinition = { ...freeForAll, published: true };
-                    const protocol = protocolDefinition.protocol;
-                    const { message: protocolMessage } = await TestDataGenerator.generateProtocolsConfigure({
-                        author: alice,
-                        protocolDefinition,
-                    });
-                    expect((await dwn.processMessage(alice.did, protocolMessage)).status.code).toBe(202);
-                    const { message: rootMessage, dataStream: rootDataStream } = await TestDataGenerator.generateRecordsWrite({
-                        author: alice,
-                        protocol,
-                        protocolPath: 'post',
-                        schema: protocolDefinition.types.post.schema,
-                    });
-                    expect((await dwn.processMessage(alice.did, rootMessage, { dataStream: rootDataStream })).status.code).toBe(202);
-                    const { message: childMessage, dataStream: childDataStream } = await TestDataGenerator.generateRecordsWrite({
-                        author: alice,
-                        protocol,
-                        protocolPath: 'post/attachment',
-                        parentContextId: rootMessage.contextId,
-                    });
-                    expect((await dwn.processMessage(alice.did, childMessage, { dataStream: childDataStream })).status.code).toBe(202);
-                    const { message: siblingMessage, dataStream: siblingDataStream } = await TestDataGenerator.generateRecordsWrite({
-                        author: alice,
-                        protocol,
-                        protocolPath: 'post',
-                        schema: protocolDefinition.types.post.schema,
-                    });
-                    expect((await dwn.processMessage(alice.did, siblingMessage, { dataStream: siblingDataStream })).status.code).toBe(202);
-                    const { message: grantMessage, dataStream: grantDataStream } = await TestDataGenerator.generateGrantCreate({
-                        author: alice,
-                        grantedTo: bob,
-                        scope: {
-                            interface: DwnInterfaceName.Messages,
-                            method: DwnMethodName.Read,
-                            protocol,
-                            contextId: rootMessage.contextId,
-                        },
-                    });
-                    expect((await dwn.processMessage(alice.did, grantMessage, { dataStream: grantDataStream })).status.code).toBe(202);
-                    const { message: syncMsg } = await MessagesSync.create({
-                        signer: Jws.createSigner(bob),
-                        action: 'leaves',
-                        prefix: '',
-                        projectionRootVersion: RECORDS_PROJECTION_ROOT_VERSION,
-                        projectionScopes: [{ protocol, contextId: rootMessage.contextId }],
-                        permissionGrantIds: [grantMessage.recordId],
-                    });
-                    const reply = await dwn.processMessage(alice.did, syncMsg);
-                    expect(reply.status.code).toBe(200);
-                    expect(reply.entries).toContain(await Message.getCid(rootMessage));
-                    expect(reply.entries).toContain(await Message.getCid(childMessage));
-                    expect(reply.entries).not.toContain(await Message.getCid(protocolMessage));
-                    expect(reply.entries).not.toContain(await Message.getCid(siblingMessage));
                 });
                 it('returns only protocol-scoped diff entries for a delegated protocol grant', async () => {
                     const alice = await TestDataGenerator.generateDidKeyPersona();
@@ -1476,77 +864,6 @@ export function testMessagesSyncHandler() {
                     parseStub.restore();
                 }
             });
-            it('returns 400 when projection scopes are provided without a projection root version', async () => {
-                const alice = await TestDataGenerator.generateDidKeyPersona();
-                const { message } = await MessagesSync.create({
-                    signer: Jws.createSigner(alice),
-                    action: 'root',
-                    projectionRootVersion: RECORDS_PROJECTION_ROOT_VERSION,
-                    projectionScopes: [{ protocol: 'http://projected-sync-schema' }],
-                });
-                delete message.descriptor.projectionRootVersion;
-                const reply = await dwn.processMessage(alice.did, message);
-                expect(reply.status.code).toBe(400);
-                expect(reply.status.detail).toContain('SchemaValidatorFailure');
-            });
-            it('returns 400 when projection root version is provided without projection scopes', async () => {
-                const alice = await TestDataGenerator.generateDidKeyPersona();
-                const { message } = await MessagesSync.create({
-                    signer: Jws.createSigner(alice),
-                    action: 'root',
-                    projectionRootVersion: RECORDS_PROJECTION_ROOT_VERSION,
-                    projectionScopes: [{ protocol: 'http://projected-sync-schema' }],
-                });
-                delete message.descriptor.projectionScopes;
-                const reply = await dwn.processMessage(alice.did, message);
-                expect(reply.status.code).toBe(400);
-                expect(reply.status.detail).toContain('SchemaValidatorFailure');
-            });
-            it('returns 400 when projection root version is unsupported', async () => {
-                const alice = await TestDataGenerator.generateDidKeyPersona();
-                const { message } = await MessagesSync.create({
-                    signer: Jws.createSigner(alice),
-                    action: 'root',
-                    projectionRootVersion: RECORDS_PROJECTION_ROOT_VERSION,
-                    projectionScopes: [{ protocol: 'http://projected-sync-schema' }],
-                });
-                const unsupportedProjectionRootVersion = 'records-primary-scope-root-v2';
-                const descriptor = {
-                    ...message.descriptor,
-                    projectionRootVersion: unsupportedProjectionRootVersion,
-                };
-                const authorization = await Message.createAuthorization({
-                    descriptor,
-                    signer: Jws.createSigner(alice),
-                });
-                const unsupportedVersionMessage = {
-                    ...message,
-                    descriptor,
-                    authorization,
-                };
-                const validateJsonSchemaStub = sinon.stub(Message, 'validateJsonSchema');
-                try {
-                    const reply = await dwn.processMessage(alice.did, unsupportedVersionMessage);
-                    expect(reply.status.code).toBe(400);
-                    expect(reply.status.detail).toContain(DwnErrorCode.MessagesSyncUnsupportedProjectionRootVersion);
-                }
-                finally {
-                    validateJsonSchemaStub.restore();
-                }
-            });
-            it('returns 400 when projected sync also specifies a protocol root', async () => {
-                const alice = await TestDataGenerator.generateDidKeyPersona();
-                const { message } = await MessagesSync.create({
-                    signer: Jws.createSigner(alice),
-                    action: 'root',
-                    projectionRootVersion: RECORDS_PROJECTION_ROOT_VERSION,
-                    projectionScopes: [{ protocol: 'http://projected-sync-schema' }],
-                });
-                message.descriptor.protocol = 'http://projected-sync-schema';
-                const reply = await dwn.processMessage(alice.did, message);
-                expect(reply.status.code).toBe(400);
-                expect(reply.status.detail).toContain('SchemaValidatorFailure');
-            });
         });
         describe('diff action', () => {
             it('returns empty diff when client hashes match server hashes', async () => {