@open-mercato/core 0.7.1-develop.7178.1.ab93fbaf4e → 0.7.1-develop.7180.1.9717fbbb43

package/dist/modules/staff/lib/time-tracking/recalculationRunner.js

@@ -0,0 +1,80 @@
+import { createLogger } from "@open-mercato/shared/lib/logger";
+import {
+  emptyRecalculationSummary,
+  resolveTimeTrackingRecalculations
+} from "./recalculations.js";
+const logger = createLogger("staff").child({ component: "time-tracking/recalculation-runner" });
+function progressContextFor(scope) {
+  return {
+    tenantId: scope.tenantId,
+    organizationId: scope.organizationIds?.length === 1 ? scope.organizationIds[0] : null,
+    userId: scope.userId ?? null
+  };
+}
+function accumulate(target, addend) {
+  target.totalCount += addend.totalCount;
+  target.processedCount += addend.processedCount;
+  target.updatedCount += addend.updatedCount;
+  target.unchangedCount += addend.unchangedCount;
+  target.skippedCount += addend.skippedCount;
+  target.cancelled = target.cancelled || addend.cancelled;
+}
+async function runTimeTrackingRecalculations(params) {
+  const { container, progressJobId, scope } = params;
+  const hooks = resolveTimeTrackingRecalculations(params.hookIds);
+  const progressService = container.resolve("progressService");
+  const progressContext = progressContextFor(scope);
+  await progressService.startJob(progressJobId, progressContext);
+  const summary = { ...emptyRecalculationSummary(), hooks: [] };
+  let knownTotal = 0;
+  let processed = 0;
+  try {
+    for (const hook of hooks) {
+      const hookSummary = await hook.run({
+        container,
+        scope,
+        report: {
+          setTotal: async (total) => {
+            knownTotal += total;
+            await progressService.updateProgress(
+              progressJobId,
+              { totalCount: knownTotal, processedCount: Math.min(processed, knownTotal) },
+              progressContext
+            );
+          },
+          advance: async (count) => {
+            processed += count;
+            await progressService.updateProgress(
+              progressJobId,
+              { totalCount: knownTotal, processedCount: Math.min(processed, knownTotal) },
+              progressContext
+            );
+          },
+          isCancellationRequested: () => progressService.isCancellationRequested(
+            progressJobId,
+            scope.tenantId,
+            progressContext.organizationId
+          )
+        }
+      });
+      summary.hooks.push({ id: hook.id, ...hookSummary });
+      accumulate(summary, hookSummary);
+      if (hookSummary.cancelled) break;
+    }
+  } catch (err) {
+    logger.error("staff.timesheets recalculation failed", { progressJobId, ...summary, err });
+    throw err;
+  }
+  if (summary.cancelled) {
+    logger.info("staff.timesheets recalculation cancelled", { progressJobId, ...summary });
+    await progressService.markCancelled(progressJobId, progressContext);
+    return summary;
+  }
+  await progressService.completeJob(progressJobId, { resultSummary: { ...summary } }, progressContext);
+  logger.info("staff.timesheets recalculation finished", { progressJobId, ...summary });
+  return summary;
+}
+export {
+  runTimeTrackingRecalculations
+};
+//# sourceMappingURL=recalculationRunner.js.map

package/dist/modules/staff/lib/time-tracking/recalculationRunner.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/modules/staff/lib/time-tracking/recalculationRunner.ts"],
+  "sourcesContent": ["/**\n * EP-51 \u2014 the job shell every registered recalculation runs inside.\n *\n * It owns the `ProgressJob` (start, totals, cancel, complete) and hands each hook\n * a reporter scoped to that job, so N hooks share one progress bar instead of\n * fighting over it. Hooks run **sequentially** and in registry order: they write\n * the same rows, and two of them racing over `staff_time_entries` is the kind of\n * bug that shows up as a wrong invoice a month later.\n *\n * A hook that throws does not silently vanish \u2014 the runner logs it and rethrows,\n * because a half-finished restatement the operator believes succeeded is worse\n * than a loud failure. Marking the `ProgressJob` failed is the worker's job: it\n * already does that for every exception that reaches it, and doing it in both\n * places would write the failure twice.\n */\n\nimport type { AwilixContainer } from 'awilix'\nimport { createLogger } from '@open-mercato/shared/lib/logger'\nimport type { ProgressService, ProgressServiceContext } from '../../../progress/lib/progressService'\nimport {\n  emptyRecalculationSummary,\n  resolveTimeTrackingRecalculations,\n  type TimeTrackingRecalculationScope,\n  type TimeTrackingRecalculationSummary,\n} from './recalculations'\n\nconst logger = createLogger('staff').child({ component: 'time-tracking/recalculation-runner' })\n\nexport type TimeTrackingRecalculationRunSummary = TimeTrackingRecalculationSummary & {\n  hooks: Array<{ id: string } & TimeTrackingRecalculationSummary>\n}\n\nfunction progressContextFor(scope: TimeTrackingRecalculationScope): ProgressServiceContext {\n  return {\n    tenantId: scope.tenantId,\n    organizationId: scope.organizationIds?.length === 1 ? scope.organizationIds[0] : null,\n    userId: scope.userId ?? null,\n  }\n}\n\nfunction accumulate(\n  target: TimeTrackingRecalculationSummary,\n  addend: TimeTrackingRecalculationSummary,\n): void {\n  target.totalCount += addend.totalCount\n  target.processedCount += addend.processedCount\n  target.updatedCount += addend.updatedCount\n  target.unchangedCount += addend.unchangedCount\n  target.skippedCount += addend.skippedCount\n  target.cancelled = target.cancelled || addend.cancelled\n}\n\nexport async function runTimeTrackingRecalculations(params: {\n  container: AwilixContainer\n  progressJobId: string\n  scope: TimeTrackingRecalculationScope\n  hookIds?: readonly string[] | null\n}): Promise<TimeTrackingRecalculationRunSummary> {\n  const { container, progressJobId, scope } = params\n  const hooks = resolveTimeTrackingRecalculations(params.hookIds)\n  const progressService = container.resolve('progressService') as ProgressService\n  const progressContext = progressContextFor(scope)\n\n  await progressService.startJob(progressJobId, progressContext)\n\n  const summary: TimeTrackingRecalculationRunSummary = { ...emptyRecalculationSummary(), hooks: [] }\n  let knownTotal = 0\n  let processed = 0\n\n  try {\n    for (const hook of hooks) {\n      const hookSummary = await hook.run({\n        container,\n        scope,\n        report: {\n          setTotal: async (total) => {\n            knownTotal += total\n            await progressService.updateProgress(\n              progressJobId,\n              { totalCount: knownTotal, processedCount: Math.min(processed, knownTotal) },\n              progressContext,\n            )\n          },\n          advance: async (count) => {\n            processed += count\n            await progressService.updateProgress(\n              progressJobId,\n              { totalCount: knownTotal, processedCount: Math.min(processed, knownTotal) },\n              progressContext,\n            )\n          },\n          isCancellationRequested: () =>\n            progressService.isCancellationRequested(\n              progressJobId,\n              scope.tenantId,\n              progressContext.organizationId,\n            ),\n        },\n      })\n      summary.hooks.push({ id: hook.id, ...hookSummary })\n      accumulate(summary, hookSummary)\n      if (hookSummary.cancelled) break\n    }\n  } catch (err) {\n    logger.error('staff.timesheets recalculation failed', { progressJobId, ...summary, err })\n    throw err\n  }\n\n  if (summary.cancelled) {\n    logger.info('staff.timesheets recalculation cancelled', { progressJobId, ...summary })\n    await progressService.markCancelled(progressJobId, progressContext)\n    return summary\n  }\n\n  await progressService.completeJob(progressJobId, { resultSummary: { ...summary } }, progressContext)\n  logger.info('staff.timesheets recalculation finished', { progressJobId, ...summary })\n  return summary\n}\n"],
+  "mappings": "AAiBA,SAAS,oBAAoB;AAE7B;AAAA,EACE;AAAA,EACA;AAAA,OAGK;AAEP,MAAM,SAAS,aAAa,OAAO,EAAE,MAAM,EAAE,WAAW,qCAAqC,CAAC;AAM9F,SAAS,mBAAmB,OAA+D;AACzF,SAAO;AAAA,IACL,UAAU,MAAM;AAAA,IAChB,gBAAgB,MAAM,iBAAiB,WAAW,IAAI,MAAM,gBAAgB,CAAC,IAAI;AAAA,IACjF,QAAQ,MAAM,UAAU;AAAA,EAC1B;AACF;AAEA,SAAS,WACP,QACA,QACM;AACN,SAAO,cAAc,OAAO;AAC5B,SAAO,kBAAkB,OAAO;AAChC,SAAO,gBAAgB,OAAO;AAC9B,SAAO,kBAAkB,OAAO;AAChC,SAAO,gBAAgB,OAAO;AAC9B,SAAO,YAAY,OAAO,aAAa,OAAO;AAChD;AAEA,eAAsB,8BAA8B,QAKH;AAC/C,QAAM,EAAE,WAAW,eAAe,MAAM,IAAI;AAC5C,QAAM,QAAQ,kCAAkC,OAAO,OAAO;AAC9D,QAAM,kBAAkB,UAAU,QAAQ,iBAAiB;AAC3D,QAAM,kBAAkB,mBAAmB,KAAK;AAEhD,QAAM,gBAAgB,SAAS,eAAe,eAAe;AAE7D,QAAM,UAA+C,EAAE,GAAG,0BAA0B,GAAG,OAAO,CAAC,EAAE;AACjG,MAAI,aAAa;AACjB,MAAI,YAAY;AAEhB,MAAI;AACF,eAAW,QAAQ,OAAO;AACxB,YAAM,cAAc,MAAM,KAAK,IAAI;AAAA,QACjC;AAAA,QACA;AAAA,QACA,QAAQ;AAAA,UACN,UAAU,OAAO,UAAU;AACzB,0BAAc;AACd,kBAAM,gBAAgB;AAAA,cACpB;AAAA,cACA,EAAE,YAAY,YAAY,gBAAgB,KAAK,IAAI,WAAW,UAAU,EAAE;AAAA,cAC1E;AAAA,YACF;AAAA,UACF;AAAA,UACA,SAAS,OAAO,UAAU;AACxB,yBAAa;AACb,kBAAM,gBAAgB;AAAA,cACpB;AAAA,cACA,EAAE,YAAY,YAAY,gBAAgB,KAAK,IAAI,WAAW,UAAU,EAAE;AAAA,cAC1E;AAAA,YACF;AAAA,UACF;AAAA,UACA,yBAAyB,MACvB,gBAAgB;AAAA,YACd;AAAA,YACA,MAAM;AAAA,YACN,gBAAgB;AAAA,UAClB;AAAA,QACJ;AAAA,MACF,CAAC;AACD,cAAQ,MAAM,KAAK,EAAE,IAAI,KAAK,IAAI,GAAG,YAAY,CAAC;AAClD,iBAAW,SAAS,WAAW;AAC/B,UAAI,YAAY,UAAW;AAAA,IAC7B;AAAA,EACF,SAAS,KAAK;AACZ,WAAO,MAAM,yCAAyC,EAAE,eAAe,GAAG,SAAS,IAAI,CAAC;AACxF,UAAM;AAAA,EACR;AAEA,MAAI,QAAQ,WAAW;AACrB,WAAO,KAAK,4CAA4C,EAAE,eAAe,GAAG,QAAQ,CAAC;AACrF,UAAM,gBAAgB,cAAc,eAAe,eAAe;AAClE,WAAO;AAAA,EACT;AAEA,QAAM,gBAAgB,YAAY,eAAe,EAAE,eAAe,EAAE,GAAG,QAAQ,EAAE,GAAG,eAAe;AACnG,SAAO,KAAK,2CAA2C,EAAE,eAAe,GAAG,QAAQ,CAAC;AACpF,SAAO;AACT;",
+  "names": []
+}

