@recordtimelabel/core 0.6.15 → 0.6.16

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.15`; 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.16`; verify that its registry tarball and lockfile integrity are available before updating consumers:
 
 ```json
-"@recordtimelabel/core": "0.6.15"
+"@recordtimelabel/core": "0.6.16"
 ```
 
 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.15",
+  "version": "0.6.16",
   "type": "module",
   "description": "Shared RecordTimeLabel data model, merge logic, operations, and sync engine.",
   "main": "./src/index.js",

package/src/index.js

@@ -147,7 +147,7 @@ export {
   selectBestMatchingTwitchVod
 };
 
-export const RECORD_TIMELABEL_CORE_VERSION = '0.6.15';
+export const RECORD_TIMELABEL_CORE_VERSION = '0.6.16';
 export const RTL_SYNC_PROTOCOL_VERSION = 2;
 export const RECORD_TIMELABEL_DURABLE_ENGINE_CAPABILITIES = Object.freeze([
   'fifo-retry-fence',
@@ -5356,6 +5356,8 @@ export const createRecordTimeLabelSyncEngine = ({
     let firstRootObservation = null;
     let latestRootObservationRevision = null;
     let adapterCatchUpProof = null;
+    let processedRootRevisionProof = null;
+    let inFlightRemoteCallbacks = 0;
     const settleReadyIfProven = () => {
       if (!isCurrentRemoteReady(readyState) || readyState.settled ||
         !firstRootObservation || (adapterReadyExpected && !adapterCatchUpProof)) {
@@ -5365,12 +5367,32 @@ export const createRecordTimeLabelSyncEngine = ({
         ? workspace.remoteBaseline.revision
         : 0;
       const proof = adapterCatchUpProof || {};
-      const revision = Number.isSafeInteger(Number(proof.revision))
+      const proofRev = proof.revision !== undefined ? Number(proof.revision) : null;
+      const proofCaughtUp = proof.caughtUpToRevision !== undefined ? Number(proof.caughtUpToRevision) : null;
+      if (
+        (proofRev !== null && (!Number.isSafeInteger(proofRev) || proofRev < 0)) ||
+        (proofCaughtUp !== null && (!Number.isSafeInteger(proofCaughtUp) || proofCaughtUp < 0))
+      ) {
+        readyState.reject(toRecordTimeLabelCloudFailureError({
+          class: RECORD_TIMELABEL_CLOUD_FAILURE_CLASSES.TERMINAL,
+          code: 'invalid_remote_ready_revision',
+          reason: 'invalid_remote_ready_revision',
+          message: 'invalid_remote_ready_revision'
+        }));
+        return;
+      }
+      const rawRevision = Number.isSafeInteger(Number(proof.revision))
         ? Number(proof.revision)
         : baselineRevision;
-      const caughtUpToRevision = Number.isSafeInteger(Number(proof.caughtUpToRevision))
+      const rawCaughtUpToRevision = Number.isSafeInteger(Number(proof.caughtUpToRevision))
         ? Number(proof.caughtUpToRevision)
-        : revision;
+        : rawRevision;
+      const revision = Number.isSafeInteger(processedRootRevisionProof)
+        ? Math.max(rawRevision, processedRootRevisionProof)
+        : rawRevision;
+      const caughtUpToRevision = Number.isSafeInteger(processedRootRevisionProof)
+        ? Math.max(rawCaughtUpToRevision, processedRootRevisionProof)
+        : rawCaughtUpToRevision;
       if (revision < 0 || caughtUpToRevision < 0) {
         readyState.reject(toRecordTimeLabelCloudFailureError({
           class: RECORD_TIMELABEL_CLOUD_FAILURE_CLASSES.TERMINAL,
@@ -5385,6 +5407,7 @@ export const createRecordTimeLabelSyncEngine = ({
         : baselineRevision;
       const requiredRevision = Math.max(baselineRevision, observedRevision);
       if (revision < requiredRevision || caughtUpToRevision < requiredRevision) {
+        if (inFlightRemoteCallbacks > 0) return;
         readyState.reject(toRecordTimeLabelCloudFailureError({
           class: RECORD_TIMELABEL_CLOUD_FAILURE_CLASSES.TERMINAL,
           code: 'stale_remote_ready_revision',
@@ -5420,6 +5443,13 @@ export const createRecordTimeLabelSyncEngine = ({
         return;
       }
       firstRootObservation = result || {success: true};
+      const rootPersistedRevision = Number(workspace?.remoteBaseline?.revision);
+      if (Number.isSafeInteger(rootPersistedRevision)) {
+        processedRootRevisionProof = Math.max(
+          processedRootRevisionProof ?? 0,
+          rootPersistedRevision
+        );
+      }
       if (Number.isSafeInteger(observedRevision) && observedRevision >= 0) {
         latestRootObservationRevision = Math.max(
           latestRootObservationRevision ?? 0,
@@ -5461,14 +5491,21 @@ export const createRecordTimeLabelSyncEngine = ({
       const observedRevision = Number.isSafeInteger(observedRevisionValue) && observedRevisionValue >= 0
         ? observedRevisionValue
         : null;
+      inFlightRemoteCallbacks += 1;
       const callbackResult = enqueue(() => processRemote(remoteValue, captured));
       if (!firstCallbackResult) firstCallbackResult = callbackResult;
-      callbackResult.then((result) => handleRootObservation(result, observedRevision)).catch((error) => {
-        if (isCurrentRemoteReady(readyState) && !readyState.settled) {
-          readyState.reject(error);
-        }
-        logger?.error?.('[RecordTimeLabelCore] durable remote callback failed', error);
-      });
+      callbackResult
+        .then((result) => handleRootObservation(result, observedRevision))
+        .catch((error) => {
+          if (isCurrentRemoteReady(readyState) && !readyState.settled) {
+            readyState.reject(error);
+          }
+          logger?.error?.('[RecordTimeLabelCore] durable remote callback failed', error);
+        })
+        .finally(() => {
+          inFlightRemoteCallbacks -= 1;
+          settleReadyIfProven();
+        });
       return callbackResult;
     };
     let disposer;
@@ -5513,19 +5550,40 @@ export const createRecordTimeLabelSyncEngine = ({
             }
           ));
         } else {
+          const rawRev = result?.revision;
+          const rawCaughtUp = result?.caughtUpToRevision;
+          if (
+            (rawRev !== undefined && (!Number.isSafeInteger(Number(rawRev)) || Number(rawRev) < 0)) ||
+            (rawCaughtUp !== undefined && (!Number.isSafeInteger(Number(rawCaughtUp)) || Number(rawCaughtUp) < 0))
+          ) {
+            readyState.reject(toRecordTimeLabelCloudFailureError({
+              class: RECORD_TIMELABEL_CLOUD_FAILURE_CLASSES.TERMINAL,
+              code: 'invalid_remote_ready_revision',
+              reason: 'invalid_remote_ready_revision',
+              message: 'invalid_remote_ready_revision'
+            }));
+            return;
+          }
           const nextProof = result && typeof result === 'object'
             ? {...result, success: true}
             : {success: true};
           const currentRevision = Number(adapterCatchUpProof?.revision);
           const currentCaughtUp = Number(adapterCatchUpProof?.caughtUpToRevision);
+          const provedRevision = Number.isSafeInteger(processedRootRevisionProof)
+            ? processedRootRevisionProof
+            : null;
           adapterCatchUpProof = {
             ...nextProof,
-            ...(Number.isSafeInteger(currentRevision) && Number.isSafeInteger(Number(nextProof.revision))
-              ? {revision: Math.max(currentRevision, Number(nextProof.revision))}
-              : {}),
-            ...(Number.isSafeInteger(currentCaughtUp) && Number.isSafeInteger(Number(nextProof.caughtUpToRevision))
-              ? {caughtUpToRevision: Math.max(currentCaughtUp, Number(nextProof.caughtUpToRevision))}
-              : {})
+            revision: Math.max(
+              Number.isSafeInteger(currentRevision) ? currentRevision : 0,
+              Number.isSafeInteger(Number(nextProof.revision)) ? Number(nextProof.revision) : 0,
+              provedRevision ?? 0
+            ),
+            caughtUpToRevision: Math.max(
+              Number.isSafeInteger(currentCaughtUp) ? currentCaughtUp : 0,
+              Number.isSafeInteger(Number(nextProof.caughtUpToRevision)) ? Number(nextProof.caughtUpToRevision) : 0,
+              provedRevision ?? 0
+            )
           };
           settleReadyIfProven();
         }