@enbox/dwn-sdk-js 0.0.6 → 0.0.8

package/dist/esm/tests/features/protocol-composition.spec.js

@@ -1,12 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import sinon from 'sinon';
 import { DataStream } from '../../src/utils/data-stream.js';
 import { Dwn } from '../../src/dwn.js';
@@ -15,13 +6,13 @@ import { Jws } from '../../src/utils/jws.js';
 import { Protocols } from '../../src/utils/protocols.js';
 import { Records } from '../../src/utils/records.js';
 import { TestDataGenerator } from '../utils/test-data-generator.js';
-import { TestEventStream } from '../test-event-stream.js';
+import { TestEventLog } from '../test-event-stream.js';
 import { TestStores } from '../test-stores.js';
 import { TestStubGenerator } from '../utils/test-stub-generator.js';
 import { X25519 } from '@enbox/crypto';
 import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'bun:test';
 import { DidKey, UniversalResolver } from '@enbox/dids';
-import { DwnErrorCode, Message, ProtocolsConfigure, RecordsDelete, RecordsQuery, RecordsRead, Time } from '../../src/index.js';
+import { DwnErrorCode, Message, ProtocolsConfigure, RecordsCount, RecordsDelete, RecordsQuery, RecordsRead, RecordsSubscribe, Time } from '../../src/index.js';
 import { HdKey, KeyDerivationScheme } from '../../src/utils/hd-key.js';
 /**
  * Tests for protocol composition using `uses` + `$ref`.
@@ -33,28 +24,28 @@ export function testProtocolComposition() {
         let dataStore;
         let resumableTaskStore;
         let stateIndex;
-        let eventStream;
+        let eventLog;
         let dwn;
-        beforeAll(() => __awaiter(this, void 0, void 0, function* () {
+        beforeAll(async () => {
             didResolver = new UniversalResolver({ didResolvers: [DidKey] });
             const stores = TestStores.get();
             messageStore = stores.messageStore;
             dataStore = stores.dataStore;
             resumableTaskStore = stores.resumableTaskStore;
             stateIndex = stores.stateIndex;
-            eventStream = TestEventStream.get();
-            dwn = yield Dwn.create({ didResolver, messageStore, dataStore, stateIndex, eventStream, resumableTaskStore });
-        }));
-        beforeEach(() => __awaiter(this, void 0, void 0, function* () {
+            eventLog = TestEventLog.get();
+            dwn = await Dwn.create({ didResolver, messageStore, dataStore, stateIndex, eventLog, resumableTaskStore });
+        });
+        beforeEach(async () => {
             sinon.restore();
-            yield messageStore.clear();
-            yield dataStore.clear();
-            yield resumableTaskStore.clear();
-            yield stateIndex.clear();
-        }));
-        afterAll(() => __awaiter(this, void 0, void 0, function* () {
-            yield dwn.close();
-        }));
+            await messageStore.clear();
+            await dataStore.clear();
+            await resumableTaskStore.clear();
+            await stateIndex.clear();
+        });
+        afterAll(async () => {
+            await dwn.close();
+        });
         // =========================================================================
         // Protocol definitions for tests
         // =========================================================================
@@ -117,18 +108,18 @@ export function testProtocolComposition() {
         // Validation tests (ProtocolsConfigure)
         // =========================================================================
         describe('ProtocolsConfigure validation', () => {
-            it('should accept a valid protocol definition with `uses` and `$ref`', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const protocolsConfigure = yield ProtocolsConfigure.create({
+            it('should accept a valid protocol definition with `uses` and `$ref`', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const protocolsConfigure = await ProtocolsConfigure.create({
                     definition: commentsProtocol,
                     signer: Jws.createSigner(alice),
                 });
                 expect(protocolsConfigure.message.descriptor.definition.uses).toEqual({
                     threads: 'https://threads.example.com',
                 });
-            }));
-            it('should reject `uses` alias that does not match naming pattern (bypassing JSON schema)', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should reject `uses` alias that does not match naming pattern (bypassing JSON schema)', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 // The JSON schema enforces alias naming via `patternProperties` + `additionalProperties: false`,
                 // which means invalid aliases like '123invalid' are caught by JSON schema before the code-level
                 // `validateUses()` check. To exercise the code-level `ProtocolsConfigureInvalidUsesAlias` error,
@@ -142,7 +133,7 @@ export function testProtocolComposition() {
                     structure: {},
                 };
                 try {
-                    yield ProtocolsConfigure.create({
+                    await ProtocolsConfigure.create({
                         definition: badDefinition,
                         signer: Jws.createSigner(alice),
                     });
@@ -151,9 +142,9 @@ export function testProtocolComposition() {
                 catch (error) {
                     expect(error.message).toContain(DwnErrorCode.ProtocolsConfigureInvalidUsesAlias);
                 }
-            }));
-            it('should reject `$ref` with alias not in `uses`', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should reject `$ref` with alias not in `uses`', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 const badDefinition = {
                     protocol: 'https://bad.example.com',
                     published: true,
@@ -171,7 +162,7 @@ export function testProtocolComposition() {
                     },
                 };
                 try {
-                    yield ProtocolsConfigure.create({
+                    await ProtocolsConfigure.create({
                         definition: badDefinition,
                         signer: Jws.createSigner(alice),
                     });
@@ -180,9 +171,9 @@ export function testProtocolComposition() {
                 catch (error) {
                     expect(error.message).toContain(DwnErrorCode.ProtocolsConfigureInvalidRefAlias);
                 }
-            }));
-            it('should reject `$ref` node with `$actions`', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should reject `$ref` node with `$actions`', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 const badDefinition = {
                     protocol: 'https://bad.example.com',
                     published: true,
@@ -199,7 +190,7 @@ export function testProtocolComposition() {
                     },
                 };
                 try {
-                    yield ProtocolsConfigure.create({
+                    await ProtocolsConfigure.create({
                         definition: badDefinition,
                         signer: Jws.createSigner(alice),
                     });
@@ -208,9 +199,9 @@ export function testProtocolComposition() {
                 catch (error) {
                     expect(error.message).toContain(DwnErrorCode.ProtocolsConfigureInvalidRefNodeHasDirectives);
                 }
-            }));
-            it('should reject `$ref` node with `$role`', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should reject `$ref` node with `$role`', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 const badDefinition = {
                     protocol: 'https://bad.example.com',
                     published: true,
@@ -224,7 +215,7 @@ export function testProtocolComposition() {
                     },
                 };
                 try {
-                    yield ProtocolsConfigure.create({
+                    await ProtocolsConfigure.create({
                         definition: badDefinition,
                         signer: Jws.createSigner(alice),
                     });
@@ -233,9 +224,9 @@ export function testProtocolComposition() {
                 catch (error) {
                     expect(error.message).toContain(DwnErrorCode.ProtocolsConfigureInvalidRefNodeHasDirectives);
                 }
-            }));
-            it('should reject cross-protocol `role` with alias not in `uses`', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should reject cross-protocol `role` with alias not in `uses`', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 const badDefinition = {
                     protocol: 'https://bad.example.com',
                     published: true,
@@ -253,7 +244,7 @@ export function testProtocolComposition() {
                     },
                 };
                 try {
-                    yield ProtocolsConfigure.create({
+                    await ProtocolsConfigure.create({
                         definition: badDefinition,
                         signer: Jws.createSigner(alice),
                     });
@@ -262,9 +253,9 @@ export function testProtocolComposition() {
                 catch (error) {
                     expect(error.message).toContain(DwnErrorCode.ProtocolsConfigureInvalidCrossProtocolRole);
                 }
-            }));
-            it('should reject `uses` with invalid protocol URL', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should reject `uses` with invalid protocol URL', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 const badDefinition = {
                     protocol: 'https://bad.example.com',
                     published: true,
@@ -273,7 +264,7 @@ export function testProtocolComposition() {
                     structure: {},
                 };
                 try {
-                    yield ProtocolsConfigure.create({
+                    await ProtocolsConfigure.create({
                         definition: badDefinition,
                         signer: Jws.createSigner(alice),
                     });
@@ -282,9 +273,9 @@ export function testProtocolComposition() {
                 catch (error) {
                     expect(error.message).toContain(DwnErrorCode.ProtocolsConfigureInvalidUsesProtocolUrl);
                 }
-            }));
-            it('should accept `$ref` referencing a multi-segment path in the referenced protocol', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should accept `$ref` referencing a multi-segment path in the referenced protocol', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 // The root-only constraint means `$ref` must appear at the root of the composing structure,
                 // but the REFERENCED path can be multi-segment (e.g., 'thread/participant').
                 const definition = {
@@ -304,22 +295,22 @@ export function testProtocolComposition() {
                     },
                 };
                 // ProtocolsConfigure.create() should succeed — the $ref is at root level
-                const protocolsConfigure = yield ProtocolsConfigure.create({
+                const protocolsConfigure = await ProtocolsConfigure.create({
                     definition,
                     signer: Jws.createSigner(alice),
                 });
                 expect(protocolsConfigure.message.descriptor.definition.uses).toBeDefined();
                 // Install-time validation should also succeed when the referenced protocol is installed
-                const threadsConfigure = yield ProtocolsConfigure.create({
+                const threadsConfigure = await ProtocolsConfigure.create({
                     definition: threadsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                yield dwn.processMessage(alice.did, threadsConfigure.message);
-                const installReply = yield dwn.processMessage(alice.did, protocolsConfigure.message);
+                await dwn.processMessage(alice.did, threadsConfigure.message);
+                const installReply = await dwn.processMessage(alice.did, protocolsConfigure.message);
                 expect(installReply.status.code).toBe(202);
-            }));
-            it('should not require `$ref` types in local types map', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should not require `$ref` types in local types map', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 // 'thread' is NOT in the local `types` — it comes from the $ref
                 const definition = {
                     protocol: 'https://comments.example.com',
@@ -336,53 +327,53 @@ export function testProtocolComposition() {
                     },
                 };
                 // should succeed without error
-                const protocolsConfigure = yield ProtocolsConfigure.create({
+                const protocolsConfigure = await ProtocolsConfigure.create({
                     definition,
                     signer: Jws.createSigner(alice),
                 });
                 expect(protocolsConfigure.message.descriptor.definition.uses).toBeDefined();
-            }));
+            });
         });
         // =========================================================================
         // Install-time validation tests (handler)
         // =========================================================================
         describe('install-time composition dependency validation', () => {
-            it('should reject composing protocol if `uses` protocol is not installed', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            it('should reject composing protocol if `uses` protocol is not installed', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 // Try to install comments protocol WITHOUT installing threads first
-                const commentsConfigure = yield ProtocolsConfigure.create({
+                const commentsConfigure = await ProtocolsConfigure.create({
                     definition: commentsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                const reply = yield dwn.processMessage(alice.did, commentsConfigure.message);
+                const reply = await dwn.processMessage(alice.did, commentsConfigure.message);
                 expect(reply.status.code).toBe(400);
                 expect(reply.status.detail).toContain(DwnErrorCode.ProtocolsConfigureComposedProtocolNotInstalled);
-            }));
-            it('should accept composing protocol when `uses` protocol is already installed', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should accept composing protocol when `uses` protocol is already installed', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 // Install threads protocol first
-                const threadsConfigure = yield ProtocolsConfigure.create({
+                const threadsConfigure = await ProtocolsConfigure.create({
                     definition: threadsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                const threadsReply = yield dwn.processMessage(alice.did, threadsConfigure.message);
+                const threadsReply = await dwn.processMessage(alice.did, threadsConfigure.message);
                 expect(threadsReply.status.code).toBe(202);
                 // Now install comments protocol — should succeed
-                const commentsConfigure = yield ProtocolsConfigure.create({
+                const commentsConfigure = await ProtocolsConfigure.create({
                     definition: commentsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                const commentsReply = yield dwn.processMessage(alice.did, commentsConfigure.message);
+                const commentsReply = await dwn.processMessage(alice.did, commentsConfigure.message);
                 expect(commentsReply.status.code).toBe(202);
-            }));
-            it('should reject composing protocol if `$ref` path does not exist in referenced protocol', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should reject composing protocol if `$ref` path does not exist in referenced protocol', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 // Install threads protocol first
-                const threadsConfigure = yield ProtocolsConfigure.create({
+                const threadsConfigure = await ProtocolsConfigure.create({
                     definition: threadsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                yield dwn.processMessage(alice.did, threadsConfigure.message);
+                await dwn.processMessage(alice.did, threadsConfigure.message);
                 // Install a composing protocol that references a non-existent type path
                 const badDefinition = {
                     protocol: 'https://bad.example.com',
@@ -398,22 +389,22 @@ export function testProtocolComposition() {
                         },
                     },
                 };
-                const badConfigure = yield ProtocolsConfigure.create({
+                const badConfigure = await ProtocolsConfigure.create({
                     definition: badDefinition,
                     signer: Jws.createSigner(alice),
                 });
-                const reply = yield dwn.processMessage(alice.did, badConfigure.message);
+                const reply = await dwn.processMessage(alice.did, badConfigure.message);
                 expect(reply.status.code).toBe(400);
                 expect(reply.status.detail).toContain(DwnErrorCode.ProtocolsConfigureInvalidRefProtocolPath);
-            }));
-            it('should reject composing protocol if cross-protocol `of` path does not exist in referenced protocol', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should reject composing protocol if cross-protocol `of` path does not exist in referenced protocol', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 // Install threads protocol first
-                const threadsConfigure = yield ProtocolsConfigure.create({
+                const threadsConfigure = await ProtocolsConfigure.create({
                     definition: threadsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                yield dwn.processMessage(alice.did, threadsConfigure.message);
+                await dwn.processMessage(alice.did, threadsConfigure.message);
                 // Install a composing protocol with an `of` reference to a non-existent path
                 const badDefinition = {
                     protocol: 'https://bad.example.com',
@@ -431,22 +422,22 @@ export function testProtocolComposition() {
                         },
                     },
                 };
-                const badConfigure = yield ProtocolsConfigure.create({
+                const badConfigure = await ProtocolsConfigure.create({
                     definition: badDefinition,
                     signer: Jws.createSigner(alice),
                 });
-                const reply = yield dwn.processMessage(alice.did, badConfigure.message);
+                const reply = await dwn.processMessage(alice.did, badConfigure.message);
                 expect(reply.status.code).toBe(400);
                 expect(reply.status.detail).toContain(DwnErrorCode.ProtocolsConfigureInvalidCrossProtocolOf);
-            }));
-            it('should reject composing protocol if cross-protocol role does not exist in referenced protocol', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should reject composing protocol if cross-protocol role does not exist in referenced protocol', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 // Install threads protocol first
-                const threadsConfigure = yield ProtocolsConfigure.create({
+                const threadsConfigure = await ProtocolsConfigure.create({
                     definition: threadsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                yield dwn.processMessage(alice.did, threadsConfigure.message);
+                await dwn.processMessage(alice.did, threadsConfigure.message);
                 // Install a composing protocol with invalid cross-protocol role
                 const badDefinition = {
                     protocol: 'https://bad.example.com',
@@ -465,45 +456,45 @@ export function testProtocolComposition() {
                         },
                     },
                 };
-                const badConfigure = yield ProtocolsConfigure.create({
+                const badConfigure = await ProtocolsConfigure.create({
                     definition: badDefinition,
                     signer: Jws.createSigner(alice),
                 });
-                const reply = yield dwn.processMessage(alice.did, badConfigure.message);
+                const reply = await dwn.processMessage(alice.did, badConfigure.message);
                 expect(reply.status.code).toBe(400);
                 expect(reply.status.detail).toContain(DwnErrorCode.ProtocolsConfigureInvalidCrossProtocolRole);
-            }));
+            });
         });
         // =========================================================================
         // Runtime cross-protocol record creation tests
         // =========================================================================
         describe('cross-protocol record creation', () => {
-            it('should allow creating a child record in a composing protocol under a parent from a different protocol', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            it('should allow creating a child record in a composing protocol under a parent from a different protocol', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 // Install both protocols
-                const threadsConfigure = yield ProtocolsConfigure.create({
+                const threadsConfigure = await ProtocolsConfigure.create({
                     definition: threadsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                yield dwn.processMessage(alice.did, threadsConfigure.message);
-                const commentsConfigure = yield ProtocolsConfigure.create({
+                await dwn.processMessage(alice.did, threadsConfigure.message);
+                const commentsConfigure = await ProtocolsConfigure.create({
                     definition: commentsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                yield dwn.processMessage(alice.did, commentsConfigure.message);
+                await dwn.processMessage(alice.did, commentsConfigure.message);
                 // Create a thread record in the threads protocol
-                const threadWrite = yield TestDataGenerator.generateRecordsWrite({
+                const threadWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: threadsProtocol.protocol,
                     protocolPath: 'thread',
                     schema: 'https://threads.example.com/schemas/thread',
                     dataFormat: 'application/json',
                 });
-                const threadReply = yield dwn.processMessage(alice.did, threadWrite.message, { dataStream: threadWrite.dataStream });
+                const threadReply = await dwn.processMessage(alice.did, threadWrite.message, { dataStream: threadWrite.dataStream });
                 expect(threadReply.status.code).toBe(202);
                 const threadContextId = threadWrite.message.contextId;
                 // Create a comment record in the comments protocol, parented under the thread
-                const commentWrite = yield TestDataGenerator.generateRecordsWrite({
+                const commentWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: commentsProtocol.protocol,
                     protocolPath: 'thread/comment',
@@ -511,35 +502,35 @@ export function testProtocolComposition() {
                     dataFormat: 'application/json',
                     parentContextId: threadContextId,
                 });
-                const commentReply = yield dwn.processMessage(alice.did, commentWrite.message, { dataStream: commentWrite.dataStream });
+                const commentReply = await dwn.processMessage(alice.did, commentWrite.message, { dataStream: commentWrite.dataStream });
                 expect(commentReply.status.code).toBe(202);
                 // The comment's contextId should chain from the thread's contextId
                 expect(commentWrite.message.contextId).toBe(`${threadContextId}/${commentWrite.message.recordId}`);
-            }));
-            it('should allow creating a grandchild in the composing protocol under a cross-protocol child', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should allow creating a grandchild in the composing protocol under a cross-protocol child', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 // Install both protocols
-                const threadsConfigure = yield ProtocolsConfigure.create({
+                const threadsConfigure = await ProtocolsConfigure.create({
                     definition: threadsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                yield dwn.processMessage(alice.did, threadsConfigure.message);
-                const commentsConfigure = yield ProtocolsConfigure.create({
+                await dwn.processMessage(alice.did, threadsConfigure.message);
+                const commentsConfigure = await ProtocolsConfigure.create({
                     definition: commentsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                yield dwn.processMessage(alice.did, commentsConfigure.message);
+                await dwn.processMessage(alice.did, commentsConfigure.message);
                 // Create thread -> comment -> reaction chain
-                const threadWrite = yield TestDataGenerator.generateRecordsWrite({
+                const threadWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: threadsProtocol.protocol,
                     protocolPath: 'thread',
                     schema: 'https://threads.example.com/schemas/thread',
                     dataFormat: 'application/json',
                 });
-                yield dwn.processMessage(alice.did, threadWrite.message, { dataStream: threadWrite.dataStream });
+                await dwn.processMessage(alice.did, threadWrite.message, { dataStream: threadWrite.dataStream });
                 const threadContextId = threadWrite.message.contextId;
-                const commentWrite = yield TestDataGenerator.generateRecordsWrite({
+                const commentWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: commentsProtocol.protocol,
                     protocolPath: 'thread/comment',
@@ -547,10 +538,10 @@ export function testProtocolComposition() {
                     dataFormat: 'application/json',
                     parentContextId: threadContextId,
                 });
-                yield dwn.processMessage(alice.did, commentWrite.message, { dataStream: commentWrite.dataStream });
+                await dwn.processMessage(alice.did, commentWrite.message, { dataStream: commentWrite.dataStream });
                 const commentContextId = commentWrite.message.contextId;
                 // Create a reaction under the comment (grandchild, same composing protocol)
-                const reactionWrite = yield TestDataGenerator.generateRecordsWrite({
+                const reactionWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: commentsProtocol.protocol,
                     protocolPath: 'thread/comment/reaction',
@@ -558,104 +549,104 @@ export function testProtocolComposition() {
                     dataFormat: 'application/json',
                     parentContextId: commentContextId,
                 });
-                const reactionReply = yield dwn.processMessage(alice.did, reactionWrite.message, { dataStream: reactionWrite.dataStream });
+                const reactionReply = await dwn.processMessage(alice.did, reactionWrite.message, { dataStream: reactionWrite.dataStream });
                 expect(reactionReply.status.code).toBe(202);
-            }));
+            });
         });
         // =========================================================================
         // Writing at the $ref position
         // =========================================================================
         describe('writing at the $ref position', () => {
-            it('should reject a non-tenant writing at the `$ref` position because `$ref` nodes have no `$actions`', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
+            it('should reject a non-tenant writing at the `$ref` position because `$ref` nodes have no `$actions`', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
                 // Install both protocols on Alice's DWN
-                const threadsConfigure = yield ProtocolsConfigure.create({
+                const threadsConfigure = await ProtocolsConfigure.create({
                     definition: threadsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                yield dwn.processMessage(alice.did, threadsConfigure.message);
-                const commentsConfigure = yield ProtocolsConfigure.create({
+                await dwn.processMessage(alice.did, threadsConfigure.message);
+                const commentsConfigure = await ProtocolsConfigure.create({
                     definition: commentsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                yield dwn.processMessage(alice.did, commentsConfigure.message);
+                await dwn.processMessage(alice.did, commentsConfigure.message);
                 // Bob tries to write a record at the `$ref` position (protocolPath: 'thread')
                 // through the composing protocol. The `$ref` node has no `$actions`, so this should
                 // be rejected for any non-tenant author.
-                const threadWriteAtRef = yield TestDataGenerator.generateRecordsWrite({
+                const threadWriteAtRef = await TestDataGenerator.generateRecordsWrite({
                     author: bob,
                     protocol: commentsProtocol.protocol,
                     protocolPath: 'thread',
                     schema: 'https://threads.example.com/schemas/thread',
                     dataFormat: 'application/json',
                 });
-                const reply = yield dwn.processMessage(alice.did, threadWriteAtRef.message, { dataStream: threadWriteAtRef.dataStream });
+                const reply = await dwn.processMessage(alice.did, threadWriteAtRef.message, { dataStream: threadWriteAtRef.dataStream });
                 expect(reply.status.code).toBe(401);
                 expect(reply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionRulesNotFound);
-            }));
-            it('should resolve type from the referenced protocol for records at the `$ref` position', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should resolve type from the referenced protocol for records at the `$ref` position', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 // Install both protocols on Alice's DWN
-                const threadsConfigure = yield ProtocolsConfigure.create({
+                const threadsConfigure = await ProtocolsConfigure.create({
                     definition: threadsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                yield dwn.processMessage(alice.did, threadsConfigure.message);
-                const commentsConfigure = yield ProtocolsConfigure.create({
+                await dwn.processMessage(alice.did, threadsConfigure.message);
+                const commentsConfigure = await ProtocolsConfigure.create({
                     definition: commentsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                yield dwn.processMessage(alice.did, commentsConfigure.message);
+                await dwn.processMessage(alice.did, commentsConfigure.message);
                 // Alice (tenant) writes at the `$ref` position using the WRONG schema.
                 // The type at position 'thread' should resolve from the threads protocol, which expects
                 // schema 'https://threads.example.com/schemas/thread'. Using a different schema should fail.
-                const wrongSchemaWrite = yield TestDataGenerator.generateRecordsWrite({
+                const wrongSchemaWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: commentsProtocol.protocol,
                     protocolPath: 'thread',
                     schema: 'https://comments.example.com/schemas/comment', // wrong schema
                     dataFormat: 'application/json',
                 });
-                const reply = yield dwn.processMessage(alice.did, wrongSchemaWrite.message, { dataStream: wrongSchemaWrite.dataStream });
+                const reply = await dwn.processMessage(alice.did, wrongSchemaWrite.message, { dataStream: wrongSchemaWrite.dataStream });
                 expect(reply.status.code).toBe(400);
                 // Type verification should fail because the schema doesn't match the referenced protocol's type
-            }));
+            });
         });
         // =========================================================================
         // Cross-protocol role invocation tests
         // =========================================================================
         describe('cross-protocol role invocation', () => {
-            it('should allow a cross-protocol role holder to perform actions in the composing protocol', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
+            it('should allow a cross-protocol role holder to perform actions in the composing protocol', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
                 // Install threads protocol on Alice's DWN
-                const threadsConfigure = yield ProtocolsConfigure.create({
+                const threadsConfigure = await ProtocolsConfigure.create({
                     definition: threadsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                const threadsReply = yield dwn.processMessage(alice.did, threadsConfigure.message);
+                const threadsReply = await dwn.processMessage(alice.did, threadsConfigure.message);
                 expect(threadsReply.status.code).toBe(202);
                 // Install comments protocol on Alice's DWN
-                const commentsConfigure = yield ProtocolsConfigure.create({
+                const commentsConfigure = await ProtocolsConfigure.create({
                     definition: commentsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                const commentsReply = yield dwn.processMessage(alice.did, commentsConfigure.message);
+                const commentsReply = await dwn.processMessage(alice.did, commentsConfigure.message);
                 expect(commentsReply.status.code).toBe(202);
                 // Alice creates a thread
-                const threadWrite = yield TestDataGenerator.generateRecordsWrite({
+                const threadWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: threadsProtocol.protocol,
                     protocolPath: 'thread',
                     schema: 'https://threads.example.com/schemas/thread',
                     dataFormat: 'application/json',
                 });
-                const threadReply = yield dwn.processMessage(alice.did, threadWrite.message, { dataStream: threadWrite.dataStream });
+                const threadReply = await dwn.processMessage(alice.did, threadWrite.message, { dataStream: threadWrite.dataStream });
                 expect(threadReply.status.code).toBe(202);
                 const threadContextId = threadWrite.message.contextId;
                 // Alice assigns Bob as a participant in the thread (role record in threads protocol)
-                const participantWrite = yield TestDataGenerator.generateRecordsWrite({
+                const participantWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     recipient: bob.did,
                     protocol: threadsProtocol.protocol,
@@ -664,10 +655,10 @@ export function testProtocolComposition() {
                     dataFormat: 'application/json',
                     parentContextId: threadContextId,
                 });
-                const participantReply = yield dwn.processMessage(alice.did, participantWrite.message, { dataStream: participantWrite.dataStream });
+                const participantReply = await dwn.processMessage(alice.did, participantWrite.message, { dataStream: participantWrite.dataStream });
                 expect(participantReply.status.code).toBe(202);
                 // Bob invokes the cross-protocol role to read comments
-                const commentWrite = yield TestDataGenerator.generateRecordsWrite({
+                const commentWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: commentsProtocol.protocol,
                     protocolPath: 'thread/comment',
@@ -675,10 +666,10 @@ export function testProtocolComposition() {
                     dataFormat: 'application/json',
                     parentContextId: threadContextId,
                 });
-                const commentReply = yield dwn.processMessage(alice.did, commentWrite.message, { dataStream: commentWrite.dataStream });
+                const commentReply = await dwn.processMessage(alice.did, commentWrite.message, { dataStream: commentWrite.dataStream });
                 expect(commentReply.status.code).toBe(202);
                 // Bob reads the comment using the cross-protocol role
-                const bobRead = yield RecordsRead.create({
+                const bobRead = await RecordsRead.create({
                     signer: Jws.createSigner(bob),
                     protocolRole: 'threads:thread/participant',
                     filter: {
@@ -687,36 +678,35 @@ export function testProtocolComposition() {
                         contextId: threadContextId,
                     },
                 });
-                const bobReadReply = yield dwn.processMessage(alice.did, bobRead.message);
+                const bobReadReply = await dwn.processMessage(alice.did, bobRead.message);
                 expect(bobReadReply.status.code).toBe(200);
-            }));
-            it('should allow a cross-protocol role holder to query records in the composing protocol', () => __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should allow a cross-protocol role holder to query records in the composing protocol', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
                 // Install both protocols on Alice's DWN
-                const threadsConfigure = yield ProtocolsConfigure.create({
+                const threadsConfigure = await ProtocolsConfigure.create({
                     definition: threadsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                yield dwn.processMessage(alice.did, threadsConfigure.message);
-                const commentsConfigure = yield ProtocolsConfigure.create({
+                await dwn.processMessage(alice.did, threadsConfigure.message);
+                const commentsConfigure = await ProtocolsConfigure.create({
                     definition: commentsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                yield dwn.processMessage(alice.did, commentsConfigure.message);
+                await dwn.processMessage(alice.did, commentsConfigure.message);
                 // Alice creates a thread
-                const threadWrite = yield TestDataGenerator.generateRecordsWrite({
+                const threadWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: threadsProtocol.protocol,
                     protocolPath: 'thread',
                     schema: 'https://threads.example.com/schemas/thread',
                     dataFormat: 'application/json',
                 });
-                yield dwn.processMessage(alice.did, threadWrite.message, { dataStream: threadWrite.dataStream });
+                await dwn.processMessage(alice.did, threadWrite.message, { dataStream: threadWrite.dataStream });
                 const threadContextId = threadWrite.message.contextId;
                 // Alice assigns Bob as a participant
-                const participantWrite = yield TestDataGenerator.generateRecordsWrite({
+                const participantWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     recipient: bob.did,
                     protocol: threadsProtocol.protocol,
@@ -725,9 +715,9 @@ export function testProtocolComposition() {
                     dataFormat: 'application/json',
                     parentContextId: threadContextId,
                 });
-                yield dwn.processMessage(alice.did, participantWrite.message, { dataStream: participantWrite.dataStream });
+                await dwn.processMessage(alice.did, participantWrite.message, { dataStream: participantWrite.dataStream });
                 // Alice creates two comments
-                const comment1 = yield TestDataGenerator.generateRecordsWrite({
+                const comment1 = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: commentsProtocol.protocol,
                     protocolPath: 'thread/comment',
@@ -735,8 +725,8 @@ export function testProtocolComposition() {
                     dataFormat: 'application/json',
                     parentContextId: threadContextId,
                 });
-                yield dwn.processMessage(alice.did, comment1.message, { dataStream: comment1.dataStream });
-                const comment2 = yield TestDataGenerator.generateRecordsWrite({
+                await dwn.processMessage(alice.did, comment1.message, { dataStream: comment1.dataStream });
+                const comment2 = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: commentsProtocol.protocol,
                     protocolPath: 'thread/comment',
@@ -744,9 +734,9 @@ export function testProtocolComposition() {
                     dataFormat: 'application/json',
                     parentContextId: threadContextId,
                 });
-                yield dwn.processMessage(alice.did, comment2.message, { dataStream: comment2.dataStream });
+                await dwn.processMessage(alice.did, comment2.message, { dataStream: comment2.dataStream });
                 // Bob queries comments using the cross-protocol role
-                const bobQuery = yield RecordsQuery.create({
+                const bobQuery = await RecordsQuery.create({
                     signer: Jws.createSigner(bob),
                     protocolRole: 'threads:thread/participant',
                     filter: {
@@ -755,37 +745,37 @@ export function testProtocolComposition() {
                         contextId: threadContextId,
                     },
                 });
-                const bobQueryReply = yield dwn.processMessage(alice.did, bobQuery.message);
+                const bobQueryReply = await dwn.processMessage(alice.did, bobQuery.message);
                 expect(bobQueryReply.status.code).toBe(200);
-                expect((_a = bobQueryReply.entries) === null || _a === void 0 ? void 0 : _a.length).toBe(2);
-            }));
-            it('should allow a cross-protocol role holder to co-delete records in the composing protocol', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
-                const carol = yield TestDataGenerator.generateDidKeyPersona();
+                expect(bobQueryReply.entries?.length).toBe(2);
+            });
+            it('should allow a cross-protocol role holder to co-delete records in the composing protocol', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
+                const carol = await TestDataGenerator.generateDidKeyPersona();
                 // Install both protocols on Alice's DWN
-                const threadsConfigure = yield ProtocolsConfigure.create({
+                const threadsConfigure = await ProtocolsConfigure.create({
                     definition: threadsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                yield dwn.processMessage(alice.did, threadsConfigure.message);
-                const commentsConfigure = yield ProtocolsConfigure.create({
+                await dwn.processMessage(alice.did, threadsConfigure.message);
+                const commentsConfigure = await ProtocolsConfigure.create({
                     definition: commentsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                yield dwn.processMessage(alice.did, commentsConfigure.message);
+                await dwn.processMessage(alice.did, commentsConfigure.message);
                 // Alice creates a thread
-                const threadWrite = yield TestDataGenerator.generateRecordsWrite({
+                const threadWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: threadsProtocol.protocol,
                     protocolPath: 'thread',
                     schema: 'https://threads.example.com/schemas/thread',
                     dataFormat: 'application/json',
                 });
-                yield dwn.processMessage(alice.did, threadWrite.message, { dataStream: threadWrite.dataStream });
+                await dwn.processMessage(alice.did, threadWrite.message, { dataStream: threadWrite.dataStream });
                 const threadContextId = threadWrite.message.contextId;
                 // Alice assigns Bob as a participant (role record)
-                const participantWrite = yield TestDataGenerator.generateRecordsWrite({
+                const participantWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     recipient: bob.did,
                     protocol: threadsProtocol.protocol,
@@ -794,9 +784,9 @@ export function testProtocolComposition() {
                     dataFormat: 'application/json',
                     parentContextId: threadContextId,
                 });
-                yield dwn.processMessage(alice.did, participantWrite.message, { dataStream: participantWrite.dataStream });
+                await dwn.processMessage(alice.did, participantWrite.message, { dataStream: participantWrite.dataStream });
                 // Carol creates a comment (via 'anyone' can 'create')
-                const carolComment = yield TestDataGenerator.generateRecordsWrite({
+                const carolComment = await TestDataGenerator.generateRecordsWrite({
                     author: carol,
                     protocol: commentsProtocol.protocol,
                     protocolPath: 'thread/comment',
@@ -804,43 +794,43 @@ export function testProtocolComposition() {
                     dataFormat: 'application/json',
                     parentContextId: threadContextId,
                 });
-                yield dwn.processMessage(alice.did, carolComment.message, { dataStream: carolComment.dataStream });
+                await dwn.processMessage(alice.did, carolComment.message, { dataStream: carolComment.dataStream });
                 // Bob (participant) co-deletes Carol's comment using the cross-protocol role
                 // The commentsProtocol grants 'threads:thread/participant' the 'co-delete' action on comments
-                const bobDelete = yield RecordsDelete.create({
+                const bobDelete = await RecordsDelete.create({
                     protocolRole: 'threads:thread/participant',
                     recordId: carolComment.message.recordId,
                     signer: Jws.createSigner(bob),
                 });
-                const deleteReply = yield dwn.processMessage(alice.did, bobDelete.message);
+                const deleteReply = await dwn.processMessage(alice.did, bobDelete.message);
                 expect(deleteReply.status.code).toBe(202);
-            }));
-            it('should deny cross-protocol role access when the role record has been deleted (revocation)', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should deny cross-protocol role access when the role record has been deleted (revocation)', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
                 // Install both protocols on Alice's DWN
-                const threadsConfigure = yield ProtocolsConfigure.create({
+                const threadsConfigure = await ProtocolsConfigure.create({
                     definition: threadsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                yield dwn.processMessage(alice.did, threadsConfigure.message);
-                const commentsConfigure = yield ProtocolsConfigure.create({
+                await dwn.processMessage(alice.did, threadsConfigure.message);
+                const commentsConfigure = await ProtocolsConfigure.create({
                     definition: commentsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                yield dwn.processMessage(alice.did, commentsConfigure.message);
+                await dwn.processMessage(alice.did, commentsConfigure.message);
                 // Alice creates a thread
-                const threadWrite = yield TestDataGenerator.generateRecordsWrite({
+                const threadWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: threadsProtocol.protocol,
                     protocolPath: 'thread',
                     schema: 'https://threads.example.com/schemas/thread',
                     dataFormat: 'application/json',
                 });
-                yield dwn.processMessage(alice.did, threadWrite.message, { dataStream: threadWrite.dataStream });
+                await dwn.processMessage(alice.did, threadWrite.message, { dataStream: threadWrite.dataStream });
                 const threadContextId = threadWrite.message.contextId;
                 // Alice assigns Bob as a participant
-                const participantWrite = yield TestDataGenerator.generateRecordsWrite({
+                const participantWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     recipient: bob.did,
                     protocol: threadsProtocol.protocol,
@@ -849,9 +839,9 @@ export function testProtocolComposition() {
                     dataFormat: 'application/json',
                     parentContextId: threadContextId,
                 });
-                yield dwn.processMessage(alice.did, participantWrite.message, { dataStream: participantWrite.dataStream });
+                await dwn.processMessage(alice.did, participantWrite.message, { dataStream: participantWrite.dataStream });
                 // Alice creates a comment
-                const commentWrite = yield TestDataGenerator.generateRecordsWrite({
+                const commentWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: commentsProtocol.protocol,
                     protocolPath: 'thread/comment',
@@ -859,9 +849,9 @@ export function testProtocolComposition() {
                     dataFormat: 'application/json',
                     parentContextId: threadContextId,
                 });
-                yield dwn.processMessage(alice.did, commentWrite.message, { dataStream: commentWrite.dataStream });
+                await dwn.processMessage(alice.did, commentWrite.message, { dataStream: commentWrite.dataStream });
                 // Verify Bob CAN read the comment (role is active)
-                const bobRead = yield RecordsRead.create({
+                const bobRead = await RecordsRead.create({
                     signer: Jws.createSigner(bob),
                     protocolRole: 'threads:thread/participant',
                     filter: {
@@ -870,17 +860,17 @@ export function testProtocolComposition() {
                         contextId: threadContextId,
                     },
                 });
-                const bobReadReply = yield dwn.processMessage(alice.did, bobRead.message);
+                const bobReadReply = await dwn.processMessage(alice.did, bobRead.message);
                 expect(bobReadReply.status.code).toBe(200);
                 // Alice deletes Bob's participant role record (revocation)
-                const deleteRole = yield RecordsDelete.create({
+                const deleteRole = await RecordsDelete.create({
                     recordId: participantWrite.message.recordId,
                     signer: Jws.createSigner(alice),
                 });
-                const deleteRoleReply = yield dwn.processMessage(alice.did, deleteRole.message);
+                const deleteRoleReply = await dwn.processMessage(alice.did, deleteRole.message);
                 expect(deleteRoleReply.status.code).toBe(202);
                 // Bob tries to read the comment again — should be denied because role was deleted
-                const bobRead2 = yield RecordsRead.create({
+                const bobRead2 = await RecordsRead.create({
                     signer: Jws.createSigner(bob),
                     protocolRole: 'threads:thread/participant',
                     filter: {
@@ -889,36 +879,36 @@ export function testProtocolComposition() {
                         contextId: threadContextId,
                     },
                 });
-                const bobRead2Reply = yield dwn.processMessage(alice.did, bobRead2.message);
+                const bobRead2Reply = await dwn.processMessage(alice.did, bobRead2.message);
                 expect(bobRead2Reply.status.code).toBe(401);
                 expect(bobRead2Reply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationMatchingRoleRecordNotFound);
-            }));
-            it('should reject a cross-protocol role invocation if the invoker lacks the role record', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const carol = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should reject a cross-protocol role invocation if the invoker lacks the role record', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const carol = await TestDataGenerator.generateDidKeyPersona();
                 // Install both protocols
-                const threadsConfigure = yield ProtocolsConfigure.create({
+                const threadsConfigure = await ProtocolsConfigure.create({
                     definition: threadsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                yield dwn.processMessage(alice.did, threadsConfigure.message);
-                const commentsConfigure = yield ProtocolsConfigure.create({
+                await dwn.processMessage(alice.did, threadsConfigure.message);
+                const commentsConfigure = await ProtocolsConfigure.create({
                     definition: commentsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                yield dwn.processMessage(alice.did, commentsConfigure.message);
+                await dwn.processMessage(alice.did, commentsConfigure.message);
                 // Alice creates a thread
-                const threadWrite = yield TestDataGenerator.generateRecordsWrite({
+                const threadWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: threadsProtocol.protocol,
                     protocolPath: 'thread',
                     schema: 'https://threads.example.com/schemas/thread',
                     dataFormat: 'application/json',
                 });
-                yield dwn.processMessage(alice.did, threadWrite.message, { dataStream: threadWrite.dataStream });
+                await dwn.processMessage(alice.did, threadWrite.message, { dataStream: threadWrite.dataStream });
                 const threadContextId = threadWrite.message.contextId;
                 // Alice creates a comment
-                const commentWrite = yield TestDataGenerator.generateRecordsWrite({
+                const commentWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: commentsProtocol.protocol,
                     protocolPath: 'thread/comment',
@@ -926,9 +916,9 @@ export function testProtocolComposition() {
                     dataFormat: 'application/json',
                     parentContextId: threadContextId,
                 });
-                yield dwn.processMessage(alice.did, commentWrite.message, { dataStream: commentWrite.dataStream });
+                await dwn.processMessage(alice.did, commentWrite.message, { dataStream: commentWrite.dataStream });
                 // Carol (who has NO participant role) tries to read the comment using the cross-protocol role
-                const carolRead = yield RecordsRead.create({
+                const carolRead = await RecordsRead.create({
                     signer: Jws.createSigner(carol),
                     protocolRole: 'threads:thread/participant',
                     filter: {
@@ -937,42 +927,42 @@ export function testProtocolComposition() {
                         contextId: threadContextId,
                     },
                 });
-                const carolReadReply = yield dwn.processMessage(alice.did, carolRead.message);
+                const carolReadReply = await dwn.processMessage(alice.did, carolRead.message);
                 expect(carolReadReply.status.code).toBe(401);
                 expect(carolReadReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationMatchingRoleRecordNotFound);
-            }));
+            });
         });
         // =========================================================================
         // Cross-protocol `who`/`of` actor checks
         // =========================================================================
         describe('cross-protocol `who`/`of` actor checks', () => {
-            it('should allow `author` of a cross-protocol parent to perform actions in the composing protocol', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
+            it('should allow `author` of a cross-protocol parent to perform actions in the composing protocol', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
                 // Install both protocols
-                const threadsConfigure = yield ProtocolsConfigure.create({
+                const threadsConfigure = await ProtocolsConfigure.create({
                     definition: threadsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                yield dwn.processMessage(alice.did, threadsConfigure.message);
-                const commentsConfigure = yield ProtocolsConfigure.create({
+                await dwn.processMessage(alice.did, threadsConfigure.message);
+                const commentsConfigure = await ProtocolsConfigure.create({
                     definition: commentsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                yield dwn.processMessage(alice.did, commentsConfigure.message);
+                await dwn.processMessage(alice.did, commentsConfigure.message);
                 // Bob creates a thread (via the 'anyone' can 'create' rule)
-                const threadWrite = yield TestDataGenerator.generateRecordsWrite({
+                const threadWrite = await TestDataGenerator.generateRecordsWrite({
                     author: bob,
                     protocol: threadsProtocol.protocol,
                     protocolPath: 'thread',
                     schema: 'https://threads.example.com/schemas/thread',
                     dataFormat: 'application/json',
                 });
-                const threadReply = yield dwn.processMessage(alice.did, threadWrite.message, { dataStream: threadWrite.dataStream });
+                const threadReply = await dwn.processMessage(alice.did, threadWrite.message, { dataStream: threadWrite.dataStream });
                 expect(threadReply.status.code).toBe(202);
                 const threadContextId = threadWrite.message.contextId;
                 // Anyone can create a comment under the thread (via 'anyone' can 'create' rule)
-                const commentWrite = yield TestDataGenerator.generateRecordsWrite({
+                const commentWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: commentsProtocol.protocol,
                     protocolPath: 'thread/comment',
@@ -980,10 +970,10 @@ export function testProtocolComposition() {
                     dataFormat: 'application/json',
                     parentContextId: threadContextId,
                 });
-                const commentReply = yield dwn.processMessage(alice.did, commentWrite.message, { dataStream: commentWrite.dataStream });
+                const commentReply = await dwn.processMessage(alice.did, commentWrite.message, { dataStream: commentWrite.dataStream });
                 expect(commentReply.status.code).toBe(202);
                 // Anyone can also read (via 'anyone' can 'read' rule)
-                const readComment = yield RecordsRead.create({
+                const readComment = await RecordsRead.create({
                     signer: Jws.createSigner(bob),
                     filter: {
                         protocol: commentsProtocol.protocol,
@@ -991,18 +981,18 @@ export function testProtocolComposition() {
                         contextId: threadContextId,
                     },
                 });
-                const readReply = yield dwn.processMessage(alice.did, readComment.message);
+                const readReply = await dwn.processMessage(alice.did, readComment.message);
                 expect(readReply.status.code).toBe(200);
-            }));
+            });
         });
         // =========================================================================
         // Cross-protocol `of` actor check — happy path
         // =========================================================================
         describe('cross-protocol `of` actor check — happy path', () => {
-            it('should allow author of cross-protocol parent to create records via `who: author, of: alias:path` rule', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
-                const carol = yield TestDataGenerator.generateDidKeyPersona();
+            it('should allow author of cross-protocol parent to create records via `who: author, of: alias:path` rule', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
+                const carol = await TestDataGenerator.generateDidKeyPersona();
                 // A protocol that grants the author of a thread (from the threads protocol) the ability to create moderation actions
                 const moderationProtocol = {
                     protocol: 'https://moderation.example.com',
@@ -1024,30 +1014,30 @@ export function testProtocolComposition() {
                     },
                 };
                 // Install both protocols on Alice's DWN
-                const threadsConfigure = yield ProtocolsConfigure.create({
+                const threadsConfigure = await ProtocolsConfigure.create({
                     definition: threadsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                yield dwn.processMessage(alice.did, threadsConfigure.message);
-                const moderationConfigure = yield ProtocolsConfigure.create({
+                await dwn.processMessage(alice.did, threadsConfigure.message);
+                const moderationConfigure = await ProtocolsConfigure.create({
                     definition: moderationProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                const modReply = yield dwn.processMessage(alice.did, moderationConfigure.message);
+                const modReply = await dwn.processMessage(alice.did, moderationConfigure.message);
                 expect(modReply.status.code).toBe(202);
                 // Bob creates a thread (via 'anyone' can 'create' in threadsProtocol)
-                const threadWrite = yield TestDataGenerator.generateRecordsWrite({
+                const threadWrite = await TestDataGenerator.generateRecordsWrite({
                     author: bob,
                     protocol: threadsProtocol.protocol,
                     protocolPath: 'thread',
                     schema: 'https://threads.example.com/schemas/thread',
                     dataFormat: 'application/json',
                 });
-                const threadReply = yield dwn.processMessage(alice.did, threadWrite.message, { dataStream: threadWrite.dataStream });
+                const threadReply = await dwn.processMessage(alice.did, threadWrite.message, { dataStream: threadWrite.dataStream });
                 expect(threadReply.status.code).toBe(202);
                 const threadContextId = threadWrite.message.contextId;
                 // Bob (as author of the thread) creates a moderation action — should succeed
-                const actionWrite = yield TestDataGenerator.generateRecordsWrite({
+                const actionWrite = await TestDataGenerator.generateRecordsWrite({
                     author: bob,
                     protocol: moderationProtocol.protocol,
                     protocolPath: 'thread/action',
@@ -1055,10 +1045,10 @@ export function testProtocolComposition() {
                     dataFormat: 'application/json',
                     parentContextId: threadContextId,
                 });
-                const actionReply = yield dwn.processMessage(alice.did, actionWrite.message, { dataStream: actionWrite.dataStream });
+                const actionReply = await dwn.processMessage(alice.did, actionWrite.message, { dataStream: actionWrite.dataStream });
                 expect(actionReply.status.code).toBe(202);
                 // Carol (NOT author of the thread, NOT the tenant) tries to create a moderation action — should fail
-                const carolActionWrite = yield TestDataGenerator.generateRecordsWrite({
+                const carolActionWrite = await TestDataGenerator.generateRecordsWrite({
                     author: carol,
                     protocol: moderationProtocol.protocol,
                     protocolPath: 'thread/action',
@@ -1066,17 +1056,17 @@ export function testProtocolComposition() {
                     dataFormat: 'application/json',
                     parentContextId: threadContextId,
                 });
-                const carolActionReply = yield dwn.processMessage(alice.did, carolActionWrite.message, { dataStream: carolActionWrite.dataStream });
+                const carolActionReply = await dwn.processMessage(alice.did, carolActionWrite.message, { dataStream: carolActionWrite.dataStream });
                 expect(carolActionReply.status.code).toBe(401);
                 expect(carolActionReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
-            }));
+            });
         });
         // =========================================================================
         // Edge case and error tests
         // =========================================================================
         describe('composition error cases', () => {
-            it('should reject `$ref` with malformed format (no colon separator)', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            it('should reject `$ref` with malformed format (no colon separator)', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 const badDefinition = {
                     protocol: 'https://bad.example.com',
                     published: true,
@@ -1092,7 +1082,7 @@ export function testProtocolComposition() {
                     },
                 };
                 try {
-                    yield ProtocolsConfigure.create({
+                    await ProtocolsConfigure.create({
                         definition: badDefinition,
                         signer: Jws.createSigner(alice),
                     });
@@ -1102,9 +1092,9 @@ export function testProtocolComposition() {
                     // JSON schema enforces `$ref` must match pattern `^[a-zA-Z][a-zA-Z0-9_-]*:.+$`
                     expect(error.message).toContain('must match pattern');
                 }
-            }));
-            it('should reject `$ref` that references own protocol', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should reject `$ref` that references own protocol', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 const badDefinition = {
                     protocol: 'https://self.example.com',
                     published: true,
@@ -1120,7 +1110,7 @@ export function testProtocolComposition() {
                     },
                 };
                 try {
-                    yield ProtocolsConfigure.create({
+                    await ProtocolsConfigure.create({
                         definition: badDefinition,
                         signer: Jws.createSigner(alice),
                     });
@@ -1129,9 +1119,9 @@ export function testProtocolComposition() {
                 catch (error) {
                     expect(error.message).toContain(DwnErrorCode.ProtocolsConfigureInvalidUsesSelfReference);
                 }
-            }));
-            it('should reject `uses` with invalid alias name (starts with a number)', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should reject `uses` with invalid alias name (starts with a number)', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 const badDefinition = {
                     protocol: 'https://bad.example.com',
                     published: true,
@@ -1140,7 +1130,7 @@ export function testProtocolComposition() {
                     structure: {},
                 };
                 try {
-                    yield ProtocolsConfigure.create({
+                    await ProtocolsConfigure.create({
                         definition: badDefinition,
                         signer: Jws.createSigner(alice),
                     });
@@ -1150,9 +1140,9 @@ export function testProtocolComposition() {
                     // JSON schema enforces alias pattern `^[a-zA-Z][a-zA-Z0-9_-]*$` via additionalProperties: false
                     expect(error.message).toContain('must NOT have additional properties');
                 }
-            }));
-            it('should reject cross-protocol `of` with alias not in `uses`', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should reject cross-protocol `of` with alias not in `uses`', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 const badDefinition = {
                     protocol: 'https://bad.example.com',
                     published: true,
@@ -1170,7 +1160,7 @@ export function testProtocolComposition() {
                     },
                 };
                 try {
-                    yield ProtocolsConfigure.create({
+                    await ProtocolsConfigure.create({
                         definition: badDefinition,
                         signer: Jws.createSigner(alice),
                     });
@@ -1179,23 +1169,23 @@ export function testProtocolComposition() {
                 catch (error) {
                     expect(error.message).toContain(DwnErrorCode.ProtocolsConfigureInvalidCrossProtocolOf);
                 }
-            }));
-            it('should return 400 when cross-protocol parent record does not exist at runtime', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should return 400 when cross-protocol parent record does not exist at runtime', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 // Install both protocols
-                const threadsConfigure = yield ProtocolsConfigure.create({
+                const threadsConfigure = await ProtocolsConfigure.create({
                     definition: threadsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                yield dwn.processMessage(alice.did, threadsConfigure.message);
-                const commentsConfigure = yield ProtocolsConfigure.create({
+                await dwn.processMessage(alice.did, threadsConfigure.message);
+                const commentsConfigure = await ProtocolsConfigure.create({
                     definition: commentsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                yield dwn.processMessage(alice.did, commentsConfigure.message);
+                await dwn.processMessage(alice.did, commentsConfigure.message);
                 // Try to create a comment under a non-existent thread (fabricate a contextId)
                 const fakeThreadContextId = 'bafybeifake1234567890';
-                const commentWrite = yield TestDataGenerator.generateRecordsWrite({
+                const commentWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: commentsProtocol.protocol,
                     protocolPath: 'thread/comment',
@@ -1203,12 +1193,12 @@ export function testProtocolComposition() {
                     dataFormat: 'application/json',
                     parentContextId: fakeThreadContextId,
                 });
-                const reply = yield dwn.processMessage(alice.did, commentWrite.message, { dataStream: commentWrite.dataStream });
+                const reply = await dwn.processMessage(alice.did, commentWrite.message, { dataStream: commentWrite.dataStream });
                 expect(reply.status.code).toBe(400);
                 expect(reply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationCrossProtocolParentNotFound);
-            }));
-            it('should reject `$ref` at non-root protocol path', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should reject `$ref` at non-root protocol path', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 const badDefinition = {
                     protocol: 'https://bad.example.com',
                     published: true,
@@ -1223,7 +1213,7 @@ export function testProtocolComposition() {
                     },
                 };
                 try {
-                    yield ProtocolsConfigure.create({
+                    await ProtocolsConfigure.create({
                         definition: badDefinition,
                         signer: Jws.createSigner(alice),
                     });
@@ -1232,9 +1222,9 @@ export function testProtocolComposition() {
                 catch (error) {
                     expect(error.message).toContain(DwnErrorCode.ProtocolsConfigureInvalidRefNotAtRoot);
                 }
-            }));
-            it('should reject `uses` with empty alias map', () => __awaiter(this, void 0, void 0, function* () {
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
+            });
+            it('should reject `uses` with empty alias map', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
                 const badDefinition = {
                     protocol: 'https://bad.example.com',
                     published: true,
@@ -1243,7 +1233,7 @@ export function testProtocolComposition() {
                     structure: {},
                 };
                 try {
-                    yield ProtocolsConfigure.create({
+                    await ProtocolsConfigure.create({
                         definition: badDefinition,
                         signer: Jws.createSigner(alice),
                     });
@@ -1253,13 +1243,644 @@ export function testProtocolComposition() {
                     // JSON schema enforces minProperties: 1 on `uses`
                     expect(error.message).toContain('must NOT have fewer than 1 properties');
                 }
-            }));
+            });
+        });
+        // =========================================================================
+        // Multi-level composition rejection (#299)
+        // =========================================================================
+        describe('multi-level composition rejection', () => {
+            it('should reject `$ref` that targets a node which is itself a `$ref` composition point', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                // Protocol B uses Protocol A (threads)
+                const protocolB = {
+                    protocol: 'https://protocol-b.example.com',
+                    published: true,
+                    uses: { threads: 'https://threads.example.com' },
+                    types: {
+                        annotation: { schema: 'https://protocol-b.example.com/schemas/annotation', dataFormats: ['application/json'] },
+                    },
+                    structure: {
+                        thread: {
+                            $ref: 'threads:thread',
+                            annotation: {
+                                $actions: [{ who: 'anyone', can: ['create', 'read'] }],
+                            },
+                        },
+                    },
+                };
+                // Protocol C uses Protocol B — attempts to $ref through B's $ref node
+                const protocolC = {
+                    protocol: 'https://protocol-c.example.com',
+                    published: true,
+                    uses: { b: 'https://protocol-b.example.com' },
+                    types: {
+                        tag: { schema: 'https://protocol-c.example.com/schemas/tag', dataFormats: ['application/json'] },
+                    },
+                    structure: {
+                        thread: {
+                            $ref: 'b:thread', // 'thread' in protocol B IS a $ref node — multi-level, should be rejected
+                            tag: {
+                                $actions: [{ who: 'anyone', can: ['create', 'read'] }],
+                            },
+                        },
+                    },
+                };
+                // Install threads protocol (protocol A)
+                const threadsConfigure = await ProtocolsConfigure.create({
+                    definition: threadsProtocol,
+                    signer: Jws.createSigner(alice),
+                });
+                await dwn.processMessage(alice.did, threadsConfigure.message);
+                // Install protocol B (depends on threads)
+                const bConfigure = await ProtocolsConfigure.create({
+                    definition: protocolB,
+                    signer: Jws.createSigner(alice),
+                });
+                const bReply = await dwn.processMessage(alice.did, bConfigure.message);
+                expect(bReply.status.code).toBe(202);
+                // Install protocol C (depends on B) — should be REJECTED
+                const cConfigure = await ProtocolsConfigure.create({
+                    definition: protocolC,
+                    signer: Jws.createSigner(alice),
+                });
+                const cReply = await dwn.processMessage(alice.did, cConfigure.message);
+                expect(cReply.status.code).toBe(400);
+                expect(cReply.status.detail).toContain(DwnErrorCode.ProtocolsConfigureInvalidRefTargetThroughRef);
+            });
+            it('should reject `$ref` that targets a multi-segment path traversing through an intermediate `$ref` node', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                // Protocol B uses threads — has $ref at 'thread' and local children under it
+                const protocolB = {
+                    protocol: 'https://protocol-b.example.com',
+                    published: true,
+                    uses: { threads: 'https://threads.example.com' },
+                    types: {
+                        annotation: { schema: 'https://protocol-b.example.com/schemas/annotation', dataFormats: ['application/json'] },
+                    },
+                    structure: {
+                        thread: {
+                            $ref: 'threads:thread',
+                            annotation: {
+                                $actions: [{ who: 'anyone', can: ['create', 'read'] }],
+                            },
+                        },
+                    },
+                };
+                // Protocol C references a path that traverses through B's $ref node: 'thread/annotation'
+                // 'thread' is a $ref node in protocol B, so this should be rejected even though 'annotation' is a real node
+                const protocolC = {
+                    protocol: 'https://protocol-c.example.com',
+                    published: true,
+                    uses: { b: 'https://protocol-b.example.com' },
+                    types: {
+                        tag: { schema: 'https://protocol-c.example.com/schemas/tag', dataFormats: ['application/json'] },
+                    },
+                    structure: {
+                        annotation: {
+                            $ref: 'b:thread/annotation', // traverses through 'thread' which is a $ref node
+                            tag: {
+                                $actions: [{ who: 'anyone', can: ['create', 'read'] }],
+                            },
+                        },
+                    },
+                };
+                // Install threads protocol
+                const threadsConfigure = await ProtocolsConfigure.create({
+                    definition: threadsProtocol,
+                    signer: Jws.createSigner(alice),
+                });
+                await dwn.processMessage(alice.did, threadsConfigure.message);
+                // Install protocol B
+                const bConfigure = await ProtocolsConfigure.create({
+                    definition: protocolB,
+                    signer: Jws.createSigner(alice),
+                });
+                const bReply = await dwn.processMessage(alice.did, bConfigure.message);
+                expect(bReply.status.code).toBe(202);
+                // Install protocol C — should be REJECTED because 'thread' (intermediate) is a $ref node
+                const cConfigure = await ProtocolsConfigure.create({
+                    definition: protocolC,
+                    signer: Jws.createSigner(alice),
+                });
+                const cReply = await dwn.processMessage(alice.did, cConfigure.message);
+                expect(cReply.status.code).toBe(400);
+                expect(cReply.status.detail).toContain(DwnErrorCode.ProtocolsConfigureInvalidRefTargetThroughRef);
+            });
+            it('should accept `$ref` to a node that does NOT have a `$ref` directive', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                // Protocol B has a normal (non-$ref) 'item' type with children
+                const protocolB = {
+                    protocol: 'https://protocol-b.example.com',
+                    published: true,
+                    types: {
+                        item: { schema: 'https://protocol-b.example.com/schemas/item', dataFormats: ['application/json'] },
+                        sub: { schema: 'https://protocol-b.example.com/schemas/sub', dataFormats: ['application/json'] },
+                    },
+                    structure: {
+                        item: {
+                            $actions: [{ who: 'anyone', can: ['create', 'read'] }],
+                            sub: {
+                                $actions: [{ who: 'anyone', can: ['create', 'read'] }],
+                            },
+                        },
+                    },
+                };
+                // Protocol C references 'item' in B — this is single-level composition (no $ref in target), should succeed
+                const protocolC = {
+                    protocol: 'https://protocol-c.example.com',
+                    published: true,
+                    uses: { b: 'https://protocol-b.example.com' },
+                    types: {
+                        extra: { schema: 'https://protocol-c.example.com/schemas/extra', dataFormats: ['application/json'] },
+                    },
+                    structure: {
+                        item: {
+                            $ref: 'b:item',
+                            extra: {
+                                $actions: [{ who: 'anyone', can: ['create', 'read'] }],
+                            },
+                        },
+                    },
+                };
+                // Install protocol B
+                const bConfigure = await ProtocolsConfigure.create({
+                    definition: protocolB,
+                    signer: Jws.createSigner(alice),
+                });
+                const bReply = await dwn.processMessage(alice.did, bConfigure.message);
+                expect(bReply.status.code).toBe(202);
+                // Install protocol C — should SUCCEED
+                const cConfigure = await ProtocolsConfigure.create({
+                    definition: protocolC,
+                    signer: Jws.createSigner(alice),
+                });
+                const cReply = await dwn.processMessage(alice.did, cConfigure.message);
+                expect(cReply.status.code).toBe(202);
+            });
+        });
+        // =========================================================================
+        // RecordsSubscribe with cross-protocol role
+        // =========================================================================
+        describe('cross-protocol RecordsSubscribe', () => {
+            it('should allow a cross-protocol role holder to subscribe to records in the composing protocol', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
+                // Install both protocols on Alice's DWN
+                const threadsConfigure = await ProtocolsConfigure.create({
+                    definition: threadsProtocol,
+                    signer: Jws.createSigner(alice),
+                });
+                await dwn.processMessage(alice.did, threadsConfigure.message);
+                const commentsConfigure = await ProtocolsConfigure.create({
+                    definition: commentsProtocol,
+                    signer: Jws.createSigner(alice),
+                });
+                await dwn.processMessage(alice.did, commentsConfigure.message);
+                // Alice creates a thread
+                const threadWrite = await TestDataGenerator.generateRecordsWrite({
+                    author: alice,
+                    protocol: threadsProtocol.protocol,
+                    protocolPath: 'thread',
+                    schema: 'https://threads.example.com/schemas/thread',
+                    dataFormat: 'application/json',
+                });
+                await dwn.processMessage(alice.did, threadWrite.message, { dataStream: threadWrite.dataStream });
+                const threadContextId = threadWrite.message.contextId;
+                // Alice assigns Bob as a participant
+                const participantWrite = await TestDataGenerator.generateRecordsWrite({
+                    author: alice,
+                    recipient: bob.did,
+                    protocol: threadsProtocol.protocol,
+                    protocolPath: 'thread/participant',
+                    schema: 'https://threads.example.com/schemas/participant',
+                    dataFormat: 'application/json',
+                    parentContextId: threadContextId,
+                });
+                await dwn.processMessage(alice.did, participantWrite.message, { dataStream: participantWrite.dataStream });
+                // Bob subscribes to comments using the cross-protocol role
+                const bobSubscribe = await RecordsSubscribe.create({
+                    signer: Jws.createSigner(bob),
+                    protocolRole: 'threads:thread/participant',
+                    filter: {
+                        protocol: commentsProtocol.protocol,
+                        protocolPath: 'thread/comment',
+                        contextId: threadContextId,
+                    },
+                });
+                const subReply = await dwn.processMessage(alice.did, bobSubscribe.message, { subscriptionHandler: () => { } });
+                expect(subReply.status.code).toBe(200);
+                expect(subReply.subscription).toBeDefined();
+                // Clean up subscription
+                await subReply.subscription.close();
+            });
+        });
+        // =========================================================================
+        // RecordsCount with cross-protocol role
+        // =========================================================================
+        describe('cross-protocol RecordsCount', () => {
+            it('should allow a cross-protocol role holder to count records in the composing protocol', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
+                // Install both protocols on Alice's DWN
+                const threadsConfigure = await ProtocolsConfigure.create({
+                    definition: threadsProtocol,
+                    signer: Jws.createSigner(alice),
+                });
+                await dwn.processMessage(alice.did, threadsConfigure.message);
+                const commentsConfigure = await ProtocolsConfigure.create({
+                    definition: commentsProtocol,
+                    signer: Jws.createSigner(alice),
+                });
+                await dwn.processMessage(alice.did, commentsConfigure.message);
+                // Alice creates a thread
+                const threadWrite = await TestDataGenerator.generateRecordsWrite({
+                    author: alice,
+                    protocol: threadsProtocol.protocol,
+                    protocolPath: 'thread',
+                    schema: 'https://threads.example.com/schemas/thread',
+                    dataFormat: 'application/json',
+                });
+                await dwn.processMessage(alice.did, threadWrite.message, { dataStream: threadWrite.dataStream });
+                const threadContextId = threadWrite.message.contextId;
+                // Alice assigns Bob as a participant
+                const participantWrite = await TestDataGenerator.generateRecordsWrite({
+                    author: alice,
+                    recipient: bob.did,
+                    protocol: threadsProtocol.protocol,
+                    protocolPath: 'thread/participant',
+                    schema: 'https://threads.example.com/schemas/participant',
+                    dataFormat: 'application/json',
+                    parentContextId: threadContextId,
+                });
+                await dwn.processMessage(alice.did, participantWrite.message, { dataStream: participantWrite.dataStream });
+                // Alice creates 3 comments
+                for (let i = 0; i < 3; i++) {
+                    const commentWrite = await TestDataGenerator.generateRecordsWrite({
+                        author: alice,
+                        protocol: commentsProtocol.protocol,
+                        protocolPath: 'thread/comment',
+                        schema: 'https://comments.example.com/schemas/comment',
+                        dataFormat: 'application/json',
+                        parentContextId: threadContextId,
+                    });
+                    await dwn.processMessage(alice.did, commentWrite.message, { dataStream: commentWrite.dataStream });
+                }
+                // Bob counts comments using the cross-protocol role
+                const bobCount = await RecordsCount.create({
+                    signer: Jws.createSigner(bob),
+                    protocolRole: 'threads:thread/participant',
+                    filter: {
+                        protocol: commentsProtocol.protocol,
+                        protocolPath: 'thread/comment',
+                        contextId: threadContextId,
+                    },
+                });
+                const countReply = await dwn.processMessage(alice.did, bobCount.message);
+                expect(countReply.status.code).toBe(200);
+                expect(countReply.count).toBe(3);
+            });
+        });
+        // =========================================================================
+        // Cross-protocol co-update via role
+        // =========================================================================
+        describe('cross-protocol co-update via role', () => {
+            it('should allow a cross-protocol role holder to co-update records in the composing protocol', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
+                // A variant of the comments protocol where participants can also co-update
+                const commentsCoUpdateProtocol = {
+                    protocol: 'https://comments-coupdate.example.com',
+                    published: true,
+                    uses: { threads: 'https://threads.example.com' },
+                    types: {
+                        comment: { schema: 'https://comments-coupdate.example.com/schemas/comment', dataFormats: ['application/json'] },
+                    },
+                    structure: {
+                        thread: {
+                            $ref: 'threads:thread',
+                            comment: {
+                                $actions: [
+                                    { who: 'anyone', can: ['create', 'read'] },
+                                    { role: 'threads:thread/participant', can: ['co-update'] },
+                                ],
+                            },
+                        },
+                    },
+                };
+                // Install both protocols on Alice's DWN
+                const threadsConfigure = await ProtocolsConfigure.create({
+                    definition: threadsProtocol,
+                    signer: Jws.createSigner(alice),
+                });
+                await dwn.processMessage(alice.did, threadsConfigure.message);
+                const commentsConfigure = await ProtocolsConfigure.create({
+                    definition: commentsCoUpdateProtocol,
+                    signer: Jws.createSigner(alice),
+                });
+                const commentsReply = await dwn.processMessage(alice.did, commentsConfigure.message);
+                expect(commentsReply.status.code).toBe(202);
+                // Alice creates a thread
+                const threadWrite = await TestDataGenerator.generateRecordsWrite({
+                    author: alice,
+                    protocol: threadsProtocol.protocol,
+                    protocolPath: 'thread',
+                    schema: 'https://threads.example.com/schemas/thread',
+                    dataFormat: 'application/json',
+                });
+                await dwn.processMessage(alice.did, threadWrite.message, { dataStream: threadWrite.dataStream });
+                const threadContextId = threadWrite.message.contextId;
+                // Alice assigns Bob as a participant
+                const participantWrite = await TestDataGenerator.generateRecordsWrite({
+                    author: alice,
+                    recipient: bob.did,
+                    protocol: threadsProtocol.protocol,
+                    protocolPath: 'thread/participant',
+                    schema: 'https://threads.example.com/schemas/participant',
+                    dataFormat: 'application/json',
+                    parentContextId: threadContextId,
+                });
+                await dwn.processMessage(alice.did, participantWrite.message, { dataStream: participantWrite.dataStream });
+                // Alice creates a comment (via 'anyone' can 'create')
+                const commentWrite = await TestDataGenerator.generateRecordsWrite({
+                    author: alice,
+                    protocol: commentsCoUpdateProtocol.protocol,
+                    protocolPath: 'thread/comment',
+                    schema: 'https://comments-coupdate.example.com/schemas/comment',
+                    dataFormat: 'application/json',
+                    parentContextId: threadContextId,
+                });
+                await dwn.processMessage(alice.did, commentWrite.message, { dataStream: commentWrite.dataStream });
+                // Bob (participant) co-updates Alice's comment using the cross-protocol role
+                const bobUpdate = await TestDataGenerator.generateFromRecordsWrite({
+                    author: bob,
+                    existingWrite: commentWrite.recordsWrite,
+                    protocolRole: 'threads:thread/participant',
+                });
+                const updateReply = await dwn.processMessage(alice.did, bobUpdate.message, { dataStream: bobUpdate.dataStream });
+                expect(updateReply.status.code).toBe(202);
+            });
+        });
+        // =========================================================================
+        // Query isolation — subscribing to referenced protocol does NOT yield composing protocol events
+        // =========================================================================
+        describe('query isolation between protocols', () => {
+            it('should not return composing protocol records when querying the referenced protocol', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                // Install both protocols
+                const threadsConfigure = await ProtocolsConfigure.create({
+                    definition: threadsProtocol,
+                    signer: Jws.createSigner(alice),
+                });
+                await dwn.processMessage(alice.did, threadsConfigure.message);
+                const commentsConfigure = await ProtocolsConfigure.create({
+                    definition: commentsProtocol,
+                    signer: Jws.createSigner(alice),
+                });
+                await dwn.processMessage(alice.did, commentsConfigure.message);
+                // Alice creates a thread in the threads protocol
+                const threadWrite = await TestDataGenerator.generateRecordsWrite({
+                    author: alice,
+                    protocol: threadsProtocol.protocol,
+                    protocolPath: 'thread',
+                    schema: 'https://threads.example.com/schemas/thread',
+                    dataFormat: 'application/json',
+                });
+                await dwn.processMessage(alice.did, threadWrite.message, { dataStream: threadWrite.dataStream });
+                const threadContextId = threadWrite.message.contextId;
+                // Alice creates comments in the composing protocol
+                const commentWrite = await TestDataGenerator.generateRecordsWrite({
+                    author: alice,
+                    protocol: commentsProtocol.protocol,
+                    protocolPath: 'thread/comment',
+                    schema: 'https://comments.example.com/schemas/comment',
+                    dataFormat: 'application/json',
+                    parentContextId: threadContextId,
+                });
+                await dwn.processMessage(alice.did, commentWrite.message, { dataStream: commentWrite.dataStream });
+                // Query the THREADS protocol for all records — should NOT include the comment
+                const threadsQuery = await RecordsQuery.create({
+                    signer: Jws.createSigner(alice),
+                    filter: {
+                        protocol: threadsProtocol.protocol,
+                    },
+                });
+                const threadsQueryReply = await dwn.processMessage(alice.did, threadsQuery.message);
+                expect(threadsQueryReply.status.code).toBe(200);
+                // Only the thread record itself should be returned
+                const threadsRecordIds = threadsQueryReply.entries.map((e) => e.recordId);
+                expect(threadsRecordIds).toContain(threadWrite.message.recordId);
+                expect(threadsRecordIds).not.toContain(commentWrite.message.recordId);
+                // Query the COMMENTS protocol — should include the comment
+                const commentsQuery = await RecordsQuery.create({
+                    signer: Jws.createSigner(alice),
+                    filter: {
+                        protocol: commentsProtocol.protocol,
+                    },
+                });
+                const commentsQueryReply = await dwn.processMessage(alice.did, commentsQuery.message);
+                expect(commentsQueryReply.status.code).toBe(200);
+                const commentsRecordIds = commentsQueryReply.entries.map((e) => e.recordId);
+                expect(commentsRecordIds).toContain(commentWrite.message.recordId);
+                expect(commentsRecordIds).not.toContain(threadWrite.message.recordId);
+            });
+        });
+        // =========================================================================
+        // Multiple composing protocols on the same $ref target
+        // =========================================================================
+        describe('multiple composing protocols on the same $ref target', () => {
+            it('should allow two different composing protocols to independently reference the same type in a base protocol', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                // commentsProtocol already references threads:thread
+                // Create a second composing protocol that also references threads:thread
+                const ratingsProtocol = {
+                    protocol: 'https://ratings.example.com',
+                    published: true,
+                    uses: { threads: 'https://threads.example.com' },
+                    types: {
+                        rating: { schema: 'https://ratings.example.com/schemas/rating', dataFormats: ['application/json'] },
+                    },
+                    structure: {
+                        thread: {
+                            $ref: 'threads:thread',
+                            rating: {
+                                $actions: [
+                                    { who: 'anyone', can: ['create', 'read'] },
+                                ],
+                            },
+                        },
+                    },
+                };
+                // Install threads (base), comments, and ratings
+                const threadsConfigure = await ProtocolsConfigure.create({
+                    definition: threadsProtocol,
+                    signer: Jws.createSigner(alice),
+                });
+                await dwn.processMessage(alice.did, threadsConfigure.message);
+                const commentsConfigure = await ProtocolsConfigure.create({
+                    definition: commentsProtocol,
+                    signer: Jws.createSigner(alice),
+                });
+                const commentsReply = await dwn.processMessage(alice.did, commentsConfigure.message);
+                expect(commentsReply.status.code).toBe(202);
+                const ratingsConfigure = await ProtocolsConfigure.create({
+                    definition: ratingsProtocol,
+                    signer: Jws.createSigner(alice),
+                });
+                const ratingsReply = await dwn.processMessage(alice.did, ratingsConfigure.message);
+                expect(ratingsReply.status.code).toBe(202);
+                // Create a thread
+                const threadWrite = await TestDataGenerator.generateRecordsWrite({
+                    author: alice,
+                    protocol: threadsProtocol.protocol,
+                    protocolPath: 'thread',
+                    schema: 'https://threads.example.com/schemas/thread',
+                    dataFormat: 'application/json',
+                });
+                await dwn.processMessage(alice.did, threadWrite.message, { dataStream: threadWrite.dataStream });
+                const threadContextId = threadWrite.message.contextId;
+                // Create a comment under the thread via comments protocol
+                const commentWrite = await TestDataGenerator.generateRecordsWrite({
+                    author: alice,
+                    protocol: commentsProtocol.protocol,
+                    protocolPath: 'thread/comment',
+                    schema: 'https://comments.example.com/schemas/comment',
+                    dataFormat: 'application/json',
+                    parentContextId: threadContextId,
+                });
+                const commentReply = await dwn.processMessage(alice.did, commentWrite.message, { dataStream: commentWrite.dataStream });
+                expect(commentReply.status.code).toBe(202);
+                // Create a rating under the same thread via ratings protocol
+                const ratingWrite = await TestDataGenerator.generateRecordsWrite({
+                    author: alice,
+                    protocol: ratingsProtocol.protocol,
+                    protocolPath: 'thread/rating',
+                    schema: 'https://ratings.example.com/schemas/rating',
+                    dataFormat: 'application/json',
+                    parentContextId: threadContextId,
+                });
+                const ratingReply = await dwn.processMessage(alice.did, ratingWrite.message, { dataStream: ratingWrite.dataStream });
+                expect(ratingReply.status.code).toBe(202);
+                // Each protocol's records are isolated — querying comments returns only comments
+                const commentsQuery = await RecordsQuery.create({
+                    signer: Jws.createSigner(alice),
+                    filter: { protocol: commentsProtocol.protocol },
+                });
+                const commentsQueryReply = await dwn.processMessage(alice.did, commentsQuery.message);
+                expect(commentsQueryReply.entries.length).toBe(1);
+                expect(commentsQueryReply.entries[0].recordId).toBe(commentWrite.message.recordId);
+                // Querying ratings returns only ratings
+                const ratingsQuery = await RecordsQuery.create({
+                    signer: Jws.createSigner(alice),
+                    filter: { protocol: ratingsProtocol.protocol },
+                });
+                const ratingsQueryReply = await dwn.processMessage(alice.did, ratingsQuery.message);
+                expect(ratingsQueryReply.entries.length).toBe(1);
+                expect(ratingsQueryReply.entries[0].recordId).toBe(ratingWrite.message.recordId);
+            });
+        });
+        // =========================================================================
+        // Composing protocol definition upgrade (adding children under $ref in V2)
+        // =========================================================================
+        describe('composing protocol definition upgrade', () => {
+            it('should allow upgrading a composing protocol to add new child types under a `$ref` node', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                // Install threads protocol
+                const threadsConfigure = await ProtocolsConfigure.create({
+                    definition: threadsProtocol,
+                    signer: Jws.createSigner(alice),
+                });
+                await dwn.processMessage(alice.did, threadsConfigure.message);
+                // Comments V1 — only has 'comment' under 'thread'
+                const commentsV1 = {
+                    protocol: 'https://comments-upgrade.example.com',
+                    published: true,
+                    uses: { threads: 'https://threads.example.com' },
+                    types: {
+                        comment: { schema: 'https://comments-upgrade.example.com/schemas/comment', dataFormats: ['application/json'] },
+                    },
+                    structure: {
+                        thread: {
+                            $ref: 'threads:thread',
+                            comment: {
+                                $actions: [{ who: 'anyone', can: ['create', 'read'] }],
+                            },
+                        },
+                    },
+                };
+                const v1Configure = await ProtocolsConfigure.create({
+                    definition: commentsV1,
+                    signer: Jws.createSigner(alice),
+                });
+                const v1Reply = await dwn.processMessage(alice.did, v1Configure.message);
+                expect(v1Reply.status.code).toBe(202);
+                // Create a thread and a V1 comment
+                const threadWrite = await TestDataGenerator.generateRecordsWrite({
+                    author: alice,
+                    protocol: threadsProtocol.protocol,
+                    protocolPath: 'thread',
+                    schema: 'https://threads.example.com/schemas/thread',
+                    dataFormat: 'application/json',
+                });
+                await dwn.processMessage(alice.did, threadWrite.message, { dataStream: threadWrite.dataStream });
+                const threadContextId = threadWrite.message.contextId;
+                const commentWrite = await TestDataGenerator.generateRecordsWrite({
+                    author: alice,
+                    protocol: commentsV1.protocol,
+                    protocolPath: 'thread/comment',
+                    schema: 'https://comments-upgrade.example.com/schemas/comment',
+                    dataFormat: 'application/json',
+                    parentContextId: threadContextId,
+                });
+                const commentReply = await dwn.processMessage(alice.did, commentWrite.message, { dataStream: commentWrite.dataStream });
+                expect(commentReply.status.code).toBe(202);
+                // Wait to ensure V2 gets a later timestamp
+                await Time.minimalSleep();
+                // Comments V2 — adds 'reaction' type under 'thread/comment'
+                const commentsV2 = {
+                    protocol: 'https://comments-upgrade.example.com',
+                    published: true,
+                    uses: { threads: 'https://threads.example.com' },
+                    types: {
+                        comment: { schema: 'https://comments-upgrade.example.com/schemas/comment', dataFormats: ['application/json'] },
+                        reaction: { schema: 'https://comments-upgrade.example.com/schemas/reaction', dataFormats: ['application/json'] },
+                    },
+                    structure: {
+                        thread: {
+                            $ref: 'threads:thread',
+                            comment: {
+                                $actions: [{ who: 'anyone', can: ['create', 'read'] }],
+                                reaction: {
+                                    $actions: [{ who: 'anyone', can: ['create', 'read'] }],
+                                },
+                            },
+                        },
+                    },
+                };
+                const v2Configure = await ProtocolsConfigure.create({
+                    definition: commentsV2,
+                    signer: Jws.createSigner(alice),
+                });
+                const v2Reply = await dwn.processMessage(alice.did, v2Configure.message);
+                expect(v2Reply.status.code).toBe(202);
+                // Now create a reaction under the comment using V2's structure
+                const commentContextId = commentWrite.message.contextId;
+                const reactionWrite = await TestDataGenerator.generateRecordsWrite({
+                    author: alice,
+                    protocol: commentsV2.protocol,
+                    protocolPath: 'thread/comment/reaction',
+                    schema: 'https://comments-upgrade.example.com/schemas/reaction',
+                    dataFormat: 'application/json',
+                    parentContextId: commentContextId,
+                });
+                const reactionReply = await dwn.processMessage(alice.did, reactionWrite.message, { dataStream: reactionWrite.dataStream });
+                expect(reactionReply.status.code).toBe(202);
+            });
         });
         // =========================================================================
         // Temporal correctness — governing timestamp for cross-protocol lookups
         // =========================================================================
         describe('temporal correctness — governing timestamp', () => {
-            it('should use the governing timestamp when fetching the referenced protocol for role verification', () => __awaiter(this, void 0, void 0, function* () {
+            it('should use the governing timestamp when fetching the referenced protocol for role verification', async () => {
                 // Scenario:
                 // 1. Install threads V1 (participant has $role: true)
                 // 2. Install comments protocol (uses threads, references threads:thread/participant role)
@@ -1267,8 +1888,8 @@ export function testProtocolComposition() {
                 // 4. Update threads to V2 where participant is no longer a role ($role removed)
                 // 5. Bob reads the comment using the cross-protocol role
                 //    → should SUCCEED because the comment's governing timestamp pins to threads V1
-                const alice = yield TestDataGenerator.generateDidKeyPersona();
-                const bob = yield TestDataGenerator.generateDidKeyPersona();
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const bob = await TestDataGenerator.generateDidKeyPersona();
                 // threads V1: participant is a role
                 const threadsV1 = {
                     protocol: 'https://threads-versioned.example.com',
@@ -1311,31 +1932,31 @@ export function testProtocolComposition() {
                     },
                 };
                 // Install threads V1
-                const threadsV1Configure = yield ProtocolsConfigure.create({
+                const threadsV1Configure = await ProtocolsConfigure.create({
                     definition: threadsV1,
                     signer: Jws.createSigner(alice),
                 });
-                const threadsV1Reply = yield dwn.processMessage(alice.did, threadsV1Configure.message);
+                const threadsV1Reply = await dwn.processMessage(alice.did, threadsV1Configure.message);
                 expect(threadsV1Reply.status.code).toBe(202);
                 // Install comments protocol (depends on threads)
-                const commentsConfigure = yield ProtocolsConfigure.create({
+                const commentsConfigure = await ProtocolsConfigure.create({
                     definition: commentsVersioned,
                     signer: Jws.createSigner(alice),
                 });
-                const commentsReply = yield dwn.processMessage(alice.did, commentsConfigure.message);
+                const commentsReply = await dwn.processMessage(alice.did, commentsConfigure.message);
                 expect(commentsReply.status.code).toBe(202);
                 // Alice creates a thread
-                const threadWrite = yield TestDataGenerator.generateRecordsWrite({
+                const threadWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: threadsV1.protocol,
                     protocolPath: 'thread',
                     schema: 'https://threads-versioned.example.com/schemas/thread',
                     dataFormat: 'application/json',
                 });
-                yield dwn.processMessage(alice.did, threadWrite.message, { dataStream: threadWrite.dataStream });
+                await dwn.processMessage(alice.did, threadWrite.message, { dataStream: threadWrite.dataStream });
                 const threadContextId = threadWrite.message.contextId;
                 // Alice assigns Bob as participant (role record in threads V1)
-                const participantWrite = yield TestDataGenerator.generateRecordsWrite({
+                const participantWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     recipient: bob.did,
                     protocol: threadsV1.protocol,
@@ -1344,9 +1965,9 @@ export function testProtocolComposition() {
                     dataFormat: 'application/json',
                     parentContextId: threadContextId,
                 });
-                yield dwn.processMessage(alice.did, participantWrite.message, { dataStream: participantWrite.dataStream });
+                await dwn.processMessage(alice.did, participantWrite.message, { dataStream: participantWrite.dataStream });
                 // Alice creates a comment (under V1)
-                const commentWrite = yield TestDataGenerator.generateRecordsWrite({
+                const commentWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: commentsVersioned.protocol,
                     protocolPath: 'thread/comment',
@@ -1354,9 +1975,9 @@ export function testProtocolComposition() {
                     dataFormat: 'application/json',
                     parentContextId: threadContextId,
                 });
-                yield dwn.processMessage(alice.did, commentWrite.message, { dataStream: commentWrite.dataStream });
+                await dwn.processMessage(alice.did, commentWrite.message, { dataStream: commentWrite.dataStream });
                 // Wait to ensure V2 gets a later timestamp
-                yield Time.minimalSleep();
+                await Time.minimalSleep();
                 // threads V2: participant is NO LONGER a role ($role removed)
                 const threadsV2 = {
                     protocol: 'https://threads-versioned.example.com',
@@ -1378,16 +1999,16 @@ export function testProtocolComposition() {
                         },
                     },
                 };
-                const threadsV2Configure = yield ProtocolsConfigure.create({
+                const threadsV2Configure = await ProtocolsConfigure.create({
                     definition: threadsV2,
                     signer: Jws.createSigner(alice),
                 });
-                const threadsV2Reply = yield dwn.processMessage(alice.did, threadsV2Configure.message);
+                const threadsV2Reply = await dwn.processMessage(alice.did, threadsV2Configure.message);
                 expect(threadsV2Reply.status.code).toBe(202);
                 // Bob reads the comment using the cross-protocol role.
                 // The comment was created under V1. The governing timestamp pins the referenced protocol
                 // lookup to V1 where participant IS a valid role. This should SUCCEED.
-                const bobRead = yield RecordsRead.create({
+                const bobRead = await RecordsRead.create({
                     signer: Jws.createSigner(bob),
                     protocolRole: 'threads:thread/participant',
                     filter: {
@@ -1396,9 +2017,9 @@ export function testProtocolComposition() {
                         contextId: threadContextId,
                     },
                 });
-                const bobReadReply = yield dwn.processMessage(alice.did, bobRead.message);
+                const bobReadReply = await dwn.processMessage(alice.did, bobRead.message);
                 expect(bobReadReply.status.code).toBe(200);
-            }));
+            });
         });
         // =========================================================================
         // Encryption + composition tests
@@ -1406,12 +2027,12 @@ export function testProtocolComposition() {
         describe('encryption with protocol composition', () => {
             let encryptionPrivateJwk;
             let encryptionRootKeyId;
-            beforeAll(() => __awaiter(this, void 0, void 0, function* () {
-                const privateKey = yield X25519.generateKey();
+            beforeAll(async () => {
+                const privateKey = await X25519.generateKey();
                 encryptionPrivateJwk = privateKey;
                 encryptionRootKeyId = 'did:example:alice#enc';
-            }));
-            it('should skip `$encryption` injection on `$ref` nodes but inject on their children (raw-key path)', () => __awaiter(this, void 0, void 0, function* () {
+            });
+            it('should skip `$encryption` injection on `$ref` nodes but inject on their children (raw-key path)', async () => {
                 const composingProtocol = {
                     protocol: 'https://comments.example.com',
                     published: true,
@@ -1432,7 +2053,7 @@ export function testProtocolComposition() {
                         },
                     },
                 };
-                const result = yield Protocols.deriveAndInjectPublicEncryptionKeys(composingProtocol, encryptionRootKeyId, encryptionPrivateJwk);
+                const result = await Protocols.deriveAndInjectPublicEncryptionKeys(composingProtocol, encryptionRootKeyId, encryptionPrivateJwk);
                 // $ref node must NOT have $encryption
                 expect(result.structure.thread.$encryption).toBeUndefined();
                 // Children of $ref node MUST have $encryption
@@ -1444,8 +2065,8 @@ export function testProtocolComposition() {
                 const reactionRuleSet = commentRuleSet.reaction;
                 expect(reactionRuleSet.$encryption).toBeDefined();
                 expect(reactionRuleSet.$encryption.rootKeyId).toBe(encryptionRootKeyId);
-            }));
-            it('should skip `$encryption` injection on `$ref` nodes but inject on their children (callback path)', () => __awaiter(this, void 0, void 0, function* () {
+            });
+            it('should skip `$encryption` injection on `$ref` nodes but inject on their children (callback path)', async () => {
                 const composingProtocol = {
                     protocol: 'https://comments.example.com',
                     published: true,
@@ -1470,15 +2091,15 @@ export function testProtocolComposition() {
                 const keyDeriver = {
                     rootKeyId: encryptionRootKeyId,
                     derivationScheme: KeyDerivationScheme.ProtocolPath,
-                    derivePublicKey: (fullDerivationPath) => __awaiter(this, void 0, void 0, function* () {
+                    derivePublicKey: async (fullDerivationPath) => {
                         calledPaths.push([...fullDerivationPath]);
-                        const privateKeyBytes = yield X25519.privateKeyToBytes({ privateKey: encryptionPrivateJwk });
-                        const derivedPrivateKeyBytes = yield HdKey.derivePrivateKeyBytes(privateKeyBytes, fullDerivationPath);
-                        const derivedPrivateKeyJwk = yield X25519.bytesToPrivateKey({ privateKeyBytes: derivedPrivateKeyBytes });
-                        return yield X25519.getPublicKey({ key: derivedPrivateKeyJwk });
-                    }),
+                        const privateKeyBytes = await X25519.privateKeyToBytes({ privateKey: encryptionPrivateJwk });
+                        const derivedPrivateKeyBytes = await HdKey.derivePrivateKeyBytes(privateKeyBytes, fullDerivationPath);
+                        const derivedPrivateKeyJwk = await X25519.bytesToPrivateKey({ privateKeyBytes: derivedPrivateKeyBytes });
+                        return await X25519.getPublicKey({ key: derivedPrivateKeyJwk });
+                    },
                 };
-                const result = yield Protocols.deriveAndInjectPublicEncryptionKeys(composingProtocol, keyDeriver);
+                const result = await Protocols.deriveAndInjectPublicEncryptionKeys(composingProtocol, keyDeriver);
                 // $ref node must NOT have $encryption
                 expect(result.structure.thread.$encryption).toBeUndefined();
                 // Children of $ref node MUST have $encryption
@@ -1493,8 +2114,8 @@ export function testProtocolComposition() {
                 const reactionPath = [KeyDerivationScheme.ProtocolPath, 'https://comments.example.com', 'thread', 'comment', 'reaction'];
                 expect(calledPaths).toContainEqual(commentPath);
                 expect(calledPaths).toContainEqual(reactionPath);
-            }));
-            it('should produce identical $encryption for children across both overloads', () => __awaiter(this, void 0, void 0, function* () {
+            });
+            it('should produce identical $encryption for children across both overloads', async () => {
                 const composingProtocol = {
                     protocol: 'https://comments.example.com',
                     published: true,
@@ -1510,19 +2131,19 @@ export function testProtocolComposition() {
                     },
                 };
                 // Raw-key path
-                const resultA = yield Protocols.deriveAndInjectPublicEncryptionKeys(composingProtocol, encryptionRootKeyId, encryptionPrivateJwk);
+                const resultA = await Protocols.deriveAndInjectPublicEncryptionKeys(composingProtocol, encryptionRootKeyId, encryptionPrivateJwk);
                 // Callback path
                 const keyDeriver = {
                     rootKeyId: encryptionRootKeyId,
                     derivationScheme: KeyDerivationScheme.ProtocolPath,
-                    derivePublicKey: (fullDerivationPath) => __awaiter(this, void 0, void 0, function* () {
-                        const privateKeyBytes = yield X25519.privateKeyToBytes({ privateKey: encryptionPrivateJwk });
-                        const derivedPrivateKeyBytes = yield HdKey.derivePrivateKeyBytes(privateKeyBytes, fullDerivationPath);
-                        const derivedPrivateKeyJwk = yield X25519.bytesToPrivateKey({ privateKeyBytes: derivedPrivateKeyBytes });
-                        return yield X25519.getPublicKey({ key: derivedPrivateKeyJwk });
-                    }),
+                    derivePublicKey: async (fullDerivationPath) => {
+                        const privateKeyBytes = await X25519.privateKeyToBytes({ privateKey: encryptionPrivateJwk });
+                        const derivedPrivateKeyBytes = await HdKey.derivePrivateKeyBytes(privateKeyBytes, fullDerivationPath);
+                        const derivedPrivateKeyJwk = await X25519.bytesToPrivateKey({ privateKeyBytes: derivedPrivateKeyBytes });
+                        return await X25519.getPublicKey({ key: derivedPrivateKeyJwk });
+                    },
                 };
-                const resultB = yield Protocols.deriveAndInjectPublicEncryptionKeys(composingProtocol, keyDeriver);
+                const resultB = await Protocols.deriveAndInjectPublicEncryptionKeys(composingProtocol, keyDeriver);
                 // Both paths must skip $ref
                 expect(resultA.structure.thread.$encryption).toBeUndefined();
                 expect(resultB.structure.thread.$encryption).toBeUndefined();
@@ -1531,69 +2152,69 @@ export function testProtocolComposition() {
                 const commentB = resultB.structure.thread.comment;
                 expect(commentA.$encryption.publicKeyJwk).toEqual(commentB.$encryption.publicKeyJwk);
                 expect(commentA.$encryption.rootKeyId).toBe(commentB.$encryption.rootKeyId);
-            }));
-            it('should successfully install a composing protocol with encryption after $ref skip', () => __awaiter(this, void 0, void 0, function* () {
+            });
+            it('should successfully install a composing protocol with encryption after $ref skip', async () => {
                 // This test verifies the full pipeline: inject encryption keys → ProtocolsConfigure.create()
                 // → validateRefNode() passes because $ref node has no $encryption.
-                const alice = yield TestDataGenerator.generatePersona();
+                const alice = await TestDataGenerator.generatePersona();
                 TestStubGenerator.stubDidResolver(didResolver, [alice]);
                 // Install the threads protocol first (required dependency)
-                const threadsConfigure = yield ProtocolsConfigure.create({
+                const threadsConfigure = await ProtocolsConfigure.create({
                     definition: threadsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                const threadsInstallReply = yield dwn.processMessage(alice.did, threadsConfigure.message);
+                const threadsInstallReply = await dwn.processMessage(alice.did, threadsConfigure.message);
                 expect(threadsInstallReply.status.code).toBe(202);
                 // Inject encryption keys into the composing protocol
-                const encryptedComments = yield Protocols.deriveAndInjectPublicEncryptionKeys(commentsProtocol, alice.keyId, alice.encryptionKeyPair.privateJwk);
+                const encryptedComments = await Protocols.deriveAndInjectPublicEncryptionKeys(commentsProtocol, alice.keyId, alice.encryptionKeyPair.privateJwk);
                 // $ref node should not have $encryption
                 expect(encryptedComments.structure.thread.$encryption).toBeUndefined();
                 // Children should have $encryption
                 expect(encryptedComments.structure.thread.comment.$encryption).toBeDefined();
                 // ProtocolsConfigure.create() should NOT throw — validateRefNode() will pass
                 // because $ref node has no forbidden directives
-                const commentsConfigure = yield ProtocolsConfigure.create({
+                const commentsConfigure = await ProtocolsConfigure.create({
                     definition: encryptedComments,
                     signer: Jws.createSigner(alice),
                 });
                 // Install should succeed
-                const commentsInstallReply = yield dwn.processMessage(alice.did, commentsConfigure.message);
+                const commentsInstallReply = await dwn.processMessage(alice.did, commentsConfigure.message);
                 expect(commentsInstallReply.status.code).toBe(202);
-            }));
-            it('should encrypt and decrypt a child record written under a `$ref` parent', () => __awaiter(this, void 0, void 0, function* () {
+            });
+            it('should encrypt and decrypt a child record written under a `$ref` parent', async () => {
                 // Full round-trip: install both protocols → write parent → write encrypted child → read and decrypt
-                const alice = yield TestDataGenerator.generatePersona();
+                const alice = await TestDataGenerator.generatePersona();
                 TestStubGenerator.stubDidResolver(didResolver, [alice]);
                 // 1. Install the threads protocol (parent)
-                const threadsConfigure = yield ProtocolsConfigure.create({
+                const threadsConfigure = await ProtocolsConfigure.create({
                     definition: threadsProtocol,
                     signer: Jws.createSigner(alice),
                 });
-                const threadsReply = yield dwn.processMessage(alice.did, threadsConfigure.message);
+                const threadsReply = await dwn.processMessage(alice.did, threadsConfigure.message);
                 expect(threadsReply.status.code).toBe(202);
                 // 2. Install the comments protocol with encryption keys
-                const encryptedComments = yield Protocols.deriveAndInjectPublicEncryptionKeys(commentsProtocol, alice.keyId, alice.encryptionKeyPair.privateJwk);
-                const commentsConfigure = yield ProtocolsConfigure.create({
+                const encryptedComments = await Protocols.deriveAndInjectPublicEncryptionKeys(commentsProtocol, alice.keyId, alice.encryptionKeyPair.privateJwk);
+                const commentsConfigure = await ProtocolsConfigure.create({
                     definition: encryptedComments,
                     signer: Jws.createSigner(alice),
                 });
-                const commentsReply = yield dwn.processMessage(alice.did, commentsConfigure.message);
+                const commentsReply = await dwn.processMessage(alice.did, commentsConfigure.message);
                 expect(commentsReply.status.code).toBe(202);
                 // 3. Write a thread record (in the threads protocol — the $ref parent)
-                const threadWrite = yield TestDataGenerator.generateRecordsWrite({
+                const threadWrite = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     protocol: threadsProtocol.protocol,
                     protocolPath: 'thread',
                     schema: 'https://threads.example.com/schemas/thread',
                     dataFormat: 'application/json',
                 });
-                const threadWriteReply = yield dwn.processMessage(alice.did, threadWrite.message, { dataStream: threadWrite.dataStream });
+                const threadWriteReply = await dwn.processMessage(alice.did, threadWrite.message, { dataStream: threadWrite.dataStream });
                 expect(threadWriteReply.status.code).toBe(202);
                 const threadContextId = threadWrite.message.contextId;
                 // 4. Write an encrypted comment (child of $ref parent, in the comments protocol)
                 const plaintext = 'This is a secret comment';
                 const plaintextBytes = Encoder.stringToBytes(plaintext);
-                const encryptedComment = yield TestDataGenerator.generateProtocolEncryptedRecordsWrite({
+                const encryptedComment = await TestDataGenerator.generateProtocolEncryptedRecordsWrite({
                     plaintextBytes,
                     author: alice,
                     protocolDefinition: encryptedComments,
@@ -1602,14 +2223,14 @@ export function testProtocolComposition() {
                     encryptSymmetricKeyWithProtocolPathDerivedKey: true,
                     encryptSymmetricKeyWithProtocolContextDerivedKey: false,
                 });
-                const commentWriteReply = yield dwn.processMessage(alice.did, encryptedComment.message, { dataStream: DataStream.fromBytes(encryptedComment.encryptedDataBytes) });
+                const commentWriteReply = await dwn.processMessage(alice.did, encryptedComment.message, { dataStream: DataStream.fromBytes(encryptedComment.encryptedDataBytes) });
                 expect(commentWriteReply.status.code).toBe(202);
                 // 5. Read the encrypted comment back
-                const readMessage = yield RecordsRead.create({
+                const readMessage = await RecordsRead.create({
                     signer: Jws.createSigner(alice),
                     filter: { recordId: encryptedComment.message.recordId },
                 });
-                const readReply = yield dwn.processMessage(alice.did, readMessage.message);
+                const readReply = await dwn.processMessage(alice.did, readMessage.message);
                 expect(readReply.status.code).toBe(200);
                 // 6. Decrypt using the composing protocol's key hierarchy.
                 //    The key derivation path is [protocolPath, commentsProtocol.protocol, 'thread', 'comment']
@@ -1620,11 +2241,11 @@ export function testProtocolComposition() {
                     derivationScheme: KeyDerivationScheme.ProtocolPath,
                     derivedPrivateKey: alice.encryptionKeyPair.privateJwk,
                 };
-                const decryptedStream = yield Records.decrypt(readReply.entry.recordsWrite, rootKey, readReply.entry.data);
-                const decryptedBytes = yield DataStream.toBytes(decryptedStream);
+                const decryptedStream = await Records.decrypt(readReply.entry.recordsWrite, rootKey, readReply.entry.data);
+                const decryptedBytes = await DataStream.toBytes(decryptedStream);
                 expect(Encoder.bytesToString(decryptedBytes)).toBe(plaintext);
-            }));
-            it('should not inject `$encryption` on the original protocol definition (immutability)', () => __awaiter(this, void 0, void 0, function* () {
+            });
+            it('should not inject `$encryption` on the original protocol definition (immutability)', async () => {
                 const composingProtocol = {
                     protocol: 'https://comments.example.com',
                     published: true,
@@ -1639,11 +2260,11 @@ export function testProtocolComposition() {
                         },
                     },
                 };
-                yield Protocols.deriveAndInjectPublicEncryptionKeys(composingProtocol, encryptionRootKeyId, encryptionPrivateJwk);
+                await Protocols.deriveAndInjectPublicEncryptionKeys(composingProtocol, encryptionRootKeyId, encryptionPrivateJwk);
                 // Original must be unmodified
                 expect(composingProtocol.structure.thread.$encryption).toBeUndefined();
                 expect(composingProtocol.structure.thread.comment.$encryption).toBeUndefined();
-            }));
+            });
         });
     });
 }