@enbox/dwn-sdk-js 0.0.7 → 0.1.0

package/src/handlers/records-subscribe.ts

@@ -1,14 +1,13 @@
-import type { DidResolver } from '@enbox/dids';
+import type { CoreProtocolRegistry } from '../core/core-protocol.js';
 import type { MessageSort } from '../types/message-types.js';
 import type { MessageStore } from '../types//message-store.js';
-import type { MethodHandler } from '../types/method-handler.js';
-import type { EventListener, EventStream } from '../types/subscriptions.js';
+import type { SubscriptionListener } from '../types/subscriptions.js';
 import type { Filter, PaginationCursor } from '../types/query-types.js';
-import type { RecordEvent, RecordsQueryReplyEntry, RecordsSubscribeMessage, RecordsSubscribeReply, RecordSubscriptionHandler } from '../types/records-types.js';
+import type { HandlerDependencies, MethodHandler } from '../types/method-handler.js';
+import type { RecordsQueryReplyEntry, RecordsSubscribeMessage, RecordsSubscribeReply } from '../types/records-types.js';
 
 import { authenticate } from '../core/auth.js';
 import { DateSort } from '../types/records-types.js';
-import { FilterUtility } from '../utils/filter.js';
 import { Message } from '../core/message.js';
 import { messageReplyFromError } from '../core/message-reply.js';
 import { ProtocolAuthorization } from '../core/protocol-authorization.js';