package/dist/modules/staff/lib/time-tracking/recalculations.js

@@ -0,0 +1,56 @@
+import { extensionPoints } from "@open-mercato/core/modules/staff/extension-points";
+import { createStrategyRegistry } from "./registries/registry.js";
+const TIME_TRACKING_RECALCULATION_REGISTRY_ID = extensionPoints.hosts.recalculationRegistry.spotId;
+const BUILT_IN_RECALCULATION_ID = "staff.time_tracking.recalculation.rounding";
+const registry = createStrategyRegistry(
+  TIME_TRACKING_RECALCULATION_REGISTRY_ID
+);
+function registerTimeTrackingRecalculation(recalculation) {
+  if (typeof recalculation?.run !== "function") {
+    throw new Error("[internal] a time-tracking recalculation must declare a run() function");
+  }
+  return registry.register(recalculation);
+}
+function listTimeTrackingRecalculations() {
+  return registry.list();
+}
+function timeTrackingRecalculationIds() {
+  return registry.ids();
+}
+function getTimeTrackingRecalculation(id) {
+  return registry.get(id);
+}
+function emptyRecalculationSummary() {
+  return {
+    totalCount: 0,
+    processedCount: 0,
+    updatedCount: 0,
+    unchangedCount: 0,
+    skippedCount: 0,
+    cancelled: false
+  };
+}
+function resolveTimeTrackingRecalculations(ids) {
+  if (!ids || ids.length === 0) {
+    const builtIn = registry.get(BUILT_IN_RECALCULATION_ID);
+    return builtIn ? [builtIn] : [];
+  }
+  const resolved = [];
+  for (const id of ids) {
+    const entry = registry.get(id);
+    if (!entry) throw new Error(`[internal] unknown time-tracking recalculation id: ${id}`);
+    if (!resolved.some((candidate) => candidate.id === entry.id)) resolved.push(entry);
+  }
+  return resolved;
+}
+export {
+  BUILT_IN_RECALCULATION_ID,
+  TIME_TRACKING_RECALCULATION_REGISTRY_ID,
+  emptyRecalculationSummary,
+  getTimeTrackingRecalculation,
+  listTimeTrackingRecalculations,
+  registerTimeTrackingRecalculation,
+  resolveTimeTrackingRecalculations,
+  timeTrackingRecalculationIds
+};
+//# sourceMappingURL=recalculations.js.map

