@enbox/dwn-sdk-js 0.4.0 → 0.4.2

package/src/utils/record-limit-occupancy.ts

@@ -0,0 +1,377 @@
+import type { MessageStore } from '../types/message-store.js';
+import type { ProtocolRecordLimitDefinition } from '../types/protocols-types.js';
+import type { RecordsWriteMessage } from '../types/records-types.js';
+import type { ValidationStateReader } from '../types/validation-state-reader.js';
+import type { Filter, PaginationCursor } from '../types/query-types.js';
+import type { MessageSort, Pagination } from '../types/message-types.js';
+
+import { FilterUtility } from './filter.js';
+import { getRuleSetAtPath } from './protocols.js';
+import { lexicographicalCompare } from './string.js';
+import { ProtocolRecordLimitStrategy } from '../types/protocols-types.js';
+import { Records } from './records.js';
+import { SortDirection } from '../types/query-types.js';
+import { DwnError, DwnErrorCode } from '../core/dwn-error.js';
+import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.js';
+
+type RecordLimitOccupancyDependencies = {
+  messageStore: MessageStore;
+  validationStateReader: ValidationStateReader;
+};
+
+type RecordLimitOccupancyQueryInput = RecordLimitOccupancyDependencies & {
+  tenant: string;
+  filters: Filter[];
+  messageTimestamp: string;
+  messageSort?: MessageSort;
+  pagination?: Pagination;
+};
+
+type RecordLimitScope = {
+  protocol: string;
+  protocolPath: string;
+  parentContextId: string;
+};
+
+type RecordLimitFilterResolution = {
+  projectedFilters: Filter[];
+};
+
+/**
+ * Queries records with bounded `$recordLimit` occupancy projection when every limited filter targets one concrete scope.
+ *
+ * Broad filters keep the store's native query path. Projecting those without a store-level grouping primitive would require
+ * scanning the full matching set, which is worse than leaving them unprojected until a bounded broad-query strategy exists.
+ */
+export async function queryRecordsWithRecordLimitOccupancy(
+  input: RecordLimitOccupancyQueryInput
+): Promise<{ messages: RecordsWriteMessage[]; cursor?: PaginationCursor }> {
+  const filterResolution = await resolveRecordLimitFilters(input);
+  if (filterResolution === undefined) {
+    const { messages, cursor } = await input.messageStore.query(input.tenant, input.filters, input.messageSort, input.pagination);
+    return { messages: messages.filter(Records.isRecordsWrite), cursor };
+  }
+
+  if (filterResolution.projectedFilters.length === 0) {
+    return { messages: [] };
+  }
+
+  const { messages, cursor } = await input.messageStore.query(
+    input.tenant,
+    filterResolution.projectedFilters,
+    input.messageSort,
+    input.pagination
+  );
+
+  return { messages: messages.filter(Records.isRecordsWrite), cursor };
+}
+
+/**
+ * Counts records with bounded `$recordLimit` occupancy projection when every limited filter targets one concrete scope.
+ */
+export async function countRecordsWithRecordLimitOccupancy(input: Omit<RecordLimitOccupancyQueryInput, 'pagination'>): Promise<number> {
+  const filterResolution = await resolveRecordLimitFilters(input);
+  if (filterResolution === undefined) {
+    return input.messageStore.count(input.tenant, input.filters, input.messageSort);
+  }
+
+  if (filterResolution.projectedFilters.length === 0) {
+    return 0;
+  }
+
+  return input.messageStore.count(input.tenant, filterResolution.projectedFilters, input.messageSort);
+}
+
+/**
+ * Returns true when the latest RecordsWrite is visible under the `$recordLimit` projection.
+ */
+export async function isRecordLimitOccupant(input: RecordLimitOccupancyDependencies & {
+  tenant: string;
+  message: RecordsWriteMessage;
+  messageTimestamp: string;
+}): Promise<boolean> {
+  const recordLimit = await getRecordLimitForMessage({
+    messageStore           : input.messageStore,
+    validationStateReader  : input.validationStateReader,
+    tenant                 : input.tenant,
+    message                : input.message,
+    messageTimestamp       : input.messageTimestamp,
+    recordLimitDefinitions : new Map(),
+  });
+
+  if (recordLimit === undefined) {
+    return true;
+  }
+
+  const occupantRecordIds = await findOccupantRecordIds({
+    messageStore : input.messageStore,
+    tenant       : input.tenant,
+    scope        : getRecordLimitScope(input.message),
+    recordLimit,
+  });
+
+  return occupantRecordIds.has(input.message.recordId);
+}
+
+async function resolveRecordLimitFilters(
+  input: Omit<RecordLimitOccupancyQueryInput, 'pagination'>
+): Promise<RecordLimitFilterResolution | undefined> {
+  const recordLimitDefinitions = new Map<string, ProtocolRecordLimitDefinition | undefined>();
+  const projectedFilters: Filter[] = [];
+  let projectionApplied = false;
+
+  for (const filter of input.filters) {
+    const recordLimit = await getRecordLimitForFilter({
+      messageStore          : input.messageStore,
+      validationStateReader : input.validationStateReader,
+      tenant                : input.tenant,
+      filter,
+      messageTimestamp      : input.messageTimestamp,
+      recordLimitDefinitions,
+    });
+
+    if (recordLimit === undefined) {
+      projectedFilters.push(filter);
+      continue;
+    }
+
+    const scope = getRecordLimitScopeFromFilter(filter);
+    if (scope === undefined) {
+      return undefined;
+    }
+
+    const occupantRecordIds = await findOccupantRecordIds({
+      messageStore : input.messageStore,
+      tenant       : input.tenant,
+      scope,
+      recordLimit,
+    });
+
+    const projectedFilter = buildProjectedFilter(filter, occupantRecordIds);
+    if (projectedFilter !== undefined) {
+      projectedFilters.push(projectedFilter);
+    }
+    projectionApplied = true;
+  }
+
+  return projectionApplied ? { projectedFilters } : undefined;
+}
+
+async function getRecordLimitForMessage(input: RecordLimitOccupancyDependencies & {
+  tenant: string;
+  message: RecordsWriteMessage;
+  messageTimestamp: string;
+  recordLimitDefinitions: Map<string, ProtocolRecordLimitDefinition | undefined>;
+}): Promise<ProtocolRecordLimitDefinition | undefined> {
+  const { protocol, protocolPath } = input.message.descriptor;
+  if (protocol === undefined || protocolPath === undefined) {
+    return undefined;
+  }
+
+  return getRecordLimit({
+    validationStateReader  : input.validationStateReader,
+    tenant                 : input.tenant,
+    protocol,
+    protocolPath,
+    messageTimestamp       : input.messageTimestamp,
+    recordLimitDefinitions : input.recordLimitDefinitions,
+  });
+}
+
+async function getRecordLimitForFilter(input: RecordLimitOccupancyDependencies & {
+  tenant: string;
+  filter: Filter;
+  messageTimestamp: string;
+  recordLimitDefinitions: Map<string, ProtocolRecordLimitDefinition | undefined>;
+}): Promise<ProtocolRecordLimitDefinition | undefined> {
+  if (input.filter.interface !== DwnInterfaceName.Records ||
+    input.filter.method !== DwnMethodName.Write ||
+    input.filter.isLatestBaseState !== true
+  ) {
+    return undefined;
+  }
+
+  const { protocol, protocolPath } = input.filter;
+  if (typeof protocol !== 'string' || typeof protocolPath !== 'string') {
+    return undefined;
+  }
+
+  return getRecordLimit({
+    validationStateReader  : input.validationStateReader,
+    tenant                 : input.tenant,
+    protocol,
+    protocolPath,
+    messageTimestamp       : input.messageTimestamp,
+    recordLimitDefinitions : input.recordLimitDefinitions,
+  });
+}
+
+async function getRecordLimit(input: {
+  validationStateReader: ValidationStateReader;
+  tenant: string;
+  protocol: string;
+  protocolPath: string;
+  messageTimestamp: string;
+  recordLimitDefinitions: Map<string, ProtocolRecordLimitDefinition | undefined>;
+}): Promise<ProtocolRecordLimitDefinition | undefined> {
+  const key = `${input.protocol}\u0000${input.protocolPath}`;
+  if (!input.recordLimitDefinitions.has(key)) {
+    let protocolDefinition;
+    try {
+      protocolDefinition = await input.validationStateReader.fetchProtocolDefinition(
+        input.tenant,
+        input.protocol,
+        input.messageTimestamp,
+      );
+    } catch (error) {
+      if (error instanceof DwnError && error.code === DwnErrorCode.ProtocolAuthorizationProtocolNotFound) {
+        input.recordLimitDefinitions.set(key, undefined);
+        return undefined;
+      }
+      throw error;
+    }
+
+    const ruleSet = getRuleSetAtPath(input.protocolPath, protocolDefinition.structure);
+    const recordLimit = ruleSet?.$recordLimit;
+    input.recordLimitDefinitions.set(
+      key,
+      recordLimit?.strategy === ProtocolRecordLimitStrategy.Reject ? recordLimit : undefined
+    );
+  }
+
+  return input.recordLimitDefinitions.get(key);
+}
+
+async function findOccupantRecordIds(input: {
+  messageStore: MessageStore;
+  tenant: string;
+  scope: RecordLimitScope;
+  recordLimit: ProtocolRecordLimitDefinition;
+}): Promise<Set<string>> {
+  const scopeFilter = buildRecordLimitScopeFilter(input.scope);
+  const messageSort = { dateCreated: SortDirection.Ascending };
+  const { messages: firstPage } = await input.messageStore.query(
+    input.tenant,
+    [scopeFilter],
+    messageSort,
+    { limit: input.recordLimit.max }
+  );
+  const firstPageCandidates = firstPage.filter(Records.isRecordsWrite);
+  if (firstPageCandidates.length === 0) {
+    return new Set();
+  }
+
+  const boundaryDateCreated = firstPageCandidates.at(-1)!.descriptor.dateCreated;
+  const beforeBoundary = firstPageCandidates.filter(
+    (message): boolean => message.descriptor.dateCreated < boundaryDateCreated
+  );
+  let boundaryCandidates = firstPageCandidates.filter(
+    (message): boolean => message.descriptor.dateCreated === boundaryDateCreated
+  );
+
+  if (firstPageCandidates.length === input.recordLimit.max) {
+    const { messages } = await input.messageStore.query(
+      input.tenant,
+      [{ ...scopeFilter, dateCreated: boundaryDateCreated }],
+      messageSort
+    );
+    boundaryCandidates = messages.filter(Records.isRecordsWrite);
+  }
+
+  boundaryCandidates.sort(compareRecordLimitCandidates);
+
+  const rankedCandidates = [
+    ...beforeBoundary,
+    ...boundaryCandidates,
+  ];
+
+  return new Set(
+    rankedCandidates
+      .slice(0, input.recordLimit.max)
+      .map((message): string => message.recordId)
+  );
+}
+
+function buildRecordLimitScopeFilter(scope: RecordLimitScope): Filter {
+  const filter: Filter = {
+    interface         : DwnInterfaceName.Records,
+    method            : DwnMethodName.Write,
+    isLatestBaseState : true,
+    protocol          : scope.protocol,
+    protocolPath      : scope.protocolPath,
+  };
+
+  if (scope.parentContextId !== '') {
+    filter.contextId = FilterUtility.constructPrefixFilterAsRangeFilter(scope.parentContextId);
+  }
+
+  return filter;
+}
+
+function getRecordLimitScopeFromFilter(filter: Filter): RecordLimitScope | undefined {
+  const { protocol, protocolPath } = filter;
+  if (typeof protocol !== 'string' || typeof protocolPath !== 'string') {
+    return undefined;
+  }
+
+  if (!protocolPath.includes('/')) {
+    return { protocol, protocolPath, parentContextId: '' };
+  }
+
+  const parentContextId = getExactParentContextIdFromFilter(filter);
+  if (parentContextId === undefined) {
+    return undefined;
+  }
+
+  return { protocol, protocolPath, parentContextId };
+}
+
+function getRecordLimitScope(message: RecordsWriteMessage): RecordLimitScope {
+  return {
+    protocol        : message.descriptor.protocol,
+    protocolPath    : message.descriptor.protocolPath,
+    parentContextId : Records.getParentContextFromOfContextId(message.contextId) ?? '',
+  };
+}
+
+function getExactParentContextIdFromFilter(filter: Filter): string | undefined {
+  const { contextId } = filter;
+  if (contextId === undefined || !FilterUtility.isRangeFilter(contextId)) {
+    return undefined;
+  }
+
+  if (typeof contextId.gte !== 'string' || contextId.lt !== `${contextId.gte}\uffff`) {
+    return undefined;
+  }
+
+  return contextId.gte;
+}
+
+function buildProjectedFilter(filter: Filter, occupantRecordIds: Set<string>): Filter | undefined {
+  let projectedRecordIds = Array.from(occupantRecordIds);
+  const existingRecordIdFilter = filter.recordId;
+  if (typeof existingRecordIdFilter === 'string') {
+    projectedRecordIds = occupantRecordIds.has(existingRecordIdFilter) ? [existingRecordIdFilter] : [];
+  } else if (Array.isArray(existingRecordIdFilter)) {
+    projectedRecordIds = existingRecordIdFilter
+      .filter((recordId): recordId is string => typeof recordId === 'string' && occupantRecordIds.has(recordId));
+  }
+
+  if (projectedRecordIds.length === 0) {
+    return undefined;
+  }
+
+  return {
+    ...filter,
+    recordId: projectedRecordIds,
+  };
+}
+
+function compareRecordLimitCandidates(left: RecordsWriteMessage, right: RecordsWriteMessage): number {
+  const dateComparison = lexicographicalCompare(left.descriptor.dateCreated, right.descriptor.dateCreated);
+  if (dateComparison !== 0) {
+    return dateComparison;
+  }
+
+  return lexicographicalCompare(left.recordId, right.recordId);
+}

