@recordtimelabel/core 0.6.0 → 0.6.2

package/README.md

@@ -17,10 +17,10 @@ During local development an app can consume a sibling checkout with:
 "@recordtimelabel/core": "file:../recordtimelabel-core"
 ```
 
-For release builds, consume a fixed npm package, git tag, or private registry version so builds do not depend on a sibling folder path. The current published artifact is `0.6.0`:
+For release builds, consume a fixed npm package, git tag, or private registry version so builds do not depend on a sibling folder path. The current published artifact is `0.6.2`:
 
 ```json
-"@recordtimelabel/core": "0.6.0"
+"@recordtimelabel/core": "0.6.2"
 ```
 
 If this checkout's `package.json` is ahead of the published version, publish the new package before updating consumers to that version.
@@ -36,6 +36,10 @@ If this checkout's `package.json` is ahead of the published version, publish the
 - `RTL_MAX_SYNC_DRAIN_ROUNDS`
 - `RTL_SYNC_DRAIN_RETRY_DELAY_MS`
 - `RECORD_TIMELABEL_DURABLE_ENGINE_CAPABILITIES`
+- `RECORD_TIMELABEL_CAPABILITY_CLOUD_FAILURE_STATE`
+- `RECORD_TIMELABEL_CLOUD_FAILURE_CLASSES`
+- `normalizeRecordTimeLabelCloudFailure(input)`
+- `toRecordTimeLabelCloudFailureError(input)`
 - `RECORD_TIMELABEL_PROTOCOL_CAPABILITIES`
 - `toRecordTimeLabelWireOperation(operation)`
 - `buildRecordTimeLabelRequestId(namespace, operations)`
@@ -97,6 +101,20 @@ has `load()` and `save(workspace)` methods (adapters may consume the optional se
 `save(workspace, fenceContext)` argument to enforce the session/epoch atomically), and its cloud port has `bootstrap(context, attemptOptions)`,
 `applyOperations(envelope, context)`, and `subscribe(listener, context)` methods. The session port
 provides `current()`, `subscribe(listener)`, and `isCurrent(sessionToken, uid, workspaceEpoch)`.
+`sessionToken` is an opaque fence for equality only. Core never aliases `current.id` or
+the whole session object as an authorization token, and `bootstrap`/`catchUp`/`apply`
+context no longer carries `token`. Platform adapters obtain Firebase credentials from
+their own credential provider.
+
+`normalizeRecordTimeLabelCloudFailure` preserves `status`, `reason`, `retryable`, and
+`retryAfterMs`, and assigns exactly one class: `transient`, `bootstrap-required`,
+`auth-transition-required`, `terminal`, or `stale-session`. Capability
+`cloud-failure-state-v1` advertises this contract. An `auth-transition-required`
+bootstrap or catch-up failure latches that session identity so repeated `init()`
+calls do not invoke `cloud.bootstrap` again. A changed SessionPort capture, UID, or
+workspace epoch clears the latch. `recoverBaseline` falls back from catch-up only for
+explicit `bootstrap-required` / cursor-gap outcomes; auth and transient failures keep
+their class and must not start a second full walk.
 
 The persisted workspace is versioned and contains only durable data:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@recordtimelabel/core",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "type": "module",
   "description": "Shared RecordTimeLabel data model, merge logic, operations, and sync engine.",
   "main": "./src/index.js",

package/src/changefeed.js

@@ -11,6 +11,27 @@ export const FIRESTORE_V2_BOOTSTRAP_REASONS = Object.freeze({
 const toId = (value) => String(value || '').trim();
 const toIdList = (value) => (Array.isArray(value) ? value : []).map(toId).filter(Boolean);
 
+const decodeLifecycleTombstoneId = (value) => {
+  const id = toId(value);
+  if (!id) return '';
+  try {
+    return decodeURIComponent(id);
+  } catch {
+    return id;
+  }
+};
+
+export const lifecycleTombstoneDocumentKey = (value) => {
+  const logicalId = decodeLifecycleTombstoneId(value);
+  return logicalId ? encodeURIComponent(logicalId) : '';
+};
+
+export const lifecycleTombstoneKeyAliases = (value) => {
+  const logicalId = decodeLifecycleTombstoneId(value);
+  if (!logicalId) return [];
+  return [...new Set([toId(value), logicalId, encodeURIComponent(logicalId)].filter(Boolean))];
+};
+
 const cloneDocuments = (documents = {}) => ({
   root: documents.root ? {...documents.root} : documents.root,
   records: {...(documents.records || {})},
@@ -113,13 +134,18 @@ export const applyFirestoreV2ResolvedChangeBatch = ({
       ? change.lifecycleTombstoneUpserts
       : [];
     const lifecycleDeletes = toIdList(change.deletedLifecycleTombstoneIds);
-    const lifecycleUpsertIds = lifecycleUpserts.map((entry) => toId(entry?.id)).filter(Boolean);
+    const lifecycleUpsertIds = lifecycleUpserts
+      .map((entry) => lifecycleTombstoneDocumentKey(entry?.id))
+      .filter(Boolean);
+    const lifecycleDeleteIds = lifecycleDeletes
+      .map((id) => lifecycleTombstoneDocumentKey(id))
+      .filter(Boolean);
 
     if (
       hasConflict(changedRecords, deletedRecords) ||
       hasConflict(changedFolders, deletedFolders) ||
       hasConflict(changedTrash, deletedTrash) ||
-      hasConflict(lifecycleUpsertIds, lifecycleDeletes)
+      hasConflict(lifecycleUpsertIds, lifecycleDeleteIds)
     ) {
       return fail(FIRESTORE_V2_BOOTSTRAP_REASONS.INVALID_CHANGE_CONFLICT, inputCache);
     }
@@ -161,11 +187,21 @@ export const applyFirestoreV2ResolvedChangeBatch = ({
     deletedFolders.forEach((id) => delete candidate.documents.folders[id]);
     deletedTrash.forEach((id) => delete candidate.documents.trash[id]);
     lifecycleUpserts.forEach((entry) => {
-      const id = toId(entry?.id);
-      if (id) candidate.documents.lifecycleTombstones[id] = {...entry, id};
+      const logicalId = decodeLifecycleTombstoneId(entry?.id);
+      const documentKey = lifecycleTombstoneDocumentKey(logicalId);
+      if (!documentKey) return;
+      lifecycleTombstoneKeyAliases(logicalId).forEach((alias) => {
+        delete candidate.documents.lifecycleTombstones[alias];
+      });
+      candidate.documents.lifecycleTombstones[documentKey] = {
+        ...entry,
+        id: logicalId
+      };
     });
     lifecycleDeletes.forEach((id) => {
-      delete candidate.documents.lifecycleTombstones[id];
+      lifecycleTombstoneKeyAliases(id).forEach((alias) => {
+        delete candidate.documents.lifecycleTombstones[alias];
+      });
     });
     candidate.revision = revision;
   }

package/src/domain/group-identity.js

@@ -1,4 +1,7 @@
-import {fingerprintCanonicalJson} from './hash.js';
+import {
+  createdAtForStableRecordTimeLabelOperationId,
+  fingerprintCanonicalJson
+} from './hash.js';
 import {
   DEFAULT_UNKNOWN_CHANNEL,
   DEFAULT_UNKNOWN_TITLE,
@@ -309,6 +312,26 @@ export const buildRecordTimeLabelGroupIndex = ({
     );
     addAliasTarget(aliasTargetsByGroupId, buildLegacyRecordTimeLabelGroupId(record, platform, unknownTitle), groupId);
     addAliasTarget(aliasTargetsByGroupId, buildFallbackRecordGroupId(record, platform, unknownTitle), groupId);
+    const declaredPlatform = normalizeText(record?.platform).toLowerCase();
+    if (declaredPlatform !== 'twitch' && declaredPlatform !== 'youtube') {
+      ['twitch', 'youtube'].forEach((themePlatform) => {
+        addAliasTarget(
+          aliasTargetsByGroupId,
+          buildLegacyRecordTimeLabelGroupId(record, themePlatform, unknownTitle),
+          groupId
+        );
+        addAliasTarget(
+          aliasTargetsByGroupId,
+          buildFallbackRecordGroupId(record, themePlatform, unknownTitle),
+          groupId
+        );
+        addAliasTarget(
+          aliasTargetsByGroupId,
+          buildRecordTimeLabelStandaloneGroupId(record, themePlatform, unknownTitle),
+          groupId
+        );
+      });
+    }
   });
 
   const groups = Object.values(groupsById).sort((left, right) => {
@@ -454,3 +477,17 @@ export const buildRecordTimeLabelGroupMetadata = ({
 export const buildRecordTimeLabelGroupReorderOperationId = (previousOrder = [], nextOrder = []) => (
   `group.reorder:canonical:${fingerprintCanonicalJson(normalizeIdList(previousOrder))}:${fingerprintCanonicalJson(normalizeIdList(nextOrder))}`
 );
+
+export const buildRecordTimeLabelGroupReorderOperation = ({
+  previousOrder = [],
+  nextOrder = []
+} = {}) => {
+  const groupOrder = normalizeIdList(nextOrder);
+  const id = buildRecordTimeLabelGroupReorderOperationId(previousOrder, groupOrder);
+  return {
+    id,
+    type: 'group.reorder',
+    createdAt: createdAtForStableRecordTimeLabelOperationId(id),
+    payload: {groupOrder}
+  };
+};

package/src/domain/hash.js

@@ -145,3 +145,9 @@ export const digestCanonicalJson = (value) => sha256Hex(canonicalizeJson(value))
 export const fingerprintCanonicalJson = (value, length = 16) => (
   digestCanonicalJson(value).slice(0, length)
 );
+
+export const createdAtForStableRecordTimeLabelOperationId = (operationId) => {
+  const digest = digestCanonicalJson(String(operationId || ''));
+  const value = Number.parseInt(digest.slice(0, 12), 16);
+  return Number.isSafeInteger(value) && value > 0 ? value : 1;
+};

package/src/domain/twitch-vod.js

@@ -1,4 +1,7 @@
-import {fingerprintCanonicalJson} from './hash.js';
+import {
+  createdAtForStableRecordTimeLabelOperationId,
+  fingerprintCanonicalJson
+} from './hash.js';
 import {buildRecordTimeLabelGroupIndex} from './group-identity.js';
 import {
   DEFAULT_UNKNOWN_TITLE,
@@ -197,6 +200,22 @@ export const buildRecordTimeLabelVodPatchOperationId = (recordId, patch = {}) =>
   `record.update:${normalizeId(recordId)}:vod-patch:${fingerprintCanonicalJson(patch || {})}`
 );
 
+export const buildRecordTimeLabelVodPatchOperation = ({recordId, patch = {}} = {}) => {
+  const safePatch = {...(patch || {})};
+  delete safePatch.updatedAt;
+  const id = buildRecordTimeLabelVodPatchOperationId(recordId, safePatch);
+  const createdAt = createdAtForStableRecordTimeLabelOperationId(id);
+  return {
+    id,
+    type: 'record.update',
+    createdAt,
+    payload: {
+      recordId: normalizeId(recordId),
+      patch: {...safePatch, updatedAt: createdAt}
+    }
+  };
+};
+
 export const buildKnownTwitchVodRecordPatches = ({
   records = [],
   groupIndex = null,

package/src/domain.js

@@ -10,11 +10,16 @@ export {
   buildLegacyRecordTimeLabelGroupId,
   buildRecordTimeLabelGroupIndex,
   buildRecordTimeLabelGroupMetadata,
+  buildRecordTimeLabelGroupReorderOperation,
   buildRecordTimeLabelGroupReorderOperationId,
   buildRecordTimeLabelStandaloneGroupId,
   canonicalizeRecordTimeLabelGroupView
 } from './domain/group-identity.js';
 
+export {
+  createdAtForStableRecordTimeLabelOperationId
+} from './domain/hash.js';
+
 export {
   extractTwitchVodIdFromUrl,
   extractYouTubeVideoIdFromUrl
@@ -22,6 +27,7 @@ export {
 
 export {
   buildKnownTwitchVodRecordPatches,
+  buildRecordTimeLabelVodPatchOperation,
   buildRecordTimeLabelVodPatchOperationId,
   calculateVodTitleSimilarity,
   normalizeVodTitleForMatch,

package/src/index.js

@@ -1,26 +1,34 @@
 import {
+  RECORD_TIMELABEL_CAPABILITY_CLOUD_FAILURE_STATE,
   RECORD_TIMELABEL_CAPABILITY_LIFECYCLE_GENERATION_FENCE,
   RECORD_TIMELABEL_CAPABILITY_OPERATION_CONFLICT_QUARANTINE,
   RECORD_TIMELABEL_CAPABILITY_STRICT_OPERATION_RESULTS,
+  RECORD_TIMELABEL_CLOUD_FAILURE_CLASSES,
   RECORD_TIMELABEL_OPERATION_RESULT_STATUSES,
   RECORD_TIMELABEL_PROTOCOL_CAPABILITIES,
   buildRecordTimeLabelRequestId,
   createRecordTimeLabelTransportFailureResults,
+  normalizeRecordTimeLabelCloudFailure,
   normalizeRecordTimeLabelEnvelopeResponse,
   normalizeRecordTimeLabelOperationResults,
+  toRecordTimeLabelCloudFailureError,
   toRecordTimeLabelWireOperation
 } from './protocol.js';
 
 export {
+  RECORD_TIMELABEL_CAPABILITY_CLOUD_FAILURE_STATE,
   RECORD_TIMELABEL_CAPABILITY_LIFECYCLE_GENERATION_FENCE,
   RECORD_TIMELABEL_CAPABILITY_OPERATION_CONFLICT_QUARANTINE,
   RECORD_TIMELABEL_CAPABILITY_STRICT_OPERATION_RESULTS,
+  RECORD_TIMELABEL_CLOUD_FAILURE_CLASSES,
   RECORD_TIMELABEL_OPERATION_RESULT_STATUSES,
   RECORD_TIMELABEL_PROTOCOL_CAPABILITIES,
   buildRecordTimeLabelRequestId,
   createRecordTimeLabelTransportFailureResults,
+  normalizeRecordTimeLabelCloudFailure,
   normalizeRecordTimeLabelEnvelopeResponse,
   normalizeRecordTimeLabelOperationResults,
+  toRecordTimeLabelCloudFailureError,
   toRecordTimeLabelWireOperation
 } from './protocol.js';
 
@@ -37,7 +45,9 @@ import {
 } from './snapshot-root.js';
 import {
   applyFirestoreV2ResolvedChangeBatch,
-  FIRESTORE_V2_BOOTSTRAP_REASONS
+  FIRESTORE_V2_BOOTSTRAP_REASONS,
+  lifecycleTombstoneDocumentKey,
+  lifecycleTombstoneKeyAliases
 } from './changefeed.js';
 
 export {
@@ -50,7 +60,9 @@ export {
 } from './snapshot-root.js';
 export {
   applyFirestoreV2ResolvedChangeBatch,
-  FIRESTORE_V2_BOOTSTRAP_REASONS
+  FIRESTORE_V2_BOOTSTRAP_REASONS,
+  lifecycleTombstoneDocumentKey,
+  lifecycleTombstoneKeyAliases
 } from './changefeed.js';
 
 import {
@@ -61,11 +73,14 @@ import {
   buildRecordTimeLabelChannelFolderPlan,
   buildRecordTimeLabelGroupIndex,
   buildRecordTimeLabelGroupMetadata,
+  buildRecordTimeLabelGroupReorderOperation,
   buildRecordTimeLabelGroupReorderOperationId,
   buildRecordTimeLabelStandaloneGroupId,
+  buildRecordTimeLabelVodPatchOperation,
   buildRecordTimeLabelVodPatchOperationId,
   calculateVodTitleSimilarity,
   canonicalizeRecordTimeLabelGroupView,
+  createdAtForStableRecordTimeLabelOperationId,
   collectRecordTimeLabelChannelCandidates,
   extractChannelHandleFromUrl,
   extractTwitchVodIdFromUrl,
@@ -89,11 +104,14 @@ export {
   buildRecordTimeLabelChannelFolderPlan,
   buildRecordTimeLabelGroupIndex,
   buildRecordTimeLabelGroupMetadata,
+  buildRecordTimeLabelGroupReorderOperation,
   buildRecordTimeLabelGroupReorderOperationId,
   buildRecordTimeLabelStandaloneGroupId,
+  buildRecordTimeLabelVodPatchOperation,
   buildRecordTimeLabelVodPatchOperationId,
   calculateVodTitleSimilarity,
   canonicalizeRecordTimeLabelGroupView,
+  createdAtForStableRecordTimeLabelOperationId,
   collectRecordTimeLabelChannelCandidates,
   extractChannelHandleFromUrl,
   extractTwitchVodIdFromUrl,
@@ -109,7 +127,7 @@ export {
   selectBestMatchingTwitchVod
 };
 
-export const RECORD_TIMELABEL_CORE_VERSION = '0.6.0';
+export const RECORD_TIMELABEL_CORE_VERSION = '0.6.2';
 export const RTL_SYNC_PROTOCOL_VERSION = 2;
 export const RECORD_TIMELABEL_DURABLE_ENGINE_CAPABILITIES = Object.freeze([
   'fifo-retry-fence',
@@ -118,7 +136,8 @@ export const RECORD_TIMELABEL_DURABLE_ENGINE_CAPABILITIES = Object.freeze([
   'remote-subscription-readiness',
   RECORD_TIMELABEL_CAPABILITY_OPERATION_CONFLICT_QUARANTINE,
   RECORD_TIMELABEL_CAPABILITY_STRICT_OPERATION_RESULTS,
-  RECORD_TIMELABEL_CAPABILITY_LIFECYCLE_GENERATION_FENCE
+  RECORD_TIMELABEL_CAPABILITY_LIFECYCLE_GENERATION_FENCE,
+  RECORD_TIMELABEL_CAPABILITY_CLOUD_FAILURE_STATE
 ]);
 export const RTL_MAX_OPERATIONS_PER_REQUEST = 20;
 export const RTL_MAX_SYNC_DRAIN_ROUNDS = 50;
@@ -2123,25 +2142,58 @@ const collectActiveTombstoneIds = (state = {}, kind) => {
 };
 
 const mergeLifecycleTombstoneDocuments = (current = {}, incoming = {}) => {
-  const merged = {...(current || {})};
-  Object.entries(incoming || {}).forEach(([id, tombstone]) => {
-    const existing = merged[id];
+  const merged = {};
+  const writeTombstone = (rawId, tombstone) => {
+    const documentKey = lifecycleTombstoneDocumentKey(rawId || tombstone?.id);
+    if (!documentKey || !tombstone) return;
+    const logicalId = decodeURIComponent(documentKey);
+    lifecycleTombstoneKeyAliases(logicalId).forEach((alias) => {
+      delete merged[alias];
+    });
+    const existing = merged[documentKey];
+    const nextTombstone = {...tombstone, id: logicalId};
     if (!existing) {
-      merged[id] = tombstone;
+      merged[documentKey] = nextTombstone;
       return;
     }
     const currentGeneration = Number(existing.lifecycleGeneration || 0);
-    const nextGeneration = Number(tombstone?.lifecycleGeneration || 0);
+    const nextGeneration = Number(nextTombstone.lifecycleGeneration || 0);
     const currentDeletedAt = Number(existing.deletedAt || 0);
-    const nextDeletedAt = Number(tombstone?.deletedAt || 0);
+    const nextDeletedAt = Number(nextTombstone.deletedAt || 0);
     if (nextGeneration > currentGeneration ||
       (nextGeneration === currentGeneration && nextDeletedAt >= currentDeletedAt)) {
-      merged[id] = tombstone;
+      merged[documentKey] = nextTombstone;
+    } else {
+      merged[documentKey] = existing;
     }
-  });
+  };
+  Object.entries(current || {}).forEach(([id, tombstone]) => writeTombstone(id, tombstone));
+  Object.entries(incoming || {}).forEach(([id, tombstone]) => writeTombstone(id, tombstone));
   return merged;
 };
 
+const pickNewerLifecycleEntity = (left, right, getTime) => {
+  if (!left) return right;
+  if (!right) return left;
+  const leftGeneration = Number(left.lifecycleGeneration || 0);
+  const rightGeneration = Number(right.lifecycleGeneration || 0);
+  if (leftGeneration !== rightGeneration) {
+    return rightGeneration > leftGeneration ? right : left;
+  }
+  return getTime(right) >= getTime(left) ? right : left;
+};
+
+const tombstoneBlocksEntity = (tombstone, entity, getTime) => {
+  if (!isActiveLifecycleTombstone(tombstone)) return false;
+  if (!entity) return true;
+  const tombstoneGeneration = Number(tombstone.lifecycleGeneration || 0);
+  const entityGeneration = Number(entity.lifecycleGeneration || 0);
+  if (entityGeneration !== tombstoneGeneration) {
+    return tombstoneGeneration > entityGeneration;
+  }
+  return toFiniteTimestamp(tombstone.deletedAt) >= getTime(entity);
+};
+
 const collectDocumentIdChanges = (currentDocs = {}, nextDocs = {}) => {
   const currentIds = new Set(Object.keys(currentDocs || {}));
   const nextIds = new Set(Object.keys(nextDocs || {}));
@@ -2164,45 +2216,92 @@ export const applyRecordTimeLabelSnapshot = (
   const incoming = normalizeState(incomingState || {});
   const currentDocs = buildFirestoreV2DocumentsFromState(current);
   const incomingDocs = buildFirestoreV2DocumentsFromState(incoming);
-  const blockedRecordIds = collectActiveTombstoneIds(current, 'records');
-  const blockedFolderIds = collectActiveTombstoneIds(current, 'folders');
-
-  const mergedRecordDocs = {...(currentDocs.records || {})};
-  Object.entries(incomingDocs.records || {}).forEach(([id, data]) => {
-    if (blockedRecordIds.has(id)) return;
-    mergedRecordDocs[id] = data;
-  });
-  const recordDocs = isMerge
-    ? mergedRecordDocs
-    : Object.fromEntries(Object.entries(mergedRecordDocs).filter(([id]) => (
-      incomingDocs.records?.[id] && !blockedRecordIds.has(id)
-    )));
-
-  const mergedFolderDocs = {...(currentDocs.folders || {})};
-  Object.entries(incomingDocs.folders || {}).forEach(([id, data]) => {
-    if (blockedFolderIds.has(id)) return;
-    mergedFolderDocs[id] = data;
-  });
-  const folderDocs = isMerge
-    ? mergedFolderDocs
-    : Object.fromEntries(Object.entries(mergedFolderDocs).filter(([id]) => (
-      incomingDocs.folders?.[id] && !blockedFolderIds.has(id)
-    )));
-
-  const nextRoot = buildFirestoreV2SnapshotRoot({
-    currentRoot: currentDocs.root || {},
-    incomingRoot: incomingDocs.root || {},
-    mode: snapshotMode
+  const mergedTombstoneDocs = mergeLifecycleTombstoneDocuments(
+    currentDocs.lifecycleTombstones,
+    incomingDocs.lifecycleTombstones
+  );
+  const splitTombstones = splitLifecycleTombstoneDocuments(mergedTombstoneDocs);
+  const mergedRecordTombstones = mergeLifecycleTombstoneSources(
+    current.deletedRecordTombstones,
+    mergeLifecycleTombstoneSources(incoming.deletedRecordTombstones, splitTombstones.records)
+  );
+  const mergedFolderTombstones = mergeLifecycleTombstoneSources(
+    current.deletedFolderTombstones,
+    mergeLifecycleTombstoneSources(incoming.deletedFolderTombstones, splitTombstones.folders)
+  );
+  const remainingTombstones = dropSupersededLifecycleDeletions({
+    deletedRecordTombstones: mergedRecordTombstones,
+    deletedFolderTombstones: mergedFolderTombstones,
+    trashEntries: {},
+    activeGenerations: collectActiveLifecycleStates(
+      ...(isMerge ? [current, incoming] : [incoming])
+    )
   });
+
+  const selectRecordDocs = (currentRecordDocs, incomingRecordDocs) => {
+    const sourceIds = isMerge
+      ? new Set([...Object.keys(currentRecordDocs || {}), ...Object.keys(incomingRecordDocs || {})])
+      : new Set(Object.keys(incomingRecordDocs || {}));
+    const nextDocs = {};
+    sourceIds.forEach((id) => {
+      const entity = isMerge
+        ? pickNewerLifecycleEntity(currentRecordDocs?.[id], incomingRecordDocs?.[id], getRecordTime)
+        : incomingRecordDocs?.[id];
+      if (!entity || tombstoneBlocksEntity(remainingTombstones.deletedRecordTombstones[id], entity, getRecordTime)) {
+        return;
+      }
+      nextDocs[id] = entity;
+    });
+    return nextDocs;
+  };
+  const selectFolderDocs = (currentFolderDocs, incomingFolderDocs) => {
+    const sourceIds = isMerge
+      ? new Set([...Object.keys(currentFolderDocs || {}), ...Object.keys(incomingFolderDocs || {})])
+      : new Set(Object.keys(incomingFolderDocs || {}));
+    const nextDocs = {};
+    sourceIds.forEach((id) => {
+      const entity = isMerge
+        ? pickNewerLifecycleEntity(currentFolderDocs?.[id], incomingFolderDocs?.[id], getFolderTime)
+        : incomingFolderDocs?.[id];
+      if (!entity || tombstoneBlocksEntity(remainingTombstones.deletedFolderTombstones[id], entity, getFolderTime)) {
+        return;
+      }
+      nextDocs[id] = entity;
+    });
+    return nextDocs;
+  };
+
+  const recordDocs = selectRecordDocs(currentDocs.records, incomingDocs.records);
+  const folderDocs = selectFolderDocs(currentDocs.folders, incomingDocs.folders);
+  const blockedRecordIds = new Set(
+    Object.keys(remainingTombstones.deletedRecordTombstones || {}).filter((id) => (
+      isActiveLifecycleTombstone(remainingTombstones.deletedRecordTombstones[id]) && !recordDocs[id]
+    ))
+  );
+  const blockedFolderIds = new Set(
+    Object.keys(remainingTombstones.deletedFolderTombstones || {}).filter((id) => (
+      isActiveLifecycleTombstone(remainingTombstones.deletedFolderTombstones[id]) && !folderDocs[id]
+    ))
+  );
+
+  const nextRoot = {
+    ...buildFirestoreV2SnapshotRoot({
+      currentRoot: currentDocs.root || {},
+      incomingRoot: incomingDocs.root || {},
+      mode: snapshotMode
+    }),
+    deletedRecordTombstones: remainingTombstones.deletedRecordTombstones,
+    deletedFolderTombstones: remainingTombstones.deletedFolderTombstones
+  };
   const {state} = buildStateFromFirestoreV2Documents({
     root: {id: 'main', ...nextRoot},
     records: recordDocs,
     folders: folderDocs,
     trash: {...(currentDocs.trash || {})},
     ops: {},
-    lifecycleTombstones: mergeLifecycleTombstoneDocuments(
-      currentDocs.lifecycleTombstones,
-      incomingDocs.lifecycleTombstones
+    lifecycleTombstones: buildV2LifecycleTombstoneDocuments(
+      remainingTombstones.deletedRecordTombstones,
+      remainingTombstones.deletedFolderTombstones
     )
   });
   const nextDocs = buildFirestoreV2DocumentsFromState(state);
@@ -3264,12 +3363,12 @@ const rtlExtractSession = (session, fallbackEpoch = 0) => {
   } catch {
     current = null;
   }
-  // A session port is intentionally small and adapters use both token and
-  // sessionToken spellings.  Preserve the original token (including objects)
-  // for isCurrent, but never put it in a workspace blob.
-  const token = current && typeof current === 'object'
-    ? (current.sessionToken ?? current.token ?? current.id ?? current)
-    : current;
+  // SessionPort.sessionToken is an opaque fence for equality only. Never treat
+  // current.id or the whole session object as an authorization credential.
+  const sessionToken = current && typeof current === 'object' &&
+    Object.prototype.hasOwnProperty.call(current, 'sessionToken')
+    ? current.sessionToken
+    : null;
   const uid = rtlNormalizeUid(current && typeof current === 'object'
     ? (current.uid ?? current.ownerUid)
     : null);
@@ -3280,8 +3379,7 @@ const rtlExtractSession = (session, fallbackEpoch = 0) => {
   return {
     current,
     hasSession: typeof session?.current === 'function',
-    token,
-    sessionToken: token,
+    sessionToken,
     uid,
     workspaceEpoch: hasEpoch
       ? rtlNormalizeWorkspaceEpoch(rawEpoch, fallbackEpoch)
@@ -3290,9 +3388,16 @@ const rtlExtractSession = (session, fallbackEpoch = 0) => {
   };
 };
 
+const rtlSameSessionIdentity = (left, right) => (
+  Boolean(left) &&
+  Boolean(right) &&
+  left.uid === right.uid &&
+  Number(left.workspaceEpoch) === Number(right.workspaceEpoch) &&
+  Object.is(left.sessionToken, right.sessionToken)
+);
+
 const rtlSessionContext = (captured, workspace, client) => ({
   sessionToken: captured?.sessionToken ?? null,
-  token: captured?.token ?? null,
   uid: captured?.uid ?? (captured?.hasSession ? null : workspace?.ownerUid ?? null),
   ownerUid: captured?.uid ?? (captured?.hasSession ? null : workspace?.ownerUid ?? null),
   workspaceEpoch: workspace?.workspaceEpoch ?? captured?.workspaceEpoch ?? 0,
@@ -3426,6 +3531,7 @@ export const createRecordTimeLabelSyncEngine = ({
     })
   };
   let bootstrapAttemptSequence = 0;
+  let authTransitionLatch = null;
   const listeners = new Set();
   let queue = Promise.resolve();
 
@@ -3478,7 +3584,11 @@ export const createRecordTimeLabelSyncEngine = ({
     }
     if (typeof session?.current !== 'function') return true;
     const current = rtlExtractSession(session, captured.workspaceEpoch);
-    if (captured.token !== undefined && captured.token !== null && current.token !== captured.token) return false;
+    if (
+      captured.sessionToken !== undefined &&
+      captured.sessionToken !== null &&
+      !Object.is(current.sessionToken, captured.sessionToken)
+    ) return false;
     if (captured.uid !== current.uid) return false;
     return !captured.hasEpoch || current.workspaceEpoch === captured.workspaceEpoch;
   };
@@ -3528,21 +3638,75 @@ export const createRecordTimeLabelSyncEngine = ({
 
   const normalizeBootstrapResponse = (response) => {
     if (!rtlEnvelopeSuccess(response)) {
-      const error = new Error(response?.error?.message || response?.message || 'recordtimelabel_bootstrap_failed');
-      error.code = response?.error?.code || response?.code || 'recordtimelabel_bootstrap_failed';
-      throw error;
+      throw toRecordTimeLabelCloudFailureError({
+        ...((response && typeof response === 'object') ? response : {}),
+        message: response?.error?.message || response?.message || 'recordtimelabel_bootstrap_failed',
+        code: response?.error?.code || response?.code || 'recordtimelabel_bootstrap_failed',
+        reason: response?.error?.reason || response?.reason ||
+          response?.error?.code || response?.code || 'recordtimelabel_bootstrap_failed'
+      });
     }
     const remote = rtlEnvelopePayload(response);
     const revision = Number(remote?.revision);
     const state = remote?.state ?? remote?.data;
     if (!remote || !rtlDurableIsObject(state) || !Number.isFinite(revision) || revision < 0) {
-      const error = new Error('recordtimelabel_invalid_bootstrap_response');
-      error.code = 'recordtimelabel_invalid_bootstrap_response';
-      throw error;
+      throw toRecordTimeLabelCloudFailureError({
+        code: 'recordtimelabel_invalid_bootstrap_response',
+        reason: 'recordtimelabel_invalid_bootstrap_response',
+        message: 'recordtimelabel_invalid_bootstrap_response',
+        retryable: false
+      });
     }
     return {state, revision, changeCursor: remote.changeCursor ?? null};
   };
 
+  const clearAuthTransitionLatchIfSessionChanged = (captured) => {
+    if (!authTransitionLatch) return;
+    if (!rtlSameSessionIdentity(authTransitionLatch, captured)) {
+      authTransitionLatch = null;
+    }
+  };
+
+  const throwIfAuthTransitionLatched = (captured) => {
+    clearAuthTransitionLatchIfSessionChanged(captured);
+    if (!authTransitionLatch) return;
+    throw toRecordTimeLabelCloudFailureError(authTransitionLatch.failure);
+  };
+
+  const rememberAuthTransitionFailure = (captured, failure) => {
+    if (failure?.class !== RECORD_TIMELABEL_CLOUD_FAILURE_CLASSES.AUTH_TRANSITION_REQUIRED) {
+      return;
+    }
+    authTransitionLatch = {
+      uid: captured?.uid ?? null,
+      sessionToken: captured?.sessionToken ?? null,
+      workspaceEpoch: captured?.workspaceEpoch ?? 0,
+      failure: {
+        class: failure.class,
+        status: failure.status ?? null,
+        reason: failure.reason ?? failure.code ?? 'auth-transition-required',
+        code: failure.code ?? failure.reason ?? 'auth-transition-required',
+        message: failure.message || failure.reason || failure.code || 'auth-transition-required',
+        retryable: false,
+        retryAfterMs: null,
+        bootstrapRequired: false
+      }
+    };
+  };
+
+  const capturedFromContext = (context) => ({
+    uid: context?.uid ?? null,
+    sessionToken: context?.sessionToken ?? null,
+    workspaceEpoch: context?.workspaceEpoch ?? 0
+  });
+
+  const rethrowClassifiedCloudFailure = (captured, error) => {
+    const failure = normalizeRecordTimeLabelCloudFailure(error);
+    rememberAuthTransitionFailure(captured, failure);
+    if (error?.class === failure.class) throw error;
+    throw toRecordTimeLabelCloudFailureError(failure);
+  };
+
   const requireBootstrapRevision = (baseline, minimumRevision) => {
     const minimum = Number(minimumRevision);
     if (Number.isFinite(minimum) && Number(baseline?.revision) < minimum) {
@@ -3561,10 +3725,13 @@ export const createRecordTimeLabelSyncEngine = ({
   // normalizeBootstrapResponse accepts) or `{success: false,
   // bootstrapRequired: true}`; it may throw on transport errors.  Gap
   // recovery prefers it over `cloud.bootstrap` and falls back to a fresh
-  // bootstrap walk on transport/protocol failure. A successful but stale
-  // catch-up response is fail-closed: falling back would hide a revision
-  // contract violation and could apply a baseline older than the ACK.
+  // bootstrap walk only for explicit bootstrap-required / cursor-gap
+  // outcomes. Auth and transient failures keep their class and must not
+  // start a second full walk. A successful but stale catch-up response is
+  // fail-closed: falling back would hide a revision contract violation.
   const recoverBaseline = async (context, targetRevision, mode) => {
+    const captured = capturedFromContext(context);
+    throwIfAuthTransitionLatched(captured);
     if (typeof cloud?.catchUp === 'function') {
       try {
         const caught = await cloud.catchUp(context, {
@@ -3575,20 +3742,35 @@ export const createRecordTimeLabelSyncEngine = ({
         if (rtlEnvelopeSuccess(caught)) {
           return requireBootstrapRevision(normalizeBootstrapResponse(caught), targetRevision);
         }
+        const failure = normalizeRecordTimeLabelCloudFailure(caught);
+        if (failure.class !== RECORD_TIMELABEL_CLOUD_FAILURE_CLASSES.BOOTSTRAP_REQUIRED) {
+          rethrowClassifiedCloudFailure(captured, failure);
+        }
       } catch (error) {
         if (error?.code === 'recordtimelabel_bootstrap_revision_behind_required') {
           throw error;
         }
-        logger?.warn?.('[RecordTimeLabelCore] catch-up failed, falling back to bootstrap', error);
+        if (error?.class === RECORD_TIMELABEL_CLOUD_FAILURE_CLASSES.BOOTSTRAP_REQUIRED ||
+            normalizeRecordTimeLabelCloudFailure(error).class ===
+              RECORD_TIMELABEL_CLOUD_FAILURE_CLASSES.BOOTSTRAP_REQUIRED) {
+          // Explicit gap recovery only.
+        } else {
+          rethrowClassifiedCloudFailure(captured, error);
+        }
       }
     }
-    return requireBootstrapRevision(
-      normalizeBootstrapResponse(await cloud.bootstrap(
-        context,
-        bootstrapAttemptOptions(mode)
-      )),
-      targetRevision
-    );
+    throwIfAuthTransitionLatched(captured);
+    try {
+      return requireBootstrapRevision(
+        normalizeBootstrapResponse(await cloud.bootstrap(
+          context,
+          bootstrapAttemptOptions(mode)
+        )),
+        targetRevision
+      );
+    } catch (error) {
+      rethrowClassifiedCloudFailure(captured, error);
+    }
   };
 
   const normalizeLoadedWorkspace = (loaded, captured) => {
@@ -3922,6 +4104,7 @@ export const createRecordTimeLabelSyncEngine = ({
 
   const initialize = async () => {
     const captured = capture();
+    throwIfAuthTransitionLatched(captured);
     const loaded = await storage.load();
     if (!(await isCurrent(captured))) return getSnapshot();
     // Read the raw owner and baseline before normalizeLoadedWorkspace adopts
@@ -3960,7 +4143,7 @@ export const createRecordTimeLabelSyncEngine = ({
         ));
       } catch (error) {
         if (!(await isCurrent(captured))) return getSnapshot();
-        throw error;
+        rethrowClassifiedCloudFailure(captured, error);
       }
       if (!(await isCurrent(captured))) return getSnapshot();
       applyRemoteBaseline(candidate, bootstrap);
@@ -3978,6 +4161,7 @@ export const createRecordTimeLabelSyncEngine = ({
         if (destroyed) return;
         enqueue(async () => {
           const current = capture();
+          clearAuthTransitionLatchIfSessionChanged(current);
           const sameIdentity = current.uid === workspace.ownerUid &&
             Number(current.workspaceEpoch) === Number(workspace.workspaceEpoch);
           if (sameIdentity) {
@@ -4330,7 +4514,7 @@ export const createRecordTimeLabelSyncEngine = ({
         );
       } catch (error) {
         if (!(await isCurrent(captured))) return {success: false, reason: 'stale_session'};
-        throw error;
+        rethrowClassifiedCloudFailure(captured, error);
       }
       if (!(await isCurrent(captured))) return {success: false, reason: 'stale_session'};
       applyRemoteBaseline(candidate, freshBaseline);
@@ -5547,10 +5731,40 @@ export default {
   RECORD_TIMELABEL_CORE_VERSION,
   RECORD_GROUP_IDENTITY_VERSION,
   RECORD_TIMELABEL_DOMAIN_CAPABILITIES,
+  buildLegacyRecordTimeLabelGroupId,
+  buildRecordTimeLabelGroupIndex,
+  buildRecordTimeLabelGroupMetadata,
+  buildRecordTimeLabelGroupReorderOperation,
+  buildRecordTimeLabelGroupReorderOperationId,
+  buildRecordTimeLabelStandaloneGroupId,
+  canonicalizeRecordTimeLabelGroupView,
+  extractTwitchVodIdFromUrl,
+  extractYouTubeVideoIdFromUrl,
+  buildKnownTwitchVodRecordPatches,
+  buildRecordTimeLabelVodPatchOperation,
+  buildRecordTimeLabelVodPatchOperationId,
+  calculateVodTitleSimilarity,
+  normalizeVodTitleForMatch,
+  scoreTwitchVodCandidate,
+  selectBestMatchingTwitchVod,
+  normalizeLegacyRecordTimeLabelImport,
+  remapLegacyRecordTimeLabelFolderAliases,
+  buildRecordTimeLabelChannelFolderPlan,
+  collectRecordTimeLabelChannelCandidates,
+  createdAtForStableRecordTimeLabelOperationId,
+  extractChannelHandleFromUrl,
+  findBestRecordTimeLabelChannelFolder,
+  getChannelMatchKey,
+  isPendingChannelFolderId,
+  isValidChannelName,
   RECORD_TIMELABEL_DURABLE_ENGINE_CAPABILITIES,
+  RECORD_TIMELABEL_CAPABILITY_CLOUD_FAILURE_STATE,
   RECORD_TIMELABEL_CAPABILITY_LIFECYCLE_GENERATION_FENCE,
   RECORD_TIMELABEL_CAPABILITY_OPERATION_CONFLICT_QUARANTINE,
   RECORD_TIMELABEL_CAPABILITY_STRICT_OPERATION_RESULTS,
+  RECORD_TIMELABEL_CLOUD_FAILURE_CLASSES,
+  normalizeRecordTimeLabelCloudFailure,
+  toRecordTimeLabelCloudFailureError,
   RECORD_TIMELABEL_OPERATION_RESULT_STATUSES,
   RECORD_TIMELABEL_PROTOCOL_CAPABILITIES,
   RTL_SYNC_PROTOCOL_VERSION,

package/src/protocol.js

@@ -23,6 +23,237 @@ export const RECORD_TIMELABEL_PROTOCOL_CAPABILITIES = Object.freeze([
   RECORD_TIMELABEL_CAPABILITY_LIFECYCLE_GENERATION_FENCE
 ]);
 
+export const RECORD_TIMELABEL_CLOUD_FAILURE_CLASSES = Object.freeze({
+  TRANSIENT: 'transient',
+  BOOTSTRAP_REQUIRED: 'bootstrap-required',
+  AUTH_TRANSITION_REQUIRED: 'auth-transition-required',
+  TERMINAL: 'terminal',
+  STALE_SESSION: 'stale-session'
+});
+
+export const RECORD_TIMELABEL_CAPABILITY_CLOUD_FAILURE_STATE = 'cloud-failure-state-v1';
+
+const CLOUD_FAILURE_CLASS_VALUES = new Set(Object.values(RECORD_TIMELABEL_CLOUD_FAILURE_CLASSES));
+
+const AUTH_TRANSITION_CODES = new Set([
+  'auth-transition-required',
+  'auth_transition_required',
+  'malformed_id_token',
+  'invalid_id_token',
+  'unauthenticated',
+  'expired_id_token',
+  'id_token_expired',
+  'token_expired',
+  'token_project_mismatch',
+  'token_user_mismatch',
+  'token_not_yet_valid',
+  'missing_token',
+  'missing_uid',
+  'token_refresh_failed',
+  'token_refresh_required'
+]);
+
+const BOOTSTRAP_REQUIRED_CODES = new Set([
+  'bootstrap-required',
+  'bootstrap_required',
+  'bootstraprequired',
+  'expired_bootstrap_cursor',
+  'invalid_bootstrap_cursor',
+  'revision_gap',
+  'recordtimelabel_bootstrap_required'
+]);
+
+const STALE_SESSION_CODES = new Set([
+  'stale-session',
+  'stale_session',
+  'recordtimelabel_stale_session',
+  'auth_context_changed'
+]);
+
+const TERMINAL_CONFLICT_CODES = new Set([
+  'operation_id_conflict',
+  'operation_request_invalid_ids',
+  'operation_result_count_mismatch',
+  'operation_result_incomplete',
+  'operation_result_duplicate_id',
+  'operation_result_unknown_id',
+  'operation_result_missing_id',
+  'operation_result_ambiguous_id'
+]);
+
+const pickFailureText = (...values) => {
+  for (const value of values) {
+    if (typeof value === 'string' && value.trim()) return value.trim();
+  }
+  return null;
+};
+
+const unwrapFailureSource = (input) => {
+  if (input == null) return {};
+  if (typeof input === 'string') return {message: input, reason: input, code: input};
+  if (typeof input !== 'object') return {message: String(input)};
+  const nested = input.error && typeof input.error === 'object' ? input.error : null;
+  return nested ? {...nested, ...input, error: nested} : input;
+};
+
+const normalizeFailureClass = (value) => (
+  CLOUD_FAILURE_CLASS_VALUES.has(value) ? value : null
+);
+
+const normalizeFailureRetryAfterMs = (value) => {
+  if (value === null || value === undefined || value === '') return null;
+  const retryAfterMs = Number(value);
+  return Number.isFinite(retryAfterMs) && retryAfterMs >= 0 ? retryAfterMs : null;
+};
+
+const collectFailureTokens = (source) => [
+  source.class,
+  source.failureClass,
+  source.cloudFailureClass,
+  source.code,
+  source.reason,
+  source.name,
+  source.message,
+  source.error,
+  source.error?.code,
+  source.error?.reason,
+  source.error?.message,
+  source.error?.name
+].flatMap((value) => {
+  if (typeof value !== 'string') return [];
+  return value.toLowerCase().split(/[^a-z0-9_-]+/).filter(Boolean);
+});
+
+const looksLikeNetworkFailure = (source, tokens) => {
+  const blob = [
+    source.name,
+    source.code,
+    source.reason,
+    source.message,
+    source.error?.name,
+    source.error?.code,
+    source.error?.reason,
+    source.error?.message
+  ].filter(Boolean).join(' ').toLowerCase();
+  return Boolean(
+    tokens.includes('retryable') ||
+    tokens.includes('unavailable') ||
+    tokens.includes('temporarily_unavailable') ||
+    tokens.includes('bulk_job_in_progress') ||
+    tokens.includes('deadline_exceeded') ||
+    tokens.includes('network_error') ||
+    tokens.includes('err_network') ||
+    tokens.includes('econnreset') ||
+    tokens.includes('etimedout') ||
+    blob.includes('failed to fetch') ||
+    blob.includes('fetch failed') ||
+    blob.includes('network-request-failed') ||
+    blob.includes('network request failed')
+  );
+};
+
+const classifyRecordTimeLabelCloudFailure = (source, status, tokens) => {
+  const explicitClass = normalizeFailureClass(
+    source.class ?? source.failureClass ?? source.cloudFailureClass
+  );
+  if (explicitClass) return explicitClass;
+  if (
+    source.stale === true ||
+    tokens.some((token) => STALE_SESSION_CODES.has(token) || token === 'stale-session')
+  ) {
+    return RECORD_TIMELABEL_CLOUD_FAILURE_CLASSES.STALE_SESSION;
+  }
+  if (
+    status === 401 ||
+    tokens.some((token) => AUTH_TRANSITION_CODES.has(token))
+  ) {
+    return RECORD_TIMELABEL_CLOUD_FAILURE_CLASSES.AUTH_TRANSITION_REQUIRED;
+  }
+  if (
+    source.bootstrapRequired === true ||
+    source.bootstrap_required === true ||
+    tokens.some((token) => BOOTSTRAP_REQUIRED_CODES.has(token))
+  ) {
+    return RECORD_TIMELABEL_CLOUD_FAILURE_CLASSES.BOOTSTRAP_REQUIRED;
+  }
+  if (tokens.some((token) => TERMINAL_CONFLICT_CODES.has(token))) {
+    return RECORD_TIMELABEL_CLOUD_FAILURE_CLASSES.TERMINAL;
+  }
+  const retryable = source.retryable === true || source.error?.retryable === true;
+  if (
+    status === 408 ||
+    status === 425 ||
+    status === 429 ||
+    status === 409 ||
+    (Number.isFinite(status) && status >= 500) ||
+    retryable ||
+    looksLikeNetworkFailure(source, tokens)
+  ) {
+    return RECORD_TIMELABEL_CLOUD_FAILURE_CLASSES.TRANSIENT;
+  }
+  return RECORD_TIMELABEL_CLOUD_FAILURE_CLASSES.TERMINAL;
+};
+
+/**
+ * Classify a cloud/bootstrap/catch-up failure without inspecting JWT structure
+ * or Firebase SDKs. Adapters may pass Firebase codes as opaque reason/code
+ * strings; this helper only preserves metadata and assigns one class.
+ */
+export const normalizeRecordTimeLabelCloudFailure = (input = {}) => {
+  const source = unwrapFailureSource(input);
+  const statusValue = Number(source.status ?? source.statusCode ?? source.error?.status);
+  const status = Number.isFinite(statusValue) ? statusValue : null;
+  const tokens = collectFailureTokens(source);
+  const failureClass = classifyRecordTimeLabelCloudFailure(source, status, tokens);
+  const reason = pickFailureText(
+    source.reason,
+    source.error?.reason,
+    source.code,
+    source.error?.code,
+    source.message,
+    source.error?.message
+  );
+  const code = pickFailureText(
+    source.code,
+    source.error?.code,
+    reason,
+    'recordtimelabel_cloud_failure'
+  );
+  const message = pickFailureText(
+    source.message,
+    source.error?.message,
+    reason,
+    code,
+    'recordtimelabel_cloud_failure'
+  );
+  const retryAfterMs = failureClass === RECORD_TIMELABEL_CLOUD_FAILURE_CLASSES.TRANSIENT
+    ? normalizeFailureRetryAfterMs(source.retryAfterMs ?? source.error?.retryAfterMs)
+    : null;
+  return {
+    class: failureClass,
+    status,
+    reason,
+    code,
+    message,
+    retryable: failureClass === RECORD_TIMELABEL_CLOUD_FAILURE_CLASSES.TRANSIENT,
+    retryAfterMs,
+    bootstrapRequired: failureClass === RECORD_TIMELABEL_CLOUD_FAILURE_CLASSES.BOOTSTRAP_REQUIRED
+  };
+};
+
+export const toRecordTimeLabelCloudFailureError = (input = {}) => {
+  const failure = normalizeRecordTimeLabelCloudFailure(input);
+  const error = new Error(failure.message);
+  error.class = failure.class;
+  error.code = failure.code;
+  error.reason = failure.reason;
+  error.status = failure.status;
+  error.retryable = failure.retryable;
+  error.retryAfterMs = failure.retryAfterMs;
+  error.bootstrapRequired = failure.bootstrapRequired;
+  return error;
+};
+
 const ALLOWED_OPERATION_RESULT_STATUSES = new Set(
   Object.values(RECORD_TIMELABEL_OPERATION_RESULT_STATUSES)
 );
@@ -269,10 +500,14 @@ export default {
   RECORD_TIMELABEL_CAPABILITY_OPERATION_CONFLICT_QUARANTINE,
   RECORD_TIMELABEL_CAPABILITY_STRICT_OPERATION_RESULTS,
   RECORD_TIMELABEL_CAPABILITY_LIFECYCLE_GENERATION_FENCE,
+  RECORD_TIMELABEL_CAPABILITY_CLOUD_FAILURE_STATE,
+  RECORD_TIMELABEL_CLOUD_FAILURE_CLASSES,
   RECORD_TIMELABEL_PROTOCOL_CAPABILITIES,
   toRecordTimeLabelWireOperation,
   buildRecordTimeLabelRequestId,
   createRecordTimeLabelTransportFailureResults,
   normalizeRecordTimeLabelOperationResults,
-  normalizeRecordTimeLabelEnvelopeResponse
+  normalizeRecordTimeLabelEnvelopeResponse,
+  normalizeRecordTimeLabelCloudFailure,
+  toRecordTimeLabelCloudFailureError
 };