package/dist/modules/staff/lib/time-tracking/recalculations.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/modules/staff/lib/time-tracking/recalculations.ts"],
+  "sourcesContent": ["/**\n * EP-51 \u2014 the recalculation registry.\n *\n * A recalculation is a tenant-wide restatement of a derived time-tracking value:\n * the module ships one, the retro-rounding pass behind\n * `POST /api/staff/timesheets/settings/reapply-rounding`, and a third party that\n * plugs in its own rate resolver (EP-33) or billability chain (EP-34) needs the\n * same thing \u2014 a way to re-apply the new rule to the rows that already exist,\n * with the progress bar, the cancel button and the queue worker the module\n * already has.\n *\n * The contract is deliberately narrow. A hook receives a scope and a reporter and\n * answers a count summary; it does NOT own the `ProgressJob`, because several\n * hooks share one job when the CLI runs them together, and a hook that started or\n * completed the job would fight the next one.\n *\n * **`run` is a write over a tenant's history.** Two rules that are not optional:\n * every query must carry `tenantId` (and honour `organizationIds` when it is not\n * `null`), and a locked entry \u2014 one frozen into a closed report \u2014 must never be\n * touched. The built-in excludes locked entries twice, in its own candidate query\n * and again in the command it drives.\n */\n\nimport type { AwilixContainer } from 'awilix'\nimport { extensionPoints } from '@open-mercato/core/modules/staff/extension-points'\nimport { createStrategyRegistry, BUILT_IN_STRATEGY_PRIORITY } from './registries/registry'\n\nexport const TIME_TRACKING_RECALCULATION_REGISTRY_ID =\n  extensionPoints.hosts.recalculationRegistry.spotId\n\nexport const BUILT_IN_RECALCULATION_ID = 'staff.time_tracking.recalculation.rounding'\n\nexport type TimeTrackingRecalculationScope = {\n  tenantId: string\n  /** Organizations the caller may act in; `null` means every organization of the tenant. */\n  organizationIds: string[] | null\n  userId?: string | null\n}\n\n/**\n * The slice of the progress job a hook is allowed to touch. `advance` is additive\n * so two hooks sharing one job cannot rewind each other's count.\n */\nexport type TimeTrackingRecalculationReporter = {\n  setTotal(total: number): Promise<void>\n  advance(processed: number): Promise<void>\n  isCancellationRequested(): Promise<boolean>\n}\n\nexport type TimeTrackingRecalculationContext = {\n  container: AwilixContainer\n  scope: TimeTrackingRecalculationScope\n  report: TimeTrackingRecalculationReporter\n}\n\nexport type TimeTrackingRecalculationSummary = {\n  totalCount: number\n  processedCount: number\n  updatedCount: number\n  unchangedCount: number\n  skippedCount: number\n  cancelled: boolean\n}\n\nexport type TimeTrackingRecalculation = {\n  id: string\n  labelKey: string\n  priority?: number\n  run(ctx: TimeTrackingRecalculationContext): Promise<TimeTrackingRecalculationSummary>\n}\n\nconst registry = createStrategyRegistry<TimeTrackingRecalculation>(\n  TIME_TRACKING_RECALCULATION_REGISTRY_ID,\n)\n\nexport function registerTimeTrackingRecalculation(\n  recalculation: TimeTrackingRecalculation,\n): () => void {\n  if (typeof recalculation?.run !== 'function') {\n    throw new Error('[internal] a time-tracking recalculation must declare a run() function')\n  }\n  return registry.register(recalculation)\n}\n\nexport function listTimeTrackingRecalculations(): TimeTrackingRecalculation[] {\n  return registry.list()\n}\n\nexport function timeTrackingRecalculationIds(): string[] {\n  return registry.ids()\n}\n\nexport function getTimeTrackingRecalculation(\n  id: string | null | undefined,\n): TimeTrackingRecalculation | null {\n  return registry.get(id)\n}\n\nexport function emptyRecalculationSummary(): TimeTrackingRecalculationSummary {\n  return {\n    totalCount: 0,\n    processedCount: 0,\n    updatedCount: 0,\n    unchangedCount: 0,\n    skippedCount: 0,\n    cancelled: false,\n  }\n}\n\n/**\n * Resolves the hooks a job should run.\n *\n * An empty or absent request resolves to the built-in alone \u2014 which is what keeps\n * the settings route byte-identical: it enqueues no hook ids, so a contribution\n * cannot attach itself to the retro-rounding button a tenant pressed. Running\n * more than one is an explicit act, and the CLI is where it is made.\n *\n * An unknown id is an error rather than a silent skip: a backfill that quietly\n * did nothing is worse than one that refused to start.\n */\nexport function resolveTimeTrackingRecalculations(\n  ids?: readonly string[] | null,\n): TimeTrackingRecalculation[] {\n  if (!ids || ids.length === 0) {\n    const builtIn = registry.get(BUILT_IN_RECALCULATION_ID)\n    return builtIn ? [builtIn] : []\n  }\n  const resolved: TimeTrackingRecalculation[] = []\n  for (const id of ids) {\n    const entry = registry.get(id)\n    if (!entry) throw new Error(`[internal] unknown time-tracking recalculation id: ${id}`)\n    if (!resolved.some((candidate) => candidate.id === entry.id)) resolved.push(entry)\n  }\n  return resolved\n}\n"],
+  "mappings": "AAwBA,SAAS,uBAAuB;AAChC,SAAS,8BAA0D;AAE5D,MAAM,0CACX,gBAAgB,MAAM,sBAAsB;AAEvC,MAAM,4BAA4B;AAyCzC,MAAM,WAAW;AAAA,EACf;AACF;AAEO,SAAS,kCACd,eACY;AACZ,MAAI,OAAO,eAAe,QAAQ,YAAY;AAC5C,UAAM,IAAI,MAAM,wEAAwE;AAAA,EAC1F;AACA,SAAO,SAAS,SAAS,aAAa;AACxC;AAEO,SAAS,iCAA8D;AAC5E,SAAO,SAAS,KAAK;AACvB;AAEO,SAAS,+BAAyC;AACvD,SAAO,SAAS,IAAI;AACtB;AAEO,SAAS,6BACd,IACkC;AAClC,SAAO,SAAS,IAAI,EAAE;AACxB;AAEO,SAAS,4BAA8D;AAC5E,SAAO;AAAA,IACL,YAAY;AAAA,IACZ,gBAAgB;AAAA,IAChB,cAAc;AAAA,IACd,gBAAgB;AAAA,IAChB,cAAc;AAAA,IACd,WAAW;AAAA,EACb;AACF;AAaO,SAAS,kCACd,KAC6B;AAC7B,MAAI,CAAC,OAAO,IAAI,WAAW,GAAG;AAC5B,UAAM,UAAU,SAAS,IAAI,yBAAyB;AACtD,WAAO,UAAU,CAAC,OAAO,IAAI,CAAC;AAAA,EAChC;AACA,QAAM,WAAwC,CAAC;AAC/C,aAAW,MAAM,KAAK;AACpB,UAAM,QAAQ,SAAS,IAAI,EAAE;AAC7B,QAAI,CAAC,MAAO,OAAM,IAAI,MAAM,sDAAsD,EAAE,EAAE;AACtF,QAAI,CAAC,SAAS,KAAK,CAAC,cAAc,UAAU,OAAO,MAAM,EAAE,EAAG,UAAS,KAAK,KAAK;AAAA,EACnF;AACA,SAAO;AACT;",
+  "names": []
+}

package/dist/modules/staff/lib/time-tracking/registries/invoke.js

@@ -0,0 +1,63 @@
+import { createLogger } from "@open-mercato/shared/lib/logger";
+const logger = createLogger("staff").child({ component: "time-tracking/registries" });
+function runStrategy(registryId, strategyId, run, fallback) {
+  try {
+    return run();
+  } catch (err) {
+    logger.error("a time-tracking strategy threw; falling back to the built-in", {
+      registryId,
+      strategyId,
+      err
+    });
+    return fallback();
+  }
+}
+function tryStrategy(registryId, strategyId, run) {
+  try {
+    return run();
+  } catch (err) {
+    logger.error("a time-tracking strategy threw; skipping this candidate", {
+      registryId,
+      strategyId,
+      err
+    });
+    return void 0;
+  }
+}
+const MAX_STORED_MINUTES = 2147483647;
+function clampToStoredMinutes(registryId, strategyId, value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    logger.error("a time-tracking strategy answered a non-finite duration; falling back to the built-in", {
+      registryId,
+      strategyId,
+      value: String(value)
+    });
+    return fallback();
+  }
+  if (value < 0) {
+    logger.error("a time-tracking strategy answered a negative duration; falling back to the built-in", {
+      registryId,
+      strategyId,
+      value
+    });
+    return fallback();
+  }
+  const rounded = Math.round(value);
+  if (rounded > MAX_STORED_MINUTES) {
+    logger.error("a time-tracking strategy answered more minutes than the column can hold; clamping", {
+      registryId,
+      strategyId,
+      value,
+      max: MAX_STORED_MINUTES
+    });
+    return MAX_STORED_MINUTES;
+  }
+  return rounded;
+}
+export {
+  MAX_STORED_MINUTES,
+  clampToStoredMinutes,
+  runStrategy,
+  tryStrategy
+};
+//# sourceMappingURL=invoke.js.map