@@ -21,7 +20,7 @@ import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.j
 
 export class RecordsSubscribeHandler implements MethodHandler {
 
-  constructor(private didResolver: DidResolver, private messageStore: MessageStore, private eventStream?: EventStream) { }
+  constructor(private deps: HandlerDependencies) { }
 
   public async handle({
     tenant,
@@ -30,11 +29,11 @@ export class RecordsSubscribeHandler implements MethodHandler {
   }: {
     tenant: string,
     message: RecordsSubscribeMessage,
-    subscriptionHandler: RecordSubscriptionHandler,
+    subscriptionHandler: SubscriptionListener,
   }): Promise<RecordsSubscribeReply> {
-    if (this.eventStream === undefined) {
+    if (this.deps.eventLog === undefined) {
       return messageReplyFromError(new DwnError(
-        DwnErrorCode.RecordsSubscribeEventStreamUnimplemented,
+        DwnErrorCode.RecordsSubscribeEventLogUnimplemented,
         'Subscriptions are not supported'
       ), 501);
     }
@@ -59,8 +58,8 @@ export class RecordsSubscribeHandler implements MethodHandler {
     } else {
       // authentication and authorization
       try {
-        await authenticate(message.authorization!, this.didResolver);
-        await RecordsSubscribeHandler.authorizeRecordsSubscribe(tenant, recordsSubscribe, this.messageStore);
+        await authenticate(message.authorization!, this.deps.didResolver);
+        await RecordsSubscribeHandler.authorizeRecordsSubscribe(tenant, recordsSubscribe, this.deps.messageStore, this.deps.coreProtocols);
       } catch (error) {
         return messageReplyFromError(error, 401);
       }
@@ -74,30 +73,51 @@ export class RecordsSubscribeHandler implements MethodHandler {
       }
     }
 
-    // Step 1: Register event listener FIRST to ensure no events are missed between query and subscribe
-    const listener: EventListener = (eventTenant, event, eventIndexes):void => {
-      if (tenant === eventTenant && FilterUtility.matchAnyFilter(eventIndexes, eventFilters)) {
-        subscriptionHandler(event as RecordEvent);
+    const messageCid = await Message.getCid(message);
+    const { cursor: eventLogCursor } = recordsSubscribe.message.descriptor;
+
+    if (eventLogCursor !== undefined) {
+      // ---- Cursor mode: catch-up from EventLog + EOSE + live ----
+      // All catch-up, buffering, dedup, and EOSE delivery are handled by the
+      // EventLog implementation. The handler just passes the cursor and filters.
+      // The subscriptionHandler receives SubscriptionMessage (event + EOSE) directly.
+
+      try {
+        const subscription = await this.deps.eventLog!.subscribe(tenant, messageCid, subscriptionHandler, {
+          cursor  : eventLogCursor,
+          filters : eventFilters,
+        });
+
+        return {
+          status: { code: 200, detail: 'OK' },
+          subscription,
+        };
+      } catch (error) {
+        return messageReplyFromError(error, 500);
       }
-    };
+    }
 
-    const messageCid = await Message.getCid(message);
-    const subscription = await this.eventStream.subscribe(tenant, messageCid, listener);
+    // ---- No cursor: existing behavior (initial snapshot from MessageStore) ----
+
+    // Step 1: Register event listener FIRST to ensure no events are missed between query and subscribe
+    const subscription = await this.deps.eventLog!.subscribe(tenant, messageCid, subscriptionHandler, {
+      filters: eventFilters,
+    });
 
     // Step 2: Query for initial snapshot of matching records
     let entries: RecordsQueryReplyEntry[];
-    let cursor: PaginationCursor | undefined;
+    let paginationCursor: PaginationCursor | undefined;
     try {
       const { dateSort, pagination } = recordsSubscribe.message.descriptor;
       const messageSort = RecordsSubscribeHandler.convertDateSort(dateSort);
-      const queryResult = await this.messageStore.query(tenant, queryFilters, messageSort, pagination);
+      const queryResult = await this.deps.messageStore.query(tenant, queryFilters, messageSort, pagination);
       entries = queryResult.messages as RecordsQueryReplyEntry[];
-      cursor = queryResult.cursor;
+      paginationCursor = queryResult.cursor;
 
       // attach initialWrite for non-initial writes
       for (const entry of entries) {
         if (!await RecordsWrite.isInitialWrite(entry)) {
-          const initialWriteResult = await this.messageStore.query(
+          const initialWriteResult = await this.deps.messageStore.query(
             tenant,
             [{ recordId: entry.recordId, isLatestBaseState: false, method: DwnMethodName.Write }]
           );
@@ -114,10 +134,10 @@ export class RecordsSubscribeHandler implements MethodHandler {
 
     // Step 3: Return subscription + initial entries + cursor
     return {
-      status: { code: 200, detail: 'OK' },
+      status : { code: 200, detail: 'OK' },
       subscription,
       entries,
-      cursor
+      cursor : paginationCursor,
     };
   }
 
@@ -300,7 +320,8 @@ export class RecordsSubscribeHandler implements MethodHandler {
   public static async authorizeRecordsSubscribe(
     tenant: string,
     recordsSubscribe: RecordsSubscribe,
-    messageStore: MessageStore
+    messageStore: MessageStore,
+    coreProtocols?: CoreProtocolRegistry,
   ): Promise<void> {
 
     if (Message.isSignedByAuthorDelegate(recordsSubscribe.message)) {
@@ -311,7 +332,7 @@ export class RecordsSubscribeHandler implements MethodHandler {
     // this is because we dynamically filter out records that the caller is not authorized to see.
     // Currently only run protocol authorization if message deliberately invokes a protocol role.
     if (Records.shouldProtocolAuthorize(recordsSubscribe.signaturePayload!)) {
-      await ProtocolAuthorization.authorizeQueryOrSubscribe(tenant, recordsSubscribe, messageStore);
+      await ProtocolAuthorization.authorizeQueryOrSubscribe(tenant, recordsSubscribe, messageStore, coreProtocols);
     }
   }
 }

package/src/handlers/records-write.ts

@@ -1,10 +1,7 @@
-import type { DataStore } from '../types/data-store.js';
-import type { DidResolver } from '@enbox/dids';
-import type { EventStream } from '../types/subscriptions.js';
+import type { Filter } from '../types/query-types.js';
 import type { GenericMessageReply } from '../types/message-types.js';
 import type { MessageStore } from '../types/message-store.js';
-import type { MethodHandler } from '../types/method-handler.js';
-import type { StateIndex } from '../types/state-index.js';
+import type { HandlerDependencies, MethodHandler } from '../types/method-handler.js';
 import type { RecordsQueryReplyEntry, RecordsWriteMessage } from '../types/records-types.js';
 
 import { authenticate } from '../core/auth.js';
@@ -12,12 +9,16 @@ import { Cid } from '../utils/cid.js';
 import { DataStream } from '../utils/data-stream.js';
 import { DwnConstant } from '../core/dwn-constant.js';
 import { Encoder } from '../utils/encoder.js';
+import { FilterUtility } from '../utils/filter.js';
 import { Message } from '../core/message.js';
 import { messageReplyFromError } from '../core/message-reply.js';
 import { PermissionsProtocol } from '../protocols/permissions.js';
 import { ProtocolAuthorization } from '../core/protocol-authorization.js';
+import { Records } from '../utils/records.js';
 import { RecordsGrantAuthorization } from '../core/records-grant-authorization.js';
 import { RecordsWrite } from '../interfaces/records-write.js';
+import { ResumableTaskName } from '../core/resumable-task-manager.js';
+import { SortDirection } from '../types/query-types.js';
 import { StorageController } from '../store/storage-controller.js';
 import { DwnError, DwnErrorCode } from '../core/dwn-error.js';
 import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.js';
@@ -26,13 +27,7 @@ type HandlerArgs = { tenant: string, message: RecordsWriteMessage, dataStream?:
 
 export class RecordsWriteHandler implements MethodHandler {
 
-  constructor(
-    private didResolver: DidResolver,
-    private messageStore: MessageStore,
-    private dataStore: DataStore,
-    private stateIndex: StateIndex,
-    private eventStream?: EventStream
-  ) { }
+  constructor(private deps: HandlerDependencies) { }
 
   public async handle({
     tenant,
@@ -43,18 +38,15 @@ export class RecordsWriteHandler implements MethodHandler {
     try {
       recordsWrite = await RecordsWrite.parse(message);
 
-      // Protocol-authorized record specific validation
-      if (message.descriptor.protocol !== undefined) {
-        await ProtocolAuthorization.validateReferentialIntegrity(tenant, recordsWrite, this.messageStore);
-      }
+      await ProtocolAuthorization.validateReferentialIntegrity(tenant, recordsWrite, this.deps.messageStore, this.deps.coreProtocols);
     } catch (e) {
       return messageReplyFromError(e, 400);
     }
 
     // authentication & authorization
     try {
-      await authenticate(message.authorization, this.didResolver, message.attestation);
-      await RecordsWriteHandler.authorizeRecordsWrite(tenant, recordsWrite, this.messageStore);
+      await authenticate(message.authorization, this.deps.didResolver, message.attestation);
+      await this.authorizeRecordsWrite(tenant, recordsWrite, this.deps.messageStore);
     } catch (e) {
       return messageReplyFromError(e, 401);
     }
@@ -64,7 +56,7 @@ export class RecordsWriteHandler implements MethodHandler {
       interface : DwnInterfaceName.Records,
       recordId  : message.recordId
     };
-    const { messages: existingMessages } = await this.messageStore.query(tenant, [ query ]);
+    const { messages: existingMessages } = await this.deps.messageStore.query(tenant, [ query ]);
 
     // if the incoming write is not the initial write, then it must not modify any immutable properties defined by the initial write
     const newMessageIsInitialWrite = await recordsWrite.isInitialWrite();
@@ -78,6 +70,15 @@ export class RecordsWriteHandler implements MethodHandler {
       }
     }
 
+    // Squash backstop: if the protocol path has $squash: true, reject any write whose
+    // messageTimestamp is <= the most recent squash record at the same path and parent context.
+    // The squash record acts as a temporal floor — no record older than the latest squash can exist.
+    try {
+      await this.enforceSquashBackstop(tenant, message);
+    } catch (e) {
+      return messageReplyFromError(e, 409);
+    }
+
     const newestExistingMessage = await Message.getNewestMessage(existingMessages);
 
     let incomingMessageIsNewest = false;
@@ -95,6 +96,12 @@ 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;
+
     try {
       if (newestExistingMessage?.descriptor.method === DwnMethodName.Delete) {
         throw new DwnError(
@@ -103,11 +110,12 @@ export class RecordsWriteHandler implements MethodHandler {
         );
       }
 
-      // NOTE: We want to perform additional validation before storing the RecordsWrite.
-      // This is necessary for core DWN RecordsWrite that needs additional processing and allows us to fail before the storing and post processing.
-      //
-      // Example: Ensures that the protocol tag of a permission revocation RecordsWrite and the parent grant's scoped protocol match.
-      await this.preProcessingForCoreRecordsWrite(tenant, message);
+      // Dispatch pre-processing hooks to the core protocol, if applicable.
+      // This allows core protocols to perform cross-record validation before storage
+      // (e.g. ensuring revocation tag consistency with the parent grant's scoped protocol).
+      if (coreProtocol?.preProcessWrite !== undefined) {
+        await coreProtocol.preProcessWrite(tenant, message, this.deps.messageStore);
+      }
 
       // NOTE: We allow isLatestBaseState to be true ONLY if the incoming message comes with data, or if the incoming message is NOT an initial write
       // This would allow an initial write to be written to the DB without data, but having it not queryable,
@@ -133,14 +141,14 @@ export class RecordsWriteHandler implements MethodHandler {
       }
 
       const indexes = await recordsWrite.constructIndexes(isLatestBaseState);
-      await this.messageStore.put(tenant, messageWithOptionalEncodedData, indexes);
-      await this.stateIndex.insert(tenant, await Message.getCid(message), indexes);
+      await this.deps.messageStore.put(tenant, messageWithOptionalEncodedData, indexes);
+      await this.deps.stateIndex!.insert(tenant, await Message.getCid(message), indexes);
 
       // NOTE: We only emit a `RecordsWrite` when the message is the latest base state.
       // Because we allow a `RecordsWrite` which is not the latest state to be written, but not queried, we shouldn't emit it either.
       // It will be emitted as a part of a subsequent next write, if it is the latest base state.
-      if (this.eventStream !== undefined && isLatestBaseState) {
-        this.eventStream.emit(tenant, { message, initialWrite }, indexes);
+      if (this.deps.eventLog !== undefined && isLatestBaseState) {
+        await this.deps.eventLog.emit(tenant, { message, initialWrite }, indexes);
       }
     } catch (error) {
       if (error instanceof DwnError) {
@@ -149,8 +157,8 @@ export class RecordsWriteHandler implements MethodHandler {
           error.code === DwnErrorCode.RecordsWriteNotAllowedAfterDelete ||
           error.code === DwnErrorCode.RecordsWriteDataCidMismatch ||
           error.code === DwnErrorCode.RecordsWriteDataSizeMismatch ||
-          error.code.startsWith('PermissionsProtocolValidate') ||
-          error.code.startsWith('SchemaValidator')) {
+          error.code.startsWith('SchemaValidator') ||
+          this.deps.coreProtocols?.mapErrorToStatusCode(error.code) !== undefined) {
           return messageReplyFromError(error, 400);
         }
       }
@@ -170,93 +178,31 @@ export class RecordsWriteHandler implements MethodHandler {
 
     // delete all existing messages of the same record that are not newest, except for the initial write
     await StorageController.deleteAllOlderMessagesButKeepInitialWrite(
-      tenant, existingMessages, newestMessage, this.messageStore, this.dataStore, this.stateIndex
+      tenant, existingMessages, newestMessage, this.deps.messageStore, this.deps.dataStore!, this.deps.stateIndex!
     );
 
-    await this.postProcessingForCoreRecordsWrite(tenant, recordsWrite);
-
-    return messageReply;
-  };
-
-  /**
-   * Performs additional necessary validation before storing the RecordsWrite if it is a core DWN RecordsWrite that needs additional processing.
-   * For instance: a Permission revocation RecordsWrite.
-   */
-  private async preProcessingForCoreRecordsWrite(tenant: string, recordsWriteMessage: RecordsWriteMessage): Promise<void> {
-
-    // we validate the protocol tag of the revocation message against the grant's scoped protocol
-    // to do this we will fetch the grant, and compare the the scoped protocol value to the protocol tag of the revocation message
-    if (recordsWriteMessage.descriptor.protocol === PermissionsProtocol.uri &&
-      recordsWriteMessage.descriptor.protocolPath === PermissionsProtocol.revocationPath) {
-
-      // get the parentId of the revocation message, which is the permissionGrantId
-      // fetch the grant in order to get the grant's protocol
-      const permissionGrantId = recordsWriteMessage.descriptor.parentId!;
-      const grant = await PermissionsProtocol.fetchGrant(tenant, this.messageStore, permissionGrantId);
-
-      // get the protocol values of the revocation message from the protocol tag and the protocol from the grant scope if they are defined
-      // compare the two values ensuring they must match
-      const revokeTagProtocol = recordsWriteMessage.descriptor.tags?.protocol;
-      const grantProtocol = 'protocol' in grant.scope ? grant.scope.protocol : undefined;
-      if (grantProtocol !== revokeTagProtocol) {
-        throw new DwnError(
-          DwnErrorCode.PermissionsProtocolValidateRevocationProtocolTagMismatch,
-          `Revocation protocol ${revokeTagProtocol} does not match grant protocol ${grantProtocol}`
-        );
-      }
-    }
-  }
-
-  private static validateSchemaForCoreRecordsWrite(recordsWriteMessage: RecordsWriteMessage, dataBytes: Uint8Array): void {
-    if (recordsWriteMessage.descriptor.protocol === PermissionsProtocol.uri) {
-      PermissionsProtocol.validateSchema(recordsWriteMessage, dataBytes);
-    }
-  }
-
-  /**
-   * Performs additional necessary tasks if the RecordsWrite handled is a core DWN RecordsWrite that need additional processing.
-   * For instance: when a Permission revocation is written, all messages authorized by the revoked grant
-   * that were created after the revocation timestamp are deleted from all stores.
-   */
-  private async postProcessingForCoreRecordsWrite(tenant: string, recordsWrite: RecordsWrite): Promise<void> {
-    if (recordsWrite.message.descriptor.protocol !== PermissionsProtocol.uri ||
-      recordsWrite.message.descriptor.protocolPath !== PermissionsProtocol.revocationPath) {
-      return;
-    }
-
-    // Delete all messages authorized by the revoked grant that were created after the revocation.
-    // `permissionGrantId` is indexed via the RecordsWriteDescriptor spread in constructIndexes().
-    const permissionGrantId = recordsWrite.message.descriptor.parentId!;
-    const grantAuthorizedMessagesQuery = {
-      permissionGrantId,
-      dateCreated: { gte: recordsWrite.message.descriptor.messageTimestamp },
-    };
-    const { messages: grantAuthorizedMessages } = await this.messageStore.query(tenant, [grantAuthorizedMessagesQuery]);
-
-    if (grantAuthorizedMessages.length === 0) {
-      return;
+    // Squash processing: if the incoming write is a squash, delete all older sibling records
+    // at the same protocol path and parent context. Uses the resumable task system for crash safety.
+    if (message.descriptor.squash === true) {
+      await this.deps.resumableTaskManager!.run({
+        name : ResumableTaskName.RecordsSquash,
+        data : { tenant, message }
+      });
     }
 
-    // Delete data from the data store first to avoid orphaned data blobs in case of crash.
-    // Only RecordsWrite messages with data larger than maxDataSizeAllowedToBeEncoded have data in the data store.
-    for (const message of grantAuthorizedMessages) {
-      if (message.descriptor.method === DwnMethodName.Write) {
-        const recordsWriteMessage = message as RecordsWriteMessage;
-        if (recordsWriteMessage.descriptor.dataSize > DwnConstant.maxDataSizeAllowedToBeEncoded) {
-          await this.dataStore.delete(tenant, recordsWriteMessage.recordId, recordsWriteMessage.descriptor.dataCid);
-        }
-      }
+    // Dispatch post-processing hooks to the core protocol, if applicable.
+    // This allows core protocols to perform cascading side effects after a successful write
+    // (e.g. deleting messages authorized by a revoked grant).
+    if (coreProtocol?.postProcessWrite !== undefined) {
+      await coreProtocol.postProcessWrite(tenant, recordsWrite, {
+        messageStore : this.deps.messageStore,
+        dataStore    : this.deps.dataStore!,
+        stateIndex   : this.deps.stateIndex!,
+      });
     }
 
-    // Compute CIDs for all messages to delete.
-    const messageCids = await Promise.all(grantAuthorizedMessages.map((message): Promise<string> => Message.getCid(message)));
-
-    // Delete from state index before message store so we don't have orphaned state entries.
-    await this.stateIndex.delete(tenant, messageCids);
-
-    // Finally delete all messages from the message store.
-    await Promise.all(messageCids.map((cid): Promise<void> => this.messageStore.delete(tenant, cid)));
-  }
+    return messageReply;
+  };
 
   /**
    * Returns a `RecordsQueryReplyEntry` with a copy of the incoming message and the incoming data encoded to `Base64URL`.
@@ -281,7 +227,13 @@ export class RecordsWriteHandler implements MethodHandler {
       const dataCid = await Cid.computeDagPbCidFromBytes(dataBytes);
       RecordsWriteHandler.validateDataIntegrity(message.descriptor.dataCid, message.descriptor.dataSize, dataCid, dataBytes.length);
 
-      RecordsWriteHandler.validateSchemaForCoreRecordsWrite(message, dataBytes);
+      // Dispatch schema validation to the core protocol, if applicable.
+      const coreProtocol = message.descriptor.protocol !== undefined
+        ? this.deps.coreProtocols?.get(message.descriptor.protocol)
+        : undefined;
+      if (coreProtocol?.validateRecord !== undefined) {
+        coreProtocol.validateRecord(message, dataBytes);
+      }
 
       messageWithOptionalEncodedData = await this.cloneAndAddEncodedData(message, dataBytes);
     } else {
@@ -292,13 +244,13 @@ export class RecordsWriteHandler implements MethodHandler {
         // perform storage and CID computation in parallel
         const [dataCid, DataStorePutResult] = await Promise.all([
           Cid.computeDagPbCidFromStream(dataStreamCopy1),
-          this.dataStore.put(tenant, message.recordId, message.descriptor.dataCid, dataStreamCopy2)
+          this.deps.dataStore!.put(tenant, message.recordId, message.descriptor.dataCid, dataStreamCopy2)
         ]);
 
         RecordsWriteHandler.validateDataIntegrity(message.descriptor.dataCid, message.descriptor.dataSize, dataCid, DataStorePutResult.dataSize);
       } catch (error) {
         // unwind/delete data if we have issue with storage or the data failed integrity validation
-        await this.dataStore.delete(tenant, message.recordId, message.descriptor.dataCid);
+        await this.deps.dataStore!.delete(tenant, message.recordId, message.descriptor.dataCid);
 
         throw error;
       }
@@ -335,7 +287,7 @@ export class RecordsWriteHandler implements MethodHandler {
       // else just make sure the data is in the data store
 
       // attempt to retrieve the data from the previous message
-      const DataStoreGetResult = await this.dataStore.get(tenant, newestExistingWrite.recordId, message.descriptor.dataCid);
+      const DataStoreGetResult = await this.deps.dataStore!.get(tenant, newestExistingWrite.recordId, message.descriptor.dataCid);
 
       if (DataStoreGetResult === undefined) {
         throw new DwnError(
@@ -377,7 +329,90 @@ export class RecordsWriteHandler implements MethodHandler {
     }
   }
 
-  private static async authorizeRecordsWrite(tenant: string, recordsWrite: RecordsWrite, messageStore: MessageStore): Promise<void> {
+  /**
+   * Enforces the squash backstop: if the incoming message is at a protocol path with `$squash: true`,
+   * and there exists a squash record at the same protocol path and parent context whose
+   * `messageTimestamp` is >= the incoming message's `messageTimestamp`, reject with 409.
+   *
+   * This check only applies to protocol-based records at `$squash: true` paths.
+   */
+  private async enforceSquashBackstop(tenant: string, message: RecordsWriteMessage): Promise<void> {
+    // Only applies to protocol-based records
+    if (message.descriptor.protocol === undefined || message.descriptor.protocolPath === undefined) {
+      return;
+    }
+
+    // Fetch the protocol definition to check if $squash is enabled at this path.
+    // Pass coreProtocols so that core protocols (e.g. permissions) are resolved from the registry.
+    let protocolDefinition;
+    try {
+      protocolDefinition = await ProtocolAuthorization.fetchProtocolDefinition(
+        tenant,
+        message.descriptor.protocol,
+        this.deps.messageStore,
+        undefined,
+        this.deps.coreProtocols,
+      );
+    } catch (error) {
+      // If the protocol definition can't be found, skip the backstop check.
+      // Authorization will handle the missing protocol error later.
+      console.warn(`enforceSquashBackstop: failed to fetch protocol definition for '${message.descriptor.protocol}':`, error);
+      return;
+    }
+
+    // Walk the structure to find the rule set for this protocol path
+    const pathSegments = message.descriptor.protocolPath.split('/');
+    let ruleSet = protocolDefinition.structure[pathSegments[0]];
+    for (let i = 1; i < pathSegments.length && ruleSet !== undefined; i++) {
+      ruleSet = ruleSet[pathSegments[i]] as typeof ruleSet;
+    }
+
+    if (ruleSet === undefined || ruleSet.$squash !== true) {
+      return;
+    }
+
+    // Find the most recent squash record at the same protocol path and parent context
+    const filter: Filter = {
+      interface         : DwnInterfaceName.Records,
+      method            : DwnMethodName.Write,
+      isLatestBaseState : true,
+      protocol          : message.descriptor.protocol,
+      protocolPath      : message.descriptor.protocolPath,
+      squash            : true,
+    };
+
+    // Scope by parent context for nested records
+    const parentContextId = Records.getParentContextFromOfContextId(message.contextId);
+    if (parentContextId !== undefined && parentContextId !== '') {
+      const prefixFilter = FilterUtility.constructPrefixFilterAsRangeFilter(parentContextId);
+      filter.contextId = prefixFilter;
+    }
+
+    const { messages: squashMessages } = await this.deps.messageStore.query(
+      tenant,
+      [filter],
+      { messageTimestamp: SortDirection.Descending },
+      { limit: 1 },
+    );
+
+    if (squashMessages.length === 0) {
+      return;
+    }
+
+    const newestSquash = squashMessages[0] as RecordsWriteMessage;
+
+    // Reject if the incoming message's timestamp is <= the squash record's timestamp
+    if (message.descriptor.messageTimestamp <= newestSquash.descriptor.messageTimestamp) {
+      throw new DwnError(
+        DwnErrorCode.ProtocolAuthorizationSquashBackstop,
+        `incoming message timestamp '${message.descriptor.messageTimestamp}' is not newer than ` +
+        `the most recent squash record timestamp '${newestSquash.descriptor.messageTimestamp}' ` +
+        `at protocol path '${message.descriptor.protocolPath}'.`
+      );
+    }
+  }
+
+  private async authorizeRecordsWrite(tenant: string, recordsWrite: RecordsWrite, messageStore: MessageStore): Promise<void> {
     // if owner signature is given (`owner` is not `undefined`), it must be the same as the tenant DID
     if (recordsWrite.owner !== undefined && recordsWrite.owner !== tenant) {
       throw new DwnError(
@@ -410,10 +445,8 @@ export class RecordsWriteHandler implements MethodHandler {
         permissionGrant,
         messageStore
       });
-    } else if (recordsWrite.message.descriptor.protocol !== undefined) {
-      await ProtocolAuthorization.authorizeWrite(tenant, recordsWrite, messageStore);
     } else {
-      throw new DwnError(DwnErrorCode.RecordsWriteAuthorizationFailed, 'message failed authorization');
+      await ProtocolAuthorization.authorizeWrite(tenant, recordsWrite, messageStore, this.deps.coreProtocols);
     }
   }
 }

package/src/index.ts

@@ -1,13 +1,17 @@
 // export everything that we want to be consumable
 export type { DwnConfig } from './dwn.js';
-export type { EventListener, EventStream, EventSubscription, MessageEvent, SubscriptionReply } from './types/subscriptions.js';
+export type { EventListener, EventLog, EventLogEntry, EventLogReadOptions, EventLogReadResult, EventLogSubscribeOptions, EventSubscription, MessageEvent, 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, MessageSubscriptionHandler, MessagesSubscribeMessageOptions, MessagesSyncAction, MessagesSyncDescriptor, 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, ProtocolPathEncryption, ProtocolsQueryDescriptor, ProtocolSizeDefinition, ProtocolTagsDefinition, ProtocolTagSchema, ProtocolType, ProtocolUses } from './types/protocols-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';
 export type { DataEncodedRecordsWriteMessage, RecordsCountDescriptor, RecordsCountMessage, RecordsCountReply, RecordsDeleteMessage, RecordsFilter, RecordsQueryMessage, RecordsQueryReply, RecordsQueryReplyEntry, RecordsReadMessage, RecordsReadReply, RecordsSubscribeDescriptor, RecordsSubscribeMessage, RecordsSubscribeReply, RecordSubscriptionHandler, RecordsWriteDescriptor, RecordsWriteTags, RecordsWriteTagValue, RecordsWriteMessage, RecordsWriteSignaturePayload, RecordsDeleteDescriptor, RecordsQueryDescriptor, RecordsReadDescriptor, RecordsSubscribeMessageOptions, RecordsWriteMessageOptions, InternalRecordsWriteMessage, RecordEvent, RecordsWriteTagsFilter } from './types/records-types.js';
 export type { GeneralJws, SignatureEntry } from './types/jws-types.js';
 export { authenticate } from './core/auth.js';
+export { CoreProtocolRegistry } from './core/core-protocol.js';
+export { PERMISSIONS_REVOCATION_PATH } from './core/constants.js';
+export type { CoreProtocol, CoreProtocolStores } from './core/core-protocol.js';
 export { AllowAllTenantGate } from './core/tenant-gate.js';
 export type { ActiveTenantCheckResult, TenantGate } from './core/tenant-gate.js';
 export { Cid } from './utils/cid.js';
@@ -72,7 +76,7 @@ export { Time } from './utils/time.js';
 export * from './types/permission-types.js';
 export * from './types/records-types.js';
 
-// concrete implementations of stores and event stream
+// concrete implementations of stores and event log
 export { BlockstoreLevel } from './store/blockstore-level.js';
 export type { BlockstoreLevelConfig } from './store/blockstore-level.js';
 export { DataStoreLevel } from './store/data-store-level.js';
@@ -85,8 +89,8 @@ export { MessageStoreLevel } from './store/message-store-level.js';
 export type { MessageStoreLevelConfig } from './store/message-store-level.js';
 export { ResumableTaskStoreLevel } from './store/resumable-task-store-level.js';
 export type { ResumableTaskStoreLevelConfig } from './store/resumable-task-store-level.js';
-export { EventEmitterStream } from './event-stream/event-emitter-stream.js';
-export type { EventEmitterStreamConfig } from './event-stream/event-emitter-stream.js';
+export { EventEmitterEventLog } from './event-stream/event-emitter-event-log.js';
+export type { EventEmitterEventLogConfig } from './event-stream/event-emitter-event-log.js';
 
 // Sparse Merkle Tree and StateIndex
 export type { StateIndex } from './types/state-index.js';

package/src/interfaces/messages-subscribe.ts

@@ -13,8 +13,13 @@ import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.j
 export type MessagesSubscribeOptions = {
   signer: MessageSigner;
   messageTimestamp?: string;
-  filters?: MessagesFilter[]
+  filters?: MessagesFilter[];
   permissionGrantId?: string;
+  /**
+   * Opaque EventLog cursor string to resume from. When provided, catch-up events are
+   * replayed from the EventLog and an EOSE marker is delivered before live events.
+   */
+  cursor?: string;
 };
 
 export class MessagesSubscribe extends AbstractMessage<MessagesSubscribeMessage> {
@@ -48,6 +53,7 @@ export class MessagesSubscribe extends AbstractMessage<MessagesSubscribeMessage>
       filters           : options.filters ?? [],
       messageTimestamp  : options.messageTimestamp ?? currentTime,
       permissionGrantId : options.permissionGrantId,
+      cursor            : options.cursor,
     };
 
     removeUndefinedProperties(descriptor);