dsh-offwork 1.0.1 → 1.1.0

package/tests/companion.test.mjs

@@ -0,0 +1,86 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { companionPresentation, COMPANION_MESSAGES } from '../companion.js';
+import { normalizeView } from '../ui-utils.js';
+const show = (patch = {}) =>
+  companionPresentation({ workStatus: 'working', phase: 'countdown', ...patch });
+const drink = { kind: 'drink', key: 'waterRecorded', token: 12 };
+
+test('only a leased due reminder changes the character to a drinking pose; it adds no second message', () => {
+  const elsewhere = show({ phase: 'due', ownsPrompt: false });
+  assert.equal(elsewhere.pose, 'calm');
+  assert.equal(elsewhere.announce, false);
+  const here = show({ phase: 'due', ownsPrompt: true });
+  assert.equal(here.pose, 'drink');
+  assert.equal(here.message, null);
+  assert.equal(here.announce, false);
+});
+
+test('explicit drink feedback is acknowledged once; quiet and break states never celebrate or animate', () => {
+  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' },
+  ]) {
+    const result = show({ ...patch, feedback: drink });
+    assert.equal(result.animate, false);
+    assert.equal(result.message, 'waterRecorded');
+  }
+  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);
+});
+
+test('hidden character, hidden page, reduced animation preference and unavailable state suppress reactions', () => {
+  const hidden = show({ visible: false, feedback: drink });
+  assert.equal(hidden.visible, false);
+  assert.equal(hidden.message, null);
+  assert.equal(hidden.announce, false);
+  assert.equal(show({ pageVisible: false, feedback: drink }).animate, false);
+  assert.equal(show({ motion: false, feedback: drink }).animate, false);
+  const failed = show({ failed: true, feedback: drink });
+  assert.equal(failed.message, 'companionUnavailable');
+  assert.equal(failed.announce, false);
+  assert.equal(failed.animate, false);
+  assert.equal(show({ ready: false, feedback: drink }).message, 'companionLoading');
+});
+
+test('quiet, paused and work states have stable localized messages with no automatic announcements', () => {
+  const cases = [
+    { phase: 'quiet' },
+    { phase: 'paused' },
+    { workStatus: 'lunch' },
+    { workStatus: 'rest' },
+    { workStatus: 'done' },
+    { workStatus: 'before' },
+    { phase: 'off' },
+    {},
+  ];
+  for (const input of cases) {
+    const result = show(input);
+    assert.equal(result.announce, false);
+    assert.equal(result.animate, false);
+    for (const lang of ['zh', 'en']) assert.ok(COMPANION_MESSAGES[lang][result.message]);
+    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');
+});
+
+test('existing view data keeps its position, privacy and opacity while explicit companion opt-out survives reload', () => {
+  const old = { mini: false, masked: true, opacity: 0.6, position: { x: 34, y: 56 } };
+  const migrated = normalizeView(old);
+  for (const key of Object.keys(old)) assert.deepEqual(migrated[key], old[key]);
+  assert.equal(migrated.companion, true);
+  const off = { ...migrated, companion: false, companionMotion: false };
+  assert.deepEqual(normalizeView(JSON.parse(JSON.stringify(off))), off);
+  assert.equal(normalizeView({ ...off, companion: true }).companionMotion, false);
+});

package/tests/hydration-extras.test.mjs

@@ -0,0 +1,226 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { calculate } from '../clock.js';
+import {
+  defaultHydration,
+  validateHydration,
+  hydrationContext,
+  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 = (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('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' });
+  const eventId = view(initial, '10:00').eventId;
+  const actions = [manual('10:00', 'due', {}, { 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);
+  }
+});
+
+test('manual request IDs are bounded, distinct records count, and old-shift retries cannot count tomorrow', () => {
+  let state = enabled();
+  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');
+  }
+});
+
+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', () => {
+  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));
+});

package/tests/hydration-store.test.mjs

