@recordtimelabel/core 0.6.14 → 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.14`; 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.14"
+"@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.14",
+  "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.14';
+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',
@@ -3660,7 +3660,11 @@ const rtlClearBootstrapResumeMeta = (syncMeta) => {
 };
 
 const rtlRebindSameOwnerWorkspaceEpoch = (workspace, captured, now) => {
-  const ownerUid = rtlNormalizeUid(captured?.uid);
+  const ownerUid = rtlNormalizeUid(
+    captured?.localOnly
+      ? (captured?.retainedOwnerUid || captured?.ownerUid || captured?.uid)
+      : captured?.uid
+  );
   const workspaceEpoch = rtlNormalizeWorkspaceEpoch(captured?.workspaceEpoch, 0);
   const next = clone(workspace);
   next.ownerUid = ownerUid;
@@ -4013,6 +4017,7 @@ const rtlSessionContext = (captured, workspace, client) => ({
   uid: captured?.uid ?? (captured?.hasSession ? null : workspace?.ownerUid ?? null),
   ownerUid: captured?.uid ?? (captured?.hasSession ? null : workspace?.ownerUid ?? null),
   workspaceEpoch: workspace?.workspaceEpoch ?? captured?.workspaceEpoch ?? 0,
+  localOnly: captured?.localOnly === true,
   client: clone(client)
 });
 
@@ -4386,7 +4391,7 @@ export const createRecordTimeLabelSyncEngine = ({
     }
   };
 
-  const normalizeBootstrapResponse = (response) => {
+  const normalizeBootstrapResponse = (response, context = null) => {
     if (!rtlEnvelopeSuccess(response)) {
       const source = response && typeof response === 'object' ? response : {
         message: 'recordtimelabel_bootstrap_failed',
@@ -4397,6 +4402,14 @@ export const createRecordTimeLabelSyncEngine = ({
     }
     const remote = rtlEnvelopePayload(response);
     if (remote?.localOnly === true) {
+      if (context?.localOnly !== true) {
+        throw toRecordTimeLabelCloudFailureError({
+          code: 'recordtimelabel_invalid_bootstrap_response',
+          reason: 'recordtimelabel_invalid_bootstrap_response',
+          message: 'recordtimelabel_invalid_bootstrap_response',
+          retryable: false
+        });
+      }
       const localState = remote.state ?? remote.data;
       if (!rtlDurableIsObject(localState)) {
         throw toRecordTimeLabelCloudFailureError({
@@ -4436,7 +4449,7 @@ export const createRecordTimeLabelSyncEngine = ({
   const runBootstrapAttempt = async (context, mode) => {
     const options = bootstrapAttemptOptions(mode, context);
     try {
-      const baseline = normalizeBootstrapResponse(await cloud.bootstrap(context, options));
+      const baseline = normalizeBootstrapResponse(await cloud.bootstrap(context, options), context);
       clearBootstrapAttempt(mode, options);
       return baseline;
     } catch (error) {
@@ -4534,7 +4547,7 @@ export const createRecordTimeLabelSyncEngine = ({
           ...createBootstrapAttemptOptions(`${mode}-catchup`)
         });
         if (rtlEnvelopeSuccess(caught)) {
-          return requireBootstrapRevision(normalizeBootstrapResponse(caught), targetRevision);
+          return requireBootstrapRevision(normalizeBootstrapResponse(caught, context), targetRevision);
         }
         const failure = normalizeRecordTimeLabelCloudFailure(caught);
         if (failure.class !== RECORD_TIMELABEL_CLOUD_FAILURE_CLASSES.BOOTSTRAP_REQUIRED) {
@@ -4570,6 +4583,9 @@ export const createRecordTimeLabelSyncEngine = ({
     const sourceOwnerUid = rtlNormalizeUid(source.ownerUid);
     const sourcePending = toArray(source.pendingOperations ?? source.pendingOps);
     const sourceHasBoundOperation = sourcePending.some((operation) => rtlNormalizeUid(operation?.ownerUid));
+    const currentUid = captured?.localOnly
+      ? (captured?.retainedOwnerUid || captured?.ownerUid || null)
+      : captured?.uid;
     const loadedWorkspace = rtlNormalizeDurableWorkspace(
       hasDurableShape ? source : {
         ...source,
@@ -4578,15 +4594,12 @@ export const createRecordTimeLabelSyncEngine = ({
         syncMeta: source.syncMeta || {}
       },
       {
-        ownerUid: captured?.uid,
+        ownerUid: currentUid,
         workspaceEpoch: captured?.workspaceEpoch,
         client,
         now
       }
     );
-    const currentUid = captured?.localOnly
-      ? (captured?.retainedOwnerUid || captured?.ownerUid || null)
-      : captured?.uid;
     const currentEpoch = captured?.workspaceEpoch ?? loadedWorkspace.workspaceEpoch;
     const anonymousMigration = Boolean(
       currentUid &&
@@ -5343,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)) {
@@ -5352,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,
@@ -5372,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',
@@ -5407,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,
@@ -5448,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;
@@ -5500,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();
         }
@@ -5765,7 +5836,8 @@ export const createRecordTimeLabelSyncEngine = ({
     }
     if (!(await isCurrent(captured))) return {success: false, reason: 'stale_session'};
     if (!workspaceMatchesSession(captured)) {
-      resetForSessionIdentity(captured);
+      const transition = resetForSessionIdentity(captured);
+      if (transition?.stale) return transition;
       return {success: false, code: 'recordtimelabel_hydration_required'};
     }
     const blockedFailure = workspace.syncMeta?.terminalFailureBlock;