dsh-offwork 1.1.1 → 1.1.2

package/tests/hydration.test.mjs

@@ -1,211 +1,141 @@
 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 time = (value) => Date.parse(value.includes('T') ? value : `2026-11-06T${value}:00+08:00`);
+const act = (state, at, action, owner = 'a') =>
+  transitionHydration(state, action, typeof at === 'number' ? at : time(at), owner);
+const enable = (at = '09:00', interval = 60) =>
+  act(defaultHydration(), at, { type: 'preferences', enabled: true, interval });
+const view = (state, at) => hydrationView(state, typeof at === 'number' ? at : time(at));
 
-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');
+test('reminders are opt-in and enabling at any hour starts one full wall-clock interval', () => {
+  assert.equal(view(defaultHydration(), '23:00').phase, 'off');
+  const state = enable('23:15');
+  assert.equal(state.dueAt, time('2026-11-07T00:15:00+08:00'));
+  assert.equal(view(state, '23:59').phase, 'countdown');
+  assert.equal(view(state, '2026-11-07T00:15:00+08:00').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');
+for (const interval of [5, 15, 17, 30, 45, 60, 90, 120, 240])
+  test(`saving ${interval} natural minutes preserves unchanged settings and applies changed intervals`, () => {
+    const initial = enable();
     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');
+    assert.equal(saved.dueAt, time(interval === 60 ? '09:00' : '09:10') + interval * 60000);
+    const restored = validateHydration(JSON.parse(JSON.stringify(saved)));
+    assert.equal(view(restored, saved.dueAt - 1).phase, 'countdown');
+    assert.equal(view(restored, saved.dueAt).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');
+for (const [start, end] of [
+  ['11:50', '12:50'],
+  ['17:50', '18:50'],
+  ['2026-11-07T10:00:00+08:00', '2026-11-07T11:00:00+08:00'],
+])
+  test(`water continues from ${start} to ${end} without lunch or workday gating`, () => {
+    const state = enable(start);
+    assert.equal(view(state, time(start) + 1800000).remaining, 1800000);
+    assert.equal(view(state, end).phase, 'due');
+  });
+test('snooze uses ten clock minutes across lunch and shift boundaries', () => {
+  for (const at of ['11:58', '17:58']) {
+    let state = enable(typeof at === 'string' ? time(at) - 3600000 : at);
+    state = act(state, at, { type: 'claim' });
+    const next = act(state, at, { type: 'snooze', eventId: view(state, at).eventId });
+    assert.equal(next.dueAt, time(at) + 600000);
+    assert.equal(next.count, 0);
+    assert.equal(view(next, next.dueAt).phase, 'due');
+  }
 });
-
-test('hours of missed ticks yield a single stable event; shift end discards it', () => {
+test('missed ticks and calendar rollover keep one overdue event rather than rescheduling', () => {
   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');
+  const event = view(state, '10:00').eventId;
+  for (const at of ['18:00', '2026-11-07T12:00:00+08:00', '2026-11-09T09:00:00+08:00']) {
+    const next = reconcileHydration(state, time(at));
+    assert.equal(view(next, at).phase, 'due');
+    assert.equal(view(next, at).eventId, event);
+    assert.equal(next.dueAt, state.dueAt);
+  }
 });
-
-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('a confirmed reminder records once and schedules from the accepted action time', () => {
+  let state = act(enable(), '18:05', { type: 'claim' });
+  const eventId = view(state, '18:05').eventId;
+  state = act(state, '18:05', { type: 'drink', eventId });
+  const replay = act(state, '18:06', { type: 'drink', eventId });
+  assert.equal(replay.count, 1);
+  assert.equal(replay.dueAt, time('19:05'));
+  assert.deepEqual(replay, state);
 });
-
-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('pause lasts until explicit resume and neither dates nor days off reset the count', () => {
+  let state = act(enable(), '17:30', { type: 'manual-drink', actionId: 'first' });
+  state = act(state, '17:40', { type: 'pause' });
+  const later = reconcileHydration(state, time('2026-11-09T09:00:00+08:00'));
+  assert.equal(view(later, '2026-11-09T09:00:00+08:00').phase, 'paused');
+  assert.equal(later.count, 1);
+  const resumed = act(later, '2026-11-09T09:00:00+08:00', { type: 'resume' });
+  assert.equal(resumed.dueAt, time('2026-11-09T10:00:00+08:00'));
 });
-
-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('clear-count does not move the deadline, change quiet/pause, or erase deduplication IDs', () => {
+  let state = act(enable(), '09:10', { type: 'manual-drink', actionId: 'keep' });
+  state = act(state, '09:11', { type: 'quiet', minutes: 60 });
+  const cleared = act(state, '09:12', { type: 'clear-count' });
+  assert.deepEqual(cleared, { ...state, count: 0 });
+  assert.equal(act(cleared, '09:13', { type: 'manual-drink', actionId: 'keep' }).count, 0);
 });
-
-test('only the current lease owner can process a live event; expired lease is transferred', () => {
-  let state = claim(enable(), '10:00');
+test('one lease owner handles a due event, ownership expires, and foreign release cannot steal it', () => {
+  const state = act(enable(), '10:00', { type: 'claim' });
   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,
-  );
+  assert.deepEqual(act(state, '10:00', { type: 'release' }, 'b'), state);
+  assert.equal(act(state, '10:00', { type: 'drink', eventId }, 'b').count, 0);
+  const now = time('10:00') + HYDRATION_LEASE_MS;
+  const next = act(state, now, { type: 'claim' }, 'b');
+  assert.equal(next.claim.owner, 'b');
+  assert.equal(act(next, now, { type: 'drink', eventId }, 'a').count, 0);
+  assert.equal(act(next, now, { type: 'drink', eventId }, 'b').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('expired, future and released claims are recoverable without changing the event', () => {
+  let state = act(enable(), '10:00', { type: 'claim' });
+  const eventId = view(state, '10:00').eventId;
+  state.claim.until = time('10:00') + HYDRATION_LEASE_MS + 1;
+  const replaced = act(state, '10:00', { type: 'claim' }, 'b');
+  assert.equal(replaced.claim.owner, 'b');
+  assert.equal(view(replaced, '10:00').eventId, eventId);
+  assert.equal(act(replaced, '10:00', { type: 'release' }, 'b').claim, null);
 });
-
-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('preference changes invalidate stale confirmations; partial updates preserve the other preference', () => {
+  let state = act(enable(), '10:00', { type: 'claim' });
+  const eventId = view(state, '10:00').eventId;
+  state = act(state, '10:00', { type: 'preferences', interval: 30 });
+  assert.equal(act(state, '10:00', { type: 'drink', eventId }).count, 0);
+  state = act(state, '10:01', { type: 'preferences', enabled: false });
+  assert.equal(state.interval, 30);
+  assert.equal(state.claim, null);
 });
-
-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');
+test('invalid stored fields, preferences and overflowing timestamps fail closed', () => {
+  for (const patch of [
+    { schema: 99 },
+    { interval: 4 },
+    { count: -1 },
+    { paused: 0 },
+    { dueAt: NaN },
+    { quietUntil: -1 },
+    { recentActions: ['x', 'x'] },
+    { claim: { owner: '', until: 1, sequence: 0 } },
+    { unknown: true },
+  ])
+    assert.throws(() => validateHydration({ ...defaultHydration(), ...patch }));
+  for (const interval of [0, 4, 241, NaN, 5.5])
+    assert.throws(() => act(defaultHydration(), '09:00', { type: 'preferences', interval }));
+  assert.throws(() =>
+    transitionHydration(
+      defaultHydration(),
+      { type: 'preferences', enabled: true },
+      Number.MAX_SAFE_INTEGER,
+      'a',
+    ),
+  );
 });

package/tests/media-server.test.mjs

@@ -0,0 +1,179 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createServer } from 'node:http';
+import { mkdtemp, writeFile, rm, symlink } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { createHash } from 'node:crypto';
+import { createMediaHandler, mediaRange, registerMediaRoute } from '../media-server.js';
+import { MEDIA_ROUTE } from '../media-manifest.js';
+import { petClipUrls } from '../pet-video.js';
+
+async function fixture(t, corrupt = false) {
+  const dir = await mkdtemp(join(tmpdir(), 'offwork-media-'));
+  const bytes = Buffer.from(Array.from({ length: 256 }, (_, i) => i));
+  const sha256 = createHash('sha256').update(bytes).digest('hex');
+  const key = sha256 + '/clip.webm';
+  await writeFile(join(dir, 'clip.webm'), corrupt ? Buffer.alloc(bytes.length) : bytes);
+  await writeFile(join(dir, 'data.json'), 'private fixture, never serve');
+  const assets = { [key]: { file: 'clip.webm', size: bytes.length, sha256 } };
+  const server = createServer(createMediaHandler({ assets, root: pathToFileURL(dir + '/') }));
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+  t.after(async () => {
+    server.closeAllConnections();
+    await new Promise((resolve) => server.close(resolve));
+    await rm(dir, { recursive: true, force: true });
+  });
+  return {
+    dir,
+    bytes,
+    sha256,
+    key,
+    origin: `http://127.0.0.1:${server.address().port}`,
+    url: `http://127.0.0.1:${server.address().port}${MEDIA_ROUTE}/${key}`,
+  };
+}
+
+test('media endpoint serves immutable verified bytes, HEAD and conditional responses', async (t) => {
+  const f = await fixture(t);
+  const response = await fetch(f.url);
+  assert.equal(response.status, 200);
+  assert.equal(response.headers.get('content-type'), 'video/webm');
+  assert.match(response.headers.get('cache-control'), /immutable/);
+  assert.equal(response.headers.get('accept-ranges'), 'bytes');
+  assert.equal(response.headers.get('cross-origin-resource-policy'), 'same-origin');
+  assert.deepEqual(Buffer.from(await response.arrayBuffer()), f.bytes);
+  const head = await fetch(f.url, { method: 'HEAD', headers: { Range: 'bytes=10-20' } });
+  assert.equal(head.status, 200);
+  assert.equal(head.headers.get('content-length'), '256');
+  assert.equal((await head.arrayBuffer()).byteLength, 0);
+  const cached = await fetch(f.url, {
+    headers: { 'If-None-Match': `W/"${f.sha256}"`, Range: 'bytes=999-' },
+  });
+  assert.equal(cached.status, 304);
+  assert.equal((await cached.arrayBuffer()).byteLength, 0);
+});
+
+test('single byte ranges, suffixes and If-Range allow seeking without loading other resources', async (t) => {
+  const f = await fixture(t);
+  for (const [header, start, end] of [
+    ['bytes=20-31', 20, 31],
+    ['bytes=-7', 249, 255],
+    ['bytes=250-', 250, 255],
+    ['bytes=250-999', 250, 255],
+  ]) {
+    const response = await fetch(f.url, {
+      headers: { Range: header, 'If-Range': `"${f.sha256}"` },
+    });
+    assert.equal(response.status, 206);
+    assert.equal(response.headers.get('content-range'), `bytes ${start}-${end}/256`);
+    assert.deepEqual(Buffer.from(await response.arrayBuffer()), f.bytes.subarray(start, end + 1));
+  }
+  const changed = await fetch(f.url, { headers: { Range: 'bytes=1-2', 'If-Range': '"other"' } });
+  assert.equal(changed.status, 200);
+  assert.deepEqual(Buffer.from(await changed.arrayBuffer()), f.bytes);
+  for (const header of [
+    'bytes=256-',
+    'bytes=-0',
+    'bytes=4-2',
+    'bytes=0-1,4-5',
+    'bytes=9999999999999999999999-',
+  ]) {
+    const response = await fetch(f.url, { headers: { Range: header } });
+    assert.equal(response.status, 416);
+    assert.equal(response.headers.get('content-range'), 'bytes */256');
+  }
+  assert.equal(mediaRange(['bytes=0-1'], 256), null);
+});
+
+test('unknown names, traversal and mutating requests never expose adjacent files', async (t) => {
+  const f = await fixture(t);
+  for (const path of [
+    'data.json',
+    'constructor',
+    '%2e%2e/data.json',
+    'a/../../../data.json',
+    f.key + '/../data.json',
+    '%2fdata.json',
+  ]) {
+    const response = await fetch(f.origin + MEDIA_ROUTE + '/' + path);
+    assert.equal(response.status, 404);
+    assert.equal(await response.text(), '');
+  }
+  const post = await fetch(f.url, { method: 'POST', body: 'overwrite' });
+  assert.equal(post.status, 405);
+  assert.equal(post.headers.get('allow'), 'GET, HEAD');
+  const response = await fetch(f.url);
+  assert.deepEqual(Buffer.from(await response.arrayBuffer()), f.bytes);
+});
+
+test('integrity failures are not cached and a repaired asset can be retried', async (t) => {
+  const f = await fixture(t, true);
+  const bad = await fetch(f.url);
+  assert.equal(bad.status, 500);
+  assert.equal(await bad.text(), '');
+  assert.equal(bad.headers.get('cache-control'), 'no-store');
+  await writeFile(join(f.dir, 'clip.webm'), f.bytes);
+  const retry = await fetch(f.url);
+  assert.equal(retry.status, 200);
+  assert.deepEqual(Buffer.from(await retry.arrayBuffer()), f.bytes);
+});
+
+test('media files cannot be replaced by a symlink to another local file', async (t) => {
+  if (process.platform === 'win32') return t.skip('POSIX symlink protection');
+  const f = await fixture(t);
+  await rm(join(f.dir, 'clip.webm'));
+  await symlink(join(f.dir, 'data.json'), join(f.dir, 'clip.webm'));
+  const response = await fetch(f.url);
+  assert.equal(response.status, 500);
+  assert.equal(await response.text(), '');
+});
+
+test('route registration is optional and owned by the web service scope', () => {
+  registerMediaRoute({});
+  let activate,
+    route,
+    disposed = false;
+  registerMediaRoute({
+    inject(names, callback) {
+      assert.deepEqual(names, ['webServer']);
+      activate = callback;
+    },
+  });
+  assert.equal(route, undefined);
+  const disposers = [];
+  activate({
+    effect(fn) {
+      disposers.push(fn());
+    },
+    webServer: {
+      register(value) {
+        route = value;
+        return () => {
+          disposed = true;
+        };
+      },
+    },
+  });
+  assert.equal(route.path, MEDIA_ROUTE);
+  assert.equal(route.kind, 'prefix');
+  disposers[0]();
+  assert.equal(disposed, true);
+});
+
+test('media URLs respect application mount paths without carrying auth queries or external URLs', () => {
+  const relative = 'offwork-clock/media/abc/idle.webm';
+  const models = {
+    short: {
+      idle: relative,
+      external: 'https://elsewhere.test/movie',
+      traversal: 'offwork-clock/media/../../data.json',
+    },
+  };
+  assert.deepEqual(petClipUrls(models, 'https://example.test/app/?token=test#fragment'), {
+    short: { idle: 'https://example.test/app/' + relative },
+  });
+  assert.deepEqual(petClipUrls(models, 'file:///tmp/index.html'), {});
+  assert.deepEqual(petClipUrls(models, 'not a URL'), {});
+});

package/tests/pet-reminder.test.mjs

@@ -0,0 +1,71 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { initialPetReminder, nextPetReminder, dismissPetReminder } from '../pet-reminder.js';
+const input = (patch = {}) => ({
+  ready: true,
+  eventId: 'shift:1',
+  phase: 'countdown',
+  visible: true,
+  available: true,
+  ownsPrompt: false,
+  ...patch,
+});
+
+test('loading or refreshing an already-due reminder never opens a card', () => {
+  let state = nextPetReminder(initialPetReminder, input({ ready: false, eventId: null }));
+  state = nextPetReminder(state, input({ phase: 'due', ownsPrompt: true }));
+  assert.equal(state.open, false);
+  assert.equal(state.armed, false);
+  assert.equal(nextPetReminder(state, input({ phase: 'due', ownsPrompt: true })), state);
+  const explicitlyOpened = { ...state, open: true };
+  assert.equal(
+    nextPetReminder(explicitlyOpened, input({ phase: 'due', ownsPrompt: true })).open,
+    true,
+  );
+});
+
+test('a live countdown opens only for its lease owner and stays dismissed for the same due phase', () => {
+  let state = nextPetReminder(initialPetReminder, input());
+  assert.equal(state.armed, true);
+  state = nextPetReminder(state, input({ phase: 'due' }));
+  assert.equal(state.open, false);
+  assert.equal(state.armed, true);
+  state = nextPetReminder(state, input({ phase: 'due', ownsPrompt: true }));
+  assert.equal(state.open, true);
+  assert.equal(nextPetReminder(state, input({ phase: 'due', ownsPrompt: true })), state);
+  state = dismissPetReminder(state);
+  assert.equal(nextPetReminder(state, input({ phase: 'due', ownsPrompt: true })).open, false);
+  state = nextPetReminder(state, input({ eventId: 'shift:2' }));
+  assert.equal(
+    nextPetReminder(state, input({ eventId: 'shift:2', phase: 'due', ownsPrompt: true })).open,
+    true,
+  );
+});
+
+test('open cards, background state and lease loss stop popups without delayed replay', () => {
+  for (const patch of [{ available: false }, { visible: false }, { ready: false }]) {
+    let state = nextPetReminder(initialPetReminder, input());
+    state = nextPetReminder(state, input({ phase: 'due', ownsPrompt: true, ...patch }));
+    assert.equal(state.open, false);
+    assert.equal(nextPetReminder(state, input({ phase: 'due', ownsPrompt: true })).open, false);
+  }
+  let state = nextPetReminder(initialPetReminder, input());
+  state = nextPetReminder(state, input({ phase: 'due', ownsPrompt: true }));
+  state = nextPetReminder(state, input({ phase: 'due', ownsPrompt: false }));
+  assert.equal(state.open, false);
+  assert.equal(nextPetReminder(state, input({ phase: 'due', ownsPrompt: true })).open, false);
+});
+
+test('quiet or unpaid-break phases can arm a reminder for work resumption without changing business state', () => {
+  for (const phase of ['quiet', 'break']) {
+    const previous = Object.freeze({ eventId: 'shift:1', armed: false, open: false });
+    const state = nextPetReminder(previous, input({ phase }));
+    assert.equal(state.armed, true);
+    assert.equal(nextPetReminder(state, input({ phase: 'due', ownsPrompt: true })).open, true);
+    assert.deepEqual(previous, { eventId: 'shift:1', armed: false, open: false });
+  }
+  for (const phase of ['off', 'waiting', 'paused', 'finished']) {
+    const state = nextPetReminder(nextPetReminder(initialPetReminder, input()), input({ phase }));
+    assert.equal(nextPetReminder(state, input({ phase: 'due', ownsPrompt: true })).open, false);
+  }
+});