dsh-offwork 1.1.1 → 1.2.2

package/settings-api.js

@@ -0,0 +1,126 @@
+import { mkdir, readFile, writeFile, rename, unlink } from 'node:fs/promises';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+export const SETTINGS_ROUTE = '/offwork-clock/settings';
+export function createSettingsAccess(directory) {
+  const file = join(directory, 'agent-access.json');
+  let queue = Promise.resolve();
+  return {
+    async get() {
+      try {
+        const value = JSON.parse(await readFile(file, 'utf8'));
+        if (value.schema !== 1 || typeof value.allowed !== 'boolean')
+          throw new Error('Invalid access policy');
+        return value.allowed;
+      } catch (error) {
+        if (error.code === 'ENOENT') return false;
+        throw error;
+      }
+    },
+    set(allowed) {
+      const result = queue.then(async () => {
+        if (typeof allowed !== 'boolean') throw new Error('Invalid access policy');
+        await mkdir(directory, { recursive: true, mode: 0o700 });
+        const temp = join(directory, `.access-${randomUUID()}.tmp`);
+        try {
+          await writeFile(temp, JSON.stringify({ schema: 1, allowed }), {
+            mode: 0o600,
+            flag: 'wx',
+          });
+          await rename(temp, file);
+        } finally {
+          await unlink(temp).catch(() => {});
+        }
+        return allowed;
+      });
+      queue = result.catch(() => {});
+      return result;
+    },
+  };
+}
+
+// Served under the Harness host's existing access boundary. Never enables CORS.
+// A custom header is required even for GET; cross-origin browsers cannot send it
+// without a successful preflight. Same-site subdomains are not trusted.
+export function createSettingsHandler(operate, access, authorize = () => 401) {
+  return async (req, res) => {
+    const send = (status, body) => {
+      if (res.destroyed || res.writableEnded) return;
+      res.writeHead(status, {
+        'Content-Type': 'application/json; charset=utf-8',
+        'Cache-Control': 'no-store',
+        'X-Content-Type-Options': 'nosniff',
+      });
+      res.end(JSON.stringify(body));
+    };
+    if (!['GET', 'POST'].includes(req.method))
+      return send(405, { ok: false, error: 'Method not allowed' });
+    const site = req.headers['sec-fetch-site'];
+    let originOK = true;
+    if (req.headers.origin) {
+      try {
+        originOK = new URL(req.headers.origin).host === req.headers.host;
+      } catch {
+        originOK = false;
+      }
+    }
+    if (
+      req.headers['x-offwork-client'] !== '1' ||
+      (site && !['same-origin', 'none'].includes(site)) ||
+      !originOK
+    )
+      return send(403, { ok: false, error: 'Same-origin client required' });
+    const rejection = authorize(req);
+    if (rejection) return send(rejection, { ok: false, error: 'Authenticated owner required' });
+    try {
+      if (req.method === 'GET') {
+        const result = await operate('get');
+        return send(result.ok ? 200 : 422, { ...result, agentAccess: await access.get() });
+      }
+      if (!/^application\/json(?:;|$)/i.test(req.headers['content-type'] || ''))
+        return send(415, { ok: false, error: 'JSON required' });
+      const chunks = [];
+      let size = 0;
+      for await (const chunk of req) {
+        size += chunk.length;
+        if (size > 16384) return send(413, { ok: false, error: 'Request too large' });
+        chunks.push(chunk);
+      }
+      const body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+      if (!body || typeof body !== 'object' || Array.isArray(body))
+        throw new Error('Invalid request');
+      if (body.action === 'access') {
+        if (Object.keys(body).some((k) => !['action', 'allowed'].includes(k)))
+          throw new Error('Unknown field');
+        return send(200, { ok: true, agentAccess: await access.set(body.allowed) });
+      }
+      if (
+        body.action !== 'set' ||
+        Object.keys(body).some((k) => !['action', 'settings'].includes(k))
+      )
+        throw new Error('Invalid action');
+      const result = await operate('set', body.settings);
+      send(result.ok ? 200 : 422, result);
+    } catch {
+      send(400, {
+        ok: false,
+        error: '无法读取或保存设置，请检查配置和访问权限。 / Unable to read or save settings.',
+      });
+    }
+  };
+}
+export function registerSettingsRoute(ctx, operate, access) {
+  ctx.inject?.(['webServer', 'connection'], (webCtx) => {
+    const authorize = (request) => {
+      if (typeof webCtx.connection?.admit !== 'function') return 503;
+      const admission = webCtx.connection.admit(request);
+      if ('rejection' in admission) return admission.rejection;
+      return admission.peer.principal.kind === 'owner' ? undefined : 403;
+    };
+    const handler = createSettingsHandler(operate, access, authorize);
+    webCtx.effect(() =>
+      webCtx.webServer.register({ kind: 'exact', path: SETTINGS_ROUTE, handler }),
+    );
+  });
+}

