shutro-erp 0.3.5 → 0.3.7

package/dist/attendance/days.d.ts

@@ -0,0 +1,96 @@
+import { type Decimal, type Id } from '../server/orm.js';
+import type { Env } from './.kosh/bindings.js';
+/** The installation's time zone for attendance; a wrong one falls back to Asia/Dhaka. */
+export declare function timeZoneOf(env: Env): Promise<string>;
+/** The date of an instant where the people work, `YYYY-MM-DD`. */
+export declare function localDate(at: Date, tz: string): string;
+/** The instant of `minutes` after midnight of `date` in `tz` (minutes may pass 1 440: the next day). */
+export declare function instantOf(date: string, minutes: number, tz: string): Date;
+/** `YYYY-MM-DD` plus `days`. */
+export declare function addDays(date: string, days: number): string;
+/** `HH:MM` as minutes after midnight. */
+export declare const minutesOf: (hhmm: string) => number;
+export interface ShiftRule {
+    readonly start: string;
+    readonly end: string;
+    readonly breakMinutes: number;
+    readonly graceMinutes: number;
+    readonly overtimeAfter: number;
+    readonly overtimeStep: number;
+}
+export interface DayInput {
+    readonly date: string;
+    readonly tz: string;
+    readonly shift: ShiftRule | null;
+    readonly weekend: boolean;
+    readonly holiday: boolean;
+    readonly leave: boolean;
+    readonly punches: readonly {
+        readonly checkIn: Date;
+        readonly checkOut: Date | null;
+    }[];
+}
+export interface DayResult {
+    readonly status: 'present' | 'absent' | 'leave' | 'holiday' | 'weekend' | 'incomplete' | 'off';
+    readonly firstIn: Date | null;
+    readonly lastOut: Date | null;
+    readonly workedMinutes: number;
+    readonly expectedMinutes: number;
+    readonly lateMinutes: number;
+    readonly earlyMinutes: number;
+    readonly overtimeMinutes: number;
+}
+/** The day: what the punches, the shift and the calendar say. */
+export declare function computeDay(input: DayInput): DayResult;
+/** A shift's length in minutes; a night shift ends the next day. */
+export declare function shiftMinutes(shift: Pick<ShiftRule, 'start' | 'end'>): number;
+/** Recomputes the days of `employees` from `from` to `to` (inclusive); approved days stay as they are. */
+export declare function recomputeDays(env: Env, employees: readonly number[], from: string, to: string): Promise<number>;
+/** A date-only value as `YYYY-MM-DD` (PostgreSQL dates read as local midnights). */
+export declare function isoDate(v: unknown): string;
+/** The distance in metres between two points (haversine). */
+export declare function distanceMetres(a: {
+    lat: number;
+    lon: number;
+}, b: {
+    lat: number;
+    lon: number;
+}): number;
+export interface PunchInput {
+    readonly source: 'phone' | 'kiosk' | 'device' | 'manual';
+    readonly site?: number | null;
+    readonly inside?: boolean | null;
+    readonly distance?: number | null;
+}
+/** Checks the employee in, or out when checked in; recomputes the day. */
+export declare function punch(env: Env, employee: number, at: Date, input: PunchInput): Promise<{
+    action: 'in' | 'out';
+    record: number;
+    at: string;
+}>;
+/** A punch read from a device file: the person's number on the device and the local time. */
+export interface DevicePunch {
+    readonly user: string;
+    /** `YYYY-MM-DD HH:MM[:SS]`, in the installation's time zone. */
+    readonly at: string;
+}
+/** A device file format (RFC 0024 §3: an adapter; ZKTeco's log and a CSV ship). */
+export interface DeviceFormat {
+    readonly key: string;
+    readonly label: string;
+    readonly parse: (text: string) => DevicePunch[];
+}
+export declare const DEVICE_FORMATS: readonly DeviceFormat[];
+export interface ImportResult {
+    readonly imported: number;
+    readonly skipped: number;
+    readonly unpaired: number;
+    readonly unknown: readonly string[];
+}
+/**
+ * Device punches into check-ins and check-outs: each person's punches of a day in pairs (in, out); a punch left
+ * alone stays a check-in on the person's last day, and is reported as unpaired before it. A punch already imported
+ * (the same person and time) is skipped.
+ */
+export declare function importPunches(env: Env, punches: readonly DevicePunch[]): Promise<ImportResult>;
+export type { Decimal, Id };

