dsh-offwork 1.1.1 → 1.1.2

package/tests/companion.test.mjs

@@ -16,25 +16,25 @@ test('only a leased due reminder changes the character to a drinking pose; it ad
   assert.equal(here.announce, false);
 });
 
-test('explicit drink feedback is acknowledged once; quiet and break states never celebrate or animate', () => {
+test('explicit drinking works outside work hours while manual quiet/pause still suppress animation', () => {
   const happy = show({ feedback: drink });
   assert.equal(happy.pose, 'happy');
   assert.equal(happy.animate, true);
   assert.equal(happy.announce, true);
-  for (const patch of [
-    { phase: 'quiet' },
-    { phase: 'paused' },
-    { workStatus: 'lunch' },
-    { workStatus: 'rest' },
-    { workStatus: 'done' },
-    { workStatus: 'before' },
-  ]) {
+  for (const patch of [{ phase: 'quiet' }, { phase: 'paused' }]) {
     const result = show({ ...patch, feedback: drink });
     assert.equal(result.animate, false);
     assert.equal(result.message, 'waterRecorded');
   }
+  for (const workStatus of ['lunch', 'rest', 'done', 'before', undefined]) {
+    const result = show({ workStatus, feedback: drink });
+    assert.equal(result.pose, 'happy');
+    assert.equal(result.animate, true);
+    const due = show({ workStatus, phase: 'due', ownsPrompt: true });
+    assert.equal(due.pose, 'drink');
+    assert.equal(due.message, null);
+  }
   assert.equal(show({ phase: 'quiet', feedback: drink }).pose, 'quiet');
-  assert.equal(show({ workStatus: 'lunch', feedback: drink }).pose, 'rest');
   assert.equal(show({ feedback: { ...drink, kind: 'notice' } }).animate, false);
 });
 
@@ -71,8 +71,8 @@ test('quiet, paused and work states have stable localized messages with no autom
     assert.deepEqual(show(input), result);
   }
   assert.notEqual(show({ phase: 'quiet' }).message, show({}).message);
-  assert.equal(show({ phase: 'paused', workStatus: 'done' }).message, 'companionDone');
-  assert.equal(show({ phase: 'paused', workStatus: 'rest' }).message, 'companionDayOff');
+  assert.equal(show({ phase: 'paused', workStatus: 'done' }).message, 'companionPaused');
+  assert.equal(show({ phase: 'paused', workStatus: 'rest' }).message, 'companionPaused');
 });
 
 test('existing view data keeps its position, privacy and opacity while explicit companion opt-out survives reload', () => {

package/tests/countdown.test.mjs

@@ -0,0 +1,115 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { IDBFactory } from 'fake-indexeddb';
+import {
+  defaultCountdown,
+  validateCountdown,
+  transitionCountdown,
+  countdownView,
+  SMOKING_TIMER_DB,
+} from '../countdown.js';
+import { createStateStore, createHydrationStore } from '../hydration-store.js';
+import { petLayout } from '../pet-view.js';
+import { petUIReducer, initialPetUI } from '../pet-interactions.js';
+
+test('wall-clock countdown stays idle until started, expires without restarting and survives serialization', () => {
+  const initial = defaultCountdown();
+  assert.equal(countdownView(initial, 8000000).phase, 'idle');
+  const running = transitionCountdown(initial, { type: 'start' }, 1000);
+  const restored = validateCountdown(JSON.parse(JSON.stringify(running)));
+  assert.equal(countdownView(restored, 31000).remaining, 3570000);
+  assert.deepEqual(countdownView(restored, 4000000), { phase: 'due', remaining: 0 });
+  assert.deepEqual(countdownView(restored, 5000000), { phase: 'due', remaining: 0 });
+  assert.equal(transitionCountdown(restored, { type: 'pause' }, 5000000).status, 'running');
+  assert.equal(transitionCountdown(restored, { type: 'start' }, 5000000).deadline, 8600000);
+});
+
+test('pause freezes the remainder; resume and explicit restart have different semantics', () => {
+  const running = transitionCountdown(defaultCountdown(), { type: 'start' }, 1000);
+  const paused = transitionCountdown(running, { type: 'pause' }, 31000);
+  assert.equal(countdownView(paused, 9000000).remaining, 3570000);
+  const changed = transitionCountdown(paused, { type: 'interval', minutes: 5 }, 9000000);
+  assert.equal(changed.remaining, paused.remaining);
+  const resumed = transitionCountdown(changed, { type: 'resume' }, 9000000);
+  assert.equal(resumed.deadline, 12570000);
+  assert.equal(transitionCountdown(resumed, { type: 'restart' }, 9000000).deadline, 9300000);
+  assert.equal(transitionCountdown(resumed, { type: 'stop' }, 9000000).status, 'idle');
+  assert.equal(transitionCountdown(resumed, { type: 'start' }, 9000000).deadline, resumed.deadline);
+});
+
+test('invalid or future timer data is rejected rather than resetting the countdown', () => {
+  for (const change of [
+    { schema: 2 },
+    { revision: -1 },
+    { minutes: 0 },
+    { minutes: 1441 },
+    { remaining: NaN },
+    { status: 'unknown' },
+    { status: 'paused', remaining: 0 },
+    { status: 'idle', deadline: 1 },
+    { status: 'running', deadline: 1, remaining: 2 },
+  ])
+    assert.throws(() => validateCountdown({ ...defaultCountdown(), ...change }));
+  assert.throws(() =>
+    transitionCountdown(defaultCountdown(), { type: 'interval', minutes: 2.5 }, 0),
+  );
+  assert.throws(() =>
+    transitionCountdown(defaultCountdown(), { type: 'start' }, Number.MAX_SAFE_INTEGER),
+  );
+});
+
+test('timer storage is atomic across tabs and separate from hydration records', async () => {
+  const idb = new IDBFactory();
+  const first = createStateStore(idb, SMOKING_TIMER_DB, defaultCountdown, validateCountdown);
+  const second = createStateStore(idb, SMOKING_TIMER_DB, defaultCountdown, validateCountdown);
+  const water = createHydrationStore(idb);
+  const original = await water.update((state) => state);
+  const results = await Promise.all(
+    [first, second].map((store) =>
+      store.update((state) =>
+        state.revision === 0 ? transitionCountdown(state, { type: 'start' }, 1000) : state,
+      ),
+    ),
+  );
+  assert.equal(results[0].revision, 1);
+  assert.equal(results[1].revision, 1);
+  const stopped = await second.update((state) =>
+    transitionCountdown(state, { type: 'stop' }, 2000),
+  );
+  assert.equal(stopped.revision, 2);
+  assert.deepEqual(await first.update((state) => state), stopped);
+  assert.deepEqual(await water.update((state) => state), original);
+  first.close();
+  second.close();
+  water.close();
+});
+
+test('independent timer cards keep navigation draft protection and reserve space below the character', () => {
+  for (const screen of ['water-countdown', 'smoking']) {
+    assert.equal(
+      petUIReducer(initialPetUI, { type: 'navigate', screen, root: true }).screen,
+      screen,
+    );
+    const dirty = { screen: 'appearance', back: null, menu: null, pending: null };
+    const guarded = petUIReducer(dirty, { type: 'navigate', screen, root: true, dirty: true });
+    assert.equal(guarded.screen, 'appearance');
+    assert.equal(guarded.pending.screen, screen);
+  }
+  for (const [width, height] of [
+    [320, 568],
+    [640, 360],
+    [390, 844],
+  ]) {
+    const layout = petLayout(
+      { x: 9999, y: 9999 },
+      { width, height },
+      220,
+      420,
+      'whale-ornate-actions',
+      90,
+    );
+    assert.ok(layout.y + layout.petHeight <= height - 12);
+    assert.ok(layout.x + layout.petWidth <= width - 12);
+    assert.ok(layout.petHeight >= layout.artworkSize * 2.1 + 90);
+  }
+});

package/tests/host.test.mjs

@@ -148,6 +148,12 @@ async function adapters(t) {
   // and neither adapter can accidentally reach the user's actual data.json.
   const moduleFile = join(fixtureData.dir, 'host.mjs');
   await writeFile(moduleFile, await readFile(source, 'utf8'));
+  await writeFile(join(fixtureData.dir, 'package.json'), '{"type":"module"}');
+  for (const name of ['media-server.js', 'media-manifest.js'])
+    await writeFile(
+      join(fixtureData.dir, name),
+      await readFile(new URL('../' + name, import.meta.url)),
+    );
   const module = await import(pathToFileURL(moduleFile).href);
   let command;
   let tool;

package/tests/hydration-extras.test.mjs

@@ -4,223 +4,187 @@ import { calculate } from '../clock.js';
 import {
   defaultHydration,
   validateHydration,
-  hydrationContext,
+  migrateHydration,
   hydrationView,
   transitionHydration,
   HYDRATION_ACTION_LIMIT,
 } from '../hydration.js';
-
-const settings = {
-  payMode: 'monthly',
-  monthlySalary: 12000,
-  workdaysPerMonth: 20,
-  start: '09:00',
-  end: '18:00',
-  breakStart: '12:00',
-  breakEnd: '13:00',
-  weekdays: [1, 2, 3, 4, 5],
-  timezone: 'Asia/Shanghai',
+const time = (value) => Date.parse(value.includes('T') ? value : `2026-11-06T${value}:00+08:00`);
+const act = (state, at, action) => transitionHydration(state, action, time(at), 'a');
+const view = (state, at) => hydrationView(state, time(at));
+const enable = (at = '09:00', interval = 60) =>
+  act(defaultHydration(), at, { type: 'preferences', enabled: true, interval });
+const legacy = (at = '09:00', schema = 2) => {
+  const settings = {
+    timezone: 'Asia/Shanghai',
+    start: '09:00',
+    end: '18:00',
+    breakStart: '12:00',
+    breakEnd: '13:00',
+    weekdays: [1, 2, 3, 4, 5],
+    payMode: 'daily',
+    dailySalary: 1,
+  };
+  const clock = calculate(settings, time(at));
+  return {
+    schema,
+    revision: 12,
+    enabled: true,
+    interval: 60,
+    shift: {
+      id: JSON.stringify([settings.timezone, clock.shiftDate]),
+      config: JSON.stringify([
+        settings.timezone,
+        settings.start,
+        settings.end,
+        settings.breakStart,
+        settings.breakEnd,
+        settings.weekdays,
+      ]),
+      schedule: JSON.stringify([
+        settings.start,
+        settings.end,
+        settings.breakStart,
+        settings.breakEnd,
+        settings.weekdays,
+        clock.shiftStart,
+        clock.shiftEnd,
+      ]),
+      count: 7,
+      paused: false,
+      due: clock.elapsed * 1000 + 3600000,
+      sequence: 3,
+      claim: { owner: 'old', until: time(at) + 8000, sequence: 3 },
+      ...(schema === 2 ? { quietUntil: 0, recentActions: ['old-drink'] } : {}),
+    },
+  };
 };
-const time = (text) => Date.parse(text.includes('T') ? text : `2026-11-04T${text}:00+08:00`);
-const context = (text, patch = {}) => {
-  const config = { ...settings, ...patch };
-  return hydrationContext(config, calculate(config, time(text)));
-};
-const act = (s, at, a, patch = {}, owner = 'a') =>
-  transitionHydration(s, context(at, patch), a, time(at), owner);
-const view = (s, at, patch = {}) => hydrationView(s, context(at, patch), time(at));
-const enabled = (at = '09:00', interval = 60, patch = {}) =>
-  act(defaultHydration(), at, { type: 'preferences', enabled: true, interval }, patch);
-const manual = (at, id, patch = {}, extra = {}) => ({
-  type: 'manual-drink',
-  actionId: id,
-  shiftId: context(at, patch).id,
-  ...extra,
-});
-
-test('manual check-in restarts an enabled timer and retries are idempotent', () => {
-  const initial = enabled();
-  const action = manual('09:40', 'glass-1');
-  const next = act(initial, '09:40', action);
-  assert.equal(next.shift.count, 1);
-  assert.equal(view(next, '09:40').remaining, 3600000);
-  assert.deepEqual(act(next, '09:45', action), next);
-  assert.equal(initial.shift.count, 0);
-});
-
-test('manual check-ins work with reminders off, preserve pause, and ignore off-hours', () => {
-  let state = act(defaultHydration(), '10:00', manual('10:00', 'off'));
-  assert.equal(state.enabled, false);
-  assert.equal(state.shift.count, 1);
-  state = act(state, '10:00', { type: 'preferences', enabled: true });
-  state = act(state, '10:10', { type: 'pause' });
-  const due = state.shift.due;
-  state = act(state, '10:20', manual('10:20', 'paused'));
-  assert.equal(state.shift.count, 2);
-  assert.equal(state.shift.paused, true);
-  assert.equal(state.shift.due, due);
-  for (const at of ['08:00', '18:00', '2026-11-07T10:00:00+08:00']) {
-    const result = act(defaultHydration(), at, manual(at, at));
-    assert.equal(result.shift, null);
+test('manual drinking is available before work, at lunch, after work and on days off without a schedule', () => {
+  for (const at of ['08:00', '12:30', '20:00', '2026-11-07T10:00:00+08:00']) {
+    const result = act(defaultHydration(), at, { type: 'manual-drink', actionId: at });
+    assert.equal(result.count, 1);
+    assert.equal(result.enabled, false);
+    assert.equal(result.dueAt, 0);
   }
 });
-
-test('lunch check-in starts a full working interval after lunch', () => {
-  const state = act(enabled('11:00', 5), '12:30', manual('12:30', 'lunch'));
-  assert.equal(state.shift.count, 1);
-  assert.equal(view(state, '12:59').phase, 'break');
-  assert.equal(view(state, '13:00').remaining, 300000);
-  assert.equal(view(state, '13:05').phase, 'due');
-});
-
-test('manual and prompted confirmation of the same due event count once in either order', () => {
-  const initial = act(enabled(), '10:00', { type: 'claim' });
+test('manual retries deduplicate and successful records reset only an enabled, unpaused timer', () => {
+  const action = { type: 'manual-drink', actionId: 'cup' };
+  const first = act(enable(), '09:15', action);
+  assert.equal(first.dueAt, time('10:15'));
+  assert.deepEqual(act(first, '09:20', action), first);
+  const paused = act(first, '09:21', { type: 'pause' });
+  const second = act(paused, '20:00', { type: 'manual-drink', actionId: 'next' });
+  assert.equal(second.count, 2);
+  assert.equal(second.paused, true);
+  assert.equal(second.dueAt, paused.dueAt);
+});
+test('manual and prompted acknowledgments of the same overdue event count once in either order', () => {
+  const initial = act(enable(), '10:00', { type: 'claim' });
   const eventId = view(initial, '10:00').eventId;
-  const actions = [manual('10:00', 'due', {}, { eventId }), { type: 'drink', eventId }];
+  const actions = [
+    { type: 'manual-drink', actionId: 'same', eventId },
+    { type: 'drink', eventId },
+  ];
   for (const order of [actions, [...actions].reverse()]) {
-    let state = initial;
-    for (const action of order) state = act(state, '10:00', action);
-    assert.equal(state.shift.count, 1);
-    assert.equal(state.shift.claim, null);
+    const result = order.reduce((s, a) => act(s, '10:00', a), initial);
+    assert.equal(result.count, 1);
+    assert.equal(result.claim, null);
   }
 });
-
-test('manual request IDs are bounded, distinct records count, and old-shift retries cannot count tomorrow', () => {
-  let state = enabled();
+test('recent action IDs are bounded and persist across calendar dates', () => {
+  let state = defaultHydration();
   for (let i = 0; i < HYDRATION_ACTION_LIMIT + 3; i++)
-    state = act(state, '09:10', manual('09:10', String(i)));
-  assert.equal(state.shift.count, HYDRATION_ACTION_LIMIT + 3);
-  assert.equal(state.shift.recentActions.length, HYDRATION_ACTION_LIMIT);
-  assert.equal(validateHydration(state).shift.count, state.shift.count);
-  const tomorrow = act(state, '2026-11-05T09:10:00+08:00', manual('09:10', 'old'));
-  assert.equal(tomorrow.shift.count, 0);
-});
-
-test('quiet time suppresses a due prompt, keeps its work deadline, and resumes once at expiry', () => {
-  let state = act(enabled('09:00', 5), '09:05', { type: 'claim' });
-  const oldEvent = view(state, '09:05').eventId;
-  const due = state.shift.due;
-  state = act(state, '09:05', { type: 'quiet', minutes: 30 });
-  assert.equal(state.shift.due, due);
-  assert.equal(state.shift.claim, null);
-  assert.equal(view(state, '09:34').phase, 'quiet');
-  assert.equal(view(state, '09:34').quietRemaining, 60000);
-  assert.equal(act(state, '09:10', { type: 'claim' }).shift.claim, null);
-  assert.equal(act(state, '09:10', { type: 'drink', eventId: oldEvent }).shift.count, 0);
-  assert.equal(view(state, '09:35').phase, 'due');
-  const resumed = act(state, '09:35', { type: 'claim' });
-  assert.equal(resumed.shift.quietUntil, 0);
-  assert.equal(resumed.shift.claim.owner, 'a');
-  assert.equal(view(resumed, '10:30').eventId, view(resumed, '09:35').eventId);
-});
-
-test('quiet time uses natural minutes across lunch and never prompts during lunch', () => {
-  let state = act(enabled('11:00', 5), '11:50', { type: 'quiet', minutes: 30 });
-  assert.equal(view(state, '12:10').quietRemaining, 600000);
-  assert.equal(view(state, '12:20').phase, 'break');
-  assert.equal(view(state, '13:00').phase, 'due');
-  state = act(state, '12:30', manual('12:30', 'lunch-quiet'));
-  assert.equal(view(state, '13:00').remaining, 300000);
-});
-
-test('manual and quiet actions commute and a check-in does not end quiet time', () => {
-  const actions = [manual('09:10', 'concurrent'), { type: 'quiet', minutes: 30 }];
-  for (const order of [actions, [...actions].reverse()]) {
-    let state = enabled('09:00', 5);
-    for (const a of order) state = act(state, '09:10', a);
-    assert.equal(state.shift.count, 1);
-    assert.equal(state.shift.quietUntil, time('09:40'));
-    assert.equal(state.shift.due, context('09:15').elapsed);
-    assert.equal(view(state, '09:14').phase, 'quiet');
+    state = act(state, '21:00', { type: 'manual-drink', actionId: 'cup-' + i });
+  assert.equal(state.count, HYDRATION_ACTION_LIMIT + 3);
+  assert.equal(state.recentActions.length, HYDRATION_ACTION_LIMIT);
+  const tomorrow = act(state, '2026-11-07T10:00:00+08:00', { type: 'tick' });
+  assert.deepEqual(tomorrow, state);
+});
+test('quiet time does not end at the end of a work shift or at midnight', () => {
+  for (const [at, end] of [
+    ['17:50', '18:50'],
+    ['23:50', '2026-11-07T00:50:00+08:00'],
+  ]) {
+    const state = act(enable(at, 5), at, { type: 'quiet', minutes: 60 });
+    assert.equal(state.quietUntil, time(end));
+    assert.equal(view(state, new Date(time(end) - 60000).toISOString()).phase, 'quiet');
+    assert.equal(view(state, end).phase, 'due');
   }
 });
-
-test('quiet duration replaces instead of adding, and can be ended early', () => {
-  let state = act(enabled(), '09:05', { type: 'quiet', minutes: 30 });
-  state = act(state, '09:10', { type: 'quiet', minutes: 60 });
-  assert.equal(state.shift.quietUntil, time('10:10'));
-  state = act(state, '09:20', { type: 'end-quiet' });
-  assert.equal(view(state, '09:20').phase, 'countdown');
-  assert.equal(state.shift.due, 3600000);
-  for (const minutes of [0, 10, 31, 90])
-    assert.throws(() => act(enabled(), '09:10', { type: 'quiet', minutes }));
-});
-
-test('pause and disable clear quiet time, expiry never cancels a full-shift pause', () => {
-  const quiet = act(enabled(), '09:05', { type: 'quiet', minutes: 60 });
-  const paused = act(quiet, '09:10', { type: 'pause' });
-  assert.equal(paused.shift.quietUntil, 0);
-  assert.equal(view(paused, '11:00').phase, 'paused');
-  assert.equal(act(paused, '09:15', { type: 'quiet', minutes: 30 }).shift.quietUntil, 0);
-  const off = act(quiet, '09:10', { type: 'preferences', enabled: false });
-  assert.equal(off.shift.quietUntil, 0);
-  const resumed = act(paused, '09:20', { type: 'resume' });
-  assert.equal(view(resumed, '09:20').remaining, 3600000);
-});
-
-test('quiet mode ends at shift end and does not leak into another shift, including overnight', () => {
-  let state = act(enabled('17:00', 5), '17:50', { type: 'quiet', minutes: 60 });
-  assert.equal(state.shift.quietUntil, time('18:00'));
-  assert.equal(view(state, '18:00').phase, 'waiting');
-  state = act(state, '2026-11-05T09:00:00+08:00', { type: 'tick' });
-  assert.equal(state.shift.quietUntil, 0);
-  const night = { start: '22:00', end: '06:00', breakStart: '02:00', breakEnd: '03:00' };
-  let overnight = enabled('2026-11-04T22:00:00+08:00', 5, night);
-  overnight = act(overnight, '2026-11-04T23:50:00+08:00', { type: 'quiet', minutes: 30 }, night);
-  assert.equal(view(overnight, '2026-11-05T00:10:00+08:00', night).quietRemaining, 600000);
-  assert.equal(view(overnight, '2026-11-05T00:20:00+08:00', night).phase, 'due');
-});
-
-test('same-shift schedule edits preserve quiet intent, clamp to new end and reject stale manual changes', () => {
-  const state = act(enabled('17:00', 5), '17:05', { type: 'quiet', minutes: 30 });
-  const patch = { end: '17:20' };
-  const updated = act(state, '17:10', { type: 'tick', baseSchedule: state.shift.schedule }, patch);
-  assert.equal(updated.shift.quietUntil, time('17:20'));
-  assert.deepEqual(act(updated, '17:11', manual('17:11', 'stale')), updated);
-  assert.deepEqual(act(updated, '17:11', { type: 'quiet', minutes: 60 }), updated);
-});
-
-test('schema 1 migrates with preferences, count, pause and due intact while revoking the lease', () => {
-  const legacy = act(enabled('09:00', 5), '09:05', { type: 'claim' });
-  legacy.schema = 1;
-  legacy.shift.count = 7;
-  legacy.shift.paused = true;
-  delete legacy.shift.quietUntil;
-  delete legacy.shift.recentActions;
-  const upgraded = validateHydration(legacy);
-  assert.equal(upgraded.schema, 2);
-  assert.equal(upgraded.interval, 5);
-  assert.equal(upgraded.shift.count, 7);
-  assert.equal(upgraded.shift.paused, true);
-  assert.equal(upgraded.shift.due, legacy.shift.due);
-  assert.equal(upgraded.shift.claim, null);
-  assert.equal(upgraded.shift.sequence, legacy.shift.sequence + 1);
-  assert.equal(upgraded.shift.quietUntil, 0);
-  assert.deepEqual(upgraded.shift.recentActions, []);
-  assert.deepEqual(validateHydration(upgraded), upgraded);
-});
-
-test('stale pause and resume actions do not postpone a timer or pause disabled reminders', () => {
-  let state = act(enabled(), '09:10', { type: 'pause' });
-  state = act(state, '09:20', { type: 'resume' });
-  assert.deepEqual(act(state, '09:30', { type: 'resume' }), state);
-  state = act(state, '09:30', { type: 'preferences', enabled: false });
-  assert.deepEqual(act(state, '09:40', { type: 'pause' }), state);
-});
-
-test('malformed new fields and malformed legacy data are rejected', () => {
+test('quiet operations invalidate old reminders; a successful drink keeps the chosen quiet deadline', () => {
+  let state = act(enable(), '10:00', { type: 'claim' });
+  const eventId = view(state, '10:00').eventId;
+  state = act(state, '10:00', { type: 'quiet', minutes: 30 });
+  assert.equal(state.claim, null);
+  assert.equal(act(state, '10:01', { type: 'drink', eventId }).count, 0);
+  state = act(state, '10:10', { type: 'manual-drink', actionId: 'quiet-cup' });
+  assert.equal(state.count, 1);
+  assert.equal(state.quietUntil, time('10:30'));
+  assert.equal(state.dueAt, time('11:10'));
+  const ended = act(state, '10:11', { type: 'end-quiet' });
+  assert.equal(ended.quietUntil, 0);
+  assert.equal(ended.dueAt, state.dueAt);
+});
+test('pause and disable end quiet time, while resume starts a full interval', () => {
+  const state = act(enable(), '09:10', { type: 'quiet', minutes: 60 });
+  const paused = act(state, '09:20', { type: 'pause' });
+  assert.equal(paused.quietUntil, 0);
+  assert.equal(act(paused, '09:21', { type: 'quiet', minutes: 30 }).quietUntil, 0);
+  assert.equal(act(state, '09:20', { type: 'preferences', enabled: false }).quietUntil, 0);
+  assert.equal(act(paused, '22:00', { type: 'resume' }).dueAt, time('23:00'));
+  assert.throws(() => act(enable(), '09:00', { type: 'quiet', minutes: 20 }));
+});
+for (const schema of [1, 2])
+  test(`schema ${schema} migration retains preferences/count and converts a matching shift remainder once`, () => {
+    const old = legacy('09:00', schema),
+      snapshot = structuredClone(old);
+    const now = time('09:20');
+    const next = migrateHydration(old, now);
+    assert.equal(next.schema, 3);
+    assert.equal(next.count, 7);
+    assert.equal(next.enabled, true);
+    assert.equal(next.interval, 60);
+    assert.equal(next.dueAt, time('10:00'));
+    assert.equal(next.claim, null);
+    assert.ok(next.sequence > old.shift.sequence);
+    assert.deepEqual(next.recentActions, schema === 2 ? ['old-drink'] : []);
+    assert.deepEqual(old, snapshot);
+    assert.deepEqual(validateHydration(JSON.parse(JSON.stringify(next))), next);
+  });
+test('migration turns remaining paid minutes during lunch into natural minutes without losing quiet settings', () => {
+  const old = legacy('11:50');
+  old.shift.quietUntil = time('13:30');
+  const next = migrateHydration(old, time('12:20'));
+  assert.equal(next.dueAt, time('13:10'));
+  assert.equal(next.quietUntil, time('13:30'));
+  assert.equal(next.count, 7);
+});
+test('migration preserves an already-overdue event; old-day records and pause retain counts without guessing past drinks', () => {
+  assert.equal(migrateHydration(legacy(), time('10:30')).dueAt, time('10:30'));
+  const old = legacy();
+  old.shift.paused = true;
+  const paused = migrateHydration(old, time('2026-11-07T10:00:00+08:00'));
+  assert.equal(paused.paused, true);
+  assert.equal(paused.count, 7);
+  assert.equal(view(paused, '2026-11-07T10:00:00+08:00').phase, 'paused');
+  old.shift.paused = false;
+  const next = migrateHydration(old, time('2026-11-07T10:00:00+08:00'));
+  assert.equal(next.count, 7);
+  assert.equal(next.dueAt, time('2026-11-07T11:00:00+08:00'));
+});
+test('legacy malformed/future data is rejected; incomplete historical schedule text retains records with a full new interval', () => {
   for (const patch of [
-    { quietUntil: -1 },
-    { quietUntil: NaN },
-    { recentActions: null },
-    { recentActions: ['same', 'same'] },
-    { recentActions: Array.from({ length: 65 }, (_, i) => String(i)) },
-  ]) {
-    const state = enabled();
-    Object.assign(state.shift, patch);
-    assert.throws(() => validateHydration(state));
-  }
-  const legacy = enabled();
-  legacy.schema = 1;
-  assert.throws(() => validateHydration(legacy));
+    { schema: 99 },
+    { revision: -1 },
+    { interval: 1 },
+    { enabled: 0 },
+    { shift: {} },
+    { other: true },
+  ])
+    assert.throws(() => migrateHydration({ ...legacy(), ...patch }, time('09:00')));
+  const old = legacy();
+  old.shift.config = 'unavailable old schedule';
+  const next = migrateHydration(old, time('09:20'));
+  assert.equal(next.count, 7);
+  assert.equal(next.dueAt, time('10:20'));
 });