@azlib/cms 0.2.0 → 0.4.0

package/dist/index.cjs

@@ -230,6 +230,7 @@ function normalizeConfig(config) {
 		},
 		collections,
 		taxonomies: config.taxonomies ?? [],
+		plugins: config.plugins ?? [],
 		admin: {
 			route: config.admin?.route ?? "/admin",
 			enableRegistration: config.admin?.enableRegistration ?? false,
@@ -1246,6 +1247,9 @@ var CMSEngine = class {
 	revisions;
 	lifecycle;
 	collections = /* @__PURE__ */ new Map();
+	plugins = /* @__PURE__ */ new Map();
+	customRoutes = /* @__PURE__ */ new Map();
+	pendingPluginSetups = [];
 	constructor(config = {}, storage, hooks) {
 		this.config = normalizeConfig(config);
 		this.hooks = hooks ?? new HooksManager();
@@ -1258,21 +1262,114 @@ var CMSEngine = class {
 		this.lifecycle = new ContentLifecycle(this.storage, this.hooks);
 		for (const coll of this.config.collections) this.collections.set(coll.slug, coll);
 		if (this.config.taxonomies) for (const tax of this.config.taxonomies) this.taxonomies.registerTaxonomy(tax);
+		if (this.config.plugins) for (const plugin of this.config.plugins) this.use(plugin);
+	}
+	/**
+	* Register a plugin with the CMS engine.
+	*/
+	use(plugin) {
+		if (this.plugins.has(plugin.name)) throw new Error(`[CMSEngine] Plugin '${plugin.name}' is already registered.`);
+		this.plugins.set(plugin.name, plugin);
+		if (plugin.collections) for (const coll of plugin.collections) this.registerCollection(coll);
+		if (plugin.taxonomies) for (const tax of plugin.taxonomies) this.taxonomies.registerTaxonomy(tax);
+		if (plugin.extendCollections) for (const [slug, fields] of Object.entries(plugin.extendCollections)) this.extendCollection(slug, fields);
+		if (plugin.setup) {
+			const context = {
+				engine: this,
+				hooks: this.hooks,
+				storage: this.storage,
+				options: this.options,
+				taxonomies: this.taxonomies,
+				media: this.media,
+				rbac: this.rbac,
+				revisions: this.revisions,
+				lifecycle: this.lifecycle,
+				registerCollection: (c) => this.registerCollection(c),
+				extendCollection: (s, f) => this.extendCollection(s, f),
+				registerTaxonomy: (t) => this.taxonomies.registerTaxonomy(t),
+				registerRoute: (m, p, h) => this.registerRoute(m, p, h)
+			};
+			const setupResult = plugin.setup(context);
+			if (setupResult instanceof Promise) this.pendingPluginSetups.push(setupResult);
+		}
+		return this;
+	}
+	/**
+	* Get all registered plugins.
+	*/
+	getPlugins() {
+		return Array.from(this.plugins.values());
+	}
+	/**
+	* Get a registered plugin by name.
+	*/
+	getPlugin(name) {
+		return this.plugins.get(name);
+	}
+	/**
+	* Check if a plugin is registered.
+	*/
+	hasPlugin(name) {
+		return this.plugins.has(name);
+	}
+	/**
+	* Register a collection dynamically.
+	*/
+	registerCollection(coll) {
+		this.collections.set(coll.slug, coll);
+	}
+	/**
+	* Inject additional field definitions into an existing collection.
+	*/
+	extendCollection(slug, newFields) {
+		const existing = this.collections.get(slug);
+		if (!existing) throw new Error(`[CMSEngine] Cannot extend non-existent collection '${slug}'.`);
+		const existingFieldNames = new Set(existing.fields.map((f) => f.name));
+		const addedFields = newFields.filter((f) => !existingFieldNames.has(f.name));
+		this.collections.set(slug, {
+			...existing,
+			fields: [...existing.fields, ...addedFields]
+		});
+	}
+	/**
+	* Register a custom Web Standard HTTP route on the engine.
+	*/
+	registerRoute(method, path, handler) {
+		const normalizedMethod = method.toUpperCase();
+		let methodMap = this.customRoutes.get(normalizedMethod);
+		if (!methodMap) {
+			methodMap = /* @__PURE__ */ new Map();
+			this.customRoutes.set(normalizedMethod, methodMap);
+		}
+		methodMap.set(path, handler);
+	}
+	/**
+	* Get all custom routes registered across all HTTP methods.
+	*/
+	getCustomRoutes() {
+		return this.customRoutes;
 	}
 	/**
 	* Initialize storage and trigger bootstrap hooks.
 	*/
 	async init() {
 		await this.storage.init();
+		if (this.pendingPluginSetups.length > 0) {
+			await Promise.all(this.pendingPluginSetups);
+			this.pendingPluginSetups = [];
+		}
 		if (this.config.site) {
 			if (!await this.options.has("site_name")) await this.options.set("site_name", this.config.site.name);
 		}
+		for (const plugin of this.plugins.values()) if (plugin.onInit) await plugin.onInit(this);
+		await this.hooks.doAction("cms.plugins_initialized", this);
 		await this.hooks.doAction("cms.init", this);
 	}
 	/**
-	* Close storage connections.
+	* Close storage connections and run plugin teardown hooks.
 	*/
 	async close() {
+		for (const plugin of this.plugins.values()) if (plugin.onClose) await plugin.onClose(this);
 		await this.storage.close();
 		await this.hooks.doAction("cms.close", this);
 	}
@@ -1298,38 +1395,39 @@ var CMSEngine = class {
 		return {
 			config: collConfig,
 			async create(input, authorId = null) {
-				const inputData = { ...input.data || {} };
-				if (input.title !== void 0) inputData.title = input.title;
-				if (input.slug !== void 0) inputData.slug = input.slug;
-				if (input.status !== void 0) inputData.status = input.status;
+				const filteredInput = await self.hooks.applyFilters("cms.before_create_input", input, { collection: slug });
+				const inputData = { ...filteredInput.data || {} };
+				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 = input.title ?? normalizedData.title ?? "";
-				const finalSlug = await resolveUniqueSlug(input.slug ? slugify(input.slug) : slugify(title) || "item", async (s) => {
+				const title = filteredInput.title ?? normalizedData.title ?? "";
+				const finalSlug = await resolveUniqueSlug(filteredInput.slug ? slugify(filteredInput.slug) : slugify(title) || "item", async (s) => {
 					return await self.storage.getContentBySlug(slug, s) !== null;
 				});
-				const status = input.status ?? (collConfig.draftable ? "draft" : "published");
+				const status = filteredInput.status ?? (collConfig.draftable ? "draft" : "published");
 				const nowIso = (/* @__PURE__ */ new Date()).toISOString();
 				const item = await self.storage.createContent({
 					collection: slug,
 					slug: finalSlug,
 					title,
 					status,
-					parentId: collConfig.hierarchical ? input.parentId ?? null : null,
+					parentId: collConfig.hierarchical ? filteredInput.parentId ?? null : null,
 					authorId,
 					publishedAt: status === "published" ? nowIso : null,
-					scheduledAt: status === "scheduled" ? input.scheduledAt ?? null : null,
+					scheduledAt: status === "scheduled" ? filteredInput.scheduledAt ?? null : null,
 					data: normalizedData,
-					terms: input.terms
+					terms: filteredInput.terms
 				});
-				if (input.terms) {
-					const allTermIds = Object.values(input.terms).flat();
+				if (filteredInput.terms) {
+					const allTermIds = Object.values(filteredInput.terms).flat();
 					if (allTermIds.length > 0) await self.taxonomies.assignTerms(item.id, allTermIds);
 				}
 				if (collConfig.revisions) await self.revisions.createRevision(item, authorId, "Initial creation");
 				await self.hooks.doAction("cms.content_created", item);
 				await self.hooks.doAction(`cms.${slug}_created`, item);
-				return item;
+				return self.hooks.applyFilters("cms.after_create_item", item, { collection: slug });
 			},
 			async findById(id) {
 				return self.storage.getContent(slug, id);
@@ -1338,51 +1436,58 @@ var CMSEngine = class {
 				return self.storage.getContentBySlug(slug, contentSlug);
 			},
 			async find(options = {}) {
-				return self.storage.findContent(slug, options);
+				const filteredOptions = await self.hooks.applyFilters("cms.find_options", options, { collection: slug });
+				return self.storage.findContent(slug, filteredOptions);
 			},
 			async update(id, input, authorId = null, revisionNote) {
 				const existing = await self.storage.getContent(slug, id);
 				if (!existing) return null;
+				const filteredInput = await self.hooks.applyFilters("cms.before_update_input", input, {
+					collection: slug,
+					id,
+					existing
+				});
 				const mergedData = {
 					...existing.data,
-					...input.data || {}
+					...filteredInput.data || {}
 				};
-				if (input.title !== void 0) mergedData.title = input.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 (input.slug !== void 0) mergedData.slug = input.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 (input.status !== void 0) mergedData.status = input.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)}`);
 				let updatedSlug = existing.slug;
-				if (input.slug && input.slug !== existing.slug) updatedSlug = await resolveUniqueSlug(input.slug, async (s) => {
+				if (filteredInput.slug && filteredInput.slug !== existing.slug) updatedSlug = await resolveUniqueSlug(filteredInput.slug, async (s) => {
 					const check = await self.storage.getContentBySlug(slug, s);
 					return check !== null && check.id !== id;
 				}, id);
-				const nextStatus = input.status ?? existing.status;
+				const nextStatus = filteredInput.status ?? existing.status;
 				const nowIso = (/* @__PURE__ */ new Date()).toISOString();
 				let publishedAt = existing.publishedAt;
 				if (nextStatus === "published" && !publishedAt) publishedAt = nowIso;
 				const updated = await self.storage.updateContent(slug, id, {
-					title: input.title !== void 0 ? input.title : existing.title,
+					title: filteredInput.title !== void 0 ? filteredInput.title : existing.title,
 					slug: updatedSlug,
 					status: nextStatus,
-					parentId: collConfig.hierarchical ? input.parentId !== void 0 ? input.parentId : existing.parentId : null,
-					scheduledAt: input.scheduledAt !== void 0 ? input.scheduledAt : existing.scheduledAt,
+					parentId: collConfig.hierarchical ? filteredInput.parentId !== void 0 ? filteredInput.parentId : existing.parentId : null,
+					scheduledAt: filteredInput.scheduledAt !== void 0 ? filteredInput.scheduledAt : existing.scheduledAt,
 					publishedAt,
 					authorId: authorId ?? existing.authorId,
 					data: normalizedData,
-					terms: input.terms !== void 0 ? input.terms : existing.terms
+					terms: filteredInput.terms !== void 0 ? filteredInput.terms : existing.terms
 				});
 				if (updated) {
-					if (input.terms) {
-						const allTermIds = Object.values(input.terms).flat();
+					if (filteredInput.terms) {
+						const allTermIds = Object.values(filteredInput.terms).flat();
 						await self.taxonomies.assignTerms(updated.id, allTermIds);
 					}
 					if (collConfig.revisions) await self.revisions.createRevision(updated, authorId, revisionNote ?? `Updated version ${updated.version}`);
 					await self.hooks.doAction("cms.content_updated", updated);
 					await self.hooks.doAction(`cms.${slug}_updated`, updated);
+					return self.hooks.applyFilters("cms.after_update_item", updated, { collection: slug });
 				}
 				return updated;
 			},
@@ -1439,7 +1544,33 @@ function createCMSEngine(config, storage, hooks) {
 	return new CMSEngine(config, storage, hooks);
 }
 //#endregion
+//#region src/core/plugin.ts
+/**
+* Type-safe helper for authoring reusable CMS plugins and plugin factories.
+*/
+function definePlugin(factory) {
+	return factory;
+}
+//#endregion
 //#region src/api/router.ts
+function compilePath(path) {
+	const keys = [];
+	const pattern = path.replace(/:([a-zA-Z0-9_]+)/g, (_, key) => {
+		keys.push(key);
+		return "([^/]+)";
+	});
+	return {
+		regex: new RegExp(`^${pattern}$`),
+		keys
+	};
+}
+function matchRoute(entry, pathname) {
+	const match = pathname.match(entry.regex);
+	if (!match) return null;
+	const params = {};
+	for (let i = 0; i < entry.keys.length; i++) params[entry.keys[i]] = decodeURIComponent(match[i + 1]);
+	return params;
+}
 function jsonResponse(data, status = 200, headers = {}) {
 	return new Response(JSON.stringify(data), {
 		status,
@@ -1454,10 +1585,25 @@ function jsonResponse(data, status = 200, headers = {}) {
 }
 var CMSRouter = class {
 	engine;
+	localRoutes = [];
 	constructor(engine) {
 		this.engine = engine;
 	}
 	/**
+	* Register a custom Web Standard route on the router.
+	*/
+	registerRoute(method, path, handler) {
+		const { regex, keys } = compilePath(path);
+		this.localRoutes.push({
+			method: method.toUpperCase(),
+			path,
+			regex,
+			keys,
+			handler
+		});
+		return this;
+	}
+	/**
 	* Universal Web Standards request handler.
 	*/
 	async handle(request) {
@@ -1485,6 +1631,8 @@ var CMSRouter = class {
 			if (pathname.startsWith("/api/taxonomies")) return this.handleTaxonomies(pathname, method, url, request);
 			if (pathname.startsWith("/api/media")) return this.handleMedia(pathname, method, url, request);
 			if (pathname.startsWith("/api/content")) return this.handleContent(pathname, method, url, request);
+			const customResponse = await this.handleCustomRoute(pathname, method, url, request);
+			if (customResponse) return customResponse;
 			return jsonResponse({
 				error: "Endpoint not found",
 				path: pathname
@@ -1493,6 +1641,29 @@ var CMSRouter = class {
 			return jsonResponse({ error: error instanceof Error ? error.message : String(error) }, 500);
 		}
 	}
+	async handleCustomRoute(pathname, method, url, request) {
+		for (const route of this.localRoutes) if (route.method === method) {
+			const params = matchRoute(route, pathname);
+			if (params !== null) {
+				const context = {
+					params,
+					url,
+					engine: this.engine
+				};
+				return await route.handler(request, context);
+			}
+		}
+		const engineRoutes = this.engine.getCustomRoutes().get(method);
+		if (engineRoutes) for (const [pathPattern, handler] of engineRoutes) {
+			const params = matchRoute(compilePath(pathPattern), pathname);
+			if (params !== null) return await handler(request, {
+				params,
+				url,
+				engine: this.engine
+			});
+		}
+		return null;
+	}
 	async handleContent(pathname, method, url, request) {
 		const parts = pathname.replace(/^\/api\/content\/?/, "").split("/").filter(Boolean);
 		const collectionSlug = parts[0];
@@ -1671,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) {
@@ -1754,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}`;
@@ -1776,12 +1956,1293 @@ 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(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 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(await service.listProducts({
+				categorySlug,
+				categoryId,
+				tagSlug,
+				brandSlug,
+				search,
+				status: statusParam,
+				inStock,
+				minPrice,
+				maxPrice,
+				orderBy,
+				orderDirection,
+				limit,
+				offset
+			}));
+		} catch (err) {
+			return badRequest(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(`Product '${id}' not found`);
+		return json(product);
+	});
+	ctx.registerRoute("POST", `${prefix}/products`, async (req) => {
+		try {
+			const body = await req.json();
+			if (!body.title) return badRequest("Product 'title' is required.");
+			if (body.price === void 0 || body.price < 0) return badRequest("Valid product 'price' is required.");
+			return json(await service.createProduct(body), 201);
+		} catch (err) {
+			return badRequest(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("PUT", `${prefix}/products/:id`, async (req, { params }) => {
+		try {
+			const body = await req.json();
+			const updated = await service.updateProduct(params.id, body);
+			if (!updated) return notFound(`Product '${params.id}' not found.`);
+			return json(updated);
+		} catch (err) {
+			return badRequest(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("DELETE", `${prefix}/products/:id`, async (_req, { params }) => {
+		if (!await service.deleteProduct(params.id)) return notFound(`Product '${params.id}' not found.`);
+		return json({
+			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("'filename' and 'mimeType' are required.");
+			return json(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(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("GET", `${prefix}/categories`, async (_req, { url }) => {
+		try {
+			if (url.searchParams.get("tree") === "true") return json(await service.getCategoryTree());
+			const parentId = url.searchParams.get("parentId");
+			return json(await service.getCategories({ parentId: parentId === "null" ? null : parentId ?? void 0 }));
+		} catch (err) {
+			return badRequest(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("POST", `${prefix}/categories`, async (req) => {
+		try {
+			const body = await req.json();
+			if (!body.name) return badRequest("Category 'name' is required.");
+			return json(await service.createCategory(body), 201);
+		} catch (err) {
+			return badRequest(err instanceof Error ? err.message : String(err));
+		}
+	});
+	if (options.enableDiscounts !== false) {
+		ctx.registerRoute("POST", `${prefix}/discounts`, async (req) => {
+			try {
+				const body = await req.json();
+				if (!body.title || !body.code) return badRequest("'title' and 'code' are required.");
+				if (body.value === void 0 || body.value < 0) return badRequest("Valid discount 'value' is required.");
+				return json(await service.createDiscount(body), 201);
+			} catch (err) {
+				return badRequest(err instanceof Error ? err.message : String(err));
+			}
+		});
+		ctx.registerRoute("POST", `${prefix}/discounts/validate`, async (req) => {
+			try {
+				const body = await req.json();
+				if (!body.code) return badRequest("Discount 'code' is required.");
+				const subtotal = Number(body.subtotal ?? 0);
+				const productIds = Array.isArray(body.productIds) ? body.productIds : [];
+				return json(await service.validateDiscount(body.code, subtotal, productIds));
+			} catch (err) {
+				return badRequest(err instanceof Error ? err.message : String(err));
+			}
+		});
+	}
+	ctx.registerRoute("POST", `${prefix}/cart/calculate`, async (req) => {
+		try {
+			const body = await req.json();
+			if (!body.items || !Array.isArray(body.items) || body.items.length === 0) return badRequest("'items' array is required and must not be empty.");
+			return json(await service.calculateCart(body));
+		} catch (err) {
+			return badRequest(err instanceof Error ? err.message : String(err));
+		}
+	});
+	if (options.enableOrders !== false) {
+		ctx.registerRoute("POST", `${prefix}/orders`, async (req) => {
+			try {
+				const body = await req.json();
+				if (!body.customerEmail) return badRequest("'customerEmail' is required.");
+				if (!body.items || !Array.isArray(body.items) || body.items.length === 0) return badRequest("'items' array is required.");
+				return json(await service.createOrder(body), 201);
+			} catch (err) {
+				return badRequest(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(`Order '${id}' not found.`);
+			return json(order);
+		});
+		ctx.registerRoute("PATCH", `${prefix}/orders/:id/status`, async (req, { params }) => {
+			try {
+				const body = await req.json();
+				if (!body.status) return badRequest("New 'status' is required.");
+				const updated = await service.updateOrderStatus(params.id, body.status, body.note);
+				if (!updated) return notFound(`Order '${params.id}' not found.`);
+				return json(updated);
+			} catch (err) {
+				return badRequest(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
 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.HooksManager = HooksManager;
 exports.MediaManager = MediaManager;
 exports.MemoryStorageAdapter = MemoryStorageAdapter;
@@ -1794,9 +3255,17 @@ exports.collection = collection;
 exports.createCMSEngine = createCMSEngine;
 exports.createCMSRouter = createCMSRouter;
 exports.createCmsClient = createCmsClient;
+exports.createDiscountCollection = createDiscountCollection;
+exports.createEcommerceTaxonomies = createEcommerceTaxonomies;
+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.normalizeConfig = normalizeConfig;
 exports.resolveUniqueSlug = resolveUniqueSlug;
 exports.slugify = slugify;