@kernhq/module-hr 0.10.0 → 0.10.2

package/dist/server/router.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../src/server/router.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,MAAM,EACX,KAAK,cAAc,EAMpB,MAAM,gBAAgB,CAAA;AA2DvB;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqyHxC"}
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../src/server/router.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,MAAM,EACX,KAAK,cAAc,EAMpB,MAAM,gBAAgB,CAAA;AA0DvB;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAw4HxC"}

package/dist/server/router.js

@@ -5,12 +5,11 @@ import { HrSettings, hrContract, hrEvents, MODULE_ID } from '../contract/index.j
 import { AccrualConfig, CarryForwardConfig, OvertimeConfig, RoundingConfig, WorkingTimeConfig, } from '../contract/policies.js';
 import { accrueForPeriod } from '../policy/accrual.js';
 import { countWorkingDays, workingDays } from '../policy/calendar.js';
-import { businessDateFor } from '../policy/working-time.js';
-import { COUNTRY_PACKS, packDays } from './packs/index.js';
+import { COUNTRY_PACKS, packDays, packFor } from './packs/index.js';
 import { approvalChains, approvalDecisions, approvalRequests, approvalSteps, attendanceDays, calendarDays, calendars, costCenters, customFieldDefs, delegations, employments, leaveLedger, leaveRequestDays, leaveRequests, leaveTypes, legalEntities, officeAssignments, offices, orgUnits, people, peopleSensitive, periods, personDocuments, personHistory, policies, policyAssignments, positions, punches, regularizations, scheduleAssignments, schedules, } from './schema.js';
 import { ApprovalService } from './services/approvals.js';
 import { AttendanceService } from './services/attendance.js';
-import { inForceOn, todayIn, todayIso } from './services/db.js';
+import { inForceOn, todayIso } from './services/db.js';
 import { LedgerService, MINUTES_PER_DAY, yearOf } from './services/ledger.js';
 import { PeopleService } from './services/people.js';
 import { hashConfig, PolicyService } from './services/policies.js';
@@ -35,8 +34,8 @@ export function implement_(kernel) {
     const svc = new PeopleService(kernel);
     const ledger = new LedgerService();
     const approvals = new ApprovalService(kernel);
-    const attendance = new AttendanceService();
     const policySvc = new PolicyService(resolve);
+    const attendance = new AttendanceService(resolve, policySvc);
     const db = kernel.database;
     const settingsOf = (workspaceId) => kernel.settings.module(workspaceId, MODULE_ID, HrSettings);
     const changed = (workspaceId, entity, id, op) => kernel.realtime.change(workspaceId, { module: MODULE_ID, entity, id, op });
@@ -1496,13 +1495,12 @@ export function implement_(kernel) {
                         .where(eq(periods.id, period.id))
                         .returning();
                     // The day sheet carries its own flag so a recomputation does not have to join periods
-                    // on every row — this is what actually stops a closed month moving.
-                    const locked = await tx
-                        .update(attendanceDays)
-                        .set({ locked: true })
-                        .where(and(eq(attendanceDays.workspaceId, input.workspaceId), gte(attendanceDays.businessDate, period.startsOn), lte(attendanceDays.businessDate, period.endsOn)))
-                        .returning({ id: attendanceDays.id });
-                    return { period: row, lockedDays: locked.length };
+                    // on every row — this is what actually stops a closed month moving. It is stamped
+                    // through `setPeriodLock`, which is also what keeps the flag scoped to the period's
+                    // legal entity: filtering on the date range alone closed January for every entity in
+                    // the workspace, while `isLocked` went on answering for one.
+                    const lockedDays = await attendance.setPeriodLock(tx, input.workspaceId, period, true);
+                    return { period: row, lockedDays };
                 });
                 await changed(input.workspaceId, 'period', input.periodId, 'updated');
                 return { ...toPeriod(result.period), lockedDays: result.lockedDays };
@@ -1523,20 +1521,16 @@ export function implement_(kernel) {
                     })
                         .where(eq(periods.id, period.id))
                         .returning();
