dsh-offwork 0.0.0-stage → 1.0.1

package/tests/clock.test.mjs

@@ -0,0 +1,236 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { calculate } from '../clock.js';
+
+const base = {
+  monthlySalary: 10000,
+  workdaysPerMonth: 20,
+  start: '09:00',
+  end: '18:00',
+  breakStart: '12:00',
+  breakEnd: '13:00',
+  weekdays: [1, 2, 3, 4, 5],
+  timezone: 'Asia/Shanghai',
+};
+const at = (time, patch = {}) => calculate({ ...base, ...patch }, Date.parse(time));
+const night = { start: '22:00', end: '06:00', breakStart: '02:00', breakEnd: '03:00' };
+const utc = { timezone: 'UTC' };
+
+for (const [time, status, progress] of [
+  ['08:00', 'before', 0],
+  ['09:00', 'working', 0],
+  ['11:00', 'working', 0.25],
+  ['12:00', 'lunch', 0.375],
+  ['12:59', 'lunch', 0.375],
+  ['13:00', 'working', 0.375],
+  ['17:00', 'working', 0.875],
+  ['18:00', 'done', 1],
+  ['23:59', 'done', 1],
+])
+  test(`same-day boundary ${time}: ${status}`, () => {
+    const result = at(`2026-11-02T${time}:00+08:00`);
+    assert.equal(result.status, status);
+    assert.equal(result.progress, progress);
+  });
+
+test('before has both actual end countdown and start countdown', () => {
+  const result = at('2026-11-02T08:00:00+08:00');
+  assert.equal(result.remaining, 36000);
+  assert.equal(result.startRemaining, 3600);
+});
+test('lunch freezes pay but not the real end countdown', () => {
+  const first = at('2026-11-02T12:00:00+08:00');
+  const second = at('2026-11-02T12:30:00+08:00');
+  assert.equal(first.earned, second.earned);
+  assert.equal(first.remaining - second.remaining, 1800);
+  assert.equal(second.startRemaining, 0);
+});
+test('equal break endpoints mean no break even outside the shift', () => {
+  const result = at('2026-11-02T13:30:00+08:00', { breakStart: '00:00', breakEnd: '00:00' });
+  assert.equal(result.progress, 0.5);
+  assert.equal(result.total, 9 * 3600);
+  assert.equal(result.breakStart, null);
+});
+test('omitted break is optional', () => {
+  const result = at('2026-11-02T13:30:00+08:00', { breakStart: undefined, breakEnd: undefined });
+  assert.equal(result.progress, 0.5);
+});
+test('weekend is rest, not a completed salaried shift', () => {
+  const result = at('2026-11-07T20:00:00+08:00');
+  assert.equal(result.status, 'rest');
+  assert.equal(result.earned, 0);
+  assert.equal(result.progress, 0);
+  assert.equal(result.remaining, 0);
+});
+test('night early hours belong to previous start date', () => {
+  const result = at('2026-11-03T01:00:00+08:00', night);
+  assert.equal(result.shiftDate, '2026-11-02');
+  assert.equal(result.date, '2026-11-03');
+  assert.equal(result.status, 'working');
+  assert.equal(result.elapsed, 3 * 3600);
+  assert.equal(result.remaining, 5 * 3600);
+});
+test('night break after midnight is normalized into the shift', () => {
+  const result = at('2026-11-03T02:30:00+08:00', night);
+  assert.equal(result.status, 'lunch');
+  assert.equal(result.elapsed, 4 * 3600);
+  assert.equal(result.total, 7 * 3600);
+});
+test('break spanning midnight is normalized', () => {
+  const result = at('2026-11-03T00:15:00+08:00', {
+    ...night,
+    breakStart: '23:30',
+    breakEnd: '00:30',
+  });
+  assert.equal(result.status, 'lunch');
+  assert.equal(result.elapsed, 1.5 * 3600);
+});
+test('Saturday early night shift uses working Friday', () => {
+  const result = at('2026-11-07T04:00:00+08:00', night);
+  assert.equal(result.status, 'working');
+  assert.equal(result.shiftDate, '2026-11-06');
+});
+test('night completed status retained through the following daytime', () => {
+  for (const time of ['06:00', '12:00', '21:59']) {
+    const result = at(`2026-11-03T${time}:00+08:00`, night);
+    assert.equal(result.status, 'done');
+    assert.equal(result.shiftDate, '2026-11-02');
+    assert.equal(result.earned, result.daily);
+  }
+});
+test('new night shift starts exactly at 22:00', () => {
+  const result = at('2026-11-03T22:00:00+08:00', night);
+  assert.equal(result.status, 'working');
+  assert.equal(result.shiftDate, '2026-11-03');
+  assert.equal(result.progress, 0);
+});
+test('Monday early hours still belong to nonworking Sunday', () => {
+  assert.equal(at('2026-11-02T04:00:00+08:00', night).status, 'rest');
+});
+test('Monday daytime is before when Sunday did not work', () => {
+  for (const time of ['06:00', '12:00', '21:59']) {
+    const result = at(`2026-11-02T${time}:00+08:00`, night);
+    assert.equal(result.status, 'before');
+    assert.equal(result.shiftDate, '2026-11-02');
+    assert.ok(result.startRemaining > 0);
+  }
+});
+test('Saturday daytime retains Friday done; Saturday night is rest', () => {
+  assert.equal(at('2026-11-07T12:00:00+08:00', night).status, 'done');
+  assert.equal(at('2026-11-07T22:00:00+08:00', night).status, 'rest');
+});
+test('configured Sunday workday overrides weekday assumptions', () => {
+  const result = at('2026-11-08T10:00:00+08:00', { weekdays: [0] });
+  assert.equal(result.status, 'working');
+});
+test('daily salary ignores monthly fields and truncates cents', () => {
+  const result = at('2026-11-02T18:00:00+08:00', {
+    payMode: 'daily',
+    dailySalary: 123.459,
+    monthlySalary: undefined,
+    workdaysPerMonth: undefined,
+  });
+  assert.equal(result.payMode, 'daily');
+  assert.equal(result.daily, 123.45);
+  assert.equal(result.earned, 123.45);
+});
+test('decimal division does not lose a cent at completion', () => {
+  const result = at('2026-11-02T18:00:00+08:00', { monthlySalary: 0.29, workdaysPerMonth: 1 });
+  assert.equal(result.dailyCents, 29);
+  assert.equal(result.earnedCents, 29);
+});
+test('hourly and partial salary truncate rather than round', () => {
+  const result = at('2026-11-02T10:00:00+08:00', { payMode: 'daily', dailySalary: 100.01 });
+  assert.equal(result.earned, 12.5);
+  assert.equal(result.hourly, 12.5);
+});
+test('zero salary remains finite', () => {
+  const result = at('2026-11-02T10:00:00+08:00', { monthlySalary: 0 });
+  assert.equal(result.earned, 0);
+  assert.equal(result.hourly, 0);
+});
+test('scientific notation salaries use exact decimal arithmetic', () => {
+  assert.equal(at('2026-11-02T18:00:00+08:00', { payMode: 'daily', dailySalary: 1e-7 }).daily, 0);
+  assert.equal(at('2026-11-02T18:00:00+08:00', { payMode: 'daily', dailySalary: 1e7 }).daily, 1e7);
+});
+test('absolute timestamp and configured timezone determine local date and status', () => {
+  const timestamp = '2026-11-02T01:00:00Z';
+  assert.equal(at(timestamp).status, 'working');
+  assert.equal(at(timestamp, utc).status, 'before');
+  const la = at(timestamp, { timezone: 'America/Los_Angeles' });
+  assert.equal(la.status, 'rest');
+  assert.equal(la.date, '2026-11-01');
+});
+test('fractional-zone offset is handled independently of system timezone', () => {
+  const result = at('2026-11-02T03:15:00Z', { timezone: 'Asia/Kathmandu' });
+  assert.equal(result.status, 'working');
+  assert.equal(result.progress, 0);
+});
+test('DST spring night countdown measures real elapsed seconds', () => {
+  const patch = {
+    ...night,
+    timezone: 'America/New_York',
+    weekdays: [6],
+    breakStart: '00:00',
+    breakEnd: '00:00',
+  };
+  const result = at('2026-03-08T06:00:00Z', patch);
+  assert.equal(result.shiftDate, '2026-03-07');
+  assert.equal(result.total, 7 * 3600);
+  assert.equal(result.elapsed, 3 * 3600);
+  assert.equal(result.remaining, 4 * 3600);
+});
+test('DST fall night countdown includes the repeated hour', () => {
+  const patch = {
+    ...night,
+    timezone: 'America/New_York',
+    weekdays: [6],
+    breakStart: '00:00',
+    breakEnd: '00:00',
+  };
+  const result = at('2026-11-01T06:30:00Z', patch);
+  assert.equal(result.total, 9 * 3600);
+  assert.equal(result.elapsed, 4.5 * 3600);
+  assert.equal(result.remaining, 4.5 * 3600);
+});
+test('subsecond countdown rounds upwards and salary remains truncated', () => {
+  const result = at('2026-11-02T17:59:59.999+08:00');
+  assert.equal(result.remaining, 1);
+  assert.equal(result.earned, 499.99);
+});
+for (const [label, patch, begin] of [
+  ['monthly lunch', {}, '2026-11-02T00:00:00+08:00'],
+  [
+    'daily no lunch',
+    { payMode: 'daily', dailySalary: 109.99, breakStart: '00:00', breakEnd: '00:00' },
+    '2026-11-02T00:00:00+08:00',
+  ],
+  [
+    'night cross-midnight lunch',
+    { ...night, breakStart: '23:30', breakEnd: '00:30' },
+    '2026-11-02T22:00:00+08:00',
+  ],
+  ['decimal cents', { monthlySalary: 0.29, workdaysPerMonth: 1 }, '2026-11-02T00:00:00+08:00'],
+])
+  test(`whole-day minute grid: monotone and bounded (${label})`, () => {
+    let previous = 0;
+    const start = Date.parse(begin);
+    // Stop before the next civil day / shift resets its earnings.
+    const last = 1439;
+    for (let minute = 0; minute <= last; minute++) {
+      const result = calculate({ ...base, ...patch }, start + minute * 60000);
+      assert.ok(result.earnedCents >= previous, `${label} minute ${minute} regressed`);
+      assert.ok(result.earnedCents <= result.dailyCents);
+      assert.ok(result.progress >= 0 && result.progress <= 1);
+      assert.equal(Number.isInteger(result.earnedCents), true);
+      previous = result.earnedCents;
+    }
+    assert.equal(previous, calculate({ ...base, ...patch }, start).dailyCents);
+  });
+test('invalid empty shift or external break fails explicitly', () => {
+  assert.throws(() => at('2026-11-02T10:00:00Z', { start: '09:00', end: '09:00' }), RangeError);
+  assert.throws(
+    () => at('2026-11-02T10:00:00Z', { breakStart: '18:00', breakEnd: '19:00' }),
+    RangeError,
+  );
+});