package/dist/modules/staff/lib/time-tracking/registries/invoke.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/modules/staff/lib/time-tracking/registries/invoke.ts"],
+  "sourcesContent": ["/**\n * Calling a contributed strategy safely.\n *\n * Every registry in `EP-32\u2026EP-41` hands third-party code a function the module then\n * calls in the middle of a write path or a report render. None of those call sites\n * originally wrapped the call, so one contributed `round`, `sort` or `serialize`\n * that threw took the surrounding operation down \u2014 for the whole process, not just\n * the tenant that installed the contribution, because the registries are plain\n * module-scope maps shared by every request the process serves.\n *\n * The rule these helpers encode: **a broken contribution degrades to the module's\n * own behaviour, loudly.** It never propagates, and it never silently wins either \u2014\n * every fallback logs the registry and the strategy id, because a strategy that\n * quietly stopped applying is the failure mode that takes weeks to notice.\n *\n * Which helper to reach for:\n *\n *  - `runStrategy` \u2014 single-winner registries, where there is exactly one right\n *    answer and the built-in is it when the contribution cannot produce one.\n *  - `tryStrategy` \u2014 chain registries, where the next candidate is asked anyway, so\n *    a thrower is skipped rather than replaced.\n */\n\nimport { createLogger } from '@open-mercato/shared/lib/logger'\n\nconst logger = createLogger('staff').child({ component: 'time-tracking/registries' })\n\nexport function runStrategy<TResult>(\n  registryId: string,\n  strategyId: string,\n  run: () => TResult,\n  fallback: () => TResult,\n): TResult {\n  try {\n    return run()\n  } catch (err) {\n    logger.error('a time-tracking strategy threw; falling back to the built-in', {\n      registryId,\n      strategyId,\n      err,\n    })\n    return fallback()\n  }\n}\n\n/** `undefined` means \"this candidate could not answer\"; ask the next one. */\nexport function tryStrategy<TResult>(\n  registryId: string,\n  strategyId: string,\n  run: () => TResult,\n): TResult | undefined {\n  try {\n    return run()\n  } catch (err) {\n    logger.error('a time-tracking strategy threw; skipping this candidate', {\n      registryId,\n      strategyId,\n      err,\n    })\n    return undefined\n  }\n}\n\n/** The largest value `staff_time_entries.rounded_minutes` \u2014 a PostgreSQL `integer` \u2014 can hold. */\nexport const MAX_STORED_MINUTES = 2_147_483_647\n\n/**\n * Clamps a strategy's answer to something the column it lands in can hold.\n *\n * `staff_time_entries.rounded_minutes` is an `integer` and the sole input to every\n * amount the suite computes, so a `NaN`, a fraction or a negative from a\n * contributed strategy is not a cosmetic problem: the write either fails or stores\n * garbage, and on read `entryAmount` substitutes `0`, which bills the entry at\n * nothing without saying so. The shipped default `unitMinutes: 0` makes this the\n * FIRST thing a plausible contribution hits \u2014 `Math.floor(raw / ctx.settings.unitMinutes)`\n * is division by zero.\n *\n * Three answers are refused rather than stored, and each one logs, because the rule\n * this file encodes is that a degraded contribution degrades *loudly*:\n *\n *  - **Not a finite number** \u2014 nothing to clamp toward; take the built-in.\n *  - **Negative** \u2014 a duration that ran backwards is not a value to clamp to zero.\n *    Storing `0` is exactly the silent zero-bill the paragraph above describes, so a\n *    negative takes the built-in arm alongside `NaN`.\n *  - **Larger than the column** \u2014 the INSERT would fail with an out-of-range error\n *    and 500 the write, which is the propagation these helpers exist to prevent.\n *    Clamped down to the column's ceiling so the write still lands.\n */\nexport function clampToStoredMinutes(\n  registryId: string,\n  strategyId: string,\n  value: unknown,\n  fallback: () => number,\n): number {\n  if (typeof value !== 'number' || !Number.isFinite(value)) {\n    logger.error('a time-tracking strategy answered a non-finite duration; falling back to the built-in', {\n      registryId,\n      strategyId,\n      value: String(value),\n    })\n    return fallback()\n  }\n  if (value < 0) {\n    logger.error('a time-tracking strategy answered a negative duration; falling back to the built-in', {\n      registryId,\n      strategyId,\n      value,\n    })\n    return fallback()\n  }\n  const rounded = Math.round(value)\n  if (rounded > MAX_STORED_MINUTES) {\n    logger.error('a time-tracking strategy answered more minutes than the column can hold; clamping', {\n      registryId,\n      strategyId,\n      value,\n      max: MAX_STORED_MINUTES,\n    })\n    return MAX_STORED_MINUTES\n  }\n  return rounded\n}\n"],
+  "mappings": "AAuBA,SAAS,oBAAoB;AAE7B,MAAM,SAAS,aAAa,OAAO,EAAE,MAAM,EAAE,WAAW,2BAA2B,CAAC;AAE7E,SAAS,YACd,YACA,YACA,KACA,UACS;AACT,MAAI;AACF,WAAO,IAAI;AAAA,EACb,SAAS,KAAK;AACZ,WAAO,MAAM,gEAAgE;AAAA,MAC3E;AAAA,MACA;AAAA,MACA;AAAA,IACF,CAAC;AACD,WAAO,SAAS;AAAA,EAClB;AACF;AAGO,SAAS,YACd,YACA,YACA,KACqB;AACrB,MAAI;AACF,WAAO,IAAI;AAAA,EACb,SAAS,KAAK;AACZ,WAAO,MAAM,2DAA2D;AAAA,MACtE;AAAA,MACA;AAAA,MACA;AAAA,IACF,CAAC;AACD,WAAO;AAAA,EACT;AACF;AAGO,MAAM,qBAAqB;AAwB3B,SAAS,qBACd,YACA,YACA,OACA,UACQ;AACR,MAAI,OAAO,UAAU,YAAY,CAAC,OAAO,SAAS,KAAK,GAAG;AACxD,WAAO,MAAM,yFAAyF;AAAA,MACpG;AAAA,MACA;AAAA,MACA,OAAO,OAAO,KAAK;AAAA,IACrB,CAAC;AACD,WAAO,SAAS;AAAA,EAClB;AACA,MAAI,QAAQ,GAAG;AACb,WAAO,MAAM,uFAAuF;AAAA,MAClG;AAAA,MACA;AAAA,MACA;AAAA,IACF,CAAC;AACD,WAAO,SAAS;AAAA,EAClB;AACA,QAAM,UAAU,KAAK,MAAM,KAAK;AAChC,MAAI,UAAU,oBAAoB;AAChC,WAAO,MAAM,qFAAqF;AAAA,MAChG;AAAA,MACA;AAAA,MACA;AAAA,MACA,KAAK;AAAA,IACP,CAAC;AACD,WAAO;AAAA,EACT;AACA,SAAO;AACT;",
+  "names": []
+}

package/dist/modules/staff/lib/time-tracking/registries/registry.js

@@ -0,0 +1,62 @@
+const BUILT_IN_STRATEGY_PRIORITY = -1e3;
+function orderSlots(left, right) {
+  const leftPriority = left.entry.priority ?? 0;
+  const rightPriority = right.entry.priority ?? 0;
+  if (leftPriority !== rightPriority) return rightPriority - leftPriority;
+  return left.sequence - right.sequence;
+}
+function createStrategyRegistry(registryId) {
+  const builtInSlots = /* @__PURE__ */ new Map();
+  const contributedSlots = /* @__PURE__ */ new Map();
+  let sequence = 0;
+  const readId = (entry) => {
+    const id = typeof entry?.id === "string" ? entry.id.trim() : "";
+    if (!id) throw new Error(`[internal] ${registryId} requires a non-empty strategy id`);
+    return id;
+  };
+  const registerBuiltIn = (entry) => {
+    const id = readId(entry);
+    if (builtInSlots.has(id)) {
+      throw new Error(`[internal] ${registryId} already has a built-in registered as ${id}`);
+    }
+    sequence += 1;
+    const slot = { entry: { ...entry, id }, sequence };
+    builtInSlots.set(id, slot);
+    return slot.entry;
+  };
+  const register = (entry) => {
+    const id = readId(entry);
+    if (builtInSlots.has(id)) {
+      throw new Error(
+        `[internal] ${id} is a built-in ${registryId} strategy and cannot be replaced; register your own id`
+      );
+    }
+    sequence += 1;
+    const slot = { entry: { ...entry, id }, sequence };
+    contributedSlots.set(id, slot);
+    return () => {
+      if (contributedSlots.get(id) === slot) contributedSlots.delete(id);
+    };
+  };
+  const list = () => [...contributedSlots.values(), ...builtInSlots.values()].sort(orderSlots).map((slot) => slot.entry);
+  const get = (id) => {
+    if (typeof id !== "string") return null;
+    const trimmed = id.trim();
+    return contributedSlots.get(trimmed)?.entry ?? builtInSlots.get(trimmed)?.entry ?? null;
+  };
+  return {
+    registryId,
+    registerBuiltIn,
+    register,
+    get,
+    has: (id) => get(id) !== null,
+    isBuiltIn: (id) => typeof id === "string" && builtInSlots.has(id.trim()),
+    list,
+    ids: () => list().map((entry) => entry.id)
+  };
+}
+export {
+  BUILT_IN_STRATEGY_PRIORITY,
+  createStrategyRegistry
+};
+//# sourceMappingURL=registry.js.map

