@recordtimelabel/core 0.6.7 → 0.6.9

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 release target is `0.6.7`; verify that its registry tarball and lockfile integrity are available before updating consumers:
+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 release target is `0.6.9`; verify that its registry tarball and lockfile integrity are available before updating consumers:
 
 ```json
-"@recordtimelabel/core": "0.6.7"
+"@recordtimelabel/core": "0.6.9"
 ```
 
 If this checkout's `package.json` is ahead of the published version, publish the new package before updating consumers to that version.

package/package.json

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

package/src/changefeed.js

@@ -145,6 +145,33 @@ export const applyFirestoreV2ResolvedChangeBatch = ({
   };
   let rootChanged = false;
 
+  // Resolved documents represent the final target revision, not every
+  // intermediate receipt. If an entity is changed and then deleted within
+  // this contiguous batch, its final document correctly does not exist.
+  // Record the final mutation so that specific case can be reduced without
+  // weakening the fail-closed rule for genuinely missing changed documents.
+  const finalMutations = {
+    records: new Map(),
+    folders: new Map(),
+    trash: new Map()
+  };
+  batch.forEach((change, index) => {
+    [
+      ['records', change?.changedRecordIds, 'changed'],
+      ['records', change?.deletedRecordIds, 'deleted'],
+      ['folders', change?.changedFolderIds, 'changed'],
+      ['folders', change?.deletedFolderIds, 'deleted'],
+      ['trash', change?.changedTrashEntryIds, 'changed'],
+      ['trash', change?.deletedTrashEntryIds, 'deleted']
+    ].forEach(([kind, ids, mutation]) => {
+      toIdList(ids).forEach((id) => finalMutations[kind].set(id, {index, mutation}));
+    });
+  });
+  const isShadowedByLaterDelete = (kind, id, index) => {
+    const finalMutation = finalMutations[kind].get(id);
+    return finalMutation?.mutation === 'deleted' && finalMutation.index > index;
+  };
+
   for (let index = 0; index < batch.length; index += 1) {
     const change = batch[index] || {};
     const revision = Number(change.revision || 0);
@@ -193,7 +220,7 @@ export const applyFirestoreV2ResolvedChangeBatch = ({
       ...changedTrash.map((id) => ['trash', id])
     ].some(([kind, id]) => {
       const document = resolvedDocument(resolvedDocuments, kind, id);
-      return document == null;
+      return document == null && !isShadowedByLaterDelete(kind, id, index);
     });
     if (missingChanged) {
       return fail(FIRESTORE_V2_BOOTSTRAP_REASONS.CHANGED_DOCUMENT_MISSING, inputCache);
@@ -211,14 +238,17 @@ export const applyFirestoreV2ResolvedChangeBatch = ({
 
     changedRecords.forEach((id) => {
       const document = resolvedDocument(resolvedDocuments, 'records', id);
+      if (document == null && isShadowedByLaterDelete('records', id, index)) return;
       candidate.documents.records[id] = {id, ...document};
     });
     changedFolders.forEach((id) => {
       const document = resolvedDocument(resolvedDocuments, 'folders', id);
+      if (document == null && isShadowedByLaterDelete('folders', id, index)) return;
       candidate.documents.folders[id] = {id, ...document};
     });
     changedTrash.forEach((id) => {
       const document = resolvedDocument(resolvedDocuments, 'trash', id);
+      if (document == null && isShadowedByLaterDelete('trash', id, index)) return;
       candidate.documents.trash[id] = {id, ...document};
     });
     deletedRecords.forEach((id) => delete candidate.documents.records[id]);

package/src/index.js

@@ -145,7 +145,7 @@ export {
   selectBestMatchingTwitchVod
 };
 
-export const RECORD_TIMELABEL_CORE_VERSION = '0.6.7';
+export const RECORD_TIMELABEL_CORE_VERSION = '0.6.9';
 export const RTL_SYNC_PROTOCOL_VERSION = 2;
 export const RECORD_TIMELABEL_DURABLE_ENGINE_CAPABILITIES = Object.freeze([
   'fifo-retry-fence',
@@ -4048,6 +4048,7 @@ export const createRecordTimeLabelSyncEngine = ({
     })
   };
   let bootstrapAttemptSequence = 0;
+  const activeBootstrapAttempts = new Map();
   let authTransitionLatch = null;
   const listeners = new Set();
   let queue = Promise.resolve();
@@ -4168,7 +4169,7 @@ export const createRecordTimeLabelSyncEngine = ({
     return {changed, stale: false};
   };
 
-  const bootstrapAttemptOptions = (mode) => ({
+  const createBootstrapAttemptOptions = (mode) => ({
     mode,
     attemptId: `bootstrap:${mode}:${now()}:${++bootstrapAttemptSequence}:${
       globalThis.crypto?.randomUUID?.() || Math.random().toString(36).slice(2, 14)
@@ -4176,6 +4177,27 @@ export const createRecordTimeLabelSyncEngine = ({
     requireFresh: true
   });
 
+  const bootstrapAttemptIdentity = (context = {}) => JSON.stringify([
+    context.uid ?? null,
+    context.sessionToken ?? null,
+    Number(context.workspaceEpoch || 0)
+  ]);
+
+  const bootstrapAttemptOptions = (mode, context) => {
+    const identity = bootstrapAttemptIdentity(context);
+    const active = activeBootstrapAttempts.get(mode);
+    if (active?.identity === identity) return active.options;
+    const options = createBootstrapAttemptOptions(mode);
+    activeBootstrapAttempts.set(mode, {identity, options});
+    return options;
+  };
+
+  const clearBootstrapAttempt = (mode, options) => {
+    if (activeBootstrapAttempts.get(mode)?.options === options) {
+      activeBootstrapAttempts.delete(mode);
+    }
+  };
+
   const normalizeBootstrapResponse = (response) => {
     if (!rtlEnvelopeSuccess(response)) {
       const source = response && typeof response === 'object' ? response : {
@@ -4200,6 +4222,24 @@ export const createRecordTimeLabelSyncEngine = ({
     return {state, revision, changeCursor: remote.changeCursor ?? null};
   };
 
+  // A transient failure belongs to the same logical page walk. Keep its
+  // attempt ID so the platform bootstrap owner can resume the signed cursor;
+  // successful and non-transient outcomes retire the attempt.
+  const runBootstrapAttempt = async (context, mode) => {
+    const options = bootstrapAttemptOptions(mode, context);
+    try {
+      const baseline = normalizeBootstrapResponse(await cloud.bootstrap(context, options));
+      clearBootstrapAttempt(mode, options);
+      return baseline;
+    } catch (error) {
+      const failure = normalizeRecordTimeLabelCloudFailure(error);
+      if (failure.class !== RECORD_TIMELABEL_CLOUD_FAILURE_CLASSES.TRANSIENT) {
+        clearBootstrapAttempt(mode, options);
+      }
+      throw error;
+    }
+  };
+
   const clearAuthTransitionLatchIfSessionChanged = (captured) => {
     if (!authTransitionLatch) return;
     if (!rtlSameSessionIdentity(authTransitionLatch, captured)) {
@@ -4283,7 +4323,7 @@ export const createRecordTimeLabelSyncEngine = ({
         const caught = await cloud.catchUp(context, {
           fromRevision: workspace.remoteBaseline.revision,
           targetRevision,
-          ...bootstrapAttemptOptions(`${mode}-catchup`)
+          ...createBootstrapAttemptOptions(`${mode}-catchup`)
         });
         if (rtlEnvelopeSuccess(caught)) {
           return requireBootstrapRevision(normalizeBootstrapResponse(caught), targetRevision);
@@ -4308,10 +4348,7 @@ export const createRecordTimeLabelSyncEngine = ({
     throwIfAuthTransitionLatched(captured);
     try {
       return requireBootstrapRevision(
-        normalizeBootstrapResponse(await cloud.bootstrap(
-          context,
-          bootstrapAttemptOptions(mode)
-        )),
+        await runBootstrapAttempt(context, mode),
         targetRevision
       );
     } catch (error) {
@@ -4585,10 +4622,7 @@ export const createRecordTimeLabelSyncEngine = ({
     }
     let baseline;
     try {
-      baseline = normalizeBootstrapResponse(await cloud.bootstrap(
-        context,
-        bootstrapAttemptOptions('apply-failure-rebase')
-      ));
+      baseline = await runBootstrapAttempt(context, 'apply-failure-rebase');
     } catch (bootstrapError) {
       if (!(await isCurrent(captured))) return {success: false, reason: 'stale_session'};
       rethrowClassifiedCloudFailure(captured, bootstrapError);
@@ -4755,10 +4789,7 @@ export const createRecordTimeLabelSyncEngine = ({
       if (typeof cloud?.bootstrap === 'function') {
         try {
           freshBaseline = requireBootstrapRevision(
-            normalizeBootstrapResponse(await cloud.bootstrap(
-              context,
-              bootstrapAttemptOptions('rejection-rebase')
-            )),
+            await runBootstrapAttempt(context, 'rejection-rebase'),
             requiredRevision
           );
         } catch (bootstrapError) {
@@ -5253,10 +5284,7 @@ export const createRecordTimeLabelSyncEngine = ({
       });
       let bootstrap;
       try {
-        bootstrap = normalizeBootstrapResponse(await cloud.bootstrap(
-          context,
-          bootstrapAttemptOptions('initial-hydration')
-        ));
+        bootstrap = await runBootstrapAttempt(context, 'initial-hydration');
       } catch (error) {
         if (!(await isCurrent(captured))) return getSnapshot();
         if (persistedHydrationRequired) {
@@ -5783,10 +5811,7 @@ export const createRecordTimeLabelSyncEngine = ({
       let freshBaseline;
       try {
         freshBaseline = requireBootstrapRevision(
-          normalizeBootstrapResponse(await cloud.bootstrap(
-            context,
-            bootstrapAttemptOptions('rejection-rebase')
-          )),
+          await runBootstrapAttempt(context, 'rejection-rebase'),
           responseRevision
         );
       } catch (error) {
@@ -5934,6 +5959,12 @@ export const createRecordTimeLabelSyncEngine = ({
         const captured = capture();
         clearAuthTransitionLatchIfSessionChanged(captured);
         if (initialized && !hydrationRequired && workspaceMatchesSession(captured)) {
+          // A transient listener failure stops only the provider subscription.
+          // Re-entering init for the same owner must reattach that subscription
+          // without discarding the committed workspace or bootstrapping again.
+          if (captured?.uid && !subscriptionContext && typeof cloud?.subscribe === 'function') {
+            startCloudSubscription(captured, workspace);
+          }
           return getSnapshot();
         }
         if (initialized && !hydrationRequired && !workspaceMatchesSession(captured)) {