package/tests/host.test.mjs

@@ -0,0 +1,221 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile, writeFile, stat, readdir, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join, resolve, dirname, basename } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { createOperations, DEFAULT_SETTINGS, validateSettings } from '../index.js';
+
+const source = new URL('../index.js', import.meta.url);
+const prefix = 'offwork-clock-host-';
+async function fixture(t) {
+  const root = resolve(tmpdir());
+  const dir = await mkdtemp(join(root, prefix));
+  t.after(async () => {
+    // Never recursively remove anything except our unique direct temporary child.
+    assert.equal(dirname(resolve(dir)), root);
+    assert.ok(basename(dir).startsWith(prefix));
+    assert.notEqual(resolve(dir), root);
+    await rm(dir, { recursive: true, force: true });
+  });
+  const file = join(dir, 'data.json');
+  return { dir, file, operate: createOperations(file) };
+}
+
+function valid(patch) {
+  return validateSettings({ ...DEFAULT_SETTINGS, ...patch });
+}
+
+test('defaults remain unsaved; real writes persist privately and can be reopened', async (t) => {
+  const { dir, file, operate } = await fixture(t);
+  const initial = await operate('get');
+  assert.deepEqual(initial, { ok: true, settings: DEFAULT_SETTINGS, configured: false });
+  initial.settings.weekdays.push(6);
+  assert.deepEqual((await operate('get')).settings.weekdays, [1, 2, 3, 4, 5]);
+  assert.deepEqual(await readdir(dir), []);
+  const saved = await operate('set', { payMode: 'daily', dailySalary: 500 });
+  assert.equal(saved.ok, true);
+  assert.equal(saved.configured, true);
+  assert.deepEqual(JSON.parse(await readFile(file, 'utf8')), saved.settings);
+  assert.equal((await stat(file)).mode & 0o777, 0o600);
+  assert.deepEqual(await createOperations(pathToFileURL(file))('get'), saved);
+  assert.deepEqual(await readdir(dir), ['data.json']);
+});
+
+test('legacy configuration gains only new defaults, without rewriting on get', async (t) => {
+  const { file, operate } = await fixture(t);
+  const { payMode, dailySalary, ...legacy } = DEFAULT_SETTINGS;
+  legacy.monthlySalary = 12345;
+  const bytes = JSON.stringify(legacy);
+  await writeFile(file, bytes);
+  const migrated = await operate('get');
+  assert.deepEqual(migrated, {
+    ok: true,
+    configured: true,
+    settings: { ...DEFAULT_SETTINGS, monthlySalary: 12345 },
+  });
+  assert.equal(await readFile(file, 'utf8'), bytes);
+  assert.equal((await operate('set', { dailySalary: 700 })).settings.monthlySalary, 12345);
+  assert.equal(JSON.parse(await readFile(file, 'utf8')).payMode, 'monthly');
+});
+
+test('malformed, unknown and incomplete saved data are never overwritten', async (t) => {
+  const { file, operate, dir } = await fixture(t);
+  for (const bytes of [
+    '{broken',
+    'null',
+    '[]',
+    JSON.stringify({ ...DEFAULT_SETTINGS, surprise: true }),
+    JSON.stringify({ start: '09:00' }),
+  ]) {
+    await writeFile(file, bytes);
+    assert.equal((await operate('get')).ok, false);
+    assert.equal((await operate('set', { monthlySalary: 5 })).ok, false);
+    assert.equal(await readFile(file, 'utf8'), bytes);
+    assert.deepEqual(await readdir(dir), ['data.json']);
+  }
+});
+
+test('day and overnight shifts normalize breaks against shift start', () => {
+  for (const patch of [
+    { start: '22:00', end: '06:00', breakStart: '02:00', breakEnd: '03:00' },
+    { start: '22:00', end: '06:00', breakStart: '23:30', breakEnd: '00:30' },
+    { start: '22:00', end: '06:00', breakStart: '22:00', breakEnd: '23:00' },
+    { start: '22:00', end: '06:00', breakStart: '05:00', breakEnd: '06:00' },
+    { start: '22:00', end: '06:00', breakStart: '12:00', breakEnd: '12:00' },
+    { breakStart: '00:00', breakEnd: '00:00' },
+  ])
+    assert.doesNotThrow(() => valid(patch));
+  for (const patch of [
+    { start: '09:00', end: '09:00' },
+    { start: '22:00', end: '06:00' },
+    { start: '22:00', end: '06:00', breakStart: '02:00', breakEnd: '01:00' },
+    { start: '22:00', end: '06:00', breakStart: '22:00', breakEnd: '06:00' },
+    { breakStart: '18:00', breakEnd: '19:00' },
+    { breakStart: '12:00', breakEnd: '11:00' },
+    { payMode: 'hourly' },
+    { dailySalary: -1 },
+    { dailySalary: Infinity },
+    { monthlySalary: NaN },
+    { workdaysPerMonth: 0 },
+    { start: '9:00' },
+    { weekdays: [1, 1] },
+    { timezone: 'not/a-zone' },
+    { surprise: true },
+  ])
+    assert.throws(() => valid(patch), JSON.stringify(patch));
+});
+
+test('invalid patches and actions do not create files; queue recovers', async (t) => {
+  const { dir, operate } = await fixture(t);
+  for (const [action, patch] of [
+    ['wat'],
+    ['get', {}],
+    ['set'],
+    ['set', []],
+    ['set', { unknown: 1 }],
+    ['set', { payMode: 'weekly' }],
+  ]) {
+    assert.equal((await operate(action, patch)).ok, false);
+  }
+  assert.deepEqual(await readdir(dir), []);
+  assert.equal((await operate('set', {})).configured, true);
+});
+
+test('concurrent partial sets serialize and preserve preceding updates', async (t) => {
+  const { file, operate, dir } = await fixture(t);
+  const patches = [
+    { monthlySalary: 22222 },
+    { dailySalary: 999 },
+    { payMode: 'daily' },
+    { timezone: 'UTC' },
+  ];
+  const pending = patches.map((patch) => operate('set', patch));
+  pending.push(operate('set', { unknown: true }));
+  for (let i = 0; i < 30; i++) pending.push(operate('set', { dailySalary: 1000 + i }));
+  const results = await Promise.all(pending);
+  assert.equal(results[4].ok, false);
+  assert.ok(results.filter((_, i) => i !== 4).every((result) => result.ok));
+  const expected = { ...DEFAULT_SETTINGS, ...Object.assign({}, ...patches), dailySalary: 1029 };
+  assert.deepEqual(JSON.parse(await readFile(file, 'utf8')), expected);
+  assert.deepEqual((await operate('get')).settings, expected);
+  assert.deepEqual(await readdir(dir), ['data.json']);
+});
+
+async function adapters(t) {
+  const fixtureData = await fixture(t);
+  // Import an isolated copy: apply() keeps its real default data URL beside the module,
+  // and neither adapter can accidentally reach the user's actual data.json.
+  const moduleFile = join(fixtureData.dir, 'host.mjs');
+  await writeFile(moduleFile, await readFile(source, 'utf8'));
+  const module = await import(pathToFileURL(moduleFile).href);
+  let command;
+  let tool;
+  module.apply({
+    effect: (effect) => effect(),
+    commands: {
+      register(definition) {
+        command = definition;
+        return () => {};
+      },
+    },
+    tools: {
+      register(definition) {
+        tool = definition;
+        return () => {};
+      },
+    },
+  });
+  const runCommand = async (rawInput) => {
+    const response = await command.handler({ rawInput });
+    const result = JSON.parse(response.text);
+    assert.equal(response.kind, result.ok ? 'success' : 'error');
+    return result;
+  };
+  return { ...fixtureData, tool, command, runCommand };
+}
+
+test('command and tool share results, validation, storage and a write queue', async (t) => {
+  const { tool, command, runCommand, file } = await adapters(t);
+  assert.equal(command.recordInput, false);
+  assert.deepEqual(await runCommand('get'), await tool.execute({ action: 'get' }));
+  const written = await runCommand('set {"payMode":"daily","dailySalary":600}');
+  assert.deepEqual(await tool.execute({ action: 'get' }), written);
+  const second = await tool.execute({ action: 'set', settings: { monthlySalary: 25000 } });
+  assert.deepEqual(await runCommand('get'), second);
+  assert.deepEqual(
+    await runCommand('set {"unknown":1}'),
+    await tool.execute({ action: 'set', settings: { unknown: 1 } }),
+  );
+  await Promise.all([
+    runCommand('set {"dailySalary":750}'),
+    tool.execute({ action: 'set', settings: { timezone: 'UTC' } }),
+  ]);
+  const stored = JSON.parse(await readFile(file, 'utf8'));
+  assert.equal(stored.dailySalary, 750);
+  assert.equal(stored.timezone, 'UTC');
+  for (const raw of ['get {}', 'set', 'set {bad', 'wat'])
+    assert.equal((await runCommand(raw)).ok, false);
+  for (const args of [null, [], { action: 'get', unknown: true }])
+    assert.equal((await tool.execute(args)).ok, false);
+});
+
+test('tool schemas expose new fields, configured flag, and typed literal branches', async (t) => {
+  const { tool } = await adapters(t);
+  const input = tool.parameters.properties.settings;
+  assert.equal(input.additionalProperties, false);
+  assert.deepEqual(input.properties.payMode.enum, ['monthly', 'daily']);
+  assert.equal(input.properties.dailySalary.type, 'number');
+  const [success, failure] = tool.output.schema.oneOf;
+  assert.deepEqual(success.properties.ok, { type: 'boolean', const: true });
+  assert.deepEqual(failure.properties.ok, { type: 'boolean', const: false });
+  assert.ok(success.required.includes('configured'));
+  assert.equal(success.properties.configured.type, 'boolean');
+  assert.deepEqual(success.properties.settings.required, Object.keys(DEFAULT_SETTINGS));
+  assert.equal(success.additionalProperties, false);
+  assert.equal(failure.additionalProperties, false);
+  const result = await tool.execute({ action: 'get' });
+  assert.deepEqual(tool.output.render({}, result), [
+    { type: 'text', text: JSON.stringify(result) },
+  ]);
+});

