dsh-offwork 0.0.0-stage → 1.0.0

package/clock.js

@@ -0,0 +1,103 @@
+// Pure calculation. Weekdays belong to the shift's START date, not the clock date.
+// Keep helpers inside calculate: the client build embeds this exact function.
+export function calculate(settings, timestamp = Date.now()) {
+  const now = Number(timestamp);
+  if (!Number.isFinite(now)) throw new RangeError('Invalid timestamp');
+  const DAY = 86400000;
+  const formatter = new Intl.DateTimeFormat('en-CA', {
+    timeZone: settings.timezone, year: 'numeric', month: '2-digit', day: '2-digit',
+    hour: '2-digit', minute: '2-digit', second: '2-digit', hourCycle: 'h23',
+  });
+  const civil = time => {
+    const p = Object.fromEntries(formatter.formatToParts(time).map(p => [p.type, p.value]));
+    return Date.UTC(+p.year, +p.month - 1, +p.day, +p.hour, +p.minute, +p.second);
+  };
+  // Convert a timezone-local civil time to an absolute instant. At DST overlaps use
+  // the earlier occurrence; at gaps move forward by the gap (Temporal-compatible).
+  const instant = local => {
+    const offsets = [...new Set([-DAY, 0, DAY].map(delta => civil(local + delta) - (local + delta)))];
+    const candidates = offsets.map(offset => local - offset);
+    const exact = candidates.filter(time => civil(time) === local);
+    if (exact.length) return Math.min(...exact);
+    const after = candidates.filter(time => civil(time) >= local);
+    return Math.min(...(after.length ? after : candidates));
+  };
+  const minute = text => {
+    if (typeof text !== 'string' || !/^(?:[01]\d|2[0-3]):[0-5]\d$/.test(text)) {
+      throw new RangeError('Shift times must be HH:mm');
+    }
+    const [h, m] = text.split(':').map(Number);
+    return h * 60 + m;
+  };
+  const start = minute(settings.start), end = minute(settings.end);
+  if (start === end) throw new RangeError('Shift must not be empty');
+  const overnight = end < start;
+  const duration = (end - start + 1440) % 1440;
+  let breakOffset = 0, breakDuration = 0;
+  if (settings.breakStart != null || settings.breakEnd != null) {
+    const bs = minute(settings.breakStart), be = minute(settings.breakEnd);
+    if (bs !== be) {
+      breakOffset = (bs - start + 1440) % 1440;
+      breakDuration = (be - bs + 1440) % 1440;
+      if (breakOffset + breakDuration > duration || breakDuration >= duration) {
+        throw new RangeError('Break must be inside the shift and leave paid work');
+      }
+    }
+  }
+  const localNow = civil(now);
+  const today = Math.floor(localNow / DAY) * DAY;
+  const minuteNow = (localNow - today) / 60000;
+  const workday = day => settings.weekdays.includes(new Date(day).getUTCDay());
+  let shiftDay = today;
+  if (overnight && minuteNow < start) {
+    // Retain yesterday's finished work shift until the next shift starts. If
+    // yesterday was off, a working today is 'before' (e.g. Monday daytime).
+    if (minuteNow < end || workday(today - DAY)) shiftDay -= DAY;
+  }
+  const isWorkday = workday(shiftDay);
+  const shiftStart = instant(shiftDay + start * 60000);
+  const shiftEnd = instant(shiftDay + (start + duration) * 60000);
+  const breakStart = breakDuration ? instant(shiftDay + (start + breakOffset) * 60000) : null;
+  const breakEnd = breakDuration ? instant(shiftDay + (start + breakOffset + breakDuration) * 60000) : null;
+  const breakMs = breakDuration ? breakEnd - breakStart : 0;
+  const totalMs = shiftEnd - shiftStart - breakMs;
+  if (totalMs <= 0 || breakMs < 0) throw new RangeError('Shift has no paid duration');
+  const clampedNow = Math.max(shiftStart, Math.min(now, shiftEnd));
+  const elapsedMs = isWorkday ? Math.max(0, Math.min(totalMs,
+    clampedNow - shiftStart - (breakDuration ? Math.max(0, Math.min(clampedNow, breakEnd) - breakStart) : 0))) : 0;
+  const status = !isWorkday ? 'rest' : now < shiftStart ? 'before' : now >= shiftEnd ? 'done'
+    : breakDuration && now >= breakStart && now < breakEnd ? 'lunch' : 'working';
+  // Decimal inputs become exact rational numbers before truncation. Never use
+  // floor((salary / days * progress) * 100): binary rounding loses whole cents.
+  const rational = number => {
+    if (typeof number !== 'number' || !Number.isFinite(number) || number < 0) throw new RangeError('Invalid salary');
+    const [mantissa, exponent = '0'] = String(number).toLowerCase().split('e');
+    const [integer, fraction = ''] = mantissa.split('.');
+    const scale = fraction.length - Number(exponent);
+    return scale >= 0 ? [BigInt(integer + fraction), 10n ** BigInt(scale)]
+      : [BigInt(integer + fraction) * 10n ** BigInt(-scale), 1n];
+  };
+  const payMode = settings.payMode === 'daily' ? 'daily' : 'monthly';
+  let [numerator, denominator] = rational(payMode === 'daily' ? settings.dailySalary : settings.monthlySalary);
+  if (payMode === 'monthly') {
+    const [daysN, daysD] = rational(settings.workdaysPerMonth);
+    if (daysN === 0n) throw new RangeError('Workdays per month must be positive');
+    numerator *= daysD;
+    denominator *= daysN;
+  }
+  const dailyCents = Number(numerator * 100n / denominator);
+  const earnedCents = Math.min(dailyCents, Number(numerator * 100n * BigInt(Math.floor(elapsedMs)) /
+    (denominator * BigInt(totalMs))));
+  const hourlyCents = Number(numerator * 100n * 3600000n / (denominator * BigInt(totalMs)));
+  const dateString = day => new Date(day).toISOString().slice(0, 10);
+  return {
+    status, remaining: isWorkday ? Math.max(0, Math.ceil((shiftEnd - now) / 1000)) : 0,
+    startRemaining: status === 'before' ? Math.max(0, Math.ceil((shiftStart - now) / 1000)) : 0,
+    progress: elapsedMs / totalMs,
+    earned: earnedCents / 100, daily: dailyCents / 100, hourly: hourlyCents / 100,
+    date: dateString(today), shiftDate: dateString(shiftDay),
+    earnedCents, dailyCents, payMode, isWorkday, overnight,
+    shiftStart, shiftEnd, breakStart, breakEnd,
+    elapsed: elapsedMs / 1000, total: totalMs / 1000,
+  };
+}