@@ -0,0 +1,287 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { IDBFactory } from 'fake-indexeddb';
+import { createHydrationStore } from '../hydration-store.js';
+import { calculate } from '../clock.js';
+import {
+  defaultHydration,
+  hydrationContext,
+  hydrationView,
+  transitionHydration,
+} 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 begin = Date.parse('2026-11-04T09:00:00+08:00');
+const due = begin + 3600000;
+const context = (at, patch = {}) => {
+  const config = { ...settings, ...patch };
+  return hydrationContext(config, calculate(config, at));
+};
+const read = (store) => store.update((state) => state);
+const fixture = (t) => {
+  const indexedDB = new IDBFactory();
+  const first = createHydrationStore(indexedDB);
+  const second = createHydrationStore(indexedDB);
+  t.after(() => {
+    first.close();
+    second.close();
+  });
+  return { indexedDB, first, second };
+};
+const seed = (store) =>
+  store.update((state) =>
+    transitionHydration(
+      state,
+      context(begin),
+      { type: 'preferences', enabled: true, interval: 60 },
+      begin,
+      'a',
+    ),
+  );
+const rawWrite = (indexedDB, state) =>
+  new Promise((resolve, reject) => {
+    const request = indexedDB.open('dsh.offwork-clock.hydration.v1', 1);
+    request.onsuccess = () => {
+      const db = request.result;
+      const transaction = db.transaction('state', 'readwrite');
+      transaction.objectStore('state').put(state, 'current');
+      transaction.oncomplete = () => {
+        db.close();
+        resolve();
+      };
+      transaction.onabort = () => {
+        db.close();
+        reject(transaction.error);
+      };
+    };
+    request.onerror = () => reject(request.error);
+  });
+
+test('read-only first load does not create a default record; committed state survives reopening', async (t) => {
+  const { indexedDB, first } = fixture(t);
+  assert.deepEqual(await read(first), defaultHydration());
+  const state = await seed(first);
+  first.close();
+  const reopened = createHydrationStore(indexedDB);
+  t.after(() => reopened.close());
+  assert.deepEqual(await read(reopened), state);
+  assert.ok(state.revision > 0);
+});
+
+test('transactions serialize competing claims and duplicate processing across connections', async (t) => {
+  const { first, second } = fixture(t);
+  await seed(first);
+  await Promise.all([
+    first.update((s) => transitionHydration(s, context(due), { type: 'claim' }, due, 'a')),
+    second.update((s) => transitionHydration(s, context(due), { type: 'claim' }, due, 'b')),
+  ]);
+  const claimed = await read(first);
+  const owner = claimed.shift.claim.owner;
+  const eventId = hydrationView(claimed, context(due)).eventId;
+  await Promise.all(
+    [first, second].map((store) =>
+      store.update((s) =>
+        transitionHydration(s, context(due), { type: 'drink', eventId }, due, owner),
+      ),
+    ),
+  );
+  assert.equal((await read(first)).shift.count, 1);
+  assert.deepEqual(await read(first), await read(second));
+});
+
+test('stale tabs cannot revert a changed schedule with tick, release, pause, or clear actions', async (t) => {
+  const { first, second } = fixture(t);
+  await seed(first);
+  const initial = await read(first);
+  const current = await first.update((s) =>
+    transitionHydration(
+      s,
+      context(due, { end: '19:00' }),
+      { type: 'tick', baseSchedule: initial.shift.schedule },
+      due,
+      'a',
+    ),
+  );
+  assert.notEqual(current.shift.schedule, initial.shift.schedule);
+  for (const type of ['tick', 'claim', 'release', 'pause', 'resume', 'clear-count']) {
+    await second.update((s) => transitionHydration(s, context(due), { type }, due, 'b'));
+    assert.deepEqual(await read(first), current, type);
+  }
+  // Even a newly opened stale tab cannot revert a timezone change that changes the shift id.
+  const timezone = await first.update((s) =>
+    transitionHydration(
+      s,
+      context(due, { timezone: 'UTC', end: '19:00' }),
+      { type: 'tick', baseSchedule: current.shift.schedule },
+      due,
+      'a',
+    ),
+  );
+  await second.update((s) => transitionHydration(s, context(due), { type: 'tick' }, due, 'b'));
+  assert.deepEqual(await read(first), timezone);
+});
+
+test('a tab without Host settings cannot erase another tab claim', async (t) => {
+  const { first, second } = fixture(t);
+  await seed(first);
+  const claimed = await first.update((s) =>
+    transitionHydration(s, context(due), { type: 'claim' }, due, 'a'),
+  );
+  await second.update((s) => transitionHydration(s, null, { type: 'release' }, due, 'b'));
+  assert.deepEqual(await read(first), claimed);
+  await first.update((s) => transitionHydration(s, null, { type: 'release' }, due, 'a'));
+  assert.equal((await read(first)).shift.claim, null);
+});
+
+test('explicit reset is monotonic and unknown data is rejected without overwriting', async (t) => {
+  const { indexedDB, first, second } = fixture(t);
+  await seed(first);
+  await rawWrite(indexedDB, { schema: 99, revision: 40 });
+  await assert.rejects(read(second), /Invalid hydration data/);
+  const reset = await first.update(() => defaultHydration(), { reset: true });
+  assert.equal(reset.revision, 41);
+  assert.equal(reset.enabled, false);
+  assert.equal(reset.shift, null);
+  assert.deepEqual(await read(second), reset);
+});
+
+test('mutating reducers and aborting reducers cannot silently lose or partially commit updates', async (t) => {
+  const { first } = fixture(t);
+  await seed(first);
+  const state = await first.update((s) => {
+    s.interval = 30;
+    return s;
+  });
+  assert.equal((await read(first)).interval, 30);
+  await assert.rejects(
+    first.update((s) => {
+      s.interval = 10;
+      throw new Error('abort');
+    }),
+    /abort/,
+  );
+  assert.deepEqual(await read(first), state);
+});
+
+test('partial preference updates preserve changes made by another connection', async (t) => {
+  const { first, second } = fixture(t);
+  await seed(first);
+  await first.update((s) =>
+    transitionHydration(s, context(begin), { type: 'preferences', interval: 30 }, begin, 'a'),
+  );
+  await second.update((s) =>
+    transitionHydration(s, context(begin), { type: 'preferences', enabled: false }, begin, 'b'),
+  );
+  const state = await read(first);
+  assert.equal(state.interval, 30);
+  assert.equal(state.enabled, false);
+});
+
+test('transient opening errors recover and unavailable storage rejects explicitly', async () => {
+  let calls = 0;
+  const indexedDB = new IDBFactory();
+  const store = createHydrationStore({
+    open(...args) {
+      if (++calls === 1) throw new Error('temporary');
+      return indexedDB.open(...args);
+    },
+  });
+  await assert.rejects(read(store), /temporary/);
+  assert.deepEqual(await read(store), defaultHydration());
+  assert.equal(calls, 2);
+  store.close();
+  const unavailable = createHydrationStore(null);
+  await assert.rejects(read(unavailable), /unavailable/);
+  unavailable.close();
+});
+
+test('legacy records migrate atomically once without losing user data', async (t) => {
+  const { indexedDB, first, second } = fixture(t);
+  const legacy = await seed(first);
+  legacy.schema = 1;
+  legacy.revision = 40;
+  legacy.interval = 5;
+  legacy.shift.count = 9;
+  legacy.shift.paused = true;
+  delete legacy.shift.quietUntil;
+  delete legacy.shift.recentActions;
+  await rawWrite(indexedDB, legacy);
+  const [a, b] = await Promise.all([read(first), read(second)]);
+  assert.equal(a.schema, 2);
+  assert.equal(a.revision, 41);
+  assert.deepEqual(a, b);
+  assert.equal(a.interval, 5);
+  assert.equal(a.shift.count, 9);
+  assert.equal(a.shift.paused, true);
+  assert.equal(a.shift.due, legacy.shift.due);
+  assert.deepEqual(await read(second), a);
+});
+
+test('concurrent check-ins deduplicate the same ID but retain independent IDs', async (t) => {
+  const { first, second } = fixture(t);
+  await seed(first);
+  const record = (store, id) =>
+    store.update((s) =>
+      transitionHydration(
+        s,
+        context(begin),
+        {
+          type: 'manual-drink',
+          actionId: id,
+          shiftId: context(begin).id,
+        },
+        begin,
+        'a',
+      ),
+    );
+  await Promise.all([record(first, 'same'), record(second, 'same')]);
+  assert.equal((await read(first)).shift.count, 1);
+  await Promise.all([record(first, 'one'), record(second, 'two')]);
+  assert.equal((await read(first)).shift.count, 3);
+});
+
+test('exhausted revisions abort an update instead of persisting invalid data', async (t) => {
+  const { indexedDB, first } = fixture(t);
+  const current = await seed(first);
+  current.revision = Number.MAX_SAFE_INTEGER;
+  await rawWrite(indexedDB, current);
+  await assert.rejects(
+    first.update((s) => ({ ...s, interval: 5 })),
+    /revision exhausted/,
+  );
+  assert.deepEqual(await read(first), current);
+});
+
+test('quiet and manual actions preserve each other across connections', async (t) => {
+  const { first, second } = fixture(t);
+  await seed(first);
+  await Promise.all([
+    first.update((s) =>
+      transitionHydration(s, context(begin), { type: 'quiet', minutes: 30 }, begin, 'a'),
+    ),
+    second.update((s) =>
+      transitionHydration(
+        s,
+        context(begin),
+        { type: 'manual-drink', actionId: 'cup', shiftId: context(begin).id },
+        begin,
+        'b',
+      ),
+    ),
+  ]);
+  const state = await read(first);
+  assert.equal(state.shift.count, 1);
+  assert.equal(state.shift.quietUntil, begin + 1800000);
+  assert.equal(hydrationView(state, context(begin), begin).phase, 'quiet');
+  assert.deepEqual(await read(second), state);
+});