@recordtimelabel/core 0.4.0 → 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.0` (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.0"
+"@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.0",
+  "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.0';
+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)
@@ -2928,19 +2947,34 @@ const rtlEnvelopeSuccess = (value) => {
 const rtlRetryableEnvelopeError = (value) => {
   const error = value?.error && typeof value.error === 'object' ? value.error : value;
   const status = Number(error?.status ?? error?.statusCode ?? value?.status ?? value?.statusCode);
-  const code = String(error?.code ?? value?.code ?? '').toLowerCase();
+  const details = [
+    error?.name,
+    error?.code,
+    error?.reason,
+    error?.message,
+    value?.code,
+    value?.reason,
+    value?.message
+  ].filter(Boolean).join(' ').toLowerCase();
   return Boolean(
     error?.retryable === true ||
     value?.retryable === true ||
     status === 408 || status === 409 || status === 425 || status === 429 || status >= 500 ||
-    code === 'bulk_job_in_progress' || code === 'retryable' || code === 'temporarily_unavailable' ||
-    code === 'unavailable' || code === 'deadline_exceeded'
+    details.includes('bulk_job_in_progress') || details.includes('retryable') ||
+    details.includes('temporarily_unavailable') || details.includes('unavailable') ||
+    details.includes('deadline_exceeded') || details.includes('failed to fetch') ||
+    details.includes('fetch failed') || details.includes('network-request-failed') ||
+    details.includes('network request failed') || details.includes('network_error') ||
+    details.includes('err_network') || details.includes('econnreset') ||
+    details.includes('etimedout')
   );
 };
 
 const rtlRetryAfterMs = (value) => {
   const error = value?.error && typeof value.error === 'object' ? value.error : value;
-  const retryAfter = Number(error?.retryAfterMs ?? value?.retryAfterMs);
+  const rawRetryAfter = error?.retryAfterMs ?? value?.retryAfterMs;
+  if (rawRetryAfter === null || rawRetryAfter === undefined || rawRetryAfter === '') return null;
+  const retryAfter = Number(rawRetryAfter);
   return Number.isFinite(retryAfter) && retryAfter >= 0 ? retryAfter : null;
 };
 
@@ -3265,8 +3299,11 @@ export const createRecordTimeLabelSyncEngine = ({
   const operationRetryAt = (operation, result, retryAfterMs, timestamp) => {
     const direct = Number(result?.nextRetryAt);
     if (Number.isFinite(direct)) return direct;
-    const after = Number(result?.retryAfterMs ?? retryAfterMs);
-    if (Number.isFinite(after) && after >= 0) return timestamp + after;
+    const rawAfter = result?.retryAfterMs ?? retryAfterMs;
+    if (rawAfter !== null && rawAfter !== undefined && rawAfter !== '') {
+      const after = Number(rawAfter);
+      if (Number.isFinite(after) && after >= 0) return timestamp + after;
+    }
     const attempts = Math.max(0, Number(operation?.retryCount || operation?.retryAttempts || 0));
     return timestamp + Math.min(RTL_RETRY_MAX_MS, RTL_RETRY_BASE_MS * (2 ** attempts));
   };
@@ -3356,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
@@ -3428,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,
@@ -3572,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)});
@@ -3582,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,
@@ -4616,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,