package/dist/modules/staff/lib/time-tracking/registries/registry.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/modules/staff/lib/time-tracking/registries/registry.ts"],
+  "sourcesContent": ["/**\n * The one registry shape every time-tracking strategy registry is built from\n * (EP-32\u2026EP-41 of `.ai/specs/2026-08-24-time-tracking-umes-extension-points.md`).\n *\n * It follows the house provider idiom \u2014 `registerPaymentProvider` /\n * `registerShippingProvider` in `modules/sales/lib/providers/registry.ts`: a\n * module-level `Map`, a `register` that returns its own disposer, and plain\n * lookup helpers. That makes every registry reachable from the browser bundle as\n * well as the server, which matters because four of these strategies are\n * consulted by client previews that cannot resolve DI.\n *\n * Ordering is the only thing added on top of the sales idiom, and it is what\n * keeps \"no contribution means no behaviour change\" true: entries are served in\n * descending `priority`, ties broken by registration order, and every built-in\n * registers at `BUILT_IN_STRATEGY_PRIORITY` \u2014 far below the default of `0` \u2014 so\n * a built-in is always the last candidate considered.\n *\n * **A built-in is not just a low-priority entry, it is a separate slot.** The\n * fail-closed rule in `scope.ts` lands an unscoped call on \"the built-in\", and the\n * whole point of that rule is that the built-in is the same pure code the module\n * shipped before the registries existed. With one map keyed by id and last-writer-\n * wins semantics, a contribution registering under a published built-in id BECAME\n * the built-in: it ran on the unscoped path the gate exists to keep byte-identical,\n * and its disposer then deleted the real built-in permanently, after which every\n * resolver that requires one throws. So `registerBuiltIn` writes to a map\n * `register` cannot reach, `register` refuses a built-in id outright, and no\n * disposer can remove a built-in.\n */\n\nexport const BUILT_IN_STRATEGY_PRIORITY = -1000\n\nexport type RegisteredStrategy = {\n  id: string\n  priority?: number\n}\n\nexport type StrategyRegistry<TEntry extends RegisteredStrategy> = {\n  registryId: string\n  /**\n   * Registers the module's own default. Not part of the contribution surface \u2014\n   * module-load code only. The returned entry is the identity every resolver\n   * should compare against rather than re-looking the id up.\n   */\n  registerBuiltIn(entry: TEntry): TEntry\n  /** Contributes a strategy. Throws on a built-in id. Returns its own disposer. */\n  register(entry: TEntry): () => void\n  get(id: string | null | undefined): TEntry | null\n  has(id: string | null | undefined): boolean\n  isBuiltIn(id: string | null | undefined): boolean\n  list(): TEntry[]\n  ids(): string[]\n}\n\ntype Slot<TEntry extends RegisteredStrategy> = {\n  entry: TEntry\n  sequence: number\n}\n\nfunction orderSlots<TEntry extends RegisteredStrategy>(left: Slot<TEntry>, right: Slot<TEntry>): number {\n  const leftPriority = left.entry.priority ?? 0\n  const rightPriority = right.entry.priority ?? 0\n  if (leftPriority !== rightPriority) return rightPriority - leftPriority\n  return left.sequence - right.sequence\n}\n\nexport function createStrategyRegistry<TEntry extends RegisteredStrategy>(\n  registryId: string,\n): StrategyRegistry<TEntry> {\n  const builtInSlots = new Map<string, Slot<TEntry>>()\n  const contributedSlots = new Map<string, Slot<TEntry>>()\n  let sequence = 0\n\n  const readId = (entry: TEntry): string => {\n    const id = typeof entry?.id === 'string' ? entry.id.trim() : ''\n    if (!id) throw new Error(`[internal] ${registryId} requires a non-empty strategy id`)\n    return id\n  }\n\n  const registerBuiltIn = (entry: TEntry): TEntry => {\n    const id = readId(entry)\n    if (builtInSlots.has(id)) {\n      throw new Error(`[internal] ${registryId} already has a built-in registered as ${id}`)\n    }\n    sequence += 1\n    const slot: Slot<TEntry> = { entry: { ...entry, id }, sequence }\n    builtInSlots.set(id, slot)\n    return slot.entry\n  }\n\n  const register = (entry: TEntry): (() => void) => {\n    const id = readId(entry)\n    if (builtInSlots.has(id)) {\n      throw new Error(\n        `[internal] ${id} is a built-in ${registryId} strategy and cannot be replaced; register your own id`,\n      )\n    }\n    sequence += 1\n    const slot: Slot<TEntry> = { entry: { ...entry, id }, sequence }\n    contributedSlots.set(id, slot)\n    return () => {\n      if (contributedSlots.get(id) === slot) contributedSlots.delete(id)\n    }\n  }\n\n  const list = (): TEntry[] =>\n    [...contributedSlots.values(), ...builtInSlots.values()].sort(orderSlots).map((slot) => slot.entry)\n\n  const get = (id: string | null | undefined): TEntry | null => {\n    if (typeof id !== 'string') return null\n    const trimmed = id.trim()\n    return contributedSlots.get(trimmed)?.entry ?? builtInSlots.get(trimmed)?.entry ?? null\n  }\n\n  return {\n    registryId,\n    registerBuiltIn,\n    register,\n    get,\n    has: (id) => get(id) !== null,\n    isBuiltIn: (id) => typeof id === 'string' && builtInSlots.has(id.trim()),\n    list,\n    ids: () => list().map((entry) => entry.id),\n  }\n}\n"],
+  "mappings": "AA6BO,MAAM,6BAA6B;AA6B1C,SAAS,WAA8C,MAAoB,OAA6B;AACtG,QAAM,eAAe,KAAK,MAAM,YAAY;AAC5C,QAAM,gBAAgB,MAAM,MAAM,YAAY;AAC9C,MAAI,iBAAiB,cAAe,QAAO,gBAAgB;AAC3D,SAAO,KAAK,WAAW,MAAM;AAC/B;AAEO,SAAS,uBACd,YAC0B;AAC1B,QAAM,eAAe,oBAAI,IAA0B;AACnD,QAAM,mBAAmB,oBAAI,IAA0B;AACvD,MAAI,WAAW;AAEf,QAAM,SAAS,CAAC,UAA0B;AACxC,UAAM,KAAK,OAAO,OAAO,OAAO,WAAW,MAAM,GAAG,KAAK,IAAI;AAC7D,QAAI,CAAC,GAAI,OAAM,IAAI,MAAM,cAAc,UAAU,mCAAmC;AACpF,WAAO;AAAA,EACT;AAEA,QAAM,kBAAkB,CAAC,UAA0B;AACjD,UAAM,KAAK,OAAO,KAAK;AACvB,QAAI,aAAa,IAAI,EAAE,GAAG;AACxB,YAAM,IAAI,MAAM,cAAc,UAAU,yCAAyC,EAAE,EAAE;AAAA,IACvF;AACA,gBAAY;AACZ,UAAM,OAAqB,EAAE,OAAO,EAAE,GAAG,OAAO,GAAG,GAAG,SAAS;AAC/D,iBAAa,IAAI,IAAI,IAAI;AACzB,WAAO,KAAK;AAAA,EACd;AAEA,QAAM,WAAW,CAAC,UAAgC;AAChD,UAAM,KAAK,OAAO,KAAK;AACvB,QAAI,aAAa,IAAI,EAAE,GAAG;AACxB,YAAM,IAAI;AAAA,QACR,cAAc,EAAE,kBAAkB,UAAU;AAAA,MAC9C;AAAA,IACF;AACA,gBAAY;AACZ,UAAM,OAAqB,EAAE,OAAO,EAAE,GAAG,OAAO,GAAG,GAAG,SAAS;AAC/D,qBAAiB,IAAI,IAAI,IAAI;AAC7B,WAAO,MAAM;AACX,UAAI,iBAAiB,IAAI,EAAE,MAAM,KAAM,kBAAiB,OAAO,EAAE;AAAA,IACnE;AAAA,EACF;AAEA,QAAM,OAAO,MACX,CAAC,GAAG,iBAAiB,OAAO,GAAG,GAAG,aAAa,OAAO,CAAC,EAAE,KAAK,UAAU,EAAE,IAAI,CAAC,SAAS,KAAK,KAAK;AAEpG,QAAM,MAAM,CAAC,OAAiD;AAC5D,QAAI,OAAO,OAAO,SAAU,QAAO;AACnC,UAAM,UAAU,GAAG,KAAK;AACxB,WAAO,iBAAiB,IAAI,OAAO,GAAG,SAAS,aAAa,IAAI,OAAO,GAAG,SAAS;AAAA,EACrF;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,KAAK,CAAC,OAAO,IAAI,EAAE,MAAM;AAAA,IACzB,WAAW,CAAC,OAAO,OAAO,OAAO,YAAY,aAAa,IAAI,GAAG,KAAK,CAAC;AAAA,IACvE;AAAA,IACA,KAAK,MAAM,KAAK,EAAE,IAAI,CAAC,UAAU,MAAM,EAAE;AAAA,EAC3C;AACF;",
+  "names": []
+}

package/dist/modules/staff/lib/time-tracking/registries/scope.js

