dsh-offwork 1.1.0 → 1.1.2

package/hydration.js

@@ -1,200 +1,203 @@
-// Pure hydration rules. Time is measured in paid-work milliseconds from calculate().
-export const HYDRATION_SCHEMA = 2;
+import { calculate } from './clock.js';
+
+// Hydration uses wall-clock deadlines, independently of salary and work schedules.
+export const HYDRATION_SCHEMA = 3;
 export const HYDRATION_ACTION_LIMIT = 64;
 export const HYDRATION_LEASE_MS = 8000;
+const hydrationInteger = (number, max = Number.MAX_SAFE_INTEGER) =>
+  Number.isSafeInteger(number) && number >= 0 && number <= max;
+const hydrationText = (value, max = 1024) =>
+  typeof value === 'string' && value.length > 0 && value.length <= max;
+const hydrationKeys = (value, keys) =>
+  value &&
+  typeof value === 'object' &&
+  !Array.isArray(value) &&
+  Object.keys(value).every((key) => keys.includes(key));
+const hydrationClaim = (claim) =>
+  claim === null ||
+  (hydrationKeys(claim, ['owner', 'until', 'sequence']) &&
+    hydrationText(claim.owner) &&
+    hydrationInteger(claim.until) &&
+    hydrationInteger(claim.sequence));
+const hydrationActions = (actions) =>
+  Array.isArray(actions) &&
+  actions.length <= HYDRATION_ACTION_LIMIT &&
+  actions.every((id) => hydrationText(id, 128)) &&
+  new Set(actions).size === actions.length;
 
 export function defaultHydration() {
-  return { schema: HYDRATION_SCHEMA, revision: 0, enabled: false, interval: 60, shift: null };
+  return {
+    schema: HYDRATION_SCHEMA,
+    revision: 0,
+    enabled: false,
+    interval: 60,
+    count: 0,
+    paused: false,
+    dueAt: 0,
+    sequence: 0,
+    claim: null,
+    quietUntil: 0,
+    recentActions: [],
+  };
 }
