@recordtimelabel/core 0.4.1 → 0.4.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 durable identity and explicit entrypoint contract is prepared in package version `0.4.1` (publish it 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 durable identity and explicit entrypoint contract is prepared in package version `0.4.2` (publish it before updating consumers):
 
 ```json
-"@recordtimelabel/core": "0.4.1"
+"@recordtimelabel/core": "0.4.2"
 ```
 
 If this checkout's `package.json` is ahead of the published version, publish the new package before updating consumers to that version.
@@ -33,6 +33,7 @@ If this checkout's `package.json` is ahead of the published version, publish the
 - `applyOperation(state, operation)`
 - `applyRecordTimeLabelOperation(state, operation)`
 - `createRecordTimeLabelSyncEngine({ storage, cloud, session, client, clock, logger })`
+- `RECORD_TIMELABEL_DURABLE_ENGINE_CAPABILITIES`
 - `normalizeRecordTimeLabelOperationResults(operations, results)`
 - `normalizeRecordTimeLabelEnvelopeResponse(operations, response)`
 - `createSyncEngine({ storageAdapter, cloudAdapter, clientId, clock, logger })`
@@ -102,6 +103,11 @@ operations missing them inherit the migrated workspace identity. An operation wh
 explicit identity does not match the current workspace is moved to
 `rejectedOperations` with a stable identity-mismatch reason before any cloud apply.
 
+Pending operations also carry an internal `syncBatchId`. Operations dispatched in
+one call share a batch boundary, while legacy pending operations are assigned one
+stable boundary during migration. Adapters may use this field to preserve immutable
+request envelopes across worker restarts; it must not be sent to the gateway.
+
 The engine exposes `init()`, `dispatch(operations)`, `sync(reason)`, `getSnapshot()`,
 `subscribe(listener)`, and `destroy()`. `getSnapshot().state` is derived by replaying pending
 operations over `remoteBaseline.state`; rejected operations are kept in diagnostics and are not

package/package.json

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

package/src/index.js

@@ -17,8 +17,13 @@ const REQUIRED_FOLDERS = [
   { id: DEFAULT_FOLDER_ID, name: 'Uncategorized' }
 ];
 
-export const RECORD_TIMELABEL_CORE_VERSION = '0.4.1';
+export const RECORD_TIMELABEL_CORE_VERSION = '0.4.2';
 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'
+]);
 export const RTL_MAX_OPERATIONS_PER_REQUEST = 20;
 export const RTL_MAX_REQUEST_BYTES = 256 * 1024;
 export const RTL_MAX_TARGET_WRITES = 100;
@@ -2729,6 +2734,16 @@ const rtlNormalizePendingOperation = (operation, options = {}) => {
   return normalized;
 };
 
+const rtlStableSyncBatchId = (operations = []) => {
+  const source = toArray(operations).map((operation) => normalizeId(operation?.id)).join('|');
+  let hash = 2166136261;
+  for (let index = 0; index < source.length; index += 1) {
+    hash ^= source.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return `durable-batch:${(hash >>> 0).toString(16).padStart(8, '0')}`;
+};
+
 const rtlNormalizeRemoteBaseline = (value = {}) => {
   const baseline = rtlDurableIsObject(value) ? value : {};
   return {
@@ -2772,6 +2787,10 @@ const rtlNormalizeDurableWorkspace = (input = {}, options = {}) => {
   const pendingOperations = toArray(pendingSource)
     .filter(Boolean)
     .map((operation) => rtlNormalizePendingOperation(operation, options));
+  const legacyBatchId = rtlStableSyncBatchId(pendingOperations);
+  pendingOperations.forEach((operation) => {
+    if (!operation.syncBatchId) operation.syncBatchId = legacyBatchId;
+  });
   const legacyExpandedGroups = Array.isArray(source.syncMeta?.legacyExpandedGroups)
     ? normalizeOrder(source.syncMeta.legacyExpandedGroups)
     : Array.isArray(source.state?.expandedGroups)
@@ -3374,6 +3393,10 @@ export const createRecordTimeLabelSyncEngine = ({
       ownerUid: captured?.uid ?? candidate.ownerUid,
       workspaceEpoch: captured?.workspaceEpoch ?? candidate.workspaceEpoch
     }));
+    const syncBatchId = rtlStableSyncBatchId(normalized);
+    normalized.forEach((operation) => {
+      if (!operation.syncBatchId) operation.syncBatchId = syncBatchId;
+    });
     const identityChecked = rtlQuarantineOperations(candidate, normalized, now());
     const viewOperations = identityChecked.accepted.filter((operation) => (
       operation.type === OPERATION_TYPES.EXPANDED_GROUPS_UPDATE
@@ -3446,9 +3469,15 @@ export const createRecordTimeLabelSyncEngine = ({
       workspace = candidate;
       notify({type: 'operations_rejected', rejectedCount: identityRejectedCount});
     }
-    const ready = workspace.pendingOperations.filter((operation) => (
-      !Number.isFinite(Number(operation.nextRetryAt)) || Number(operation.nextRetryAt) <= timestamp
-    ));
+    // Pending operations are a FIFO log. A retry deadline on an earlier entry
+    // is a head-of-line barrier; dependent operations behind it must not
+    // overtake it merely because they do not have their own deadline yet.
+    const ready = [];
+    for (const operation of workspace.pendingOperations) {
+      if (Number.isFinite(Number(operation.nextRetryAt)) &&
+          Number(operation.nextRetryAt) > timestamp) break;
+      ready.push(operation);
+    }
     if (ready.length === 0) {
       return {
         success: true,
@@ -3590,6 +3619,18 @@ export const createRecordTimeLabelSyncEngine = ({
       lastSyncReason: reason ?? null,
       lastSyncError: null
     };
+    const rejectedCount = parsed.results.filter((result) => result.status === 'rejected').length;
+    if (rejectedCount > 0 && typeof cloud?.bootstrap === 'function') {
+      let freshBaseline;
+      try {
+        freshBaseline = await cloud.bootstrap(context);
+      } catch (error) {
+        if (!(await isCurrent(captured))) return {success: false, reason: 'stale_session'};
+        throw error;
+      }
+      if (!(await isCurrent(captured))) return {success: false, reason: 'stale_session'};
+      applyRemoteBaseline(candidate, freshBaseline);
+    }
     if (!(await persist(candidate, captured))) return {success: false, reason: 'stale_session'};
     workspace = candidate;
     notify({type: 'synced', operations: clone(parsed.results)});
@@ -3600,7 +3641,7 @@ export const createRecordTimeLabelSyncEngine = ({
         success: true,
       appliedCount: appliedOperations.length,
       syncedCount: appliedOperations.length + parsed.results.filter((result) => result.status === 'noop').length,
-      rejectedCount: parsed.results.filter((result) => result.status === 'rejected').length,
+      rejectedCount,
       retryCount: parsed.results.filter((result) => result.status === 'retryable').length,
       retryAt: Number.isFinite(retryAt) ? retryAt : null,
       pendingCount: workspace.pendingOperations.length,
@@ -4634,6 +4675,7 @@ export const buildOperationsFromSnapshotDiff = ({
 
 export default {
   RECORD_TIMELABEL_CORE_VERSION,
+  RECORD_TIMELABEL_DURABLE_ENGINE_CAPABILITIES,
   RECORD_TIMELABEL_OPERATION_RESULT_STATUSES,
   RTL_SYNC_PROTOCOL_VERSION,
   RTL_MAX_OPERATIONS_PER_REQUEST,