package/tests/ui.test.mjs

@@ -0,0 +1,132 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import {
+  formatDuration,
+  clampPosition,
+  normalizeView,
+  clampOpacity,
+  decodeCommand,
+  changedSettings,
+} from '../ui-utils.js';
+test('duration rounds countdown upward and supports >24 hours', () => {
+  assert.equal(formatDuration(0), '00:00:00');
+  assert.equal(formatDuration(3661), '01:01:01');
+  assert.equal(formatDuration(0.1), '00:00:01');
+  assert.equal(formatDuration(90000), '25:00:00');
+  assert.equal(formatDuration(NaN), '--:--:--');
+  assert.equal(formatDuration(-1), '--:--:--');
+});
+test('position stays visible when viewport shrinks', () => {
+  assert.deepEqual(
+    clampPosition({ x: 9000, y: -20 }, { width: 800, height: 600 }, { width: 330, height: 400 }),
+    { x: 458, y: 12 },
+  );
+  assert.deepEqual(clampPosition(null, { width: 200, height: 200 }, { width: 330, height: 400 }), {
+    x: 12,
+    y: 12,
+  });
+});
+test('view defaults: compact, salary hidden, 82% glass', () => {
+  assert.deepEqual(normalizeView(null), {
+    mini: true,
+    masked: true,
+    opacity: 0.82,
+    position: null,
+  });
+  assert.deepEqual(
+    normalizeView({ mini: false, masked: false, opacity: 0.5, position: { x: 1, y: 2 } }),
+    { mini: false, masked: false, opacity: 0.5, position: { x: 1, y: 2 } },
+  );
+  assert.equal(normalizeView({ mini: 'yes' }).mini, true);
+  assert.equal(normalizeView({ masked: 'false' }).masked, true);
+});
+test('malformed positions and opacity are repaired, not trusted', () => {
+  assert.deepEqual(normalizeView({ mini: 'yes', masked: true, position: { x: 'oops', y: 2 } }), {
+    mini: true,
+    masked: true,
+    opacity: 0.82,
+    position: null,
+  });
+  assert.equal(normalizeView({ opacity: 0 }).opacity, 0.3);
+  assert.equal(normalizeView({ opacity: 9 }).opacity, 1);
+  assert.equal(normalizeView({ opacity: 'x' }).opacity, 0.82);
+  assert.equal(clampOpacity(0.55), 0.55);
+});
+test('salary stays hidden until explicitly revealed, including on first paint', () => {
+  assert.equal(normalizeView(null).masked, true);
+  assert.equal(normalizeView({}).masked, true);
+  assert.equal(normalizeView({ masked: false }).masked, false);
+});
+test('RPC decodes every failure layer and real command envelopes', () => {
+  const response = (data, kind = 'success') => ({
+    ok: true,
+    value: { result: { kind, text: JSON.stringify(data) } },
+  });
+  assert.deepEqual(
+    decodeCommand(response({ ok: true, settings: { monthlySalary: 1000 }, configured: true }))
+      .settings,
+    { monthlySalary: 1000 },
+  );
+  assert.throws(
+    () => decodeCommand({ ok: false, error: { message: 'permission denied' } }),
+    /permission denied/,
+  );
+  assert.throws(() => decodeCommand({ ok: true }), /Command unavailable/);
+  assert.throws(
+    () => decodeCommand(response({ ok: false, error: 'bad shift' }, 'error')),
+    /bad shift/,
+  );
+  assert.throws(
+    () => decodeCommand({ ok: true, value: { result: { kind: 'success', text: 'oops' } } }),
+    /Invalid/,
+  );
+});
+test('partial saves preserve unrelated edits from another caller', () => {
+  assert.deepEqual(
+    changedSettings(
+      { salary: 1, days: [1, 2], start: '09:00' },
+      { salary: 2, days: [1, 2], start: '09:00' },
+    ),
+    { salary: 2 },
+  );
+});
+test('Client uses the exact tested engine and a single surface', async () => {
+  const source = await readFile(new URL('../client.source.js', import.meta.url), 'utf8');
+  const built = await readFile(new URL('../client.js', import.meta.url), 'utf8');
+  const engine = (await readFile(new URL('../clock.js', import.meta.url), 'utf8')).replace(
+    /^export /gm,
+    '',
+  );
+  assert.ok(built.includes(engine));
+  assert.match(source, /prefers-reduced-motion:reduce/);
+  assert.match(source, /prefers-reduced-transparency:reduce/);
+  assert.match(source, /visibilitychange/);
+  assert.match(source, /removeEventListener\('storage'/);
+  assert.match(source, /ro\?\.disconnect/);
+  assert.match(source, /generation\.current/);
+  assert.doesNotMatch(source, /document\.body|window\.open|fetch\(/);
+  assert.match(source, /money\(safeState\.earned\)/);
+  assert.match(source, /owc-glass/);
+  assert.match(source, /--owc-alpha/);
+  assert.match(source, /type: 'range'/);
+  assert.match(source, /dragState/);
+  assert.ok(source.includes('onPointerMove: dragMove'));
+});
+test('compact strip stacks time above amount', async () => {
+  const source = await readFile(new URL('../client.source.js', import.meta.url), 'utf8');
+  const css = source.slice(source.indexOf('.owc-pill{'), source.indexOf('.owc-pill{') + 200);
+  assert.match(css, /flex-direction:column/);
+  assert.match(source, /className: 'owc-pill-top'/);
+  assert.match(source, /className: 'owc-pill-bottom'/);
+  assert.ok(
+    source.indexOf("className: 'owc-pill-time'") < source.indexOf("className: 'owc-pill-money'"),
+  );
+});
+test('compact strip keeps both drag surface and expand action; panel keeps collapse', async () => {
+  const source = await readFile(new URL('../client.source.js', import.meta.url), 'utf8');
+  assert.match(source, /onPointerDown: dragDown/);
+  assert.match(source, /mini: false/);
+  assert.match(source, /mini: true/);
+  assert.match(source, /hasPointerCapture/);
+});

package/tools/build.mjs

@@ -0,0 +1,28 @@
+import { readFile, writeFile } from 'node:fs/promises';
+
+const root = new URL('../', import.meta.url);
+const moduleNames = ['client.source.js', 'clock.js', 'ui-utils.js'];
+const [entry, ...modules] = await Promise.all(
+  moduleNames.map((name) => readFile(new URL(name, root), 'utf8')),
+);
+const marker = '/* PURE_MODULES */';
+if (entry.split(marker).length !== 2) {
+  throw new Error('Expected exactly one pure-module marker in client.source.js');
+}
+
+// Preserve the pure modules verbatim apart from exports so the browser runs
+// the same implementation that the Node.js tests import.
+const pure = modules.map((source) => source.replace(/^export /gm, '')).join('\n');
+const banner = '// Generated by tools/build.mjs; edit client.source.js, clock.js or ui-utils.js.\n';
+const result = banner + entry.replace(marker, pure);
+const output = new URL('client.js', root);
+
+if (process.argv.includes('--check')) {
+  if ((await readFile(output, 'utf8')) !== result) {
+    throw new Error('Client artifact is stale. Run npm run build and commit client.js.');
+  }
+  console.log('Client artifact matches tested source');
+} else {
+  await writeFile(output, result);
+  console.log('Built client.js from one calculation source');
+}