-
 export function validateHydration(value) {
-  const integer = (number, max = Number.MAX_SAFE_INTEGER) =>
-    Number.isSafeInteger(number) && number >= 0 && number <= max;
-  const text = (string) => typeof string === 'string' && string.length > 0 && string.length <= 1024;
-  const keys = (object, allowed) =>
-    object &&
-    typeof object === 'object' &&
-    !Array.isArray(object) &&
-    Object.keys(object).every((key) => allowed.includes(key));
   if (
-    !keys(value, ['schema', 'revision', 'enabled', 'interval', 'shift']) ||
-    ![1, HYDRATION_SCHEMA].includes(value.schema) ||
-    !integer(value.revision) ||
+    !hydrationKeys(value, [
+      'schema',
+      'revision',
+      'enabled',
+      'interval',
+      'count',
+      'paused',
+      'dueAt',
+      'sequence',
+      'claim',
+      'quietUntil',
+      'recentActions',
+    ]) ||
+    value.schema !== HYDRATION_SCHEMA ||
+    !hydrationInteger(value.revision) ||
     typeof value.enabled !== 'boolean' ||
-    !integer(value.interval, 240) ||
-    value.interval < 5
-  ) {
+    !hydrationInteger(value.interval, 240) ||
+    value.interval < 5 ||
+    !hydrationInteger(value.count, 1000000) ||
+    typeof value.paused !== 'boolean' ||
+    !hydrationInteger(value.dueAt) ||
+    !hydrationInteger(value.sequence) ||
+    !hydrationInteger(value.quietUntil) ||
+    !hydrationClaim(value.claim) ||
+    !hydrationActions(value.recentActions)
+  )
     throw new Error('Invalid hydration data');
-  }
+  return structuredClone(value);
+}
+
+function validateLegacyHydration(value) {
+  if (
+    !hydrationKeys(value, ['schema', 'revision', 'enabled', 'interval', 'shift']) ||
+    ![1, 2].includes(value.schema) ||
+    !hydrationInteger(value.revision) ||
+    typeof value.enabled !== 'boolean' ||
+    !hydrationInteger(value.interval, 240) ||
+    value.interval < 5
+  )
+    throw new Error('Invalid legacy hydration data');
   const shift = value.shift;
-  if (shift !== null) {
-    if (
-      !keys(shift, [
-        'id',
-        'schedule',
-        'config',
-        'count',
-        'paused',
-        'due',
-        'sequence',
-        'claim',
-        ...(value.schema === 2 ? ['quietUntil', 'recentActions'] : []),
-      ]) ||
-      !text(shift.id) ||
-      !text(shift.schedule) ||
-      !text(shift.config) ||
-      !integer(shift.count, 1000000) ||
+  if (
+    shift !== null &&
+    (!hydrationKeys(shift, [
+      'id',
+      'schedule',
+      'config',
+      'count',
+      'paused',
+      'due',
+      'sequence',
+      'claim',
+      ...(value.schema === 2 ? ['quietUntil', 'recentActions'] : []),
+    ]) ||
+      !hydrationText(shift.id) ||
+      !hydrationText(shift.schedule) ||
+      !hydrationText(shift.config) ||
+      !hydrationInteger(shift.count, 1000000) ||
       typeof shift.paused !== 'boolean' ||
-      !integer(shift.sequence) ||
-      !integer(shift.due, 172800000)
-    ) {
-      throw new Error('Invalid hydration shift');
-    }
-    if (
-      value.schema === 2 &&
-      (!integer(shift.quietUntil) ||
-        !Array.isArray(shift.recentActions) ||
-        shift.recentActions.length > HYDRATION_ACTION_LIMIT ||
-        !shift.recentActions.every((id) => text(id) && id.length <= 128) ||
-        new Set(shift.recentActions).size !== shift.recentActions.length)
-    )
-      throw new Error('Invalid hydration actions');
-    if (
-      shift.claim !== null &&
-      (!keys(shift.claim, ['owner', 'until', 'sequence']) ||
-        !text(shift.claim.owner) ||
-        !integer(shift.claim.until) ||
-        !integer(shift.claim.sequence))
-    ) {
-      throw new Error('Invalid hydration claim');
-    }
-  }
-  const result = structuredClone(value);
-  if (result.schema === 1) {
-    result.schema = HYDRATION_SCHEMA;
-    if (result.shift) {
-      result.shift.quietUntil = 0;
-      result.shift.recentActions = [];
-      result.shift.claim = null;
-      result.shift.sequence++;
-      if (!Number.isSafeInteger(result.shift.sequence))
-        throw new Error('Invalid hydration sequence');
+      !hydrationInteger(shift.due, 172800000) ||
+      !hydrationInteger(shift.sequence) ||
+      !hydrationClaim(shift.claim) ||
+      (value.schema === 2 &&
+        (!hydrationInteger(shift.quietUntil) || !hydrationActions(shift.recentActions))))
+  )
+    throw new Error('Invalid legacy hydration record');
+  return structuredClone(value);
+}
+
+// Invoked only inside the one-time, two-store migration transaction. The original
+// work-based record stays untouched in its old object store for preservation.
+export function migrateHydration(value, now) {
+  if (!hydrationInteger(now)) throw new Error('Invalid hydration migration time');
+  if (value === undefined) return defaultHydration();
+  const old = validateLegacyHydration(value),
+    next = defaultHydration(),
+    shift = old.shift;
+  next.revision = old.revision;
+  next.enabled = old.enabled;
+  next.interval = old.interval;
+  let remaining = next.interval * 60000;
+  if (shift) {
+    next.count = shift.count;
+    next.paused = shift.paused;
+    next.sequence = shift.sequence + 1;
+    next.quietUntil = old.schema === 2 && shift.quietUntil > now ? shift.quietUntil : 0;
+    next.recentActions = old.schema === 2 ? shift.recentActions : [];
+    // A matching retained shift supplies the remaining paid minutes. Convert
+    // that remainder once; never consult work settings again after migration.
+    try {
+      const [timezone, start, end, breakStart, breakEnd, weekdays] = JSON.parse(shift.config);
+      const clock = calculate(
+        { timezone, start, end, breakStart, breakEnd, weekdays, payMode: 'daily', dailySalary: 1 },
+        now,
+      );
+      const id = JSON.stringify([timezone, clock.shiftDate]);
+      const schedule = JSON.stringify([
+        start,
+        end,
+        breakStart,
+        breakEnd,
+        [...weekdays].sort(),
+        clock.shiftStart,
+        clock.shiftEnd,
+      ]);
+      if (id === shift.id && schedule === shift.schedule && !shift.paused)
+        remaining = Math.max(0, shift.due - Math.floor(clock.elapsed * 1000));
+    } catch {
+      /* Older/unknown schedule text: start one full configured interval. */
     }
   }
-  return result;
+  next.dueAt = next.enabled ? now + remaining : 0;
+  return validateHydration(next);
 }
 
-export function hydrationContext(settings, clock) {
-  if (!settings || !clock || !Number.isFinite(clock.elapsed) || !Number.isFinite(clock.total))
-    return null;
+export function reconcileHydration(state, now) {
+  const next = validateHydration(state);
+  if (!hydrationInteger(now)) throw new Error('Invalid reminder time');
+  if (next.enabled && next.dueAt === 0) next.dueAt = now + next.interval * 60000;
+  if (next.quietUntil <= now) next.quietUntil = 0;
+  if (!next.enabled || next.paused || next.quietUntil > now) next.claim = null;
+  return validateHydration(next);
+}
+export function hydrationView(state, now) {
+  const remaining = state.dueAt ? Math.max(0, state.dueAt - now) : state.interval * 60000;
+  const quietRemaining = state.enabled && !state.paused ? Math.max(0, state.quietUntil - now) : 0;
+  const phase = !state.enabled
+    ? 'off'
+    : state.paused
+      ? 'paused'
+      : quietRemaining > 0
+        ? 'quiet'
+        : remaining === 0
+          ? 'due'
+          : 'countdown';
   return {
-    id: JSON.stringify([settings.timezone, clock.shiftDate]),
-    config: JSON.stringify([
-      settings.timezone,
-      settings.start,
-      settings.end,
-      settings.breakStart,
-      settings.breakEnd,
-      [...settings.weekdays].sort(),
-    ]),
-    schedule: JSON.stringify([
-      settings.start,
-      settings.end,
-      settings.breakStart,
-      settings.breakEnd,
-      [...settings.weekdays].sort(),
-      clock.shiftStart,
-      clock.shiftEnd,
-    ]),
-    status: clock.status,
-    end: clock.shiftEnd,
-    elapsed: Math.max(0, Math.floor(clock.elapsed * 1000)),
-    total: Math.max(0, Math.floor(clock.total * 1000)),
+    phase,
+    count: state.count,
+    remaining,
+    quietRemaining,
+    eventId:
+      state.enabled && state.dueAt
+        ? JSON.stringify(['wall-clock', state.sequence, state.dueAt])
+        : null,
   };
 }
-
-export function reconcileHydration(state, context, manual = false) {
-  const next = structuredClone(state);
-  if (!context) return next;
-  if (!next.enabled && !manual) {
-    if (next.shift) next.shift.claim = null;
-    return next;
-  }
-  if (next.shift?.id !== context.id) {
-    // Do not discard the last shift's count on a day off. New working shifts
-    // are initialized once the user opens the page, never backfilled.
-    if (!['before', 'working', 'lunch'].includes(context.status)) return next;
-    next.shift = {
-      id: context.id,
-      schedule: context.schedule,
-      config: context.config,
-      count: 0,
-      paused: false,
-      due: context.elapsed + next.interval * 60000,
-      sequence: 0,
-      claim: null,
-      quietUntil: 0,
-      recentActions: [],
-    };
-  } else if (next.shift.schedule !== context.schedule) {
-    next.shift.schedule = context.schedule;
-    next.shift.config = context.config;
-    next.shift.due = context.elapsed + next.interval * 60000;
-    next.shift.sequence++;
-    next.shift.claim = null;
-    next.shift.quietUntil = Math.min(next.shift.quietUntil, context.end);
-  }
-  if (next.shift && (!next.enabled || context.status !== 'working')) next.shift.claim = null;
-  return next;
-}
-
-export function hydrationView(state, context, now = 0) {
-  const same =
-    context && state.shift?.id === context.id && state.shift.schedule === context.schedule;
-  const shift = same ? state.shift : null;
-  const count = shift?.count ?? 0;
-  const remaining = shift ? Math.max(0, shift.due - context.elapsed) : state.interval * 60000;
-  const eventId = shift
-    ? JSON.stringify([shift.id, shift.schedule, shift.sequence, shift.due])
-    : null;
-  const quietRemaining =
-    shift && ['working', 'lunch'].includes(context.status)
-      ? Math.max(0, Math.min(shift.quietUntil, context.end) - now)
-      : 0;
-  let phase = 'waiting';
-  if (!state.enabled) phase = 'off';
-  else if (shift?.paused) phase = 'paused';
-  else if (quietRemaining > 0) phase = 'quiet';
-  else if (context?.status === 'lunch') phase = 'break';
-  else if (shift && context.status === 'working') {
-    phase = remaining === 0 ? 'due' : shift.due >= context.total ? 'finished' : 'countdown';
-  }
-  return { phase, count, remaining, eventId, quietRemaining };
-}
-
-export function transitionHydration(state, context, action, now, owner) {
-  if (!Number.isSafeInteger(now) || now < 0) throw new Error('Invalid reminder time');
-  // Reconfiguration requires an explicit compare-and-set grant obtained before
-  // reading/saving Host settings. A stale tab may release its lease or disable
-  // reminders, but cannot silently restore its previous schedule.
-  if (
-    context &&
-    state.shift &&
-    (state.shift.config !== context.config ||
-      (state.shift.id === context.id && state.shift.schedule !== context.schedule)) &&
-    action.baseSchedule !== state.shift.schedule
-  )
-    context = null;
-  const manual =
-    action.type === 'manual-drink' &&
-    action.shiftId === context?.id &&
-    ['working', 'lunch'].includes(context?.status);
-  let next = reconcileHydration(state, context, manual);
+export function transitionHydration(state, action, now, owner) {
+  let next = reconcileHydration(state, now);
+  const finish = () => validateHydration(next);
+  const invalidate = () => {
+    next.sequence++;
+    next.claim = null;
+  };
   const restart = () => {
-    if (!next.shift || !context || next.shift.id !== context.id) return;
-    next.shift.due = context.elapsed + next.interval * 60000;
-    next.shift.sequence++;
-    next.shift.claim = null;
+    next.dueAt = now + next.interval * 60000;
+    invalidate();
   };
   if (action.type === 'reset') return defaultHydration();
   if (action.type === 'preferences') {
@@ -207,86 +210,65 @@ export function transitionHydration(state, context, action, now, owner) {
       interval > 240
     )
       throw new Error('Invalid reminder preferences');
-    const changed = next.enabled !== enabled || next.interval !== interval;
+    const changed = enabled !== next.enabled || interval !== next.interval;
     next.enabled = enabled;
     next.interval = interval;
-    next = reconcileHydration(next, context);
-    if (!next.enabled && next.shift) {
-      next.shift.claim = null;
-      next.shift.quietUntil = 0;
+    if (!enabled) {
+      next.claim = null;
+      next.quietUntil = 0;
     }
-    if (changed) restart();
-    return next;
-  }
-  const shift = next.shift;
-  if (action.type === 'release') {
-    if (shift?.claim?.owner === owner) shift.claim = null;
-    return next;
+    if (changed) {
+      if (enabled) restart();
+      else invalidate();
+    }
+    return finish();
   }
-  if (!shift || !context || shift.id !== context.id) return next;
-  if (shift.quietUntil && (now >= shift.quietUntil || now >= context.end)) shift.quietUntil = 0;
-  const view = hydrationView(next, context, now);
+  const view = hydrationView(next, now);
   const validClaim =
-    shift.claim &&
-    shift.claim.owner === owner &&
-    shift.claim.sequence === shift.sequence &&
-    shift.claim.until > now &&
-    shift.claim.until <= now + HYDRATION_LEASE_MS;
-  if (action.type === 'manual-drink' && manual) {
-    if (
-      typeof action.actionId !== 'string' ||
-      !action.actionId.length ||
-      action.actionId.length > 128
-    )
-      throw new Error('Invalid hydration action id');
+    next.claim &&
+    next.claim.owner === owner &&
+    next.claim.sequence === next.sequence &&
+    next.claim.until > now &&
+    next.claim.until <= now + HYDRATION_LEASE_MS;
+  if (action.type === 'release') {
+    if (next.claim?.owner === owner) next.claim = null;
+  } else if (action.type === 'manual-drink') {
+    if (!hydrationText(action.actionId, 128)) throw new Error('Invalid hydration action id');
     if (
-      shift.recentActions.includes(action.actionId) ||
+      next.recentActions.includes(action.actionId) ||
       (action.eventId !== undefined && action.eventId !== view.eventId)
     )
-      return next;
-    shift.recentActions = [
-      ...shift.recentActions.slice(-(HYDRATION_ACTION_LIMIT - 1)),
+      return finish();
+    next.recentActions = [
+      ...next.recentActions.slice(-(HYDRATION_ACTION_LIMIT - 1)),
       action.actionId,
     ];
-    shift.count = Math.min(1000000, shift.count + 1);
-    if (next.enabled && !shift.paused) restart();
-    else {
-      shift.sequence++;
-      shift.claim = null;
-    }
-  } else if (
-    action.type === 'quiet' &&
-    next.enabled &&
-    !shift.paused &&
-    ['working', 'lunch'].includes(context.status)
-  ) {
+    next.count = Math.min(1000000, next.count + 1);
+    if (next.enabled && !next.paused) restart();
+    else invalidate();
+  } else if (action.type === 'quiet' && next.enabled && !next.paused) {
     if (![30, 60].includes(action.minutes)) throw new Error('Invalid quiet duration');
-    shift.quietUntil = Math.min(now + action.minutes * 60000, context.end);
-    shift.claim = null;
-    shift.sequence++;
-  } else if (action.type === 'end-quiet' && shift.quietUntil) {
-    shift.quietUntil = 0;
-    shift.claim = null;
-    shift.sequence++;
+    next.quietUntil = now + action.minutes * 60000;
+    invalidate();
+  } else if (action.type === 'end-quiet' && next.quietUntil) {
+    next.quietUntil = 0;
+    invalidate();
   } else if (action.type === 'claim' && view.phase === 'due') {
-    const claim = shift.claim;
+    if (!hydrationText(owner)) throw new Error('Invalid reminder owner');
     if (
-      !claim ||
-      claim.owner === owner ||
-      claim.until <= now ||
-      claim.until > now + HYDRATION_LEASE_MS
-    ) {
-      shift.claim = { owner, until: now + HYDRATION_LEASE_MS, sequence: shift.sequence };
-    }
-  } else if (action.type === 'clear-count') {
-    shift.count = 0;
-  } else if (action.type === 'pause' && next.enabled && !shift.paused) {
-    shift.paused = true;
-    shift.quietUntil = 0;
-    shift.claim = null;
-    shift.sequence++;
-  } else if (action.type === 'resume' && next.enabled && shift.paused) {
-    shift.paused = false;
+      !next.claim ||
+      next.claim.owner === owner ||
+      next.claim.until <= now ||
+      next.claim.until > now + HYDRATION_LEASE_MS
+    )
+      next.claim = { owner, until: now + HYDRATION_LEASE_MS, sequence: next.sequence };
+  } else if (action.type === 'clear-count') next.count = 0;
+  else if (action.type === 'pause' && next.enabled && !next.paused) {
+    next.paused = true;
+    next.quietUntil = 0;
+    invalidate();
+  } else if (action.type === 'resume' && next.enabled && next.paused) {
+    next.paused = false;
     restart();
   } else if (
     ['drink', 'snooze'].includes(action.type) &&
@@ -294,10 +276,9 @@ export function transitionHydration(state, context, action, now, owner) {
     validClaim &&
     action.eventId === view.eventId
   ) {
-    if (action.type === 'drink') shift.count = Math.min(1000000, shift.count + 1);
-    shift.due = context.elapsed + (action.type === 'snooze' ? 10 : next.interval) * 60000;
-    shift.sequence++;
-    shift.claim = null;
+    if (action.type === 'drink') next.count = Math.min(1000000, next.count + 1);
+    next.dueAt = now + (action.type === 'snooze' ? 10 : next.interval) * 60000;
+    invalidate();
   }
-  return next;
+  return finish();
 }

package/index.js

@@ -2,6 +2,7 @@ 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';
+import { registerMediaRoute } from './media-server.js';
 
 export const inject = ['commands', 'tools'];
 
@@ -200,6 +201,7 @@ const settingsSchema = {
 };
 
 export function apply(ctx) {
+  registerMediaRoute(ctx);
   const operate = createOperations();
   ctx.effect(() =>
     ctx.commands.register({

package/locale/en.json

@@ -1,6 +1,6 @@
 {
   "meta": {
     "title": "Offwork Clock",
-    "description": "A Harness character companion with a clock-out countdown, estimated earnings, hydration reminders, quiet time and independent feature cards."
+    "description": "A Harness character companion and compact widget with clock-out, all-day hydration and independent smoking timers, earnings, action previews and privacy controls."
   }
 }

package/locale/zh.json

@@ -1,6 +1,6 @@
 {
   "meta": {
     "title": "下班计时器",
-    "description": "Harness 页面陪伴角色、下班倒计时、实时收入和喝水提醒，支持鲸系少女外观、免打扰、独立功能卡片与隐私偏好。"
+    "description": "Harness 页面角色与紧凑小卡片，提供下班倒计时、全天喝水提醒、独立抽烟计时、收入与动作试播，支持简洁详情页和隐私偏好。"
   }
 }

package/media-manifest.js

@@ -0,0 +1,29 @@
+// Generated by tools/build.mjs; edit the source modules, not this file.
+export const MEDIA_ROUTE = "/offwork-clock/media";
+export const MEDIA_ASSETS = Object.freeze({
+  "2b98a0d8f5ab3569254c57185f712ceae7081d081f3879a3bb48f62ae59ea616/ornate-greet.webm": {
+    "file": "assets/animations/ornate-greet.webm",
+    "size": 1419513,
+    "sha256": "2b98a0d8f5ab3569254c57185f712ceae7081d081f3879a3bb48f62ae59ea616"
+  },
+  "6149773dbf3b89062f649d54d990230caacdea084d22f93bd4867b0c25344b59/whale-greet.webm": {
+    "file": "assets/animations/whale-greet.webm",
+    "size": 1726801,
+    "sha256": "6149773dbf3b89062f649d54d990230caacdea084d22f93bd4867b0c25344b59"
+  },
+  "ac0e8be1731b24dfbc232114d08a771ea87512cef2c6f3949154a90c6413f1a7/ornate-drink.webm": {
+    "file": "assets/animations/ornate-drink.webm",
+    "size": 1746731,
+    "sha256": "ac0e8be1731b24dfbc232114d08a771ea87512cef2c6f3949154a90c6413f1a7"
+  },
+  "e6befff2ade25304f13c03e3ba30a19148cd7155c862f5a59cfdb31c8669e519/ornate-idle.webm": {
+    "file": "assets/animations/ornate-idle.webm",
+    "size": 890695,
+    "sha256": "e6befff2ade25304f13c03e3ba30a19148cd7155c862f5a59cfdb31c8669e519"
+  },
+  "f993c90acb9c4c6b9c4363986792790d4a38b2f5e3e4e589b0972d62d5a326f8/whale-drink.webm": {
+    "file": "assets/animations/whale-drink.webm",
+    "size": 1598173,
+    "sha256": "f993c90acb9c4c6b9c4363986792790d4a38b2f5e3e4e589b0972d62d5a326f8"
+  }
+});