-                    const unlocked = await tx
-                        .update(attendanceDays)
-                        .set({ locked: false })
-                        .where(and(eq(attendanceDays.workspaceId, input.workspaceId), gte(attendanceDays.businessDate, period.startsOn), lte(attendanceDays.businessDate, period.endsOn)))
-                        .returning({ id: attendanceDays.id });
+                    const unlockedDays = await attendance.setPeriodLock(tx, input.workspaceId, period, false);
                     kernel.log.warn({
                         module: MODULE_ID,
                         workspaceId: input.workspaceId,
                         periodId: period.id,
-                        days: unlocked.length,
+                        days: unlockedDays,
                         actorId: context.principal.userId,
                         reason: input.reason,
                     }, 'payroll period reopened');
-                    return { period: row, unlockedDays: unlocked.length };
+                    return { period: row, unlockedDays };
                 });
                 await changed(input.workspaceId, 'period', input.periodId, 'updated');
                 return { ...toPeriod(result.period), unlockedDays: result.unlockedDays };
@@ -1549,13 +1543,16 @@ export function implement_(kernel) {
                 .use(requires('hr.attendance.view'))
                 .handler(({ input, context }) => db.withWorkspace(input.workspaceId, async (tx) => {
                 const personId = await personFor(tx, input.workspaceId, context, input.personId);
-                const { timezone, businessDate, schedule } = await clockContext(tx, input.workspaceId, personId);
-                const rows = await attendance.punchesOn(tx, input.workspaceId, personId, businessDate);
+                // The same attribution the next punch will be judged against, so what a person is shown
+                // and what they are then allowed to do cannot disagree. Somebody who forgot to clock out
+                // last night is told they are still on last night's shift, which is both true and the
+                // thing they need to know before pressing anything.
+                const { timezone, at, attribution } = await clockNow(tx, input.workspaceId, personId);
                 let open = null;
                 let onBreak = false;
                 let workedMs = 0;
                 let breakOpen = null;
-                for (const r of rows) {
+                for (const r of attribution.punches) {
                     if (r.direction === 'in')
                         open = r.at;
                     else if (r.direction === 'out' && open) {
@@ -1573,15 +1570,15 @@ export function implement_(kernel) {
                     }
                 }
                 // An open span counts up to now, so the widget shows time accruing rather than freezing
-                // at the last completed pair.
+                // at the last completed pair. `at` rather than a fresh `Date.now()`: one instant per
+                // request, the one the attribution was made from.
                 if (open)
-                    workedMs += Date.now() - open.getTime();
+                    workedMs += at.getTime() - open.getTime();
                 if (breakOpen)
-                    workedMs -= Date.now() - breakOpen.getTime();
-                void schedule;
+                    workedMs -= at.getTime() - breakOpen.getTime();
                 return {
                     personId,
-                    businessDate,
+                    businessDate: attribution.businessDate,
                     clockedIn: open !== null,
                     onBreak,
                     since: (open ?? breakOpen)?.toISOString() ?? null,
@@ -1635,7 +1632,7 @@ export function implement_(kernel) {
                         const me = await svc.byUserId(tx, input.workspaceId, context.principal.userId ?? '');
                         const { original } = await attendance.voidPunch(tx, input.workspaceId, input.punchId, input.reason, me?.id ?? null);
                         // The day is derived, so voiding a punch means the sheet is stale until it is rebuilt.
-                        const { timezone, schedule } = await clockContext(tx, input.workspaceId, original.personId);
+                        const { timezone, schedule } = await personContext(tx, input.workspaceId, original.personId);
                         await attendance.recomputeDay(tx, input.workspaceId, original.personId, original.businessDate, timezone, schedule);
                         return original;
                     });
@@ -1685,7 +1682,7 @@ export function implement_(kernel) {
                     .use(requires('hr.attendance.manage'))
                     .handler(({ input, context }) => db.withWorkspace(input.workspaceId, async (tx) => {
                     const personId = await personFor(tx, input.workspaceId, context, input.personId);
-                    const { timezone, schedule } = await clockContext(tx, input.workspaceId, personId);
+                    const { timezone, schedule } = await personContext(tx, input.workspaceId, personId);
                     const dates = await attendance.datesWithPunches(tx, input.workspaceId, personId, input.from, input.to);
                     let recomputed = 0;
                     const skippedLocked = [];
@@ -2061,7 +2058,12 @@ export function implement_(kernel) {
                         await ledger.lockAndRead(tx, input.workspaceId, personId, input.leaveTypeId, year);
                         const sim = await simulate(tx, input.workspaceId, personId, input);
                         if (sim.blockers.length)
-                            throw KernError.conflict(sim.blockers[0].message, `hr.leave.${sim.blockers[0].code}`);
+                            // `details`, for the reason `refusePunch` gives: `KernError.conflict`'s second
+                            // argument is kept on the error object and never serialised, so the blocker code
+                            // this line has always meant to send was reaching nobody.
+                            throw new KernError('CONFLICT', sim.blockers[0].message, {
+                                reason: `hr.leave.${sim.blockers[0].code}`,
+                            });
                         const [request] = await tx
                             .insert(leaveRequests)
                             .values({
@@ -2130,8 +2132,14 @@ export function implement_(kernel) {
                     .handler(async ({ input, context }) => {
                     const row = await db.withWorkspace(input.workspaceId, async (tx) => {
                         const request = await loadRequest(tx, input.workspaceId, input.requestId);
-                        if (request.status === 'cancelled' || request.status === 'withdrawn')
-                            throw KernError.conflict('That request is already cancelled');
+                        // A reason beside the sentence, because the sentence is English and the reason is what
+                        // a client can translate. Two states, not one: "withdrawn" is the requester taking it
+                        // back and "cancelled" is somebody else doing so, and telling a person their own
+                        // withdrawal was "already cancelled" is a small lie about who did what.
+                        if (request.status === 'cancelled')
+                            throw KernError.conflict('That request is already cancelled.', 'hr.leave.already_cancelled');
+                        if (request.status === 'withdrawn')
+                            throw KernError.conflict('That request was already withdrawn.', 'hr.leave.already_withdrawn');
                         const year = yearOf(request.startsOn);
                         await ledger.lockAndRead(tx, input.workspaceId, request.personId, request.leaveTypeId, year);
                         // Approved leave is *reversed*, not deleted. "She booked it and cancelled" and "she
@@ -2647,7 +2655,31 @@ export function implement_(kernel) {
      * company's own holidays during a routine yearly refresh, silently, months before anyone notices.
      * Showing exactly which days survive is how an administrator can believe the operation.
      */
+    /**
+     * The days a pack would add, change and drop — and the days it must never touch.
+     *
+     * A pack key nobody publishes is refused rather than treated as a pack with no days in it.
+     * `packDays` answers `[]` for an unknown key, which made the diff for a typo "add nothing, change
+     * nothing, **remove every national holiday**" — with Apply live beside it, and `keptCustom` still
+     * promising the company's own days were safe, which was true and beside the point. The screen
+     * could reach that state on its own: `COUNTRY_PACKS` is keyed `TR`, the editor prefilled the
+     * calendar's country lowercased, and so a calendar made by hand offered to empty itself.
+     *
+     * This is the one operation in the module that deletes rows a customer did not ask it to, so it
+     * fails closed: an unknown key is a mistake, never an instruction.
+     */
+    function requirePack(packKey) {
+        // `packFor` states the rule and is tested beside the packs; this turns its refusal into the
+        // error shape a client can render.
+        try {
+            packFor(packKey);
+        }
+        catch (error) {
+            throw KernError.badRequest(error.message);
+        }
+    }
     async function diffPack(tx, workspaceId, calendarId, packKey, year) {
+        requirePack(packKey);
         const from = `${year}-01-01`;
         const to = `${year}-12-31`;
         const existing = await tx
@@ -2946,17 +2978,55 @@ export function implement_(kernel) {
         };
     }
     /**
-     * Everything a punch needs: the person's zone, today's business date, and their schedule.
+     * Everything a punch needs about a person: their zone, and the schedule that shapes their day.
      *
      * The zone comes from the resolution ladder — their primary office unless they have an override —
      * so a punch made on a business trip still counts towards the month they are employed in.
+     *
+     * Everything here is resolved **as of today**, which is what a punch is about. It is therefore
+     * not the place to answer a question about a past date: this used to hand out today's legal
+     * entity as well, and three callers applied it to business dates months back — so a person who
+     * transferred entity had a filed month recomputed against the one they are in now. `recomputeDay`
+     * asks that question of the day it is rebuilding.
      */
-    async function clockContext(tx, workspaceId, personId) {
+    async function personContext(tx, workspaceId, personId) {
         const today = todayIso();
         const resolution = await resolve.forPerson(tx, workspaceId, personId, today);
         const schedule = await attendance.scheduleFor(tx, workspaceId, personId, today);
-        const businessDate = businessDateFor(Date.now(), resolution.timezone, schedule.shiftFor(todayIn(resolution.timezone)));
-        return { timezone: resolution.timezone, businessDate, schedule, resolution };
+        return { timezone: resolution.timezone, schedule, resolution };
+    }
+    /**
+     * The same, plus the one decision every clock procedure has to agree about: which shift *this
+     * instant* belongs to, and what is already filed on it.
+     *
+     * The instant is taken once, here, and travels with its answer — so the guard, the row that is
+     * written and the figures the widget shows all come out of a single attribution. They used to be
+     * three: `clockContext` attributed `Date.now()`, the guard re-read the punches of whatever date
+     * that produced, and `record` attributed its own `new Date()` again on the way to the insert.
+     * Every version of the night-shift bug is those answers disagreeing, and a person being told they
+     * are not clocked in at the end of a shift they have just worked.
+     */
+    async function clockNow(tx, workspaceId, personId) {
+        const context = await personContext(tx, workspaceId, personId);
+        const at = new Date();
+        const attribution = await attendance.attribute(tx, workspaceId, personId, at.getTime(), context.timezone, context.schedule);
+        return { ...context, at, attribution };
+    }
+    /**
+     * A refused punch: the sentence for the reader, and a stable reason for the screen.
+     *
+     * The reason travels in `details`, not in `KernError.conflict`'s `reason` argument. Only
+     * `details` is on the wire — `kernErrorToORPC` maps it to the oRPC error's `data` and drops
+     * everything else — so a reason passed as `conflict(message, reason)` never leaves this process.
+     * Reasons are dotted and namespaced like `hr.leave.*` above, and are API: renaming one silently
+     * puts the English sentence back in front of every non-English reader.
+     *
+     * A `function`, like every other helper down here: these sit after the router's `return`, so a
+     * `const` is never initialised and the first refusal throws a ReferenceError instead of a
+     * conflict. `noUnreachable` is what catches that — nothing else does until a person punches.
+     */
+    function refusePunch(reason, message) {
+        return new KernError('CONFLICT', message, { reason });
     }
     /**
      * One punch, and the day rebuilt straight afterwards.
@@ -2968,24 +3038,35 @@ export function implement_(kernel) {
     async function punch(input, context, direction) {
         const row = await db.withWorkspace(input.workspaceId, async (tx) => {
             const personId = await personFor(tx, input.workspaceId, context, input.personId);
-            const { timezone, businessDate, schedule, resolution } = await clockContext(tx, input.workspaceId, personId);
+            const { timezone, schedule, resolution, at, attribution } = await clockNow(tx, input.workspaceId, personId);
             // Refuse the transitions that make no sense, with a sentence rather than a constraint error:
             // clocking in twice, or out when never in, is somebody double-tapping a button.
-            const existing = await attendance.punchesOn(tx, input.workspaceId, personId, businessDate);
-            const open = openState(existing);
+            //
+            // The sentence is written for a person, and it is written in English — a router has no locale.
+            // So every refusal also carries a *reason*, which is what the clock widget translates; the
+            // sentence is what it falls back to for a reason it has no string for, so a sixth refusal
+            // added here reaches the reader in English rather than not at all.
+            //
+            // What it is judged against comes out of the attribution rather than being fetched again.
+            // Re-reading `punchesOn(businessDate)` here is what made the guard circular: it could only
+            // ever confirm the date the attribution had already chosen, so a wrong choice arrived as
+            // "You are not clocked in." at the end of a shift somebody had just worked.
+            const open = attribution.open;
             if (direction === 'in' && open.clockedIn)
-                throw KernError.conflict('You are already clocked in.');
+                throw refusePunch('hr.clock.already_clocked_in', 'You are already clocked in.');
             if (direction === 'out' && !open.clockedIn)
-                throw KernError.conflict('You are not clocked in.');
+                throw refusePunch('hr.clock.not_clocked_in', 'You are not clocked in.');
             if (direction === 'break_start' && !open.clockedIn)
-                throw KernError.conflict('Clock in before starting a break.');
+                throw refusePunch('hr.clock.break_before_clock_in', 'Clock in before starting a break.');
             if (direction === 'break_start' && open.onBreak)
-                throw KernError.conflict('You are already on a break.');
+                throw refusePunch('hr.clock.already_on_break', 'You are already on a break.');
             if (direction === 'break_end' && !open.onBreak)
-                throw KernError.conflict('You are not on a break.');
+                throw refusePunch('hr.clock.not_on_break', 'You are not on a break.');
             const punchRow = await attendance.record(tx, input.workspaceId, {
                 personId,
                 direction,
+                at,
+                businessDate: attribution.businessDate,
                 timezone,
                 method: input.method ?? 'web',
                 clientReportedAt: input.clientReportedAt ?? null,
@@ -2993,7 +3074,10 @@ export function implement_(kernel) {
                 geo: input.geo ?? null,
                 note: input.note ?? null,
                 idempotencyKey: input.idempotencyKey ?? null,
-            }, schedule);
+            });
+            // A punch inside a closed month is still recorded — it is a fact about somebody's day, and
+            // refusing it because payroll has been filed loses the fact to protect the report. What must
+            // not move is the derived sheet, and `recomputeDay` is where that is decided.
             await attendance.recomputeDay(tx, input.workspaceId, personId, punchRow.businessDate, timezone, schedule);
             return punchRow;
         });
@@ -3007,24 +3091,6 @@ export function implement_(kernel) {
         await changed(input.workspaceId, 'attendance_day', row.personId, 'updated');
         return toPunch(row);
     }
-    /** Whether a person is currently clocked in or on a break, from their punches so far. */
-    function openState(rows) {
-        let clockedIn = false;
-        let onBreak = false;
-        for (const r of rows) {
-            if (r.direction === 'in')
-                clockedIn = true;
-            else if (r.direction === 'out') {
-                clockedIn = false;
-                onBreak = false;
-            }
-            else if (r.direction === 'break_start')
-                onBreak = true;
-            else if (r.direction === 'break_end')
-                onBreak = false;
-        }
-        return { clockedIn, onBreak };
-    }
     /**
      * Apply an approved correction: write the proposed punches, void what they replace, rebuild.
      *
@@ -3042,7 +3108,7 @@ export function implement_(kernel) {
             return;
         if (row.punchId)
             await attendance.voidPunch(tx, workspaceId, row.punchId, 'Regularized', null);
-        const { timezone, schedule } = await clockContext(tx, workspaceId, row.personId);
+        const { timezone, schedule } = await personContext(tx, workspaceId, row.personId);
         for (const proposal of row.proposed)
             await tx.insert(punches).values({
                 id: uuidv7(),
@@ -3121,6 +3187,30 @@ export function implement_(kernel) {
             .from(employments)
             .where(and(eq(employments.workspaceId, workspaceId), inArray(employments.personId, ids), inForceOn(employments.effectiveFrom, employments.effectiveTo, to)));
         const employmentBy = new Map(employmentRows.map((e) => [e.personId, e]));
+        /**
+         * Hours worked in the window, for the frequency that accrues against them.
+         *
+         * The preview has to answer with the same numbers the job will credit, so it reads the same
+         * inputs. `per_hour_worked` was fed by neither for as long as it existed, which made the
+         * preview quietly agree with a job that granted nothing. Only queried where a policy asks.
+         */
+        const hoursBy = new Map();
+        if ([...resolved.values()].some((p) => p?.config?.frequency === 'per_hour_worked')) {
+            const rows = await tx
+                .select({
+                personId: attendanceDays.personId,
+                worked: sql `coalesce(sum(${attendanceDays.workedMinutes}), 0)`,
+                scheduled: sql `coalesce(sum(${attendanceDays.scheduledMinutes}), 0)`,
+            })
+                .from(attendanceDays)
+                .where(and(eq(attendanceDays.workspaceId, workspaceId), inArray(attendanceDays.personId, ids), gte(attendanceDays.businessDate, from), lte(attendanceDays.businessDate, to)))
+                .groupBy(attendanceDays.personId);
+            for (const r of rows)
+                hoursBy.set(r.personId, {
+                    workedMinutes: Number(r.worked),
+                    scheduledMinutes: Number(r.scheduled),
+                });
+        }
         const types = await tx
             .select()
             .from(leaveTypes)
@@ -3175,6 +3265,7 @@ export function implement_(kernel) {
                 hiredOn: person.hiredOn,
                 terminatedOn: person.terminatedOn,
                 fte: employment ? Number.parseFloat(employment.fte ?? '1') : 1,
+                ...hoursBy.get(person.id),
             });
             const alreadyAccrued = already.has(`${person.id}:${type.id}`);
             rows.push({