package/dist/attendance/days.js

@@ -0,0 +1,430 @@
+/**
+ * Attendance computed (RFC 0024 §2.2): the day of each person from their punches, their shift (the roster's, else
+ * their usual one), the weekend (Workforce's setting), public holidays and approved leave — in the installation's
+ * time zone (App settings › Attendance). Approved days are never recomputed.
+ *
+ * Also here: a punch from the phone or the kiosk (check in, or out when checked in), the geofence, and device files
+ * (ZKTeco's attendance log and a plain CSV) turned into punches, each once.
+ */
+import { weekendOf } from '../hr/index.js';
+import { installationSetting } from '../server/index.js';
+import { orm } from '../server/orm.js';
+const DAY = 86_400_000;
+// ---- time zones: dates and minutes of the day where the people work.
+/** The installation's time zone for attendance; a wrong one falls back to Asia/Dhaka. */
+export async function timeZoneOf(env) {
+    const tz = String(await installationSetting(env, 'attendance.timezone', 'Asia/Dhaka'));
+    try {
+        new Intl.DateTimeFormat('en-US', { timeZone: tz });
+        return tz;
+    }
+    catch {
+        return 'Asia/Dhaka';
+    }
+}
+function parts(at, tz) {
+    const out = {};
+    for (const p of new Intl.DateTimeFormat('en-US', {
+        timeZone: tz,
+        hourCycle: 'h23',
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+    }).formatToParts(at))
+        if (p.type !== 'literal')
+            out[p.type] = Number(p.value);
+    return {
+        y: out['year'] ?? 0,
+        m: out['month'] ?? 1,
+        d: out['day'] ?? 1,
+        h: out['hour'] ?? 0,
+        min: out['minute'] ?? 0,
+    };
+}
+/** The date of an instant where the people work, `YYYY-MM-DD`. */
+export function localDate(at, tz) {
+    const p = parts(at, tz);
+    return `${p.y}-${String(p.m).padStart(2, '0')}-${String(p.d).padStart(2, '0')}`;
+}
+/** The instant of `minutes` after midnight of `date` in `tz` (minutes may pass 1 440: the next day). */
+export function instantOf(date, minutes, tz) {
+    const [y, m, d] = date.split('-').map(Number);
+    const guess = Date.UTC(y, m - 1, d, 0, minutes);
+    const offset = (t) => {
+        const p = parts(new Date(t), tz);
+        return Date.UTC(p.y, p.m - 1, p.d, p.h, p.min) - t;
+    };
+    const first = guess - offset(guess);
+    return new Date(guess - offset(first));
+}
+/** `YYYY-MM-DD` plus `days`. */
+export function addDays(date, days) {
+    return new Date(Date.parse(`${date}T00:00:00Z`) + days * DAY).toISOString().slice(0, 10);
+}
+/** `HH:MM` as minutes after midnight. */
+export const minutesOf = (hhmm) => {
+    const [h, m] = hhmm.split(':').map(Number);
+    return h * 60 + m;
+};
+/** The day: what the punches, the shift and the calendar say. */
+export function computeDay(input) {
+    const { shift, punches } = input;
+    const workday = shift !== null && !input.weekend && !input.holiday && !input.leave;
+    const span = shift === null ? 0 : shiftMinutes(shift);
+    const expected = workday && shift !== null ? Math.max(0, span - shift.breakMinutes) : 0;
+    const sorted = [...punches].sort((a, b) => a.checkIn.getTime() - b.checkIn.getTime());
+    if (sorted.length === 0)
+        return {
+            status: input.leave
+                ? 'leave'
+                : input.holiday
+                    ? 'holiday'
+                    : input.weekend
+                        ? 'weekend'
+                        : shift === null
+                            ? 'off'
+                            : 'absent',
+            firstIn: null,
+            lastOut: null,
+            workedMinutes: 0,
+            expectedMinutes: expected,
+            lateMinutes: 0,
+            earlyMinutes: 0,
+            overtimeMinutes: 0,
+        };
+    const present = sorted.reduce((sum, p) => sum + (p.checkOut === null ? 0 : (p.checkOut.getTime() - p.checkIn.getTime()) / 60_000), 0);
+    // The shift's break is not work: deducted, less the breaks the punches already show (their gaps).
+    let gaps = 0;
+    for (let i = 1; i < sorted.length; i += 1) {
+        const before = sorted[i - 1]?.checkOut;
+        const next = sorted[i]?.checkIn;
+        if (before != null && next !== undefined)
+            gaps += Math.max(0, (next.getTime() - before.getTime()) / 60_000);
+    }
+    const unpaidBreak = shift === null ? 0 : Math.max(0, shift.breakMinutes - gaps);
+    const worked = present > unpaidBreak ? present - unpaidBreak : present;
+    const firstIn = sorted[0]?.checkIn ?? null;
+    const closed = sorted.filter((p) => p.checkOut !== null);
+    const lastOut = closed.length === 0 ? null : (closed[closed.length - 1]?.checkOut ?? null);
+    const open = sorted.some((p) => p.checkOut === null);
+    const midnight = instantOf(input.date, 0, input.tz).getTime();
+    const sinceMidnight = (d) => Math.round((d.getTime() - midnight) / 60_000);
+    let late = 0;
+    let early = 0;
+    let overtime = 0;
+    if (workday && shift !== null) {
+        const start = minutesOf(shift.start);
+        const end = start + span;
+        if (firstIn !== null)
+            late = Math.max(0, sinceMidnight(firstIn) - (start + shift.graceMinutes));
+        if (lastOut !== null && !open)
+            early = Math.max(0, end - sinceMidnight(lastOut));
+        const extra = worked - expected;
+        if (extra > shift.overtimeAfter)
+            overtime = floorTo(extra, shift.overtimeStep);
+    }
+    else if (shift !== null && (input.weekend || input.holiday)) {
+        // Every hour worked on a weekend or a holiday is overtime.
+        overtime = floorTo(worked, shift.overtimeStep);
+    }
+    return {
+        status: open ? 'incomplete' : 'present',
+        firstIn,
+        lastOut,
+        workedMinutes: Math.round(worked),
+        expectedMinutes: expected,
+        lateMinutes: Math.round(late),
+        earlyMinutes: Math.round(early),
+        overtimeMinutes: overtime,
+    };
+}
+/** A shift's length in minutes; a night shift ends the next day. */
+export function shiftMinutes(shift) {
+    const start = minutesOf(shift.start);
+    let end = minutesOf(shift.end);
+    if (end <= start)
+        end += 1440;
+    return end - start;
+}
+const floorTo = (minutes, step) => Math.floor(minutes / Math.max(1, step)) * Math.max(1, step);
+const hours = (minutes) => orm.toDecimal(minutes).div(60).toDecimalPlaces(2).toString();
+// ---- days written for people and dates.
+/** Recomputes the days of `employees` from `from` to `to` (inclusive); approved days stay as they are. */
+export async function recomputeDays(env, employees, from, to) {
+    if (employees.length === 0 || to < from)
+        return 0;
+    const tz = await timeZoneOf(env);
+    const weekend = await weekendOf(env);
+    let written = 0;
+    for (const e of await env
+        .model('hr.employee')
+        .browse(employees)
+        .load({ attendanceShift: true, company: true })) {
+        const rosters = await (await env.model('attendance.roster').search({
+            where: { employee: e.id, dateFrom: { lte: to }, dateTo: { gte: from } },
+        })).load({ shift: true });
+        const holidays = new Set([
+            ...(await (await env.model('attendance.holiday').search({
+                where: { company: e.company.id, date: { gte: from, lte: to } },
+            })).load(['date'])),
+        ].map((h) => isoDate(h.date)));
+        const leaves = [
+            ...(await (await env.model('hr.leave').search({
+                where: {
+                    employee: e.id,
+                    state: 'approved',
+                    dateFrom: { lte: to },
+                    dateTo: { gte: from },
+                },
+            })).load(['dateFrom', 'dateTo'])),
+        ].map((l) => [isoDate(l.dateFrom), isoDate(l.dateTo)]);
+        const punches = [
+            ...(await (await env.model('attendance.record').search({
+                where: {
+                    employee: e.id,
+                    checkIn: { gte: instantOf(from, 0, tz), lt: instantOf(addDays(to, 1), 0, tz) },
+                },
+            })).load(['checkIn', 'checkOut'])),
+        ];
+        const existing = new Map([
+            ...(await (await env.model('attendance.day').search({
+                where: { employee: e.id, date: { gte: from, lte: to } },
+            })).load(['date', 'state'])),
+        ].map((d) => [isoDate(d.date), d]));
+        for (let date = from; date <= to; date = addDays(date, 1)) {
+            const old = existing.get(date);
+            if (old?.state === 'approved')
+                continue;
+            const roster = [...rosters].find((r) => isoDate(r.dateFrom) <= date && isoDate(r.dateTo) >= date);
+            const shift = roster?.shift ?? e.attendanceShift ?? null;
+            const mine = punches.filter((p) => localDate(p.checkIn, tz) === date);
+            const dow = new Date(`${date}T00:00:00Z`).getUTCDay();
+            const result = computeDay({
+                date,
+                tz,
+                shift,
+                weekend: weekend.includes(dow),
+                holiday: holidays.has(date),
+                leave: leaves.some(([a, b]) => a <= date && b >= date),
+                punches: mine,
+            });
+            // Nothing to say about a weekend, a holiday or a day without a shift nobody worked.
+            if (old === undefined &&
+                mine.length === 0 &&
+                ['weekend', 'holiday', 'off'].includes(result.status))
+                continue;
+            const values = {
+                employee: e.id,
+                date,
+                company: e.company.id,
+                shift: shift?.id ?? null,
+                status: result.status,
+                firstIn: result.firstIn,
+                lastOut: result.lastOut,
+                workedHours: hours(result.workedMinutes),
+                expectedHours: hours(result.expectedMinutes),
+                lateMinutes: result.lateMinutes,
+                earlyMinutes: result.earlyMinutes,
+                overtimeHours: hours(result.overtimeMinutes),
+                overtimeApproved: hours(result.overtimeMinutes),
+                overtimeRate: (shift?.overtimeRate ?? orm.toDecimal(2)).toString(),
+            };
+            if (old === undefined)
+                await env.model('attendance.day').create([values]);
+            else
+                await env
+                    .model('attendance.day')
+                    .browse([old.id])
+                    .write(values);
+            written += 1;
+        }
+    }
+    return written;
+}
+/** A date-only value as `YYYY-MM-DD` (PostgreSQL dates read as local midnights). */
+export function isoDate(v) {
+    if (!(v instanceof Date))
+        return String(v ?? '').slice(0, 10);
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${v.getFullYear()}-${pad(v.getMonth() + 1)}-${pad(v.getDate())}`;
+}
+// ---- punches.
+/** The distance in metres between two points (haversine). */
+export function distanceMetres(a, b) {
+    const rad = (x) => (x * Math.PI) / 180;
+    const dLat = rad(b.lat - a.lat);
+    const dLon = rad(b.lon - a.lon);
+    const h = Math.sin(dLat / 2) ** 2 + Math.cos(rad(a.lat)) * Math.cos(rad(b.lat)) * Math.sin(dLon / 2) ** 2;
+    return Math.round(2 * 6_371_000 * Math.asin(Math.sqrt(h)));
+}
+/** Checks the employee in, or out when checked in; recomputes the day. */
+export async function punch(env, employee, at, input) {
+    const open = await env
+        .model('attendance.record')
+        .search({ where: { employee: employee, checkOut: { isNull: true } }, limit: 1 });
+    const [e] = await env
+        .model('hr.employee')
+        .browse([employee])
+        .load({ company: true });
+    if (e === undefined)
+        throw new orm.ValidationError('attendance.record', ['employee'], 'No such employee.', 'Choose an employee.');
+    let action;
+    let id;
+    let checkIn = at;
+    if (open.length > 0) {
+        const [current] = await open.load(['checkIn']);
+        checkIn = current?.checkIn ?? at;
+        if (at.getTime() - checkIn.getTime() < 60_000)
+            throw new orm.ValidationError('attendance.record', ['checkOut'], 'Checked in less than a minute ago.', 'A second tap is not a check-out: wait a minute.');
+        await open.write({ checkOut: at });
+        action = 'out';
+        id = open.ids[0];
+    }
+    else {
+        const made = await env.model('attendance.record').create([
+            {
+                employee,
+                company: e.company.id,
+                checkIn: at,
+                source: input.source,
+                site: input.site ?? null,
+                ...(input.inside == null ? {} : { inside: input.inside }),
+                distance: input.distance ?? null,
+            },
+        ]);
+        action = 'in';
+        id = made.ids[0];
+    }
+    await env.flush();
+    const tz = await timeZoneOf(env);
+    await recomputeDays(env, [employee], localDate(checkIn, tz), localDate(at, tz));
+    return { action, record: id, at: at.toISOString() };
+}
+const LOCAL = /^(\d{4}-\d{2}-\d{2})[ T](\d{2}:\d{2})(:\d{2})?$/;
+export const DEVICE_FORMATS = [
+    {
+        key: 'zkteco',
+        label: 'ZKTeco attendance log (attlog.dat)',
+        // `   12\t2026-10-20 08:58:12\t1\t0\t1\t0`: the user ID, the date and time, then flags.
+        parse: (text) => text
+            .split(/\r?\n/)
+            .map((line) => line.trim().split(/\s+/))
+            .filter((cols) => cols.length >= 3 && LOCAL.test(`${cols[1]} ${cols[2]}`))
+            .map((cols) => ({ user: cols[0], at: `${cols[1]} ${cols[2]}` })),
+    },
+    {
+        key: 'csv',
+        label: 'CSV: employee code and time',
+        // A header with `employee` (the badge or device user ID) and `time` (or `timestamp`) columns.
+        parse: (text) => {
+            const rows = text
+                .split(/\r?\n/)
+                .filter((l) => l.trim() !== '')
+                .map((l) => l.split(',').map((c) => c.trim().replace(/^"|"$/g, '')));
+            const header = (rows[0] ?? []).map((h) => h.toLowerCase());
+            const who = header.findIndex((h) => h === 'employee' || h === 'code' || h === 'user');
+            const when = header.findIndex((h) => h === 'time' || h === 'timestamp' || h === 'datetime');
+            if (who < 0 || when < 0)
+                return [];
+            return rows
+                .slice(1)
+                .map((r) => ({ user: r[who] ?? '', at: r[when] ?? '' }))
+                .filter((p) => p.user !== '' && LOCAL.test(p.at));
+        },
+    },
+];
+/**
+ * Device punches into check-ins and check-outs: each person's punches of a day in pairs (in, out); a punch left
+ * alone stays a check-in on the person's last day, and is reported as unpaired before it. A punch already imported
+ * (the same person and time) is skipped.
+ */
+export async function importPunches(env, punches) {
+    const tz = await timeZoneOf(env);
+    const codes = [...new Set(punches.map((p) => p.user))];
+    const people = new Map();
+    if (codes.length > 0) {
+        for (const e of await (await env.model('hr.employee').search({
+            where: { or: [{ deviceUserId: { in: codes } }, { attendanceBadge: { in: codes } }] },
+        })).load(['deviceUserId', 'attendanceBadge'])) {
+            if (e.deviceUserId !== null)
+                people.set(e.deviceUserId, e.id);
+            if (e.attendanceBadge !== null && !people.has(e.attendanceBadge))
+                people.set(e.attendanceBadge, e.id);
+        }
+    }
+    const unknown = codes.filter((c) => !people.has(c));
+    const toInstant = (at) => {
+        const m = LOCAL.exec(at);
+        const [hh, mm] = m[2].split(':').map(Number);
+        const ss = m[3] === undefined ? 0 : Number(m[3].slice(1));
+        return new Date(instantOf(m[1], hh * 60 + mm, tz).getTime() + ss * 1000);
+    };
+    let imported = 0;
+    let skipped = 0;
+    let unpaired = 0;
+    const touched = new Map();
+    const byPerson = new Map();
+    for (const p of punches) {
+        const id = people.get(p.user);
+        if (id === undefined)
+            continue;
+        const list = byPerson.get(id) ?? [];
+        list.push(toInstant(p.at));
+        byPerson.set(id, list);
+    }
+    for (const [employee, times] of byPerson) {
+        const [e] = await env
+            .model('hr.employee')
+            .browse([employee])
+            .load({ company: true });
+        if (e === undefined)
+            continue;
+        const sorted = [...new Set(times.map((t) => t.getTime()))]
+            .sort((a, b) => a - b)
+            .map((t) => new Date(t));
+        const days = new Map();
+        for (const t of sorted) {
+            const d = localDate(t, tz);
+            days.set(d, [...(days.get(d) ?? []), t]);
+        }
+        const dates = [...days.keys()].sort();
+        for (const date of dates) {
+            const list = days.get(date);
+            for (let i = 0; i < list.length; i += 2) {
+                const checkIn = list[i];
+                const checkOut = list[i + 1] ?? null;
+                const exists = await env
+                    .model('attendance.record')
+                    .search({ where: { employee: employee, checkIn }, limit: 1 });
+                if (exists.length > 0) {
+                    skipped += 1;
+                    continue;
+                }
+                if (checkOut === null) {
+                    const open = await env.model('attendance.record').search({
+                        where: { employee: employee, checkOut: { isNull: true } },
+                        limit: 1,
+                    });
+                    if (date !== dates[dates.length - 1] || open.length > 0) {
+                        unpaired += 1;
+                        continue;
+                    }
+                }
+                await env
+                    .model('attendance.record')
+                    .create([
+                    { employee, company: e.company.id, checkIn, checkOut, source: 'device' },
+                ]);
+                imported += 1;
+            }
+        }
+        if (dates.length > 0)
+            touched.set(employee, { from: dates[0], to: dates[dates.length - 1] });
+    }
+    await env.flush();
+    for (const [employee, span] of touched)
+        await recomputeDays(env, [employee], span.from, span.to);
+    return { imported, skipped, unpaired, unknown };
+}

package/dist/attendance/demo.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Attendance's demo data (RFC 0008 §5.8): the head office as a site with its geofence, the General shift as Rahim's
+ * and Sumi's usual one, and their check-ins of the last working days — one late arrival, one evening of overtime —
+ * computed into days that wait for Dina's review.
+ */
+import type { DemoContext } from '../modules-sdk/index.js';
+export declare function attendanceDemo(ctx: DemoContext): Promise<string>;

package/dist/attendance/demo.js

@@ -0,0 +1,58 @@
+import { idByName } from '../modules-sdk/index.js';
+import { instantOf, recomputeDays, timeZoneOf } from './days.js';
+const DINA = { login: 'dina', name: 'Dina Rahman', groups: ['attendance.manager'] };
+const RAHIM = { login: 'rahim', name: 'Rahim Uddin', groups: ['attendance.user'] };
+const SUMI = { login: 'sumi', name: 'Sumi Begum', groups: ['attendance.user'] };
+export async function attendanceDemo(ctx) {
+    const uid = async (user) => ctx.as(user, async (raw) => raw.userId);
+    const users = { rahim: await uid(RAHIM), sumi: await uid(SUMI) };
+    await ctx.as(DINA, async (raw) => {
+        const env = raw;
+        const general = await idByName(env, 'attendance.shift', 'General');
+        await env.model('attendance.site').create([
+            {
+                name: 'Head office',
+                latitude: '23.780600',
+                longitude: '90.407800',
+                radius: 200,
+            },
+        ]);
+        const tz = await timeZoneOf(env);
+        const people = [];
+        for (const [name, user] of [
+            ['Rahim Uddin', users.rahim],
+            ['Sumi Begum', users.sumi],
+        ]) {
+            const found = await env.model('hr.employee').search({ where: { user }, limit: 1 });
+            const id = found.ids[0] ?? (await env.model('hr.employee').create([{ name, user }])).ids[0];
+            if (id === undefined)
+                continue;
+            await env
+                .model('hr.employee')
+                .browse([id])
+                .write({ attendanceShift: general });
+            people.push(id);
+        }
+        // Five weekdays back: Rahim late on the first, Sumi two hours over on the second.
+        const days = [-5, -4, -3].map((d) => ctx.date(d));
+        for (const [i, date] of days.entries())
+            for (const [p, employee] of people.entries()) {
+                const late = p === 0 && i === 0 ? 35 : 0;
+                const over = p === 1 && i === 1 ? 120 : 0;
+                await env.model('attendance.record').create([
+                    {
+                        employee,
+                        checkIn: instantOf(date, 9 * 60 - 5 + late, tz),
+                        checkOut: instantOf(date, 18 * 60 + 2 + over, tz),
+                        source: 'manual',
+                    },
+                ]);
+            }
+        await env.flush();
+        await env.asSuperuser({ reason: 'demo attendance days' }, async (su) => {
+            await recomputeDays(su, people, days[0], days[days.length - 1]);
+            await su.flush();
+        });
+    });
+    return 'Attendance: the head office site, the General shift, three days of check-ins to review.';
+}

package/dist/attendance/i18n/bn.d.ts

@@ -0,0 +1,2 @@
+/** Bangla for the module's labels, keyed by their English text (RFC 0023 §3.1; `pnpm i18n:extract`). */
+export declare const bn: Readonly<Record<string, string>>;