@azlib/cms 0.3.0 → 0.5.0

package/dist/index.cjs

@@ -1397,9 +1397,9 @@ var CMSEngine = class {
 			async create(input, authorId = null) {
 				const filteredInput = await self.hooks.applyFilters("cms.before_create_input", input, { collection: slug });
 				const inputData = { ...filteredInput.data || {} };
-				if (filteredInput.title !== void 0) inputData.title = filteredInput.title;
-				if (filteredInput.slug !== void 0) inputData.slug = filteredInput.slug;
-				if (filteredInput.status !== void 0) inputData.status = filteredInput.status;
+				if (filteredInput.title !== void 0 && inputData.title === void 0) inputData.title = filteredInput.title;
+				if (filteredInput.slug !== void 0 && inputData.slug === void 0) inputData.slug = filteredInput.slug;
+				if (filteredInput.status !== void 0 && inputData.status === void 0) inputData.status = filteredInput.status;
 				const { data: normalizedData, errors } = validateAndNormalizeData(collConfig.fields, inputData);
 				if (Object.keys(errors).length > 0) throw new Error(`[CMSEngine] Validation failed for collection '${slug}': ${JSON.stringify(errors)}`);
 				const title = filteredInput.title ?? normalizedData.title ?? "";
@@ -1451,11 +1451,11 @@ var CMSEngine = class {
 					...existing.data,
 					...filteredInput.data || {}
 				};
-				if (filteredInput.title !== void 0) mergedData.title = filteredInput.title;
+				if (filteredInput.title !== void 0 && filteredInput.data?.title === void 0) mergedData.title = filteredInput.title;
 				else if (existing.title !== void 0 && mergedData.title === void 0) mergedData.title = existing.title;
-				if (filteredInput.slug !== void 0) mergedData.slug = filteredInput.slug;
+				if (filteredInput.slug !== void 0 && filteredInput.data?.slug === void 0) mergedData.slug = filteredInput.slug;
 				else if (existing.slug !== void 0 && mergedData.slug === void 0) mergedData.slug = existing.slug;
-				if (filteredInput.status !== void 0) mergedData.status = filteredInput.status;
+				if (filteredInput.status !== void 0 && filteredInput.data?.status === void 0) mergedData.status = filteredInput.status;
 				else if (existing.status !== void 0 && mergedData.status === void 0) mergedData.status = existing.status;
 				const { data: normalizedData, errors } = validateAndNormalizeData(collConfig.fields, mergedData);
 				if (Object.keys(errors).length > 0) throw new Error(`[CMSEngine] Validation failed updating '${slug}': ${JSON.stringify(errors)}`);
@@ -1842,6 +1842,12 @@ var CMSClient = class {
 			...options.headers || {}
 		};
 	}
+	/**
+	* Access underlying CMSEngine instance when in in-process mode.
+	*/
+	getEngine() {
+		return this.engine;
+	}
 	collection(slug) {
 		const self = this;
 		if (this.engine) {
@@ -1925,6 +1931,9 @@ var CMSClient = class {
 			return defaultValue;
 		}
 	} };
+	/**
+	* Perform an HTTP request against the CMS API (available in remote mode).
+	*/
 	async request(endpoint, init) {
 		if (!this.baseUrl) throw new Error(`[CMSClient] baseUrl must be provided when connecting to a remote CMS API.`);
 		const url = `${this.baseUrl}${endpoint}`;
@@ -1947,12 +1956,2886 @@ function createCmsClient(options) {
 	return new CMSClient(options);
 }
 //#endregion
+//#region src/plugins/ecommerce/schemas.ts
+/**
+* Creates the collection configuration for Products.
+*/
+function createProductCollection(options = {}) {
+	const slug = options.productCollectionSlug ?? "products";
+	const catSlug = options.categoriesTaxonomySlug ?? "product_categories";
+	const tagSlug = options.tagsTaxonomySlug ?? "product_tags";
+	const brandSlug = options.brandsTaxonomySlug ?? "product_brands";
+	const defaultCurrency = options.defaultCurrency ?? "USD";
+	return collection({
+		slug,
+		label: "Products",
+		singularLabel: "Product",
+		description: "Catalog products with pricing, inventory, images, and variants",
+		timestamps: true,
+		revisions: true,
+		draftable: true,
+		taxonomies: [
+			catSlug,
+			tagSlug,
+			brandSlug
+		],
+		defaultSort: {
+			field: "createdAt",
+			direction: "desc"
+		},
+		fields: [
+			fields.text({
+				name: "title",
+				label: "Product Title",
+				required: true
+			}),
+			fields.slug({
+				from: "title",
+				unique: true
+			}),
+			fields.text({
+				name: "sku",
+				label: "SKU",
+				description: "Stock Keeping Unit identifier"
+			}),
+			fields.number({
+				name: "price",
+				label: "Price",
+				required: true,
+				min: 0
+			}),
+			fields.number({
+				name: "compareAtPrice",
+				label: "Compare At Price",
+				description: "Original retail price for showing strike-through discounts",
+				min: 0
+			}),
+			fields.number({
+				name: "costPrice",
+				label: "Cost Price",
+				description: "Wholesale or production cost for margin tracking",
+				min: 0
+			}),
+			fields.text({
+				name: "currency",
+				label: "Currency",
+				defaultValue: defaultCurrency
+			}),
+			fields.number({
+				name: "stock",
+				label: "Inventory Quantity",
+				defaultValue: 0,
+				min: 0
+			}),
+			fields.boolean({
+				name: "trackInventory",
+				label: "Track Inventory",
+				defaultValue: options.inventoryManagement ?? true
+			}),
+			fields.select({
+				name: "status",
+				label: "Status",
+				options: [
+					"draft",
+					"published",
+					"out_of_stock",
+					"archived"
+				],
+				defaultValue: "draft"
+			}),
+			fields.richText({
+				name: "description",
+				label: "Full Description"
+			}),
+			fields.text({
+				name: "shortDescription",
+				label: "Short Description"
+			}),
+			fields.image({
+				name: "featuredImage",
+				label: "Featured Image"
+			}),
+			fields.json({
+				name: "gallery",
+				label: "Image Gallery",
+				defaultValue: []
+			}),
+			fields.json({
+				name: "variants",
+				label: "Product Variants",
+				defaultValue: []
+			}),
+			fields.json({
+				name: "attributes",
+				label: "Specifications / Attributes",
+				defaultValue: {}
+			}),
+			fields.number({
+				name: "weight",
+				label: "Weight",
+				min: 0
+			})
+		]
+	});
+}
+/**
+* Creates the collection configuration for Discounts / Coupons.
+*/
+function createDiscountCollection(options = {}) {
+	return collection({
+		slug: options.discountCollectionSlug ?? "discounts",
+		label: "Discounts",
+		singularLabel: "Discount",
+		description: "Promotional discount codes and coupons",
+		timestamps: true,
+		revisions: true,
+		draftable: false,
+		defaultSort: {
+			field: "createdAt",
+			direction: "desc"
+		},
+		fields: [
+			fields.text({
+				name: "title",
+				label: "Discount Name",
+				required: true
+			}),
+			fields.text({
+				name: "code",
+				label: "Coupon Code",
+				required: true,
+				unique: true
+			}),
+			fields.select({
+				name: "discountType",
+				label: "Discount Type",
+				options: [
+					"percentage",
+					"fixed_amount",
+					"free_shipping"
+				],
+				defaultValue: "percentage"
+			}),
+			fields.number({
+				name: "value",
+				label: "Discount Value",
+				required: true,
+				min: 0
+			}),
+			fields.number({
+				name: "minOrderAmount",
+				label: "Minimum Order Amount",
+				min: 0
+			}),
+			fields.number({
+				name: "maxDiscountAmount",
+				label: "Maximum Discount Cap",
+				min: 0
+			}),
+			fields.number({
+				name: "maxUses",
+				label: "Maximum Uses",
+				min: 1
+			}),
+			fields.number({
+				name: "usedCount",
+				label: "Times Used",
+				defaultValue: 0,
+				min: 0
+			}),
+			fields.date({
+				name: "startDate",
+				label: "Start Date"
+			}),
+			fields.date({
+				name: "endDate",
+				label: "Expiration Date"
+			}),
+			fields.select({
+				name: "status",
+				label: "Status",
+				options: [
+					"active",
+					"disabled",
+					"expired"
+				],
+				defaultValue: "active"
+			}),
+			fields.json({
+				name: "appliesToProductIds",
+				label: "Specific Product IDs",
+				defaultValue: []
+			}),
+			fields.json({
+				name: "appliesToCategoryIds",
+				label: "Specific Category Term IDs",
+				defaultValue: []
+			})
+		]
+	});
+}
+/**
+* Creates the collection configuration for Orders.
+*/
+function createOrderCollection(options = {}) {
+	const slug = options.orderCollectionSlug ?? "orders";
+	const defaultCurrency = options.defaultCurrency ?? "USD";
+	return collection({
+		slug,
+		label: "Orders",
+		singularLabel: "Order",
+		description: "Customer orders, status lifecycle, and line items",
+		timestamps: true,
+		revisions: true,
+		draftable: false,
+		defaultSort: {
+			field: "createdAt",
+			direction: "desc"
+		},
+		fields: [
+			fields.text({
+				name: "orderNumber",
+				label: "Order Number",
+				required: true,
+				unique: true
+			}),
+			fields.text({
+				name: "customerEmail",
+				label: "Customer Email",
+				required: true
+			}),
+			fields.text({
+				name: "customerName",
+				label: "Customer Name"
+			}),
+			fields.select({
+				name: "status",
+				label: "Status",
+				options: [
+					"pending",
+					"paid",
+					"processing",
+					"shipped",
+					"delivered",
+					"cancelled",
+					"refunded"
+				],
+				defaultValue: "pending"
+			}),
+			fields.text({
+				name: "currency",
+				label: "Currency",
+				defaultValue: defaultCurrency
+			}),
+			fields.json({
+				name: "items",
+				label: "Line Items",
+				defaultValue: []
+			}),
+			fields.number({
+				name: "subtotal",
+				label: "Subtotal",
+				defaultValue: 0,
+				min: 0
+			}),
+			fields.number({
+				name: "discountTotal",
+				label: "Discount Total",
+				defaultValue: 0,
+				min: 0
+			}),
+			fields.text({
+				name: "discountCode",
+				label: "Discount Code"
+			}),
+			fields.number({
+				name: "shippingTotal",
+				label: "Shipping Total",
+				defaultValue: 0,
+				min: 0
+			}),
+			fields.number({
+				name: "taxTotal",
+				label: "Tax Total",
+				defaultValue: 0,
+				min: 0
+			}),
+			fields.number({
+				name: "total",
+				label: "Grand Total",
+				defaultValue: 0,
+				min: 0
+			}),
+			fields.json({
+				name: "shippingAddress",
+				label: "Shipping Address"
+			}),
+			fields.json({
+				name: "billingAddress",
+				label: "Billing Address"
+			}),
+			fields.text({
+				name: "paymentMethod",
+				label: "Payment Method"
+			}),
+			fields.text({
+				name: "notes",
+				label: "Notes"
+			})
+		]
+	});
+}
+/**
+* Creates the standard e-commerce taxonomies: product categories, tags, and brands.
+*/
+function createEcommerceTaxonomies(options = {}) {
+	const productSlug = options.productCollectionSlug ?? "products";
+	const catSlug = options.categoriesTaxonomySlug ?? "product_categories";
+	const tagSlug = options.tagsTaxonomySlug ?? "product_tags";
+	const brandSlug = options.brandsTaxonomySlug ?? "product_brands";
+	return [
+		{
+			slug: catSlug,
+			label: "Product Categories",
+			singularLabel: "Product Category",
+			hierarchical: true,
+			postTypes: [productSlug],
+			description: "Hierarchical categories and catalog collections for organizing products"
+		},
+		{
+			slug: tagSlug,
+			label: "Product Tags",
+			singularLabel: "Product Tag",
+			hierarchical: false,
+			postTypes: [productSlug],
+			description: "Flat keyword tags for filtering products"
+		},
+		{
+			slug: brandSlug,
+			label: "Brands",
+			singularLabel: "Brand",
+			hierarchical: false,
+			postTypes: [productSlug],
+			description: "Product manufacturers or brand labels"
+		}
+	];
+}
+//#endregion
+//#region src/plugins/ecommerce/service.ts
+var EcommerceService = class {
+	engine;
+	options;
+	productSlug;
+	discountSlug;
+	orderSlug;
+	categoriesTaxonomy;
+	tagsTaxonomy;
+	brandsTaxonomy;
+	defaultCurrency;
+	inventoryManagement;
+	constructor(engine, options = {}) {
+		this.engine = engine;
+		this.options = options;
+		this.productSlug = options.productCollectionSlug ?? "products";
+		this.discountSlug = options.discountCollectionSlug ?? "discounts";
+		this.orderSlug = options.orderCollectionSlug ?? "orders";
+		this.categoriesTaxonomy = options.categoriesTaxonomySlug ?? "product_categories";
+		this.tagsTaxonomy = options.tagsTaxonomySlug ?? "product_tags";
+		this.brandsTaxonomy = options.brandsTaxonomySlug ?? "product_brands";
+		this.defaultCurrency = options.defaultCurrency ?? "USD";
+		this.inventoryManagement = options.inventoryManagement ?? true;
+	}
+	get productsCollection() {
+		return this.engine.collection(this.productSlug);
+	}
+	get discountsCollection() {
+		return this.engine.collection(this.discountSlug);
+	}
+	get ordersCollection() {
+		return this.engine.collection(this.orderSlug);
+	}
+	/**
+	* Create a new product in the catalog.
+	*/
+	async createProduct(input, authorId) {
+		const productData = {
+			price: input.price,
+			compareAtPrice: input.compareAtPrice,
+			costPrice: input.costPrice,
+			sku: input.sku,
+			currency: input.currency ?? this.defaultCurrency,
+			stock: input.stock ?? 0,
+			trackInventory: input.trackInventory ?? this.inventoryManagement,
+			status: input.status ?? "draft",
+			description: input.description,
+			shortDescription: input.shortDescription,
+			featuredImage: input.featuredImage,
+			gallery: input.gallery ?? [],
+			variants: input.variants ?? [],
+			attributes: input.attributes ?? {},
+			weight: input.weight
+		};
+		const product = await this.productsCollection.create({
+			title: input.title,
+			slug: input.slug,
+			status: input.status === "published" ? "published" : "draft",
+			data: productData
+		}, authorId);
+		if (input.categoryIds && input.categoryIds.length > 0) await this.engine.taxonomies.assignTerms(product.id, input.categoryIds);
+		if (input.tagIds && input.tagIds.length > 0) await this.engine.taxonomies.assignTerms(product.id, input.tagIds);
+		if (input.brandIds && input.brandIds.length > 0) await this.engine.taxonomies.assignTerms(product.id, input.brandIds);
+		await this.engine.hooks.doAction("ecommerce.product_created", product);
+		return product;
+	}
+	/**
+	* Update an existing product.
+	*/
+	async updateProduct(id, input, authorId) {
+		const existing = await this.getProduct(id);
+		if (!existing) return null;
+		const updatedData = {
+			...existing.data,
+			...input.price !== void 0 ? { price: input.price } : {},
+			...input.compareAtPrice !== void 0 ? { compareAtPrice: input.compareAtPrice } : {},
+			...input.costPrice !== void 0 ? { costPrice: input.costPrice } : {},
+			...input.sku !== void 0 ? { sku: input.sku } : {},
+			...input.currency !== void 0 ? { currency: input.currency } : {},
+			...input.stock !== void 0 ? { stock: input.stock } : {},
+			...input.trackInventory !== void 0 ? { trackInventory: input.trackInventory } : {},
+			...input.status !== void 0 ? { status: input.status } : {},
+			...input.description !== void 0 ? { description: input.description } : {},
+			...input.shortDescription !== void 0 ? { shortDescription: input.shortDescription } : {},
+			...input.featuredImage !== void 0 ? { featuredImage: input.featuredImage } : {},
+			...input.gallery !== void 0 ? { gallery: input.gallery } : {},
+			...input.variants !== void 0 ? { variants: input.variants } : {},
+			...input.attributes !== void 0 ? { attributes: input.attributes } : {},
+			...input.weight !== void 0 ? { weight: input.weight } : {}
+		};
+		const updated = await this.productsCollection.update(id, {
+			...input.title ? { title: input.title } : {},
+			...input.slug ? { slug: input.slug } : {},
+			...input.status === "published" ? { status: "published" } : input.status ? { status: "draft" } : {},
+			data: updatedData
+		}, authorId);
+		if (updated) {
+			if (input.categoryIds) await this.engine.taxonomies.assignTerms(id, input.categoryIds);
+			if (input.tagIds) await this.engine.taxonomies.assignTerms(id, input.tagIds);
+			if (input.brandIds) await this.engine.taxonomies.assignTerms(id, input.brandIds);
+			await this.engine.hooks.doAction("ecommerce.product_updated", updated);
+		}
+		return updated;
+	}
+	/**
+	* Get a product by ID.
+	*/
+	async getProduct(id) {
+		return this.productsCollection.findById(id);
+	}
+	/**
+	* Get a product by its URL slug.
+	*/
+	async getProductBySlug(slug) {
+		return this.productsCollection.findBySlug(slug);
+	}
+	/**
+	* Delete a product by ID.
+	*/
+	async deleteProduct(id) {
+		const deleted = await this.productsCollection.delete(id);
+		if (deleted) await this.engine.hooks.doAction("ecommerce.product_deleted", id);
+		return deleted;
+	}
+	/**
+	* List and filter catalog products.
+	*/
+	async listProducts(query = {}) {
+		let termIds;
+		if (query.categorySlug) {
+			const term = await this.engine.taxonomies.getTermBySlug(this.categoriesTaxonomy, query.categorySlug);
+			if (term) termIds = [term.id];
+			else return {
+				items: [],
+				total: 0,
+				limit: query.limit ?? 20,
+				offset: query.offset ?? 0,
+				hasMore: false
+			};
+		} else if (query.categoryId) termIds = [query.categoryId];
+		if (query.tagSlug) {
+			const term = await this.engine.taxonomies.getTermBySlug(this.tagsTaxonomy, query.tagSlug);
+			if (term) termIds = termIds ? [...termIds, term.id] : [term.id];
+		}
+		if (query.brandSlug) {
+			const term = await this.engine.taxonomies.getTermBySlug(this.brandsTaxonomy, query.brandSlug);
+			if (term) termIds = termIds ? [...termIds, term.id] : [term.id];
+		}
+		const contentStatus = query.status === "draft" ? "draft" : query.status === "published" ? "published" : void 0;
+		const result = await this.productsCollection.find({
+			search: query.search,
+			termIds,
+			status: contentStatus ?? "published",
+			limit: query.limit ?? 20,
+			offset: query.offset ?? 0,
+			orderBy: query.orderBy === "price" || query.orderBy === "stock" ? void 0 : query.orderBy,
+			orderDirection: query.orderDirection ?? "desc"
+		});
+		let items = result.items;
+		if (query.status) {
+			const statuses = Array.isArray(query.status) ? query.status : [query.status];
+			items = items.filter((p) => statuses.includes(p.data.status));
+		}
+		if (query.minPrice !== void 0) items = items.filter((p) => p.data.price >= query.minPrice);
+		if (query.maxPrice !== void 0) items = items.filter((p) => p.data.price <= query.maxPrice);
+		if (query.inStock) items = items.filter((p) => !p.data.trackInventory || p.data.stock > 0);
+		if (query.orderBy === "price") items.sort((a, b) => query.orderDirection === "asc" ? a.data.price - b.data.price : b.data.price - a.data.price);
+		else if (query.orderBy === "stock") items.sort((a, b) => query.orderDirection === "asc" ? a.data.stock - b.data.stock : b.data.stock - a.data.stock);
+		return {
+			items,
+			total: items.length,
+			limit: result.limit,
+			offset: result.offset,
+			hasMore: result.offset + items.length < result.total
+		};
+	}
+	/**
+	* Upload and link a product image to its gallery and featured slot.
+	*/
+	async uploadProductImage(productId, file, authorId) {
+		const product = await this.getProduct(productId);
+		if (!product) throw new Error(`[EcommerceService] Product '${productId}' not found.`);
+		const media = await this.engine.media.upload({
+			filename: file.filename,
+			mimeType: file.mimeType,
+			sizeBytes: file.sizeBytes,
+			url: file.url,
+			altText: file.altText ?? product.title,
+			caption: file.caption,
+			width: file.width,
+			height: file.height
+		}, authorId);
+		const gallery = [...product.data.gallery || []];
+		gallery.push({
+			id: media.id,
+			url: media.url,
+			altText: media.altText,
+			caption: media.caption,
+			width: media.width,
+			height: media.height
+		});
+		const isFeatured = file.isFeatured ?? !product.data.featuredImage;
+		const updated = await this.productsCollection.update(productId, { data: {
+			...product.data,
+			gallery,
+			...isFeatured ? { featuredImage: media.url } : {}
+		} });
+		await this.engine.hooks.doAction("ecommerce.product_image_added", {
+			product: updated ?? product,
+			media
+		});
+		return {
+			media,
+			product: updated ?? product
+		};
+	}
+	/**
+	* Adjust inventory stock for a product or variant.
+	*/
+	async adjustStock(productId, delta, variantId) {
+		const product = await this.getProduct(productId);
+		if (!product) return null;
+		if (!product.data.trackInventory) return product;
+		let newStock = product.data.stock;
+		const variants = [...product.data.variants || []];
+		if (variantId) {
+			const idx = variants.findIndex((v) => v.id === variantId);
+			if (idx !== -1) {
+				const currentVariantStock = variants[idx].stock ?? 0;
+				const updatedVariantStock = Math.max(0, currentVariantStock + delta);
+				variants[idx] = {
+					...variants[idx],
+					stock: updatedVariantStock
+				};
+			}
+		} else newStock = Math.max(0, product.data.stock + delta);
+		const newStatus = newStock === 0 && product.data.status === "published" ? "out_of_stock" : product.data.status === "out_of_stock" && newStock > 0 ? "published" : product.data.status;
+		const updated = await this.productsCollection.update(productId, { data: {
+			...product.data,
+			stock: newStock,
+			variants,
+			status: newStatus
+		} });
+		await this.engine.hooks.doAction("ecommerce.stock_changed", {
+			product: updated ?? product,
+			delta,
+			variantId,
+			oldStock: product.data.stock,
+			newStock
+		});
+		return updated;
+	}
+	/**
+	* Create a catalog category in the hierarchical category taxonomy.
+	*/
+	async createCategory(input) {
+		return this.engine.taxonomies.createTerm(this.categoriesTaxonomy, input);
+	}
+	/**
+	* Get all catalog categories.
+	*/
+	async getCategories(options) {
+		return this.engine.taxonomies.getTerms(this.categoriesTaxonomy, options);
+	}
+	/**
+	* Get full hierarchical catalog category tree.
+	*/
+	async getCategoryTree() {
+		return this.engine.taxonomies.getTermTree(this.categoriesTaxonomy);
+	}
+	/**
+	* Assign category IDs to a product.
+	*/
+	async assignProductCategory(productId, categoryIds) {
+		const ids = Array.isArray(categoryIds) ? categoryIds : [categoryIds];
+		await this.engine.taxonomies.assignTerms(productId, ids);
+	}
+	/**
+	* Get assigned categories for a product.
+	*/
+	async getProductCategories(productId) {
+		return this.engine.taxonomies.getContentTerms(productId, this.categoriesTaxonomy);
+	}
+	/**
+	* Create a promotional coupon / discount code.
+	*/
+	async createDiscount(input, authorId) {
+		const normalizedCode = input.code.trim().toUpperCase();
+		const discountData = {
+			code: normalizedCode,
+			discountType: input.discountType,
+			value: input.value,
+			minOrderAmount: input.minOrderAmount,
+			maxDiscountAmount: input.maxDiscountAmount,
+			maxUses: input.maxUses,
+			usedCount: 0,
+			startDate: input.startDate,
+			endDate: input.endDate,
+			status: input.status ?? "active",
+			appliesToProductIds: input.appliesToProductIds ?? [],
+			appliesToCategoryIds: input.appliesToCategoryIds ?? []
+		};
+		const discount = await this.discountsCollection.create({
+			title: input.title,
+			slug: normalizedCode.toLowerCase(),
+			status: "published",
+			data: discountData
+		}, authorId);
+		await this.engine.hooks.doAction("ecommerce.discount_created", discount);
+		return discount;
+	}
+	/**
+	* Find a discount code.
+	*/
+	async getDiscountByCode(code) {
+		const normalized = code.trim().toUpperCase();
+		return (await this.discountsCollection.find({ limit: 100 })).items.find((d) => d.data.code?.toUpperCase() === normalized) ?? null;
+	}
+	/**
+	* Validate a discount coupon against cart items and order subtotal.
+	*/
+	async validateDiscount(code, cartSubtotal, productIds = []) {
+		const normalized = code.trim().toUpperCase();
+		const discount = await this.getDiscountByCode(normalized);
+		if (!discount) return {
+			valid: false,
+			code: normalized,
+			discountAmount: 0,
+			message: `Discount code '${code}' not found.`
+		};
+		const { data } = discount;
+		if (data.status !== "active") return {
+			valid: false,
+			code: normalized,
+			discountAmount: 0,
+			message: "Discount code is currently inactive."
+		};
+		const now = Date.now();
+		if (data.startDate && new Date(data.startDate).getTime() > now) return {
+			valid: false,
+			code: normalized,
+			discountAmount: 0,
+			message: "Discount code is not yet active."
+		};
+		if (data.endDate && new Date(data.endDate).getTime() < now) return {
+			valid: false,
+			code: normalized,
+			discountAmount: 0,
+			message: "Discount code has expired."
+		};
+		if (data.maxUses !== void 0 && data.usedCount >= data.maxUses) return {
+			valid: false,
+			code: normalized,
+			discountAmount: 0,
+			message: "Discount code usage limit reached."
+		};
+		if (data.minOrderAmount !== void 0 && cartSubtotal < data.minOrderAmount) return {
+			valid: false,
+			code: normalized,
+			discountAmount: 0,
+			message: `Minimum order amount of ${data.minOrderAmount} required for this coupon.`
+		};
+		if (data.appliesToProductIds && data.appliesToProductIds.length > 0 && productIds.length > 0) {
+			if (!productIds.some((id) => data.appliesToProductIds?.includes(id))) return {
+				valid: false,
+				code: normalized,
+				discountAmount: 0,
+				message: "Coupon is not applicable to any products in your cart."
+			};
+		}
+		let discountAmount = 0;
+		if (data.discountType === "percentage") {
+			discountAmount = cartSubtotal * data.value / 100;
+			if (data.maxDiscountAmount) discountAmount = Math.min(discountAmount, data.maxDiscountAmount);
+		} else if (data.discountType === "fixed_amount") discountAmount = Math.min(data.value, cartSubtotal);
+		else if (data.discountType === "free_shipping") discountAmount = 0;
+		discountAmount = await this.engine.hooks.applyFilters("ecommerce.apply_discount", discountAmount, {
+			discount,
+			cartSubtotal
+		});
+		return {
+			valid: true,
+			code: normalized,
+			discountAmount: Math.round(discountAmount * 100) / 100,
+			discountType: data.discountType,
+			discount
+		};
+	}
+	/**
+	* Calculate cart subtotals, apply discounts, shipping, and taxes.
+	*/
+	async calculateCart(input) {
+		const lineItems = [];
+		let subtotal = 0;
+		const productIds = [];
+		for (const item of input.items) {
+			const product = await this.getProduct(item.productId);
+			if (!product) throw new Error(`[EcommerceService] Product '${item.productId}' not found.`);
+			productIds.push(product.id);
+			let price = product.data.price;
+			let sku = product.data.sku;
+			let title = product.title ?? "Product";
+			let availableStock = product.data.stock;
+			let image = product.data.featuredImage;
+			if (item.variantId && product.data.variants) {
+				const variant = product.data.variants.find((v) => v.id === item.variantId);
+				if (variant) {
+					price = variant.price ?? price;
+					sku = variant.sku ?? sku;
+					title = `${title} (${variant.title})`;
+					availableStock = variant.stock ?? availableStock;
+					image = variant.image ?? image;
+				}
+			}
+			if (this.inventoryManagement && product.data.trackInventory && availableStock < item.quantity) throw new Error(`[EcommerceService] Insufficient stock for '${title}'. Available: ${availableStock}, Requested: ${item.quantity}.`);
+			const itemSubtotal = Math.round(price * item.quantity * 100) / 100;
+			subtotal += itemSubtotal;
+			lineItems.push({
+				productId: product.id,
+				variantId: item.variantId,
+				title,
+				sku,
+				price,
+				quantity: item.quantity,
+				subtotal: itemSubtotal,
+				image
+			});
+		}
+		subtotal = Math.round(subtotal * 100) / 100;
+		let discountTotal = 0;
+		let discountType;
+		if (input.discountCode) {
+			const validation = await this.validateDiscount(input.discountCode, subtotal, productIds);
+			if (validation.valid) {
+				discountTotal = validation.discountAmount;
+				discountType = validation.discountType;
+			}
+		}
+		let shippingTotal = input.shippingCost ?? this.options.defaultShippingCost ?? 0;
+		if (discountType === "free_shipping") shippingTotal = 0;
+		const taxRate = input.taxRate ?? this.options.defaultTaxRate ?? 0;
+		const taxableAmount = Math.max(0, subtotal - discountTotal);
+		const taxTotal = Math.round(taxableAmount * taxRate * 100) / 100;
+		const total = Math.round((taxableAmount + shippingTotal + taxTotal) * 100) / 100;
+		const result = {
+			items: lineItems,
+			subtotal,
+			discountTotal,
+			discountCode: input.discountCode,
+			shippingTotal,
+			taxTotal,
+			total,
+			currency: this.defaultCurrency
+		};
+		return this.engine.hooks.applyFilters("ecommerce.calculate_totals", result, input);
+	}
+	/**
+	* Place a new order with cart validation, inventory deduction, and coupon counter updates.
+	*/
+	async createOrder(input, authorId) {
+		const calc = await this.calculateCart({
+			items: input.items,
+			discountCode: input.discountCode,
+			shippingCost: input.shippingCost,
+			taxRate: input.taxRate
+		});
+		const orderNumber = `ORD-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10).replace(/-/g, "")}-${Math.random().toString(36).substring(2, 6).toUpperCase()}`;
+		if (this.inventoryManagement) for (const item of input.items) await this.adjustStock(item.productId, -item.quantity, item.variantId);
+		if (input.discountCode) {
+			const discount = await this.getDiscountByCode(input.discountCode);
+			if (discount) await this.discountsCollection.update(discount.id, { data: {
+				...discount.data,
+				usedCount: (discount.data.usedCount || 0) + 1
+			} });
+		}
+		const orderData = {
+			orderNumber,
+			customerEmail: input.customerEmail,
+			customerName: input.customerName,
+			status: "pending",
+			currency: calc.currency,
+			items: calc.items,
+			subtotal: calc.subtotal,
+			discountTotal: calc.discountTotal,
+			discountCode: calc.discountCode,
+			shippingTotal: calc.shippingTotal,
+			taxTotal: calc.taxTotal,
+			total: calc.total,
+			shippingAddress: input.shippingAddress,
+			billingAddress: input.billingAddress,
+			paymentMethod: input.paymentMethod,
+			notes: input.notes
+		};
+		const order = await this.ordersCollection.create({
+			title: `Order #${orderNumber}`,
+			slug: orderNumber.toLowerCase(),
+			status: "published",
+			data: orderData
+		}, authorId);
+		await this.engine.hooks.doAction("ecommerce.order_created", order);
+		return order;
+	}
+	/**
+	* Get order by ID.
+	*/
+	async getOrder(id) {
+		return this.ordersCollection.findById(id);
+	}
+	/**
+	* Get order by order number.
+	*/
+	async getOrderByNumber(orderNumber) {
+		return (await this.ordersCollection.find({ limit: 100 })).items.find((o) => o.data.orderNumber?.toUpperCase() === orderNumber.toUpperCase()) ?? null;
+	}
+	/**
+	* Update the status of an order (e.g. pending -> paid -> shipped).
+	*/
+	async updateOrderStatus(id, status, note) {
+		const existing = await this.getOrder(id);
+		if (!existing) return null;
+		const oldStatus = existing.data.status;
+		const updated = await this.ordersCollection.update(id, { data: {
+			...existing.data,
+			status
+		} }, void 0, note);
+		if (updated) await this.engine.hooks.doAction("ecommerce.order_status_changed", {
+			order: updated,
+			oldStatus,
+			newStatus: status,
+			note
+		});
+		return updated;
+	}
+};
+//#endregion
+//#region src/plugins/ecommerce/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 registerEcommerceRoutes(ctx, service, options = {}) {
+	const prefix = (options.apiPrefix ?? "/api/ecommerce").replace(/\/+$/, "");
+	ctx.registerRoute("GET", `${prefix}/products`, async (_req, { url }) => {
+		try {
+			const categorySlug = url.searchParams.get("category") ?? void 0;
+			const categoryId = url.searchParams.get("categoryId") ?? void 0;
+			const tagSlug = url.searchParams.get("tag") ?? void 0;
+			const brandSlug = url.searchParams.get("brand") ?? void 0;
+			const search = url.searchParams.get("search") ?? void 0;
+			const statusParam = url.searchParams.get("status");
+			const inStock = url.searchParams.get("inStock") === "true";
+			const minPriceStr = url.searchParams.get("minPrice");
+			const maxPriceStr = url.searchParams.get("maxPrice");
+			const minPrice = minPriceStr ? parseFloat(minPriceStr) : void 0;
+			const maxPrice = maxPriceStr ? parseFloat(maxPriceStr) : void 0;
+			const orderBy = url.searchParams.get("orderBy");
+			const orderDirection = url.searchParams.get("orderDirection") ?? "desc";
+			const limitStr = url.searchParams.get("limit");
+			const offsetStr = url.searchParams.get("offset");
+			const limit = limitStr ? parseInt(limitStr, 10) : 20;
+			const offset = offsetStr ? parseInt(offsetStr, 10) : 0;
+			return json$1(await service.listProducts({
+				categorySlug,
+				categoryId,
+				tagSlug,
+				brandSlug,
+				search,
+				status: statusParam,
+				inStock,
+				minPrice,
+				maxPrice,
+				orderBy,
+				orderDirection,
+				limit,
+				offset
+			}));
+		} catch (err) {
+			return badRequest$1(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("GET", `${prefix}/products/:id`, async (_req, { params, url }) => {
+		const id = params.id;
+		const by = url.searchParams.get("by");
+		let product = null;
+		if (by === "slug") product = await service.getProductBySlug(id);
+		else {
+			product = await service.getProduct(id);
+			if (!product) product = await service.getProductBySlug(id);
+		}
+		if (!product) return notFound$1(`Product '${id}' not found`);
+		return json$1(product);
+	});
+	ctx.registerRoute("POST", `${prefix}/products`, async (req) => {
+		try {
+			const body = await req.json();
+			if (!body.title) return badRequest$1("Product 'title' is required.");
+			if (body.price === void 0 || body.price < 0) return badRequest$1("Valid product 'price' is required.");
+			return json$1(await service.createProduct(body), 201);
+		} catch (err) {
+			return badRequest$1(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$1(`Product '${params.id}' not found.`);
+			return json$1(updated);
+		} catch (err) {
+			return badRequest$1(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("DELETE", `${prefix}/products/:id`, async (_req, { params }) => {
+		if (!await service.deleteProduct(params.id)) return notFound$1(`Product '${params.id}' not found.`);
+		return json$1({
+			success: true,
+			id: params.id
+		});
+	});
+	ctx.registerRoute("POST", `${prefix}/products/:id/images`, async (req, { params }) => {
+		try {
+			const body = await req.json();
+			if (!body.filename || !body.mimeType) return badRequest$1("'filename' and 'mimeType' are required.");
+			return json$1(await service.uploadProductImage(params.id, {
+				filename: body.filename,
+				mimeType: body.mimeType,
+				sizeBytes: body.sizeBytes ?? 0,
+				url: body.url,
+				altText: body.altText,
+				caption: body.caption,
+				width: body.width,
+				height: body.height,
+				isFeatured: body.isFeatured
+			}), 201);
+		} catch (err) {
+			return badRequest$1(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("GET", `${prefix}/categories`, async (_req, { url }) => {
+		try {
+			if (url.searchParams.get("tree") === "true") return json$1(await service.getCategoryTree());
+			const parentId = url.searchParams.get("parentId");
+			return json$1(await service.getCategories({ parentId: parentId === "null" ? null : parentId ?? void 0 }));
+		} catch (err) {
+			return badRequest$1(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$1("Category 'name' is required.");
+			return json$1(await service.createCategory(body), 201);
+		} catch (err) {
+			return badRequest$1(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$1("'title' and 'code' are required.");
+				if (body.value === void 0 || body.value < 0) return badRequest$1("Valid discount 'value' is required.");
+				return json$1(await service.createDiscount(body), 201);
+			} catch (err) {
+				return badRequest$1(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$1("Discount 'code' is required.");
+				const subtotal = Number(body.subtotal ?? 0);
+				const productIds = Array.isArray(body.productIds) ? body.productIds : [];
+				return json$1(await service.validateDiscount(body.code, subtotal, productIds));
+			} catch (err) {
+				return badRequest$1(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$1("'items' array is required and must not be empty.");
+			return json$1(await service.calculateCart(body));
+		} catch (err) {
+			return badRequest$1(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$1("'customerEmail' is required.");
+				if (!body.items || !Array.isArray(body.items) || body.items.length === 0) return badRequest$1("'items' array is required.");
+				return json$1(await service.createOrder(body), 201);
+			} catch (err) {
+				return badRequest$1(err instanceof Error ? err.message : String(err));
+			}
+		});
+		ctx.registerRoute("GET", `${prefix}/orders/:id`, async (_req, { params, url }) => {
+			const id = params.id;
+			const by = url.searchParams.get("by");
+			let order = null;
+			if (by === "number") order = await service.getOrderByNumber(id);
+			else {
+				order = await service.getOrder(id);
+				if (!order) order = await service.getOrderByNumber(id);
+			}
+			if (!order) return notFound$1(`Order '${id}' not found.`);
+			return json$1(order);
+		});
+		ctx.registerRoute("PATCH", `${prefix}/orders/:id/status`, async (req, { params }) => {
+			try {
+				const body = await req.json();
+				if (!body.status) return badRequest$1("New 'status' is required.");
+				const updated = await service.updateOrderStatus(params.id, body.status, body.note);
+				if (!updated) return notFound$1(`Order '${params.id}' not found.`);
+				return json$1(updated);
+			} catch (err) {
+				return badRequest$1(err instanceof Error ? err.message : String(err));
+			}
+		});
+	}
+}
+//#endregion
+//#region src/plugins/ecommerce/client.ts
+var EcommerceClient = class {
+	client;
+	options;
+	service;
+	prefix;
+	constructor(client, options = {}) {
+		this.client = client;
+		this.options = options;
+		this.prefix = (options.apiPrefix ?? "/api/ecommerce").replace(/\/+$/, "");
+		const engine = client.getEngine();
+		if (engine) this.service = new EcommerceService(engine, options);
+	}
+	products = {
+		find: async (query = {}) => {
+			if (this.service) return this.service.listProducts(query);
+			const params = new URLSearchParams();
+			if (query.categorySlug) params.set("category", query.categorySlug);
+			if (query.categoryId) params.set("categoryId", query.categoryId);
+			if (query.tagSlug) params.set("tag", query.tagSlug);
+			if (query.brandSlug) params.set("brand", query.brandSlug);
+			if (query.search) params.set("search", query.search);
+			if (query.inStock) params.set("inStock", "true");
+			if (query.minPrice !== void 0) params.set("minPrice", String(query.minPrice));
+			if (query.maxPrice !== void 0) params.set("maxPrice", String(query.maxPrice));
+			if (query.orderBy) params.set("orderBy", query.orderBy);
+			if (query.orderDirection) params.set("orderDirection", query.orderDirection);
+			if (query.limit !== void 0) params.set("limit", String(query.limit));
+			if (query.offset !== void 0) params.set("offset", String(query.offset));
+			const q = params.toString() ? `?${params.toString()}` : "";
+			return this.client.request(`${this.prefix}/products${q}`);
+		},
+		get: async (idOrSlug, by) => {
+			if (this.service) return by === "slug" ? this.service.getProductBySlug(idOrSlug) : this.service.getProduct(idOrSlug);
+			const query = by ? `?by=${by}` : "";
+			return this.client.request(`${this.prefix}/products/${encodeURIComponent(idOrSlug)}${query}`);
+		},
+		create: async (data) => {
+			if (this.service) return this.service.createProduct(data);
+			return this.client.request(`${this.prefix}/products`, {
+				method: "POST",
+				body: JSON.stringify(data)
+			});
+		},
+		update: async (id, data) => {
+			if (this.service) return this.service.updateProduct(id, data);
+			return this.client.request(`${this.prefix}/products/${encodeURIComponent(id)}`, {
+				method: "PUT",
+				body: JSON.stringify(data)
+			});
+		},
+		delete: async (id) => {
+			if (this.service) return this.service.deleteProduct(id);
+			const res = await this.client.request(`${this.prefix}/products/${encodeURIComponent(id)}`, { method: "DELETE" });
+			return Boolean(res?.success);
+		},
+		uploadImage: async (productId, file) => {
+			if (this.service) return this.service.uploadProductImage(productId, file);
+			return this.client.request(`${this.prefix}/products/${encodeURIComponent(productId)}/images`, {
+				method: "POST",
+				body: JSON.stringify(file)
+			});
+		}
+	};
+	categories = {
+		list: async (options) => {
+			if (this.service) return this.service.getCategories(options);
+			const q = options?.parentId !== void 0 ? `?parentId=${options.parentId}` : "";
+			return this.client.request(`${this.prefix}/categories${q}`);
+		},
+		tree: async () => {
+			if (this.service) return this.service.getCategoryTree();
+			return this.client.request(`${this.prefix}/categories?tree=true`);
+		},
+		create: async (input) => {
+			if (this.service) return this.service.createCategory(input);
+			return this.client.request(`${this.prefix}/categories`, {
+				method: "POST",
+				body: JSON.stringify(input)
+			});
+		}
+	};
+	discounts = {
+		validate: async (code, subtotal, productIds) => {
+			if (this.service) return this.service.validateDiscount(code, subtotal, productIds);
+			return this.client.request(`${this.prefix}/discounts/validate`, {
+				method: "POST",
+				body: JSON.stringify({
+					code,
+					subtotal,
+					productIds
+				})
+			});
+		},
+		create: async (input) => {
+			if (this.service) return this.service.createDiscount(input);
+			return this.client.request(`${this.prefix}/discounts`, {
+				method: "POST",
+				body: JSON.stringify(input)
+			});
+		}
+	};
+	cart = { calculate: async (input) => {
+		if (this.service) return this.service.calculateCart(input);
+		return this.client.request(`${this.prefix}/cart/calculate`, {
+			method: "POST",
+			body: JSON.stringify(input)
+		});
+	} };
+	orders = {
+		create: async (input) => {
+			if (this.service) return this.service.createOrder(input);
+			return this.client.request(`${this.prefix}/orders`, {
+				method: "POST",
+				body: JSON.stringify(input)
+			});
+		},
+		get: async (idOrNumber, by) => {
+			if (this.service) return by === "number" ? this.service.getOrderByNumber(idOrNumber) : this.service.getOrder(idOrNumber);
+			const q = by ? `?by=${by}` : "";
+			return this.client.request(`${this.prefix}/orders/${encodeURIComponent(idOrNumber)}${q}`);
+		},
+		updateStatus: async (id, status, note) => {
+			if (this.service) return this.service.updateOrderStatus(id, status, note);
+			return this.client.request(`${this.prefix}/orders/${encodeURIComponent(id)}/status`, {
+				method: "PATCH",
+				body: JSON.stringify({
+					status,
+					note
+				})
+			});
+		}
+	};
+};
+/**
+* Get or create an EcommerceClient adapter for a CMSClient.
+*/
+function getEcommerceClient(client, options) {
+	return new EcommerceClient(client, options);
+}
+//#endregion
+//#region src/plugins/ecommerce/index.ts
+/**
+* @azlib/cms - Built-in E-commerce Plugin
+*/
+/**
+* Built-in E-commerce plugin factory for @azlib/cms.
+* Equips the CMS engine with product catalogs, hierarchical categories,
+* image uploading, discount coupons, cart calculation, and order tracking.
+*/
+const ecommercePlugin = definePlugin((options) => {
+	const opts = options || {};
+	const collections = [createProductCollection(opts)];
+	if (opts.enableDiscounts !== false) collections.push(createDiscountCollection(opts));
+	if (opts.enableOrders !== false) collections.push(createOrderCollection(opts));
+	return {
+		name: "ecommerce",
+		version: "1.0.0",
+		description: "Built-in E-commerce shopping, products, catalogs, discounts, and orders plugin",
+		collections,
+		taxonomies: createEcommerceTaxonomies(opts),
+		setup(ctx) {
+			const service = new EcommerceService(ctx.engine, opts);
+			ctx.engine.__ecommerceService = service;
+			registerEcommerceRoutes(ctx, service, opts);
+		}
+	};
+});
+/**
+* Retrieve the active EcommerceService instance associated with a CMSEngine.
+*/
+function getEcommerceService(engine, options) {
+	if (engine.__ecommerceService) return engine.__ecommerceService;
+	const service = new EcommerceService(engine, options);
+	engine.__ecommerceService = service;
+	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(data, status = 200) {
+	return new Response(JSON.stringify(data), {
+		status,
+		headers: {
+			"Content-Type": "application/json",
+			"Access-Control-Allow-Origin": "*"
+		}
+	});
+}
+function badRequest(message) {
+	return json({ error: message }, 400);
+}
+function notFound(message) {
+	return json({ 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(await service.listEmployers({
+				status,
+				page,
+				limit
+			}));
+		} catch (err) {
+			return badRequest(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("companyName is required.");
+			return json(await service.createEmployer(body), 201);
+		} catch (err) {
+			return badRequest(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(`Employer '${params.id}' not found.`);
+			return json(employer);
+		} catch (err) {
+			return badRequest(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(`Employer '${params.id}' not found.`);
+			return json(updated);
+		} catch (err) {
+			return badRequest(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(await service.listEmployees({
+				employerId,
+				department,
+				employmentType,
+				status,
+				search,
+				page,
+				limit
+			}));
+		} catch (err) {
+			return badRequest(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("employerId is required.");
+			if (!body.employeeNumber) return badRequest("employeeNumber is required.");
+			if (!body.firstName || !body.lastName) return badRequest("firstName and lastName are required.");
+			if (!body.email) return badRequest("email is required.");
+			return json(await service.createEmployee(body), 201);
+		} catch (err) {
+			return badRequest(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(`Employee '${params.id}' not found.`);
+			return json(employee);
+		} catch (err) {
+			return badRequest(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(`Employee '${params.id}' not found.`);
+			return json(updated);
+		} catch (err) {
+			return badRequest(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(`Employee '${params.id}' not found.`);
+			return json({ success: true });
+		} catch (err) {
+			return badRequest(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(await service.calculateLeaveBalance(params.id, year));
+		} catch (err) {
+			return badRequest(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({
+				items: reports,
+				total: reports.length
+			});
+		} catch (err) {
+			return badRequest(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("employeeId is required.");
+			return json(await service.checkIn(body), 201);
+		} catch (err) {
+			return badRequest(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("employeeId is required.");
+			return json(await service.checkOut(body));
+		} catch (err) {
+			return badRequest(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(await service.listAttendance({
+				employerId,
+				employeeId,
+				date,
+				startDate,
+				endDate,
+				status,
+				page,
+				limit
+			}));
+		} catch (err) {
+			return badRequest(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("employerId, employeeId, date, and checkInAt are required.");
+			return json(await service.recordAttendanceManual(body), 201);
+		} catch (err) {
+			return badRequest(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({
+				items: types,
+				total: types.length
+			});
+		} catch (err) {
+			return badRequest(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("name, code, and daysAllowedPerYear are required.");
+			return json(await service.createLeaveType(body), 201);
+		} catch (err) {
+			return badRequest(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(`Leave type '${params.id}' not found.`);
+			return json(leaveType);
+		} catch (err) {
+			return badRequest(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(await service.listLeaveRequests({
+				employerId,
+				employeeId,
+				leaveTypeId,
+				status,
+				year,
+				page,
+				limit
+			}));
+		} catch (err) {
+			return badRequest(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("employeeId, leaveTypeId, startDate, and endDate are required.");
+			return json(await service.requestLeave(body), 201);
+		} catch (err) {
+			return badRequest(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(await service.approveLeave({
+				requestId: params.id,
+				approverId
+			}));
+		} catch (err) {
+			return badRequest(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(await service.rejectLeave({
+				requestId: params.id,
+				approverId,
+				reason: body.reason
+			}));
+		} catch (err) {
+			return badRequest(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("POST", `${prefix}/leave-requests/:id/cancel`, async (_req, { params }) => {
+		try {
+			return json(await service.cancelLeave(params.id));
+		} catch (err) {
+			return badRequest(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
 exports.CMSClient = CMSClient;
 exports.CMSEngine = CMSEngine;
 exports.CMSRouter = CMSRouter;
 exports.ContentLifecycle = ContentLifecycle;
 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.HooksManager = HooksManager;
 exports.MediaManager = MediaManager;
 exports.MemoryStorageAdapter = MemoryStorageAdapter;
@@ -1962,13 +4845,29 @@ exports.RevisionManager = RevisionManager;
 exports.TaxonomyManager = TaxonomyManager;
 exports.VALID_STATUS_TRANSITIONS = VALID_STATUS_TRANSITIONS;
 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.ecommercePlugin = ecommercePlugin;
 exports.fields = fields;
+exports.getEcommerceClient = getEcommerceClient;
+exports.getEcommerceService = getEcommerceService;
+exports.getHRMSClient = getHRMSClient;
+exports.getHRMSService = getHRMSService;
+exports.hrmsPlugin = hrmsPlugin;
 exports.normalizeConfig = normalizeConfig;
 exports.resolveUniqueSlug = resolveUniqueSlug;
 exports.slugify = slugify;