package/cordis.patch.yml

@@ -0,0 +1,4 @@
+- insert:
+    - id: offwork-clock
+      name: 'dsh-offwork'
+      config: {}

package/icon.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64"><rect width="64" height="64" rx="16" fill="#167a69"/><circle cx="29" cy="28" r="18" fill="none" stroke="#fff" stroke-width="4"/><path d="M29 17v12l8 5" fill="none" stroke="#fff" stroke-width="4" stroke-linecap="round"/><circle cx="46" cy="46" r="13" fill="#f6d376"/><path d="m40 40 6 7 6-7m-6 7v8m-6-7h12m-12 4h12" fill="none" stroke="#31534a" stroke-width="2.5"/></svg>

package/index.js

@@ -0,0 +1,198 @@
+import { readFile, writeFile, rename, unlink, chmod } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const inject = ['commands', 'tools'];
+
+export const DEFAULT_SETTINGS = Object.freeze({
+  payMode: 'monthly',
+  monthlySalary: 10000,
+  dailySalary: 400,
+  workdaysPerMonth: 21.75,
+  start: '09:00',
+  end: '18:00',
+  breakStart: '12:00',
+  breakEnd: '13:00',
+  weekdays: Object.freeze([1, 2, 3, 4, 5]),
+  timezone: 'Asia/Shanghai',
+});
+
+const dataFile = new URL('./data.json', import.meta.url);
+const keys = Object.keys(DEFAULT_SETTINGS);
+const isObject = value => value !== null && typeof value === 'object' && !Array.isArray(value);
+const fail = error => ({ ok: false, error: error instanceof Error ? error.message : String(error) });
+
+function validatePatch(value) {
+  if (!isObject(value)) throw new Error('settings 必须是 JSON 对象。');
+  for (const key of Object.keys(value)) {
+    if (!keys.includes(key)) throw new Error(`未知配置字段：${key}`);
+  }
+}
+
+export function validateSettings(value) {
+  validatePatch(value);
+  for (const key of keys) {
+    if (!Object.hasOwn(value, key)) throw new Error(`缺少配置字段：${key}`);
+  }
+  if (value.payMode !== 'monthly' && value.payMode !== 'daily') {
+    throw new Error('payMode 必须是 monthly 或 daily。');
+  }
+  if (typeof value.dailySalary !== 'number' || !Number.isFinite(value.dailySalary) || value.dailySalary < 0) {
+    throw new Error('dailySalary 必须是大于等于 0 的有限数字。');
+  }
+  if (typeof value.monthlySalary !== 'number' || !Number.isFinite(value.monthlySalary) || value.monthlySalary < 0) {
+    throw new Error('monthlySalary 必须是大于等于 0 的有限数字。');
+  }
+  if (typeof value.workdaysPerMonth !== 'number' || !Number.isFinite(value.workdaysPerMonth) || value.workdaysPerMonth <= 0) {
+    throw new Error('workdaysPerMonth 必须是大于 0 的有限数字。');
+  }
+  const minutes = key => {
+    if (typeof value[key] !== 'string' || !/^(?:[01]\d|2[0-3]):[0-5]\d$/.test(value[key])) {
+      throw new Error(`${key} 必须是 24 小时制 HH:mm。`);
+    }
+    const [hour, minute] = value[key].split(':').map(Number);
+    return hour * 60 + minute;
+  };
+  const start = minutes('start');
+  const end = minutes('end');
+  const breakStart = minutes('breakStart');
+  const breakEnd = minutes('breakEnd');
+  if (end === start) throw new Error('start 和 end 不能相同。');
+  const relative = minute => (minute - start + 1440) % 1440;
+  const duration = relative(end);
+  if (breakStart !== breakEnd) {
+    const from = relative(breakStart);
+    const to = relative(breakEnd);
+    if (from >= to || to > duration) {
+      throw new Error('午休必须按班次起点顺序落在班次内。');
+    }
+    if (to - from >= duration) throw new Error('午休不能占满整个班次。');
+  }
+  if (!Array.isArray(value.weekdays) || value.weekdays.length === 0 ||
+      value.weekdays.some(day => !Number.isInteger(day) || day < 0 || day > 6) ||
+      new Set(value.weekdays).size !== value.weekdays.length) {
+    throw new Error('weekdays 必须是非空、不重复的 0–6 整数数组（0 为周日）。');
+  }
+  if (typeof value.timezone !== 'string' || value.timezone.length === 0 || value.timezone.trim() !== value.timezone) {
+    throw new Error('timezone 必须是有效时区名称。');
+  }
+  try { new Intl.DateTimeFormat('en', { timeZone: value.timezone }); }
+  catch { throw new Error('timezone 必须是有效时区名称。'); }
+  return { ...value, weekdays: [...value.weekdays] };
+}
+
+// One local persistence owner, shared by the command and tool adapters.
+// Reads never persist defaults. Writes are serialized and atomically replace a 0600 file.
+export function createOperations(dataFileArg = dataFile) {
+  const target = dataFileArg instanceof URL ? fileURLToPath(dataFileArg) : resolve(dataFileArg);
+  let queue = Promise.resolve();
+  async function read() {
+    let text;
+    try { text = await readFile(target, 'utf8'); }
+    catch (error) {
+      if (error.code === 'ENOENT') return { settings: validateSettings(DEFAULT_SETTINGS), configured: false };
+      throw new Error('无法读取本机配置。');
+    }
+    try {
+      const stored = JSON.parse(text);
+      validatePatch(stored);
+      // Only the newly introduced fields are optional in legacy files.
+      const settings = validateSettings({ payMode: DEFAULT_SETTINGS.payMode, dailySalary: DEFAULT_SETTINGS.dailySalary, ...stored });
+      return { settings, configured: true };
+    } catch { throw new Error('本机配置损坏或无效；请检查插件目录 data.json。'); }
+  }
+  async function write(settings) {
+    const temp = join(dirname(target), `.data-${randomUUID()}.tmp`);
+    try {
+      await writeFile(temp, `${JSON.stringify(settings, null, 2)}\n`, { mode: 0o600, flag: 'wx' });
+      await chmod(temp, 0o600);
+      await rename(temp, target);
+    } catch {
+      throw new Error('无法保存本机配置。');
+    } finally {
+      await unlink(temp).catch(() => {});
+    }
+  }
+  return function operate(action, patch) {
+    const operation = queue.then(async () => {
+      try {
+        if (action !== 'get' && action !== 'set') throw new Error('action 必须是 get 或 set。');
+        if (action === 'get' && patch !== undefined) throw new Error('get 不接受 settings。');
+        if (action === 'set') validatePatch(patch);
+        const current = await read();
+        if (action === 'get') return { ok: true, ...current };
+        const settings = validateSettings({ ...current.settings, ...patch });
+        await write(settings);
+        return { ok: true, settings, configured: true };
+      } catch (error) { return fail(error); }
+    });
+    queue = operation.then(() => {}, () => {});
+    return operation;
+  };
+}
+
+const settingsSchema = {
+  type: 'object', additionalProperties: false,
+  description: '要合并保存的配置字段。时间使用 HH:mm。',
+  properties: {
+    payMode: { type: 'string', enum: ['monthly', 'daily'], description: '计薪方式，默认 monthly（月薪）；daily 为日薪。' },
+    dailySalary: { type: 'number', description: '日薪，有限数字且 >= 0，默认 400。' },
+    monthlySalary: { type: 'number', description: '月薪，有限数字且 >= 0。' },
+    workdaysPerMonth: { type: 'number', description: '每月工作日数，有限数字且 > 0。' },
+    start: { type: 'string', description: '上班时间 HH:mm。' },
+    end: { type: 'string', description: '下班时间 HH:mm；早于上班表示次日，不能与上班相同。' },
+    breakStart: { type: 'string', description: '休息开始 HH:mm。' },
+    breakEnd: { type: 'string', description: '休息结束 HH:mm；与开始相同即关闭，否则按班次顺序在班次内，且不能占满班次。' },
+    weekdays: { type: 'array', items: { type: 'integer', enum: [0, 1, 2, 3, 4, 5, 6] }, description: '非空、不重复；0 为周日，1 为周一。' },
+    timezone: { type: 'string', description: '有效时区，例如 Asia/Shanghai。' },
+  },
+};
+
+export function apply(ctx) {
+  const operate = createOperations();
+  ctx.effect(() => ctx.commands.register({
+    name: 'offwork-clock',
+    description: '读取或保存本机下班时钟配置：get 或 set JSON。',
+    input: { hint: 'get | set {"monthlySalary":10000}' },
+    recordInput: false,
+    async handler({ rawInput }) {
+      let result;
+      try {
+        const match = /^(get|set)(?:\s+([\s\S]*))?$/.exec(rawInput.trim());
+        if (!match) throw new Error('用法：/offwork-clock get 或 /offwork-clock set JSON');
+        const [, action, json] = match;
+        if (action === 'get' && json !== undefined) throw new Error('get 不接受参数。');
+        if (action === 'set' && !json?.trim()) throw new Error('set 需要 JSON 配置对象。');
+        result = await operate(action, action === 'set' ? JSON.parse(json) : undefined);
+      } catch (error) { result = fail(error); }
+      return { kind: result.ok ? 'success' : 'error', text: JSON.stringify(result) };
+    },
+  }));
+  ctx.effect(() => ctx.tools.register({
+    name: 'offwork_clock',
+    description: '读取或更新本机下班时钟的工资与班次配置。get 返回配置及 configured（是否已有保存文件）；set 合并保存。工资仅存本机，但调用及结果会进入会话记录。',
+    parameters: {
+      type: 'object', additionalProperties: false, required: ['action'],
+      properties: {
+        action: { type: 'string', enum: ['get', 'set'], description: 'get 读取；set 更新。' },
+        settings: settingsSchema,
+      },
+    },
+    output: {
+      schema: {
+        oneOf: [
+          { type: 'object', additionalProperties: false, required: ['ok', 'settings', 'configured'], properties: { ok: { type: 'boolean', const: true }, settings: { ...settingsSchema, required: keys }, configured: { type: 'boolean' } } },
+          { type: 'object', additionalProperties: false, required: ['ok', 'error'], properties: { ok: { type: 'boolean', const: false }, error: { type: 'string' } } },
+        ],
+      },
+      render: (_args, value) => [{ type: 'text', text: JSON.stringify(value) }],
+    },
+    async execute(args) {
+      if (!isObject(args) || Object.keys(args).some(key => key !== 'action' && key !== 'settings')) {
+        return fail('参数必须是仅含 action 和可选 settings 的对象。');
+      }
+      return operate(args.action, args.settings);
+    },
+  }));
+}

