@recordtimelabel/core 0.6.8 → 0.6.10

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.8`; 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.8"
+"@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.8",
+  "version": "0.6.10",
   "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/domain.js

@@ -1,6 +1,7 @@
 export const RECORD_TIMELABEL_DOMAIN_CAPABILITIES = Object.freeze([
   'group-identity-v1',
   'twitch-vod-matching-v1',
+  'twitch-vod-sibling-reconciliation-v1',
   'legacy-import-v1',
   'channel-folder-planning-v1'
 ]);

package/src/index.js

@@ -145,13 +145,14 @@ export {
   selectBestMatchingTwitchVod
 };
 
-export const RECORD_TIMELABEL_CORE_VERSION = '0.6.8';
+export const RECORD_TIMELABEL_CORE_VERSION = '0.6.10';
 export const RTL_SYNC_PROTOCOL_VERSION = 2;
 export const RECORD_TIMELABEL_DURABLE_ENGINE_CAPABILITIES = Object.freeze([
   'fifo-retry-fence',
   'baseline-refresh-after-rejection',
   'sync-batch-boundary',
   'remote-subscription-readiness',
+  'twitch-vod-sibling-reconciliation-v1',
   RECORD_TIMELABEL_CAPABILITY_OPERATION_CONFLICT_QUARANTINE,
   RECORD_TIMELABEL_CAPABILITY_STRICT_OPERATION_RESULTS,
   RECORD_TIMELABEL_CAPABILITY_LIFECYCLE_GENERATION_FENCE,
@@ -1484,6 +1485,27 @@ export const applyOperation = (state = {}, operation = {}) => {
 
 export const applyRecordTimeLabelOperation = (state = {}, operation = {}) => applyOperation(state, operation);
 
+const collectRecordTimeLabelDomainRecords = (records = {}) => Object.entries(records || {})
+  .flatMap(([folderId, folderRecords]) => (
+    folderId === 'all' || !Array.isArray(folderRecords) ? [] : folderRecords
+  ));
+
+export const buildRecordTimeLabelVodSiblingOperations = ({
+  state = {},
+  fallbackPlatform = 'unknown',
+  unknownTitle
+} = {}) => {
+  const normalized = normalizeState(state);
+  const result = buildKnownTwitchVodRecordPatches({
+    records: collectRecordTimeLabelDomainRecords(normalized.records),
+    fallbackPlatform,
+    unknownTitle
+  });
+  return result.patches.map(({recordId, patch}) => (
+    buildRecordTimeLabelVodPatchOperation({recordId, patch})
+  ));
+};
+
 export const mergeLocalRemote = ({
   localState = {},
   remoteState = {},
@@ -3028,6 +3050,22 @@ export const createRecordTimeLabelController = ({
     });
   };
 
+  const reconcileVodSiblings = () => {
+    const pendingIds = new Set(pendingOps.map((operation) => operation?.id).filter(Boolean));
+    const operations = buildRecordTimeLabelVodSiblingOperations({state})
+      .filter((operation) => !pendingIds.has(operation.id))
+      .map((operation) => ({
+        ...operation,
+        clientId: operation.clientId || clientId,
+        createdAt: operation.createdAt || clock()
+      }));
+    operations.forEach((operation) => {
+      state = applyRecordTimeLabelOperation(state, operation);
+    });
+    if (operations.length > 0) pendingOps = [...pendingOps, ...operations];
+    return operations;
+  };
+
   const controller = {
     async init() {
       const loaded = await storageAdapter.load(storageKeys);
@@ -3035,6 +3073,8 @@ export const createRecordTimeLabelController = ({
       pendingOps = toArray(loaded?.pendingOps).map((operation) => ({ ...operation }));
       syncMeta = loaded?.syncMeta && typeof loaded.syncMeta === 'object' ? { ...loaded.syncMeta } : {};
 
+      let shouldPersist = false;
+
       if (cloudAdapter?.load) {
         const remoteState = await cloudAdapter.load();
         const merged = mergeRemoteStateIntoLocal({
@@ -3047,8 +3087,20 @@ export const createRecordTimeLabelController = ({
           now: clock()
         });
         state = merged.state;
-        await persist();
+        shouldPersist = true;
+      }
+
+      const reconciledOperations = reconcileVodSiblings();
+      if (reconciledOperations.length > 0) {
+        const lastOperation = reconciledOperations.at(-1);
+        syncMeta = {
+          ...syncMeta,
+          lastLocalOperationAt: lastOperation.createdAt,
+          lastLocalOperationType: lastOperation.type
+        };
+        shouldPersist = true;
       }
+      if (shouldPersist) await persist();
 
       if (cloudAdapter?.subscribe) {
         unsubscribeCloud = cloudAdapter.subscribe(async (remoteState) => {
@@ -3079,13 +3131,19 @@ export const createRecordTimeLabelController = ({
       };
       state = applyRecordTimeLabelOperation(state, nextOperation);
       pendingOps = [...pendingOps, nextOperation];
+      const reconciledOperations = reconcileVodSiblings();
+      const lastOperation = reconciledOperations.at(-1) || nextOperation;
       syncMeta = {
         ...syncMeta,
-        lastLocalOperationAt: nextOperation.createdAt,
-        lastLocalOperationType: nextOperation.type
+        lastLocalOperationAt: lastOperation.createdAt,
+        lastLocalOperationType: lastOperation.type
       };
       await persist();
-      notify({ type: 'local_applied', operation: nextOperation });
+      notify({
+        type: 'local_applied',
+        operation: nextOperation,
+        operations: [nextOperation, ...reconciledOperations]
+      });
       return getSnapshot();
     },
 
@@ -3100,8 +3158,17 @@ export const createRecordTimeLabelController = ({
         now: clock()
       });
       state = merged.state;
+      const reconciledOperations = reconcileVodSiblings();
+      if (reconciledOperations.length > 0) {
+        const lastOperation = reconciledOperations.at(-1);
+        syncMeta = {
+          ...syncMeta,
+          lastLocalOperationAt: lastOperation.createdAt,
+          lastLocalOperationType: lastOperation.type
+        };
+      }
       await persist();
-      notify({ type: 'remote_merged' });
+      notify({ type: 'remote_merged', operations: reconciledOperations });
       return getSnapshot();
     },
 
@@ -4169,6 +4236,32 @@ export const createRecordTimeLabelSyncEngine = ({
     return {changed, stale: false};
   };
 
+  const appendVodSiblingReconciliation = (candidate, captured, {syncBatchId = null} = {}) => {
+    const operations = buildRecordTimeLabelVodSiblingOperations({
+      state: rtlDeriveDurableVisibleState(candidate)
+    });
+    if (operations.length === 0) return [];
+
+    const normalized = operations.map((operation) => rtlNormalizePendingOperation(operation, {
+      client,
+      clientId: typeof client === 'string' ? client : client?.id,
+      now,
+      ownerUid: captured?.uid ?? candidate.ownerUid,
+      workspaceEpoch: captured?.workspaceEpoch ?? candidate.workspaceEpoch
+    }));
+    const reconciliationBatchId = syncBatchId || rtlStableSyncBatchId(normalized);
+    normalized.forEach((operation) => {
+      if (!operation.syncBatchId) operation.syncBatchId = reconciliationBatchId;
+    });
+    const identityChecked = rtlQuarantineOperations(candidate, normalized, now());
+    candidate.pendingOperations = [
+      ...candidate.pendingOperations,
+      ...identityChecked.accepted
+    ];
+    candidate.rejectedOperations = identityChecked.rejected;
+    return identityChecked.accepted;
+  };
+
   const createBootstrapAttemptOptions = (mode) => ({
     mode,
     attemptId: `bootstrap:${mode}:${now()}:${++bootstrapAttemptSequence}:${
@@ -4952,9 +5045,10 @@ export const createRecordTimeLabelSyncEngine = ({
     }
     const applied = applyRemoteBaseline(candidate, baselineValue);
     if (applied.stale || !applied.changed) return {success: true, ignored: true};
+    const reconciledOperations = appendVodSiblingReconciliation(candidate, captured);
     if (!(await persist(candidate, captured))) return {stale: true, reason: 'stale_session'};
     workspace = candidate;
-    notify({type: 'remote_merged'});
+    notify({type: 'remote_merged', operations: clone(reconciledOperations)});
     return getSnapshot();
   };
 
@@ -5322,6 +5416,16 @@ export const createRecordTimeLabelSyncEngine = ({
     // Always persist the normalized durable shape before subscribing.  This
     // also makes legacy migration atomic from the engine's point of view.
     clearPersistedHydrationBarrier(candidate);
+    const reconciledOperations = appendVodSiblingReconciliation(candidate, captured);
+    if (reconciledOperations.length > 0) {
+      const lastOperation = reconciledOperations.at(-1);
+      candidate.syncMeta = {
+        ...candidate.syncMeta,
+        lastLocalOperationAt: lastOperation.createdAt,
+        lastLocalOperationId: lastOperation.id,
+        lastLocalOperationType: lastOperation.type
+      };
+    }
     if (!(await persist(candidate, captured))) return getSnapshot();
     workspace = candidate;
     initialized = true;
@@ -5397,6 +5501,8 @@ export const createRecordTimeLabelSyncEngine = ({
       ...durableOperations
     ];
     candidate.rejectedOperations = identityChecked.rejected;
+    const reconciledOperations = appendVodSiblingReconciliation(candidate, captured, {syncBatchId});
+    const allDurableOperations = [...durableOperations, ...reconciledOperations];
     if (viewOperations.length > 0) {
       candidate.syncMeta = {
         ...candidate.syncMeta,
@@ -5406,8 +5512,8 @@ export const createRecordTimeLabelSyncEngine = ({
         lastLocalViewOperationId: viewOperations[viewOperations.length - 1].id
       };
     }
-    if (durableOperations.length > 0) {
-      const lastOperation = durableOperations[durableOperations.length - 1];
+    if (allDurableOperations.length > 0) {
+      const lastOperation = allDurableOperations[allDurableOperations.length - 1];
       candidate.syncMeta = {
         ...candidate.syncMeta,
         lastLocalOperationAt: lastOperation.createdAt,
@@ -5417,11 +5523,11 @@ export const createRecordTimeLabelSyncEngine = ({
     }
     if (!(await persist(candidate, captured))) return getSnapshot();
     workspace = candidate;
-    if (durableOperations.length > 0 || viewOperations.length > 0) {
+    if (allDurableOperations.length > 0 || viewOperations.length > 0) {
       notify({
         type: 'local_applied',
-        operations: clone([...durableOperations, ...viewOperations]),
-        operation: clone(viewOperations.at(-1) || durableOperations.at(-1)),
+        operations: clone([...allDurableOperations, ...viewOperations]),
+        operation: clone(viewOperations.at(-1) || allDurableOperations.at(-1)),
         rejectedCount: identityChecked.rejectedCount,
         deduplicatedCount: identityChecked.deduplicatedCount
       });
@@ -7336,6 +7442,7 @@ export default {
   extractTwitchVodIdFromUrl,
   extractYouTubeVideoIdFromUrl,
   buildKnownTwitchVodRecordPatches,
+  buildRecordTimeLabelVodSiblingOperations,
   buildRecordTimeLabelVodPatchOperation,
   buildRecordTimeLabelVodPatchOperationId,
   calculateVodTitleSimilarity,