package/tests/classic-overview.test.mjs

@@ -0,0 +1,77 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { classicClockPresentation } from '../ui-utils.js';
+import { calculate } from '../clock.js';
+const settings = {
+  payMode: 'monthly',
+  monthlySalary: 10000,
+  workdaysPerMonth: 21.75,
+  dailySalary: 0,
+  start: '09:00',
+  end: '18:00',
+  breakStart: '12:00',
+  breakEnd: '13:00',
+  weekdays: [1, 2, 3, 4, 5],
+  timezone: 'Asia/Shanghai',
+};
+const present = (time, config = settings) => {
+  const now = Date.parse(time);
+  return classicClockPresentation({
+    hasSession: true,
+    loaded: true,
+    configured: true,
+    failed: false,
+    state: calculate(config, now),
+    now,
+  });
+};
+test('classic overview distinguishes startup, missing configuration and failed reads without a zero countdown', () => {
+  const base = {
+    hasSession: true,
+    loaded: true,
+    configured: true,
+    failed: false,
+    state: null,
+    now: 0,
+  };
+  for (const [patch, phase] of [
+    [{ hasSession: false }, 'waiting'],
+    [{ loaded: false }, 'loading'],
+    [{ configured: false }, 'setup'],
+    [{ failed: true }, 'error'],
+  ]) {
+    const view = classicClockPresentation({ ...base, ...patch });
+    assert.equal(view.phase, phase);
+    assert.equal(view.seconds, null);
+  }
+});
+test('classic overview shows the correct countdown target for before, working and lunch', () => {
+  assert.equal(present('2026-11-05T00:00:00Z').seconds, 3600);
+  const working = present('2026-11-05T02:00:00Z');
+  assert.equal(working.phase, 'working');
+  assert.equal(working.seconds, 8 * 3600);
+  const lunch = present('2026-11-05T04:30:00Z');
+  assert.equal(lunch.phase, 'lunch');
+  assert.equal(lunch.seconds, 1800);
+});
+test('completed shifts and rest days show a state instead of a meaningless zero', () => {
+  for (const [date, phase] of [
+    ['2026-11-05T11:00:00Z', 'done'],
+    ['2026-11-07T02:00:00Z', 'rest'],
+  ]) {
+    const result = present(date);
+    assert.equal(result.phase, phase);
+    assert.equal(result.seconds, null);
+  }
+  const night = {
+    ...settings,
+    start: '22:00',
+    end: '06:00',
+    breakStart: '02:00',
+    breakEnd: '02:00',
+  };
+  assert.equal(present('2026-11-05T15:00:00Z', night).seconds, 7 * 3600);
+  const completed = present('2026-11-05T23:00:00Z', night);
+  assert.equal(completed.phase, 'done');
+  assert.equal(completed.seconds, null);
+});

package/tests/companion-state.test.mjs