package/locale/en.json

@@ -0,0 +1 @@
+{"meta":{"title":"Offwork Clock","description":"A draggable countdown to clock-out with live estimated earnings and salary settings."}}

package/locale/zh.json

@@ -0,0 +1 @@
+{"meta":{"title":"下班计时器","description":"可拖动的下班倒计时与工资悬浮窗，支持月薪/日薪、夜班、工作日、可选休息扣除、金额隐藏与位置记忆。"}}

package/package.json

@@ -1,6 +1,62 @@
 {
   "name": "dsh-offwork",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "下班倒计时与实时工资悬浮窗：可拖动、可调透明度、工资可隐藏。A draggable countdown and salary overlay for DeepSeek Harness.",
+  "type": "module",
+  "license": "MIT",
+  "author": "now",
+  "repository": { "type": "git", "url": "git+https://github.com/SnowBeatRain/dsh-offwork.git" },
+  "homepage": "https://github.com/SnowBeatRain/dsh-offwork#readme",
+  "bugs": { "url": "https://github.com/SnowBeatRain/dsh-offwork/issues" },
+  "keywords": [
+    "deepseek-harness",
+    "dsh-plugin",
+    "dsh-widget",
+    "countdown",
+    "salary",
+    "offwork",
+    "overlay"
+  ],
+  "engines": {
+    "dsh": ">=0.2.1-rc.5 <0.3.0-0"
+  },
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.js",
+    "client.js",
+    "client.source.js",
+    "clock.js",
+    "ui-utils.js",
+    "cordis.patch.yml",
+    "locale/*.json",
+    "icon.svg",
+    "LICENSE",
+    "README.md",
+    "tests/*.mjs",
+    "tools/build.mjs"
+  ],
+  "scripts": {
+    "build": "node tools/build.mjs",
+    "test": "node tools/build.mjs --check && node --test tests/*.mjs",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-api-remotes"
+      ]
+    }
+  }
+}

package/tests/clock.test.mjs

@@ -0,0 +1,193 @@
+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);
+});