@azlib/cms 0.4.0 → 0.6.0

package/dist/index.cjs

@@ -1,4 +1,28 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let exceljs = require("exceljs");
+exceljs = __toESM(exceljs, 1);
 //#region src/content/schema.ts
 const fields = {
 	text(options) {
@@ -2857,7 +2881,7 @@ var EcommerceService = class {
 };
 //#endregion
 //#region src/plugins/ecommerce/routes.ts
-function json(data, status = 200) {
+function json$2(data, status = 200) {
 	return new Response(JSON.stringify(data), {
 		status,
 		headers: {
@@ -2866,11 +2890,11 @@ function json(data, status = 200) {
 		}
 	});
 }
-function badRequest(message) {
-	return json({ error: message }, 400);
+function badRequest$2(message) {
+	return json$2({ error: message }, 400);
 }
-function notFound(message) {
-	return json({ error: message }, 404);
+function notFound$2(message) {
+	return json$2({ error: message }, 404);
 }
 function registerEcommerceRoutes(ctx, service, options = {}) {
 	const prefix = (options.apiPrefix ?? "/api/ecommerce").replace(/\/+$/, "");
@@ -2893,7 +2917,7 @@ function registerEcommerceRoutes(ctx, service, options = {}) {
 			const offsetStr = url.searchParams.get("offset");
 			const limit = limitStr ? parseInt(limitStr, 10) : 20;
 			const offset = offsetStr ? parseInt(offsetStr, 10) : 0;
-			return json(await service.listProducts({
+			return json$2(await service.listProducts({
 				categorySlug,
 				categoryId,
 				tagSlug,
@@ -2909,7 +2933,7 @@ function registerEcommerceRoutes(ctx, service, options = {}) {
 				offset
 			}));
 		} catch (err) {
-			return badRequest(err instanceof Error ? err.message : String(err));
+			return badRequest$2(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("GET", `${prefix}/products/:id`, async (_req, { params, url }) => {
@@ -2921,32 +2945,32 @@ function registerEcommerceRoutes(ctx, service, options = {}) {
 			product = await service.getProduct(id);
 			if (!product) product = await service.getProductBySlug(id);
 		}
-		if (!product) return notFound(`Product '${id}' not found`);
-		return json(product);
+		if (!product) return notFound$2(`Product '${id}' not found`);
+		return json$2(product);
 	});
 	ctx.registerRoute("POST", `${prefix}/products`, async (req) => {
 		try {
 			const body = await req.json();
-			if (!body.title) return badRequest("Product 'title' is required.");
-			if (body.price === void 0 || body.price < 0) return badRequest("Valid product 'price' is required.");
-			return json(await service.createProduct(body), 201);
+			if (!body.title) return badRequest$2("Product 'title' is required.");
+			if (body.price === void 0 || body.price < 0) return badRequest$2("Valid product 'price' is required.");
+			return json$2(await service.createProduct(body), 201);
 		} catch (err) {
-			return badRequest(err instanceof Error ? err.message : String(err));
+			return badRequest$2(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("PUT", `${prefix}/products/:id`, async (req, { params }) => {
 		try {
 			const body = await req.json();
 			const updated = await service.updateProduct(params.id, body);
-			if (!updated) return notFound(`Product '${params.id}' not found.`);
-			return json(updated);
+			if (!updated) return notFound$2(`Product '${params.id}' not found.`);
+			return json$2(updated);
 		} catch (err) {
-			return badRequest(err instanceof Error ? err.message : String(err));
+			return badRequest$2(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("DELETE", `${prefix}/products/:id`, async (_req, { params }) => {
-		if (!await service.deleteProduct(params.id)) return notFound(`Product '${params.id}' not found.`);
-		return json({
+		if (!await service.deleteProduct(params.id)) return notFound$2(`Product '${params.id}' not found.`);
+		return json$2({
 			success: true,
 			id: params.id
 		});
@@ -2954,8 +2978,8 @@ function registerEcommerceRoutes(ctx, service, options = {}) {
 	ctx.registerRoute("POST", `${prefix}/products/:id/images`, async (req, { params }) => {
 		try {
 			const body = await req.json();
-			if (!body.filename || !body.mimeType) return badRequest("'filename' and 'mimeType' are required.");
-			return json(await service.uploadProductImage(params.id, {
+			if (!body.filename || !body.mimeType) return badRequest$2("'filename' and 'mimeType' are required.");
+			return json$2(await service.uploadProductImage(params.id, {
 				filename: body.filename,
 				mimeType: body.mimeType,
 				sizeBytes: body.sizeBytes ?? 0,
@@ -2967,68 +2991,68 @@ function registerEcommerceRoutes(ctx, service, options = {}) {
 				isFeatured: body.isFeatured
 			}), 201);
 		} catch (err) {
-			return badRequest(err instanceof Error ? err.message : String(err));
+			return badRequest$2(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("GET", `${prefix}/categories`, async (_req, { url }) => {
 		try {
-			if (url.searchParams.get("tree") === "true") return json(await service.getCategoryTree());
+			if (url.searchParams.get("tree") === "true") return json$2(await service.getCategoryTree());
 			const parentId = url.searchParams.get("parentId");
-			return json(await service.getCategories({ parentId: parentId === "null" ? null : parentId ?? void 0 }));
+			return json$2(await service.getCategories({ parentId: parentId === "null" ? null : parentId ?? void 0 }));
 		} catch (err) {
-			return badRequest(err instanceof Error ? err.message : String(err));
+			return badRequest$2(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("POST", `${prefix}/categories`, async (req) => {
 		try {
 			const body = await req.json();
-			if (!body.name) return badRequest("Category 'name' is required.");
-			return json(await service.createCategory(body), 201);
+			if (!body.name) return badRequest$2("Category 'name' is required.");
+			return json$2(await service.createCategory(body), 201);
 		} catch (err) {
-			return badRequest(err instanceof Error ? err.message : String(err));
+			return badRequest$2(err instanceof Error ? err.message : String(err));
 		}
 	});
 	if (options.enableDiscounts !== false) {
 		ctx.registerRoute("POST", `${prefix}/discounts`, async (req) => {
 			try {
 				const body = await req.json();
-				if (!body.title || !body.code) return badRequest("'title' and 'code' are required.");
-				if (body.value === void 0 || body.value < 0) return badRequest("Valid discount 'value' is required.");
-				return json(await service.createDiscount(body), 201);
+				if (!body.title || !body.code) return badRequest$2("'title' and 'code' are required.");
+				if (body.value === void 0 || body.value < 0) return badRequest$2("Valid discount 'value' is required.");
+				return json$2(await service.createDiscount(body), 201);
 			} catch (err) {
-				return badRequest(err instanceof Error ? err.message : String(err));
+				return badRequest$2(err instanceof Error ? err.message : String(err));
 			}
 		});
 		ctx.registerRoute("POST", `${prefix}/discounts/validate`, async (req) => {
 			try {
 				const body = await req.json();
-				if (!body.code) return badRequest("Discount 'code' is required.");
+				if (!body.code) return badRequest$2("Discount 'code' is required.");
 				const subtotal = Number(body.subtotal ?? 0);
 				const productIds = Array.isArray(body.productIds) ? body.productIds : [];
-				return json(await service.validateDiscount(body.code, subtotal, productIds));
+				return json$2(await service.validateDiscount(body.code, subtotal, productIds));
 			} catch (err) {
-				return badRequest(err instanceof Error ? err.message : String(err));
+				return badRequest$2(err instanceof Error ? err.message : String(err));
 			}
 		});
 	}
 	ctx.registerRoute("POST", `${prefix}/cart/calculate`, async (req) => {
 		try {
 			const body = await req.json();
-			if (!body.items || !Array.isArray(body.items) || body.items.length === 0) return badRequest("'items' array is required and must not be empty.");
-			return json(await service.calculateCart(body));
+			if (!body.items || !Array.isArray(body.items) || body.items.length === 0) return badRequest$2("'items' array is required and must not be empty.");
+			return json$2(await service.calculateCart(body));
 		} catch (err) {
-			return badRequest(err instanceof Error ? err.message : String(err));
+			return badRequest$2(err instanceof Error ? err.message : String(err));
 		}
 	});
 	if (options.enableOrders !== false) {
 		ctx.registerRoute("POST", `${prefix}/orders`, async (req) => {
 			try {
 				const body = await req.json();
-				if (!body.customerEmail) return badRequest("'customerEmail' is required.");
-				if (!body.items || !Array.isArray(body.items) || body.items.length === 0) return badRequest("'items' array is required.");
-				return json(await service.createOrder(body), 201);
+				if (!body.customerEmail) return badRequest$2("'customerEmail' is required.");
+				if (!body.items || !Array.isArray(body.items) || body.items.length === 0) return badRequest$2("'items' array is required.");
+				return json$2(await service.createOrder(body), 201);
 			} catch (err) {
-				return badRequest(err instanceof Error ? err.message : String(err));
+				return badRequest$2(err instanceof Error ? err.message : String(err));
 			}
 		});
 		ctx.registerRoute("GET", `${prefix}/orders/:id`, async (_req, { params, url }) => {
@@ -3040,18 +3064,18 @@ function registerEcommerceRoutes(ctx, service, options = {}) {
 				order = await service.getOrder(id);
 				if (!order) order = await service.getOrderByNumber(id);
 			}
-			if (!order) return notFound(`Order '${id}' not found.`);
-			return json(order);
+			if (!order) return notFound$2(`Order '${id}' not found.`);
+			return json$2(order);
 		});
 		ctx.registerRoute("PATCH", `${prefix}/orders/:id/status`, async (req, { params }) => {
 			try {
 				const body = await req.json();
-				if (!body.status) return badRequest("New 'status' is required.");
+				if (!body.status) return badRequest$2("New 'status' is required.");
 				const updated = await service.updateOrderStatus(params.id, body.status, body.note);
-				if (!updated) return notFound(`Order '${params.id}' not found.`);
-				return json(updated);
+				if (!updated) return notFound$2(`Order '${params.id}' not found.`);
+				return json$2(updated);
 			} catch (err) {
-				return badRequest(err instanceof Error ? err.message : String(err));
+				return badRequest$2(err instanceof Error ? err.message : String(err));
 			}
 		});
 	}
@@ -3235,6 +3259,3401 @@ function getEcommerceService(engine, options) {
 	return service;
 }
 //#endregion
+//#region src/plugins/hrms/schemas.ts
+/**
+* Creates the collection configuration for Employers (Organizations / Companies).
+*/
+function createEmployerCollection(options = {}) {
+	return collection({
+		slug: options.employerCollectionSlug ?? "employers",
+		label: "Employers",
+		singularLabel: "Employer",
+		description: "Companies and organizational entities managing employees, shifts, and leave policies",
+		timestamps: true,
+		revisions: true,
+		draftable: true,
+		defaultSort: {
+			field: "createdAt",
+			direction: "desc"
+		},
+		fields: [
+			fields.text({
+				name: "companyName",
+				label: "Company Name",
+				required: true
+			}),
+			fields.slug({
+				from: "companyName",
+				unique: true
+			}),
+			fields.text({
+				name: "legalName",
+				label: "Legal Entity Name"
+			}),
+			fields.text({
+				name: "taxId",
+				label: "Tax / EIN Number"
+			}),
+			fields.text({
+				name: "email",
+				label: "Primary Email"
+			}),
+			fields.text({
+				name: "phone",
+				label: "Phone Number"
+			}),
+			fields.text({
+				name: "website",
+				label: "Website URL"
+			}),
+			fields.image({
+				name: "logo",
+				label: "Company Logo"
+			}),
+			fields.json({
+				name: "address",
+				label: "Company Address"
+			}),
+			fields.text({
+				name: "timezone",
+				label: "Primary Timezone",
+				defaultValue: "UTC"
+			}),
+			fields.json({
+				name: "workSchedule",
+				label: "Standard Work Schedule",
+				defaultValue: {
+					startTime: options.workScheduleStart ?? "09:00",
+					endTime: options.workScheduleEnd ?? "17:00",
+					standardHoursPerDay: options.standardWorkDayHours ?? 8,
+					gracePeriodMinutes: options.gracePeriodMinutes ?? 15,
+					workDays: [
+						1,
+						2,
+						3,
+						4,
+						5
+					]
+				}
+			}),
+			fields.select({
+				name: "status",
+				label: "Status",
+				options: ["active", "inactive"],
+				defaultValue: "active"
+			})
+		]
+	});
+}
+/**
+* Creates the collection configuration for Employees.
+*/
+function createEmployeeCollection(options = {}) {
+	const slug = options.employeeCollectionSlug ?? "employees";
+	const employerSlug = options.employerCollectionSlug ?? "employers";
+	return collection({
+		slug,
+		label: "Employees",
+		singularLabel: "Employee",
+		description: "Employee profiles, job assignments, emergency contacts, and attached records",
+		timestamps: true,
+		revisions: true,
+		draftable: true,
+		taxonomies: [options.departmentsTaxonomySlug ?? "hrms_departments", options.designationsTaxonomySlug ?? "hrms_designations"],
+		defaultSort: {
+			field: "createdAt",
+			direction: "desc"
+		},
+		fields: [
+			fields.relationship({
+				name: "employerId",
+				label: "Employer",
+				targetCollection: employerSlug,
+				required: true
+			}),
+			fields.text({
+				name: "userId",
+				label: "Associated User ID",
+				description: "Optional reference to an authenticated user account"
+			}),
+			fields.text({
+				name: "employeeNumber",
+				label: "Employee Number",
+				required: true,
+				unique: true
+			}),
+			fields.text({
+				name: "firstName",
+				label: "First Name",
+				required: true
+			}),
+			fields.text({
+				name: "lastName",
+				label: "Last Name",
+				required: true
+			}),
+			fields.text({
+				name: "email",
+				label: "Work Email",
+				required: true
+			}),
+			fields.text({
+				name: "phone",
+				label: "Contact Phone"
+			}),
+			fields.image({
+				name: "avatar",
+				label: "Profile Picture"
+			}),
+			fields.text({
+				name: "jobTitle",
+				label: "Job Title"
+			}),
+			fields.select({
+				name: "employmentType",
+				label: "Employment Type",
+				options: [
+					"full_time",
+					"part_time",
+					"contractor",
+					"intern"
+				],
+				defaultValue: "full_time"
+			}),
+			fields.select({
+				name: "status",
+				label: "Status",
+				options: [
+					"active",
+					"on_leave",
+					"terminated",
+					"suspended"
+				],
+				defaultValue: "active"
+			}),
+			fields.date({
+				name: "hireDate",
+				label: "Hire Date",
+				required: true
+			}),
+			fields.date({
+				name: "terminationDate",
+				label: "Termination Date"
+			}),
+			fields.relationship({
+				name: "managerId",
+				label: "Reporting Manager",
+				targetCollection: slug
+			}),
+			fields.json({
+				name: "emergencyContact",
+				label: "Emergency Contact"
+			}),
+			fields.repeater({
+				name: "documents",
+				label: "Attached Documents & Contracts",
+				fields: [
+					fields.text({
+						name: "title",
+						label: "Document Title",
+						required: true
+					}),
+					fields.text({
+						name: "fileUrl",
+						label: "File URL",
+						required: true
+					}),
+					fields.text({
+						name: "category",
+						label: "Category"
+					}),
+					fields.text({
+						name: "uploadedAt",
+						label: "Uploaded Date"
+					})
+				]
+			}),
+			fields.number({
+				name: "salary",
+				label: "Base Salary"
+			}),
+			fields.text({
+				name: "notes",
+				label: "Internal Notes"
+			})
+		]
+	});
+}
+/**
+* Creates the collection configuration for Daily Attendance.
+*/
+function createAttendanceCollection(options = {}) {
+	const slug = options.attendanceCollectionSlug ?? "attendance";
+	const employerSlug = options.employerCollectionSlug ?? "employers";
+	const employeeSlug = options.employeeCollectionSlug ?? "employees";
+	return collection({
+		slug,
+		label: "Attendance",
+		singularLabel: "Attendance Record",
+		description: "Daily check-in and check-out logs, hours worked, overtime, and punctuality status",
+		timestamps: true,
+		revisions: false,
+		draftable: false,
+		defaultSort: {
+			field: "date",
+			direction: "desc"
+		},
+		fields: [
+			fields.relationship({
+				name: "employerId",
+				label: "Employer",
+				targetCollection: employerSlug,
+				required: true
+			}),
+			fields.relationship({
+				name: "employeeId",
+				label: "Employee",
+				targetCollection: employeeSlug,
+				required: true
+			}),
+			fields.date({
+				name: "date",
+				label: "Date",
+				required: true
+			}),
+			fields.text({
+				name: "checkInAt",
+				label: "Check-In Timestamp",
+				required: true
+			}),
+			fields.text({
+				name: "checkOutAt",
+				label: "Check-Out Timestamp"
+			}),
+			fields.number({
+				name: "totalHours",
+				label: "Total Hours",
+				defaultValue: 0
+			}),
+			fields.number({
+				name: "overtimeHours",
+				label: "Overtime Hours",
+				defaultValue: 0
+			}),
+			fields.select({
+				name: "status",
+				label: "Status",
+				options: [
+					"present",
+					"late",
+					"half_day",
+					"absent",
+					"on_leave"
+				],
+				defaultValue: "present"
+			}),
+			fields.text({
+				name: "location",
+				label: "Location / IP / Geofence"
+			}),
+			fields.text({
+				name: "notes",
+				label: "Notes"
+			})
+		]
+	});
+}
+/**
+* Creates the collection configuration for Leave Types.
+*/
+function createLeaveTypeCollection(options = {}) {
+	const slug = options.leaveTypeCollectionSlug ?? "leave_types";
+	const employerSlug = options.employerCollectionSlug ?? "employers";
+	return collection({
+		slug,
+		label: "Leave Types",
+		singularLabel: "Leave Type",
+		description: "Available leave categories (Annual, Sick, Unpaid) and yearly quotas",
+		timestamps: true,
+		revisions: true,
+		draftable: false,
+		fields: [
+			fields.relationship({
+				name: "employerId",
+				label: "Employer",
+				targetCollection: employerSlug
+			}),
+			fields.text({
+				name: "name",
+				label: "Leave Name",
+				required: true
+			}),
+			fields.text({
+				name: "code",
+				label: "Leave Code",
+				required: true
+			}),
+			fields.number({
+				name: "daysAllowedPerYear",
+				label: "Days Allowed Per Year",
+				required: true,
+				defaultValue: 15,
+				min: 0
+			}),
+			fields.boolean({
+				name: "paid",
+				label: "Paid Leave",
+				defaultValue: true
+			}),
+			fields.boolean({
+				name: "requiresApproval",
+				label: "Requires Manager Approval",
+				defaultValue: true
+			}),
+			fields.text({
+				name: "color",
+				label: "Display Color Code"
+			}),
+			fields.text({
+				name: "description",
+				label: "Description / Policy"
+			})
+		]
+	});
+}
+/**
+* Creates the collection configuration for Leave Requests.
+*/
+function createLeaveRequestCollection(options = {}) {
+	const slug = options.leaveRequestCollectionSlug ?? "leave_requests";
+	const employerSlug = options.employerCollectionSlug ?? "employers";
+	const employeeSlug = options.employeeCollectionSlug ?? "employees";
+	const leaveTypeSlug = options.leaveTypeCollectionSlug ?? "leave_types";
+	return collection({
+		slug,
+		label: "Leave Requests",
+		singularLabel: "Leave Request",
+		description: "Employee time-off requests, approval tracking, and deducted balances",
+		timestamps: true,
+		revisions: true,
+		draftable: false,
+		defaultSort: {
+			field: "createdAt",
+			direction: "desc"
+		},
+		fields: [
+			fields.relationship({
+				name: "employerId",
+				label: "Employer",
+				targetCollection: employerSlug,
+				required: true
+			}),
+			fields.relationship({
+				name: "employeeId",
+				label: "Employee",
+				targetCollection: employeeSlug,
+				required: true
+			}),
+			fields.relationship({
+				name: "leaveTypeId",
+				label: "Leave Type",
+				targetCollection: leaveTypeSlug,
+				required: true
+			}),
+			fields.date({
+				name: "startDate",
+				label: "Start Date",
+				required: true
+			}),
+			fields.date({
+				name: "endDate",
+				label: "End Date",
+				required: true
+			}),
+			fields.number({
+				name: "daysCount",
+				label: "Days Count",
+				required: true,
+				min: .5
+			}),
+			fields.text({
+				name: "reason",
+				label: "Reason"
+			}),
+			fields.select({
+				name: "status",
+				label: "Request Status",
+				options: [
+					"pending",
+					"approved",
+					"rejected",
+					"cancelled"
+				],
+				defaultValue: "pending"
+			}),
+			fields.relationship({
+				name: "approvedBy",
+				label: "Approved / Rejected By",
+				targetCollection: employeeSlug
+			}),
+			fields.text({
+				name: "approvedAt",
+				label: "Decision Timestamp"
+			}),
+			fields.text({
+				name: "rejectionReason",
+				label: "Rejection Reason"
+			})
+		]
+	});
+}
+/**
+* Creates the standard HRMS taxonomies: departments and designations.
+*/
+function createHRMSTaxonomies(options = {}) {
+	const employeeSlug = options.employeeCollectionSlug ?? "employees";
+	const deptSlug = options.departmentsTaxonomySlug ?? "hrms_departments";
+	const desigSlug = options.designationsTaxonomySlug ?? "hrms_designations";
+	return [{
+		slug: deptSlug,
+		label: "Departments",
+		singularLabel: "Department",
+		hierarchical: true,
+		postTypes: [employeeSlug],
+		description: "Hierarchical departmental tree (e.g. Engineering, Sales, HR)"
+	}, {
+		slug: desigSlug,
+		label: "Designations",
+		singularLabel: "Designation",
+		hierarchical: false,
+		postTypes: [employeeSlug],
+		description: "Job titles and designations across the workforce"
+	}];
+}
+//#endregion
+//#region src/plugins/hrms/service.ts
+var HRMSService = class {
+	engine;
+	options;
+	employerSlug;
+	employeeSlug;
+	attendanceSlug;
+	leaveTypeSlug;
+	leaveRequestSlug;
+	departmentsTaxonomy;
+	designationsTaxonomy;
+	standardWorkDayHours;
+	workScheduleStart;
+	workScheduleEnd;
+	gracePeriodMinutes;
+	constructor(engine, options = {}) {
+		this.engine = engine;
+		this.options = options;
+		this.employerSlug = options.employerCollectionSlug ?? "employers";
+		this.employeeSlug = options.employeeCollectionSlug ?? "employees";
+		this.attendanceSlug = options.attendanceCollectionSlug ?? "attendance";
+		this.leaveTypeSlug = options.leaveTypeCollectionSlug ?? "leave_types";
+		this.leaveRequestSlug = options.leaveRequestCollectionSlug ?? "leave_requests";
+		this.departmentsTaxonomy = options.departmentsTaxonomySlug ?? "hrms_departments";
+		this.designationsTaxonomy = options.designationsTaxonomySlug ?? "hrms_designations";
+		this.standardWorkDayHours = options.standardWorkDayHours ?? 8;
+		this.workScheduleStart = options.workScheduleStart ?? "09:00";
+		this.workScheduleEnd = options.workScheduleEnd ?? "17:00";
+		this.gracePeriodMinutes = options.gracePeriodMinutes ?? 15;
+	}
+	get employersCollection() {
+		return this.engine.collection(this.employerSlug);
+	}
+	get employeesCollection() {
+		return this.engine.collection(this.employeeSlug);
+	}
+	get attendanceCollection() {
+		return this.engine.collection(this.attendanceSlug);
+	}
+	get leaveTypesCollection() {
+		return this.engine.collection(this.leaveTypeSlug);
+	}
+	get leaveRequestsCollection() {
+		return this.engine.collection(this.leaveRequestSlug);
+	}
+	async createEmployer(input, authorId) {
+		const employerData = {
+			companyName: input.companyName,
+			legalName: input.legalName,
+			taxId: input.taxId,
+			email: input.email,
+			phone: input.phone,
+			website: input.website,
+			logo: input.logo,
+			address: input.address,
+			timezone: input.timezone ?? "UTC",
+			workSchedule: input.workSchedule ?? {
+				startTime: this.workScheduleStart,
+				endTime: this.workScheduleEnd,
+				standardHoursPerDay: this.standardWorkDayHours,
+				gracePeriodMinutes: this.gracePeriodMinutes,
+				workDays: [
+					1,
+					2,
+					3,
+					4,
+					5
+				]
+			},
+			status: input.status ?? "active"
+		};
+		const employer = await this.employersCollection.create({
+			title: input.companyName,
+			status: input.status === "inactive" ? "draft" : "published",
+			data: employerData
+		}, authorId);
+		await this.engine.hooks.doAction("hrms.employer_created", employer);
+		return employer;
+	}
+	async getEmployer(id) {
+		return this.employersCollection.findById(id);
+	}
+	async getEmployerBySlug(slug) {
+		return this.employersCollection.findBySlug(slug);
+	}
+	async updateEmployer(id, input, authorId) {
+		const existing = await this.getEmployer(id);
+		if (!existing) return null;
+		const updatedData = {
+			...existing.data,
+			...input.companyName !== void 0 ? { companyName: input.companyName } : {},
+			...input.legalName !== void 0 ? { legalName: input.legalName } : {},
+			...input.taxId !== void 0 ? { taxId: input.taxId } : {},
+			...input.email !== void 0 ? { email: input.email } : {},
+			...input.phone !== void 0 ? { phone: input.phone } : {},
+			...input.website !== void 0 ? { website: input.website } : {},
+			...input.logo !== void 0 ? { logo: input.logo } : {},
+			...input.address !== void 0 ? { address: input.address } : {},
+			...input.timezone !== void 0 ? { timezone: input.timezone } : {},
+			...input.workSchedule !== void 0 ? { workSchedule: input.workSchedule } : {},
+			...input.status !== void 0 ? { status: input.status } : {}
+		};
+		const updated = await this.employersCollection.update(id, {
+			title: input.companyName ?? existing.title,
+			data: updatedData
+		}, authorId);
+		if (updated) await this.engine.hooks.doAction("hrms.employer_updated", updated);
+		return updated;
+	}
+	async listEmployers(query = {}) {
+		const limit = query.limit ?? 20;
+		const offset = query.page ? (query.page - 1) * limit : 0;
+		let items = (await this.employersCollection.find({ limit: 500 })).items;
+		if (query.status) items = items.filter((item) => item.data.status === query.status);
+		const total = items.length;
+		return {
+			items: items.slice(offset, offset + limit),
+			total,
+			limit,
+			offset,
+			hasMore: offset + limit < total
+		};
+	}
+	async createEmployee(input, authorId) {
+		if (!await this.getEmployer(input.employerId)) throw new Error(`[HRMSService] Employer with ID '${input.employerId}' not found.`);
+		if (await this.getEmployeeByNumber(input.employerId, input.employeeNumber)) throw new Error(`[HRMSService] Employee number '${input.employeeNumber}' is already registered for this employer.`);
+		const employeeData = {
+			employerId: input.employerId,
+			userId: input.userId,
+			employeeNumber: input.employeeNumber,
+			firstName: input.firstName,
+			lastName: input.lastName,
+			email: input.email,
+			phone: input.phone,
+			avatar: input.avatar,
+			jobTitle: input.jobTitle,
+			employmentType: input.employmentType ?? "full_time",
+			status: input.status ?? "active",
+			hireDate: input.hireDate,
+			managerId: input.managerId,
+			emergencyContact: input.emergencyContact,
+			documents: input.documents ?? [],
+			salary: input.salary,
+			notes: input.notes
+		};
+		const title = `${input.firstName} ${input.lastName}`;
+		const employee = await this.employeesCollection.create({
+			title,
+			status: input.status === "terminated" ? "draft" : "published",
+			data: employeeData
+		}, authorId);
+		if (input.departmentSlug) {
+			const term = await this.engine.taxonomies.getTermBySlug(this.departmentsTaxonomy, input.departmentSlug);
+			if (term) await this.engine.taxonomies.assignTerms(employee.id, [term.id]);
+		}
+		await this.engine.hooks.doAction("hrms.employee_created", employee);
+		return employee;
+	}
+	async getEmployee(id) {
+		return this.employeesCollection.findById(id);
+	}
+	async getEmployeeByNumber(employerId, employeeNumber) {
+		return (await this.employeesCollection.find({ limit: 500 })).items.find((e) => e.data.employerId === employerId && e.data.employeeNumber === employeeNumber) ?? null;
+	}
+	async updateEmployee(id, input, authorId) {
+		const existing = await this.getEmployee(id);
+		if (!existing) return null;
+		const updatedData = {
+			...existing.data,
+			...input.employerId !== void 0 ? { employerId: input.employerId } : {},
+			...input.userId !== void 0 ? { userId: input.userId } : {},
+			...input.employeeNumber !== void 0 ? { employeeNumber: input.employeeNumber } : {},
+			...input.firstName !== void 0 ? { firstName: input.firstName } : {},
+			...input.lastName !== void 0 ? { lastName: input.lastName } : {},
+			...input.email !== void 0 ? { email: input.email } : {},
+			...input.phone !== void 0 ? { phone: input.phone } : {},
+			...input.avatar !== void 0 ? { avatar: input.avatar } : {},
+			...input.jobTitle !== void 0 ? { jobTitle: input.jobTitle } : {},
+			...input.employmentType !== void 0 ? { employmentType: input.employmentType } : {},
+			...input.status !== void 0 ? { status: input.status } : {},
+			...input.hireDate !== void 0 ? { hireDate: input.hireDate } : {},
+			...input.terminationDate !== void 0 ? { terminationDate: input.terminationDate } : {},
+			...input.managerId !== void 0 ? { managerId: input.managerId } : {},
+			...input.emergencyContact !== void 0 ? { emergencyContact: input.emergencyContact } : {},
+			...input.documents !== void 0 ? { documents: input.documents } : {},
+			...input.salary !== void 0 ? { salary: input.salary } : {},
+			...input.notes !== void 0 ? { notes: input.notes } : {}
+		};
+		const title = input.firstName || input.lastName ? `${updatedData.firstName} ${updatedData.lastName}` : existing.title;
+		const updated = await this.employeesCollection.update(id, {
+			title,
+			data: updatedData
+		}, authorId);
+		if (updated) {
+			if (input.departmentSlug) {
+				const term = await this.engine.taxonomies.getTermBySlug(this.departmentsTaxonomy, input.departmentSlug);
+				if (term) await this.engine.taxonomies.assignTerms(id, [term.id]);
+			}
+			await this.engine.hooks.doAction("hrms.employee_updated", updated);
+		}
+		return updated;
+	}
+	async deleteEmployee(id) {
+		const deleted = await this.employeesCollection.delete(id);
+		if (deleted) await this.engine.hooks.doAction("hrms.employee_deleted", id);
+		return deleted;
+	}
+	async listEmployees(query = {}) {
+		const limit = query.limit ?? 20;
+		const offset = query.page ? (query.page - 1) * limit : 0;
+		let termIds;
+		if (query.department) {
+			const term = await this.engine.taxonomies.getTermBySlug(this.departmentsTaxonomy, query.department);
+			if (term) termIds = [term.id];
+			else return {
+				items: [],
+				total: 0,
+				limit,
+				offset,
+				hasMore: false
+			};
+		}
+		let items = (await this.employeesCollection.find({
+			termIds,
+			limit: 1e3
+		})).items;
+		if (query.employerId) items = items.filter((e) => e.data.employerId === query.employerId);
+		if (query.employmentType) items = items.filter((e) => e.data.employmentType === query.employmentType);
+		if (query.status) items = items.filter((e) => e.data.status === query.status);
+		if (query.search) {
+			const s = query.search.toLowerCase();
+			items = items.filter((e) => e.data.firstName.toLowerCase().includes(s) || e.data.lastName.toLowerCase().includes(s) || e.data.email.toLowerCase().includes(s) || e.data.employeeNumber.toLowerCase().includes(s) || e.data.jobTitle && e.data.jobTitle.toLowerCase().includes(s));
+		}
+		const total = items.length;
+		return {
+			items: items.slice(offset, offset + limit),
+			total,
+			limit,
+			offset,
+			hasMore: offset + limit < total
+		};
+	}
+	async getDirectReports(managerId) {
+		return (await this.employeesCollection.find({ limit: 1e3 })).items.filter((e) => e.data.managerId === managerId);
+	}
+	parseTimeToMinutes(timeStr) {
+		const [hours, minutes] = timeStr.split(":").map((v) => parseInt(v, 10));
+		return (hours || 0) * 60 + (minutes || 0);
+	}
+	formatDateString(date, timezone) {
+		if (!timezone || timezone === "UTC") return date.toISOString().slice(0, 10);
+		try {
+			return new Intl.DateTimeFormat("en-CA", {
+				timeZone: timezone,
+				year: "numeric",
+				month: "2-digit",
+				day: "2-digit"
+			}).format(date);
+		} catch {
+			return date.toISOString().slice(0, 10);
+		}
+	}
+	getHoursAndMinutes(date, timezone) {
+		if (!timezone || timezone === "UTC") return {
+			hours: date.getUTCHours(),
+			minutes: date.getUTCMinutes()
+		};
+		try {
+			const parts = new Intl.DateTimeFormat("en-US", {
+				timeZone: timezone,
+				hour: "numeric",
+				minute: "numeric",
+				hour12: false
+			}).formatToParts(date);
+			const hoursPart = parts.find((p) => p.type === "hour");
+			const minutesPart = parts.find((p) => p.type === "minute");
+			return {
+				hours: hoursPart ? parseInt(hoursPart.value, 10) : date.getUTCHours(),
+				minutes: minutesPart ? parseInt(minutesPart.value, 10) : date.getUTCMinutes()
+			};
+		} catch {
+			return {
+				hours: date.getUTCHours(),
+				minutes: date.getUTCMinutes()
+			};
+		}
+	}
+	/**
+	* Check in an employee for today (or specified timestamp).
+	*/
+	async checkIn(input) {
+		const employee = await this.getEmployee(input.employeeId);
+		if (!employee) throw new Error(`[HRMSService] Employee with ID '${input.employeeId}' not found.`);
+		const employer = await this.getEmployer(employee.data.employerId);
+		const timezone = employer?.data?.timezone ?? "UTC";
+		const checkInDate = input.timestamp ? new Date(input.timestamp) : /* @__PURE__ */ new Date();
+		const dateStr = this.formatDateString(checkInDate, timezone);
+		const existing = await this.getDailyAttendance(employee.id, dateStr);
+		if (existing && existing.data.checkInAt) throw new Error(`[HRMSService] Employee '${employee.id}' is already checked in for date ${dateStr}.`);
+		const schedule = employer?.data?.workSchedule;
+		const schedStart = schedule?.startTime ?? this.workScheduleStart;
+		const grace = schedule?.gracePeriodMinutes ?? this.gracePeriodMinutes;
+		const schedMinutes = this.parseTimeToMinutes(schedStart);
+		const { hours: punchHours, minutes: punchMins } = this.getHoursAndMinutes(checkInDate, timezone);
+		const status = punchHours * 60 + punchMins > schedMinutes + grace ? "late" : "present";
+		const attendanceData = {
+			employerId: employee.data.employerId,
+			employeeId: employee.id,
+			date: dateStr,
+			checkInAt: checkInDate.toISOString(),
+			totalHours: 0,
+			overtimeHours: 0,
+			status,
+			location: input.location,
+			notes: input.notes
+		};
+		const attendance = await this.attendanceCollection.create({
+			title: `${employee.title} - ${dateStr}`,
+			status: "published",
+			data: attendanceData
+		});
+		await this.engine.hooks.doAction("hrms.checked_in", attendance, employee);
+		return attendance;
+	}
+	/**
+	* Check out an employee for today (or specified timestamp).
+	*/
+	async checkOut(input) {
+		const employee = await this.getEmployee(input.employeeId);
+		if (!employee) throw new Error(`[HRMSService] Employee with ID '${input.employeeId}' not found.`);
+		const employer = await this.getEmployer(employee.data.employerId);
+		const timezone = employer?.data?.timezone ?? "UTC";
+		const checkOutDate = input.timestamp ? new Date(input.timestamp) : /* @__PURE__ */ new Date();
+		const dateStr = this.formatDateString(checkOutDate, timezone);
+		const record = await this.getDailyAttendance(employee.id, dateStr);
+		if (!record || !record.data.checkInAt) throw new Error(`[HRMSService] No active check-in record found for employee '${employee.id}' on ${dateStr}.`);
+		if (record.data.checkOutAt) throw new Error(`[HRMSService] Employee '${employee.id}' has already checked out for date ${dateStr}.`);
+		const checkInDate = new Date(record.data.checkInAt);
+		const durationMs = Math.max(0, checkOutDate.getTime() - checkInDate.getTime());
+		const totalHours = Math.round(durationMs / (1e3 * 60 * 60) * 100) / 100;
+		const standardHours = employer?.data?.workSchedule?.standardHoursPerDay ?? this.standardWorkDayHours;
+		const overtimeHours = Math.max(0, Math.round((totalHours - standardHours) * 100) / 100);
+		let status = record.data.status;
+		if (totalHours < standardHours / 2 && status === "present") status = "half_day";
+		const updatedData = {
+			...record.data,
+			checkOutAt: checkOutDate.toISOString(),
+			totalHours,
+			overtimeHours,
+			status,
+			...input.location ? { location: input.location } : {},
+			...input.notes ? { notes: input.notes } : {}
+		};
+		const updated = await this.attendanceCollection.update(record.id, { data: updatedData });
+		if (!updated) throw new Error(`[HRMSService] Failed to update attendance record for '${employee.id}'.`);
+		await this.engine.hooks.doAction("hrms.checked_out", updated, employee);
+		return updated;
+	}
+	async getDailyAttendance(employeeId, date) {
+		return (await this.attendanceCollection.find({ limit: 1e3 })).items.find((a) => a.data.employeeId === employeeId && a.data.date === date) ?? null;
+	}
+	async recordAttendanceManual(input) {
+		const existing = await this.getDailyAttendance(input.employeeId, input.date);
+		const attendanceData = {
+			employerId: input.employerId,
+			employeeId: input.employeeId,
+			date: input.date,
+			checkInAt: input.checkInAt,
+			checkOutAt: input.checkOutAt,
+			totalHours: input.totalHours ?? 0,
+			overtimeHours: input.overtimeHours ?? 0,
+			status: input.status ?? "present",
+			location: input.location,
+			notes: input.notes
+		};
+		if (existing) {
+			const updated = await this.attendanceCollection.update(existing.id, { data: attendanceData });
+			if (!updated) throw new Error(`[HRMSService] Failed to update attendance for '${input.employeeId}'.`);
+			return updated;
+		}
+		return this.attendanceCollection.create({
+			title: `${input.employeeId} - ${input.date}`,
+			status: "published",
+			data: attendanceData
+		});
+	}
+	async listAttendance(query = {}) {
+		const limit = query.limit ?? 30;
+		const offset = query.page ? (query.page - 1) * limit : 0;
+		let items = (await this.attendanceCollection.find({ limit: 2e3 })).items;
+		if (query.employerId) items = items.filter((a) => a.data.employerId === query.employerId);
+		if (query.employeeId) items = items.filter((a) => a.data.employeeId === query.employeeId);
+		if (query.date) items = items.filter((a) => a.data.date === query.date);
+		if (query.startDate) items = items.filter((a) => a.data.date >= query.startDate);
+		if (query.endDate) items = items.filter((a) => a.data.date <= query.endDate);
+		if (query.status) items = items.filter((a) => a.data.status === query.status);
+		const total = items.length;
+		return {
+			items: items.slice(offset, offset + limit),
+			total,
+			limit,
+			offset,
+			hasMore: offset + limit < total
+		};
+	}
+	async createLeaveType(input, authorId) {
+		const leaveTypeData = {
+			employerId: input.employerId,
+			name: input.name,
+			code: input.code.toUpperCase(),
+			daysAllowedPerYear: input.daysAllowedPerYear,
+			paid: input.paid ?? true,
+			requiresApproval: input.requiresApproval ?? true,
+			color: input.color,
+			description: input.description
+		};
+		const item = await this.leaveTypesCollection.create({
+			title: input.name,
+			status: "published",
+			data: leaveTypeData
+		}, authorId);
+		await this.engine.hooks.doAction("hrms.leave_type_created", item);
+		return item;
+	}
+	async getLeaveType(id) {
+		return this.leaveTypesCollection.findById(id);
+	}
+	async listLeaveTypes(employerId) {
+		const result = await this.leaveTypesCollection.find({ limit: 100 });
+		if (!employerId) return result.items;
+		return result.items.filter((lt) => !lt.data.employerId || lt.data.employerId === employerId);
+	}
+	/**
+	* Calculate leave balance report for an employee for a given year.
+	*/
+	async calculateLeaveBalance(employeeId, year) {
+		const targetYear = year ?? (/* @__PURE__ */ new Date()).getFullYear();
+		const employee = await this.getEmployee(employeeId);
+		if (!employee) throw new Error(`[HRMSService] Employee with ID '${employeeId}' not found.`);
+		const leaveTypes = await this.listLeaveTypes(employee.data.employerId);
+		const allRequests = await this.leaveRequestsCollection.find({ limit: 1e3 });
+		const yearStr = String(targetYear);
+		const employeeRequests = allRequests.items.filter((r) => r.data.employeeId === employeeId && (r.data.startDate.startsWith(yearStr) || r.data.endDate.startsWith(yearStr)));
+		const balances = leaveTypes.map((lt) => {
+			const approved = employeeRequests.filter((r) => r.data.leaveTypeId === lt.id && r.data.status === "approved");
+			const pending = employeeRequests.filter((r) => r.data.leaveTypeId === lt.id && r.data.status === "pending");
+			const usedDays = approved.reduce((sum, r) => sum + (r.data.daysCount || 0), 0);
+			const pendingDays = pending.reduce((sum, r) => sum + (r.data.daysCount || 0), 0);
+			const allocatedDays = lt.data.daysAllowedPerYear ?? 0;
+			const remainingDays = Math.max(0, allocatedDays - usedDays);
+			return {
+				leaveTypeId: lt.id,
+				leaveTypeName: lt.data.name,
+				leaveTypeCode: lt.data.code,
+				allocatedDays,
+				usedDays,
+				pendingDays,
+				remainingDays
+			};
+		});
+		const report = {
+			employeeId,
+			year: targetYear,
+			balances,
+			totalAllocated: balances.reduce((sum, b) => sum + b.allocatedDays, 0),
+			totalUsed: balances.reduce((sum, b) => sum + b.usedDays, 0),
+			totalRemaining: balances.reduce((sum, b) => sum + b.remainingDays, 0)
+		};
+		return this.engine.hooks.applyFilters("hrms.calculate_leave_balance", report, employeeId, targetYear);
+	}
+	/**
+	* Submit a new leave request.
+	*/
+	async requestLeave(input, authorId) {
+		const employee = await this.getEmployee(input.employeeId);
+		if (!employee) throw new Error(`[HRMSService] Employee with ID '${input.employeeId}' not found.`);
+		const leaveType = await this.getLeaveType(input.leaveTypeId);
+		if (!leaveType) throw new Error(`[HRMSService] Leave type with ID '${input.leaveTypeId}' not found.`);
+		if (input.startDate > input.endDate) throw new Error(`[HRMSService] Start date '${input.startDate}' cannot be after end date '${input.endDate}'.`);
+		const start = new Date(input.startDate);
+		const end = new Date(input.endDate);
+		const calculatedDays = Math.max(1, Math.round((end.getTime() - start.getTime()) / (1e3 * 60 * 60 * 24)) + 1);
+		const daysCount = input.daysCount ?? calculatedDays;
+		const startYear = start.getFullYear();
+		const balance = (await this.calculateLeaveBalance(employee.id, startYear)).balances.find((b) => b.leaveTypeId === leaveType.id);
+		if (balance && leaveType.data.requiresApproval && daysCount > balance.remainingDays) throw new Error(`[HRMSService] Insufficient leave balance for ${leaveType.data.name}. Requested: ${daysCount}, Remaining: ${balance.remainingDays}.`);
+		const leaveRequestData = {
+			employerId: input.employerId ?? employee.data.employerId,
+			employeeId: employee.id,
+			leaveTypeId: leaveType.id,
+			startDate: input.startDate,
+			endDate: input.endDate,
+			daysCount,
+			reason: input.reason,
+			status: "pending"
+		};
+		const item = await this.leaveRequestsCollection.create({
+			title: `${employee.title} - ${leaveType.data.name} (${input.startDate})`,
+			status: "published",
+			data: leaveRequestData
+		}, authorId);
+		await this.engine.hooks.doAction("hrms.leave_requested", item, employee);
+		return item;
+	}
+	/**
+	* Approve a pending leave request.
+	*/
+	async approveLeave(input) {
+		const request = await this.leaveRequestsCollection.findById(input.requestId);
+		if (!request) throw new Error(`[HRMSService] Leave request with ID '${input.requestId}' not found.`);
+		if (request.data.status !== "pending") throw new Error(`[HRMSService] Cannot approve leave request with status '${request.data.status}'.`);
+		const updated = await this.leaveRequestsCollection.update(request.id, { data: {
+			...request.data,
+			status: "approved",
+			approvedBy: input.approverId,
+			approvedAt: (/* @__PURE__ */ new Date()).toISOString()
+		} });
+		if (!updated) throw new Error(`[HRMSService] Failed to update leave request.`);
+		await this.engine.hooks.doAction("hrms.leave_approved", updated);
+		return updated;
+	}
+	/**
+	* Reject a pending leave request.
+	*/
+	async rejectLeave(input) {
+		const request = await this.leaveRequestsCollection.findById(input.requestId);
+		if (!request) throw new Error(`[HRMSService] Leave request with ID '${input.requestId}' not found.`);
+		if (request.data.status !== "pending") throw new Error(`[HRMSService] Cannot reject leave request with status '${request.data.status}'.`);
+		const updated = await this.leaveRequestsCollection.update(request.id, { data: {
+			...request.data,
+			status: "rejected",
+			approvedBy: input.approverId,
+			rejectionReason: input.reason,
+			approvedAt: (/* @__PURE__ */ new Date()).toISOString()
+		} });
+		if (!updated) throw new Error(`[HRMSService] Failed to update leave request.`);
+		await this.engine.hooks.doAction("hrms.leave_rejected", updated);
+		return updated;
+	}
+	/**
+	* Cancel a leave request.
+	*/
+	async cancelLeave(requestId) {
+		const request = await this.leaveRequestsCollection.findById(requestId);
+		if (!request) throw new Error(`[HRMSService] Leave request with ID '${requestId}' not found.`);
+		if (request.data.status === "cancelled") return request;
+		const updated = await this.leaveRequestsCollection.update(request.id, { data: {
+			...request.data,
+			status: "cancelled"
+		} });
+		if (!updated) throw new Error(`[HRMSService] Failed to cancel leave request.`);
+		await this.engine.hooks.doAction("hrms.leave_cancelled", updated);
+		return updated;
+	}
+	async listLeaveRequests(query = {}) {
+		const limit = query.limit ?? 20;
+		const offset = query.page ? (query.page - 1) * limit : 0;
+		let items = (await this.leaveRequestsCollection.find({ limit: 1e3 })).items;
+		if (query.employerId) items = items.filter((r) => r.data.employerId === query.employerId);
+		if (query.employeeId) items = items.filter((r) => r.data.employeeId === query.employeeId);
+		if (query.leaveTypeId) items = items.filter((r) => r.data.leaveTypeId === query.leaveTypeId);
+		if (query.status) items = items.filter((r) => r.data.status === query.status);
+		if (query.year) {
+			const yearStr = String(query.year);
+			items = items.filter((r) => r.data.startDate.startsWith(yearStr) || r.data.endDate.startsWith(yearStr));
+		}
+		const total = items.length;
+		return {
+			items: items.slice(offset, offset + limit),
+			total,
+			limit,
+			offset,
+			hasMore: offset + limit < total
+		};
+	}
+};
+//#endregion
+//#region src/plugins/hrms/routes.ts
+function json$1(data, status = 200) {
+	return new Response(JSON.stringify(data), {
+		status,
+		headers: {
+			"Content-Type": "application/json",
+			"Access-Control-Allow-Origin": "*"
+		}
+	});
+}
+function badRequest$1(message) {
+	return json$1({ error: message }, 400);
+}
+function notFound$1(message) {
+	return json$1({ error: message }, 404);
+}
+function registerHRMSRoutes(ctx, service, options = {}) {
+	const prefix = (options.apiPrefix ?? "/api/hrms").replace(/\/+$/, "");
+	ctx.registerRoute("GET", `${prefix}/employers`, async (_req, { url }) => {
+		try {
+			const status = url.searchParams.get("status");
+			const pageStr = url.searchParams.get("page");
+			const limitStr = url.searchParams.get("limit");
+			const page = pageStr ? parseInt(pageStr, 10) : void 0;
+			const limit = limitStr ? parseInt(limitStr, 10) : void 0;
+			return json$1(await service.listEmployers({
+				status,
+				page,
+				limit
+			}));
+		} catch (err) {
+			return badRequest$1(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("POST", `${prefix}/employers`, async (req) => {
+		try {
+			const body = await req.json();
+			if (!body.companyName) return badRequest$1("companyName is required.");
+			return json$1(await service.createEmployer(body), 201);
+		} catch (err) {
+			return badRequest$1(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("GET", `${prefix}/employers/:id`, async (_req, { params }) => {
+		try {
+			const employer = await service.getEmployer(params.id);
+			if (!employer) return notFound$1(`Employer '${params.id}' not found.`);
+			return json$1(employer);
+		} catch (err) {
+			return badRequest$1(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("PUT", `${prefix}/employers/:id`, async (req, { params }) => {
+		try {
+			const body = await req.json();
+			const updated = await service.updateEmployer(params.id, body);
+			if (!updated) return notFound$1(`Employer '${params.id}' not found.`);
+			return json$1(updated);
+		} catch (err) {
+			return badRequest$1(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("GET", `${prefix}/employees`, async (_req, { url }) => {
+		try {
+			const employerId = url.searchParams.get("employerId") ?? void 0;
+			const department = url.searchParams.get("department") ?? void 0;
+			const employmentType = url.searchParams.get("employmentType");
+			const status = url.searchParams.get("status");
+			const search = url.searchParams.get("search") ?? void 0;
+			const pageStr = url.searchParams.get("page");
+			const limitStr = url.searchParams.get("limit");
+			const page = pageStr ? parseInt(pageStr, 10) : void 0;
+			const limit = limitStr ? parseInt(limitStr, 10) : void 0;
+			return json$1(await service.listEmployees({
+				employerId,
+				department,
+				employmentType,
+				status,
+				search,
+				page,
+				limit
+			}));
+		} catch (err) {
+			return badRequest$1(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("POST", `${prefix}/employees`, async (req) => {
+		try {
+			const body = await req.json();
+			if (!body.employerId) return badRequest$1("employerId is required.");
+			if (!body.employeeNumber) return badRequest$1("employeeNumber is required.");
+			if (!body.firstName || !body.lastName) return badRequest$1("firstName and lastName are required.");
+			if (!body.email) return badRequest$1("email is required.");
+			return json$1(await service.createEmployee(body), 201);
+		} catch (err) {
+			return badRequest$1(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("GET", `${prefix}/employees/:id`, async (_req, { params }) => {
+		try {
+			const employee = await service.getEmployee(params.id);
+			if (!employee) return notFound$1(`Employee '${params.id}' not found.`);
+			return json$1(employee);
+		} catch (err) {
+			return badRequest$1(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("PUT", `${prefix}/employees/:id`, async (req, { params }) => {
+		try {
+			const body = await req.json();
+			const updated = await service.updateEmployee(params.id, body);
+			if (!updated) return notFound$1(`Employee '${params.id}' not found.`);
+			return json$1(updated);
+		} catch (err) {
+			return badRequest$1(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("DELETE", `${prefix}/employees/:id`, async (_req, { params }) => {
+		try {
+			if (!await service.deleteEmployee(params.id)) return notFound$1(`Employee '${params.id}' not found.`);
+			return json$1({ success: true });
+		} catch (err) {
+			return badRequest$1(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("GET", `${prefix}/employees/:id/leave-balance`, async (_req, { params, url }) => {
+		try {
+			const yearStr = url.searchParams.get("year");
+			const year = yearStr ? parseInt(yearStr, 10) : void 0;
+			return json$1(await service.calculateLeaveBalance(params.id, year));
+		} catch (err) {
+			return badRequest$1(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("GET", `${prefix}/employees/:id/direct-reports`, async (_req, { params }) => {
+		try {
+			const reports = await service.getDirectReports(params.id);
+			return json$1({
+				items: reports,
+				total: reports.length
+			});
+		} catch (err) {
+			return badRequest$1(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("POST", `${prefix}/attendance/check-in`, async (req) => {
+		try {
+			const body = await req.json();
+			if (!body.employeeId) return badRequest$1("employeeId is required.");
+			return json$1(await service.checkIn(body), 201);
+		} catch (err) {
+			return badRequest$1(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("POST", `${prefix}/attendance/check-out`, async (req) => {
+		try {
+			const body = await req.json();
+			if (!body.employeeId) return badRequest$1("employeeId is required.");
+			return json$1(await service.checkOut(body));
+		} catch (err) {
+			return badRequest$1(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("GET", `${prefix}/attendance`, async (_req, { url }) => {
+		try {
+			const employerId = url.searchParams.get("employerId") ?? void 0;
+			const employeeId = url.searchParams.get("employeeId") ?? void 0;
+			const date = url.searchParams.get("date") ?? void 0;
+			const startDate = url.searchParams.get("startDate") ?? void 0;
+			const endDate = url.searchParams.get("endDate") ?? void 0;
+			const status = url.searchParams.get("status");
+			const pageStr = url.searchParams.get("page");
+			const limitStr = url.searchParams.get("limit");
+			const page = pageStr ? parseInt(pageStr, 10) : void 0;
+			const limit = limitStr ? parseInt(limitStr, 10) : void 0;
+			return json$1(await service.listAttendance({
+				employerId,
+				employeeId,
+				date,
+				startDate,
+				endDate,
+				status,
+				page,
+				limit
+			}));
+		} catch (err) {
+			return badRequest$1(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("POST", `${prefix}/attendance/manual`, async (req) => {
+		try {
+			const body = await req.json();
+			if (!body.employerId || !body.employeeId || !body.date || !body.checkInAt) return badRequest$1("employerId, employeeId, date, and checkInAt are required.");
+			return json$1(await service.recordAttendanceManual(body), 201);
+		} catch (err) {
+			return badRequest$1(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("GET", `${prefix}/leave-types`, async (_req, { url }) => {
+		try {
+			const employerId = url.searchParams.get("employerId") ?? void 0;
+			const types = await service.listLeaveTypes(employerId);
+			return json$1({
+				items: types,
+				total: types.length
+			});
+		} catch (err) {
+			return badRequest$1(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("POST", `${prefix}/leave-types`, async (req) => {
+		try {
+			const body = await req.json();
+			if (!body.name || !body.code || body.daysAllowedPerYear === void 0) return badRequest$1("name, code, and daysAllowedPerYear are required.");
+			return json$1(await service.createLeaveType(body), 201);
+		} catch (err) {
+			return badRequest$1(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("GET", `${prefix}/leave-types/:id`, async (_req, { params }) => {
+		try {
+			const leaveType = await service.getLeaveType(params.id);
+			if (!leaveType) return notFound$1(`Leave type '${params.id}' not found.`);
+			return json$1(leaveType);
+		} catch (err) {
+			return badRequest$1(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("GET", `${prefix}/leave-requests`, async (_req, { url }) => {
+		try {
+			const employerId = url.searchParams.get("employerId") ?? void 0;
+			const employeeId = url.searchParams.get("employeeId") ?? void 0;
+			const leaveTypeId = url.searchParams.get("leaveTypeId") ?? void 0;
+			const status = url.searchParams.get("status");
+			const yearStr = url.searchParams.get("year");
+			const year = yearStr ? parseInt(yearStr, 10) : void 0;
+			const pageStr = url.searchParams.get("page");
+			const limitStr = url.searchParams.get("limit");
+			const page = pageStr ? parseInt(pageStr, 10) : void 0;
+			const limit = limitStr ? parseInt(limitStr, 10) : void 0;
+			return json$1(await service.listLeaveRequests({
+				employerId,
+				employeeId,
+				leaveTypeId,
+				status,
+				year,
+				page,
+				limit
+			}));
+		} catch (err) {
+			return badRequest$1(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("POST", `${prefix}/leave-requests`, async (req) => {
+		try {
+			const body = await req.json();
+			if (!body.employeeId || !body.leaveTypeId || !body.startDate || !body.endDate) return badRequest$1("employeeId, leaveTypeId, startDate, and endDate are required.");
+			return json$1(await service.requestLeave(body), 201);
+		} catch (err) {
+			return badRequest$1(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("POST", `${prefix}/leave-requests/:id/approve`, async (req, { params }) => {
+		try {
+			const approverId = (await req.json().catch(() => ({}))).approverId ?? "admin";
+			return json$1(await service.approveLeave({
+				requestId: params.id,
+				approverId
+			}));
+		} catch (err) {
+			return badRequest$1(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("POST", `${prefix}/leave-requests/:id/reject`, async (req, { params }) => {
+		try {
+			const body = await req.json().catch(() => ({}));
+			const approverId = body.approverId ?? "admin";
+			return json$1(await service.rejectLeave({
+				requestId: params.id,
+				approverId,
+				reason: body.reason
+			}));
+		} catch (err) {
+			return badRequest$1(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("POST", `${prefix}/leave-requests/:id/cancel`, async (_req, { params }) => {
+		try {
+			return json$1(await service.cancelLeave(params.id));
+		} catch (err) {
+			return badRequest$1(err instanceof Error ? err.message : String(err));
+		}
+	});
+}
+//#endregion
+//#region src/plugins/hrms/client.ts
+var HRMSClient = class {
+	client;
+	options;
+	service;
+	prefix;
+	constructor(client, options = {}) {
+		this.client = client;
+		this.options = options;
+		this.prefix = (options.apiPrefix ?? "/api/hrms").replace(/\/+$/, "");
+		const engine = client.getEngine();
+		if (engine) this.service = new HRMSService(engine, options);
+	}
+	employers = {
+		find: async (query = {}) => {
+			if (this.service) return this.service.listEmployers(query);
+			const params = new URLSearchParams();
+			if (query.status) params.set("status", query.status);
+			if (query.page) params.set("page", String(query.page));
+			if (query.limit) params.set("limit", String(query.limit));
+			const q = params.toString() ? `?${params.toString()}` : "";
+			return this.client.request(`${this.prefix}/employers${q}`);
+		},
+		get: async (id) => {
+			if (this.service) return this.service.getEmployer(id);
+			return this.client.request(`${this.prefix}/employers/${encodeURIComponent(id)}`);
+		},
+		create: async (input) => {
+			if (this.service) return this.service.createEmployer(input);
+			return this.client.request(`${this.prefix}/employers`, {
+				method: "POST",
+				body: JSON.stringify(input)
+			});
+		},
+		update: async (id, input) => {
+			if (this.service) return this.service.updateEmployer(id, input);
+			return this.client.request(`${this.prefix}/employers/${encodeURIComponent(id)}`, {
+				method: "PUT",
+				body: JSON.stringify(input)
+			});
+		}
+	};
+	employees = {
+		find: async (query = {}) => {
+			if (this.service) return this.service.listEmployees(query);
+			const params = new URLSearchParams();
+			if (query.employerId) params.set("employerId", query.employerId);
+			if (query.department) params.set("department", query.department);
+			if (query.employmentType) params.set("employmentType", query.employmentType);
+			if (query.status) params.set("status", query.status);
+			if (query.search) params.set("search", query.search);
+			if (query.page) params.set("page", String(query.page));
+			if (query.limit) params.set("limit", String(query.limit));
+			const q = params.toString() ? `?${params.toString()}` : "";
+			return this.client.request(`${this.prefix}/employees${q}`);
+		},
+		get: async (id) => {
+			if (this.service) return this.service.getEmployee(id);
+			return this.client.request(`${this.prefix}/employees/${encodeURIComponent(id)}`);
+		},
+		getByNumber: async (employerId, employeeNumber) => {
+			if (this.service) return this.service.getEmployeeByNumber(employerId, employeeNumber);
+			return (await this.employees.find({
+				employerId,
+				search: employeeNumber
+			})).items.find((e) => e.data.employeeNumber === employeeNumber) ?? null;
+		},
+		create: async (input) => {
+			if (this.service) return this.service.createEmployee(input);
+			return this.client.request(`${this.prefix}/employees`, {
+				method: "POST",
+				body: JSON.stringify(input)
+			});
+		},
+		update: async (id, input) => {
+			if (this.service) return this.service.updateEmployee(id, input);
+			return this.client.request(`${this.prefix}/employees/${encodeURIComponent(id)}`, {
+				method: "PUT",
+				body: JSON.stringify(input)
+			});
+		},
+		delete: async (id) => {
+			if (this.service) return this.service.deleteEmployee(id);
+			return (await this.client.request(`${this.prefix}/employees/${encodeURIComponent(id)}`, { method: "DELETE" })).success;
+		},
+		getLeaveBalance: async (employeeId, year) => {
+			if (this.service) return this.service.calculateLeaveBalance(employeeId, year);
+			const q = year ? `?year=${year}` : "";
+			return this.client.request(`${this.prefix}/employees/${encodeURIComponent(employeeId)}/leave-balance${q}`);
+		},
+		getDirectReports: async (managerId) => {
+			if (this.service) return this.service.getDirectReports(managerId);
+			return (await this.client.request(`${this.prefix}/employees/${encodeURIComponent(managerId)}/direct-reports`)).items;
+		}
+	};
+	attendance = {
+		checkIn: async (input) => {
+			if (this.service) return this.service.checkIn(input);
+			return this.client.request(`${this.prefix}/attendance/check-in`, {
+				method: "POST",
+				body: JSON.stringify(input)
+			});
+		},
+		checkOut: async (input) => {
+			if (this.service) return this.service.checkOut(input);
+			return this.client.request(`${this.prefix}/attendance/check-out`, {
+				method: "POST",
+				body: JSON.stringify(input)
+			});
+		},
+		getDaily: async (employeeId, date) => {
+			if (this.service) return this.service.getDailyAttendance(employeeId, date);
+			return (await this.attendance.find({
+				employeeId,
+				date
+			})).items[0] ?? null;
+		},
+		find: async (query = {}) => {
+			if (this.service) return this.service.listAttendance(query);
+			const params = new URLSearchParams();
+			if (query.employerId) params.set("employerId", query.employerId);
+			if (query.employeeId) params.set("employeeId", query.employeeId);
+			if (query.date) params.set("date", query.date);
+			if (query.startDate) params.set("startDate", query.startDate);
+			if (query.endDate) params.set("endDate", query.endDate);
+			if (query.status) params.set("status", query.status);
+			if (query.page) params.set("page", String(query.page));
+			if (query.limit) params.set("limit", String(query.limit));
+			const q = params.toString() ? `?${params.toString()}` : "";
+			return this.client.request(`${this.prefix}/attendance${q}`);
+		},
+		recordManual: async (input) => {
+			if (this.service) return this.service.recordAttendanceManual(input);
+			return this.client.request(`${this.prefix}/attendance/manual`, {
+				method: "POST",
+				body: JSON.stringify(input)
+			});
+		}
+	};
+	leaves = {
+		listTypes: async (employerId) => {
+			if (this.service) return this.service.listLeaveTypes(employerId);
+			const q = employerId ? `?employerId=${encodeURIComponent(employerId)}` : "";
+			return (await this.client.request(`${this.prefix}/leave-types${q}`)).items;
+		},
+		createType: async (input) => {
+			if (this.service) return this.service.createLeaveType(input);
+			return this.client.request(`${this.prefix}/leave-types`, {
+				method: "POST",
+				body: JSON.stringify(input)
+			});
+		},
+		getType: async (id) => {
+			if (this.service) return this.service.getLeaveType(id);
+			return this.client.request(`${this.prefix}/leave-types/${encodeURIComponent(id)}`);
+		},
+		findRequests: async (query = {}) => {
+			if (this.service) return this.service.listLeaveRequests(query);
+			const params = new URLSearchParams();
+			if (query.employerId) params.set("employerId", query.employerId);
+			if (query.employeeId) params.set("employeeId", query.employeeId);
+			if (query.leaveTypeId) params.set("leaveTypeId", query.leaveTypeId);
+			if (query.status) params.set("status", query.status);
+			if (query.year) params.set("year", String(query.year));
+			if (query.page) params.set("page", String(query.page));
+			if (query.limit) params.set("limit", String(query.limit));
+			const q = params.toString() ? `?${params.toString()}` : "";
+			return this.client.request(`${this.prefix}/leave-requests${q}`);
+		},
+		request: async (input) => {
+			if (this.service) return this.service.requestLeave(input);
+			return this.client.request(`${this.prefix}/leave-requests`, {
+				method: "POST",
+				body: JSON.stringify(input)
+			});
+		},
+		approve: async (input) => {
+			if (this.service) return this.service.approveLeave(input);
+			return this.client.request(`${this.prefix}/leave-requests/${encodeURIComponent(input.requestId)}/approve`, {
+				method: "POST",
+				body: JSON.stringify({ approverId: input.approverId })
+			});
+		},
+		reject: async (input) => {
+			if (this.service) return this.service.rejectLeave(input);
+			return this.client.request(`${this.prefix}/leave-requests/${encodeURIComponent(input.requestId)}/reject`, {
+				method: "POST",
+				body: JSON.stringify({
+					approverId: input.approverId,
+					reason: input.reason
+				})
+			});
+		},
+		cancel: async (requestId) => {
+			if (this.service) return this.service.cancelLeave(requestId);
+			return this.client.request(`${this.prefix}/leave-requests/${encodeURIComponent(requestId)}/cancel`, { method: "POST" });
+		}
+	};
+};
+/**
+* Get or create an HRMSClient adapter for a CMSClient.
+*/
+function getHRMSClient(client, options) {
+	return new HRMSClient(client, options);
+}
+//#endregion
+//#region src/plugins/hrms/index.ts
+/**
+* @azlib/cms - Built-in HRMS Plugin
+*/
+/**
+* Built-in HRMS plugin factory for @azlib/cms.
+* Equips the CMS engine with multi-tenant employers, employee profiles,
+* daily attendance check-in/out tracking, and leave quota approval workflows.
+*/
+const hrmsPlugin = definePlugin((options) => {
+	const opts = options || {};
+	const collections = [createEmployeeCollection(opts)];
+	if (opts.enableEmployers !== false) collections.unshift(createEmployerCollection(opts));
+	if (opts.enableAttendance !== false) collections.push(createAttendanceCollection(opts));
+	if (opts.enableLeaves !== false) {
+		collections.push(createLeaveTypeCollection(opts));
+		collections.push(createLeaveRequestCollection(opts));
+	}
+	return {
+		name: "hrms",
+		version: "1.0.0",
+		description: "Built-in Human Resource Management System (HRMS) plugin for employers, employees, attendance, and leave management",
+		collections,
+		taxonomies: createHRMSTaxonomies(opts),
+		setup(ctx) {
+			const service = new HRMSService(ctx.engine, opts);
+			ctx.engine.__hrmsService = service;
+			registerHRMSRoutes(ctx, service, opts);
+		}
+	};
+});
+/**
+* Retrieve the active HRMSService instance associated with a CMSEngine.
+*/
+function getHRMSService(engine, options) {
+	if (engine.__hrmsService) return engine.__hrmsService;
+	const service = new HRMSService(engine, options);
+	engine.__hrmsService = service;
+	return service;
+}
+//#endregion
+//#region src/plugins/transfer/parsers/json.ts
+/**
+* @azlib/cms - Universal JSON Data Parser
+*/
+function parseJsonSource(input) {
+	if (Array.isArray(input)) return input.filter((item) => Boolean(item && typeof item === "object" && !Array.isArray(item)));
+	let text;
+	if (typeof input === "string") text = input.trim();
+	else if (input instanceof Uint8Array || Buffer.isBuffer(input)) text = new TextDecoder("utf-8").decode(input).trim();
+	else if (input && typeof input === "object") {
+		const obj = input;
+		if (Array.isArray(obj.data)) return parseJsonSource(obj.data);
+		if (Array.isArray(obj.items)) return parseJsonSource(obj.items);
+		return [obj];
+	} else throw new Error("[TransferParser] Invalid JSON input: expected string, buffer, or array.");
+	if (text.charCodeAt(0) === 65279) text = text.slice(1);
+	if (!text) return [];
+	try {
+		const parsed = JSON.parse(text);
+		if (Array.isArray(parsed)) return parsed.filter((item) => Boolean(item && typeof item === "object" && !Array.isArray(item)));
+		if (parsed && typeof parsed === "object") {
+			if (Array.isArray(parsed.data)) return parseJsonSource(parsed.data);
+			if (Array.isArray(parsed.items)) return parseJsonSource(parsed.items);
+			return [parsed];
+		}
+		return [];
+	} catch {
+		const lines = text.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+		const records = [];
+		for (const line of lines) try {
+			const item = JSON.parse(line);
+			if (item && typeof item === "object" && !Array.isArray(item)) records.push(item);
+		} catch (err) {
+			throw new Error(`[TransferParser] Failed to parse JSON source: ${err instanceof Error ? err.message : String(err)}`);
+		}
+		return records;
+	}
+}
+//#endregion
+//#region src/plugins/transfer/parsers/csv.ts
+/**
+* @azlib/cms - Universal RFC 4180 CSV Data Parser
+*/
+function parseCsvSource(input) {
+	let text;
+	if (typeof input === "string") text = input;
+	else if (input instanceof Uint8Array || Buffer.isBuffer(input)) text = new TextDecoder("utf-8").decode(input);
+	else throw new Error("[TransferParser] Invalid CSV input: expected string or buffer.");
+	if (text.charCodeAt(0) === 65279) text = text.slice(1);
+	const rows = parseCsvRows(text);
+	if (rows.length === 0) return [];
+	const headers = rows[0].map((h, i) => {
+		return h.trim() || `column_${i + 1}`;
+	});
+	const records = [];
+	for (let r = 1; r < rows.length; r++) {
+		const row = rows[r];
+		if (row.length === 0 || row.length === 1 && row[0].trim() === "") continue;
+		const record = {};
+		for (let c = 0; c < headers.length; c++) {
+			const header = headers[c];
+			record[header] = coerceCsvValue(c < row.length ? row[c].trim() : "");
+		}
+		records.push(record);
+	}
+	return records;
+}
+/**
+* Tokenize CSV into 2D array of string cells following RFC 4180.
+*/
+function parseCsvRows(text) {
+	const rows = [];
+	let currentRow = [];
+	let currentCell = "";
+	let insideQuotes = false;
+	let i = 0;
+	const len = text.length;
+	while (i < len) {
+		const char = text[i];
+		if (insideQuotes) if (char === "\"") if (i + 1 < len && text[i + 1] === "\"") {
+			currentCell += "\"";
+			i += 2;
+			continue;
+		} else {
+			insideQuotes = false;
+			i++;
+			continue;
+		}
+		else {
+			currentCell += char;
+			i++;
+			continue;
+		}
+		if (char === "\"") {
+			insideQuotes = true;
+			i++;
+			continue;
+		}
+		if (char === ",") {
+			currentRow.push(currentCell);
+			currentCell = "";
+			i++;
+			continue;
+		}
+		if (char === "\r") {
+			if (i + 1 < len && text[i + 1] === "\n") i++;
+			currentRow.push(currentCell);
+			rows.push(currentRow);
+			currentRow = [];
+			currentCell = "";
+			i++;
+			continue;
+		}
+		if (char === "\n") {
+			currentRow.push(currentCell);
+			rows.push(currentRow);
+			currentRow = [];
+			currentCell = "";
+			i++;
+			continue;
+		}
+		currentCell += char;
+		i++;
+	}
+	if (currentCell.length > 0 || currentRow.length > 0) {
+		currentRow.push(currentCell);
+		rows.push(currentRow);
+	}
+	return rows;
+}
+/**
+* Coerce obvious numeric / boolean CSV strings to primitives when lossless.
+*/
+function coerceCsvValue(val) {
+	if (val === "") return "";
+	if (val.toLowerCase() === "true") return true;
+	if (val.toLowerCase() === "false") return false;
+	if (val.toLowerCase() === "null") return null;
+	if (/^-?\d+(\.\d+)?$/.test(val)) {
+		if (val.length > 1 && val.startsWith("0") && !val.startsWith("0.")) return val;
+		const num = Number(val);
+		if (!Number.isNaN(num)) return num;
+	}
+	return val;
+}
+//#endregion
+//#region src/plugins/transfer/parsers/excel.ts
+/**
+* @azlib/cms - Universal Excel (.xlsx) Data Parser using ExcelJS
+*/
+async function parseExcelSource(input, options = {}) {
+	const workbook = new exceljs.default.Workbook();
+	let buffer;
+	if (Buffer.isBuffer(input)) buffer = input;
+	else if (input instanceof Uint8Array) buffer = Buffer.from(input.buffer, input.byteOffset, input.byteLength);
+	else if (input instanceof ArrayBuffer) buffer = Buffer.from(input);
+	else throw new Error("[TransferParser] Invalid Excel input: expected Buffer, Uint8Array, or ArrayBuffer.");
+	await workbook.xlsx.load(buffer);
+	const sheetNames = workbook.worksheets.map((s) => s.name);
+	if (sheetNames.length === 0) return {
+		sheets: [],
+		selectedSheet: "",
+		records: []
+	};
+	let worksheet = options.sheetName ? workbook.getWorksheet(options.sheetName) : void 0;
+	if (!worksheet) worksheet = workbook.worksheets[0];
+	const selectedSheet = worksheet.name;
+	const records = [];
+	const headerRow = worksheet.getRow(1);
+	const headers = [];
+	headerRow.eachCell({ includeEmpty: false }, (cell, colNumber) => {
+		let headerText = String(cell.value ?? "").trim();
+		if (!headerText) headerText = `column_${colNumber}`;
+		headers[colNumber] = headerText;
+	});
+	if (headers.length === 0) return {
+		sheets: sheetNames,
+		selectedSheet,
+		records: []
+	};
+	const rowCount = worksheet.rowCount;
+	for (let r = 2; r <= rowCount; r++) {
+		const row = worksheet.getRow(r);
+		let hasValues = false;
+		const record = {};
+		for (let c = 1; c < headers.length; c++) {
+			const header = headers[c];
+			if (!header) continue;
+			const val = extractCellValue(row.getCell(c).value);
+			if (val !== void 0 && val !== null && val !== "") hasValues = true;
+			record[header] = val;
+		}
+		if (hasValues) records.push(record);
+	}
+	return {
+		sheets: sheetNames,
+		selectedSheet,
+		records
+	};
+}
+/**
+* Normalizes ExcelJS cell values (handles formulas, dates, rich text, hyperlinks).
+*/
+function extractCellValue(val) {
+	if (val === void 0 || val === null) return null;
+	if (val instanceof Date) return val.toISOString();
+	if (typeof val === "object") {
+		if ("formula" in val) return extractCellValue(val.result);
+		if ("text" in val && "hyperlink" in val) return val.text;
+		if ("richText" in val && Array.isArray(val.richText)) return val.richText.map((t) => t.text).join("");
+		if ("error" in val) return null;
+	}
+	return val;
+}
+//#endregion
+//#region src/plugins/transfer/parsers/index.ts
+/**
+* Detect the format of an input payload if not explicitly provided.
+*/
+function detectFormat(input, fileName) {
+	if (Array.isArray(input)) return "json";
+	if (fileName) {
+		const lower = fileName.toLowerCase();
+		if (lower.endsWith(".xlsx") || lower.endsWith(".xls")) return "excel";
+		if (lower.endsWith(".csv")) return "csv";
+		if (lower.endsWith(".json") || lower.endsWith(".ndjson")) return "json";
+	}
+	if (input instanceof Uint8Array || Buffer.isBuffer(input)) {
+		if (input.length >= 4 && input[0] === 80 && input[1] === 75 && input[2] === 3 && input[3] === 4) return "excel";
+		try {
+			const head = new TextDecoder("utf-8").decode(input.slice(0, 100)).trim();
+			if (head.startsWith("{") || head.startsWith("[")) return "json";
+			if (head.includes(",") && head.includes("\n")) return "csv";
+		} catch {}
+	}
+	if (typeof input === "string") {
+		const trimmed = input.trim();
+		if (trimmed.startsWith("{") || trimmed.startsWith("[")) return "json";
+		if (trimmed.includes(",") || trimmed.includes("\n")) return "csv";
+	}
+	return "json";
+}
+/**
+* Universal source parser that handles JSON, CSV, and Excel (.xlsx).
+*/
+async function parseSource(input, options = {}) {
+	switch (options.format || detectFormat(input, options.fileName)) {
+		case "excel": {
+			const excelResult = await parseExcelSource(input, { sheetName: options.sheetName });
+			return {
+				format: "excel",
+				sheets: excelResult.sheets,
+				selectedSheet: excelResult.selectedSheet,
+				records: excelResult.records
+			};
+		}
+		case "csv": return {
+			format: "csv",
+			records: parseCsvSource(input)
+		};
+		default: return {
+			format: "json",
+			records: parseJsonSource(input)
+		};
+	}
+}
+//#endregion
+//#region src/plugins/transfer/serializers/json.ts
+function serializeJson(records, options = {}) {
+	const indent = options.pretty !== false ? 2 : void 0;
+	return JSON.stringify(records, null, indent);
+}
+//#endregion
+//#region src/plugins/transfer/serializers/csv.ts
+function serializeCsv(records, options = {}) {
+	if (records.length === 0) return "";
+	let columns = options.columns;
+	if (!columns || columns.length === 0) {
+		const keys = /* @__PURE__ */ new Set();
+		for (const record of records) for (const key of Object.keys(record)) keys.add(key);
+		columns = Array.from(keys).map((k) => ({
+			key: k,
+			header: k
+		}));
+	}
+	const lines = [];
+	lines.push(columns.map((c) => escapeCsvCell(c.header)).join(","));
+	for (const record of records) {
+		const rowCells = columns.map((col) => {
+			const val = record[col.key];
+			return escapeCsvCell(formatCsvValue(val));
+		});
+		lines.push(rowCells.join(","));
+	}
+	return lines.join("\r\n");
+}
+function formatCsvValue(val) {
+	if (val === void 0 || val === null) return "";
+	if (typeof val === "object") {
+		if (val instanceof Date) return val.toISOString();
+		return JSON.stringify(val);
+	}
+	return String(val);
+}
+function escapeCsvCell(cell) {
+	if (cell.includes(",") || cell.includes("\"") || cell.includes("\n") || cell.includes("\r")) return `"${cell.replace(/"/g, "\"\"")}"`;
+	return cell;
+}
+//#endregion
+//#region src/plugins/transfer/serializers/excel.ts
+/**
+* @azlib/cms - Universal Excel (.xlsx) Serializer using ExcelJS
+*/
+async function serializeExcel(records, options = {}) {
+	const workbook = new exceljs.default.Workbook();
+	const sheetName = (options.sheetName || "Export").replace(/[:\\/?*\[\]]/g, "_");
+	const worksheet = workbook.addWorksheet(sheetName.slice(0, 31));
+	let columns = options.columns;
+	if (!columns || columns.length === 0) {
+		const keys = /* @__PURE__ */ new Set();
+		for (const record of records) for (const key of Object.keys(record)) keys.add(key);
+		columns = Array.from(keys).map((k) => ({
+			key: k,
+			header: formatHeaderLabel(k)
+		}));
+	}
+	worksheet.columns = columns.map((col) => {
+		let maxLen = col.header.length;
+		for (let i = 0; i < Math.min(records.length, 100); i++) {
+			const val = records[i][col.key];
+			if (val !== void 0 && val !== null) {
+				const str = typeof val === "object" ? JSON.stringify(val) : String(val);
+				if (str.length > maxLen) maxLen = Math.min(str.length, 50);
+			}
+		}
+		return {
+			header: col.header,
+			key: col.key,
+			width: Math.max(maxLen + 4, col.width ?? 12)
+		};
+	});
+	const headerRow = worksheet.getRow(1);
+	headerRow.height = 28;
+	headerRow.eachCell((cell) => {
+		cell.font = {
+			bold: true,
+			color: { argb: "FF1E293B" },
+			size: 11
+		};
+		cell.fill = {
+			type: "pattern",
+			pattern: "solid",
+			fgColor: { argb: "FFF1F5F9" }
+		};
+		cell.alignment = {
+			vertical: "middle",
+			horizontal: "center",
+			wrapText: true
+		};
+		cell.border = {
+			top: {
+				style: "thin",
+				color: { argb: "FFE2E8F0" }
+			},
+			bottom: {
+				style: "medium",
+				color: { argb: "FFCBD5E1" }
+			},
+			left: {
+				style: "thin",
+				color: { argb: "FFE2E8F0" }
+			},
+			right: {
+				style: "thin",
+				color: { argb: "FFE2E8F0" }
+			}
+		};
+	});
+	for (const record of records) {
+		const rowValues = {};
+		for (const col of columns) {
+			const val = record[col.key];
+			rowValues[col.key] = formatExcelCellValue(val);
+		}
+		const row = worksheet.addRow(rowValues);
+		row.height = 20;
+		row.eachCell((cell) => {
+			cell.alignment = { vertical: "middle" };
+			cell.border = {
+				top: {
+					style: "thin",
+					color: { argb: "FFF1F5F9" }
+				},
+				bottom: {
+					style: "thin",
+					color: { argb: "FFF1F5F9" }
+				},
+				left: {
+					style: "thin",
+					color: { argb: "FFF1F5F9" }
+				},
+				right: {
+					style: "thin",
+					color: { argb: "FFF1F5F9" }
+				}
+			};
+		});
+	}
+	const arrayBuffer = await workbook.xlsx.writeBuffer();
+	return new Uint8Array(arrayBuffer);
+}
+function formatHeaderLabel(key) {
+	return key.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function formatExcelCellValue(val) {
+	if (val === void 0 || val === null) return "";
+	if (typeof val === "number" || typeof val === "boolean") return val;
+	if (val instanceof Date) return val;
+	if (typeof val === "object") return JSON.stringify(val);
+	return String(val);
+}
+//#endregion
+//#region src/plugins/transfer/serializers/index.ts
+async function serializeSource(records, options = {}) {
+	const format = options.format || "json";
+	const baseName = options.fileName || "export";
+	switch (format) {
+		case "excel": return {
+			format: "excel",
+			data: await serializeExcel(records, {
+				sheetName: options.sheetName,
+				columns: options.columns
+			}),
+			mimeType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+			fileName: baseName.endsWith(".xlsx") ? baseName : `${baseName}.xlsx`,
+			totalRecords: records.length
+		};
+		case "csv": return {
+			format: "csv",
+			data: serializeCsv(records, { columns: options.columns }),
+			mimeType: "text/csv; charset=utf-8",
+			fileName: baseName.endsWith(".csv") ? baseName : `${baseName}.csv`,
+			totalRecords: records.length
+		};
+		default: return {
+			format: "json",
+			data: serializeJson(records, { pretty: true }),
+			mimeType: "application/json; charset=utf-8",
+			fileName: baseName.endsWith(".json") ? baseName : `${baseName}.json`,
+			totalRecords: records.length
+		};
+	}
+}
+//#endregion
+//#region src/plugins/transfer/inspect.ts
+/**
+* Inspect an uploaded source file or payload to discover its schema,
+* infer column types, and generate auto-mapping suggestions against a target collection.
+*/
+async function inspectSource(input, options = {}) {
+	const parsed = await parseSource(input, {
+		format: options.format,
+		fileName: options.fileName,
+		sheetName: options.sheetName
+	});
+	const records = parsed.records;
+	const totalRows = records.length;
+	const previewLimit = options.previewLimit ?? 5;
+	const previewRows = records.slice(0, previewLimit);
+	const fieldKeys = /* @__PURE__ */ new Set();
+	for (const row of records) for (const key of Object.keys(row)) fieldKeys.add(key);
+	const sourceFields = [];
+	for (const key of fieldKeys) {
+		let nullCount = 0;
+		const samples = [];
+		const detectedTypes = [];
+		for (const row of records) {
+			const val = row[key];
+			if (val === void 0 || val === null || val === "") nullCount++;
+			else {
+				if (samples.length < 5) samples.push(val);
+				detectedTypes.push(inferValueType(val));
+			}
+		}
+		sourceFields.push({
+			name: key,
+			inferredType: resolveDominantType(detectedTypes),
+			sampleValues: samples,
+			nullCount,
+			totalCount: totalRows
+		});
+	}
+	let targetSchema;
+	let suggestedMapping;
+	if (options.collectionConfig) {
+		targetSchema = summarizeCollection(options.collectionConfig);
+		suggestedMapping = generateSuggestedMapping(sourceFields.map((f) => f.name), targetSchema);
+	}
+	return {
+		format: parsed.format,
+		sheets: parsed.sheets,
+		selectedSheet: parsed.selectedSheet,
+		totalRows,
+		sourceFields,
+		targetSchema,
+		suggestedMapping,
+		previewRows
+	};
+}
+/**
+* Summarize a CMS CollectionConfig into consumer-friendly schema details.
+*/
+function summarizeCollection(config) {
+	return {
+		slug: config.slug,
+		label: config.label,
+		singularLabel: config.singularLabel || config.label,
+		description: config.description,
+		taxonomies: config.taxonomies || [],
+		fields: config.fields.map((f) => ({
+			name: f.name,
+			label: f.label || f.name,
+			type: f.type,
+			required: Boolean(f.required),
+			unique: Boolean(f.unique),
+			description: f.description,
+			defaultValue: f.defaultValue,
+			targetCollection: f.targetCollection,
+			options: f.options
+		}))
+	};
+}
+/**
+* Generates intelligent auto-mapping suggestions matching source headers to CMS fields.
+*/
+function generateSuggestedMapping(sourceHeaders, targetSchema) {
+	const suggestions = [];
+	const matchedTargets = /* @__PURE__ */ new Set();
+	for (const sourceHeader of sourceHeaders) {
+		let bestMatch = null;
+		for (const targetField of targetSchema.fields) {
+			if (matchedTargets.has(targetField.name)) continue;
+			const score = calculateMatchConfidence(sourceHeader, targetField);
+			if (score >= .6 && (!bestMatch || score > bestMatch.confidence)) bestMatch = {
+				field: targetField.name,
+				confidence: score
+			};
+		}
+		if (bestMatch) {
+			matchedTargets.add(bestMatch.field);
+			suggestions.push({
+				sourceField: sourceHeader,
+				targetField: bestMatch.field,
+				confidence: Number(bestMatch.confidence.toFixed(2))
+			});
+		}
+	}
+	return suggestions;
+}
+function normalize(str) {
+	return str.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+/**
+* Common field synonyms dictionary for intuitive fuzzy matching.
+*/
+const SYNONYMS = {
+	employeeNumber: [
+		"empid",
+		"employeeid",
+		"empnumber",
+		"staffid",
+		"badgenumber",
+		"staffno",
+		"empno"
+	],
+	companyName: [
+		"company",
+		"organization",
+		"employer",
+		"businessname",
+		"employername",
+		"firm"
+	],
+	firstName: [
+		"fname",
+		"givenname",
+		"first"
+	],
+	lastName: [
+		"lname",
+		"surname",
+		"familyname",
+		"last"
+	],
+	email: [
+		"mail",
+		"workemail",
+		"primaryemail",
+		"emailaddress"
+	],
+	phone: [
+		"mobile",
+		"cell",
+		"telephone",
+		"phonenumber",
+		"contactnumber",
+		"tel"
+	],
+	employerId: [
+		"employer",
+		"companyid",
+		"company",
+		"organizationid",
+		"orgid"
+	],
+	hireDate: [
+		"startdate",
+		"joiningdate",
+		"hired",
+		"dateofjoining"
+	],
+	jobTitle: [
+		"title",
+		"position",
+		"role",
+		"designation"
+	],
+	employmentType: [
+		"contracttype",
+		"worktype",
+		"jobtype"
+	],
+	salary: [
+		"compensation",
+		"wage",
+		"pay",
+		"rate",
+		"annualsalary"
+	],
+	taxId: [
+		"ein",
+		"vat",
+		"taxnumber",
+		"tin"
+	],
+	status: ["state", "active"]
+};
+function calculateMatchConfidence(sourceHeader, targetField) {
+	const normSource = normalize(sourceHeader);
+	const normTargetName = normalize(targetField.name);
+	const normTargetLabel = normalize(targetField.label);
+	if (sourceHeader === targetField.name) return 1;
+	if (normSource === normTargetName) return .95;
+	if (sourceHeader.toLowerCase() === targetField.label.toLowerCase()) return .92;
+	if (normSource === normTargetLabel) return .9;
+	const synonyms = SYNONYMS[targetField.name];
+	if (synonyms && synonyms.includes(normSource)) return .85;
+	if (normSource.includes(normTargetName) || normTargetName.includes(normSource)) return .7;
+	if (normSource.includes(normTargetLabel) || normTargetLabel.includes(normSource)) return .65;
+	return 0;
+}
+function inferValueType(val) {
+	if (typeof val === "boolean") return "boolean";
+	if (typeof val === "number") return "number";
+	if (Array.isArray(val)) return "array";
+	if (val && typeof val === "object") return "object";
+	if (typeof val === "string") {
+		const s = val.trim();
+		if (s.toLowerCase() === "true" || s.toLowerCase() === "false") return "boolean";
+		if (/^-?\d+(\.\d+)?$/.test(s) && !/^0\d+/.test(s)) return "number";
+		if (/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}(:\d{2})?(\.\d+)?(Z|[+-]\d{2}:?\d{2})?)?$/.test(s)) {
+			const parsed = Date.parse(s);
+			if (!Number.isNaN(parsed)) return "date";
+		}
+	}
+	return "string";
+}
+function resolveDominantType(types) {
+	if (types.length === 0) return "string";
+	const counts = /* @__PURE__ */ new Map();
+	for (const t of types) counts.set(t, (counts.get(t) || 0) + 1);
+	let dominant = "string";
+	let maxCount = 0;
+	for (const [t, count] of counts) if (count > maxCount) {
+		maxCount = count;
+		dominant = t;
+	}
+	return dominant;
+}
+//#endregion
+//#region src/plugins/transfer/mapping.ts
+/**
+* Apply a mapping definition to transform an external raw record into a CMS content payload.
+*/
+function mapSourceRecord(rawRecord, mapping) {
+	const mappedData = {};
+	const mappedTargetFields = /* @__PURE__ */ new Set();
+	for (const rule of mapping.fields) {
+		mappedTargetFields.add(rule.targetField);
+		const sourceVal = rawRecord[rule.sourceField];
+		const transformed = applyFieldTransform(rule, sourceVal, rawRecord);
+		if (transformed !== void 0) mappedData[rule.targetField] = transformed;
+	}
+	if (mapping.options?.ignoreUnmappedFields === false) {
+		for (const [key, val] of Object.entries(rawRecord)) if (!mapping.fields.some((r) => r.sourceField === key)) mappedData[key] = val;
+	}
+	let title = typeof mappedData.title === "string" ? mappedData.title : void 0;
+	if (!title) {
+		if (typeof mappedData.companyName === "string") title = mappedData.companyName;
+		else if (typeof mappedData.name === "string") title = mappedData.name;
+		else if (typeof mappedData.firstName === "string" || typeof mappedData.lastName === "string") {
+			const parts = [mappedData.firstName, mappedData.lastName].filter(Boolean);
+			if (parts.length > 0) title = parts.join(" ");
+		}
+	}
+	let slug = typeof mappedData.slug === "string" ? mappedData.slug : void 0;
+	if (!slug && mapping.options?.autoGenerateSlug !== false && title) slug = slugify(title);
+	let status = mapping.options?.defaultStatus;
+	if (mapping.options?.statusField && mappedData[mapping.options.statusField]) status = String(mappedData[mapping.options.statusField]);
+	return {
+		data: mappedData,
+		title,
+		slug,
+		status
+	};
+}
+/**
+* Applies transform preset or custom function to a field value.
+*/
+function applyFieldTransform(rule, value, rawRecord) {
+	let val = value;
+	if (typeof rule.transform === "function") try {
+		val = rule.transform(val, rawRecord);
+	} catch (err) {
+		throw new Error(`Transform error on field '${rule.sourceField}': ${err instanceof Error ? err.message : String(err)}`);
+	}
+	else if (rule.transform && typeof rule.transform === "string") val = applyPresetTransform(rule.transform, val);
+	if (val === void 0 || val === null || val === "") {
+		if (rule.defaultValue !== void 0) val = rule.defaultValue;
+	}
+	return val;
+}
+function applyPresetTransform(preset, val) {
+	if (val === void 0 || val === null) return val;
+	switch (preset) {
+		case "trim": return typeof val === "string" ? val.trim() : val;
+		case "lowercase": return typeof val === "string" ? val.toLowerCase() : val;
+		case "uppercase": return typeof val === "string" ? val.toUpperCase() : val;
+		case "number": {
+			if (typeof val === "number") return val;
+			const parsed = Number(val);
+			return Number.isNaN(parsed) ? val : parsed;
+		}
+		case "boolean": {
+			if (typeof val === "boolean") return val;
+			const s = String(val).toLowerCase().trim();
+			if (s === "true" || s === "1" || s === "yes") return true;
+			if (s === "false" || s === "0" || s === "no") return false;
+			return Boolean(val);
+		}
+		case "date": {
+			if (val instanceof Date) return val.toISOString();
+			const s = String(val).trim();
+			const parsed = Date.parse(s);
+			return Number.isNaN(parsed) ? s : new Date(parsed).toISOString();
+		}
+		case "json":
+			if (typeof val === "object") return val;
+			try {
+				return JSON.parse(String(val));
+			} catch {
+				return val;
+			}
+		case "slug": return slugify(String(val));
+		case "split_comma":
+			if (Array.isArray(val)) return val;
+			return String(val).split(",").map((s) => s.trim()).filter(Boolean);
+		default: return val;
+	}
+}
+/**
+* Reverse mapping for export: transforms a CMS ContentItem into an external export record.
+*/
+function mapCmsItemForExport(item, mapping, options = {}) {
+	const exportRecord = {};
+	if (mapping && mapping.fields.length > 0) {
+		for (const rule of mapping.fields) {
+			const val = item.data[rule.targetField] !== void 0 ? item.data[rule.targetField] : item[rule.targetField];
+			exportRecord[rule.sourceField] = val !== void 0 ? val : rule.defaultValue ?? "";
+		}
+		return exportRecord;
+	}
+	if (options.includeId !== false) exportRecord.id = item.id;
+	if (item.title) exportRecord.title = item.title;
+	if (item.slug) exportRecord.slug = item.slug;
+	if (item.status) exportRecord.status = item.status;
+	for (const [k, v] of Object.entries(item.data)) exportRecord[k] = v;
+	if (options.includeTimestamps) {
+		exportRecord.createdAt = item.createdAt;
+		exportRecord.updatedAt = item.updatedAt;
+	}
+	return exportRecord;
+}
+//#endregion
+//#region src/plugins/transfer/validator.ts
+/**
+* Validates a batch of source records against a target CMS collection configuration
+* and live database constraints.
+*/
+async function validateTransferBatch(rawRecords, mapping, collectionConfig, options = {}) {
+	const errors = [];
+	const previewRows = [];
+	const previewLimit = options.previewLimit ?? 10;
+	const onDuplicate = options.onDuplicate ?? mapping.options?.onDuplicate ?? "error";
+	const uniqueFields = collectionConfig.fields.filter((f) => Boolean(f.unique) || f.name === "slug");
+	const relationshipFields = collectionConfig.fields.filter((f) => f.type === "relationship" && Boolean(f.targetCollection));
+	const seenUniqueValues = /* @__PURE__ */ new Map();
+	for (const uf of uniqueFields) seenUniqueValues.set(uf.name, /* @__PURE__ */ new Map());
+	let validCount = 0;
+	for (let i = 0; i < rawRecords.length; i++) {
+		const rowNumber = i + 1;
+		const raw = rawRecords[i];
+		const rowErrors = [];
+		let mappedResult;
+		try {
+			mappedResult = mapSourceRecord(raw, mapping);
+		} catch (err) {
+			const errDetail = {
+				rowNumber,
+				code: "TRANSFORM_ERROR",
+				reason: err instanceof Error ? err.message : String(err)
+			};
+			rowErrors.push(errDetail);
+			errors.push(errDetail);
+			if (previewRows.length < previewLimit) previewRows.push({
+				rowNumber,
+				raw,
+				mapped: {},
+				valid: false,
+				errors: rowErrors
+			});
+			continue;
+		}
+		const data = mappedResult.data;
+		for (const field of collectionConfig.fields) validateField(field, data, rowNumber, rowErrors);
+		for (const rule of mapping.fields) if (rule.required && !collectionConfig.fields.some((f) => f.name === rule.targetField)) {
+			const val = data[rule.targetField];
+			if (val === void 0 || val === null || val === "") rowErrors.push({
+				rowNumber,
+				field: rule.targetField,
+				value: val,
+				code: "REQUIRED_FIELD_MISSING",
+				reason: `Field '${rule.targetField}' is required by mapping definition.`
+			});
+		}
+		for (const uf of uniqueFields) {
+			const val = data[uf.name] ?? (uf.name === "slug" ? mappedResult.slug : void 0);
+			if (val !== void 0 && val !== null && val !== "") {
+				const seenMap = seenUniqueValues.get(uf.name);
+				if (seenMap.has(val)) {
+					const prevRow = seenMap.get(val);
+					rowErrors.push({
+						rowNumber,
+						field: uf.name,
+						value: val,
+						code: "CONSTRAINT_UNIQUE_VIOLATION",
+						reason: `${uf.label || uf.name} value '${val}' is duplicated in row ${prevRow} and row ${rowNumber}.`
+					});
+				} else seenMap.set(val, rowNumber);
+				if (options.storage && onDuplicate === "error") {
+					if (await checkExistingUnique(options.storage, collectionConfig.slug, uf.name, val)) rowErrors.push({
+						rowNumber,
+						field: uf.name,
+						value: val,
+						code: "CONSTRAINT_UNIQUE_VIOLATION",
+						reason: `${uf.label || uf.name} value '${val}' already exists in database.`
+					});
+				}
+			}
+		}
+		if (options.storage) for (const rf of relationshipFields) {
+			const targetColl = rf.targetCollection;
+			const refVal = data[rf.name];
+			if (refVal !== void 0 && refVal !== null && refVal !== "") {
+				if (!await checkRelationshipExists(options.storage, targetColl, refVal)) rowErrors.push({
+					rowNumber,
+					field: rf.name,
+					value: refVal,
+					code: "CONSTRAINT_FOREIGN_KEY_VIOLATION",
+					reason: `Referenced ${rf.label || rf.name} with identifier '${refVal}' does not exist in collection '${targetColl}'.`
+				});
+			}
+		}
+		if (rowErrors.length === 0) validCount++;
+		else errors.push(...rowErrors);
+		if (previewRows.length < previewLimit) previewRows.push({
+			rowNumber,
+			raw,
+			mapped: data,
+			valid: rowErrors.length === 0,
+			errors: rowErrors.length > 0 ? rowErrors : void 0
+		});
+	}
+	return {
+		valid: errors.length === 0,
+		totalRows: rawRecords.length,
+		validCount,
+		errorCount: errors.length,
+		errors,
+		previewRows
+	};
+}
+/**
+* Validates a single field against its FieldDefinition.
+*/
+function validateField(field, data, rowNumber, errors) {
+	const val = data[field.name];
+	const label = field.label || field.name;
+	if (field.required && (val === void 0 || val === null || val === "")) {
+		errors.push({
+			rowNumber,
+			field: field.name,
+			value: val,
+			code: "REQUIRED_FIELD_MISSING",
+			reason: `${label} is required.`
+		});
+		return;
+	}
+	if (val === void 0 || val === null || val === "") return;
+	switch (field.type) {
+		case "number": {
+			const num = typeof val === "number" ? val : Number(val);
+			if (Number.isNaN(num)) errors.push({
+				rowNumber,
+				field: field.name,
+				value: val,
+				code: "INVALID_DATA_TYPE",
+				reason: `${label} must be a valid number, received '${val}'.`
+			});
+			else {
+				data[field.name] = num;
+				const min = field.min;
+				const max = field.max;
+				if (min !== void 0 && num < min) errors.push({
+					rowNumber,
+					field: field.name,
+					value: val,
+					code: "VALIDATION_RULE_FAILED",
+					reason: `${label} must be greater than or equal to ${min}.`
+				});
+				if (max !== void 0 && num > max) errors.push({
+					rowNumber,
+					field: field.name,
+					value: val,
+					code: "VALIDATION_RULE_FAILED",
+					reason: `${label} must be less than or equal to ${max}.`
+				});
+			}
+			break;
+		}
+		case "boolean":
+			if (typeof val !== "boolean") {
+				const s = String(val).toLowerCase().trim();
+				if (s === "true" || s === "1" || s === "yes") data[field.name] = true;
+				else if (s === "false" || s === "0" || s === "no") data[field.name] = false;
+				else errors.push({
+					rowNumber,
+					field: field.name,
+					value: val,
+					code: "INVALID_DATA_TYPE",
+					reason: `${label} must be a boolean (true/false), received '${val}'.`
+				});
+			}
+			break;
+		case "date": {
+			const parsed = Date.parse(String(val));
+			if (Number.isNaN(parsed)) errors.push({
+				rowNumber,
+				field: field.name,
+				value: val,
+				code: "INVALID_DATA_TYPE",
+				reason: `${label} must be a valid date, received '${val}'.`
+			});
+			break;
+		}
+		case "select": {
+			const options = field.options;
+			if (options && options.length > 0) {
+				const allowedValues = options.map((opt) => typeof opt === "object" ? String(opt.value) : String(opt));
+				if (!allowedValues.includes(String(val))) errors.push({
+					rowNumber,
+					field: field.name,
+					value: val,
+					code: "INVALID_SELECT_OPTION",
+					reason: `${label} value '${val}' is not a valid option (allowed: ${allowedValues.join(", ")}).`
+				});
+			}
+			break;
+		}
+		case "json":
+			if (typeof val === "string") try {
+				data[field.name] = JSON.parse(val);
+			} catch {
+				errors.push({
+					rowNumber,
+					field: field.name,
+					value: val,
+					code: "INVALID_DATA_TYPE",
+					reason: `${label} must be a valid JSON structure.`
+				});
+			}
+			break;
+	}
+	if (typeof field.validate === "function") try {
+		const res = field.validate(val, data);
+		if (typeof res === "string") errors.push({
+			rowNumber,
+			field: field.name,
+			value: val,
+			code: "VALIDATION_RULE_FAILED",
+			reason: res
+		});
+		else if (res === false) errors.push({
+			rowNumber,
+			field: field.name,
+			value: val,
+			code: "VALIDATION_RULE_FAILED",
+			reason: `${label} failed custom validation constraint.`
+		});
+	} catch (err) {
+		errors.push({
+			rowNumber,
+			field: field.name,
+			value: val,
+			code: "VALIDATION_RULE_FAILED",
+			reason: err instanceof Error ? err.message : String(err)
+		});
+	}
+}
+async function checkExistingUnique(storage, collectionSlug, fieldName, value) {
+	if (fieldName === "slug") return await storage.getContentBySlug(collectionSlug, String(value)) !== null;
+	return (await storage.findContent(collectionSlug, {
+		where: { [fieldName]: value },
+		limit: 1
+	})).items.length > 0;
+}
+async function checkRelationshipExists(storage, targetCollection, refId) {
+	const idStr = String(refId);
+	if (await storage.getContent(targetCollection, idStr) !== null) return true;
+	return await storage.getContentBySlug(targetCollection, idStr) !== null;
+}
+//#endregion
+//#region src/plugins/transfer/presets/hrms.ts
+/**
+* Preconfigured mapping definition for importing and exporting HRMS Employers.
+*/
+const HRMS_EMPLOYER_TRANSFER_PRESET = {
+	id: "hrms_employers_preset",
+	name: "HRMS Employers Standard Mapping",
+	collectionSlug: "employers",
+	fields: [
+		{
+			sourceField: "Company Name",
+			targetField: "companyName",
+			required: true
+		},
+		{
+			sourceField: "Legal Name",
+			targetField: "legalName"
+		},
+		{
+			sourceField: "Tax ID",
+			targetField: "taxId"
+		},
+		{
+			sourceField: "Primary Email",
+			targetField: "email",
+			transform: "trim"
+		},
+		{
+			sourceField: "Phone",
+			targetField: "phone",
+			transform: "trim"
+		},
+		{
+			sourceField: "Website",
+			targetField: "website"
+		},
+		{
+			sourceField: "Timezone",
+			targetField: "timezone",
+			defaultValue: "UTC"
+		},
+		{
+			sourceField: "Status",
+			targetField: "status",
+			defaultValue: "active"
+		}
+	],
+	options: {
+		autoGenerateSlug: true,
+		defaultStatus: "published",
+		onDuplicate: "update",
+		uniqueIdentifierField: "taxId"
+	}
+};
+/**
+* Preconfigured mapping definition for importing and exporting HRMS Employees.
+*/
+const HRMS_EMPLOYEE_TRANSFER_PRESET = {
+	id: "hrms_employees_preset",
+	name: "HRMS Employees Standard Mapping",
+	collectionSlug: "employees",
+	fields: [
+		{
+			sourceField: "Employer ID",
+			targetField: "employerId",
+			required: true
+		},
+		{
+			sourceField: "Employee Number",
+			targetField: "employeeNumber",
+			required: true,
+			transform: "trim"
+		},
+		{
+			sourceField: "First Name",
+			targetField: "firstName",
+			required: true,
+			transform: "trim"
+		},
+		{
+			sourceField: "Last Name",
+			targetField: "lastName",
+			required: true,
+			transform: "trim"
+		},
+		{
+			sourceField: "Work Email",
+			targetField: "email",
+			required: true,
+			transform: "lowercase"
+		},
+		{
+			sourceField: "Phone",
+			targetField: "phone",
+			transform: "trim"
+		},
+		{
+			sourceField: "Job Title",
+			targetField: "jobTitle"
+		},
+		{
+			sourceField: "Employment Type",
+			targetField: "employmentType",
+			defaultValue: "full_time"
+		},
+		{
+			sourceField: "Hire Date",
+			targetField: "hireDate",
+			required: true,
+			transform: "date"
+		},
+		{
+			sourceField: "Status",
+			targetField: "status",
+			defaultValue: "active"
+		}
+	],
+	options: {
+		autoGenerateSlug: true,
+		defaultStatus: "published",
+		onDuplicate: "error",
+		uniqueIdentifierField: "employeeNumber"
+	}
+};
+//#endregion
+//#region src/plugins/transfer/service.ts
+var TransferService = class {
+	engine;
+	options;
+	presets = /* @__PURE__ */ new Map();
+	constructor(engine, options = {}) {
+		this.engine = engine;
+		this.options = options;
+		this.registerPreset(HRMS_EMPLOYER_TRANSFER_PRESET);
+		this.registerPreset(HRMS_EMPLOYEE_TRANSFER_PRESET);
+	}
+	/**
+	* List all registered collections across all active plugins in the engine.
+	*/
+	listCollections() {
+		return this.engine.getCollections().map(summarizeCollection);
+	}
+	/**
+	* Get the collection schema summary for a specific collection slug.
+	*/
+	getCollectionSchema(collectionSlug) {
+		return summarizeCollection(this.getCollectionConfigOrThrow(collectionSlug));
+	}
+	/**
+	* Register a reusable data mapping preset.
+	*/
+	registerPreset(preset) {
+		const id = preset.id || `${preset.collectionSlug}_${preset.name || "preset"}`;
+		this.presets.set(id, {
+			...preset,
+			id
+		});
+	}
+	/**
+	* Get a registered preset by ID.
+	*/
+	getPreset(id) {
+		return this.presets.get(id);
+	}
+	/**
+	* Get all registered presets, optionally filtered by target collection.
+	*/
+	getPresets(collectionSlug) {
+		const all = Array.from(this.presets.values());
+		if (collectionSlug) return all.filter((p) => p.collectionSlug === collectionSlug);
+		return all;
+	}
+	/**
+	* Generate a 1:1 default mapping template for any collection.
+	*/
+	getMappingTemplate(collectionSlug) {
+		const config = this.getCollectionConfigOrThrow(collectionSlug);
+		return {
+			id: `${collectionSlug}_default_template`,
+			name: `${config.label} Default Template`,
+			collectionSlug,
+			fields: config.fields.map((f) => ({
+				sourceField: f.name,
+				targetField: f.name,
+				required: Boolean(f.required),
+				defaultValue: f.defaultValue
+			})),
+			options: {
+				autoGenerateSlug: true,
+				defaultStatus: config.draftable ? "draft" : "published",
+				onDuplicate: "error"
+			}
+		};
+	}
+	/**
+	* Inspect any source payload or file (JSON, Excel, CSV) to extract headers,
+	* infer data types, and generate auto-mapping suggestions against a target collection.
+	*/
+	async inspectSource(input, options = {}) {
+		const config = options.collectionSlug ? this.engine.getCollectionConfig(options.collectionSlug) : void 0;
+		return inspectSource(input, {
+			...options,
+			collectionConfig: config
+		});
+	}
+	/**
+	* Dry-run validation of a source batch against a target collection's schema
+	* and live database constraints without committing any changes.
+	*/
+	async validateImport(collectionSlug, input, mapping, options = {}) {
+		const config = this.getCollectionConfigOrThrow(collectionSlug);
+		const parsed = await parseSource(input, {
+			format: options.format,
+			fileName: options.fileName,
+			sheetName: options.sheetName
+		});
+		const activeMapping = mapping || this.getMappingTemplate(collectionSlug);
+		return validateTransferBatch(parsed.records, activeMapping, config, {
+			storage: this.engine.storage,
+			onDuplicate: options.onDuplicate,
+			previewLimit: options.previewLimit
+		});
+	}
+	/**
+	* Execute an import batch from raw data or an external file (JSON, Excel, CSV)
+	* into a target CMS collection.
+	*/
+	async importData(collectionSlug, input, mapping, options = {}) {
+		const config = this.getCollectionConfigOrThrow(collectionSlug);
+		const parsed = await parseSource(input, {
+			format: options.format,
+			fileName: options.fileName,
+			sheetName: options.sheetName
+		});
+		const activeMapping = mapping || this.getMappingTemplate(collectionSlug);
+		const rawRecords = parsed.records;
+		const onDuplicate = options.onDuplicate ?? activeMapping.options?.onDuplicate ?? "error";
+		const abortOnError = options.abortOnError ?? activeMapping.options?.abortOnError ?? false;
+		const validation = await validateTransferBatch(rawRecords, activeMapping, config, {
+			storage: this.engine.storage,
+			onDuplicate
+		});
+		if (options.dryRun) return {
+			success: validation.valid,
+			collectionSlug,
+			totalRows: rawRecords.length,
+			importedCount: validation.validCount,
+			updatedCount: 0,
+			skippedCount: 0,
+			failedCount: validation.errorCount,
+			createdIds: [],
+			updatedIds: [],
+			errors: validation.errors
+		};
+		if (abortOnError && !validation.valid) return {
+			success: false,
+			collectionSlug,
+			totalRows: rawRecords.length,
+			importedCount: 0,
+			updatedCount: 0,
+			skippedCount: 0,
+			failedCount: validation.errorCount,
+			createdIds: [],
+			updatedIds: [],
+			errors: validation.errors
+		};
+		await this.engine.hooks.doAction("cms.transfer_import_started", {
+			collectionSlug,
+			totalRows: rawRecords.length
+		});
+		const createdIds = [];
+		const updatedIds = [];
+		const errors = [...validation.errors];
+		let importedCount = 0;
+		let updatedCount = 0;
+		let skippedCount = 0;
+		const rowErrorsMap = /* @__PURE__ */ new Map();
+		for (const err of validation.errors) {
+			const list = rowErrorsMap.get(err.rowNumber) || [];
+			list.push(err);
+			rowErrorsMap.set(err.rowNumber, list);
+		}
+		const collService = this.engine.collection(collectionSlug);
+		for (let i = 0; i < rawRecords.length; i++) {
+			const rowNumber = i + 1;
+			const rowErrors = rowErrorsMap.get(rowNumber);
+			if (rowErrors && rowErrors.length > 0) {
+				if (rowErrors.some((e) => e.code !== "CONSTRAINT_UNIQUE_VIOLATION" || onDuplicate === "error")) continue;
+			}
+			const raw = rawRecords[i];
+			let mapped;
+			try {
+				mapped = mapSourceRecord(raw, activeMapping);
+			} catch (err) {
+				errors.push({
+					rowNumber,
+					code: "TRANSFORM_ERROR",
+					reason: err instanceof Error ? err.message : String(err)
+				});
+				continue;
+			}
+			mapped = await this.engine.hooks.applyFilters("cms.transfer_before_import_row", mapped, {
+				collectionSlug,
+				rowNumber,
+				raw
+			});
+			const identifierField = options.uniqueIdentifierField || activeMapping.options?.uniqueIdentifierField || this.detectUniqueField(config);
+			let existingItem = null;
+			if (identifierField && mapped.data[identifierField] !== void 0) {
+				const val = mapped.data[identifierField];
+				if (identifierField === "slug") existingItem = await this.engine.storage.getContentBySlug(collectionSlug, String(val));
+				else existingItem = (await this.engine.storage.findContent(collectionSlug, {
+					where: { [identifierField]: val },
+					limit: 1
+				})).items[0] || null;
+			}
+			if (existingItem) {
+				if (onDuplicate === "skip") {
+					skippedCount++;
+					continue;
+				}
+				if (onDuplicate === "update") {
+					try {
+						const updated = await collService.update(existingItem.id, {
+							title: mapped.title ?? existingItem.title,
+							slug: mapped.slug ?? existingItem.slug,
+							status: mapped.status ?? existingItem.status,
+							data: {
+								...existingItem.data,
+								...mapped.data
+							}
+						}, options.authorId, options.revisionNote || "Import transfer update");
+						if (updated) {
+							updatedIds.push(updated.id);
+							updatedCount++;
+							await this.engine.hooks.doAction("cms.transfer_row_imported", {
+								collectionSlug,
+								action: "update",
+								item: updated
+							});
+						}
+					} catch (err) {
+						errors.push({
+							rowNumber,
+							code: "VALIDATION_RULE_FAILED",
+							reason: err instanceof Error ? err.message : String(err)
+						});
+					}
+					continue;
+				}
+			}
+			try {
+				const created = await collService.create({
+					title: mapped.title,
+					slug: mapped.slug,
+					status: mapped.status,
+					data: mapped.data
+				}, options.authorId);
+				createdIds.push(created.id);
+				importedCount++;
+				await this.engine.hooks.doAction("cms.transfer_row_imported", {
+					collectionSlug,
+					action: "create",
+					item: created
+				});
+			} catch (err) {
+				errors.push({
+					rowNumber,
+					code: "VALIDATION_RULE_FAILED",
+					reason: err instanceof Error ? err.message : String(err)
+				});
+			}
+		}
+		const result = {
+			success: errors.length === 0,
+			collectionSlug,
+			totalRows: rawRecords.length,
+			importedCount,
+			updatedCount,
+			skippedCount,
+			failedCount: rawRecords.length - (importedCount + updatedCount + skippedCount),
+			createdIds,
+			updatedIds,
+			errors
+		};
+		await this.engine.hooks.doAction("cms.transfer_import_completed", result);
+		await this.engine.hooks.doAction(`cms.${collectionSlug}_transferred`, result);
+		return result;
+	}
+	/**
+	* Export CMS collection records to JSON, Excel (.xlsx), or CSV.
+	*/
+	async exportData(collectionSlug, options = {}) {
+		const config = this.getCollectionConfigOrThrow(collectionSlug);
+		const collService = this.engine.collection(collectionSlug);
+		const query = options.query || { limit: 1e4 };
+		const items = (await collService.find(query)).items;
+		const exportRecords = [];
+		for (const item of items) {
+			let mappedRow = mapCmsItemForExport(item, options.mapping, {
+				includeId: options.includeId,
+				includeTimestamps: options.includeTimestamps
+			});
+			mappedRow = await this.engine.hooks.applyFilters("cms.transfer_before_export_row", mappedRow, {
+				collectionSlug,
+				item
+			});
+			exportRecords.push(mappedRow);
+		}
+		return serializeSource(exportRecords, {
+			format: options.format || "json",
+			fileName: options.fileName || `${collectionSlug}_export_${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`,
+			sheetName: options.sheetName || config.label
+		});
+	}
+	getCollectionConfigOrThrow(collectionSlug) {
+		const config = this.engine.getCollectionConfig(collectionSlug);
+		if (!config) throw new Error(`[TransferService] Collection '${collectionSlug}' is not registered in the CMS engine.`);
+		return config;
+	}
+	detectUniqueField(config) {
+		const unique = config.fields.find((f) => Boolean(f.unique));
+		if (unique) return unique.name;
+		const slugField = config.fields.find((f) => f.type === "slug" || f.name === "slug");
+		if (slugField) return slugField.name;
+	}
+};
+//#endregion
+//#region src/plugins/transfer/routes.ts
+function json(data, status = 200, headers = {}) {
+	return new Response(JSON.stringify(data), {
+		status,
+		headers: {
+			"Content-Type": "application/json",
+			"Access-Control-Allow-Origin": "*",
+			...headers
+		}
+	});
+}
+function badRequest(message) {
+	return json({ error: message }, 400);
+}
+function notFound(message) {
+	return json({ error: message }, 404);
+}
+function registerTransferRoutes(ctx, service, options = {}) {
+	const prefix = (options.apiPrefix ?? "/api/transfer").replace(/\/+$/, "");
+	ctx.registerRoute("GET", `${prefix}/collections`, async () => {
+		try {
+			return json({ collections: service.listCollections() });
+		} catch (err) {
+			return badRequest(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("GET", `${prefix}/presets`, async (_req, { url }) => {
+		try {
+			const collectionSlug = url.searchParams.get("collection") || void 0;
+			return json({ presets: service.getPresets(collectionSlug) });
+		} catch (err) {
+			return badRequest(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("POST", `${prefix}/presets`, async (req) => {
+		try {
+			const body = await req.json();
+			if (!body.collectionSlug || !Array.isArray(body.fields)) return badRequest("collectionSlug and fields array are required.");
+			service.registerPreset(body);
+			return json({
+				success: true,
+				preset: body
+			}, 201);
+		} catch (err) {
+			return badRequest(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("GET", `${prefix}/:collection/schema`, async (_req, { params }) => {
+		try {
+			return json({
+				schema: service.getCollectionSchema(params.collection),
+				template: service.getMappingTemplate(params.collection)
+			});
+		} catch (err) {
+			return notFound(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("POST", `${prefix}/inspect`, async (req) => {
+		try {
+			const payload = await extractPayload(req);
+			return json(await service.inspectSource(payload.data, {
+				collectionSlug: payload.collectionSlug,
+				format: payload.format,
+				fileName: payload.fileName,
+				sheetName: payload.sheetName
+			}));
+		} catch (err) {
+			return badRequest(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("POST", `${prefix}/:collection/preview`, async (req, { params }) => {
+		try {
+			const payload = await extractPayload(req);
+			return json(await service.validateImport(params.collection, payload.data, payload.mapping, {
+				format: payload.format,
+				fileName: payload.fileName,
+				sheetName: payload.sheetName,
+				onDuplicate: payload.onDuplicate
+			}));
+		} catch (err) {
+			return badRequest(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("POST", `${prefix}/:collection/import`, async (req, { params }) => {
+		try {
+			const payload = await extractPayload(req);
+			const result = await service.importData(params.collection, payload.data, payload.mapping, {
+				format: payload.format,
+				fileName: payload.fileName,
+				sheetName: payload.sheetName,
+				onDuplicate: payload.onDuplicate,
+				uniqueIdentifierField: payload.uniqueIdentifierField,
+				abortOnError: payload.abortOnError,
+				authorId: payload.authorId,
+				revisionNote: payload.revisionNote
+			});
+			return json(result, result.success ? 200 : 207);
+		} catch (err) {
+			return badRequest(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("POST", `${prefix}/:collection/export`, async (req, { params }) => {
+		try {
+			const body = await req.json();
+			const result = await service.exportData(params.collection, {
+				format: body.format,
+				mapping: body.mapping,
+				query: body.query,
+				fileName: body.fileName,
+				sheetName: body.sheetName,
+				includeId: body.includeId,
+				includeTimestamps: body.includeTimestamps
+			});
+			return new Response(result.data, {
+				status: 200,
+				headers: {
+					"Content-Type": result.mimeType,
+					"Content-Disposition": `attachment; filename="${result.fileName}"`,
+					"Access-Control-Allow-Origin": "*"
+				}
+			});
+		} catch (err) {
+			return badRequest(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("GET", `${prefix}/:collection/export`, async (_req, { params, url }) => {
+		try {
+			const format = url.searchParams.get("format") || "json";
+			const fileName = url.searchParams.get("fileName") || void 0;
+			const status = url.searchParams.get("status") || void 0;
+			const search = url.searchParams.get("search") || void 0;
+			const result = await service.exportData(params.collection, {
+				format,
+				fileName,
+				query: {
+					status,
+					search
+				}
+			});
+			return new Response(result.data, {
+				status: 200,
+				headers: {
+					"Content-Type": result.mimeType,
+					"Content-Disposition": `attachment; filename="${result.fileName}"`,
+					"Access-Control-Allow-Origin": "*"
+				}
+			});
+		} catch (err) {
+			return badRequest(err instanceof Error ? err.message : String(err));
+		}
+	});
+}
+/**
+* Helper to extract payload and options from JSON or Multipart requests.
+*/
+async function extractPayload(req) {
+	if ((req.headers.get("content-type") || "").includes("multipart/form-data")) {
+		const formData = await req.formData();
+		const file = formData.get("file");
+		let data = null;
+		let fileName;
+		if (file && typeof file === "object" && "arrayBuffer" in file) {
+			data = new Uint8Array(await file.arrayBuffer());
+			fileName = file.name;
+		}
+		const mappingRaw = formData.get("mapping");
+		const mapping = mappingRaw ? JSON.parse(String(mappingRaw)) : void 0;
+		return {
+			data,
+			collectionSlug: formData.get("collectionSlug") || void 0,
+			format: formData.get("format") || void 0,
+			fileName: formData.get("fileName") || fileName,
+			sheetName: formData.get("sheetName") || void 0,
+			mapping,
+			onDuplicate: formData.get("onDuplicate") || void 0,
+			uniqueIdentifierField: formData.get("uniqueIdentifierField") || void 0,
+			abortOnError: formData.get("abortOnError") === "true",
+			authorId: formData.get("authorId") || void 0,
+			revisionNote: formData.get("revisionNote") || void 0
+		};
+	}
+	const body = await req.json();
+	let data = body.data;
+	if (typeof body.base64 === "string") data = Buffer.from(body.base64, "base64");
+	return {
+		data: data !== void 0 ? data : body,
+		collectionSlug: body.collectionSlug,
+		format: body.format,
+		fileName: body.fileName,
+		sheetName: body.sheetName,
+		mapping: body.mapping,
+		onDuplicate: body.onDuplicate,
+		uniqueIdentifierField: body.uniqueIdentifierField,
+		abortOnError: body.abortOnError,
+		authorId: body.authorId,
+		revisionNote: body.revisionNote
+	};
+}
+//#endregion
+//#region src/plugins/transfer/client.ts
+var TransferClient = class {
+	client;
+	options;
+	service;
+	prefix;
+	constructor(client, options = {}) {
+		this.client = client;
+		this.options = options;
+		this.prefix = (options.apiPrefix ?? "/api/transfer").replace(/\/+$/, "");
+		const engine = client.getEngine();
+		if (engine) this.service = new TransferService(engine, options);
+	}
+	/**
+	* List all registered collections across all active plugins.
+	*/
+	async listCollections() {
+		if (this.service) return this.service.listCollections();
+		return (await this.client.request(`${this.prefix}/collections`)).collections;
+	}
+	/**
+	* Get the collection schema and default mapping template.
+	*/
+	async getSchema(collectionSlug) {
+		if (this.service) return {
+			schema: this.service.getCollectionSchema(collectionSlug),
+			template: this.service.getMappingTemplate(collectionSlug)
+		};
+		return this.client.request(`${this.prefix}/${collectionSlug}/schema`);
+	}
+	/**
+	* Inspect a source file or payload.
+	*/
+	async inspect(data, options = {}) {
+		if (this.service) return this.service.inspectSource(data, options);
+		return this.client.request(`${this.prefix}/inspect`, {
+			method: "POST",
+			body: JSON.stringify({
+				data,
+				...options
+			})
+		});
+	}
+	/**
+	* Dry-run validation of a source batch against a target collection and database constraints.
+	*/
+	async preview(collectionSlug, data, mapping, options = {}) {
+		if (this.service) return this.service.validateImport(collectionSlug, data, mapping, options);
+		return this.client.request(`${this.prefix}/${collectionSlug}/preview`, {
+			method: "POST",
+			body: JSON.stringify({
+				data,
+				mapping,
+				...options
+			})
+		});
+	}
+	/**
+	* Execute an import batch into a target collection.
+	*/
+	async import(collectionSlug, data, mapping, options = {}) {
+		if (this.service) return this.service.importData(collectionSlug, data, mapping, options);
+		return this.client.request(`${this.prefix}/${collectionSlug}/import`, {
+			method: "POST",
+			body: JSON.stringify({
+				data,
+				mapping,
+				...options
+			})
+		});
+	}
+	/**
+	* Export collection records to JSON, Excel, or CSV.
+	*/
+	async export(collectionSlug, options = {}) {
+		if (this.service) return this.service.exportData(collectionSlug, options);
+		return await this.client.request(`${this.prefix}/${collectionSlug}/export`, {
+			method: "POST",
+			body: JSON.stringify(options)
+		});
+	}
+};
+/**
+* Access or instantiate the TransferClient associated with a CMSClient instance.
+*/
+function getTransferClient(client, options) {
+	if (client.__transferClient) return client.__transferClient;
+	const tc = new TransferClient(client, options);
+	client.__transferClient = tc;
+	return tc;
+}
+//#endregion
+//#region src/plugins/transfer/index.ts
+/**
+* @azlib/cms - Built-in Universal Transfer Plugin
+*/
+/**
+* Built-in Universal Data Transfer plugin factory for @azlib/cms.
+* Equips the CMS engine with dynamic, schema-driven import and export capabilities
+* across all collections, featuring file schema discovery, definition mapping,
+* multi-level data validation, database constraint verification, and multi-format support.
+*/
+const transferPlugin = definePlugin((options) => {
+	const opts = options || {};
+	return {
+		name: "transfer",
+		version: "1.0.0",
+		description: "Universal schema-driven data transfer plugin supporting import/export, definition mapping, and constraint validation",
+		setup(ctx) {
+			const service = new TransferService(ctx.engine, opts);
+			ctx.engine.__transferService = service;
+			if (opts.enableRoutes !== false) registerTransferRoutes(ctx, service, opts);
+		}
+	};
+});
+/**
+* Retrieve the active TransferService instance associated with a CMSEngine.
+*/
+function getTransferService(engine, options) {
+	if (engine.__transferService) return engine.__transferService;
+	const service = new TransferService(engine, options);
+	engine.__transferService = service;
+	return service;
+}
+//#endregion
 exports.CMSClient = CMSClient;
 exports.CMSEngine = CMSEngine;
 exports.CMSRouter = CMSRouter;
@@ -3243,6 +6662,10 @@ exports.DEFAULT_COLLECTIONS = DEFAULT_COLLECTIONS;
 exports.DEFAULT_ROLE_CAPABILITIES = DEFAULT_ROLE_CAPABILITIES;
 exports.EcommerceClient = EcommerceClient;
 exports.EcommerceService = EcommerceService;
+exports.HRMSClient = HRMSClient;
+exports.HRMSService = HRMSService;
+exports.HRMS_EMPLOYEE_TRANSFER_PRESET = HRMS_EMPLOYEE_TRANSFER_PRESET;
+exports.HRMS_EMPLOYER_TRANSFER_PRESET = HRMS_EMPLOYER_TRANSFER_PRESET;
 exports.HooksManager = HooksManager;
 exports.MediaManager = MediaManager;
 exports.MemoryStorageAdapter = MemoryStorageAdapter;
@@ -3250,23 +6673,53 @@ exports.OptionsManager = OptionsManager;
 exports.RBACManager = RBACManager;
 exports.RevisionManager = RevisionManager;
 exports.TaxonomyManager = TaxonomyManager;
+exports.TransferClient = TransferClient;
+exports.TransferService = TransferService;
 exports.VALID_STATUS_TRANSITIONS = VALID_STATUS_TRANSITIONS;
+exports.applyFieldTransform = applyFieldTransform;
 exports.collection = collection;
+exports.createAttendanceCollection = createAttendanceCollection;
 exports.createCMSEngine = createCMSEngine;
 exports.createCMSRouter = createCMSRouter;
 exports.createCmsClient = createCmsClient;
 exports.createDiscountCollection = createDiscountCollection;
 exports.createEcommerceTaxonomies = createEcommerceTaxonomies;
+exports.createEmployeeCollection = createEmployeeCollection;
+exports.createEmployerCollection = createEmployerCollection;
+exports.createHRMSTaxonomies = createHRMSTaxonomies;
+exports.createLeaveRequestCollection = createLeaveRequestCollection;
+exports.createLeaveTypeCollection = createLeaveTypeCollection;
 exports.createOrderCollection = createOrderCollection;
 exports.createProductCollection = createProductCollection;
 exports.defaultHooks = defaultHooks;
 exports.defineConfig = defineConfig;
 exports.definePlugin = definePlugin;
+exports.detectFormat = detectFormat;
 exports.ecommercePlugin = ecommercePlugin;
 exports.fields = fields;
+exports.generateSuggestedMapping = generateSuggestedMapping;
 exports.getEcommerceClient = getEcommerceClient;
 exports.getEcommerceService = getEcommerceService;
+exports.getHRMSClient = getHRMSClient;
+exports.getHRMSService = getHRMSService;
+exports.getTransferClient = getTransferClient;
+exports.getTransferService = getTransferService;
+exports.hrmsPlugin = hrmsPlugin;
+exports.inspectSource = inspectSource;
+exports.mapCmsItemForExport = mapCmsItemForExport;
+exports.mapSourceRecord = mapSourceRecord;
 exports.normalizeConfig = normalizeConfig;
+exports.parseCsvSource = parseCsvSource;
+exports.parseExcelSource = parseExcelSource;
+exports.parseJsonSource = parseJsonSource;
+exports.parseSource = parseSource;
 exports.resolveUniqueSlug = resolveUniqueSlug;
+exports.serializeCsv = serializeCsv;
+exports.serializeExcel = serializeExcel;
+exports.serializeJson = serializeJson;
+exports.serializeSource = serializeSource;
 exports.slugify = slugify;
+exports.summarizeCollection = summarizeCollection;
+exports.transferPlugin = transferPlugin;
 exports.validateAndNormalizeData = validateAndNormalizeData;
+exports.validateTransferBatch = validateTransferBatch;