dsh-offwork 1.0.0 → 1.1.0

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);
+});

package/tests/hydration.test.mjs

@@ -0,0 +1,211 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { calculate } from '../clock.js';
+import {
+  defaultHydration,
+  validateHydration,
+  hydrationContext,
+  reconcileHydration,
+  hydrationView,
+  transitionHydration,
+  HYDRATION_LEASE_MS,
+} from '../hydration.js';
+
+const settings = {
+  payMode: 'monthly',
+  monthlySalary: 12000,
+  dailySalary: 600,
+  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 = (state, at, action, patch = {}, owner = 'tab-a') =>
+  transitionHydration(state, context(at, patch), action, time(at), owner);
+const enable = (at = '09:00', interval = 60, patch = {}) =>
+  act(defaultHydration(), at, { type: 'preferences', enabled: true, interval }, patch);
+const view = (state, at, patch = {}) =>
+  hydrationView(reconcileHydration(state, context(at, patch)), context(at, patch), time(at));
+const claim = (state, at, patch = {}, owner = 'tab-a') =>
+  act(state, at, { type: 'claim' }, patch, owner);
+
+test('off by default; enabling mid-shift starts a full interval, not catch-up', () => {
+  assert.equal(view(defaultHydration(), '11:45').phase, 'off');
+  const state = enable('10:15');
+  assert.equal(view(state, '10:15').remaining, 3600000);
+  assert.equal(view(state, '11:14').phase, 'countdown');
+  assert.equal(view(state, '11:15').phase, 'due');
+});
+
+for (const interval of [5, 15, 17, 30, 45, 60, 90, 120, 240]) {
+  test(`saving ${interval} minutes applies that interval instead of the 60-minute default`, () => {
+    const initial = enable('09:00');
+    const saved = act(initial, '09:10', { type: 'preferences', enabled: true, interval });
+    assert.equal(saved.interval, interval);
+    const elapsed = context('09:10').elapsed;
+    // Saving an unchanged 60-minute interval keeps the existing cycle.
+    const anchor = interval === 60 ? 0 : elapsed;
+    assert.equal(saved.shift.due, anchor + interval * 60000);
+    const reopened = validateHydration(JSON.parse(JSON.stringify(saved)));
+    assert.equal(reopened.interval, interval);
+    const deadline =
+      time('09:00') + saved.shift.due + (saved.shift.due >= 3 * 3600000 ? 3600000 : 0);
+    const before = hydrationContext(settings, calculate(settings, deadline - 1));
+    const atDue = hydrationContext(settings, calculate(settings, deadline));
+    assert.equal(hydrationView(reopened, before).phase, 'countdown');
+    assert.equal(hydrationView(reopened, atDue).phase, 'due');
+  });
+}
+
+test('break freezes working-time countdown; snooze crosses break', () => {
+  const state = enable('11:10');
+  assert.equal(view(state, '12:00').phase, 'break');
+  assert.equal(view(state, '12:50').remaining, 600000);
+  assert.equal(view(state, '13:10').phase, 'due');
+  let snoozed = claim(enable('10:58'), '11:58');
+  snoozed = act(snoozed, '11:58', { type: 'snooze', eventId: view(snoozed, '11:58').eventId });
+  assert.equal(view(snoozed, '12:30').remaining, 480000);
+  assert.equal(view(snoozed, '13:07').phase, 'countdown');
+  assert.equal(view(snoozed, '13:08').phase, 'due');
+  assert.equal(snoozed.shift.count, 0);
+});
+
+test('completion is idempotent and schedules from actual click, not old due time', () => {
+  let state = claim(enable(), '10:03');
+  const eventId = view(state, '10:03').eventId;
+  state = act(state, '10:03', { type: 'drink', eventId });
+  state = act(state, '10:03', { type: 'drink', eventId });
+  assert.equal(state.shift.count, 1);
+  assert.equal(view(state, '11:02').phase, 'countdown');
+  assert.equal(view(state, '11:03').phase, 'due');
+});
+
+test('hours of missed ticks yield a single stable event; shift end discards it', () => {
+  const state = enable();
+  assert.equal(view(state, '10:00').eventId, view(state, '17:30').eventId);
+  assert.equal(view(state, '17:30').phase, 'due');
+  assert.equal(view(state, '18:00').phase, 'waiting');
+  assert.equal(view(state, '2026-11-07T11:00:00+08:00').phase, 'waiting');
+});
+
+test('pause persists through overnight midnight and resets at a new shift', () => {
+  const night = { start: '22:00', end: '06:00', breakStart: '02:00', breakEnd: '03:00' };
+  let state = enable('2026-11-06T22:00:00+08:00', 60, night);
+  state = act(state, '2026-11-06T23:00:00+08:00', { type: 'pause' }, night);
+  assert.equal(view(state, '2026-11-07T01:00:00+08:00', night).phase, 'paused');
+  assert.equal(view(state, '2026-11-07T22:00:00+08:00', night).phase, 'waiting');
+  const next = reconcileHydration(state, context('2026-11-09T22:00:00+08:00', night));
+  assert.equal(hydrationView(next, context('2026-11-09T22:00:00+08:00', night)).phase, 'countdown');
+  assert.equal(next.shift.paused, false);
+});
+
+test('resume and interval changes restart; count reset does not alter timer', () => {
+  let state = claim(enable(), '10:00');
+  state = act(state, '10:00', { type: 'drink', eventId: view(state, '10:00').eventId });
+  const due = state.shift.due;
+  state = act(state, '10:10', { type: 'clear-count' });
+  assert.equal(state.shift.count, 0);
+  assert.equal(state.shift.due, due);
+  state = act(state, '10:10', { type: 'pause' });
+  state = act(state, '10:40', { type: 'resume' });
+  assert.equal(view(state, '10:40').remaining, 3600000);
+  state = act(state, '10:50', { type: 'preferences', enabled: true, interval: 5 });
+  assert.equal(view(state, '10:50').remaining, 300000);
+  assert.equal(view(state, '10:55').phase, 'due');
+});
+
+test('schedule changes retain same-shift count and pause; pay changes do not reschedule', () => {
+  let state = claim(enable(), '10:00');
+  state = act(state, '10:00', { type: 'drink', eventId: view(state, '10:00').eventId });
+  const oldDue = state.shift.due;
+  assert.equal(
+    reconcileHydration(state, context('10:30', { monthlySalary: 15000 })).shift.due,
+    oldDue,
+  );
+  state = act(state, '10:30', { type: 'pause' });
+  const shifted = reconcileHydration(state, context('10:45', { end: '19:00' }));
+  assert.equal(shifted.shift.count, 1);
+  assert.equal(shifted.shift.paused, true);
+  assert.equal(shifted.shift.due - context('10:45', { end: '19:00' }).elapsed, 3600000);
+});
+
+test('only the current lease owner can process a live event; expired lease is transferred', () => {
+  let state = claim(enable(), '10:00');
+  const eventId = view(state, '10:00').eventId;
+  state = claim(state, '10:00', {}, 'tab-b');
+  assert.equal(state.shift.claim.owner, 'tab-a');
+  assert.equal(act(state, '10:00', { type: 'drink', eventId }, {}, 'tab-b').shift.count, 0);
+  const at = time('10:00') + HYDRATION_LEASE_MS + 1;
+  const ctx = hydrationContext(settings, calculate(settings, at));
+  state = transitionHydration(state, ctx, { type: 'claim' }, at, 'tab-b');
+  assert.equal(state.shift.claim.owner, 'tab-b');
+  assert.equal(
+    transitionHydration(state, ctx, { type: 'drink', eventId }, at, 'tab-a').shift.count,
+    0,
+  );
+  assert.equal(
+    transitionHydration(state, ctx, { type: 'drink', eventId }, at, 'tab-b').shift.count,
+    1,
+  );
+});
+
+test('release, disabled settings and break boundaries remove a displayed lease', () => {
+  let state = claim(enable(), '10:00');
+  assert.equal(act(state, '10:00', { type: 'release' }).shift.claim, null);
+  assert.equal(
+    act(state, '10:00', { type: 'preferences', enabled: false, interval: 60 }).shift.claim,
+    null,
+  );
+  state = claim(enable('11:00'), '11:59');
+  assert.equal(reconcileHydration(state, context('12:00')).shift.claim, null);
+  assert.deepEqual(act(state, '12:00', { type: 'reset' }), defaultHydration());
+});
+
+test('at exact shift end there is no reminder; first opening tomorrow starts fresh', () => {
+  const state = enable('17:00');
+  assert.equal(view(state, '17:00').phase, 'finished');
+  assert.notEqual(view(state, '18:00').phase, 'due');
+  assert.equal(view(state, '2026-11-05T10:25:00+08:00').remaining, 3600000);
+});
+
+test('DST forward and backward transitions count actual paid elapsed time', () => {
+  const patch = {
+    timezone: 'America/New_York',
+    start: '22:00',
+    end: '06:00',
+    breakStart: '00:00',
+    breakEnd: '00:00',
+    weekdays: [6],
+  };
+  const spring = enable('2026-03-08T06:30:00Z', 60, patch);
+  assert.equal(view(spring, '2026-03-08T07:00:00Z', patch).remaining, 1800000);
+  assert.equal(view(spring, '2026-03-08T07:30:00Z', patch).phase, 'due');
+  const fall = enable('2026-11-01T05:30:00Z', 60, patch);
+  assert.equal(view(fall, '2026-11-01T06:30:00Z', patch).phase, 'due');
+});
+
+test('malformed data, unknown schemas and invalid preferences fail closed', () => {
+  for (const data of [
+    null,
+    {},
+    [],
+    { ...defaultHydration(), schema: 99 },
+    ,
+    { ...defaultHydration(), interval: 0 },
+    { ...defaultHydration(), shift: {} },
+  ]) {
+    assert.throws(() => validateHydration(data));
+  }
+  for (const interval of [0, 4, 241, 5.5, NaN]) assert.throws(() => enable('09:00', interval));
+  const state = enable();
+  assert.deepEqual(validateHydration(state), state);
+  assert.equal(hydrationView(state, null).phase, 'waiting');
+});

package/tests/pet-character.test.mjs

@@ -0,0 +1,56 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { petLayout, petModel, petArtwork } from '../pet-view.js';
+import { normalizeView } from '../ui-utils.js';
+
+test('existing preferences gain the long dress without losing privacy, position or motion choices', () => {
+  const old = {
+    masked: true,
+    companion: false,
+    companionMotion: false,
+    petSize: 148,
+    petPosition: { x: 300, y: 400 },
+    opacity: 0.7,
+  };
+  const next = normalizeView(old);
+  assert.equal(next.petModel, 'whale-dress');
+  for (const k of Object.keys(old)) assert.deepEqual(next[k], old[k]);
+  for (const id of ['whale-dress', 'whale-ornate', 'xiaoxie-original'])
+    assert.equal(normalizeView({ ...next, petModel: id }).petModel, id);
+  for (const id of ['unknown', '__proto__', 'toString']) {
+    assert.equal(normalizeView({ petModel: id }).petModel, 'whale-dress');
+    assert.equal(petModel(id).id, 'whale-dress');
+  }
+});
+test('portrait layout fits the complete figure and badge in narrow, short and offset viewports', () => {
+  for (const id of ['whale-dress', 'whale-ornate'])
+    for (const size of [80, 132, 180])
+      for (const viewport of [
+        { width: 1440, height: 1000 },
+        { width: 320, height: 568 },
+        { width: 640, height: 320 },
+        { width: 240, height: 180, left: 50, top: 200 },
+      ]) {
+        const p = petLayout({ x: 9999, y: 9999 }, viewport, size, 420, id),
+          m = petModel(id);
+        assert.ok(p.x >= (viewport.left ?? 0) && p.y >= (viewport.top ?? 0));
+        assert.ok(p.x + p.petWidth <= (viewport.left ?? 0) + viewport.width);
+        assert.ok(p.y + p.petHeight <= (viewport.top ?? 0) + viewport.height);
+        assert.ok(p.artworkSize * m.widthScale <= p.petWidth);
+        assert.ok(p.artworkSize * m.heightScale + 26 <= p.petHeight);
+      }
+});
+test('portrait uses an inert image with proportional dimensions; missing resource retains the SVG fallback', () => {
+  const h = (type, props, ...children) => ({ type, props, children }),
+    presentation = { pose: 'drink', animate: true };
+  const im = petArtwork(h, presentation, 132, 'event-1', 'whale-dress', {
+    'whale-dress': 'data:image/webp;base64,test',
+  });
+  assert.equal(im.type, 'img');
+  assert.equal(im.props.draggable, false);
+  assert.equal(im.props['aria-hidden'], true);
+  assert.equal(im.props.width / im.props.height, 640 / 1024);
+  assert.equal(im.props['data-animate'], true);
+  assert.equal(petArtwork(h, presentation, 132, '', 'whale-dress', {}).type, 'svg');
+  assert.equal(petArtwork(h, presentation, 132, '', 'xiaoxie-original', {}).type, 'svg');
+});

package/tests/pet-interactions.test.mjs

@@ -0,0 +1,88 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { initialPetUI, petUIReducer, appearanceValues } from '../pet-interactions.js';
+const go = (s, screen, extra = {}) => petUIReducer(s, { type: 'navigate', screen, ...extra });
+
+test('one screen is active and editor navigation retains a predictable parent', () => {
+  let s = go(initialPetUI, 'home');
+  s = go(s, 'income');
+  s = go(s, 'water');
+  assert.equal(s.screen, 'water');
+  assert.equal(s.back, 'income');
+  s = go(s, 'appearance');
+  assert.equal(s.back, 'income');
+  s = go(s, s.back);
+  assert.equal(s.screen, 'income');
+  s = go(s, null);
+  assert.equal(s.screen, null);
+  assert.equal(go(initialPetUI, 'appearance').back, null);
+});
+test('dirty navigation preserves the editor until save or explicit discard', () => {
+  const editing = go(go(initialPetUI, 'home'), 'water');
+  const blocked = go(editing, 'appearance', { dirty: true });
+  assert.equal(blocked.screen, 'water');
+  assert.deepEqual(blocked.pending, { screen: 'appearance' });
+  assert.equal(petUIReducer(blocked, { type: 'stay' }).screen, 'water');
+  const discarded = go(blocked, blocked.pending.screen, { discard: true });
+  assert.equal(discarded.screen, 'appearance');
+  assert.equal(discarded.pending, null);
+  const close = go(editing, null, { dirty: true });
+  assert.deepEqual(close.pending, { screen: null });
+  assert.equal(close.screen, 'water');
+  assert.equal(go(close, null, { discard: true }).screen, null);
+});
+test('context menu does not navigate or destroy the pending editor state', () => {
+  const original = go(go(initialPetUI, 'home'), 'schedule');
+  const menu = petUIReducer(original, { type: 'menu', position: { x: 20, y: 30 } });
+  assert.equal(menu.screen, 'schedule');
+  assert.equal(menu.back, 'home');
+  assert.deepEqual(petUIReducer(menu, { type: 'dismiss-menu' }), original);
+  assert.equal(go(menu, 'appearance', { dirty: true }).menu, null);
+  assert.deepEqual(original, go(go(initialPetUI, 'home'), 'schedule'));
+});
+test('reopening the current page preserves drafts and unsupported navigation is ignored', () => {
+  const s = go(go(initialPetUI, 'home'), 'water');
+  assert.deepEqual(go(s, 'water', { dirty: true }), s);
+  assert.equal(go(s, 'unknown'), s);
+});
+test('menu cards are independent roots while reminder settings return only to water', () => {
+  const water = go(initialPetUI, 'home', { root: true });
+  const settings = go(water, 'water');
+  assert.equal(settings.back, 'home');
+  const clock = go(settings, 'income', { root: true, discard: true });
+  assert.equal(clock.back, null);
+  const appearance = go(clock, 'appearance', { root: true });
+  assert.equal(appearance.back, null);
+  assert.equal(go(appearance, appearance.back).screen, null);
+  assert.equal(go(initialPetUI, 'earnings', { root: true }).screen, 'earnings');
+});
+test('dirty navigation retains the root destination for explicit save or discard', () => {
+  const settings = go(go(initialPetUI, 'home'), 'water');
+  const pending = go(settings, 'appearance', { root: true, dirty: true });
+  assert.deepEqual(pending.pending, { screen: 'appearance', root: true });
+  const next = go(pending, pending.pending.screen, { root: pending.pending.root, discard: true });
+  assert.equal(next.back, null);
+  assert.equal(next.screen, 'appearance');
+});
+
+test('appearance snapshots omit position and salary preferences', () => {
+  assert.deepEqual(
+    appearanceValues({
+      companion: true,
+      companionMotion: false,
+      petSize: 132,
+      petModel: 'whale-ornate',
+      opacity: 0.8,
+      position: { x: 1, y: 2 },
+      petPosition: { x: 3, y: 4 },
+      masked: false,
+    }),
+    {
+      companion: true,
+      companionMotion: false,
+      petSize: 132,
+      petModel: 'whale-ornate',
+      opacity: 0.8,
+    },
+  );
+});