package/src/utils/records.ts

@@ -36,6 +36,26 @@ export class Records {
     return isRecordsWrite;
   }
 
+  /**
+   * Gets the newest `RecordsWrite` from the given message set.
+   */
+  public static async getNewestRecordsWrite(messages: GenericMessage[]): Promise<RecordsWriteMessage | undefined> {
+    const recordsWriteMessages = messages.filter(Records.isRecordsWrite);
+    const newestRecordsWrite = await Message.getNewestMessage(recordsWriteMessages);
+    return newestRecordsWrite as RecordsWriteMessage | undefined;
+  }
+
+  /**
+   * Gets the newest `RecordsDelete` from the given message set.
+   */
+  public static async getNewestRecordsDelete(messages: GenericMessage[]): Promise<RecordsDeleteMessage | undefined> {
+    const recordsDeleteMessages = messages.filter((message): message is RecordsDeleteMessage =>
+      message.descriptor.interface === DwnInterfaceName.Records && message.descriptor.method === DwnMethodName.Delete
+    );
+    const newestRecordsDelete = await Message.getNewestMessage(recordsDeleteMessages);
+    return newestRecordsDelete as RecordsDeleteMessage | undefined;
+  }
+
   /**
    * Decrypts the encrypted data in a message reply.
    *
@@ -285,6 +305,35 @@ export class Records {
     return filterCopy;
   }
 
+  /**
+   * Nested protocol-path queries must pin one parent context. Otherwise the same
+   * protocol type is read across every parent instance.
+   */
+  public static validateNestedProtocolPathQueryScope(
+    filter: RecordsFilter,
+    errorCode: DwnErrorCode,
+    operationName: string,
+  ): void {
+    const { contextId, protocolPath } = filter;
+    if (!protocolPath?.includes('/')) {
+      return;
+    }
+
+    const expectedParentDepth = protocolPath.split('/').length - 1;
+    const contextIdSegments = contextId?.split('/');
+    if (
+      contextIdSegments?.length === expectedParentDepth &&
+      contextIdSegments.every(segment => segment.length > 0)
+    ) {
+      return;
+    }
+
+    throw new DwnError(
+      errorCode,
+      `${operationName} for nested protocol path '${protocolPath}' must include the direct parent contextId in the filter`
+    );
+  }
+
 
   public static isStartsWithFilter(filter: RecordsWriteTagsFilter): filter is StartsWithFilter {
     return typeof filter === 'object' && ('startsWith' in filter && typeof filter.startsWith === 'string');
@@ -530,25 +579,32 @@ export class Records {
   }
 
   /**
-   * Checks if the given RecordsDelete message can be performed against a record with the given newest existing state.
+   * Checks whether the given `RecordsDelete` is beaten by an existing tombstone for the record,
+   * per the tombstone lattice. A tombstone displaces any `RecordsWrite` regardless of timestamp
+   * (delete-wins). Among competing tombstones one canonical winner stands on every replica:
+   * a prune beats a plain delete regardless of timestamp — the cascade is a side effect, and a
+   * plain-newer winner would leave replicas that ran the cascade diverged from those that never
+   * would — and within the same class the newest tombstone wins, with `Message.isNewer`'s
+   * (messageTimestamp, CID) total order picking the same winner everywhere. Admission and
+   * resumable-task replay must share this predicate: state can advance between acceptance and
+   * replay, and replay must never admit a delete that admission would now reject.
    */
-  public static canPerformDeleteAgainstRecord(deleteToBePerformed: RecordsDeleteMessage, newestExistingMessage: GenericMessage | undefined): boolean {
-    if (newestExistingMessage === undefined) {
+  public static async isDeleteBeatenByExistingTombstone(
+    deleteToBePerformed: RecordsDeleteMessage,
+    newestExistingMessage: GenericMessage
+  ): Promise<boolean> {
+    if (newestExistingMessage.descriptor.method !== DwnMethodName.Delete) {
       return false;
     }
 
-    // can't perform delete if:
-    // attempting to delete on an already deleted record; or
-    // attempting to prune on an already pruned record;
-    if (newestExistingMessage.descriptor.method === DwnMethodName.Delete) {
-      if (deleteToBePerformed.descriptor.prune !== true) {
-        return false;
-      } else if ((newestExistingMessage as RecordsDeleteMessage).descriptor.prune === true) {
-        return false;
-      }
+    const incomingIsPrune = deleteToBePerformed.descriptor.prune === true;
+    const existingIsPrune = (newestExistingMessage as RecordsDeleteMessage).descriptor.prune === true;
+    if (incomingIsPrune !== existingIsPrune) {
+      return existingIsPrune;
     }
 
-    return true;
+    const incomingDeleteIsNewest = await Message.isNewer(deleteToBePerformed, newestExistingMessage);
+    return !incomingDeleteIsNewest;
   }
 
   /**

package/src/utils/replication.ts

@@ -0,0 +1,122 @@
+import type { GenericMessage } from '../types/message-types.js';
+import type { KeyValues } from '../types/query-types.js';
+
+import { PermissionsProtocol } from '../protocols/permissions.js';
+import { DwnError, DwnErrorCode } from '../core/dwn-error.js';
+
+const POSITION_PAD_WIDTH = 20;
+
+type ReplicationMessageDescriptor = GenericMessage['descriptor'] & {
+  tags?: Record<string, unknown>;
+};
+
+/**
+ * Shared helpers for the replication log substrate.
+ */
+export class Replication {
+  public static readonly globalDomain = '';
+
+  public static protocolDomain(protocolUri: string): string {
+    return `protocol:${protocolUri}`;
+  }
+
+  public static permissionDomain(protocolUri: string): string {
+    return `perm:${protocolUri}`;
+  }
+
+  public static async deriveStreamId(tenant: string): Promise<string> {
+    const bytes = new TextEncoder().encode(tenant);
+    const hashBuffer = await crypto.subtle.digest('SHA-256', bytes);
+    const hashArray = new Uint8Array(hashBuffer);
+    return Array.from(hashArray.slice(0, 8), (b: number) => b.toString(16).padStart(2, '0')).join('');
+  }
+
+  public static computeFingerprintScopes(message: GenericMessage, indexes: KeyValues): string[] {
+    const scopes = [Replication.globalDomain];
+
+    const descriptor: ReplicationMessageDescriptor = message.descriptor;
+    const protocol = indexes.protocol;
+    if (typeof protocol === 'string') {
+      scopes.push(Replication.protocolDomain(protocol));
+
+      if (protocol === PermissionsProtocol.uri) {
+        const indexedTaggedProtocol = indexes['tag.protocol'];
+        const taggedProtocol = indexedTaggedProtocol ?? descriptor.tags?.protocol;
+        if (typeof taggedProtocol === 'string') {
+          scopes.push(Replication.permissionDomain(taggedProtocol));
+        }
+      }
+    }
+
+    return scopes;
+  }
+
+  public static assertFingerprintScopesUntouched(
+    persistedScopes: string[],
+    message: GenericMessage,
+    messageCid: string,
+    newIndexes: KeyValues,
+  ): void {
+    const expectedScopes = Replication.computeFingerprintScopes(message, newIndexes);
+    if (!Replication.scopeSetsMatch(persistedScopes, expectedScopes)) {
+      Replication.throwFingerprintScopeMutation(messageCid);
+    }
+  }
+
+  private static scopeSetsMatch(left: string[], right: string[]): boolean {
+    if (left.length !== right.length) {
+      return false;
+    }
+
+    return right.every((scope) => left.includes(scope));
+  }
+
+  private static throwFingerprintScopeMutation(messageCid: string): never {
+    throw new DwnError(
+      DwnErrorCode.MessageStoreFingerprintScopeMutation,
+      `index replacement for message ${messageCid} would change its persisted fingerprint scopes`
+    );
+  }
+
+  public static async hashMessageCid(messageCid: string): Promise<Uint8Array> {
+    const bytes = new TextEncoder().encode(messageCid);
+    const hashBuffer = await crypto.subtle.digest('SHA-256', bytes);
+    return new Uint8Array(hashBuffer);
+  }
+
+  public static emptyFingerprint(): Uint8Array {
+    return new Uint8Array(32);
+  }
+
+  public static xorFingerprint(fingerprint: Uint8Array, contribution: Uint8Array): Uint8Array {
+    const result = new Uint8Array(32);
+    for (let i = 0; i < 32; i++) {
+      result[i] = fingerprint[i] ^ contribution[i];
+    }
+    return result;
+  }
+
+  public static fingerprintToHex(fingerprint: Uint8Array): string {
+    return Array.from(fingerprint, (b: number) => b.toString(16).padStart(2, '0')).join('');
+  }
+
+  public static hexToFingerprint(hex: string): Uint8Array {
+    const bytes = new Uint8Array(32);
+    for (let i = 0; i < 32; i++) {
+      bytes[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    }
+    return bytes;
+  }
+
+  public static encodePositionKey(position: bigint): string {
+    const decimal = position.toString();
+    if (position < 0n || decimal.length > POSITION_PAD_WIDTH) {
+      throw new DwnError(
+        DwnErrorCode.MessageStoreReplicationPositionOverflow,
+        `log position ${decimal} cannot be encoded within ${POSITION_PAD_WIDTH} digits`
+      );
+    }
+
+    return decimal.padStart(POSITION_PAD_WIDTH, '0');
+  }
+}

package/dist/esm/src/core/record-chain.js

@@ -1,64 +0,0 @@
-import { RecordsWrite } from '../interfaces/records-write.js';
-import { DwnError, DwnErrorCode } from './dwn-error.js';
-import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.js';
-/**
- * Fetches the initial RecordsWrite message associated with the given (tenant + recordId).
- */
-export async function fetchInitialWrite(tenant, recordId, messageStore) {
-    const query = {
-        interface: DwnInterfaceName.Records,
-        method: DwnMethodName.Write,
-        recordId: recordId
-    };
-    const { messages } = await messageStore.query(tenant, [query]);
-    if (messages.length === 0) {
-        return undefined;
-    }
-    const initialWrite = await RecordsWrite.getInitialWrite(messages);
-    return initialWrite;
-}
-/**
- * Constructs the chain of EXISTING records in the datastore where the first record is the root initial `RecordsWrite` of the record chain
- * and last record is the initial `RecordsWrite` of the descendant record specified.
- * @param descendantRecordId The ID of the descendent record to start constructing the record chain from by repeatedly looking up the parent.
- * @returns the record chain where each record is represented by its initial `RecordsWrite`;
- *          returns empty array if `descendantRecordId` is `undefined`.
- * @throws {DwnError} if `descendantRecordId` is defined but any initial `RecordsWrite` is not found in the chain of records.
- */
-export async function constructRecordChain(tenant, descendantRecordId, messageStore) {
-    if (descendantRecordId === undefined) {
-        return [];
-    }
-    const recordChain = [];
-    // keep walking up the chain from the inbound message's parent, until there is no more parent
-    let currentRecordId = descendantRecordId;
-    while (currentRecordId !== undefined) {
-        const initialWrite = await fetchInitialWrite(tenant, currentRecordId, messageStore);
-        // RecordsWrite needed should be available since we perform necessary checks at the time of writes,
-        // eg. check the immediate parent in `verifyProtocolPathAndContextId` at the time of writing,
-        // so if this condition is triggered, it means there is an unexpected bug that caused an incomplete chain.
-        // We add additional defensive check here because returning an unexpected/incorrect record chain could lead to security vulnerabilities.
-        if (initialWrite === undefined) {
-            throw new DwnError(DwnErrorCode.ProtocolAuthorizationParentNotFoundConstructingRecordChain, `Unexpected error that should never trigger: no parent found with ID ${currentRecordId} when constructing record chain.`);
-        }
-        recordChain.push(initialWrite);
-        currentRecordId = initialWrite.descriptor.parentId;
-    }
-    return recordChain.reverse(); // root record first
-}
-/**
- * Determines the timestamp that governs which protocol definition version applies to the given RecordsWrite.
- * For an update, this is the initial write's `messageTimestamp` (the protocol version is locked at creation time).
- * For a new initial write, returns `undefined` — the latest protocol definition should be used because the
- * record is being created now and must conform to the current protocol rules.
- */
-export async function getGoverningTimestamp(tenant, incomingMessage, messageStore) {
-    const existingInitialWrite = await fetchInitialWrite(tenant, incomingMessage.message.recordId, messageStore);
-    if (existingInitialWrite !== undefined) {
-        // update case: use the initial write's timestamp
-        return existingInitialWrite.descriptor.messageTimestamp;
-    }
-    // initial write case: validate against the latest protocol definition
-    return undefined;
-}
-//# sourceMappingURL=record-chain.js.map

package/dist/esm/src/core/record-chain.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"record-chain.js","sourceRoot":"","sources":["../../../../src/core/record-chain.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAC9D,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AAEnF;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,MAAc,EACd,QAAgB,EAChB,YAA0B;IAG1B,MAAM,KAAK,GAAW;QACpB,SAAS,EAAG,gBAAgB,CAAC,OAAO;QACpC,MAAM,EAAM,aAAa,CAAC,KAAK;QAC/B,QAAQ,EAAI,QAAQ;KACrB,CAAC;IACF,MAAM,EAAE,QAAQ,EAAE,GAAG,MAAM,YAAY,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;IAE/D,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,MAAM,YAAY,GAAG,MAAM,YAAY,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;IAClE,OAAO,YAAY,CAAC;AACtB,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACxC,MAAc,EACd,kBAAsC,EACtC,YAA0B;IAG1B,IAAI,kBAAkB,KAAK,SAAS,EAAE,CAAC;QACrC,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,MAAM,WAAW,GAA0B,EAAE,CAAC;IAE9C,6FAA6F;IAC7F,IAAI,eAAe,GAAuB,kBAAkB,CAAC;IAC7D,OAAO,eAAe,KAAK,SAAS,EAAE,CAAC;QAErC,MAAM,YAAY,GAAG,MAAM,iBAAiB,CAAC,MAAM,EAAE,eAAe,EAAE,YAAY,CAAC,CAAC;QAEpF,mGAAmG;QACnG,6FAA6F;QAC7F,0GAA0G;QAC1G,wIAAwI;QACxI,IAAI,YAAY,KAAK,SAAS,EAAE,CAAC;YAC/B,MAAM,IAAI,QAAQ,CAChB,YAAY,CAAC,0DAA0D,EACvE,uEAAuE,eAAe,kCAAkC,CACzH,CAAC;QACJ,CAAC;QAED,WAAW,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAC/B,eAAe,GAAG,YAAY,CAAC,UAAU,CAAC,QAAQ,CAAC;IACrD,CAAC;IAED,OAAO,WAAW,CAAC,OAAO,EAAE,CAAC,CAAC,oBAAoB;AACpD,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,MAAc,EACd,eAA6B,EAC7B,YAA0B;IAE1B,MAAM,oBAAoB,GAAG,MAAM,iBAAiB,CAClD,MAAM,EAAE,eAAe,CAAC,OAAO,CAAC,QAAQ,EAAE,YAAY,CACvD,CAAC;IAEF,IAAI,oBAAoB,KAAK,SAAS,EAAE,CAAC;QACvC,iDAAiD;QACjD,OAAO,oBAAoB,CAAC,UAAU,CAAC,gBAAgB,CAAC;IAC1D,CAAC;IAED,sEAAsE;IACtE,OAAO,SAAS,CAAC;AACnB,CAAC"}