@@ -0,0 +1,21 @@
+function isNonEmpty(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function readResolverScope(ctx) {
+  if (!ctx) return null;
+  if (!isNonEmpty(ctx.tenantId) || !isNonEmpty(ctx.organizationId)) return null;
+  return { tenantId: ctx.tenantId, organizationId: ctx.organizationId };
+}
+function hasResolverScope(ctx) {
+  return readResolverScope(ctx) !== null;
+}
+function selectScopedStrategy(candidates, builtIn, ctx) {
+  if (!hasResolverScope(ctx)) return builtIn;
+  return candidates[0] ?? builtIn;
+}
+export {
+  hasResolverScope,
+  readResolverScope,
+  selectScopedStrategy
+};
+//# sourceMappingURL=scope.js.map

package/dist/modules/staff/lib/time-tracking/registries/scope.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/modules/staff/lib/time-tracking/registries/scope.ts"],
+  "sourcesContent": ["/**\n * The scope contract every time-tracking strategy resolver receives, and the\n * fail-closed rule the spec's cross-cutting requirements attach to it: a\n * contributed strategy runs only when the caller supplied BOTH a tenant and an\n * organization, matching `resolveProjectAccess` in `../access.ts`.\n *\n * A built-in never needs the scope \u2014 it is the same pure arithmetic the module\n * shipped before the registries existed \u2014 so failing closed lands on the\n * built-in rather than on an error. That is what makes a client preview\n * (`TimeEntryDialog`, `timeTrackingSettingsForm`, `ProjectCodeField`), which has\n * no tenant id to hand, keep producing exactly the number it produced before.\n */\n\nexport type TimeTrackingResolverScope = {\n  tenantId: string\n  organizationId: string\n}\n\nexport type ScopedResolverContext = Partial<TimeTrackingResolverScope>\n\nfunction isNonEmpty(value: unknown): value is string {\n  return typeof value === 'string' && value.trim().length > 0\n}\n\nexport function readResolverScope(\n  ctx: ScopedResolverContext | null | undefined,\n): TimeTrackingResolverScope | null {\n  if (!ctx) return null\n  if (!isNonEmpty(ctx.tenantId) || !isNonEmpty(ctx.organizationId)) return null\n  return { tenantId: ctx.tenantId, organizationId: ctx.organizationId }\n}\n\nexport function hasResolverScope(ctx: ScopedResolverContext | null | undefined): boolean {\n  return readResolverScope(ctx) !== null\n}\n\n/**\n * Picks the strategy a scoped call site should run: the highest-priority\n * contribution when the scope is complete, the built-in otherwise. `candidates`\n * arrives already ordered by the registry.\n *\n * The built-in is passed **by reference**, not looked up by id among the\n * candidates. An id is a string anyone can register; identity is not. Resolving\n * the fail-closed default by id meant a contribution that named itself after the\n * built-in was served on the unscoped path the rule exists to keep byte-identical\n * \u2014 `registry.ts` now refuses that registration, and this makes the second half of\n * the same guarantee structural rather than conventional.\n */\nexport function selectScopedStrategy<TEntry extends { id: string }>(\n  candidates: readonly TEntry[],\n  builtIn: TEntry,\n  ctx: ScopedResolverContext | null | undefined,\n): TEntry {\n  if (!hasResolverScope(ctx)) return builtIn\n  return candidates[0] ?? builtIn\n}\n"],
+  "mappings": "AAoBA,SAAS,WAAW,OAAiC;AACnD,SAAO,OAAO,UAAU,YAAY,MAAM,KAAK,EAAE,SAAS;AAC5D;AAEO,SAAS,kBACd,KACkC;AAClC,MAAI,CAAC,IAAK,QAAO;AACjB,MAAI,CAAC,WAAW,IAAI,QAAQ,KAAK,CAAC,WAAW,IAAI,cAAc,EAAG,QAAO;AACzE,SAAO,EAAE,UAAU,IAAI,UAAU,gBAAgB,IAAI,eAAe;AACtE;AAEO,SAAS,iBAAiB,KAAwD;AACvF,SAAO,kBAAkB,GAAG,MAAM;AACpC;AAcO,SAAS,qBACd,YACA,SACA,KACQ;AACR,MAAI,CAAC,iBAAiB,GAAG,EAAG,QAAO;AACnC,SAAO,WAAW,CAAC,KAAK;AAC1B;",
+  "names": []
+}

package/dist/modules/staff/lib/time-tracking/rollup.js

@@ -0,0 +1,34 @@
+function readEntries(source, taskId) {
+  if (!source) return [];
+  if (source instanceof Map) return source.get(taskId) ?? [];
+  return source[taskId] ?? [];
+}
+function sumEntryMinutes(entries) {
+  let total = 0;
+  for (const entry of entries) {
+    if (!entry || entry.deletedAt) continue;
+    const minutes = entry.durationMinutes;
+    if (minutes === null || minutes === void 0 || !Number.isFinite(minutes)) continue;
+    total += minutes;
+  }
+  return total;
+}
+function loggedMinutes(task, allTasks, entriesByTaskId) {
+  const ownMinutes = sumEntryMinutes(readEntries(entriesByTaskId, task.id));
+  const children = (allTasks ?? []).filter(
+    (candidate) => candidate.parentTaskId === task.id && candidate.id !== task.id && !candidate.deletedAt
+  );
+  let childMinutes = 0;
+  for (const child of children) {
+    childMinutes += sumEntryMinutes(readEntries(entriesByTaskId, child.id));
+  }
+  return {
+    ownMinutes,
+    loggedMinutes: ownMinutes + childMinutes,
+    childCount: children.length
+  };
+}
+export {
+  loggedMinutes
+};
+//# sourceMappingURL=rollup.js.map

package/dist/modules/staff/lib/time-tracking/rollup.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/modules/staff/lib/time-tracking/rollup.ts"],
+  "sourcesContent": ["export type RollupTask = {\n  id: string\n  parentTaskId?: string | null\n  deletedAt?: Date | string | null\n}\n\nexport type RollupEntry = {\n  durationMinutes?: number | null\n  deletedAt?: Date | string | null\n}\n\nexport type EntriesByTaskId =\n  | ReadonlyMap<string, readonly RollupEntry[]>\n  | Record<string, readonly RollupEntry[] | undefined>\n\nexport type TaskRollup = {\n  ownMinutes: number\n  loggedMinutes: number\n  childCount: number\n}\n\nfunction readEntries(source: EntriesByTaskId | null | undefined, taskId: string): readonly RollupEntry[] {\n  if (!source) return []\n  if (source instanceof Map) return source.get(taskId) ?? []\n  return (source as Record<string, readonly RollupEntry[] | undefined>)[taskId] ?? []\n}\n\nfunction sumEntryMinutes(entries: readonly RollupEntry[]): number {\n  let total = 0\n  for (const entry of entries) {\n    if (!entry || entry.deletedAt) continue\n    const minutes = entry.durationMinutes\n    if (minutes === null || minutes === undefined || !Number.isFinite(minutes)) continue\n    total += minutes\n  }\n  return total\n}\n\nexport function loggedMinutes(\n  task: RollupTask,\n  allTasks: readonly RollupTask[],\n  entriesByTaskId: EntriesByTaskId,\n): TaskRollup {\n  const ownMinutes = sumEntryMinutes(readEntries(entriesByTaskId, task.id))\n  const children = (allTasks ?? []).filter(\n    (candidate) => candidate.parentTaskId === task.id && candidate.id !== task.id && !candidate.deletedAt,\n  )\n\n  let childMinutes = 0\n  for (const child of children) {\n    childMinutes += sumEntryMinutes(readEntries(entriesByTaskId, child.id))\n  }\n\n  return {\n    ownMinutes,\n    loggedMinutes: ownMinutes + childMinutes,\n    childCount: children.length,\n  }\n}\n"],
+  "mappings": "AAqBA,SAAS,YAAY,QAA4C,QAAwC;AACvG,MAAI,CAAC,OAAQ,QAAO,CAAC;AACrB,MAAI,kBAAkB,IAAK,QAAO,OAAO,IAAI,MAAM,KAAK,CAAC;AACzD,SAAQ,OAA8D,MAAM,KAAK,CAAC;AACpF;AAEA,SAAS,gBAAgB,SAAyC;AAChE,MAAI,QAAQ;AACZ,aAAW,SAAS,SAAS;AAC3B,QAAI,CAAC,SAAS,MAAM,UAAW;AAC/B,UAAM,UAAU,MAAM;AACtB,QAAI,YAAY,QAAQ,YAAY,UAAa,CAAC,OAAO,SAAS,OAAO,EAAG;AAC5E,aAAS;AAAA,EACX;AACA,SAAO;AACT;AAEO,SAAS,cACd,MACA,UACA,iBACY;AACZ,QAAM,aAAa,gBAAgB,YAAY,iBAAiB,KAAK,EAAE,CAAC;AACxE,QAAM,YAAY,YAAY,CAAC,GAAG;AAAA,IAChC,CAAC,cAAc,UAAU,iBAAiB,KAAK,MAAM,UAAU,OAAO,KAAK,MAAM,CAAC,UAAU;AAAA,EAC9F;AAEA,MAAI,eAAe;AACnB,aAAW,SAAS,UAAU;AAC5B,oBAAgB,gBAAgB,YAAY,iBAAiB,MAAM,EAAE,CAAC;AAAA,EACxE;AAEA,SAAO;AAAA,IACL;AAAA,IACA,eAAe,aAAa;AAAA,IAC5B,YAAY,SAAS;AAAA,EACvB;AACF;",
+  "names": []
+}

package/dist/modules/staff/lib/time-tracking/rounding.js

