@happyvertical/smrt-timesheets 0.56.0 → 0.56.2

package/dist/chunks/time-entry-actions-Bp--TxUD.js

@@ -0,0 +1,576 @@
+import { a as validateDurationHours, i as ServiceTimeEntryCollection, t as SERVICE_DURATION_HOURS_EVIDENCE } from "./service-time-entry-Cxh0pt0J.js";
+import { SmrtCollection, SmrtObject, ValidationError, field, foreignKey, smrt } from "@happyvertical/smrt-core";
+import { TenantScoped, getCurrentTenant, tenantId, withTenant } from "@happyvertical/smrt-tenancy";
+import { OperationPermissionError, UserCollection, assertOperationPermission, getCurrentSessionPermissionContext } from "@happyvertical/smrt-users";
+//#region \0rolldown/runtime.js
+var __defProp$1 = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp$1(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp$1(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/models/service-snapshots.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);
+function assertSnapshotMinorUnits(model, amount) {
+	if (typeof amount !== "number" || !Number.isSafeInteger(amount)) throw new ValidationError(`${model}.amount must be a safe integer number of minor units (cents) \u2014 got ${String(amount)}. $19.99 is 1999.`, "VALIDATION_INVALID_VALUE", {
+		fieldName: "amount",
+		value: amount,
+		expectedType: "safe integer minor units"
+	});
+}
+var chargeSnapshot = /* @__PURE__ */ new WeakMap();
+var compensationSnapshot = /* @__PURE__ */ new WeakMap();
+async function immutableCommercialSnapshot(object, fields) {
+	if (!object.id) return null;
+	try {
+		const row = await object.db.get(object.tableName, { id: object.id });
+		if (!row) return null;
+		return JSON.stringify(Object.fromEntries(fields.map((key) => [key, row[key.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`)] ?? null])));
+	} catch {
+		return null;
+	}
+}
+function commercialSnapshot(object, fields) {
+	return JSON.stringify(Object.fromEntries(fields.map((key) => [key, object[key] ?? null])));
+}
+var CHARGE_FIELDS = [
+	"timeEntryId",
+	"amount",
+	"currency",
+	"pricingVersion",
+	"strategy",
+	"rateSnapshot",
+	"sourceChargeRef"
+];
+var COMPENSATION_FIELDS = [
+	"timeEntryId",
+	"amount",
+	"currency",
+	"termsVersion",
+	"rateSnapshot"
+];
+var ServiceChargeSnapshot = class extends SmrtObject {
+	tenantId = null;
+	timeEntryId = "";
+	/**
+	* Client charge in **integer minor units** of {@link currency} — `$19.99` is
+	* `1999`. The `= 0` initializer is load-bearing: SMRT maps an integer literal
+	* to INTEGER and a decimal literal to DECIMAL (#2401).
+	*
+	* Copied verbatim from the upstream `ClientCharge.amount`, so the two carry
+	* the same unit by construction; a split would land cents in a major-units
+	* column with no error anywhere.
+	*/
+	amount = 0;
+	currency = "USD";
+	pricingVersion = "";
+	strategy = "";
+	rateSnapshot = "{}";
+	sourceChargeRef = "";
+	createdAt = /* @__PURE__ */ new Date();
+	async initialize() {
+		await super.initialize();
+		if (await this.isSaved()) chargeSnapshot.set(this, commercialSnapshot(this, CHARGE_FIELDS));
+		return this;
+	}
+	async save() {
+		assertSnapshotMinorUnits("ServiceChargeSnapshot", this.amount);
+		const current = commercialSnapshot(this, CHARGE_FIELDS);
+		const prior = await immutableCommercialSnapshot(this, CHARGE_FIELDS) ?? chargeSnapshot.get(this) ?? null;
+		if (prior && prior !== current) throw new Error("ServiceChargeSnapshot is immutable; append an upstream adjustment instead.");
+		const result = await super.save();
+		chargeSnapshot.set(this, current);
+		return result;
+	}
+};
+__publicField(ServiceChargeSnapshot, "__smrtPackage__", "@happyvertical/smrt-timesheets");
+__decorateClass([tenantId({ nullable: true })], ServiceChargeSnapshot.prototype, "tenantId", 2);
+__decorateClass([foreignKey("ServiceTimeEntry", { required: true })], ServiceChargeSnapshot.prototype, "timeEntryId", 2);
+__decorateClass([field({ type: "text" })], ServiceChargeSnapshot.prototype, "currency", 2);
+__decorateClass([field({ type: "text" })], ServiceChargeSnapshot.prototype, "pricingVersion", 2);
+__decorateClass([field({ type: "text" })], ServiceChargeSnapshot.prototype, "strategy", 2);
+__decorateClass([field({ type: "text" })], ServiceChargeSnapshot.prototype, "rateSnapshot", 2);
+__decorateClass([field({ type: "text" })], ServiceChargeSnapshot.prototype, "sourceChargeRef", 2);
+ServiceChargeSnapshot = __decorateClass([TenantScoped({ mode: "optional" }), smrt({
+	tableName: "service_charge_snapshots",
+	previousQualifiedNames: ["@happyvertical/smrt-projects:ServiceChargeSnapshot"],
+	conflictColumns: ["time_entry_id"],
+	api: { include: ["list", "get"] },
+	cli: { include: ["list", "get"] },
+	mcp: { include: ["list", "get"] }
+})], ServiceChargeSnapshot);
+var ServiceCompensationSnapshot = class extends SmrtObject {
+	tenantId = null;
+	timeEntryId = "";
+	/**
+	* Provider earning in **integer minor units** of {@link currency} (#2401).
+	*
+	* Converts with {@link ServiceChargeSnapshot.amount}: the delivery margin is
+	* `charge - compensation`, so a mixed pair would make that subtraction
+	* meaningless.
+	*/
+	amount = 0;
+	currency = "USD";
+	termsVersion = "";
+	rateSnapshot = "{}";
+	createdAt = /* @__PURE__ */ new Date();
+	async initialize() {
+		await super.initialize();
+		if (await this.isSaved()) compensationSnapshot.set(this, commercialSnapshot(this, COMPENSATION_FIELDS));
+		return this;
+	}
+	async save() {
+		assertSnapshotMinorUnits("ServiceCompensationSnapshot", this.amount);
+		const current = commercialSnapshot(this, COMPENSATION_FIELDS);
+		const prior = await immutableCommercialSnapshot(this, COMPENSATION_FIELDS) ?? compensationSnapshot.get(this) ?? null;
+		if (prior && prior !== current) throw new Error("ServiceCompensationSnapshot is immutable; create explicit settlement evidence instead.");
+		const result = await super.save();
+		compensationSnapshot.set(this, current);
+		return result;
+	}
+};
+__publicField(ServiceCompensationSnapshot, "__smrtPackage__", "@happyvertical/smrt-timesheets");
+__decorateClass([tenantId({ nullable: true })], ServiceCompensationSnapshot.prototype, "tenantId", 2);
+__decorateClass([foreignKey("ServiceTimeEntry", { required: true })], ServiceCompensationSnapshot.prototype, "timeEntryId", 2);
+__decorateClass([field({ type: "text" })], ServiceCompensationSnapshot.prototype, "currency", 2);
+__decorateClass([field({ type: "text" })], ServiceCompensationSnapshot.prototype, "termsVersion", 2);
+__decorateClass([field({ type: "text" })], ServiceCompensationSnapshot.prototype, "rateSnapshot", 2);
+ServiceCompensationSnapshot = __decorateClass([TenantScoped({ mode: "optional" }), smrt({
+	tableName: "service_compensation_snapshots",
+	previousQualifiedNames: ["@happyvertical/smrt-projects:ServiceCompensationSnapshot"],
+	conflictColumns: ["time_entry_id"],
+	api: { include: ["list", "get"] },
+	cli: { include: ["list", "get"] },
+	mcp: { include: ["list", "get"] }
+})], ServiceCompensationSnapshot);
+var ServiceChargeSnapshotCollection = class extends SmrtCollection {};
+__publicField(ServiceChargeSnapshotCollection, "__smrtPackage__", "@happyvertical/smrt-timesheets");
+__publicField(ServiceChargeSnapshotCollection, "_itemClass", ServiceChargeSnapshot);
+ServiceChargeSnapshotCollection = __decorateClass([smrt({
+	mcp: { include: ["list", "get"] },
+	cli: false
+})], ServiceChargeSnapshotCollection);
+var ServiceCompensationSnapshotCollection = class extends SmrtCollection {};
+__publicField(ServiceCompensationSnapshotCollection, "__smrtPackage__", "@happyvertical/smrt-timesheets");
+__publicField(ServiceCompensationSnapshotCollection, "_itemClass", ServiceCompensationSnapshot);
+ServiceCompensationSnapshotCollection = __decorateClass([smrt({
+	mcp: { include: ["list", "get"] },
+	cli: false
+})], ServiceCompensationSnapshotCollection);
+//#endregion
+//#region src/services/action-principal.ts
+var TimesheetActionError = class extends Error {
+	status;
+	code;
+	publicMessage;
+	constructor(status, code, message) {
+		super(message);
+		this.name = "TimesheetActionError";
+		this.status = status;
+		this.code = code;
+		this.publicMessage = message;
+	}
+};
+function profileIdOf(user) {
+	if (!user || typeof user !== "object") return null;
+	const value = user.profileId;
+	return typeof value === "string" && value ? value : null;
+}
+function ambientPrincipal() {
+	const tenant = getCurrentTenant();
+	const session = getCurrentSessionPermissionContext();
+	if (tenant?.tenantId) {
+		const sessionProfile = session?.userId && session.userId === tenant.userId ? profileIdOf(session.user) : null;
+		return {
+			tenantId: tenant.tenantId,
+			userId: tenant.userId ?? null,
+			permissions: tenant.permissions,
+			profileId: profileIdOf(tenant.user) ?? sessionProfile,
+			fromTenancy: true
+		};
+	}
+	return {
+		tenantId: session?.tenantId ?? null,
+		userId: session?.userId ?? null,
+		permissions: session?.permissionSet ?? /* @__PURE__ */ new Set(),
+		profileId: profileIdOf(session?.user),
+		fromTenancy: false
+	};
+}
+async function loadProfileId(userId, options) {
+	try {
+		return profileIdOf(await (await UserCollection.create({ db: options.db ?? options.persistence })).get({ id: userId }));
+	} catch {
+		return null;
+	}
+}
+async function principalHolds(collection, action, options) {
+	const ambient = ambientPrincipal();
+	try {
+		await assertOperationPermission({
+			collection,
+			action,
+			db: options.db ?? options.persistence,
+			tenantId: ambient.tenantId,
+			userId: ambient.userId,
+			permissionSet: ambient.permissions,
+			allowSystemContextBypass: false,
+			allowSuperAdminBypass: false
+		});
+		return true;
+	} catch (error) {
+		if (error instanceof OperationPermissionError) return false;
+		throw error;
+	}
+}
+async function authorizeTimesheetAction(collection, action, options, guard) {
+	const ambient = ambientPrincipal();
+	try {
+		await assertOperationPermission({
+			collection,
+			action,
+			db: options.db ?? options.persistence,
+			tenantId: ambient.tenantId,
+			userId: ambient.userId,
+			permissionSet: ambient.permissions,
+			allowSystemContextBypass: false,
+			allowSuperAdminBypass: guard.allowSuperAdminBypass
+		});
+	} catch (error) {
+		if (error instanceof OperationPermissionError) throw new TimesheetActionError(403, "permission_denied", error.message);
+		throw error;
+	}
+	if (!ambient.tenantId || !ambient.userId) throw new TimesheetActionError(403, "permission_denied", "Time entry actions need an authenticated tenant context.");
+	const profileId = ambient.profileId ?? await loadProfileId(ambient.userId, options);
+	if (!profileId) throw new TimesheetActionError(403, "actor_profile_required", "Time entry actions need a user with a linked profile.");
+	return {
+		tenantId: ambient.tenantId,
+		userId: ambient.userId,
+		permissions: ambient.permissions,
+		profileId,
+		fromTenancy: ambient.fromTenancy
+	};
+}
+async function withActionPrincipal(principal, fn) {
+	if (principal.fromTenancy) return fn();
+	return withTenant({
+		tenantId: principal.tenantId,
+		userId: principal.userId,
+		permissions: new Set(principal.permissions)
+	}, fn);
+}
+//#endregion
+//#region src/services/service-evidence-service.ts
+var ServiceEvidenceService = class ServiceEvidenceService {
+	constructor(entries, charges, compensation, commercial) {
+		this.entries = entries;
+		this.charges = charges;
+		this.compensation = compensation;
+		this.commercial = commercial;
+	}
+	entries;
+	charges;
+	compensation;
+	commercial;
+	static async create(options = {}, commercial) {
+		const [entries, charges, compensation] = await Promise.all([
+			ServiceTimeEntryCollection.create(options),
+			ServiceChargeSnapshotCollection.create(options),
+			ServiceCompensationSnapshotCollection.create(options)
+		]);
+		return new ServiceEvidenceService(entries, charges, compensation, commercial);
+	}
+	async record(input) {
+		if (![
+			"timer",
+			"manual",
+			"import",
+			"agent"
+		].includes(input.source)) throw new Error("Unsupported service time source.");
+		if (Boolean(input.workRefType) !== Boolean(input.workRefId)) throw new Error("workRefType and workRefId must be provided together.");
+		if (!(input.workRefType && input.workRefId)) throw new Error("Service time requires a work reference.");
+		if (input.participantKind === "human" && !input.participantProfileId) throw new Error("Human service time requires participantProfileId.");
+		if (input.participantKind === "agent" && !input.agentRef) throw new Error("Agent service time requires agentRef.");
+		if (input.source === "timer" && (!input.startedAt || !input.endedAt)) throw new Error("Timer service time requires startedAt and endedAt.");
+		if (input.startedAt && input.endedAt && input.startedAt >= input.endedAt) throw new Error("Service time startedAt must be before endedAt.");
+		const { durationHours, ...fields } = input;
+		if (input.evidence?.some((item) => item?.kind === "@happyvertical/smrt-timesheets:duration-hours")) throw new Error("Use durationHours to supply reserved decimal-hours evidence.");
+		const hours = durationHours === void 0 ? null : validateDurationHours(durationHours);
+		if (hours !== null && (input.durationSeconds != null || input.startedAt || input.endedAt)) throw new Error("Decimal-hours-only service time cannot also supply seconds or timestamps.");
+		if (hours === null && input.durationSeconds === null) throw new Error("Null durationSeconds requires durationHours.");
+		const duration = hours !== null ? null : input.durationSeconds ?? (input.startedAt && input.endedAt ? Math.round((input.endedAt.getTime() - input.startedAt.getTime()) / 1e3) : 0);
+		if (duration !== null && (!Number.isSafeInteger(duration) || duration <= 0)) throw new Error("Service time durationSeconds must be a positive integer.");
+		const entry = await this.entries.create({
+			...fields,
+			durationSeconds: duration,
+			evidence: JSON.stringify([...input.evidence ?? [], ...hours === null ? [] : [{
+				kind: SERVICE_DURATION_HOURS_EVIDENCE,
+				hours
+			}]]),
+			metadata: JSON.stringify(input.metadata ?? {}),
+			status: "draft",
+			submittedAt: null,
+			submittedByProfileId: null,
+			approvedAt: null,
+			approvedByProfileId: null,
+			approvalPath: "",
+			rejectedAt: null,
+			rejectedByProfileId: null,
+			rejectionReason: "",
+			correctionOfId: null
+		});
+		await entry.save();
+		return entry;
+	}
+	async submit(entry, profileId) {
+		if (entry.status !== "draft" && entry.status !== "rejected") throw new Error("Only draft or rejected service time may be submitted.");
+		entry.status = "submitted";
+		entry.submittedAt = /* @__PURE__ */ new Date();
+		entry.submittedByProfileId = profileId ?? null;
+		return entry.save();
+	}
+	async approve(entry, options) {
+		if (entry.status !== "submitted" && entry.status !== "approved") throw new Error("Only submitted service time or an incomplete approval may be approved.");
+		if (!this.commercial) throw new Error("A ServiceCommercialResolver is required to approve service time.");
+		const timeEntryId = entry.id;
+		if (!timeEntryId) throw new Error("ServiceTimeEntry must be saved before approval.");
+		const existingCharge = (await this.charges.list({
+			where: { timeEntryId },
+			limit: 1
+		}))[0];
+		const existingCompensation = (await this.compensation.list({
+			where: { timeEntryId },
+			limit: 1
+		}))[0];
+		if (entry.status === "approved" && existingCharge && existingCompensation) return entry;
+		await this.commercial.validateEntry?.(entry);
+		if (entry.status === "submitted") {
+			entry.status = "approved";
+			entry.approvedAt = /* @__PURE__ */ new Date();
+			entry.approvedByProfileId = options.actorProfileId ?? null;
+			entry.approvalPath = options.approvalPath;
+			try {
+				await entry.save();
+			} catch (error) {
+				if (!(error instanceof Error && "code" in error && error.code === "RUNTIME_REVISION_CONFLICT")) throw error;
+				const concurrent = await this.entries.get(timeEntryId);
+				if (concurrent?.status !== "approved") throw error;
+				entry = concurrent;
+				await this.commercial.validateEntry?.(entry);
+			}
+		}
+		const provider = existingCompensation ? null : await this.commercial.compensateProvider(entry);
+		if (provider) {
+			const snapshotId = await deterministicSnapshotId("service-compensation-snapshot", timeEntryId);
+			try {
+				await this.compensation.create({
+					id: snapshotId,
+					tenantId: entry.tenantId,
+					timeEntryId,
+					amount: provider.amount,
+					currency: provider.currency ?? "USD",
+					termsVersion: provider.version,
+					rateSnapshot: JSON.stringify(provider.terms),
+					_insertOnly: true
+				});
+			} catch (error) {
+				if (!(await this.compensation.get(snapshotId) ?? (await this.compensation.list({
+					where: { timeEntryId },
+					limit: 1
+				}))[0])) throw error;
+			}
+		}
+		const client = existingCharge ? null : await this.commercial.priceClient(entry);
+		if (client) {
+			const snapshotId = await deterministicSnapshotId("service-charge-snapshot", timeEntryId);
+			try {
+				await this.charges.create({
+					id: snapshotId,
+					tenantId: entry.tenantId,
+					timeEntryId,
+					amount: client.amount,
+					currency: client.currency ?? "USD",
+					pricingVersion: client.version,
+					strategy: client.strategy ?? "",
+					rateSnapshot: JSON.stringify(client.terms),
+					sourceChargeRef: client.sourceRef ?? "",
+					_insertOnly: true
+				});
+			} catch (error) {
+				if (!(await this.charges.get(snapshotId) ?? (await this.charges.list({
+					where: { timeEntryId },
+					limit: 1
+				}))[0])) throw error;
+			}
+		}
+		return entry;
+	}
+	async correct(entry, input) {
+		if (entry.status !== "approved") throw new Error("Only approved service time may be corrected.");
+		if (input.tenantId !== void 0 && input.tenantId !== entry.tenantId) throw new Error("Service time corrections must remain in the original tenant.");
+		const correction = await this.record({
+			...input,
+			tenantId: entry.tenantId
+		});
+		correction.correctionOfId = entry.id ?? null;
+		await correction.save();
+		entry.status = "corrected";
+		await entry.save();
+		return correction;
+	}
+};
+async function deterministicSnapshotId(kind, timeEntryId) {
+	const bytes = new TextEncoder().encode(JSON.stringify([kind, timeEntryId]));
+	const uuid = new Uint8Array(await crypto.subtle.digest("SHA-256", bytes)).slice(0, 16);
+	uuid[6] = uuid[6] & 15 | 80;
+	uuid[8] = uuid[8] & 63 | 128;
+	const hex = Array.from(uuid, (byte) => byte.toString(16).padStart(2, "0")).join("");
+	return [
+		hex.slice(0, 8),
+		hex.slice(8, 12),
+		hex.slice(12, 16),
+		hex.slice(16, 20),
+		hex.slice(20)
+	].join("-");
+}
+//#endregion
+//#region src/services/time-entry-actions.ts
+var time_entry_actions_exports = /* @__PURE__ */ __exportAll({
+	SERVICE_TIME_ENTRY_ACTION_APPROVAL_PATH: () => SERVICE_TIME_ENTRY_ACTION_APPROVAL_PATH,
+	approveServiceTimeAction: () => approveServiceTimeAction,
+	getServiceTimeEntryCommercialResolver: () => getServiceTimeEntryCommercialResolver,
+	recordServiceTimeAction: () => recordServiceTimeAction,
+	setServiceTimeEntryCommercialResolver: () => setServiceTimeEntryCommercialResolver,
+	submitServiceTimeAction: () => submitServiceTimeAction
+});
+var SERVICE_TIME_ENTRY_ACTION_APPROVAL_PATH = "operator";
+var actionCommercialResolver = null;
+function setServiceTimeEntryCommercialResolver(resolver) {
+	actionCommercialResolver = resolver;
+}
+function getServiceTimeEntryCommercialResolver() {
+	return actionCommercialResolver;
+}
+function asRecord(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new TimesheetActionError(400, "invalid_request", "The action body must be a JSON object.");
+	return value;
+}
+function optionalString(body, key) {
+	const value = body[key];
+	if (value === void 0 || value === null) return void 0;
+	if (typeof value !== "string") throw new TimesheetActionError(400, "invalid_request", `${key} must be a string.`);
+	return value;
+}
+function requiredString(body, key) {
+	const value = optionalString(body, key)?.trim();
+	if (!value) throw new TimesheetActionError(400, "invalid_request", `${key} is required.`);
+	return value;
+}
+function optionalInstant(body, key) {
+	const value = optionalString(body, key);
+	if (value === void 0) return null;
+	const date = new Date(value);
+	if (Number.isNaN(date.getTime())) throw new TimesheetActionError(400, "invalid_request", `${key} must be an ISO 8601 instant.`);
+	return date;
+}
+async function serviceCall(fn) {
+	try {
+		return await fn();
+	} catch (error) {
+		if (error instanceof Error && error.constructor === Error) throw new TimesheetActionError(400, "invalid_request", error.message);
+		throw error;
+	}
+}
+async function evidenceService(entries, commercial) {
+	const options = entries.options;
+	const [charges, compensation] = await Promise.all([ServiceChargeSnapshotCollection.create(options), ServiceCompensationSnapshotCollection.create(options)]);
+	return new ServiceEvidenceService(entries, charges, compensation, commercial);
+}
+function itemClass(entries) {
+	return entries.constructor._itemClass;
+}
+async function loadEntry(entries, principal, body) {
+	const entryId = requiredString(body, "entryId");
+	const entry = await entries.get({ id: entryId });
+	if (!entry || (entry.tenantId ?? null) !== principal.tenantId) throw new TimesheetActionError(404, "not_found", `Service time entry ${entryId} was not found.`);
+	return entry;
+}
+async function recordServiceTimeAction(entries, input) {
+	const body = asRecord(input);
+	const principal = await authorizeTimesheetAction(itemClass(entries), "record", entries.options, { allowSuperAdminBypass: true });
+	const participantProfileId = optionalString(body, "participantProfileId")?.trim() || principal.profileId;
+	if (participantProfileId !== principal.profileId && !await principalHolds(itemClass(entries), "approve", entries.options)) throw new TimesheetActionError(403, "permission_denied", "Recording another person's time needs the approve permission.");
+	const source = optionalString(body, "source") ?? "manual";
+	if (source !== "manual" && source !== "timer") throw new TimesheetActionError(400, "invalid_request", "source must be 'manual' or 'timer'.");
+	const durationSeconds = body.durationSeconds;
+	if (durationSeconds !== void 0 && durationSeconds !== null && typeof durationSeconds !== "number") throw new TimesheetActionError(400, "invalid_request", "durationSeconds must be a number.");
+	const evidence = body.evidence;
+	if (evidence !== void 0 && !Array.isArray(evidence)) throw new TimesheetActionError(400, "invalid_request", "evidence must be an array.");
+	const metadata = body.metadata;
+	if (metadata !== void 0 && (metadata === null || typeof metadata !== "object" || Array.isArray(metadata))) throw new TimesheetActionError(400, "invalid_request", "metadata must be an object.");
+	return withActionPrincipal(principal, async () => {
+		const service = await evidenceService(entries);
+		return serviceCall(() => service.record({
+			tenantId: principal.tenantId,
+			workRefType: requiredString(body, "workRefType"),
+			workRefId: requiredString(body, "workRefId"),
+			participantKind: "human",
+			participantProfileId,
+			source,
+			description: optionalString(body, "description") ?? "",
+			startedAt: optionalInstant(body, "startedAt"),
+			endedAt: optionalInstant(body, "endedAt"),
+			...durationSeconds !== void 0 ? { durationSeconds } : {},
+			...body.durationHours !== void 0 ? { durationHours: optionalString(body, "durationHours") } : {},
+			...evidence ? { evidence } : {},
+			...metadata ? { metadata } : {}
+		}));
+	});
+}
+async function submitServiceTimeAction(entries, input) {
+	const body = asRecord(input);
+	const principal = await authorizeTimesheetAction(itemClass(entries), "submit", entries.options, { allowSuperAdminBypass: true });
+	return withActionPrincipal(principal, async () => {
+		const entry = await loadEntry(entries, principal, body);
+		if (entry.participantProfileId !== principal.profileId && !await principalHolds(itemClass(entries), "approve", entries.options)) throw new TimesheetActionError(403, "permission_denied", "Submitting another person's time needs the approve permission.");
+		const service = await evidenceService(entries);
+		return serviceCall(() => service.submit(entry, principal.profileId));
+	});
+}
+async function approveServiceTimeAction(entries, input) {
+	const body = asRecord(input);
+	const principal = await authorizeTimesheetAction(itemClass(entries), "approve", entries.options, { allowSuperAdminBypass: false });
+	const source = actionCommercialResolver;
+	if (!source) throw new TimesheetActionError(409, "approval_not_configured", "No ServiceCommercialResolver is installed for time entry approval.");
+	return withActionPrincipal(principal, async () => {
+		const entry = await loadEntry(entries, principal, body);
+		const service = await evidenceService(entries, typeof source === "function" ? await source({ options: entries.options }) : source);
+		return serviceCall(() => service.approve(entry, {
+			actorProfileId: principal.profileId,
+			approvalPath: SERVICE_TIME_ENTRY_ACTION_APPROVAL_PATH
+		}));
+	});
+}
+//#endregion
+export { setServiceTimeEntryCommercialResolver as a, ServiceEvidenceService as c, ServiceChargeSnapshotCollection as d, ServiceCompensationSnapshot as f, recordServiceTimeAction as i, TimesheetActionError as l, approveServiceTimeAction as n, submitServiceTimeAction as o, ServiceCompensationSnapshotCollection as p, getServiceTimeEntryCommercialResolver as r, time_entry_actions_exports as s, SERVICE_TIME_ENTRY_ACTION_APPROVAL_PATH as t, ServiceChargeSnapshot as u };
+
+//# sourceMappingURL=time-entry-actions-Bp--TxUD.js.map