@happyvertical/smrt-timesheets 0.55.23 → 0.56.0

package/dist/chunks/attendance-DGVy-iHI.js

@@ -0,0 +1,1246 @@
+import { i as ServiceTimeEntryCollection, o as parseTimesheetJson } from "./service-time-entry-t7P-bkOQ.js";
+import { c as AttendanceSegmentCollection, d as persistAutoClose, f as persistCorrection, i as AttendancePunchCollection, l as deleteCorrection, n as AttendanceBreakCollection, o as AttendanceReplayCollection, r as AttendancePunch, s as AttendanceSegment, t as AttendanceBreak, u as isCorrectionWrite } from "./models-0-YD5F_o.js";
+import { SmrtCollection, SmrtObject, crossPackageRef, field, foreignKey, isEmbeddedDatabase, isPostgresDatabase, smrt, withEmbeddedWriteTransaction } from "@happyvertical/smrt-core";
+import { TenantScoped, getTenantId, tenantId, withTenant } from "@happyvertical/smrt-tenancy";
+//#region src/attendance/correction-models.ts
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value
+}) : obj[key] = value;
+var __decorateClass = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp(target, key, result);
+	return result;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var ATTENDANCE_CORRECTION_KINDS = [
+	"punch.corrected",
+	"punch.added",
+	"break.added",
+	"break.changed",
+	"break.removed",
+	"segment.added",
+	"segment.changed",
+	"segment.removed"
+];
+var IMMUTABLE_COLUMNS = [
+	"tenant_id",
+	"subject_profile_id",
+	"actor_profile_id",
+	"kind",
+	"punch_id",
+	"target_id",
+	"before_state",
+	"after_state",
+	"reason"
+];
+var AttendanceCorrection = class extends SmrtObject {
+	tenantId = "";
+	subjectProfileId = "";
+	actorProfileId = "";
+	kind = "punch.corrected";
+	punchId = "";
+	/** The break or segment id for those kinds; the punch id for punch kinds. */
+	targetId = "";
+	beforeState = "null";
+	afterState = "null";
+	reason = "";
+	acknowledgementRequired = false;
+	acknowledgedAt = null;
+	acknowledgedByProfileId = null;
+	/** The values before the change, or null for an addition. */
+	getBefore() {
+		return parseTimesheetJson(this.beforeState, null);
+	}
+	/** The values after the change, or null for a removal. */
+	getAfter() {
+		return parseTimesheetJson(this.afterState, null);
+	}
+	async save() {
+		if (!isCorrectionWrite(this)) throw new Error("Attendance corrections are writable only through AttendanceCorrectionService.");
+		if (!this.tenantId || !this.subjectProfileId || !this.actorProfileId || !this.punchId || !this.targetId || !ATTENDANCE_CORRECTION_KINDS.includes(this.kind) || typeof this.reason !== "string" || !this.reason.trim() || typeof this.acknowledgementRequired !== "boolean") throw new Error("Invalid attendance correction.");
+		for (const json of [this.beforeState, this.afterState]) JSON.parse(json);
+		if (!!this.acknowledgedAt !== !!this.acknowledgedByProfileId) throw new Error("Acknowledgement needs both a time and a profile.");
+		if (this.acknowledgedAt) {
+			if (!this.acknowledgementRequired) throw new Error("This correction does not require acknowledgement.");
+			if (this.acknowledgedByProfileId !== this.subjectProfileId) throw new Error("Only the subject can acknowledge a correction.");
+		}
+		const prior = this.id ? await this.db.get(this.tableName, { id: this.id }) : null;
+		if (prior) {
+			const row = this;
+			const camel = (column) => column.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+			if (IMMUTABLE_COLUMNS.some((column) => prior[column] !== row[camel(column)]) || Boolean(prior.acknowledgement_required) !== this.acknowledgementRequired || prior.acknowledged_at && (new Date(prior.acknowledged_at).getTime() !== this.acknowledgedAt?.getTime() || prior.acknowledged_by_profile_id !== this.acknowledgedByProfileId)) throw new Error("Attendance corrections are append-only; only a first acknowledgement may change.");
+		}
+		this.id ??= crypto.randomUUID();
+		return super.save();
+	}
+	async delete() {
+		throw new Error("Attendance correction history cannot be deleted.");
+	}
+};
+__publicField(AttendanceCorrection, "__smrtPackage__", "@happyvertical/smrt-timesheets");
+__decorateClass([tenantId()], AttendanceCorrection.prototype, "tenantId", 2);
+__decorateClass([crossPackageRef("@happyvertical/smrt-profiles:Profile")], AttendanceCorrection.prototype, "subjectProfileId", 2);
+__decorateClass([crossPackageRef("@happyvertical/smrt-profiles:Profile")], AttendanceCorrection.prototype, "actorProfileId", 2);
+__decorateClass([field({ type: "text" })], AttendanceCorrection.prototype, "kind", 2);
+__decorateClass([foreignKey(AttendancePunch)], AttendanceCorrection.prototype, "punchId", 2);
+__decorateClass([field({ type: "text" })], AttendanceCorrection.prototype, "beforeState", 2);
+__decorateClass([field({ type: "text" })], AttendanceCorrection.prototype, "afterState", 2);
+__decorateClass([field({ type: "text" })], AttendanceCorrection.prototype, "reason", 2);
+__decorateClass([crossPackageRef("@happyvertical/smrt-profiles:Profile", { nullable: true })], AttendanceCorrection.prototype, "acknowledgedByProfileId", 2);
+AttendanceCorrection = __decorateClass([TenantScoped({ mode: "required" }), smrt({
+	tableName: "attendance_corrections",
+	sensitive: true,
+	indexes: [{
+		name: "attendance_corrections_punch_idx",
+		columns: ["tenantId", "punchId"]
+	}, {
+		name: "attendance_corrections_subject_idx",
+		columns: ["tenantId", "subjectProfileId"]
+	}],
+	api: { include: [] },
+	cli: { include: [] },
+	mcp: { include: [] }
+})], AttendanceCorrection);
+var AttendanceCorrectionCollection = class extends SmrtCollection {
+	static _itemClass = AttendanceCorrection;
+};
+//#endregion
+//#region src/attendance/context.ts
+var MAX_LABEL = 64;
+function attendanceLabel(value, name) {
+	if (value === void 0 || value === null) return "";
+	if (typeof value !== "string" || value !== value.trim() || value.length > MAX_LABEL) throw new AttendanceConflict(`${name} must be a trimmed string of at most ${MAX_LABEL} characters.`, "invalid");
+	return value;
+}
+function attendanceProvenance(options) {
+	const source = attendanceLabel(options?.source, "source");
+	const device = options?.device;
+	if (device !== void 0 && (!device || typeof device !== "object")) throw new AttendanceConflict("device must be { type, id }.", "invalid");
+	const deviceRefType = attendanceLabel(device?.type, "device.type");
+	const deviceRefId = attendanceLabel(device?.id, "device.id");
+	if (!!deviceRefType !== !!deviceRefId) throw new AttendanceConflict("device.type and device.id must be provided together.", "invalid");
+	return {
+		source,
+		deviceRefType,
+		deviceRefId
+	};
+}
+var AttendanceConflict = class extends Error {
+	/**
+	* Stable machine-readable reason (see {@link AttendanceRefusalCode}); stored
+	* on a refused replay outcome so a device screen can say why.
+	*/
+	code;
+	constructor(message, code = "conflict") {
+		super(message);
+		this.code = code;
+	}
+};
+function validateAttendanceWork(work) {
+	if (!work || typeof work.workRefType !== "string" || !work.workRefType || typeof work.workRefId !== "string" || !work.workRefId || typeof work.description !== "string") throw new AttendanceConflict("A complete work reference and description are required.");
+	for (const key of [
+		"taskRefType",
+		"taskRefId",
+		"kind"
+	]) if (work[key] !== void 0 && typeof work[key] !== "string") throw new AttendanceConflict(`${key} must be a string.`);
+	if (!!work.taskRefType !== !!work.taskRefId) throw new AttendanceConflict("taskRefType and taskRefId must be provided together.");
+}
+function attendanceIdentity(db, value) {
+	if (!isPostgresDatabase(db)) return value;
+	const hex = value.replace(/[{}-]/g, "").toLowerCase();
+	if (!/^[0-9a-f]{32}$/.test(hex)) throw new Error("PostgreSQL attendance identities must be UUIDs.");
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+//#endregion
+//#region src/attendance/segments.ts
+async function openSegment(tx, punch) {
+	const [segment] = await tx.segments.list({
+		where: {
+			tenantId: punch.tenantId,
+			punchId: punch.id,
+			endedAt: null
+		},
+		limit: 1
+	});
+	return segment ?? null;
+}
+async function listSegments(tx, punch) {
+	return tx.segments.list({
+		where: {
+			tenantId: punch.tenantId,
+			punchId: punch.id
+		},
+		orderBy: "started_at ASC"
+	});
+}
+async function closeOpenSegment(tx, punch, at, reason) {
+	const segment = await openSegment(tx, punch);
+	if (!segment) return null;
+	if (at < segment.startedAt) throw new AttendanceConflict("Segment cannot end before it starts.");
+	segment.endedAt = at;
+	segment.closedReason = reason;
+	await segment.save();
+	return segment;
+}
+async function beginSegment(tx, punch, at, work) {
+	validateAttendanceWork(work);
+	if (punch.endedAt) throw new AttendanceConflict("Punch is closed.");
+	if ((await tx.breaks.list({ where: {
+		tenantId: punch.tenantId,
+		punchId: punch.id
+	} })).some((b) => !b.endedAt)) throw new AttendanceConflict("Cannot work during an open break.", "during_break");
+	if (await openSegment(tx, punch)) throw new AttendanceConflict("A work segment is already open.", "work_open");
+	return tx.segments.create({
+		tenantId: punch.tenantId,
+		punchId: punch.id ?? void 0,
+		workRefType: work.workRefType,
+		workRefId: work.workRefId,
+		taskRefType: work.taskRefType ?? "",
+		taskRefId: work.taskRefId ?? "",
+		kind: work.kind ?? "",
+		description: work.description,
+		startedAt: at,
+		_insertOnly: true
+	});
+}
+async function replaceSegment(tx, punch, at, work) {
+	validateAttendanceWork(work);
+	if (!await closeOpenSegment(tx, punch, at, "switch")) throw new AttendanceConflict("No open work segment to switch.", "no_open_work");
+	return beginSegment(tx, punch, at, work);
+}
+async function endSegment(tx, punch, at) {
+	const segment = await closeOpenSegment(tx, punch, at, "stop");
+	if (!segment) throw new AttendanceConflict("No open work segment.", "no_open_work");
+	return segment;
+}
+async function continueSegment(tx, punch, at) {
+	const all = await listSegments(tx, punch);
+	const last = all[all.length - 1];
+	const breaks = await tx.breaks.list({
+		where: {
+			tenantId: punch.tenantId,
+			punchId: punch.id
+		},
+		orderBy: "started_at DESC",
+		limit: 1
+	});
+	if (last?.closedReason !== "break" || !last.endedAt || last.endedAt.getTime() !== breaks[0]?.startedAt.getTime()) throw new AttendanceConflict("No work interrupted by a break to resume.", "no_resumable_work");
+	return beginSegment(tx, punch, at, last);
+}
+//#endregion
+//#region src/attendance/service.ts
+function sameAttribution(metadata, work) {
+	const stored = parseTimesheetJson(metadata, {});
+	return (stored.taskRefType ?? "") === (work.taskRefType ?? "") && (stored.taskRefId ?? "") === (work.taskRefId ?? "") && (stored.kind ?? "") === (work.kind ?? "");
+}
+var TAP_ACTIONS = [
+	"punchIn",
+	"punchOut",
+	"startBreak",
+	"endBreak",
+	"startWork",
+	"switchWork",
+	"stopWork",
+	"resumeWork"
+];
+var AttendanceService = class {
+	constructor(db, actor) {
+		this.db = db;
+		this.actor = actor;
+		if (!actor.tenantId || !actor.profileId) throw new Error("Attendance requires a trusted tenant/profile actor.");
+		this.actor = {
+			tenantId: this.identity(actor.tenantId),
+			profileId: this.identity(actor.profileId)
+		};
+	}
+	db;
+	actor;
+	identity(value) {
+		return attendanceIdentity(this.db, value);
+	}
+	/**
+	* Run `operation` in the actor's serialized attendance transaction. The
+	* context's collections share the executor, so corrections and replay can
+	* compose several attendance mutations (with the segment helpers) atomically.
+	* Results that are punches or segments are re-read after commit.
+	*/
+	async withTransaction(operation) {
+		return this.transact(operation);
+	}
+	async transact(operation) {
+		const current = getTenantId();
+		if (current && this.identity(current) !== this.actor.tenantId) throw new Error("Attendance actor differs from active tenant.");
+		return withTenant({ tenantId: this.actor.tenantId }, async () => {
+			const result = await withEmbeddedWriteTransaction(this.db, isEmbeddedDatabase(this.db), async (db) => {
+				if (isPostgresDatabase(db)) await db.query("SELECT pg_advisory_xact_lock(hashtextextended($1, 0))", JSON.stringify([
+					"smrt.attendance",
+					this.actor.tenantId,
+					this.actor.profileId
+				]));
+				return operation({
+					db,
+					punches: await AttendancePunchCollection.create({ db }),
+					breaks: await AttendanceBreakCollection.create({ db }),
+					segments: await AttendanceSegmentCollection.create({ db }),
+					replays: await AttendanceReplayCollection.create({ db })
+				});
+			}, true);
+			if (result instanceof AttendancePunch) {
+				const [fresh] = await (await AttendancePunchCollection.create({ db: this.db })).list({
+					where: {
+						...this.actor,
+						id: result.id
+					},
+					limit: 1
+				});
+				if (!fresh) throw new Error("Committed attendance punch disappeared.");
+				return fresh;
+			}
+			if (result instanceof AttendanceSegment) {
+				const [fresh] = await (await AttendanceSegmentCollection.create({ db: this.db })).list({
+					where: {
+						tenantId: this.actor.tenantId,
+						id: result.id
+					},
+					limit: 1
+				});
+				if (!fresh) throw new Error("Committed attendance segment disappeared.");
+				return fresh;
+			}
+			return result;
+		});
+	}
+	date(at) {
+		if (!(at instanceof Date) || !Number.isFinite(at.getTime())) throw new AttendanceConflict("Attendance timestamps must be valid dates.");
+		return at;
+	}
+	async open(tx) {
+		const [punch] = await tx.punches.list({
+			where: {
+				...this.actor,
+				endedAt: null
+			},
+			limit: 1
+		});
+		if (!punch) throw new AttendanceConflict("No open punch.", "no_open_punch");
+		return punch;
+	}
+	async chronological(tx, at) {
+		const open = await tx.punches.list({
+			where: {
+				...this.actor,
+				endedAt: null
+			},
+			limit: 1
+		});
+		const rows = open.length ? open : await tx.punches.list({
+			where: { ...this.actor },
+			orderBy: "ended_at DESC",
+			limit: 1
+		});
+		if (!rows.length) return;
+		const punch = rows[0];
+		const breaks = await tx.breaks.list({ where: {
+			tenantId: this.actor.tenantId,
+			punchId: punch.id
+		} });
+		const segments = await tx.segments.list({ where: {
+			tenantId: this.actor.tenantId,
+			punchId: punch.id
+		} });
+		const latest = Math.max(punch.startedAt.getTime(), ...segments.flatMap((g) => [g.startedAt.getTime(), g.endedAt?.getTime() ?? 0]), punch.endedAt?.getTime() ?? 0, ...breaks.flatMap((b) => [b.startedAt.getTime(), b.endedAt?.getTime() ?? 0]));
+		if (at.getTime() < latest) throw new AttendanceConflict("Tap predates committed attendance; manual review required.", "predates_committed");
+	}
+	/** Open one punch; the database unique slot also protects direct model writers. */
+	async punchIn(at = /* @__PURE__ */ new Date(), options) {
+		const meta = attendanceProvenance(options);
+		return this.transact((tx) => this.transition(tx, "punchIn", this.date(at), false, void 0, false, {
+			...meta,
+			kind: ""
+		}));
+	}
+	/** Close the punch and any active break; optionally create linked draft evidence. */
+	async punchOut(at, work) {
+		return this.transact((tx) => this.transition(tx, "punchOut", this.date(at), false, work));
+	}
+	/** Begin a break; paid defaults false and must be explicitly configured by the caller. */
+	async startBreak(at, paid = false, options) {
+		const kind = attendanceLabel(options?.kind, "kind");
+		return this.transact((tx) => this.transition(tx, "startBreak", this.date(at), paid, void 0, false, {
+			...attendanceProvenance(),
+			kind
+		}));
+	}
+	/**
+	* End the current break. With `{ resumeWork: true }` the work interrupted by
+	* `startBreak` resumes at the same instant, atomically with the break end.
+	*/
+	async endBreak(at, options) {
+		return this.transact((tx) => this.transition(tx, "endBreak", this.date(at), false, void 0, options?.resumeWork));
+	}
+	/** Open a work segment in the open punch; refuses during a break or while one is open. */
+	async startWork(at, work) {
+		return this.transact(async (tx) => {
+			validateAttendanceWork(work);
+			await this.chronological(tx, this.date(at));
+			return beginSegment(tx, await this.open(tx), at, work);
+		});
+	}
+	/** Atomically close the open segment and open the next one at `at`. */
+	async switchWork(at, work) {
+		return this.transact(async (tx) => {
+			validateAttendanceWork(work);
+			await this.chronological(tx, this.date(at));
+			return replaceSegment(tx, await this.open(tx), at, work);
+		});
+	}
+	/** Close the open segment without starting another. */
+	async stopWork(at) {
+		return this.transact(async (tx) => {
+			await this.chronological(tx, this.date(at));
+			return endSegment(tx, await this.open(tx), at);
+		});
+	}
+	/** Reopen the work a break interrupted (the latest segment must have closed on `startBreak`). */
+	async resumeWork(at) {
+		return this.transact(async (tx) => {
+			await this.chronological(tx, this.date(at));
+			return continueSegment(tx, await this.open(tx), at);
+		});
+	}
+	/** The open work segment of the actor's open punch, or null. */
+	async currentWork() {
+		return this.transact(async (tx) => {
+			const [punch] = await tx.punches.list({
+				where: {
+					...this.actor,
+					endedAt: null
+				},
+				limit: 1
+			});
+			return punch ? openSegment(tx, punch) : null;
+		});
+	}
+	/** Work segments of one of the actor's punches, oldest first. */
+	async segments(punchId) {
+		return this.transact(async (tx) => {
+			const [punch] = await tx.punches.list({
+				where: {
+					...this.actor,
+					id: punchId
+				},
+				limit: 1
+			});
+			if (!punch) throw new AttendanceConflict("Punch not found for actor.");
+			return listSegments(tx, punch);
+		});
+	}
+	async transition(tx, action, at, paid = false, work, resumeWork = false, meta = {
+		...attendanceProvenance(),
+		kind: ""
+	}) {
+		await this.chronological(tx, at);
+		if (action === "punchIn") {
+			if ((await tx.punches.list({
+				where: {
+					...this.actor,
+					endedAt: null
+				},
+				limit: 1
+			})).length) throw new AttendanceConflict("A punch is already open.", "punch_open");
+			return tx.punches.create({
+				...this.actor,
+				startedAt: at,
+				source: meta.source,
+				deviceRefType: meta.deviceRefType,
+				deviceRefId: meta.deviceRefId,
+				_insertOnly: true
+			});
+		}
+		const punch = await this.open(tx);
+		const breaks = await tx.breaks.list({ where: {
+			tenantId: this.actor.tenantId,
+			punchId: punch.id
+		} });
+		const active = breaks.find((b) => !b.endedAt);
+		if (action === "startBreak") {
+			if (active) throw new AttendanceConflict("A break is already open.", "break_open");
+			if (typeof paid !== "boolean") throw new AttendanceConflict("paid must be boolean.");
+			await closeOpenSegment(tx, punch, at, "break");
+			await tx.breaks.create({
+				tenantId: this.actor.tenantId,
+				punchId: punch.id ?? void 0,
+				startedAt: at,
+				paid,
+				kind: meta.kind,
+				_insertOnly: true
+			});
+			return punch;
+		}
+		if (action !== "endBreak" && action !== "punchOut") throw new AttendanceConflict("Unknown attendance action.");
+		if (action === "endBreak" && !active) throw new AttendanceConflict("No open break.", "no_open_break");
+		if (action === "punchOut" && work) {
+			this.validateWork(work);
+			const unpaidMilliseconds2 = breaks.filter((b) => !b.paid).reduce((sum, b) => sum + (b.endedAt ?? at).getTime() - b.startedAt.getTime(), 0);
+			if (Math.round((at.getTime() - punch.startedAt.getTime() - unpaidMilliseconds2) / 1e3) <= 0) throw new AttendanceConflict("Only closed punches with positive duration can produce service evidence.");
+		}
+		if (active) {
+			active.endedAt = at;
+			await active.save();
+		}
+		if (action === "endBreak") {
+			if (resumeWork) await continueSegment(tx, punch, at);
+			return punch;
+		}
+		await closeOpenSegment(tx, punch, at, "punchOut");
+		punch.endedAt = at;
+		const unpaidMilliseconds = breaks.filter((b) => !b.paid).reduce((sum, b) => sum + b.endedAt.getTime() - b.startedAt.getTime(), 0);
+		punch.unpaidBreakSeconds = Math.round(unpaidMilliseconds / 1e3);
+		punch.durationSeconds = Math.round((at.getTime() - punch.startedAt.getTime() - unpaidMilliseconds) / 1e3);
+		await punch.save();
+		if (work) await this.link(tx, punch, work);
+		return punch;
+	}
+	/** Run one replayed tap on `tx`; work actions share the punch changes' transaction. */
+	async apply(tx, tap, at) {
+		const work = () => {
+			if (!tap.work) throw new AttendanceConflict("Work is required.", "invalid");
+			return tap.work;
+		};
+		let segment;
+		switch (tap.action) {
+			case "startWork":
+				await this.chronological(tx, at);
+				segment = await beginSegment(tx, await this.open(tx), at, work());
+				break;
+			case "switchWork":
+				await this.chronological(tx, at);
+				segment = await replaceSegment(tx, await this.open(tx), at, work());
+				break;
+			case "stopWork":
+				await this.chronological(tx, at);
+				segment = await endSegment(tx, await this.open(tx), at);
+				break;
+			case "resumeWork":
+				await this.chronological(tx, at);
+				segment = await continueSegment(tx, await this.open(tx), at);
+				break;
+			default: return { punch: await this.transition(tx, tap.action, at, tap.paid, tap.work, false, {
+				...attendanceProvenance({
+					source: tap.source,
+					device: tap.device
+				}),
+				kind: attendanceLabel(tap.kind, "kind")
+			}) };
+		}
+		const [punch] = await tx.punches.list({
+			where: {
+				...this.actor,
+				id: segment.punchId
+			},
+			limit: 1
+		});
+		return {
+			punch,
+			segment
+		};
+	}
+	validateWork(work) {
+		validateAttendanceWork(work);
+	}
+	async link(tx, punch, work) {
+		this.validateWork(work);
+		if (!punch.endedAt || punch.durationSeconds <= 0) throw new AttendanceConflict("Only closed punches with positive duration can produce service evidence.");
+		const entries = await ServiceTimeEntryCollection.create({ db: tx.db });
+		if (punch.serviceTimeEntryId) {
+			const [existing] = await entries.list({
+				where: {
+					id: punch.serviceTimeEntryId,
+					tenantId: this.actor.tenantId
+				},
+				limit: 1
+			});
+			if (!existing || existing.workRefType !== work.workRefType || existing.workRefId !== work.workRefId || existing.description !== work.description || !sameAttribution(existing.metadata, work)) throw new AttendanceConflict("Punch already linked to different work.");
+			return;
+		}
+		const entry = await entries.create({
+			tenantId: this.actor.tenantId,
+			participantKind: "human",
+			participantProfileId: this.actor.profileId,
+			workRefType: work.workRefType,
+			workRefId: work.workRefId,
+			description: work.description,
+			source: "timer",
+			startedAt: punch.startedAt,
+			endedAt: punch.endedAt,
+			durationSeconds: punch.durationSeconds,
+			status: "draft",
+			metadata: JSON.stringify({
+				attendancePunchId: punch.id,
+				...work.taskRefType ? {
+					taskRefType: work.taskRefType,
+					taskRefId: work.taskRefId
+				} : {},
+				...work.kind ? { kind: work.kind } : {}
+			}),
+			_insertOnly: true
+		});
+		if (!entry.id) throw new Error("Saved service entry has no id.");
+		punch.serviceTimeEntryId = entry.id;
+		await punch.save();
+	}
+	/** Idempotently link a closed, owned punch to draft service evidence. */
+	async linkServiceTimeEntry(punchId, work) {
+		return this.transact(async (tx) => {
+			const [punch] = await tx.punches.list({
+				where: {
+					...this.actor,
+					id: punchId
+				},
+				limit: 1
+			});
+			if (!punch) throw new AttendanceConflict("Punch not found for actor.");
+			await this.link(tx, punch, work);
+			return punch;
+		});
+	}
+	/**
+	* Close the open punch once its deadline has passed, flagging it for review.
+	* `deadline` is either a fixed maximum open duration in seconds (closing at
+	* `startedAt + seconds`, reason `maxDuration`) or a resolver called with the
+	* open punch that returns its deadline (a `Date`, or `{ deadline, reason }`),
+	* or null to leave it open. The consumer owns time zones and shop-day rules.
+	* The open work segment and break close at the deadline; returns the closed
+	* punch, or null when nothing was due.
+	*/
+	async autoClose(now, deadline) {
+		this.date(now);
+		if (typeof deadline !== "function" && (!Number.isSafeInteger(deadline) || deadline <= 0)) throw new AttendanceConflict("maxOpenSeconds must be a positive integer.");
+		return this.transact(async (tx) => {
+			const [punch] = await tx.punches.list({
+				where: {
+					...this.actor,
+					endedAt: null
+				},
+				limit: 1
+			});
+			if (!punch) return null;
+			let at;
+			let reason = "maxDuration";
+			if (typeof deadline === "function") {
+				const resolved = await deadline(punch);
+				if (resolved === null || resolved === void 0) return null;
+				const decision = resolved instanceof Date ? { deadline: resolved } : resolved;
+				at = decision.deadline;
+				if (!(at instanceof Date) || !Number.isFinite(at.getTime())) throw new AttendanceConflict("Auto-close deadline is invalid.");
+				if (at < punch.startedAt) throw new AttendanceConflict("Auto-close deadline predates the punch.");
+				reason = decision.reason ?? "deadline";
+				if (typeof reason !== "string" || !reason.trim() || reason.length > 200) throw new AttendanceConflict("Auto-close reason must be 1 to 200 characters.");
+			} else at = new Date(punch.startedAt.getTime() + deadline * 1e3);
+			if (at > now) return null;
+			const closed = await this.transition(tx, "punchOut", at);
+			closed.reviewRequired = true;
+			closed.autoCloseReason = reason;
+			await persistAutoClose(closed);
+			return closed;
+		});
+	}
+	/**
+	* Replay device timestamps in order (ties use clientId). Committed attendance
+	* wins: stale/state-conflicting taps get durable refusals; identical retries
+	* return the same outcome, changed payloads using a key are rejected. A
+	* database failure rolls back its tap and receipt and remains retryable.
+	*/
+	async replay(taps, options = {}) {
+		for (const tap of taps) {
+			if (!tap || typeof tap.at !== "string" || typeof tap.clientId !== "string" || !tap.clientId || !TAP_ACTIONS.includes(tap.action)) throw new AttendanceConflict("Malformed attendance tap.");
+			this.date(new Date(tap.at));
+			if (tap.work !== void 0) this.validateWork(tap.work);
+			if ((tap.action === "startWork" || tap.action === "switchWork") && tap.work === void 0) throw new AttendanceConflict("Malformed attendance tap.");
+			if (tap.paid !== void 0 && typeof tap.paid !== "boolean") throw new AttendanceConflict("paid must be boolean.");
+			attendanceProvenance({
+				source: tap.source,
+				device: tap.device
+			});
+			attendanceLabel(tap.kind, "kind");
+		}
+		const ordered = [...taps].sort((a, b) => Date.parse(a.at) - Date.parse(b.at) || (a.clientId < b.clientId ? -1 : a.clientId > b.clientId ? 1 : 0));
+		const outcomes = [];
+		for (const tap of ordered) outcomes.push(await this.transact(async (tx) => {
+			const replayKey = JSON.stringify([
+				this.actor.tenantId,
+				this.actor.profileId,
+				tap.clientId
+			]);
+			const content = JSON.stringify([
+				tap.action,
+				new Date(tap.at).toISOString(),
+				tap.paid ?? false,
+				tap.work?.workRefType ?? null,
+				tap.work?.workRefId ?? null,
+				tap.work?.description ?? null,
+				...tap.work?.taskRefType || tap.work?.kind ? [
+					tap.work.taskRefType ?? null,
+					tap.work.taskRefId ?? null,
+					tap.work.kind ?? null
+				] : [],
+				...tap.source || tap.device || tap.kind ? [{
+					source: tap.source ?? "",
+					deviceType: tap.device?.type ?? "",
+					deviceId: tap.device?.id ?? "",
+					kind: tap.kind ?? ""
+				}] : []
+			]);
+			const [receipt] = await tx.replays.list({
+				where: {
+					tenantId: this.actor.tenantId,
+					replayKey
+				},
+				limit: 1
+			});
+			if (receipt) {
+				if (receipt.content !== content) throw new AttendanceConflict("Client id reused with different content.");
+				const outcome2 = receipt.getOutcome();
+				if (outcome2.clientId !== tap.clientId) throw new Error("Stored attendance receipt belongs to another client id.");
+				return outcome2;
+			}
+			const deviceAt = new Date(tap.at);
+			let at = deviceAt;
+			let review = false;
+			if (options.resolveAt) {
+				const serverNow = this.date(options.now?.() ?? /* @__PURE__ */ new Date());
+				const resolved = await options.resolveAt({
+					tap,
+					deviceAt,
+					serverNow,
+					waitedMs: serverNow.getTime() - deviceAt.getTime(),
+					actor: { ...this.actor }
+				});
+				if (!resolved || !(resolved.at instanceof Date) || !Number.isFinite(resolved.at.getTime())) throw new Error("resolveAt must return a valid date.");
+				at = resolved.at;
+				review = resolved.reviewRequired === true;
+			}
+			let outcome;
+			try {
+				outcome = await withEmbeddedWriteTransaction(tx.db, isEmbeddedDatabase(tx.db), async (db) => {
+					const inner = {
+						db,
+						punches: await AttendancePunchCollection.create({ db }),
+						breaks: await AttendanceBreakCollection.create({ db }),
+						segments: await AttendanceSegmentCollection.create({ db }),
+						replays: tx.replays
+					};
+					const { punch, segment } = await this.apply(inner, tap, at);
+					punch.recordedOffline = true;
+					punch.reviewRequired = true;
+					await punch.save();
+					if (segment && review) {
+						segment.reviewRequired = true;
+						await segment.save();
+					}
+					return {
+						clientId: tap.clientId,
+						punchId: punch.id,
+						...segment ? { segmentId: segment.id } : {},
+						...at.getTime() !== deviceAt.getTime() ? { resolvedAt: at.toISOString() } : {}
+					};
+				}, true);
+			} catch (error) {
+				if (!(error instanceof AttendanceConflict)) throw error;
+				const custom = options.refusal?.(tap, error) || void 0;
+				outcome = {
+					clientId: tap.clientId,
+					error: custom?.message || error.message,
+					code: custom?.code || error.code
+				};
+			}
+			await tx.replays.create({
+				tenantId: this.actor.tenantId,
+				replayKey,
+				content,
+				outcome: JSON.stringify(outcome),
+				_insertOnly: true
+			});
+			return outcome;
+		}));
+		return outcomes;
+	}
+};
+//#endregion
+//#region src/attendance/correction-service.ts
+var iso = (d) => d ? d.toISOString() : null;
+var punchState = (p) => ({
+	startedAt: iso(p.startedAt),
+	endedAt: iso(p.endedAt),
+	durationSeconds: p.durationSeconds,
+	unpaidBreakSeconds: p.unpaidBreakSeconds,
+	reviewRequired: p.reviewRequired,
+	...p.source ? { source: p.source } : {},
+	...p.deviceRefType ? {
+		deviceRefType: p.deviceRefType,
+		deviceRefId: p.deviceRefId
+	} : {}
+});
+var breakState = (b) => ({
+	startedAt: iso(b.startedAt),
+	endedAt: iso(b.endedAt),
+	paid: b.paid,
+	...b.kind ? { kind: b.kind } : {}
+});
+var segmentState = (s) => ({
+	startedAt: iso(s.startedAt),
+	endedAt: iso(s.endedAt),
+	workRefType: s.workRefType,
+	workRefId: s.workRefId,
+	taskRefType: s.taskRefType,
+	taskRefId: s.taskRefId,
+	kind: s.kind,
+	description: s.description,
+	durationSeconds: s.durationSeconds,
+	closedReason: s.closedReason
+});
+function instant(value, name) {
+	if (!(value instanceof Date) || !Number.isFinite(value.getTime())) throw new AttendanceConflict(`${name} must be a valid date.`);
+	return value;
+}
+function overlapping(a, b) {
+	return a.start < b.end && b.start < a.end;
+}
+function validateLayout(layout) {
+	const inside = (r) => r.endedAt.getTime() >= r.startedAt.getTime() && r.startedAt.getTime() >= layout.startsAt && r.endedAt.getTime() <= layout.endsAt;
+	if (!layout.breaks.every(inside)) throw new AttendanceConflict("A break must be an interval inside its punch.");
+	if (!layout.segments.every(inside)) throw new AttendanceConflict("A work segment must be an interval inside its punch.");
+	const span = (r) => ({
+		start: r.startedAt.getTime(),
+		end: r.endedAt.getTime()
+	});
+	const sets = [layout.breaks, layout.segments];
+	for (const set of sets) for (let i = 0; i < set.length; i++) for (let j = i + 1; j < set.length; j++) if (overlapping(span(set[i]), span(set[j]))) throw new AttendanceConflict(set === layout.breaks ? "Breaks must not overlap." : "Work segments must not overlap.");
+	for (const b of layout.breaks) for (const s of layout.segments) if (overlapping(span(b), span(s))) throw new AttendanceConflict("A work segment must not overlap a break.");
+}
+var AttendanceCorrectionService = class {
+	constructor(db, actor, options = {}) {
+		this.db = db;
+		this.options = options;
+		if (!actor?.tenantId || !actor.profileId) throw new Error("Corrections require a trusted tenant/profile actor.");
+		this.actor = {
+			tenantId: attendanceIdentity(db, actor.tenantId),
+			profileId: attendanceIdentity(db, actor.profileId)
+		};
+	}
+	db;
+	options;
+	actor;
+	/** Change a closed punch's start and/or end. A reviewed punch no longer needs review. */
+	async correctPunch(input) {
+		return this.run(input, async (tx, subject, record) => {
+			const punch = await this.closedPunch(tx, subject, input.punchId);
+			const before = punchState(punch);
+			const startedAt = input.startedAt === void 0 ? punch.startedAt : instant(input.startedAt, "startedAt");
+			const endedAt = input.endedAt === void 0 ? punch.endedAt : instant(input.endedAt, "endedAt");
+			if (endedAt <= startedAt) throw new AttendanceConflict("A punch must end after it starts.");
+			const children = await this.children(tx, punch);
+			validateLayout(this.layout(startedAt, endedAt, children));
+			for (const other of await tx.punches.list({ where: {
+				tenantId: subject.tenantId,
+				profileId: subject.profileId
+			} })) if (other.id !== punch.id && overlapping({
+				start: startedAt.getTime(),
+				end: endedAt.getTime()
+			}, {
+				start: other.startedAt.getTime(),
+				end: other.endedAt?.getTime() ?? Number.POSITIVE_INFINITY
+			})) throw new AttendanceConflict("Punches must not overlap.");
+			await this.guard(tx, subject, [{
+				startsAt: punch.startedAt,
+				endsAt: punch.endedAt
+			}, {
+				startsAt: startedAt,
+				endsAt: endedAt
+			}]);
+			const entry = await this.editableEntry(tx, punch);
+			punch.startedAt = startedAt;
+			punch.endedAt = endedAt;
+			punch.reviewRequired = false;
+			await this.settle(tx, punch, children.breaks, entry);
+			return record("punch.corrected", punch, punch.id, before, punchState(punch));
+		});
+	}
+	/** Record a missed punch retroactively, as an already-closed interval. */
+	async addPunch(input) {
+		return this.run(input, async (tx, subject, record) => {
+			const startedAt = instant(input.startedAt, "startedAt");
+			const endedAt = instant(input.endedAt, "endedAt");
+			const meta = attendanceProvenance(input);
+			if (endedAt <= startedAt) throw new AttendanceConflict("A punch must end after it starts.");
+			for (const other of await tx.punches.list({ where: {
+				tenantId: subject.tenantId,
+				profileId: subject.profileId
+			} })) if (overlapping({
+				start: startedAt.getTime(),
+				end: endedAt.getTime()
+			}, {
+				start: other.startedAt.getTime(),
+				end: other.endedAt?.getTime() ?? Number.POSITIVE_INFINITY
+			})) throw new AttendanceConflict("Punches must not overlap.");
+			await this.guard(tx, subject, [{
+				startsAt: startedAt,
+				endsAt: endedAt
+			}]);
+			const punch = await tx.punches.create({
+				tenantId: subject.tenantId,
+				profileId: subject.profileId,
+				startedAt,
+				endedAt,
+				durationSeconds: Math.round((endedAt.getTime() - startedAt.getTime()) / 1e3),
+				...meta,
+				_insertOnly: true
+			});
+			return record("punch.added", punch, punch.id, null, punchState(punch));
+		});
+	}
+	/** Add a break to a closed punch, or change one (times and/or paid). */
+	async saveBreak(input) {
+		return this.run(input, async (tx, subject, record) => {
+			const punch = await this.closedPunch(tx, subject, input.punchId);
+			const children = await this.children(tx, punch);
+			const existing = input.breakId ? children.breaks.find((b) => b.id === input.breakId) : void 0;
+			if (input.breakId && !existing) throw new AttendanceConflict("Break not found in that punch.");
+			if (!existing && (input.startedAt === void 0 || input.endedAt === void 0)) throw new AttendanceConflict("A new break needs startedAt and endedAt.");
+			if (input.paid !== void 0 && typeof input.paid !== "boolean") throw new AttendanceConflict("paid must be boolean.");
+			const next = {
+				startedAt: instant(input.startedAt ?? existing?.startedAt, "startedAt"),
+				endedAt: instant(input.endedAt ?? existing?.endedAt ?? void 0, "endedAt"),
+				paid: input.paid ?? existing?.paid ?? false,
+				kind: input.kind === void 0 ? existing?.kind ?? "" : attendanceLabel(input.kind, "kind")
+			};
+			const rest = children.breaks.filter((b) => b !== existing);
+			validateLayout(this.layout(punch.startedAt, punch.endedAt, {
+				breaks: [...rest, next],
+				segments: children.segments
+			}));
+			await this.guard(tx, subject, [{
+				startsAt: punch.startedAt,
+				endsAt: punch.endedAt
+			}]);
+			const entry = await this.editableEntry(tx, punch);
+			const before = existing ? breakState(existing) : null;
+			let target;
+			if (existing) {
+				existing.startedAt = next.startedAt;
+				existing.endedAt = next.endedAt;
+				existing.paid = next.paid;
+				existing.kind = next.kind;
+				await persistCorrection(existing);
+				target = existing;
+			} else {
+				target = await new AttendanceBreak({
+					db: tx.db,
+					id: crypto.randomUUID(),
+					_skipLoad: true
+				}).initialize();
+				Object.assign(target, {
+					tenantId: subject.tenantId,
+					punchId: punch.id ?? void 0,
+					...next
+				});
+				await persistCorrection(target);
+			}
+			await this.settle(tx, punch, [...rest, target], entry);
+			return record(existing ? "break.changed" : "break.added", punch, target.id, before, breakState(target));
+		});
+	}
+	/** Remove a break from a closed punch. */
+	async removeBreak(input) {
+		return this.run(input, async (tx, subject, record) => {
+			const [target] = await tx.breaks.list({
+				where: {
+					tenantId: subject.tenantId,
+					id: input.breakId
+				},
+				limit: 1
+			});
+			if (!target) throw new AttendanceConflict("Break not found.");
+			const punch = await this.closedPunch(tx, subject, target.punchId);
+			const children = await this.children(tx, punch);
+			await this.guard(tx, subject, [{
+				startsAt: punch.startedAt,
+				endsAt: punch.endedAt
+			}]);
+			const entry = await this.editableEntry(tx, punch);
+			const before = breakState(target);
+			await deleteCorrection(target);
+			await this.settle(tx, punch, children.breaks.filter((b) => b.id !== target.id), entry);
+			return record("break.removed", punch, target.id, before, null);
+		});
+	}
+	/** Add a work segment to a closed punch, or change one (times and/or work attribution). */
+	async saveSegment(input) {
+		return this.run(input, async (tx, subject, record) => {
+			const punch = await this.closedPunch(tx, subject, input.punchId);
+			const children = await this.children(tx, punch);
+			const existing = input.segmentId ? children.segments.find((s) => s.id === input.segmentId) : void 0;
+			if (input.segmentId && !existing) throw new AttendanceConflict("Work segment not found in that punch.");
+			if (!existing && (input.startedAt === void 0 || input.endedAt === void 0 || !input.work)) throw new AttendanceConflict("A new work segment needs startedAt, endedAt and work.");
+			if (input.work) validateAttendanceWork(input.work);
+			const next = {
+				startedAt: instant(input.startedAt ?? existing?.startedAt, "startedAt"),
+				endedAt: instant(input.endedAt ?? existing?.endedAt ?? void 0, "endedAt")
+			};
+			const rest = children.segments.filter((s) => s !== existing);
+			validateLayout(this.layout(punch.startedAt, punch.endedAt, {
+				breaks: children.breaks,
+				segments: [...rest, next]
+			}));
+			await this.guard(tx, subject, [{
+				startsAt: punch.startedAt,
+				endsAt: punch.endedAt
+			}]);
+			const before = existing ? segmentState(existing) : null;
+			let target;
+			if (existing) {
+				existing.startedAt = next.startedAt;
+				existing.endedAt = next.endedAt;
+				if (input.work) this.attribute(existing, input.work);
+				await persistCorrection(existing);
+				target = existing;
+			} else {
+				target = await new AttendanceSegment({
+					db: tx.db,
+					id: crypto.randomUUID(),
+					_skipLoad: true
+				}).initialize();
+				Object.assign(target, {
+					tenantId: subject.tenantId,
+					punchId: punch.id ?? void 0,
+					workRefType: input.work.workRefType,
+					workRefId: input.work.workRefId,
+					taskRefType: input.work.taskRefType ?? "",
+					taskRefId: input.work.taskRefId ?? "",
+					kind: input.work.kind ?? "",
+					description: input.work.description,
+					...next,
+					closedReason: "stop"
+				});
+				await persistCorrection(target);
+			}
+			return record(existing ? "segment.changed" : "segment.added", punch, target.id, before, segmentState(target));
+		});
+	}
+	/** Remove a work segment from a closed punch. */
+	async removeSegment(input) {
+		return this.run(input, async (tx, subject, record) => {
+			const [target] = await tx.segments.list({
+				where: {
+					tenantId: subject.tenantId,
+					id: input.segmentId
+				},
+				limit: 1
+			});
+			if (!target) throw new AttendanceConflict("Work segment not found.");
+			const punch = await this.closedPunch(tx, subject, target.punchId);
+			await this.guard(tx, subject, [{
+				startsAt: punch.startedAt,
+				endsAt: punch.endedAt
+			}]);
+			const before = segmentState(target);
+			await deleteCorrection(target);
+			return record("segment.removed", punch, target.id, before, null);
+		});
+	}
+	/**
+	* The subject confirms they have seen a correction that required it. Only
+	* the subject (this service's actor) may; it can be done once.
+	*/
+	async acknowledge(correctionId, at = /* @__PURE__ */ new Date()) {
+		instant(at, "at");
+		const id = await this.attendance(this.actor.profileId).withTransaction(async (tx) => {
+			const [row] = await (await AttendanceCorrectionCollection.create({ db: tx.db })).list({
+				where: {
+					tenantId: this.actor.tenantId,
+					id: correctionId
+				},
+				limit: 1
+			});
+			if (!row) throw new AttendanceConflict("Correction not found.");
+			if (row.subjectProfileId !== this.actor.profileId) throw new AttendanceConflict("Only the subject can acknowledge a correction.");
+			if (!row.acknowledgementRequired) throw new AttendanceConflict("This correction does not require acknowledgement.");
+			if (row.acknowledgedAt) throw new AttendanceConflict("Correction already acknowledged.");
+			row.acknowledgedAt = at;
+			row.acknowledgedByProfileId = this.actor.profileId;
+			await persistCorrection(row);
+			return row.id;
+		});
+		return this.read(id);
+	}
+	/** Corrections to one punch, oldest first. */
+	async listForPunch(punchId) {
+		return this.attendance(this.actor.profileId).withTransaction(async (tx) => await (await AttendanceCorrectionCollection.create({ db: tx.db })).list({
+			where: {
+				tenantId: this.actor.tenantId,
+				punchId
+			},
+			orderBy: "created_at ASC"
+		}));
+	}
+	/** Corrections of the actor's own time that still await their acknowledgement. */
+	async pendingAcknowledgements() {
+		return this.attendance(this.actor.profileId).withTransaction(async (tx) => (await (await AttendanceCorrectionCollection.create({ db: tx.db })).list({
+			where: {
+				tenantId: this.actor.tenantId,
+				subjectProfileId: this.actor.profileId
+			},
+			orderBy: "created_at ASC"
+		})).filter((row) => row.acknowledgementRequired && !row.acknowledgedAt));
+	}
+	attendance(subjectProfileId) {
+		return new AttendanceService(this.db, {
+			tenantId: this.actor.tenantId,
+			profileId: subjectProfileId
+		});
+	}
+	async read(id) {
+		return this.attendance(this.actor.profileId).withTransaction(async (tx) => {
+			const [row] = await (await AttendanceCorrectionCollection.create({ db: tx.db })).list({
+				where: {
+					tenantId: this.actor.tenantId,
+					id
+				},
+				limit: 1
+			});
+			if (!row) throw new Error("Committed attendance correction disappeared.");
+			return row;
+		});
+	}
+	async run(request, operation) {
+		const reason = typeof request.reason === "string" ? request.reason.trim() : "";
+		if (!reason) throw new AttendanceConflict("A correction needs a reason.");
+		if (request.acknowledgementRequired !== void 0 && typeof request.acknowledgementRequired !== "boolean") throw new AttendanceConflict("acknowledgementRequired must be boolean.");
+		if (!request.subjectProfileId) throw new AttendanceConflict("A correction needs a subject.");
+		const subject = {
+			tenantId: this.actor.tenantId,
+			profileId: attendanceIdentity(this.db, request.subjectProfileId)
+		};
+		const id = await this.attendance(subject.profileId).withTransaction(async (tx) => {
+			await AttendanceCorrectionCollection.create({ db: tx.db });
+			return operation(tx, subject, async (kind, punch, targetId, before, after) => {
+				const row = await new AttendanceCorrection({
+					db: tx.db,
+					id: crypto.randomUUID(),
+					_skipLoad: true
+				}).initialize();
+				Object.assign(row, {
+					tenantId: subject.tenantId,
+					subjectProfileId: subject.profileId,
+					actorProfileId: this.actor.profileId,
+					kind,
+					punchId: punch.id ?? void 0,
+					targetId,
+					beforeState: JSON.stringify(before),
+					afterState: JSON.stringify(after),
+					reason,
+					acknowledgementRequired: request.acknowledgementRequired ?? false
+				});
+				await persistCorrection(row);
+				return row.id;
+			});
+		});
+		return this.read(id);
+	}
+	async closedPunch(tx, subject, punchId) {
+		const [punch] = await tx.punches.list({
+			where: {
+				tenantId: subject.tenantId,
+				profileId: subject.profileId,
+				id: punchId
+			},
+			limit: 1
+		});
+		if (!punch) throw new AttendanceConflict("Punch not found for subject.");
+		if (!punch.endedAt) throw new AttendanceConflict("Only closed punches are corrected; use AttendanceService for an open one.");
+		return punch;
+	}
+	async children(tx, punch) {
+		const where = {
+			tenantId: punch.tenantId,
+			punchId: punch.id
+		};
+		const breaks = await tx.breaks.list({
+			where,
+			orderBy: "started_at ASC"
+		});
+		const segments = await tx.segments.list({
+			where,
+			orderBy: "started_at ASC"
+		});
+		if (breaks.some((b) => !b.endedAt) || segments.some((s) => !s.endedAt)) throw new AttendanceConflict("Closed punch has an open break or segment.");
+		return {
+			breaks,
+			segments
+		};
+	}
+	layout(startedAt, endedAt, children) {
+		return {
+			startsAt: startedAt.getTime(),
+			endsAt: endedAt.getTime(),
+			breaks: children.breaks.map((b) => ({
+				startedAt: b.startedAt,
+				endedAt: b.endedAt,
+				paid: b.paid
+			})),
+			segments: children.segments.map((s) => ({
+				startedAt: s.startedAt,
+				endedAt: s.endedAt
+			}))
+		};
+	}
+	attribute(segment, work) {
+		segment.workRefType = work.workRefType;
+		segment.workRefId = work.workRefId;
+		segment.taskRefType = work.taskRefType ?? "";
+		segment.taskRefId = work.taskRefId ?? "";
+		segment.kind = work.kind ?? "";
+		segment.description = work.description;
+	}
+	async guard(tx, subject, intervals) {
+		const refusal = await this.options.guard?.(tx, subject, intervals);
+		if (refusal) throw new AttendanceConflict(refusal);
+	}
+	/** The punch's still-draft evidence entry, refusing when it is no longer editable. */
+	async editableEntry(tx, punch) {
+		if (!punch.serviceTimeEntryId) return null;
+		const [entry] = await (await ServiceTimeEntryCollection.create({ db: tx.db })).list({
+			where: {
+				id: punch.serviceTimeEntryId,
+				tenantId: punch.tenantId
+			},
+			limit: 1
+		});
+		if (!entry) return null;
+		if (entry.status !== "draft") throw new AttendanceConflict(`Linked service evidence is ${entry.status}; correct it with ServiceEvidenceService first.`);
+		return entry;
+	}
+	/** Recompute the punch's durations from its breaks and persist it and its draft entry. */
+	async settle(tx, punch, breaks, entry) {
+		const unpaidMs = breaks.filter((b) => !b.paid).reduce((sum, b) => sum + b.endedAt.getTime() - b.startedAt.getTime(), 0);
+		punch.unpaidBreakSeconds = Math.round(unpaidMs / 1e3);
+		punch.durationSeconds = Math.round((punch.endedAt.getTime() - punch.startedAt.getTime() - unpaidMs) / 1e3);
+		await persistCorrection(punch);
+		if (entry) {
+			entry.startedAt = punch.startedAt;
+			entry.endedAt = punch.endedAt;
+			entry.durationSeconds = punch.durationSeconds;
+			await entry.save();
+		}
+	}
+};
+//#endregion
+export { continueSegment as a, openSegment as c, validateAttendanceWork as d, ATTENDANCE_CORRECTION_KINDS as f, closeOpenSegment as i, replaceSegment as l, AttendanceCorrectionCollection as m, AttendanceService as n, endSegment as o, AttendanceCorrection as p, beginSegment as r, listSegments as s, AttendanceCorrectionService as t, AttendanceConflict as u };
+
+//# sourceMappingURL=attendance-DGVy-iHI.js.map