dsh-offwork 1.0.0 → 1.0.1

package/tests/clock.test.mjs

@@ -3,23 +3,35 @@ 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',
+  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);
-});
+  ['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');
@@ -65,7 +77,11 @@ test('night break after midnight is normalized into the shift', () => {
   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' });
+  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);
 });
@@ -109,7 +125,10 @@ test('configured Sunday workday overrides weekday assumptions', () => {
 });
 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,
+    payMode: 'daily',
+    dailySalary: 123.459,
+    monthlySalary: undefined,
+    workdaysPerMonth: undefined,
   });
   assert.equal(result.payMode, 'daily');
   assert.equal(result.daily, 123.45);
@@ -148,7 +167,13 @@ test('fractional-zone offset is handled independently of system timezone', () =>
   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 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);
@@ -156,7 +181,13 @@ test('DST spring night countdown measures real elapsed seconds', () => {
   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 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);
@@ -169,25 +200,37 @@ test('subsecond countdown rounds upwards and salary remains truncated', () => {
 });
 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'],
+  [
+    '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(`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);
+  assert.throws(
+    () => at('2026-11-02T10:00:00Z', { breakStart: '18:00', breakEnd: '19:00' }),
+    RangeError,
+  );
 });

package/tests/host.test.mjs

@@ -22,9 +22,11 @@ async function fixture(t) {
   return { dir, file, operate: createOperations(file) };
 }
 
-function valid(patch) { return validateSettings({ ...DEFAULT_SETTINGS, ...patch }); }
+function valid(patch) {
+  return validateSettings({ ...DEFAULT_SETTINGS, ...patch });
+}
 
-test('defaults remain unsaved; real writes persist privately and can be reopened', async t => {
+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 });
@@ -40,22 +42,32 @@ test('defaults remain unsaved; real writes persist privately and can be reopened
   assert.deepEqual(await readdir(dir), ['data.json']);
 });
 
-test('legacy configuration gains only new defaults, without rewriting on get', async t => {
+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.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 => {
+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' })]) {
+  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);
@@ -72,7 +84,8 @@ test('day and overnight shifts normalize breaks against shift start', () => {
     { 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));
+  ])
+    assert.doesNotThrow(() => valid(patch));
   for (const patch of [
     { start: '09:00', end: '09:00' },
     { start: '22:00', end: '06:00' },
@@ -80,30 +93,49 @@ test('day and overnight shifts normalize breaks against shift start', () => {
     { 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));
+    { 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 => {
+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' }]]) {
+  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 => {
+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));
+  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));
+  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);
@@ -120,11 +152,21 @@ async function adapters(t) {
   let command;
   let tool;
   module.apply({
-    effect: effect => effect(),
-    commands: { register(definition) { command = definition; return () => {}; } },
-    tools: { register(definition) { tool = definition; return () => {}; } },
+    effect: (effect) => effect(),
+    commands: {
+      register(definition) {
+        command = definition;
+        return () => {};
+      },
+    },
+    tools: {
+      register(definition) {
+        tool = definition;
+        return () => {};
+      },
+    },
   });
-  const runCommand = async rawInput => {
+  const runCommand = async (rawInput) => {
     const response = await command.handler({ rawInput });
     const result = JSON.parse(response.text);
     assert.equal(response.kind, result.ok ? 'success' : 'error');
@@ -133,7 +175,7 @@ async function adapters(t) {
   return { ...fixtureData, tool, command, runCommand };
 }
 
-test('command and tool share results, validation, storage and a write queue', async t => {
+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' }));
@@ -141,7 +183,10 @@ test('command and tool share results, validation, storage and a write queue', as
   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 } }));
+  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' } }),
@@ -149,11 +194,13 @@ test('command and tool share results, validation, storage and a write queue', as
   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);
+  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 => {
+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);
@@ -168,5 +215,7 @@ test('tool schemas expose new fields, configured flag, and typed literal branche
   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) }]);
+  assert.deepEqual(tool.output.render({}, result), [
+    { type: 'text', text: JSON.stringify(result) },
+  ]);
 });

package/tests/ui.test.mjs

@@ -1,25 +1,53 @@
 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';
+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(.1), '00:00:01'); assert.equal(formatDuration(90000), '25:00:00');
-  assert.equal(formatDuration(NaN), '--:--:--'); assert.equal(formatDuration(-1), '--:--:--');
+  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 });
+  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.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.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);
@@ -31,25 +59,52 @@ test('salary stays hidden until explicitly revealed, including on first paint',
   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/);
