dsh-offwork 1.1.1 → 1.2.2

package/hydration-store.js

@@ -1,8 +1,22 @@
-import { defaultHydration, validateHydration } from './hydration.js';
+import { defaultHydration, validateHydration, migrateHydration } from './hydration.js';
 
 // A single IndexedDB read/write transaction is the cross-tab mutex. Neither
 // notification delivery nor localStorage read-back is used as an atomic lock.
-export function createHydrationStore(indexedDB, name = 'dsh.offwork-clock.hydration.v1') {
+export function createHydrationStore(
+  indexedDB,
+  name = 'dsh.offwork-clock.hydration.v1',
+  now = () => Date.now(),
+) {
+  return createStateStore(indexedDB, name, defaultHydration, validateHydration, {
+    version: 2,
+    storeName: 'wall-clock',
+    legacyStore: 'state',
+    migrate: (value) => migrateHydration(value, now()),
+  });
+}
+
+export function createStateStore(indexedDB, name, initial, validate, options = {}) {
+  const storeName = options.storeName || 'state';
   let database = null;
   let opening = null;
   let closed = false;
@@ -20,8 +34,11 @@ export function createHydrationStore(indexedDB, name = 'dsh.offwork-clock.hydrat
         reject(new Error('Hydration storage unavailable'));
         return;
       }
-      const request = indexedDB.open(name, 1);
-      request.onupgradeneeded = () => request.result.createObjectStore('state');
+      const request = indexedDB.open(name, options.version || 1);
+      request.onupgradeneeded = () => {
+        if (!request.result.objectStoreNames.contains(storeName))
+          request.result.createObjectStore(storeName);
+      };
       request.onerror = () => fail(request.error ?? new Error('Hydration storage unavailable'));
       request.onblocked = () => fail(new Error('Hydration storage blocked'));
       request.onsuccess = () => {
@@ -53,37 +70,59 @@ export function createHydrationStore(indexedDB, name = 'dsh.offwork-clock.hydrat
       const db = await open();
       if (closed) throw new Error('Hydration store closed');
       return new Promise((resolve, reject) => {
-        const transaction = db.transaction('state', 'readwrite');
-        const store = transaction.objectStore('state');
+        const hasLegacy =
+          !!options.legacyStore && db.objectStoreNames.contains(options.legacyStore);
+        const transaction = db.transaction(
+          hasLegacy ? [storeName, options.legacyStore] : storeName,
+          'readwrite',
+        );
+        const store = transaction.objectStore(storeName);
         const request = store.get('current');
         let output;
         let failure;
-        request.onsuccess = () => {
+        const apply = (stored, legacy, imported = false) => {
           try {
-            const current =
-              reset || request.result === undefined
-                ? defaultHydration()
-                : validateHydration(request.result);
-            const next = validateHydration(reducer(structuredClone(current)));
+            const current = reset
+              ? initial()
+              : stored !== undefined
+                ? validate(stored)
+                : imported
+                  ? validate(options.migrate(legacy))
+                  : initial();
+            const next = validate(reducer(structuredClone(current)));
             const changed = JSON.stringify(next) !== JSON.stringify(current);
-            const migrated =
-              request.result !== undefined && request.result.schema !== current.schema;
+            const migrated = imported || (stored !== undefined && stored.schema !== current.schema);
             if (reset || changed || migrated) {
               const previousRevision =
-                Number.isSafeInteger(request.result?.revision) && request.result.revision >= 0
-                  ? request.result.revision
+                Number.isSafeInteger(stored?.revision) && stored.revision >= 0
+                  ? stored.revision
                   : current.revision;
               next.revision = previousRevision + 1;
               if (!Number.isSafeInteger(next.revision))
                 throw new Error('Hydration revision exhausted');
               store.put(next, 'current');
             }
+            if (imported || (reset && hasLegacy)) store.put(true, 'legacy-imported');
             output = next;
           } catch (error) {
             failure = error;
             transaction.abort();
           }
         };
+        request.onsuccess = () => {
+          if (hasLegacy) {
+            const marker = store.get('legacy-imported');
+            marker.onsuccess = () => {
+              if (!reset && request.result === undefined && marker.result !== true) {
+                const legacy = transaction.objectStore(options.legacyStore).get('current');
+                legacy.onsuccess = () => apply(undefined, legacy.result, true);
+              } else {
+                if (marker.result !== true) store.put(true, 'legacy-imported');
+                apply(request.result);
+              }
+            };
+          } else apply(request.result);
+        };
         transaction.oncomplete = () => resolve(output);
         transaction.onabort = () =>
           reject(failure ?? transaction.error ?? new Error('Hydration transaction aborted'));

package/hydration.js

@@ -1,200 +1,203 @@
-// Pure hydration rules. Time is measured in paid-work milliseconds from calculate().
-export const HYDRATION_SCHEMA = 2;
+import { calculate } from './clock.js';
+
+// Hydration uses wall-clock deadlines, independently of salary and work schedules.
+export const HYDRATION_SCHEMA = 3;
 export const HYDRATION_ACTION_LIMIT = 64;
 export const HYDRATION_LEASE_MS = 8000;
+const hydrationInteger = (number, max = Number.MAX_SAFE_INTEGER) =>
+  Number.isSafeInteger(number) && number >= 0 && number <= max;
+const hydrationText = (value, max = 1024) =>
+  typeof value === 'string' && value.length > 0 && value.length <= max;
+const hydrationKeys = (value, keys) =>
+  value &&
+  typeof value === 'object' &&
+  !Array.isArray(value) &&
+  Object.keys(value).every((key) => keys.includes(key));
+const hydrationClaim = (claim) =>
+  claim === null ||
+  (hydrationKeys(claim, ['owner', 'until', 'sequence']) &&
+    hydrationText(claim.owner) &&
+    hydrationInteger(claim.until) &&
+    hydrationInteger(claim.sequence));
+const hydrationActions = (actions) =>
+  Array.isArray(actions) &&
+  actions.length <= HYDRATION_ACTION_LIMIT &&
+  actions.every((id) => hydrationText(id, 128)) &&
+  new Set(actions).size === actions.length;
 
 export function defaultHydration() {
-  return { schema: HYDRATION_SCHEMA, revision: 0, enabled: false, interval: 60, shift: null };
+  return {
+    schema: HYDRATION_SCHEMA,
+    revision: 0,
+    enabled: false,
+    interval: 60,
+    count: 0,
+    paused: false,
+    dueAt: 0,
+    sequence: 0,
+    claim: null,
+    quietUntil: 0,
+    recentActions: [],
+  };
 }
-
 export function validateHydration(value) {
-  const integer = (number, max = Number.MAX_SAFE_INTEGER) =>
-    Number.isSafeInteger(number) && number >= 0 && number <= max;
-  const text = (string) => typeof string === 'string' && string.length > 0 && string.length <= 1024;
-  const keys = (object, allowed) =>
-    object &&
-    typeof object === 'object' &&
-    !Array.isArray(object) &&
-    Object.keys(object).every((key) => allowed.includes(key));
   if (
-    !keys(value, ['schema', 'revision', 'enabled', 'interval', 'shift']) ||
-    ![1, HYDRATION_SCHEMA].includes(value.schema) ||
-    !integer(value.revision) ||
+    !hydrationKeys(value, [
+      'schema',
+      'revision',
+      'enabled',
+      'interval',
+      'count',
+      'paused',
+      'dueAt',
+      'sequence',
+      'claim',
+      'quietUntil',
+      'recentActions',
+    ]) ||
+    value.schema !== HYDRATION_SCHEMA ||
+    !hydrationInteger(value.revision) ||
     typeof value.enabled !== 'boolean' ||
-    !integer(value.interval, 240) ||
-    value.interval < 5
-  ) {
+    !hydrationInteger(value.interval, 240) ||
+    value.interval < 5 ||
+    !hydrationInteger(value.count, 1000000) ||
+    typeof value.paused !== 'boolean' ||
+    !hydrationInteger(value.dueAt) ||
+    !hydrationInteger(value.sequence) ||
+    !hydrationInteger(value.quietUntil) ||
+    !hydrationClaim(value.claim) ||
+    !hydrationActions(value.recentActions)
+  )
     throw new Error('Invalid hydration data');
-  }
+  return structuredClone(value);
+}
+
+function validateLegacyHydration(value) {
+  if (
+    !hydrationKeys(value, ['schema', 'revision', 'enabled', 'interval', 'shift']) ||
+    ![1, 2].includes(value.schema) ||
+    !hydrationInteger(value.revision) ||
+    typeof value.enabled !== 'boolean' ||
+    !hydrationInteger(value.interval, 240) ||
+    value.interval < 5
+  )
+    throw new Error('Invalid legacy hydration data');
   const shift = value.shift;
-  if (shift !== null) {
-    if (
-      !keys(shift, [
-        'id',
-        'schedule',
-        'config',
-        'count',
-        'paused',
-        'due',
-        'sequence',
-        'claim',
-        ...(value.schema === 2 ? ['quietUntil', 'recentActions'] : []),
-      ]) ||
-      !text(shift.id) ||
-      !text(shift.schedule) ||
-      !text(shift.config) ||
-      !integer(shift.count, 1000000) ||
+  if (
+    shift !== null &&
+    (!hydrationKeys(shift, [
+      'id',
+      'schedule',
+      'config',
+      'count',
+      'paused',
+      'due',
+      'sequence',
+      'claim',
+      ...(value.schema === 2 ? ['quietUntil', 'recentActions'] : []),
+    ]) ||
+      !hydrationText(shift.id) ||
+      !hydrationText(shift.schedule) ||
+      !hydrationText(shift.config) ||
+      !hydrationInteger(shift.count, 1000000) ||
       typeof shift.paused !== 'boolean' ||
-      !integer(shift.sequence) ||
-      !integer(shift.due, 172800000)
-    ) {
-      throw new Error('Invalid hydration shift');
-    }
-    if (
-      value.schema === 2 &&
-      (!integer(shift.quietUntil) ||
-        !Array.isArray(shift.recentActions) ||
-        shift.recentActions.length > HYDRATION_ACTION_LIMIT ||
-        !shift.recentActions.every((id) => text(id) && id.length <= 128) ||
-        new Set(shift.recentActions).size !== shift.recentActions.length)
-    )
-      throw new Error('Invalid hydration actions');
-    if (
-      shift.claim !== null &&
-      (!keys(shift.claim, ['owner', 'until', 'sequence']) ||
-        !text(shift.claim.owner) ||
-        !integer(shift.claim.until) ||
-        !integer(shift.claim.sequence))
-    ) {
-      throw new Error('Invalid hydration claim');
-    }
-  }
-  const result = structuredClone(value);
-  if (result.schema === 1) {
-    result.schema = HYDRATION_SCHEMA;
-    if (result.shift) {
-      result.shift.quietUntil = 0;
-      result.shift.recentActions = [];
-      result.shift.claim = null;
-      result.shift.sequence++;
-      if (!Number.isSafeInteger(result.shift.sequence))
-        throw new Error('Invalid hydration sequence');
+      !hydrationInteger(shift.due, 172800000) ||
+      !hydrationInteger(shift.sequence) ||
+      !hydrationClaim(shift.claim) ||
+      (value.schema === 2 &&
+        (!hydrationInteger(shift.quietUntil) || !hydrationActions(shift.recentActions))))
+  )
+    throw new Error('Invalid legacy hydration record');
+  return structuredClone(value);
+}
+
+// Invoked only inside the one-time, two-store migration transaction. The original
+// work-based record stays untouched in its old object store for preservation.
+export function migrateHydration(value, now) {
+  if (!hydrationInteger(now)) throw new Error('Invalid hydration migration time');
+  if (value === undefined) return defaultHydration();
+  const old = validateLegacyHydration(value),
+    next = defaultHydration(),
+    shift = old.shift;
+  next.revision = old.revision;
+  next.enabled = old.enabled;
+  next.interval = old.interval;
+  let remaining = next.interval * 60000;
+  if (shift) {
+    next.count = shift.count;
+    next.paused = shift.paused;
+    next.sequence = shift.sequence + 1;
+    next.quietUntil = old.schema === 2 && shift.quietUntil > now ? shift.quietUntil : 0;
+    next.recentActions = old.schema === 2 ? shift.recentActions : [];
+    // A matching retained shift supplies the remaining paid minutes. Convert
+    // that remainder once; never consult work settings again after migration.
+    try {
+      const [timezone, start, end, breakStart, breakEnd, weekdays] = JSON.parse(shift.config);
+      const clock = calculate(
+        { timezone, start, end, breakStart, breakEnd, weekdays, payMode: 'daily', dailySalary: 1 },
+        now,
+      );
+      const id = JSON.stringify([timezone, clock.shiftDate]);
+      const schedule = JSON.stringify([
+        start,
+        end,
+        breakStart,
+        breakEnd,
+        [...weekdays].sort(),
+        clock.shiftStart,
+        clock.shiftEnd,
+      ]);
+      if (id === shift.id && schedule === shift.schedule && !shift.paused)
+        remaining = Math.max(0, shift.due - Math.floor(clock.elapsed * 1000));
+    } catch {
+      /* Older/unknown schedule text: start one full configured interval. */
     }
   }
-  return result;
+  next.dueAt = next.enabled ? now + remaining : 0;
+  return validateHydration(next);
 }
 
-export function hydrationContext(settings, clock) {
-  if (!settings || !clock || !Number.isFinite(clock.elapsed) || !Number.isFinite(clock.total))
-    return null;
+export function reconcileHydration(state, now) {
+  const next = validateHydration(state);
+  if (!hydrationInteger(now)) throw new Error('Invalid reminder time');
+  if (next.enabled && next.dueAt === 0) next.dueAt = now + next.interval * 60000;
+  if (next.quietUntil <= now) next.quietUntil = 0;
+  if (!next.enabled || next.paused || next.quietUntil > now) next.claim = null;
+  return validateHydration(next);
+}
+export function hydrationView(state, now) {
+  const remaining = state.dueAt ? Math.max(0, state.dueAt - now) : state.interval * 60000;
+  const quietRemaining = state.enabled && !state.paused ? Math.max(0, state.quietUntil - now) : 0;
+  const phase = !state.enabled
+    ? 'off'
+    : state.paused
+      ? 'paused'
+      : quietRemaining > 0
+        ? 'quiet'
+        : remaining === 0
+          ? 'due'
+          : 'countdown';
   return {
-    id: JSON.stringify([settings.timezone, clock.shiftDate]),
-    config: JSON.stringify([
-      settings.timezone,
-      settings.start,
-      settings.end,
-      settings.breakStart,
-      settings.breakEnd,
-      [...settings.weekdays].sort(),
-    ]),
-    schedule: JSON.stringify([
-      settings.start,
-      settings.end,
-      settings.breakStart,
-      settings.breakEnd,
-      [...settings.weekdays].sort(),
-      clock.shiftStart,
-      clock.shiftEnd,
-    ]),
-    status: clock.status,
-    end: clock.shiftEnd,
-    elapsed: Math.max(0, Math.floor(clock.elapsed * 1000)),
-    total: Math.max(0, Math.floor(clock.total * 1000)),
+    phase,
+    count: state.count,
+    remaining,
+    quietRemaining,
+    eventId:
+      state.enabled && state.dueAt
+        ? JSON.stringify(['wall-clock', state.sequence, state.dueAt])
+        : null,
   };
 }
-
-export function reconcileHydration(state, context, manual = false) {
-  const next = structuredClone(state);
-  if (!context) return next;
-  if (!next.enabled && !manual) {
-    if (next.shift) next.shift.claim = null;
-    return next;
-  }
-  if (next.shift?.id !== context.id) {
-    // Do not discard the last shift's count on a day off. New working shifts
-    // are initialized once the user opens the page, never backfilled.
-    if (!['before', 'working', 'lunch'].includes(context.status)) return next;
-    next.shift = {
-      id: context.id,
-      schedule: context.schedule,
-      config: context.config,
-      count: 0,
-      paused: false,
-      due: context.elapsed + next.interval * 60000,
-      sequence: 0,
-      claim: null,
-      quietUntil: 0,
-      recentActions: [],
-    };
-  } else if (next.shift.schedule !== context.schedule) {
-    next.shift.schedule = context.schedule;
-    next.shift.config = context.config;
-    next.shift.due = context.elapsed + next.interval * 60000;
-    next.shift.sequence++;
-    next.shift.claim = null;
-    next.shift.quietUntil = Math.min(next.shift.quietUntil, context.end);
-  }
-  if (next.shift && (!next.enabled || context.status !== 'working')) next.shift.claim = null;
-  return next;
-}
-
-export function hydrationView(state, context, now = 0) {
-  const same =
-    context && state.shift?.id === context.id && state.shift.schedule === context.schedule;
-  const shift = same ? state.shift : null;
-  const count = shift?.count ?? 0;
-  const remaining = shift ? Math.max(0, shift.due - context.elapsed) : state.interval * 60000;
-  const eventId = shift
-    ? JSON.stringify([shift.id, shift.schedule, shift.sequence, shift.due])
-    : null;
-  const quietRemaining =
-    shift && ['working', 'lunch'].includes(context.status)
-      ? Math.max(0, Math.min(shift.quietUntil, context.end) - now)
-      : 0;
-  let phase = 'waiting';
-  if (!state.enabled) phase = 'off';
-  else if (shift?.paused) phase = 'paused';
-  else if (quietRemaining > 0) phase = 'quiet';
-  else if (context?.status === 'lunch') phase = 'break';
-  else if (shift && context.status === 'working') {
-    phase = remaining === 0 ? 'due' : shift.due >= context.total ? 'finished' : 'countdown';
-  }
-  return { phase, count, remaining, eventId, quietRemaining };
-}
-
-export function transitionHydration(state, context, action, now, owner) {
-  if (!Number.isSafeInteger(now) || now < 0) throw new Error('Invalid reminder time');
-  // Reconfiguration requires an explicit compare-and-set grant obtained before
-  // reading/saving Host settings. A stale tab may release its lease or disable
-  // reminders, but cannot silently restore its previous schedule.
-  if (
-    context &&
-    state.shift &&
-    (state.shift.config !== context.config ||
-      (state.shift.id === context.id && state.shift.schedule !== context.schedule)) &&
-    action.baseSchedule !== state.shift.schedule
-  )
-    context = null;
-  const manual =
-    action.type === 'manual-drink' &&
-    action.shiftId === context?.id &&
-    ['working', 'lunch'].includes(context?.status);
-  let next = reconcileHydration(state, context, manual);
+export function transitionHydration(state, action, now, owner) {
+  let next = reconcileHydration(state, now);
+  const finish = () => validateHydration(next);
+  const invalidate = () => {
+    next.sequence++;
+    next.claim = null;
+  };
   const restart = () => {
-    if (!next.shift || !context || next.shift.id !== context.id) return;
-    next.shift.due = context.elapsed + next.interval * 60000;
-    next.shift.sequence++;
-    next.shift.claim = null;
+    next.dueAt = now + next.interval * 60000;
+    invalidate();
   };
   if (action.type === 'reset') return defaultHydration();
   if (action.type === 'preferences') {
@@ -207,86 +210,65 @@ export function transitionHydration(state, context, action, now, owner) {
       interval > 240
     )
       throw new Error('Invalid reminder preferences');
-    const changed = next.enabled !== enabled || next.interval !== interval;
+    const changed = enabled !== next.enabled || interval !== next.interval;
     next.enabled = enabled;
     next.interval = interval;
-    next = reconcileHydration(next, context);
-    if (!next.enabled && next.shift) {
-      next.shift.claim = null;
-      next.shift.quietUntil = 0;
+    if (!enabled) {
+      next.claim = null;
+      next.quietUntil = 0;
     }
-    if (changed) restart();
-    return next;
-  }
-  const shift = next.shift;
-  if (action.type === 'release') {
-    if (shift?.claim?.owner === owner) shift.claim = null;
-    return next;
+    if (changed) {
+      if (enabled) restart();
+      else invalidate();
+    }
+    return finish();
   }
-  if (!shift || !context || shift.id !== context.id) return next;
-  if (shift.quietUntil && (now >= shift.quietUntil || now >= context.end)) shift.quietUntil = 0;
-  const view = hydrationView(next, context, now);
+  const view = hydrationView(next, now);
   const validClaim =
-    shift.claim &&
-    shift.claim.owner === owner &&
-    shift.claim.sequence === shift.sequence &&
-    shift.claim.until > now &&
-    shift.claim.until <= now + HYDRATION_LEASE_MS;
-  if (action.type === 'manual-drink' && manual) {
-    if (
-      typeof action.actionId !== 'string' ||
-      !action.actionId.length ||
-      action.actionId.length > 128
-    )
-      throw new Error('Invalid hydration action id');
+    next.claim &&
+    next.claim.owner === owner &&
+    next.claim.sequence === next.sequence &&
+    next.claim.until > now &&
+    next.claim.until <= now + HYDRATION_LEASE_MS;
+  if (action.type === 'release') {
+    if (next.claim?.owner === owner) next.claim = null;
+  } else if (action.type === 'manual-drink') {
+    if (!hydrationText(action.actionId, 128)) throw new Error('Invalid hydration action id');
     if (
-      shift.recentActions.includes(action.actionId) ||
+      next.recentActions.includes(action.actionId) ||
       (action.eventId !== undefined && action.eventId !== view.eventId)
     )
-      return next;
-    shift.recentActions = [
-      ...shift.recentActions.slice(-(HYDRATION_ACTION_LIMIT - 1)),
+      return finish();
+    next.recentActions = [
+      ...next.recentActions.slice(-(HYDRATION_ACTION_LIMIT - 1)),
       action.actionId,
     ];
-    shift.count = Math.min(1000000, shift.count + 1);
-    if (next.enabled && !shift.paused) restart();
-    else {
-      shift.sequence++;
-      shift.claim = null;
-    }
-  } else if (
-    action.type === 'quiet' &&
-    next.enabled &&
-    !shift.paused &&
-    ['working', 'lunch'].includes(context.status)
-  ) {
+    next.count = Math.min(1000000, next.count + 1);
+    if (next.enabled && !next.paused) restart();
+    else invalidate();
+  } else if (action.type === 'quiet' && next.enabled && !next.paused) {
     if (![30, 60].includes(action.minutes)) throw new Error('Invalid quiet duration');
-    shift.quietUntil = Math.min(now + action.minutes * 60000, context.end);
-    shift.claim = null;
-    shift.sequence++;
-  } else if (action.type === 'end-quiet' && shift.quietUntil) {
-    shift.quietUntil = 0;
-    shift.claim = null;
-    shift.sequence++;
+    next.quietUntil = now + action.minutes * 60000;
+    invalidate();
+  } else if (action.type === 'end-quiet' && next.quietUntil) {
+    next.quietUntil = 0;
+    invalidate();
   } else if (action.type === 'claim' && view.phase === 'due') {
-    const claim = shift.claim;
+    if (!hydrationText(owner)) throw new Error('Invalid reminder owner');
     if (
-      !claim ||
-      claim.owner === owner ||
-      claim.until <= now ||
-      claim.until > now + HYDRATION_LEASE_MS
-    ) {
-      shift.claim = { owner, until: now + HYDRATION_LEASE_MS, sequence: shift.sequence };
-    }
-  } else if (action.type === 'clear-count') {
-    shift.count = 0;
-  } else if (action.type === 'pause' && next.enabled && !shift.paused) {
-    shift.paused = true;
-    shift.quietUntil = 0;
-    shift.claim = null;
-    shift.sequence++;
-  } else if (action.type === 'resume' && next.enabled && shift.paused) {
-    shift.paused = false;
+      !next.claim ||
+      next.claim.owner === owner ||
+      next.claim.until <= now ||
+      next.claim.until > now + HYDRATION_LEASE_MS
+    )
+      next.claim = { owner, until: now + HYDRATION_LEASE_MS, sequence: next.sequence };
+  } else if (action.type === 'clear-count') next.count = 0;
+  else if (action.type === 'pause' && next.enabled && !next.paused) {
+    next.paused = true;
+    next.quietUntil = 0;
+    invalidate();
+  } else if (action.type === 'resume' && next.enabled && next.paused) {
+    next.paused = false;
     restart();
   } else if (
     ['drink', 'snooze'].includes(action.type) &&
@@ -294,10 +276,9 @@ export function transitionHydration(state, context, action, now, owner) {
     validClaim &&
     action.eventId === view.eventId
   ) {
-    if (action.type === 'drink') shift.count = Math.min(1000000, shift.count + 1);
-    shift.due = context.elapsed + (action.type === 'snooze' ? 10 : next.interval) * 60000;
-    shift.sequence++;
-    shift.claim = null;
+    if (action.type === 'drink') next.count = Math.min(1000000, next.count + 1);
+    next.dueAt = now + (action.type === 'snooze' ? 10 : next.interval) * 60000;
+    invalidate();
   }
-  return next;
+  return finish();
 }