@enbox/dwn-sdk-js 0.0.5 → 0.0.7

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';
@@ -35,7 +26,7 @@ export function testProtocolComposition() {
         let stateIndex;
         let eventStream;
         let dwn;
-        beforeAll(() => __awaiter(this, void 0, void 0, function* () {
+        beforeAll(async () => {
             didResolver = new UniversalResolver({ didResolvers: [DidKey] });
             const stores = TestStores.get();
             messageStore = stores.messageStore;
@@ -43,18 +34,18 @@ export function testProtocolComposition() {
             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* () {
+            dwn = await Dwn.create({ didResolver, messageStore, dataStore, stateIndex, eventStream, 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,13 @@ export function testProtocolComposition() {
                     // JSON schema enforces minProperties: 1 on `uses`
                     expect(error.message).toContain('must NOT have fewer than 1 properties');
                 }
-            }));
+            });
         });
         // =========================================================================
         // 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 +1257,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 +1301,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 +1334,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 +1344,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 +1368,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 +1386,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 +1396,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 +1422,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 +1434,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 +1460,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 +1483,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 +1500,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 +1521,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 +1592,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 +1610,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 +1629,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();
-            }));
+            });
         });
     });
 }