+  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/);
+  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 });
+  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, '');
+  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.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/);
@@ -64,7 +119,9 @@ test('compact strip stacks time above amount', async () => {
   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'"));
+  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');

package/tools/build.mjs

@@ -1,13 +1,28 @@
 import { readFile, writeFile } from 'node:fs/promises';
+
 const root = new URL('../', import.meta.url);
-const [entry, clock, utils] = await Promise.all(['client.source.js','clock.js','ui-utils.js'].map(name=>readFile(new URL(name,root),'utf8')));
-if (entry.split('/* PURE_MODULES */').length !== 2) throw new Error('Expected exactly one pure-module marker');
-const pure = [clock,utils].map(text=>text.replace(/^export /gm,'')).join('\n');
-const result = '// Generated by tools/build.mjs; edit client.source.js, clock.js or ui-utils.js.\n'+entry.replace('/* PURE_MODULES */',pure);
-if(process.argv.includes('--check')) {
-  if(await readFile(new URL('client.js',root),'utf8')!==result) throw new Error('Client artifact is stale');
+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(new URL('client.js',root),result);
+  await writeFile(output, result);
   console.log('Built client.js from one calculation source');
 }

package/tools/check-package.mjs

@@ -0,0 +1,96 @@
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { readFile, readdir } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+
+const root = new URL('../', import.meta.url);
+const cwd = fileURLToPath(root);
+const read = (path) => readFile(new URL(path, root), 'utf8');
+const pkg = JSON.parse(await read('package.json'));
+
+assert.equal(pkg.name, 'dsh-offwork');
+assert.equal(pkg.type, 'module');
+assert.equal(pkg.license, 'MIT');
+assert.equal(pkg.repository.url, 'git+https://github.com/SnowBeatRain/dsh-offwork.git');
+assert.ok(pkg.engines?.dsh, 'Declare the supported Harness versions');
+assert.equal(pkg.dsh?.bundle?.patch, './cordis.patch.yml');
+assert.equal(pkg.dsh?.client?.platform, 'web');
+assert.match(await read('LICENSE'), /^MIT License/);
+
+// This check covers this project's patch; Harness composition remains the
+// authoritative check that the bundle can be installed in a real profile.
+const patch = await read('cordis.patch.yml');
+assert.match(patch, /^- insert:/m);
+assert.match(patch, /^\s+- id: offwork-clock\s*$/m);
+assert.match(patch, /^\s+name: ['"]?dsh-offwork['"]?\s*$/m);
+
+for (const lifecycle of ['preinstall', 'install', 'postinstall', 'prepare']) {
+  assert.equal(pkg.scripts?.[lifecycle], undefined, `Unexpected install script: ${lifecycle}`);
+}
+for (const name of Object.keys(pkg.dependencies ?? {})) {
+  assert.ok(!name.startsWith('@deepseek-ai/'), `${name} belongs in peerDependencies`);
+}
+
+const sourceFiles = [];
+for (const directory of ['', 'tests/', 'tools/']) {
+  for (const entry of await readdir(new URL(directory || '.', root), { withFileTypes: true })) {
+    if (entry.isFile() && /\.(?:js|mjs)$/.test(entry.name)) {
+      sourceFiles.push(directory + entry.name);
+    }
+  }
+}
+for (const path of sourceFiles) {
+  execFileSync(process.execPath, ['--check', path], { cwd, stdio: 'pipe' });
+}
+
+for (const language of ['zh', 'en']) {
+  const locale = JSON.parse(await read(`locale/${language}.json`));
+  assert.equal(typeof locale.meta?.title, 'string');
+  assert.ok(locale.meta.title.length > 0);
+  assert.equal(typeof locale.meta?.description, 'string');
+  assert.ok(locale.meta.description.length > 0);
+}
+
+// Ignore lifecycle scripts here: this checker also runs inside prepublishOnly.
+// Inspect npm's actual package file list, rather than relying on .gitignore.
+const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+const [packed] = JSON.parse(
+  execFileSync(npm, ['pack', '--dry-run', '--json', '--ignore-scripts'], {
+    cwd,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  }),
+);
+const files = new Set(packed.files.map((file) => file.path));
+assert.equal(packed.name, pkg.name);
+assert.equal(packed.version, pkg.version);
+for (const path of [
+  'package.json',
+  'index.js',
+  'client.js',
+  'cordis.patch.yml',
+  'icon.svg',
+  'locale/zh.json',
+  'locale/en.json',
+  'README.md',
+  'LICENSE',
+]) {
+  assert.ok(files.has(path), `Missing package file: ${path}`);
+}
+for (const target of Object.values(pkg.exports)) {
+  if (typeof target === 'string' && !target.includes('*')) {
+    assert.ok(files.has(target.replace(/^\.\//, '')), `Missing export: ${target}`);
+  }
+}
+for (const path of files) {
+  assert.ok(
+    !/(^|\/)(?:data\.json|\.data-[^/]*|\.env(?:\.[^/]*)?|\.npmrc|\.git(?:\/|$)|node_modules(?:\/|$))/.test(
+      path,
+    ),
+    `Local settings or credentials included in package: ${path}`,
+  );
+  assert.ok(!path.endsWith('.tgz'), `Nested package archive: ${path}`);
+}
+console.log(
+  `Package checks passed: ${sourceFiles.length} JavaScript files, ${files.size} packed files.`,
+);