@@ -0,0 +1,66 @@
+import { extensionPoints } from "@open-mercato/core/modules/staff/extension-points";
+import { createStrategyRegistry, BUILT_IN_STRATEGY_PRIORITY } from "./registries/registry.js";
+import { selectScopedStrategy } from "./registries/scope.js";
+import { clampToStoredMinutes, runStrategy } from "./registries/invoke.js";
+const DEFAULT_ROUNDING_SETTINGS = {
+  unitMinutes: 0,
+  direction: "up"
+};
+const TIME_ROUNDING_REGISTRY_ID = extensionPoints.hosts.timeRoundingRegistry.spotId;
+const BUILT_IN_TIME_ROUNDING_STRATEGY_ID = "staff.time_tracking.rounding.unit";
+const registry = createStrategyRegistry(TIME_ROUNDING_REGISTRY_ID);
+function registerTimeRoundingStrategy(strategy) {
+  return registry.register(strategy);
+}
+function listTimeRoundingStrategies() {
+  return registry.list();
+}
+function getTimeRoundingStrategy(id) {
+  return registry.get(id);
+}
+function roundToUnit(raw, settings) {
+  if (!Number.isFinite(raw)) return 0;
+  const unit = settings?.unitMinutes ?? 0;
+  if (!unit) return Math.round(raw);
+  const sign = raw < 0 ? -1 : 1;
+  const magnitude = Math.abs(raw) / unit;
+  const units = settings.direction === "nearest" ? Math.round(magnitude) : Math.ceil(magnitude);
+  return sign * units * unit;
+}
+const builtInRoundingStrategy = registry.registerBuiltIn({
+  id: BUILT_IN_TIME_ROUNDING_STRATEGY_ID,
+  labelKey: "staff.time_tracking.rounding.strategy.unit",
+  priority: BUILT_IN_STRATEGY_PRIORITY,
+  round: (rawMinutes, ctx) => roundToUnit(rawMinutes, ctx.settings)
+});
+function resolveTimeRoundingStrategy(ctx) {
+  return selectScopedStrategy(registry.list(), builtInRoundingStrategy, ctx);
+}
+function roundMinutes(raw, settings, ctx) {
+  const strategy = resolveTimeRoundingStrategy(ctx);
+  const builtIn = () => roundToUnit(raw, settings);
+  if (strategy === builtInRoundingStrategy) return builtIn();
+  let threw = false;
+  const answer = runStrategy(
+    TIME_ROUNDING_REGISTRY_ID,
+    strategy.id,
+    () => strategy.round(raw, { ...ctx ?? {}, settings }),
+    () => {
+      threw = true;
+      return Number.NaN;
+    }
+  );
+  if (threw) return builtIn();
+  return clampToStoredMinutes(TIME_ROUNDING_REGISTRY_ID, strategy.id, answer, builtIn);
+}
+export {
+  BUILT_IN_TIME_ROUNDING_STRATEGY_ID,
+  DEFAULT_ROUNDING_SETTINGS,
+  TIME_ROUNDING_REGISTRY_ID,
+  getTimeRoundingStrategy,
+  listTimeRoundingStrategies,
+  registerTimeRoundingStrategy,
+  resolveTimeRoundingStrategy,
+  roundMinutes
+};
+//# sourceMappingURL=rounding.js.map

package/dist/modules/staff/lib/time-tracking/rounding.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/modules/staff/lib/time-tracking/rounding.ts"],
+  "sourcesContent": ["/**\n * EP-32 \u2014 the rounding strategy registry.\n *\n * `roundMinutes` is still the single rounding entry point every call site uses,\n * and with no contribution it runs the built-in `staff.time_tracking.rounding.unit`\n * strategy, which is the same `up`/`nearest` \u00D7 `0|5|10|15` arithmetic this file\n * has always held. A contribution outranks it only when the call site supplies a\n * complete tenant + organization scope (`registries/scope.ts`), so an unscoped\n * client preview keeps producing the built-in's number.\n */\n\nimport { extensionPoints } from '@open-mercato/core/modules/staff/extension-points'\nimport { createStrategyRegistry, BUILT_IN_STRATEGY_PRIORITY } from './registries/registry'\nimport { selectScopedStrategy, type ScopedResolverContext } from './registries/scope'\nimport { clampToStoredMinutes, runStrategy } from './registries/invoke'\n\nexport type RoundingUnitMinutes = 0 | 5 | 10 | 15\n\nexport type RoundingDirection = 'up' | 'nearest'\n\nexport type RoundingSettings = {\n  unitMinutes: RoundingUnitMinutes\n  direction: RoundingDirection\n}\n\nexport const DEFAULT_ROUNDING_SETTINGS: RoundingSettings = {\n  unitMinutes: 0,\n  direction: 'up',\n}\n\nexport type TimeRoundingContext = ScopedResolverContext & {\n  settings: RoundingSettings\n  /** Present on write paths; absent on the settings-screen and dialog previews. */\n  timeProjectId?: string | null\n  taskId?: string | null\n  staffMemberId?: string | null\n  date?: string | null\n}\n\nexport type TimeRoundingStrategy = {\n  id: string\n  labelKey: string\n  priority?: number\n  round(rawMinutes: number, ctx: TimeRoundingContext): number\n}\n\nexport const TIME_ROUNDING_REGISTRY_ID = extensionPoints.hosts.timeRoundingRegistry.spotId\n\nexport const BUILT_IN_TIME_ROUNDING_STRATEGY_ID = 'staff.time_tracking.rounding.unit'\n\nconst registry = createStrategyRegistry<TimeRoundingStrategy>(TIME_ROUNDING_REGISTRY_ID)\n\nexport function registerTimeRoundingStrategy(strategy: TimeRoundingStrategy): () => void {\n  return registry.register(strategy)\n}\n\nexport function listTimeRoundingStrategies(): TimeRoundingStrategy[] {\n  return registry.list()\n}\n\nexport function getTimeRoundingStrategy(id: string | null | undefined): TimeRoundingStrategy | null {\n  return registry.get(id)\n}\n\nfunction roundToUnit(raw: number, settings: RoundingSettings): number {\n  if (!Number.isFinite(raw)) return 0\n  const unit = settings?.unitMinutes ?? 0\n  if (!unit) return Math.round(raw)\n\n  const sign = raw < 0 ? -1 : 1\n  const magnitude = Math.abs(raw) / unit\n  const units = settings.direction === 'nearest' ? Math.round(magnitude) : Math.ceil(magnitude)\n  return sign * units * unit\n}\n\nconst builtInRoundingStrategy: TimeRoundingStrategy = registry.registerBuiltIn({\n  id: BUILT_IN_TIME_ROUNDING_STRATEGY_ID,\n  labelKey: 'staff.time_tracking.rounding.strategy.unit',\n  priority: BUILT_IN_STRATEGY_PRIORITY,\n  round: (rawMinutes, ctx) => roundToUnit(rawMinutes, ctx.settings),\n})\n\nexport function resolveTimeRoundingStrategy(\n  ctx?: ScopedResolverContext | null,\n): TimeRoundingStrategy {\n  return selectScopedStrategy(registry.list(), builtInRoundingStrategy, ctx)\n}\n\n/**\n * The single rounding entry point, and the boundary a contributed strategy's answer\n * has to survive.\n *\n * The result is written straight into `staff_time_entries.rounded_minutes` \u2014 an\n * `integer` column, and the only input to every amount the suite computes \u2014 so an\n * unusable answer is clamped back to the built-in's rather than stored, and one\n * larger than the column can hold is capped at its ceiling rather than 500ing the\n * write. The built-in is exempt from the clamp on purpose: it is the arithmetic the\n * module shipped, it cannot produce a non-finite or fractional value, and re-shaping\n * its output would be the behaviour change the registries exist to avoid.\n *\n * A strategy that *threw* has already been logged and replaced by `runStrategy`, so\n * it returns the built-in directly instead of routing its `NaN` through the clamp,\n * which would log the same failure a second time under the wrong description.\n */\nexport function roundMinutes(\n  raw: number,\n  settings: RoundingSettings,\n  ctx?: ScopedResolverContext | null,\n): number {\n  const strategy = resolveTimeRoundingStrategy(ctx)\n  const builtIn = () => roundToUnit(raw, settings)\n  if (strategy === builtInRoundingStrategy) return builtIn()\n\n  let threw = false\n  const answer = runStrategy(\n    TIME_ROUNDING_REGISTRY_ID,\n    strategy.id,\n    () => strategy.round(raw, { ...(ctx ?? {}), settings }),\n    () => {\n      threw = true\n      return Number.NaN\n    },\n  )\n  if (threw) return builtIn()\n  return clampToStoredMinutes(TIME_ROUNDING_REGISTRY_ID, strategy.id, answer, builtIn)\n}\n"],
+  "mappings": "AAWA,SAAS,uBAAuB;AAChC,SAAS,wBAAwB,kCAAkC;AACnE,SAAS,4BAAwD;AACjE,SAAS,sBAAsB,mBAAmB;AAW3C,MAAM,4BAA8C;AAAA,EACzD,aAAa;AAAA,EACb,WAAW;AACb;AAkBO,MAAM,4BAA4B,gBAAgB,MAAM,qBAAqB;AAE7E,MAAM,qCAAqC;AAElD,MAAM,WAAW,uBAA6C,yBAAyB;AAEhF,SAAS,6BAA6B,UAA4C;AACvF,SAAO,SAAS,SAAS,QAAQ;AACnC;AAEO,SAAS,6BAAqD;AACnE,SAAO,SAAS,KAAK;AACvB;AAEO,SAAS,wBAAwB,IAA4D;AAClG,SAAO,SAAS,IAAI,EAAE;AACxB;AAEA,SAAS,YAAY,KAAa,UAAoC;AACpE,MAAI,CAAC,OAAO,SAAS,GAAG,EAAG,QAAO;AAClC,QAAM,OAAO,UAAU,eAAe;AACtC,MAAI,CAAC,KAAM,QAAO,KAAK,MAAM,GAAG;AAEhC,QAAM,OAAO,MAAM,IAAI,KAAK;AAC5B,QAAM,YAAY,KAAK,IAAI,GAAG,IAAI;AAClC,QAAM,QAAQ,SAAS,cAAc,YAAY,KAAK,MAAM,SAAS,IAAI,KAAK,KAAK,SAAS;AAC5F,SAAO,OAAO,QAAQ;AACxB;AAEA,MAAM,0BAAgD,SAAS,gBAAgB;AAAA,EAC7E,IAAI;AAAA,EACJ,UAAU;AAAA,EACV,UAAU;AAAA,EACV,OAAO,CAAC,YAAY,QAAQ,YAAY,YAAY,IAAI,QAAQ;AAClE,CAAC;AAEM,SAAS,4BACd,KACsB;AACtB,SAAO,qBAAqB,SAAS,KAAK,GAAG,yBAAyB,GAAG;AAC3E;AAkBO,SAAS,aACd,KACA,UACA,KACQ;AACR,QAAM,WAAW,4BAA4B,GAAG;AAChD,QAAM,UAAU,MAAM,YAAY,KAAK,QAAQ;AAC/C,MAAI,aAAa,wBAAyB,QAAO,QAAQ;AAEzD,MAAI,QAAQ;AACZ,QAAM,SAAS;AAAA,IACb;AAAA,IACA,SAAS;AAAA,IACT,MAAM,SAAS,MAAM,KAAK,EAAE,GAAI,OAAO,CAAC,GAAI,SAAS,CAAC;AAAA,IACtD,MAAM;AACJ,cAAQ;AACR,aAAO,OAAO;AAAA,IAChB;AAAA,EACF;AACA,MAAI,MAAO,QAAO,QAAQ;AAC1B,SAAO,qBAAqB,2BAA2B,SAAS,IAAI,QAAQ,OAAO;AACrF;",
+  "names": []
+}

