@enbox/dwn-sdk-js 0.3.4 → 0.3.6

package/src/dwn.ts

@@ -33,21 +33,33 @@ import { StorageController } from './store/storage-controller.js';
 import { DidDht, DidJwk, DidKey, DidResolverCacheMemory, DidWeb, UniversalResolver } from '@enbox/dids';
 import { DwnInterfaceName, DwnMethodName } from './enums/dwn-interface-method.js';
 
+/**
+ * Structural shape for `DidResolver` implementations that expose
+ * optional lifecycle hooks (e.g. cache-backed resolvers that need to
+ * open/close a store). The base `DidResolver` interface in
+ * `@enbox/dids` doesn't declare these methods, so `Dwn.open()` /
+ * `Dwn.close()` probe via this narrowly-typed cast (no `any`).
+ */
+type LifecycleResolver = {
+  open: () => Promise<void>;
+  close: () => Promise<void>;
+};
+
 export class Dwn {
-  private methodHandlers: { [key:string]: MethodHandler };
-  private didResolver: DidResolver;
-  private messageStore: MessageStore;
-  private dataStore: DataStore;
-  private resumableTaskStore: ResumableTaskStore;
-  private stateIndex: StateIndex;
-  private tenantGate: TenantGate;
-  private eventLog?: EventLog;
-  private storageController: StorageController;
-  private resumableTaskManager: ResumableTaskManager;
-  private _coreProtocols: CoreProtocolRegistry;
+  private readonly methodHandlers: { [key:string]: MethodHandler };
+  private readonly didResolver: DidResolver;
+  private readonly messageStore: MessageStore;
+  private readonly dataStore: DataStore;
+  private readonly resumableTaskStore: ResumableTaskStore;
+  private readonly stateIndex: StateIndex;
+  private readonly tenantGate: TenantGate;
+  private readonly eventLog?: EventLog;
+  private readonly storageController: StorageController;
+  private readonly resumableTaskManager: ResumableTaskManager;
+  private readonly _coreProtocols: CoreProtocolRegistry;
 
   /** Whether the DWN owns the resolver's lifecycle (i.e., created it via defaults). */
-  private ownsResolver: boolean;
+  private readonly ownsResolver: boolean;
 
   private constructor(config: DwnConfig) {
     this.didResolver = config.didResolver!;
@@ -125,8 +137,12 @@ export class Dwn {
    */
   public async open(): Promise<void> {
     // Open the resolver's cache if the DWN owns it (created via defaults).
-    if (this.ownsResolver && typeof (this.didResolver as any).open === 'function') {
-      await (this.didResolver as any).open();
+    // The base `DidResolver` interface in `@enbox/dids` doesn't declare
+    // optional lifecycle hooks; cache-backed implementations expose them
+    // structurally. Narrowly-typed probe (no `any`).
+    const lifecycleResolver = this.didResolver as Partial<LifecycleResolver>;
+    if (this.ownsResolver && typeof lifecycleResolver.open === 'function') {
+      await lifecycleResolver.open();
     }
 
     await this.messageStore.open();
@@ -146,8 +162,9 @@ export class Dwn {
     await this.stateIndex.close();
 
     // Close the resolver's cache if the DWN owns it.
-    if (this.ownsResolver && typeof (this.didResolver as any).close === 'function') {
-      await (this.didResolver as any).close();
+    const lifecycleResolver = this.didResolver as Partial<LifecycleResolver>;
+    if (this.ownsResolver && typeof lifecycleResolver.close === 'function') {
+      await lifecycleResolver.close();
     }
   }
 
@@ -204,7 +221,7 @@ export class Dwn {
     const handlerKey = rawMessage.descriptor.interface + rawMessage.descriptor.method;
     const methodHandlerReply = await this.methodHandlers[handlerKey].handle({
       tenant,
-      message: rawMessage as GenericMessage,
+      message: rawMessage,
       dataStream,
       subscriptionHandler
     });

package/src/event-stream/event-emitter-event-log.ts

@@ -65,21 +65,21 @@ export interface EventEmitterEventLogConfig {
  * For multi-node deployments, use a distributed implementation (NATS, Redis, etc.).
  */
 export class EventEmitterEventLog implements EventLog {
-  private emitter = mitt<EmitterEvents>();
+  private readonly emitter = mitt<EmitterEvents>();
   private isOpen: boolean = false;
-  private errorHandler: (error: any) => void = (error): void => { console.error('event log error', error); };
-  private maxEventsPerTenant: number;
+  private readonly errorHandler: (error: any) => void = (error): void => { console.error('event log error', error); };
+  private readonly maxEventsPerTenant: number;
 
   /**
    * Per-tenant ordered event storage.
    * Key: tenant DID → Map of seq → StoredEntry.
    */
-  private tenantLogs: Map<string, Map<number, StoredEntry>> = new Map();
+  private readonly tenantLogs: Map<string, Map<number, StoredEntry>> = new Map();
 
   /**
    * Per-tenant monotonic sequence counter.
    */
-  private tenantSeqs: Map<string, number> = new Map();
+  private readonly tenantSeqs: Map<string, number> = new Map();
 
   /**
    * Epoch for this EventLog instance. Generated once at construction as a
@@ -131,9 +131,7 @@ export class EventEmitterEventLog implements EventLog {
     let reason: ProgressGapReason;
     if (cursor.streamId !== expectedStreamId) {
       reason = 'stream_mismatch';
-    } else if (cursor.epoch !== this.epoch) {
-      reason = 'epoch_mismatch';
-    } else {
+    } else if (cursor.epoch === this.epoch) {
       // Check if position is still within replay bounds.
       const log = this.tenantLogs.get(tenant);
       if (log !== undefined && log.size > 0) {
@@ -148,6 +146,8 @@ export class EventEmitterEventLog implements EventLog {
       } else {
         return; // No events for tenant — cursor is vacuously valid (will get empty catch-up + EOSE).
       }
+    } else {
+      reason = 'epoch_mismatch';
     }
 
     // Build gap metadata.
@@ -226,7 +226,7 @@ export class EventEmitterEventLog implements EventLog {
       await this.validateCursor(tenant, cursor);
     }
 
-    const cursorSeq = cursor !== undefined ? EventEmitterEventLog.parsePosition(cursor.position) : undefined;
+    const cursorSeq = cursor === undefined ? undefined : EventEmitterEventLog.parsePosition(cursor.position);
     const log = this.tenantLogs.get(tenant);
 
     if (log === undefined || log.size === 0) {
@@ -319,12 +319,12 @@ export class EventEmitterEventLog implements EventLog {
         if (filters !== undefined && filters.length > 0) {
           if (!FilterUtility.matchAnyFilter(payload.indexes, filters)) { return; }
         }
-        if (!catchUpComplete) {
-          pendingLiveEvents.push({ event: payload.event, seq: payload.seq, messageCid: payload.messageCid });
-        } else {
+        if (catchUpComplete) {
           void tokenFromPayload(payload).then((token) => {
             listener({ type: 'event', cursor: token, event: payload.event });
           });
+        } else {
+          pendingLiveEvents.push({ event: payload.event, seq: payload.seq, messageCid: payload.messageCid });
         }
       };
 
@@ -334,9 +334,9 @@ export class EventEmitterEventLog implements EventLog {
       const readResult = await this.read(tenant, { cursor, filters });
       // The read cursor is the token of the last read event, or the input cursor if nothing new.
       const eoseCursor = readResult.cursor ?? cursor;
-      const lastCatchUpSeq = readResult.cursor !== undefined
-        ? EventEmitterEventLog.parsePosition(readResult.cursor.position)
-        : cursorSeq;
+      const lastCatchUpSeq = readResult.cursor === undefined
+        ? cursorSeq
+        : EventEmitterEventLog.parsePosition(readResult.cursor.position);
 
       // Use the messageCid captured by read() during its synchronous iteration.
       // This eliminates re-lookup races: read() populates entry.messageCid before

package/src/handlers/messages-read.ts

@@ -18,7 +18,7 @@ type HandleArgs = { tenant: string, message: MessagesReadMessage };
 
 export class MessagesReadHandler implements MethodHandler {
 
-  constructor(private deps: HandlerDependencies) {}
+  constructor(private readonly deps: HandlerDependencies) {}
 
   public async handle({ tenant, message }: HandleArgs): Promise<MessagesReadReply> {
     let messagesRead: MessagesRead;
@@ -52,16 +52,16 @@ export class MessagesReadHandler implements MethodHandler {
       const recordsWrite = entry.message as RecordsQueryReplyEntry;
       // RecordsWrite specific handling, if MessageStore has embedded `encodedData` return it with the entry.
       // we store `encodedData` along with the message if the data is below a certain threshold.
-      if (recordsWrite.encodedData !== undefined) {
-        const dataBytes = Encoder.base64UrlToBytes(recordsWrite.encodedData);
-        entry.data = DataStream.fromBytes(dataBytes);
-        delete recordsWrite.encodedData;
-      } else {
-        // otherwise check the data store for the associated data
+      if (recordsWrite.encodedData === undefined) {
+        // check the data store for the associated data
         const result = await this.deps.dataStore!.get(tenant, recordsWrite.recordId, recordsWrite.descriptor.dataCid);
         if (result?.dataStream !== undefined) {
           entry.data = result.dataStream;
         }
+      } else {
+        const dataBytes = Encoder.base64UrlToBytes(recordsWrite.encodedData);
+        entry.data = DataStream.fromBytes(dataBytes);
+        delete recordsWrite.encodedData;
       }
     }
 

package/src/handlers/messages-subscribe.ts

@@ -14,7 +14,7 @@ import { DwnError, DwnErrorCode } from '../core/dwn-error.js';
 
 export class MessagesSubscribeHandler implements MethodHandler {
 
-  constructor(private deps: HandlerDependencies) {}
+  constructor(private readonly deps: HandlerDependencies) {}
 
   public async handle({
     tenant,
@@ -65,7 +65,7 @@ export class MessagesSubscribeHandler implements MethodHandler {
         const gapInfo = (error as any).gapInfo as ProgressGapInfo | undefined;
         return {
           status : { code: 410, detail: 'Progress token gap' },
-          error  : gapInfo !== undefined ? { code: 'ProgressGap' as const, ...gapInfo } : undefined,
+          error  : gapInfo === undefined ? undefined : { code: 'ProgressGap' as const, ...gapInfo },
         };
       }
       return messageReplyFromError(error, 500);

package/src/handlers/messages-sync.ts

@@ -25,7 +25,7 @@ const DEFAULT_MAX_INLINE_DATA_SIZE = DwnConstant.maxDataSizeAllowedToBeEncoded;
 
 export class MessagesSyncHandler implements MethodHandler {
 
-  constructor(private deps: HandlerDependencies) { }
+  constructor(private readonly deps: HandlerDependencies) { }
 
   public async handle({
     tenant,
@@ -51,9 +51,9 @@ export class MessagesSyncHandler implements MethodHandler {
     try {
       switch (action) {
       case 'root': {
-        const rootHash = protocol !== undefined
-          ? await this.deps.stateIndex!.getProtocolRoot(tenant, protocol)
-          : await this.deps.stateIndex!.getRoot(tenant);
+        const rootHash = protocol === undefined
+          ? await this.deps.stateIndex!.getRoot(tenant)
+          : await this.deps.stateIndex!.getProtocolRoot(tenant, protocol);
         return {
           status : { code: 200, detail: 'OK' },
           root   : hashToHex(rootHash),
@@ -62,9 +62,9 @@ export class MessagesSyncHandler implements MethodHandler {
 
       case 'subtree': {
         const bitPath = MessagesSyncHandler.parseBitPrefix(prefix!);
-        const hash = protocol !== undefined
-          ? await this.deps.stateIndex!.getProtocolSubtreeHash(tenant, protocol, bitPath)
-          : await this.deps.stateIndex!.getSubtreeHash(tenant, bitPath);
+        const hash = protocol === undefined
+          ? await this.deps.stateIndex!.getSubtreeHash(tenant, bitPath)
+          : await this.deps.stateIndex!.getProtocolSubtreeHash(tenant, protocol, bitPath);
         return {
           status : { code: 200, detail: 'OK' },
           hash   : hashToHex(hash),
@@ -73,9 +73,9 @@ export class MessagesSyncHandler implements MethodHandler {
 
       case 'leaves': {
         const bitPath = MessagesSyncHandler.parseBitPrefix(prefix!);
-        const leaves = protocol !== undefined
-          ? await this.deps.stateIndex!.getProtocolLeaves(tenant, protocol, bitPath)
-          : await this.deps.stateIndex!.getLeaves(tenant, bitPath);
+        const leaves = protocol === undefined
+          ? await this.deps.stateIndex!.getLeaves(tenant, bitPath)
+          : await this.deps.stateIndex!.getProtocolLeaves(tenant, protocol, bitPath);
         return {
           status  : { code: 200, detail: 'OK' },
           entries : leaves,
@@ -165,18 +165,18 @@ export class MessagesSyncHandler implements MethodHandler {
       if (clientHash === undefined) {
         // Server has entries the client doesn't — enumerate server leaves.
         const bitPath = MessagesSyncHandler.parseBitPrefix(pfx);
-        const leaves = protocol !== undefined
-          ? await stateIndex.getProtocolLeaves(tenant, protocol, bitPath)
-          : await stateIndex.getLeaves(tenant, bitPath);
+        const leaves = protocol === undefined
+          ? await stateIndex.getLeaves(tenant, bitPath)
+          : await stateIndex.getProtocolLeaves(tenant, protocol, bitPath);
         onlyRemoteCids.push(...leaves);
         continue;
       }
 
       // Both sides have entries but they differ — enumerate both and set-diff.
       const bitPath = MessagesSyncHandler.parseBitPrefix(pfx);
-      const serverLeaves = protocol !== undefined
-        ? await stateIndex.getProtocolLeaves(tenant, protocol, bitPath)
-        : await stateIndex.getLeaves(tenant, bitPath);
+      const serverLeaves = protocol === undefined
+        ? await stateIndex.getLeaves(tenant, bitPath)
+        : await stateIndex.getProtocolLeaves(tenant, protocol, bitPath);
 
       // We don't have the client's leaves, so we report all server leaves
       // as onlyRemote (the client will de-duplicate locally). We also
@@ -210,9 +210,9 @@ export class MessagesSyncHandler implements MethodHandler {
 
     const walk = async (prefix: string, currentDepth: number): Promise<void> => {
       const bitPath = MessagesSyncHandler.parseBitPrefix(prefix);
-      const hash = protocol !== undefined
-        ? await stateIndex.getProtocolSubtreeHash(tenant, protocol, bitPath)
-        : await stateIndex.getSubtreeHash(tenant, bitPath);
+      const hash = protocol === undefined
+        ? await stateIndex.getSubtreeHash(tenant, bitPath)
+        : await stateIndex.getProtocolSubtreeHash(tenant, protocol, bitPath);
       const hexHash = hashToHex(hash);
 
       if (hexHash === defaultHashHex) {

package/src/handlers/protocols-configure.ts

@@ -15,7 +15,7 @@ import { getRuleSetAtPath, parseCrossProtocolRef } from '../utils/protocols.js';
 
 export class ProtocolsConfigureHandler implements MethodHandler {
 
-  constructor(private deps: HandlerDependencies) { }
+  constructor(private readonly deps: HandlerDependencies) { }
 
   public async handle({
     tenant,
@@ -298,7 +298,7 @@ export class ProtocolsConfigureHandler implements MethodHandler {
 
             // Check that the role path exists and is marked $role: true in the referenced protocol
             const roleRuleSet = getRuleSetAtPath(parsed.protocolPath, refDefinition.structure);
-            if (roleRuleSet === undefined || !roleRuleSet.$role) {
+            if (!roleRuleSet?.$role) {
               throw new DwnError(
                 DwnErrorCode.ProtocolsConfigureInvalidCrossProtocolRole,
                 `cross-protocol role '${actionRule.role}' at protocol path '${childProtocolPath}' ` +

package/src/handlers/protocols-query.ts

@@ -5,13 +5,13 @@ import { authenticate } from '../core/auth.js';
 import { DwnErrorCode } from '../core/dwn-error.js';
 import { messageReplyFromError } from '../core/message-reply.js';
 import { ProtocolsQuery } from '../interfaces/protocols-query.js';
-import { removeUndefinedProperties } from '../utils/object.js';
+import { removeUndefinedProperties } from '@enbox/common';
 
 import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.js';
 
 export class ProtocolsQueryHandler implements MethodHandler {
 
-  constructor(private deps: HandlerDependencies) { }
+  constructor(private readonly deps: HandlerDependencies) { }
 
   public async handle({
     tenant,

package/src/handlers/records-count.ts

@@ -14,7 +14,7 @@ import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.j
 
 export class RecordsCountHandler implements MethodHandler {
 
-  constructor(private deps: HandlerDependencies) { }
+  constructor(private readonly deps: HandlerDependencies) { }
 
   public async handle({
     tenant,

package/src/handlers/records-delete.ts

@@ -18,7 +18,7 @@ import { ResumableTaskName } from '../core/resumable-task-manager.js';
 
 export class RecordsDeleteHandler implements MethodHandler {
 
-  constructor(private deps: HandlerDependencies) { }
+  constructor(private readonly deps: HandlerDependencies) { }
 
   public async handle({
     tenant,

package/src/handlers/records-query.ts

@@ -18,7 +18,7 @@ import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.j
 
 export class RecordsQueryHandler implements MethodHandler {
 
-  constructor(private deps: HandlerDependencies) { }
+  constructor(private readonly deps: HandlerDependencies) { }
 
   public async handle({
     tenant,

package/src/handlers/records-read.ts

@@ -20,7 +20,7 @@ import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.j
 
 export class RecordsReadHandler implements MethodHandler {
 
-  constructor(private deps: HandlerDependencies) { }
+  constructor(private readonly deps: HandlerDependencies) { }
 
   public async handle({
     tenant,
@@ -115,11 +115,7 @@ export class RecordsReadHandler implements MethodHandler {
     }
 
     let data;
-    if (matchedRecordsWrite.encodedData !== undefined) {
-      const dataBytes = Encoder.base64UrlToBytes(matchedRecordsWrite.encodedData);
-      data = DataStream.fromBytes(dataBytes);
-      delete matchedRecordsWrite.encodedData;
-    } else {
+    if (matchedRecordsWrite.encodedData === undefined) {
       const result = await this.deps.dataStore!.get(tenant, matchedRecordsWrite.recordId, matchedRecordsWrite.descriptor.dataCid);
       if (result?.dataStream === undefined) {
         // The message envelope exists but the record data is unavailable (e.g., evicted
@@ -131,6 +127,10 @@ export class RecordsReadHandler implements MethodHandler {
         };
       }
       data = result.dataStream;
+    } else {
+      const dataBytes = Encoder.base64UrlToBytes(matchedRecordsWrite.encodedData);
+      data = DataStream.fromBytes(dataBytes);
+      delete matchedRecordsWrite.encodedData;
     }
 
     const recordsReadReply: RecordsReadReply = {

package/src/handlers/records-subscribe.ts

@@ -20,7 +20,7 @@ import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.j
 
 export class RecordsSubscribeHandler implements MethodHandler {
 
-  constructor(private deps: HandlerDependencies) { }
+  constructor(private readonly deps: HandlerDependencies) { }
 
   public async handle({
     tenant,
@@ -97,7 +97,7 @@ export class RecordsSubscribeHandler implements MethodHandler {
           const gapInfo = (error as any).gapInfo as ProgressGapInfo | undefined;
           return {
             status : { code: 410, detail: 'Progress token gap' },
-            error  : gapInfo !== undefined ? { code: 'ProgressGap' as const, ...gapInfo } : undefined,
+            error  : gapInfo === undefined ? undefined : { code: 'ProgressGap' as const, ...gapInfo },
           };
         }
         return messageReplyFromError(error, 500);

package/src/handlers/records-write.ts

@@ -27,7 +27,7 @@ type HandlerArgs = { tenant: string, message: RecordsWriteMessage, dataStream?:
 
 export class RecordsWriteHandler implements MethodHandler {
 
-  constructor(private deps: HandlerDependencies) { }
+  constructor(private readonly deps: HandlerDependencies) { }
 
   public async handle({
     tenant,
@@ -106,7 +106,7 @@ export class RecordsWriteHandler implements MethodHandler {
         if (isInitial) {
           const hasInlineData = !!(newestExistingMessage as any).encodedData;
           const hasStoredData = this.deps.dataStore
-            ? !!(await this.deps.dataStore.get(tenant, recordsWrite.message.recordId, message.descriptor.dataCid!))
+            ? !!(await this.deps.dataStore.get(tenant, recordsWrite.message.recordId, message.descriptor.dataCid))
             : false;
           existingLacksData = !hasInlineData && !hasStoredData;
         }
@@ -121,9 +121,9 @@ export class RecordsWriteHandler implements MethodHandler {
 
     // Look up the core protocol (if any) for the incoming message so that lifecycle hooks
     // can be dispatched generically rather than checking for specific protocol URIs.
-    const coreProtocol = message.descriptor.protocol !== undefined
-      ? this.deps.coreProtocols?.get(message.descriptor.protocol)
-      : undefined;
+    const coreProtocol = message.descriptor.protocol === undefined
+      ? undefined
+      : this.deps.coreProtocols?.get(message.descriptor.protocol);
 
     try {
       if (newestExistingMessage?.descriptor.method === DwnMethodName.Delete) {
@@ -148,11 +148,8 @@ export class RecordsWriteHandler implements MethodHandler {
       let isLatestBaseState = false;
       let messageWithOptionalEncodedData = message as RecordsQueryReplyEntry;
 
-      if (dataStream !== undefined) {
-        messageWithOptionalEncodedData = await this.processMessageWithDataStream(tenant, message, dataStream);
-        isLatestBaseState = true;
-      } else {
-        // else data stream is NOT provided
+      if (dataStream === undefined) {
+        // data stream is NOT provided
 
         // if the incoming message is not an initial write, and no dataStream is provided, we would allow it provided it passes validation
         // processMessageWithoutDataStream() abstracts that logic
@@ -161,6 +158,9 @@ export class RecordsWriteHandler implements MethodHandler {
           messageWithOptionalEncodedData = await this.processMessageWithoutDataStream(tenant, message, newestExistingWrite );
           isLatestBaseState = true;
         }
+      } else {
+        messageWithOptionalEncodedData = await this.processMessageWithDataStream(tenant, message, dataStream);
+        isLatestBaseState = true;
       }
 
       const indexes = await recordsWrite.constructIndexes(isLatestBaseState);
@@ -252,14 +252,14 @@ export class RecordsWriteHandler implements MethodHandler {
     // if data is below the threshold, we store it within MessageStore
     if (message.descriptor.dataSize <= DwnConstant.maxDataSizeAllowedToBeEncoded) {
       // validate data integrity before setting.
-      const dataBytes = await DataStream.toBytes(dataStream!);
+      const dataBytes = await DataStream.toBytes(dataStream);
       const dataCid = await Cid.computeDagPbCidFromBytes(dataBytes);
       RecordsWriteHandler.validateDataIntegrity(message.descriptor.dataCid, message.descriptor.dataSize, dataCid, dataBytes.length);
 
       // Dispatch schema validation to the core protocol, if applicable.
-      const coreProtocol = message.descriptor.protocol !== undefined
-        ? this.deps.coreProtocols?.get(message.descriptor.protocol)
-        : undefined;
+      const coreProtocol = message.descriptor.protocol === undefined
+        ? undefined
+        : this.deps.coreProtocols?.get(message.descriptor.protocol);
       if (coreProtocol?.validateRecord !== undefined) {
         coreProtocol.validateRecord(message, dataBytes);
       }
@@ -304,13 +304,13 @@ export class RecordsWriteHandler implements MethodHandler {
 
     if (dataSize <= DwnConstant.maxDataSizeAllowedToBeEncoded) {
       // we encode the data from the original write if it is smaller than the data-store threshold
-      if (newestExistingWrite.encodedData !== undefined) {
-        messageWithOptionalEncodedData.encodedData = newestExistingWrite.encodedData;
-      } else {
+      if (newestExistingWrite.encodedData === undefined) {
         throw new DwnError(
           DwnErrorCode.RecordsWriteMissingEncodedDataInPrevious,
           `No dataStream was provided and unable to get data from previous message`
         );
+      } else {
+        messageWithOptionalEncodedData.encodedData = newestExistingWrite.encodedData;
       }
     } else {
       // else just make sure the data is in the data store
@@ -396,7 +396,7 @@ export class RecordsWriteHandler implements MethodHandler {
       ruleSet = ruleSet[pathSegments[i]] as typeof ruleSet;
     }
 
-    if (ruleSet === undefined || ruleSet.$squash !== true) {
+    if (ruleSet?.$squash !== true) {
       return;
     }
 

package/src/index.ts

@@ -2,7 +2,7 @@
 export type { DwnConfig } from './dwn.js';
 export type { EventListener, EventLog, EventLogEntry, EventLogReadOptions, EventLogReadResult, EventLogSubscribeOptions, EventSubscription, MessageEvent, ProgressGapInfo, ProgressGapReason, ProgressToken, SubscriptionEose, SubscriptionEvent, SubscriptionListener, SubscriptionMessage, SubscriptionReply } from './types/subscriptions.js';
 export type { AuthorizationModel, Descriptor, DelegatedGrantRecordsWriteMessage, GenericMessage, GenericMessageReply, GenericSignaturePayload, MessageSort, MessageSubscription, Pagination, QueryResultEntry, Status } from './types/message-types.js';
-export type { MessagesFilter, MessagesReadMessage as MessagesReadMessage, MessagesReadReply as MessagesReadReply, MessagesReadReplyEntry as MessagesReadReplyEntry, MessagesReadDescriptor, MessagesSubscribeDescriptor, MessagesSubscribeMessage, MessagesSubscribeReply, MessagesSubscribeMessageOptions, MessagesSyncAction, MessagesSyncDescriptor, MessagesSyncDiffEntry, MessagesSyncMessage, MessagesSyncReply } from './types/messages-types.js';
+export type { MessagesFilter, MessagesReadMessage, MessagesReadReply, MessagesReadReplyEntry, MessagesReadDescriptor, MessagesSubscribeDescriptor, MessagesSubscribeMessage, MessagesSubscribeReply, MessagesSubscribeMessageOptions, MessagesSyncAction, MessagesSyncDescriptor, MessagesSyncDiffEntry, MessagesSyncMessage, MessagesSyncReply } from './types/messages-types.js';
 export type { GT, LT, Filter, FilterValue, KeyValues, EqualFilter, OneOfFilter, RangeFilter, RangeCriterion, PaginationCursor, QueryOptions, RangeValue, StartsWithFilter } from './types/query-types.js';
 export type { ProtocolsConfigureDescriptor, ProtocolDefinition, ProtocolTypes, ProtocolRuleSet, ProtocolsQueryFilter, ProtocolsConfigureMessage, ProtocolsQueryMessage, ProtocolsQueryReply, ProtocolActionRule, ProtocolDeliveryStrategy, ProtocolPathEncryption, ProtocolsQueryDescriptor, ProtocolRecordLimitDefinition, ProtocolSizeDefinition, ProtocolTagsDefinition, ProtocolTagSchema, ProtocolType, ProtocolUses } from './types/protocols-types.js';
 export { ProtocolRecordLimitStrategy } from './types/protocols-types.js';
@@ -30,8 +30,8 @@ export { DwnConstant } from './core/dwn-constant.js';
 export { DwnError, DwnErrorCode } from './core/dwn-error.js';
 export { DwnInterfaceName, DwnMethodName } from './enums/dwn-interface-method.js';
 export { Encoder } from './utils/encoder.js';
-export { MessagesSubscribe as MessagesSubscribe } from './interfaces/messages-subscribe.js';
-export type { MessagesSubscribeOptions as MessagesSubscribeOptions } from './interfaces/messages-subscribe.js';
+export { MessagesSubscribe } from './interfaces/messages-subscribe.js';
+export type { MessagesSubscribeOptions } from './interfaces/messages-subscribe.js';
 export { Encryption, ContentEncryptionAlgorithm, KeyAgreementAlgorithm } from './utils/encryption.js';
 export type { JweEncryption, JweRecipient, JweRecipientHeader, JweProtectedHeader, JweKeyUnwrapPayload } from './utils/encryption.js';
 export { RecordsWrite } from './interfaces/records-write.js';
@@ -40,8 +40,8 @@ export { executeUnlessAborted } from './utils/abort.js';
 export { Jws } from './utils/jws.js';
 export type { KeyMaterial, PrivateKeyJwk, PublicKeyJwk, Jwk } from './types/jose-types.js';
 export { Message } from './core/message.js';
-export { MessagesRead as MessagesRead } from './interfaces/messages-read.js';
-export type { MessagesReadOptions as MessagesReadOptions } from './interfaces/messages-read.js';
+export { MessagesRead } from './interfaces/messages-read.js';
+export type { MessagesReadOptions } from './interfaces/messages-read.js';
 export { MessagesSync } from './interfaces/messages-sync.js';
 export type { MessagesSyncOptions } from './interfaces/messages-sync.js';
 export type { UnionMessageReply } from './core/message-reply.js';

package/src/interfaces/messages-subscribe.ts

@@ -5,7 +5,7 @@ import type { MessagesSubscribeDescriptor, MessagesSubscribeMessage } from '../t
 
 import { AbstractMessage } from '../core/abstract-message.js';
 import { Message } from '../core/message.js';
-import { removeUndefinedProperties } from '../utils/object.js';
+import { removeUndefinedProperties } from '@enbox/common';
 import { Time } from '../utils/time.js';
 import { validateProtocolUrlNormalized } from '../utils/url.js';
 import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.js';

package/src/interfaces/messages-sync.ts

@@ -3,7 +3,7 @@ import type { MessagesSyncAction, MessagesSyncDescriptor, MessagesSyncMessage }
 
 import { AbstractMessage } from '../core/abstract-message.js';
 import { Message } from '../core/message.js';
-import { removeUndefinedProperties } from '../utils/object.js';
+import { removeUndefinedProperties } from '@enbox/common';
 import { Time } from '../utils/time.js';
 import { validateProtocolUrlNormalized } from '../utils/url.js';
 import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.js';

package/src/interfaces/protocols-configure.ts

@@ -377,16 +377,8 @@ export class ProtocolsConfigure extends AbstractMessage<ProtocolsConfigureMessag
       for (let j = i + 1; j < actionRules.length; j++) {
         const otherActionRule = actionRules[j];
 
-        if (actionRule.who !== undefined) {
-          if (actionRule.who === otherActionRule.who && actionRule.of === otherActionRule.of) {
-            throw new DwnError(
-              DwnErrorCode.ProtocolsConfigureDuplicateActorInRuleSet,
-              `More than one action rule per actor ${actionRule.who} of ${actionRule.of} ` +
-              `not allowed within a rule set: ${JSON.stringify(actionRule)}`
-            );
-          }
-        } else {
-          // else implicitly a role-based action rule
+        if (actionRule.who === undefined) {
+          // implicitly a role-based action rule
 
           if (actionRule.role === otherActionRule.role) {
             throw new DwnError(
@@ -394,6 +386,14 @@ export class ProtocolsConfigure extends AbstractMessage<ProtocolsConfigureMessag
               `More than one action rule per role ${actionRule.role} not allowed within a rule set: ${JSON.stringify(actionRule)}`
             );
           }
+        } else {
+          if (actionRule.who === otherActionRule.who && actionRule.of === otherActionRule.of) {
+            throw new DwnError(
+              DwnErrorCode.ProtocolsConfigureDuplicateActorInRuleSet,
+              `More than one action rule per actor ${actionRule.who} of ${actionRule.of} ` +
+              `not allowed within a rule set: ${JSON.stringify(actionRule)}`
+            );
+          }
         }
       }
     }
@@ -497,7 +497,7 @@ export class ProtocolsConfigure extends AbstractMessage<ProtocolsConfigureMessag
     }
 
     // validate alias exists in `uses`
-    if (uses === undefined || uses[parsed.alias] === undefined) {
+    if (uses?.[parsed.alias] === undefined) {
       throw new DwnError(
         DwnErrorCode.ProtocolsConfigureInvalidRefAlias,
         `'$ref' alias '${parsed.alias}' at protocol path '${ruleSetProtocolPath}' does not exist in the 'uses' map.`
@@ -543,7 +543,7 @@ export class ProtocolsConfigure extends AbstractMessage<ProtocolsConfigureMessag
       );
     }
 
-    if (uses === undefined || uses[parsed.alias] === undefined) {
+    if (uses?.[parsed.alias] === undefined) {
       const errorCode = fieldName === 'role'
         ? DwnErrorCode.ProtocolsConfigureInvalidCrossProtocolRole
         : DwnErrorCode.ProtocolsConfigureInvalidCrossProtocolOf;

package/src/interfaces/protocols-query.ts

@@ -7,7 +7,7 @@ import { AbstractMessage } from '../core/abstract-message.js';
 import { Message } from '../core/message.js';
 import { PermissionsProtocol } from '../protocols/permissions.js';
 import { ProtocolsGrantAuthorization } from '../core/protocols-grant-authorization.js';
-import { removeUndefinedProperties } from '../utils/object.js';
+import { removeUndefinedProperties } from '@enbox/common';
 import { Time } from '../utils/time.js';
 import { DwnError, DwnErrorCode } from '../core/dwn-error.js';
 import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.js';

package/src/interfaces/records-count.ts

@@ -7,7 +7,7 @@ import { Message } from '../core/message.js';
 import { PermissionGrant } from '../protocols/permission-grant.js';
 import { Records } from '../utils/records.js';
 import { RecordsGrantAuthorization } from '../core/records-grant-authorization.js';
-import { removeUndefinedProperties } from '../utils/object.js';
+import { removeUndefinedProperties } from '@enbox/common';
 import { Time } from '../utils/time.js';
 import { DwnError, DwnErrorCode } from '../core/dwn-error.js';
 import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.js';