@@ -0,0 +1,267 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { IDBFactory } from 'fake-indexeddb';
+import { defaultCountdown, transitionCountdown } from '../countdown.js';
+import { defaultHydration, transitionHydration } from '../hydration.js';
+import { createStateStore } from '../hydration-store.js';
+import {
+  defaultCompanionState,
+  validateCompanionState,
+  companionEvents,
+  companionPending,
+  companionTransition,
+  reconcileCompanion,
+  companionDaySummary,
+  validateBrowserBackup,
+  companionBackupStamp,
+  companionStateStamp,
+  createCompanionRecoveryStore,
+} from '../companion-state.js';
+const at = Date.parse('2026-11-12T09:00:00Z');
+const event = { id: 'smoking:1', kind: 'smoking', label: 'Smoking', dueAt: at };
+const fresh = () => reconcileCompanion(defaultCompanionState(), [event], at);
+
+test('closing, snoozing and quiet mode have distinct persistent semantics', () => {
+  let state = fresh();
+  state = companionTransition(state, { type: 'dismiss', id: event.id }, at);
+  assert.equal(companionPending(state, [event], at).length, 0);
+  assert.equal(state.deliveries[event.id].dueAt, at);
+  state = companionTransition(state, { type: 'snooze', id: event.id }, at);
+  assert.equal(companionPending(state, [event], at + 599999).length, 0);
+  assert.equal(companionPending(state, [event], at + 600000).length, 1);
+  state = companionTransition(
+    state,
+    { type: 'preferences', patch: { quietUntil: at + 700000 } },
+    at,
+  );
+  assert.equal(companionPending(state, [event], at + 600000).length, 0);
+  assert.equal(companionPending(state, [event], at + 700000).length, 1);
+});
+test('only one tab owns a reminder; lease can recover after a crash', async () => {
+  const idb = new IDBFactory();
+  const stores = ['a', 'b'].map(() =>
+    createStateStore(idb, 'race', defaultCompanionState, validateCompanionState),
+  );
+  await stores[0].update(() => fresh());
+  const winners = [];
+  await Promise.all(
+    stores.map((s, i) =>
+      s.update((value) => {
+        const next = companionTransition(
+          value,
+          { type: 'claim', id: event.id, owner: String(i) },
+          at,
+        );
+        if (next.deliveries[event.id].owner === String(i)) winners.push(i);
+        return next;
+      }),
+    ),
+  );
+  assert.equal(winners.length, 1);
+  const loser = String(1 - winners[0]);
+  const next = await stores[1].update((s) =>
+    companionTransition(s, { type: 'claim', id: event.id, owner: loser }, at + 8000),
+  );
+  assert.equal(next.deliveries[event.id].owner, loser);
+  stores.forEach((s) => s.close());
+});
+test('notification claims are atomic across tabs and snooze permits one new notification', async () => {
+  const idb = new IDBFactory();
+  const a = createStateStore(idb, 'notification', defaultCompanionState, validateCompanionState),
+    b = createStateStore(idb, 'notification', defaultCompanionState, validateCompanionState);
+  await a.update(() => fresh());
+  let sent = 0;
+  await Promise.all(
+    [a, b].map((store) =>
+      store.update((s) => {
+        if (!s.deliveries[event.id].notifiedAt) sent++;
+        return companionTransition(s, { type: 'notify', id: event.id }, at);
+      }),
+    ),
+  );
+  assert.equal(sent, 1);
+  let state = await a.update((s) => companionTransition(s, { type: 'snooze', id: event.id }, at));
+  assert.equal(state.deliveries[event.id].notifiedAt, 0);
+  state = companionTransition(state, { type: 'notify', id: event.id }, at + 1);
+  assert.equal(state.deliveries[event.id].notifiedAt, 0);
+  a.close();
+  b.close();
+});
+test('legacy water/smoking clocks are observed without modifying them', () => {
+  let smoking = transitionCountdown(defaultCountdown(), { type: 'start' }, at - 3600000);
+  let water = transitionHydration(
+    defaultHydration(),
+    { type: 'preferences', enabled: true, interval: 5 },
+    at - 300000,
+    'test',
+  );
+  const before = JSON.stringify({ smoking, water });
+  const events = companionEvents(
+    defaultCompanionState(),
+    { smoking, water, smokingReady: true, waterReady: true },
+    at,
+  );
+  assert.deepEqual(events.map((e) => e.kind).sort(), ['smoking', 'water']);
+  assert.equal(JSON.stringify({ smoking, water }), before);
+  water.claim = { owner: 'older-client', until: at + 8000, sequence: water.sequence };
+  assert.equal(
+    companionEvents(
+      defaultCompanionState(),
+      { water, waterReady: true, waterOwner: 'new-client' },
+      at,
+    ).length,
+    0,
+  );
+  assert.equal(
+    companionEvents(
+      defaultCompanionState(),
+      { water, waterReady: true, waterOwner: 'new-client' },
+      at + 8000,
+    ).length,
+    1,
+  );
+});
+test('wrap-up completion suppresses this shift only and leaves water/custom clocks intact', () => {
+  let state = defaultCompanionState();
+  state.preferences.wrapEnabled = true;
+  const shift = {
+    isWorkday: true,
+    shiftDate: '2026-11-12',
+    shiftStart: at - 3600000,
+    shiftEnd: at + 300000,
+  };
+  const inputs = { shift };
+  assert.equal(companionEvents(state, inputs, at).length, 1);
+  state = companionTransition(
+    state,
+    {
+      type: 'journal',
+      date: shift.shiftDate,
+      done: 'One change',
+      next: 'Review',
+      base: 0,
+      end: true,
+    },
+    at,
+  );
+  assert.equal(companionEvents(state, inputs, at).length, 0);
+  assert.equal(state.preferences.wrapEnabled, true);
+  assert.equal(
+    companionEvents(state, { shift: { ...shift, shiftDate: '2026-11-13' } }, at).length,
+    1,
+  );
+  assert.equal(companionEvents(state, { shift: { ...shift, isWorkday: false } }, at).length, 0);
+});
+test('notes reject a stale tab and repeating end does not duplicate history', () => {
+  let s = companionTransition(
+    defaultCompanionState(),
+    { type: 'journal', date: '2026-11-12', done: 'A', next: 'B', base: 0, end: true },
+    at,
+  );
+  assert.throws(
+    () =>
+      companionTransition(
+        s,
+        { type: 'journal', date: '2026-11-12', done: 'stale', next: '', base: 0, end: false },
+        at + 1,
+      ),
+    /another tab/,
+  );
+  s = companionTransition(
+    s,
+    { type: 'journal', date: '2026-11-12', done: 'A2', next: 'B', base: at, end: true },
+    at + 1,
+  );
+  assert.equal(s.history.length, 1);
+});
+test('custom timers are independent and actions reject stale per-timer revisions', () => {
+  let s = defaultCompanionState();
+  for (const id of ['tea', 'rest'])
+    s = companionTransition(s, { type: 'add-timer', id, name: id, minutes: 5 }, at);
+  s = companionTransition(
+    s,
+    { type: 'timer', id: 'tea', revision: 0, operation: { type: 'start' } },
+    at,
+  );
+  assert.equal(s.timers[1].clock.status, 'idle');
+  assert.throws(
+    () =>
+      companionTransition(
+        s,
+        { type: 'timer', id: 'tea', revision: 0, operation: { type: 'stop' } },
+        at,
+      ),
+    /changed/,
+  );
+  assert.equal(companionEvents(s, {}, at + 300000)[0].timerId, 'tea');
+});
+test('restore validates data, requires current revision, and resets permissions and leases', () => {
+  let s = fresh();
+  s.revision = 8;
+  const backup = fresh();
+  backup.preferences.sound = true;
+  backup.preferences.notifications = true;
+  backup.deliveries[event.id].owner = 'old';
+  backup.deliveries[event.id].leaseUntil = at + 1000;
+  assert.throws(
+    () => companionTransition(s, { type: 'restore', value: backup, base: 7 }, at),
+    /changed/,
+  );
+  const restored = companionTransition(s, { type: 'restore', value: backup, base: 8 }, at);
+  assert.equal(restored.preferences.sound, false);
+  assert.equal(restored.preferences.notifications, false);
+  assert.equal(restored.deliveries[event.id].owner, '');
+  assert.throws(() => validateCompanionState({ ...s, schema: 999 }));
+  assert.throws(() =>
+    validateCompanionState({
+      ...s,
+      preferences: { ...s.preferences, image: 'https://evil.example/image.svg' },
+    }),
+  );
+});
+test('actual event history is bounded, idempotent and counted in chosen timezone', () => {
+  let s = defaultCompanionState();
+  const e = {
+    id: 'drink:1',
+    label: 'Water',
+    type: 'water',
+    at: Date.parse('2026-11-12T23:00:00Z'),
+  };
+  s = companionTransition(s, { type: 'record', event: e }, at);
+  s = companionTransition(s, { type: 'record', event: e }, at);
+  assert.equal(s.history.length, 1);
+  assert.equal(companionDaySummary(s, '2026-11-13', 'Asia/Shanghai').water, 1);
+  assert.equal(companionDaySummary(s, '2026-11-12', 'Asia/Shanghai').water, 0);
+});
+
+test('backup preview ignores leases but detects user changes; recovery survives reopening', async () => {
+  const b = validateBrowserBackup({
+    format: 'dsh-offwork-browser',
+    version: 1,
+    createdAt: at,
+    companion: fresh(),
+    water: defaultHydration(),
+    smoking: defaultCountdown(),
+    view: {},
+  });
+  const stamp = companionBackupStamp(b);
+  b.water.claim = { owner: 'other-tab', until: at + 8000, sequence: 0 };
+  b.companion.revision++;
+  assert.equal(companionBackupStamp(b), stamp);
+  const restored = companionTransition(
+    b.companion,
+    { type: 'restore', value: b.companion, base: 0, stamp: companionStateStamp(b.companion) },
+    at,
+  );
+  assert.equal(restored.revision, b.companion.revision);
+  b.water.count++;
+  assert.notEqual(companionBackupStamp(b), stamp);
+  const idb = new IDBFactory();
+  let store = createCompanionRecoveryStore(idb, createStateStore);
+  await store.update((s) => ({ ...s, bundle: b }));
+  store.close();
+  store = createCompanionRecoveryStore(idb, createStateStore);
+  assert.equal((await store.update((s) => s)).bundle.water.count, 1);
+  store.close();
+  assert.throws(() => validateBrowserBackup({ ...b, water: { ...b.water, schema: 999 } }));
+});

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