package/dist/modules/staff/lib/time-tracking/roundingImpact.js

@@ -0,0 +1,39 @@
+import { roundMinutes } from "./rounding.js";
+const EMPTY_ROUNDING_IMPACT = {
+  entryCount: 0,
+  rawMinutes: 0,
+  roundedMinutes: 0,
+  deltaMinutes: 0
+};
+function toCount(value) {
+  const parsed = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.trunc(parsed) : 0;
+}
+function toMinutes(value) {
+  const parsed = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(parsed) ? Math.trunc(parsed) : 0;
+}
+function projectRoundingImpact(buckets, settings) {
+  let entryCount = 0;
+  let rawMinutes = 0;
+  let roundedMinutes = 0;
+  for (const bucket of buckets) {
+    const count = toCount(bucket.entryCount);
+    if (count === 0) continue;
+    const duration = toMinutes(bucket.durationMinutes);
+    entryCount += count;
+    rawMinutes += duration * count;
+    roundedMinutes += roundMinutes(duration, settings) * count;
+  }
+  return {
+    entryCount,
+    rawMinutes,
+    roundedMinutes,
+    deltaMinutes: roundedMinutes - rawMinutes
+  };
+}
+export {
+  EMPTY_ROUNDING_IMPACT,
+  projectRoundingImpact
+};
+//# sourceMappingURL=roundingImpact.js.map

package/dist/modules/staff/lib/time-tracking/roundingImpact.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/modules/staff/lib/time-tracking/roundingImpact.ts"],
+  "sourcesContent": ["/**\n * Rounding impact projection (T7.2) \u2014 the warning card on screen 16.\n *\n * Changing the rounding rule changes what clients are billed, and the effect is\n * invisible until an invoice. The preview answers the only question that matters\n * before saving: at the candidate rule, what would the last 90 days have billed?\n *\n * Two properties this file exists to guarantee:\n *\n *  1. **It rounds through `roundMinutes`, never a second implementation.** A\n *     preview that disagreed with the write path would be worse than no preview.\n *  2. **It rounds per entry, not per sum** (D-7). That is why the projection is\n *     driven by `(durationMinutes, entryCount)` buckets rather than a SQL\n *     `SUM(duration_minutes)`: the database groups identical durations, and each\n *     distinct duration is rounded exactly once and multiplied by its count. The\n *     result is arithmetically identical to rounding every row, at a fraction of\n *     the rows.\n */\n\nimport { roundMinutes, type RoundingSettings } from './rounding'\n\nexport type DurationBucket = {\n  durationMinutes: number\n  entryCount: number\n}\n\nexport type RoundingImpact = {\n  entryCount: number\n  rawMinutes: number\n  roundedMinutes: number\n  /** Positive when the rule bills more than the raw time; negative when it bills less. */\n  deltaMinutes: number\n}\n\nexport const EMPTY_ROUNDING_IMPACT: RoundingImpact = {\n  entryCount: 0,\n  rawMinutes: 0,\n  roundedMinutes: 0,\n  deltaMinutes: 0,\n}\n\nfunction toCount(value: unknown): number {\n  const parsed = typeof value === 'number' ? value : Number(value)\n  return Number.isFinite(parsed) && parsed > 0 ? Math.trunc(parsed) : 0\n}\n\nfunction toMinutes(value: unknown): number {\n  const parsed = typeof value === 'number' ? value : Number(value)\n  return Number.isFinite(parsed) ? Math.trunc(parsed) : 0\n}\n\nexport function projectRoundingImpact(\n  buckets: readonly DurationBucket[],\n  settings: RoundingSettings,\n): RoundingImpact {\n  let entryCount = 0\n  let rawMinutes = 0\n  let roundedMinutes = 0\n\n  for (const bucket of buckets) {\n    const count = toCount(bucket.entryCount)\n    if (count === 0) continue\n    const duration = toMinutes(bucket.durationMinutes)\n    entryCount += count\n    rawMinutes += duration * count\n    roundedMinutes += roundMinutes(duration, settings) * count\n  }\n\n  return {\n    entryCount,\n    rawMinutes,\n    roundedMinutes,\n    deltaMinutes: roundedMinutes - rawMinutes,\n  }\n}\n"],
+  "mappings": "AAmBA,SAAS,oBAA2C;AAe7C,MAAM,wBAAwC;AAAA,EACnD,YAAY;AAAA,EACZ,YAAY;AAAA,EACZ,gBAAgB;AAAA,EAChB,cAAc;AAChB;AAEA,SAAS,QAAQ,OAAwB;AACvC,QAAM,SAAS,OAAO,UAAU,WAAW,QAAQ,OAAO,KAAK;AAC/D,SAAO,OAAO,SAAS,MAAM,KAAK,SAAS,IAAI,KAAK,MAAM,MAAM,IAAI;AACtE;AAEA,SAAS,UAAU,OAAwB;AACzC,QAAM,SAAS,OAAO,UAAU,WAAW,QAAQ,OAAO,KAAK;AAC/D,SAAO,OAAO,SAAS,MAAM,IAAI,KAAK,MAAM,MAAM,IAAI;AACxD;AAEO,SAAS,sBACd,SACA,UACgB;AAChB,MAAI,aAAa;AACjB,MAAI,aAAa;AACjB,MAAI,iBAAiB;AAErB,aAAW,UAAU,SAAS;AAC5B,UAAM,QAAQ,QAAQ,OAAO,UAAU;AACvC,QAAI,UAAU,EAAG;AACjB,UAAM,WAAW,UAAU,OAAO,eAAe;AACjD,kBAAc;AACd,kBAAc,WAAW;AACzB,sBAAkB,aAAa,UAAU,QAAQ,IAAI;AAAA,EACvD;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA,cAAc,iBAAiB;AAAA,EACjC;AACF;",
+  "names": []
+}