@azlib/cms 0.2.0

package/dist/index.mjs

@@ -0,0 +1,1780 @@
+//#region src/content/schema.ts
+const fields = {
+	text(options) {
+		return {
+			type: "text",
+			...options
+		};
+	},
+	slug(options = {}) {
+		return {
+			name: options.name ?? "slug",
+			type: "slug",
+			label: options.label ?? "Slug",
+			fromField: options.from ?? "title",
+			required: options.required ?? false,
+			unique: options.unique ?? true
+		};
+	},
+	richText(options) {
+		return {
+			type: "richText",
+			...options
+		};
+	},
+	number(options) {
+		return {
+			type: "number",
+			...options
+		};
+	},
+	boolean(options) {
+		return {
+			type: "boolean",
+			defaultValue: false,
+			...options
+		};
+	},
+	select(options) {
+		return {
+			type: "select",
+			...options
+		};
+	},
+	image(options) {
+		return {
+			type: "image",
+			...options
+		};
+	},
+	taxonomy(options) {
+		return {
+			type: "taxonomy",
+			...options
+		};
+	},
+	relationship(options) {
+		return {
+			type: "relationship",
+			...options
+		};
+	},
+	date(options) {
+		return {
+			type: "date",
+			...options
+		};
+	},
+	json(options) {
+		return {
+			type: "json",
+			...options
+		};
+	},
+	repeater(options) {
+		return {
+			type: "repeater",
+			...options
+		};
+	}
+};
+/**
+* Define a CMS Collection with field schemas and lifecycle rules.
+*/
+function collection(options) {
+	return {
+		slug: options.slug,
+		label: options.label,
+		singularLabel: options.singularLabel ?? options.label,
+		description: options.description,
+		hierarchical: options.hierarchical ?? false,
+		timestamps: options.timestamps ?? true,
+		revisions: options.revisions ?? true,
+		draftable: options.draftable ?? true,
+		fields: options.fields,
+		taxonomies: options.taxonomies ?? [],
+		defaultSort: options.defaultSort ?? {
+			field: "createdAt",
+			direction: "desc"
+		}
+	};
+}
+/**
+* Validate and apply default values to input data for a collection.
+*/
+function validateAndNormalizeData(fieldsList, inputData) {
+	const normalized = { ...inputData };
+	const errors = {};
+	for (const field of fieldsList) {
+		let val = normalized[field.name];
+		if (val === void 0 && field.defaultValue !== void 0) {
+			val = field.defaultValue;
+			normalized[field.name] = val;
+		}
+		if (field.required && (val === void 0 || val === null || val === "")) {
+			errors[field.name] = `${field.label || field.name} is required.`;
+			continue;
+		}
+		if (val !== void 0 && val !== null) {
+			if (field.type === "number" && typeof val !== "number") {
+				const parsed = Number(val);
+				if (Number.isNaN(parsed)) errors[field.name] = `${field.label || field.name} must be a valid number.`;
+				else normalized[field.name] = parsed;
+			} else if (field.type === "boolean" && typeof val !== "boolean") normalized[field.name] = Boolean(val);
+		}
+		if (field.validate && val !== void 0) {
+			const res = field.validate(val, normalized);
+			if (typeof res === "string") errors[field.name] = res;
+			else if (res === false) errors[field.name] = `${field.label || field.name} is invalid.`;
+		}
+	}
+	return {
+		data: normalized,
+		errors
+	};
+}
+//#endregion
+//#region src/core/config.ts
+/**
+* Default standard collections provided when not explicitly specified.
+*/
+const DEFAULT_COLLECTIONS = [collection({
+	slug: "posts",
+	label: "Posts",
+	singularLabel: "Post",
+	revisions: true,
+	timestamps: true,
+	taxonomies: ["categories", "tags"],
+	fields: [
+		fields.text({
+			name: "title",
+			label: "Title",
+			required: true
+		}),
+		fields.slug({ from: "title" }),
+		fields.richText({
+			name: "content",
+			label: "Content"
+		}),
+		fields.text({
+			name: "excerpt",
+			label: "Excerpt"
+		}),
+		fields.image({
+			name: "featuredImage",
+			label: "Featured Image"
+		}),
+		fields.select({
+			name: "status",
+			label: "Status",
+			options: [
+				"draft",
+				"pending_review",
+				"scheduled",
+				"published",
+				"trash"
+			],
+			defaultValue: "draft"
+		})
+	]
+}), collection({
+	slug: "pages",
+	label: "Pages",
+	singularLabel: "Page",
+	hierarchical: true,
+	revisions: true,
+	timestamps: true,
+	fields: [
+		fields.text({
+			name: "title",
+			label: "Title",
+			required: true
+		}),
+		fields.slug({ from: "title" }),
+		fields.richText({
+			name: "content",
+			label: "Content"
+		}),
+		fields.select({
+			name: "status",
+			label: "Status",
+			options: [
+				"draft",
+				"published",
+				"trash"
+			],
+			defaultValue: "draft"
+		})
+	]
+})];
+/**
+* Type-safe configuration helper function for azlib.config.ts.
+*/
+function defineConfig(config) {
+	return config;
+}
+/**
+* Normalize and merge user config with CMS defaults.
+*/
+function normalizeConfig(config) {
+	const collections = config.collections && config.collections.length > 0 ? config.collections : DEFAULT_COLLECTIONS;
+	return {
+		site: {
+			name: config.site?.name ?? "Azlib CMS",
+			description: config.site?.description ?? "A modern headless CMS powered by @azlib",
+			url: config.site?.url ?? "http://localhost:3000",
+			locale: config.site?.locale ?? "en-US",
+			timezone: config.site?.timezone ?? "UTC",
+			...config.site
+		},
+		collections,
+		taxonomies: config.taxonomies ?? [],
+		admin: {
+			route: config.admin?.route ?? "/admin",
+			enableRegistration: config.admin?.enableRegistration ?? false,
+			...config.admin
+		}
+	};
+}
+//#endregion
+//#region src/core/hooks.ts
+var HooksManager = class {
+	actions = /* @__PURE__ */ new Map();
+	filters = /* @__PURE__ */ new Map();
+	/**
+	* Register an action callback.
+	* Lower priority numbers execute first (default: 10).
+	*/
+	addAction(tag, callback, priority = 10) {
+		const list = this.actions.get(tag) ?? [];
+		list.push({
+			callback,
+			priority
+		});
+		list.sort((a, b) => a.priority - b.priority);
+		this.actions.set(tag, list);
+		return this;
+	}
+	/**
+	* Execute all callbacks registered for the specified action asynchronously.
+	*/
+	async doAction(tag, ...args) {
+		const list = this.actions.get(tag);
+		if (!list || list.length === 0) return;
+		for (const entry of list) await entry.callback(...args);
+	}
+	/**
+	* Execute all callbacks registered for the specified action synchronously.
+	*/
+	doActionSync(tag, ...args) {
+		const list = this.actions.get(tag);
+		if (!list || list.length === 0) return;
+		for (const entry of list) {
+			const result = entry.callback(...args);
+			if (result instanceof Promise) result.catch((err) => {
+				console.error(`[HooksManager] Unhandled error in async action '${tag}':`, err);
+			});
+		}
+	}
+	/**
+	* Register a filter callback.
+	* Filter callbacks receive a value and return the modified value.
+	*/
+	addFilter(tag, callback, priority = 10) {
+		const list = this.filters.get(tag) ?? [];
+		list.push({
+			callback,
+			priority
+		});
+		list.sort((a, b) => a.priority - b.priority);
+		this.filters.set(tag, list);
+		return this;
+	}
+	/**
+	* Apply all filters registered for the specified tag sequentially.
+	*/
+	async applyFilters(tag, initialValue, ...args) {
+		const list = this.filters.get(tag);
+		if (!list || list.length === 0) return initialValue;
+		let currentValue = initialValue;
+		for (const entry of list) currentValue = await entry.callback(currentValue, ...args);
+		return currentValue;
+	}
+	/**
+	* Apply all filters registered for the specified tag synchronously.
+	*/
+	applyFiltersSync(tag, initialValue, ...args) {
+		const list = this.filters.get(tag);
+		if (!list || list.length === 0) return initialValue;
+		let currentValue = initialValue;
+		for (const entry of list) {
+			const next = entry.callback(currentValue, ...args);
+			if (next instanceof Promise) throw new Error(`[HooksManager] Async filter detected during applyFiltersSync for tag '${tag}'. Use applyFilters instead.`);
+			currentValue = next;
+		}
+		return currentValue;
+	}
+	/**
+	* Remove a registered action callback.
+	*/
+	removeAction(tag, callback) {
+		const list = this.actions.get(tag);
+		if (!list) return false;
+		const initialLen = list.length;
+		const filtered = list.filter((e) => e.callback !== callback);
+		this.actions.set(tag, filtered);
+		return filtered.length < initialLen;
+	}
+	/**
+	* Remove a registered filter callback.
+	*/
+	removeFilter(tag, callback) {
+		const list = this.filters.get(tag);
+		if (!list) return false;
+		const initialLen = list.length;
+		const filtered = list.filter((e) => e.callback !== callback);
+		this.filters.set(tag, filtered);
+		return filtered.length < initialLen;
+	}
+	/**
+	* Check if any callbacks are registered for an action.
+	*/
+	hasAction(tag) {
+		const list = this.actions.get(tag);
+		return Boolean(list && list.length > 0);
+	}
+	/**
+	* Check if any callbacks are registered for a filter.
+	*/
+	hasFilter(tag) {
+		const list = this.filters.get(tag);
+		return Boolean(list && list.length > 0);
+	}
+	/**
+	* Remove all registered actions and filters.
+	*/
+	removeAll(tag) {
+		if (tag) {
+			this.actions.delete(tag);
+			this.filters.delete(tag);
+		} else {
+			this.actions.clear();
+			this.filters.clear();
+		}
+	}
+};
+const defaultHooks = new HooksManager();
+//#endregion
+//#region src/core/options.ts
+var OptionsManager = class {
+	storage;
+	hooks;
+	constructor(storage, hooks) {
+		this.storage = storage;
+		this.hooks = hooks;
+	}
+	/**
+	* Retrieve an option by key. Returns defaultValue if option does not exist.
+	*/
+	async get(key, defaultValue) {
+		const item = await this.storage.getOption(key);
+		let value = item ? item.value : defaultValue;
+		if (this.hooks) value = await this.hooks.applyFilters(`cms.option.${key}`, value);
+		return value;
+	}
+	/**
+	* Set or update an option value.
+	*/
+	async set(key, value, options) {
+		let finalValue = value;
+		if (this.hooks) finalValue = await this.hooks.applyFilters(`cms.pre_set_option.${key}`, finalValue);
+		const item = {
+			key,
+			value: finalValue,
+			autoload: options?.autoload ?? true,
+			namespace: options?.namespace,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		await this.storage.setOption(item);
+		if (this.hooks) {
+			await this.hooks.doAction("cms.option_updated", key, finalValue);
+			await this.hooks.doAction(`cms.option_updated.${key}`, finalValue);
+		}
+		return item;
+	}
+	/**
+	* Delete an option by key.
+	*/
+	async delete(key) {
+		const deleted = await this.storage.deleteOption(key);
+		if (deleted && this.hooks) await this.hooks.doAction("cms.option_deleted", key);
+		return deleted;
+	}
+	/**
+	* Check if an option exists.
+	*/
+	async has(key) {
+		const item = await this.storage.getOption(key);
+		return item !== null && item !== void 0;
+	}
+	/**
+	* Get all options, optionally filtered by namespace.
+	*/
+	async getAll(namespace) {
+		const items = await this.storage.getOptions(namespace);
+		const result = {};
+		for (const item of items) result[item.key] = item.value;
+		return result;
+	}
+};
+//#endregion
+//#region src/content/lifecycle.ts
+const VALID_STATUS_TRANSITIONS = {
+	draft: [
+		"pending_review",
+		"scheduled",
+		"published",
+		"private",
+		"trash"
+	],
+	pending_review: [
+		"draft",
+		"scheduled",
+		"published",
+		"trash"
+	],
+	scheduled: [
+		"draft",
+		"published",
+		"trash"
+	],
+	published: [
+		"draft",
+		"trash",
+		"private"
+	],
+	private: [
+		"draft",
+		"published",
+		"trash"
+	],
+	trash: ["draft"]
+};
+var ContentLifecycle = class {
+	storage;
+	hooks;
+	constructor(storage, hooks) {
+		this.storage = storage;
+		this.hooks = hooks;
+	}
+	/**
+	* Validate whether a status transition is permitted.
+	*/
+	canTransition(currentStatus, nextStatus) {
+		if (currentStatus === nextStatus) return true;
+		const allowed = VALID_STATUS_TRANSITIONS[currentStatus];
+		return Boolean(allowed && allowed.includes(nextStatus));
+	}
+	/**
+	* Process all scheduled content across a collection (or all collections) and publish mature items.
+	*/
+	async processScheduledContent(collection, now = /* @__PURE__ */ new Date()) {
+		const scheduledRes = await this.storage.findContent(collection, {
+			status: "scheduled",
+			limit: 1e3
+		});
+		const nowIso = now.toISOString();
+		const publishedItems = [];
+		for (const item of scheduledRes.items) if (item.scheduledAt && item.scheduledAt <= nowIso) {
+			const updated = await this.storage.updateContent(collection, item.id, {
+				status: "published",
+				publishedAt: item.scheduledAt
+			});
+			if (updated) {
+				publishedItems.push(updated);
+				if (this.hooks) {
+					await this.hooks.doAction("cms.content_published", updated);
+					await this.hooks.doAction(`cms.${collection}_published`, updated);
+				}
+			}
+		}
+		return publishedItems;
+	}
+};
+//#endregion
+//#region src/content/revisions.ts
+var RevisionManager = class {
+	storage;
+	hooks;
+	constructor(storage, hooks) {
+		this.storage = storage;
+		this.hooks = hooks;
+	}
+	/**
+	* Save a revision snapshot for a content item.
+	*/
+	async createRevision(item, authorId, note) {
+		const revision = await this.storage.createRevision(item.id, item.collection, item.version, item, authorId, note);
+		if (this.hooks) await this.hooks.doAction("cms.revision_created", revision);
+		return revision;
+	}
+	/**
+	* Get all revisions for a content item.
+	*/
+	async getRevisions(contentId) {
+		return this.storage.getRevisions(contentId);
+	}
+	/**
+	* Get a specific revision by ID.
+	*/
+	async getRevision(revisionId) {
+		return this.storage.getRevision(revisionId);
+	}
+	/**
+	* Compute differences between two content snapshots.
+	*/
+	computeDiff(oldSnapshot, newSnapshot) {
+		const changes = [];
+		if (oldSnapshot.title !== newSnapshot.title) changes.push({
+			field: "title",
+			oldValue: oldSnapshot.title,
+			newValue: newSnapshot.title
+		});
+		if (oldSnapshot.slug !== newSnapshot.slug) changes.push({
+			field: "slug",
+			oldValue: oldSnapshot.slug,
+			newValue: newSnapshot.slug
+		});
+		if (oldSnapshot.status !== newSnapshot.status) changes.push({
+			field: "status",
+			oldValue: oldSnapshot.status,
+			newValue: newSnapshot.status
+		});
+		const allKeys = /* @__PURE__ */ new Set([...Object.keys(oldSnapshot.data || {}), ...Object.keys(newSnapshot.data || {})]);
+		const topLevelFields = /* @__PURE__ */ new Set([
+			"title",
+			"slug",
+			"status"
+		]);
+		for (const key of allKeys) {
+			if (topLevelFields.has(key)) continue;
+			const oldVal = oldSnapshot.data?.[key];
+			const newVal = newSnapshot.data?.[key];
+			if (JSON.stringify(oldVal) !== JSON.stringify(newVal)) changes.push({
+				field: `data.${key}`,
+				oldValue: oldVal,
+				newValue: newVal
+			});
+		}
+		return {
+			contentId: newSnapshot.id,
+			fromVersion: oldSnapshot.version,
+			toVersion: newSnapshot.version,
+			changes
+		};
+	}
+	/**
+	* Restore a content item to a previous revision snapshot.
+	*/
+	async restoreRevision(collection, revisionId, authorId) {
+		const revision = await this.storage.getRevision(revisionId);
+		if (!revision || revision.collection !== collection) return null;
+		const snapshot = revision.snapshot;
+		const restored = await this.storage.updateContent(collection, revision.contentId, {
+			title: snapshot.title,
+			slug: snapshot.slug,
+			status: snapshot.status,
+			parentId: snapshot.parentId,
+			data: snapshot.data,
+			authorId: authorId ?? snapshot.authorId
+		});
+		if (restored) {
+			await this.createRevision(restored, authorId, `Restored from revision v${revision.version}`);
+			if (this.hooks) await this.hooks.doAction("cms.revision_restored", restored, revision);
+		}
+		return restored;
+	}
+};
+//#endregion
+//#region src/content/slug.ts
+/**
+* @azlib/cms - Slug generation and normalization utility
+*/
+/**
+* Generate a clean, URL-safe slug from any input string.
+*/
+function slugify(input) {
+	if (!input) return "";
+	return input.toString().normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().trim().replace(/[^a-z0-9\s-_]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+/**
+* Create a unique slug given an existing set of slugs or a check function.
+*/
+async function resolveUniqueSlug(baseSlug, isSlugTaken, currentId) {
+	const root = slugify(baseSlug) || "item";
+	let candidate = root;
+	let counter = 1;
+	while (await isSlugTaken(candidate)) {
+		counter += 1;
+		candidate = `${root}-${counter}`;
+	}
+	return candidate;
+}
+//#endregion
+//#region src/taxonomy/taxonomy.ts
+var TaxonomyManager = class {
+	storage;
+	hooks;
+	registeredTaxonomies = /* @__PURE__ */ new Map();
+	constructor(storage, hooks) {
+		this.storage = storage;
+		this.hooks = hooks;
+		this.registerTaxonomy({
+			slug: "categories",
+			label: "Categories",
+			singularLabel: "Category",
+			hierarchical: true,
+			postTypes: ["posts"]
+		});
+		this.registerTaxonomy({
+			slug: "tags",
+			label: "Tags",
+			singularLabel: "Tag",
+			hierarchical: false,
+			postTypes: ["posts"]
+		});
+	}
+	/**
+	* Register a taxonomy definition.
+	*/
+	registerTaxonomy(config) {
+		this.registeredTaxonomies.set(config.slug, config);
+	}
+	/**
+	* Get all registered taxonomies.
+	*/
+	getTaxonomies() {
+		return Array.from(this.registeredTaxonomies.values());
+	}
+	/**
+	* Get a single taxonomy configuration by slug.
+	*/
+	getTaxonomy(slug) {
+		return this.registeredTaxonomies.get(slug);
+	}
+	/**
+	* Create a new term (e.g. category or tag).
+	*/
+	async createTerm(taxonomy, data) {
+		const taxConfig = this.getTaxonomy(taxonomy);
+		if (!taxConfig) throw new Error(`[TaxonomyManager] Taxonomy '${taxonomy}' is not registered.`);
+		const finalSlug = await resolveUniqueSlug(data.slug ? slugify(data.slug) : slugify(data.name), async (s) => {
+			return await this.storage.getTermBySlug(taxonomy, s) !== null;
+		});
+		const term = await this.storage.createTerm({
+			taxonomy,
+			name: data.name.trim(),
+			slug: finalSlug,
+			description: data.description,
+			parentId: taxConfig.hierarchical ? data.parentId ?? null : null,
+			meta: data.meta
+		});
+		if (this.hooks) {
+			await this.hooks.doAction("cms.term_created", term);
+			await this.hooks.doAction(`cms.${taxonomy}_term_created`, term);
+		}
+		return term;
+	}
+	/**
+	* Get a term by ID.
+	*/
+	async getTermById(id) {
+		return this.storage.getTermById(id);
+	}
+	/**
+	* Get a term by slug within a taxonomy.
+	*/
+	async getTermBySlug(taxonomy, slug) {
+		return this.storage.getTermBySlug(taxonomy, slug);
+	}
+	/**
+	* Get terms for a taxonomy.
+	*/
+	async getTerms(taxonomy, options) {
+		return this.storage.getTerms(taxonomy, options);
+	}
+	/**
+	* Build a hierarchical tree of terms for a taxonomy (parent -> children).
+	*/
+	async getTermTree(taxonomy) {
+		const allTerms = await this.storage.getTerms(taxonomy);
+		const map = /* @__PURE__ */ new Map();
+		const roots = [];
+		for (const term of allTerms) map.set(term.id, {
+			...term,
+			children: []
+		});
+		for (const term of allTerms) {
+			const node = map.get(term.id);
+			if (term.parentId && map.has(term.parentId)) map.get(term.parentId).children.push(node);
+			else roots.push(node);
+		}
+		return roots;
+	}
+	/**
+	* Update a term.
+	*/
+	async updateTerm(id, updates) {
+		const existing = await this.storage.getTermById(id);
+		if (!existing) return null;
+		let slug = existing.slug;
+		if (updates.slug && updates.slug !== existing.slug) slug = await resolveUniqueSlug(updates.slug, async (s) => {
+			const check = await this.storage.getTermBySlug(existing.taxonomy, s);
+			return check !== null && check.id !== id;
+		}, id);
+		const updated = await this.storage.updateTerm(id, {
+			...updates,
+			slug,
+			name: updates.name ? updates.name.trim() : existing.name
+		});
+		if (updated && this.hooks) await this.hooks.doAction("cms.term_updated", updated);
+		return updated;
+	}
+	/**
+	* Delete a term.
+	*/
+	async deleteTerm(id) {
+		const term = await this.storage.getTermById(id);
+		if (!term) return false;
+		const deleted = await this.storage.deleteTerm(id);
+		if (deleted && this.hooks) await this.hooks.doAction("cms.term_deleted", term);
+		return deleted;
+	}
+	/**
+	* Assign term IDs to a content item.
+	*/
+	async assignTerms(contentId, termIds) {
+		await this.storage.assignTermsToContent(contentId, termIds);
+		if (this.hooks) await this.hooks.doAction("cms.terms_assigned", contentId, termIds);
+	}
+	/**
+	* Get all terms assigned to a content item.
+	*/
+	async getContentTerms(contentId, taxonomy) {
+		return this.storage.getContentTerms(contentId, taxonomy);
+	}
+	/**
+	* Remove terms from a content item.
+	*/
+	async removeTerms(contentId, termIds) {
+		await this.storage.removeTermsFromContent(contentId, termIds);
+	}
+};
+//#endregion
+//#region src/media/media-manager.ts
+var MediaManager = class {
+	storage;
+	hooks;
+	publicBaseUrl;
+	allowedMimePrefixes = [
+		"image/",
+		"video/",
+		"audio/",
+		"application/pdf",
+		"text/"
+	];
+	constructor(storage, hooks, publicBaseUrl = "/uploads") {
+		this.storage = storage;
+		this.hooks = hooks;
+		this.publicBaseUrl = publicBaseUrl;
+	}
+	/**
+	* Upload / register a new media item.
+	*/
+	async upload(input, authorId) {
+		if (!this.allowedMimePrefixes.some((prefix) => input.mimeType.startsWith(prefix))) throw new Error(`[MediaManager] Unsupported MIME type: ${input.mimeType}`);
+		const extMatch = input.filename.match(/\.([a-zA-Z0-9]+)$/);
+		const ext = extMatch ? `.${extMatch[1].toLowerCase()}` : "";
+		const cleanFilename = `${slugify(input.filename.replace(/\.[^/.]+$/, ""))}${ext}`;
+		const url = input.url ?? `${this.publicBaseUrl}/${cleanFilename}`;
+		const media = await this.storage.createMedia({
+			filename: cleanFilename,
+			originalName: input.filename,
+			mimeType: input.mimeType,
+			sizeBytes: input.sizeBytes,
+			url,
+			width: input.width,
+			height: input.height,
+			altText: input.altText,
+			caption: input.caption,
+			variants: input.variants,
+			authorId
+		});
+		if (this.hooks) await this.hooks.doAction("cms.media_uploaded", media);
+		return media;
+	}
+	/**
+	* Get a media item by ID.
+	*/
+	async get(id) {
+		return this.storage.getMedia(id);
+	}
+	/**
+	* Find media items.
+	*/
+	async find(options) {
+		return this.storage.findMedia(options);
+	}
+	/**
+	* Update media metadata (alt text, caption, dimensions).
+	*/
+	async updateMetadata(id, updates) {
+		const updated = await this.storage.updateMedia(id, updates);
+		if (updated && this.hooks) await this.hooks.doAction("cms.media_updated", updated);
+		return updated;
+	}
+	/**
+	* Delete a media item.
+	*/
+	async delete(id) {
+		const media = await this.storage.getMedia(id);
+		if (!media) return false;
+		const deleted = await this.storage.deleteMedia(id);
+		if (deleted && this.hooks) await this.hooks.doAction("cms.media_deleted", media);
+		return deleted;
+	}
+};
+//#endregion
+//#region src/auth/rbac.ts
+const DEFAULT_ROLE_CAPABILITIES = {
+	admin: [
+		"manage_options",
+		"manage_taxonomies",
+		"upload_files",
+		"delete_files",
+		"edit_posts",
+		"edit_others_posts",
+		"publish_posts",
+		"delete_posts",
+		"delete_others_posts",
+		"read_private_posts"
+	],
+	editor: [
+		"manage_taxonomies",
+		"upload_files",
+		"delete_files",
+		"edit_posts",
+		"edit_others_posts",
+		"publish_posts",
+		"delete_posts",
+		"delete_others_posts",
+		"read_private_posts"
+	],
+	author: [
+		"upload_files",
+		"edit_posts",
+		"publish_posts",
+		"delete_posts"
+	],
+	contributor: ["edit_posts", "delete_posts"],
+	subscriber: ["read"]
+};
+var RBACManager = class {
+	roleCapabilities = /* @__PURE__ */ new Map();
+	constructor() {
+		for (const [role, caps] of Object.entries(DEFAULT_ROLE_CAPABILITIES)) this.roleCapabilities.set(role, new Set(caps));
+	}
+	/**
+	* Register a custom role with its capabilities.
+	*/
+	registerRole(role, capabilities) {
+		this.roleCapabilities.set(role, new Set(capabilities));
+	}
+	/**
+	* Add a capability to an existing role.
+	*/
+	addCapabilityToRole(role, capability) {
+		let caps = this.roleCapabilities.get(role);
+		if (!caps) {
+			caps = /* @__PURE__ */ new Set();
+			this.roleCapabilities.set(role, caps);
+		}
+		caps.add(capability);
+	}
+	/**
+	* Get all capabilities assigned to a role.
+	*/
+	getRoleCapabilities(role) {
+		const caps = this.roleCapabilities.get(role);
+		return caps ? Array.from(caps) : [];
+	}
+	/**
+	* Check if a user possesses a specific capability.
+	* If a target content item context is provided, checks object ownership rules.
+	*/
+	can(user, capability, context) {
+		if (!user || user.active === false) return false;
+		if (user.capabilities && user.capabilities.includes(capability)) return true;
+		const roleCaps = this.roleCapabilities.get(user.role);
+		if (!roleCaps) return false;
+		if (user.role === "admin") return true;
+		if (context?.contentItem) {
+			const isOwner = context.contentItem.authorId === user.id;
+			if (capability === "edit_posts") {
+				if (isOwner) return roleCaps.has("edit_posts");
+				return roleCaps.has("edit_others_posts");
+			}
+			if (capability === "delete_posts") {
+				if (isOwner) return roleCaps.has("delete_posts");
+				return roleCaps.has("delete_others_posts");
+			}
+		}
+		return roleCaps.has(capability);
+	}
+};
+//#endregion
+//#region src/storage/memory-adapter.ts
+function generateId(prefix = "") {
+	return `${prefix}${Date.now().toString(36)}_${Math.random().toString(36).substring(2, 9)}`;
+}
+var MemoryStorageAdapter = class {
+	content = /* @__PURE__ */ new Map();
+	revisions = /* @__PURE__ */ new Map();
+	terms = /* @__PURE__ */ new Map();
+	contentTerms = /* @__PURE__ */ new Map();
+	media = /* @__PURE__ */ new Map();
+	options = /* @__PURE__ */ new Map();
+	async init() {}
+	async close() {}
+	async createContent(item) {
+		const id = generateId("cnt_");
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const fullItem = {
+			...item,
+			id,
+			version: 1,
+			createdAt: now,
+			updatedAt: now
+		};
+		this.content.set(id, fullItem);
+		return JSON.parse(JSON.stringify(fullItem));
+	}
+	async getContent(collection, id) {
+		const item = this.content.get(id);
+		if (!item || item.collection !== collection) return null;
+		return JSON.parse(JSON.stringify(item));
+	}
+	async getContentBySlug(collection, slug) {
+		for (const item of this.content.values()) if (item.collection === collection && item.slug === slug) return JSON.parse(JSON.stringify(item));
+		return null;
+	}
+	async findContent(collection, options = {}) {
+		let list = [];
+		for (const item of this.content.values()) {
+			if (item.collection !== collection) continue;
+			if (options.status) {
+				if (!(Array.isArray(options.status) ? options.status : [options.status]).includes(item.status)) continue;
+			}
+			if (options.authorId && item.authorId !== options.authorId) continue;
+			if (options.parentId !== void 0 && item.parentId !== options.parentId) continue;
+			if (options.termIds && options.termIds.length > 0) {
+				const assigned = this.contentTerms.get(item.id);
+				if (!assigned || !options.termIds.some((tId) => assigned.has(tId))) continue;
+			}
+			if (options.search) {
+				const query = options.search.toLowerCase();
+				const inTitle = item.title?.toLowerCase().includes(query);
+				const inSlug = item.slug.toLowerCase().includes(query);
+				const inData = JSON.stringify(item.data).toLowerCase().includes(query);
+				if (!inTitle && !inSlug && !inData) continue;
+			}
+			if (options.where) {
+				let match = true;
+				for (const [key, val] of Object.entries(options.where)) if (item.data[key] !== val && item[key] !== val) {
+					match = false;
+					break;
+				}
+				if (!match) continue;
+			}
+			list.push(item);
+		}
+		const total = list.length;
+		const orderBy = options.orderBy || "createdAt";
+		const dir = options.orderDirection === "asc" ? 1 : -1;
+		list.sort((a, b) => {
+			const valA = a[orderBy] ?? a.data[orderBy] ?? "";
+			const valB = b[orderBy] ?? b.data[orderBy] ?? "";
+			if (valA < valB) return -1 * dir;
+			if (valA > valB) return 1 * dir;
+			return 0;
+		});
+		const offset = options.offset ?? 0;
+		const limit = options.limit ?? 20;
+		const paged = list.slice(offset, offset + limit);
+		return {
+			items: JSON.parse(JSON.stringify(paged)),
+			total,
+			limit,
+			offset,
+			hasMore: offset + limit < total
+		};
+	}
+	async updateContent(collection, id, updates) {
+		const existing = this.content.get(id);
+		if (!existing || existing.collection !== collection) return null;
+		const updated = {
+			...existing,
+			...updates,
+			data: {
+				...existing.data,
+				...updates.data || {}
+			},
+			version: existing.version + 1,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		this.content.set(id, updated);
+		return JSON.parse(JSON.stringify(updated));
+	}
+	async deleteContent(collection, id) {
+		const existing = this.content.get(id);
+		if (!existing || existing.collection !== collection) return false;
+		this.content.delete(id);
+		this.contentTerms.delete(id);
+		await this.deleteRevisionsByContentId(id);
+		return true;
+	}
+	async countContent(collection, options = {}) {
+		return (await this.findContent(collection, {
+			...options,
+			limit: 1e6
+		})).total;
+	}
+	async createRevision(contentId, collection, version, snapshot, authorId, note) {
+		const id = generateId("rev_");
+		const record = {
+			id,
+			contentId,
+			collection,
+			version,
+			snapshot: JSON.parse(JSON.stringify(snapshot)),
+			authorId,
+			note,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		this.revisions.set(id, record);
+		return JSON.parse(JSON.stringify(record));
+	}
+	async getRevisions(contentId) {
+		const list = [];
+		for (const rev of this.revisions.values()) if (rev.contentId === contentId) list.push(rev);
+		list.sort((a, b) => b.version - a.version);
+		return JSON.parse(JSON.stringify(list));
+	}
+	async getRevision(revisionId) {
+		const rev = this.revisions.get(revisionId);
+		return rev ? JSON.parse(JSON.stringify(rev)) : null;
+	}
+	async deleteRevisionsByContentId(contentId) {
+		let count = 0;
+		for (const [id, rev] of this.revisions.entries()) if (rev.contentId === contentId) {
+			this.revisions.delete(id);
+			count++;
+		}
+		return count;
+	}
+	async createTerm(term) {
+		const id = generateId("trm_");
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const item = {
+			...term,
+			id,
+			count: 0,
+			createdAt: now,
+			updatedAt: now
+		};
+		this.terms.set(id, item);
+		return JSON.parse(JSON.stringify(item));
+	}
+	async getTermById(id) {
+		const term = this.terms.get(id);
+		return term ? JSON.parse(JSON.stringify(term)) : null;
+	}
+	async getTermBySlug(taxonomy, slug) {
+		for (const term of this.terms.values()) if (term.taxonomy === taxonomy && term.slug === slug) return JSON.parse(JSON.stringify(term));
+		return null;
+	}
+	async getTerms(taxonomy, options) {
+		const list = [];
+		for (const term of this.terms.values()) {
+			if (term.taxonomy !== taxonomy) continue;
+			if (options?.parentId !== void 0 && term.parentId !== options.parentId) continue;
+			list.push(term);
+		}
+		return JSON.parse(JSON.stringify(list));
+	}
+	async updateTerm(id, updates) {
+		const term = this.terms.get(id);
+		if (!term) return null;
+		const updated = {
+			...term,
+			...updates,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		this.terms.set(id, updated);
+		return JSON.parse(JSON.stringify(updated));
+	}
+	async deleteTerm(id) {
+		const exists = this.terms.delete(id);
+		if (exists) for (const set of this.contentTerms.values()) set.delete(id);
+		return exists;
+	}
+	async assignTermsToContent(contentId, termIds) {
+		let set = this.contentTerms.get(contentId);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.contentTerms.set(contentId, set);
+		}
+		for (const id of termIds) set.add(id);
+		this.recalculateTermCounts();
+	}
+	async getContentTerms(contentId, taxonomy) {
+		const set = this.contentTerms.get(contentId);
+		if (!set) return [];
+		const list = [];
+		for (const termId of set) {
+			const term = this.terms.get(termId);
+			if (term) {
+				if (!taxonomy || term.taxonomy === taxonomy) list.push(term);
+			}
+		}
+		return JSON.parse(JSON.stringify(list));
+	}
+	async removeTermsFromContent(contentId, termIds) {
+		const set = this.contentTerms.get(contentId);
+		if (!set) return;
+		for (const id of termIds) set.delete(id);
+		this.recalculateTermCounts();
+	}
+	recalculateTermCounts() {
+		const counts = /* @__PURE__ */ new Map();
+		for (const set of this.contentTerms.values()) for (const termId of set) counts.set(termId, (counts.get(termId) || 0) + 1);
+		for (const [id, term] of this.terms.entries()) term.count = counts.get(id) || 0;
+	}
+	async createMedia(item) {
+		const id = generateId("med_");
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const mediaItem = {
+			...item,
+			id,
+			createdAt: now,
+			updatedAt: now
+		};
+		this.media.set(id, mediaItem);
+		return JSON.parse(JSON.stringify(mediaItem));
+	}
+	async getMedia(id) {
+		const m = this.media.get(id);
+		return m ? JSON.parse(JSON.stringify(m)) : null;
+	}
+	async findMedia(options = {}) {
+		const list = [];
+		for (const item of this.media.values()) {
+			if (options.mimeType && !item.mimeType.startsWith(options.mimeType)) continue;
+			if (options.authorId && item.authorId !== options.authorId) continue;
+			if (options.search) {
+				const q = options.search.toLowerCase();
+				if (!item.filename.toLowerCase().includes(q) && !item.originalName.toLowerCase().includes(q) && !item.altText?.toLowerCase().includes(q)) continue;
+			}
+			list.push(item);
+		}
+		list.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+		const total = list.length;
+		const offset = options.offset ?? 0;
+		const limit = options.limit ?? 20;
+		return {
+			items: JSON.parse(JSON.stringify(list.slice(offset, offset + limit))),
+			total,
+			limit,
+			offset,
+			hasMore: offset + limit < total
+		};
+	}
+	async updateMedia(id, updates) {
+		const m = this.media.get(id);
+		if (!m) return null;
+		const updated = {
+			...m,
+			...updates,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		this.media.set(id, updated);
+		return JSON.parse(JSON.stringify(updated));
+	}
+	async deleteMedia(id) {
+		return this.media.delete(id);
+	}
+	async getOption(key) {
+		const opt = this.options.get(key);
+		return opt ? JSON.parse(JSON.stringify(opt)) : null;
+	}
+	async setOption(item) {
+		this.options.set(item.key, JSON.parse(JSON.stringify(item)));
+	}
+	async deleteOption(key) {
+		return this.options.delete(key);
+	}
+	async getOptions(namespace) {
+		const list = [];
+		for (const opt of this.options.values()) {
+			if (namespace && opt.namespace !== namespace) continue;
+			list.push(opt);
+		}
+		return JSON.parse(JSON.stringify(list));
+	}
+};
+//#endregion
+//#region src/core/engine.ts
+var CMSEngine = class {
+	config;
+	hooks;
+	storage;
+	options;
+	taxonomies;
+	media;
+	rbac;
+	revisions;
+	lifecycle;
+	collections = /* @__PURE__ */ new Map();
+	constructor(config = {}, storage, hooks) {
+		this.config = normalizeConfig(config);
+		this.hooks = hooks ?? new HooksManager();
+		this.storage = storage ?? new MemoryStorageAdapter();
+		this.options = new OptionsManager(this.storage, this.hooks);
+		this.taxonomies = new TaxonomyManager(this.storage, this.hooks);
+		this.media = new MediaManager(this.storage, this.hooks);
+		this.rbac = new RBACManager();
+		this.revisions = new RevisionManager(this.storage, this.hooks);
+		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);
+	}
+	/**
+	* Initialize storage and trigger bootstrap hooks.
+	*/
+	async init() {
+		await this.storage.init();
+		if (this.config.site) {
+			if (!await this.options.has("site_name")) await this.options.set("site_name", this.config.site.name);
+		}
+		await this.hooks.doAction("cms.init", this);
+	}
+	/**
+	* Close storage connections.
+	*/
+	async close() {
+		await this.storage.close();
+		await this.hooks.doAction("cms.close", this);
+	}
+	/**
+	* Get all registered collection configurations.
+	*/
+	getCollections() {
+		return Array.from(this.collections.values());
+	}
+	/**
+	* Get a single collection configuration.
+	*/
+	getCollectionConfig(slug) {
+		return this.collections.get(slug);
+	}
+	/**
+	* Access high-level CRUD service for a collection.
+	*/
+	collection(slug) {
+		const collConfig = this.collections.get(slug);
+		if (!collConfig) throw new Error(`[CMSEngine] Collection '${slug}' is not registered.`);
+		const self = this;
+		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 { 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) => {
+					return await self.storage.getContentBySlug(slug, s) !== null;
+				});
+				const status = input.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,
+					authorId,
+					publishedAt: status === "published" ? nowIso : null,
+					scheduledAt: status === "scheduled" ? input.scheduledAt ?? null : null,
+					data: normalizedData,
+					terms: input.terms
+				});
+				if (input.terms) {
+					const allTermIds = Object.values(input.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;
+			},
+			async findById(id) {
+				return self.storage.getContent(slug, id);
+			},
+			async findBySlug(contentSlug) {
+				return self.storage.getContentBySlug(slug, contentSlug);
+			},
+			async find(options = {}) {
+				return self.storage.findContent(slug, options);
+			},
+			async update(id, input, authorId = null, revisionNote) {
+				const existing = await self.storage.getContent(slug, id);
+				if (!existing) return null;
+				const mergedData = {
+					...existing.data,
+					...input.data || {}
+				};
+				if (input.title !== void 0) mergedData.title = input.title;
+				else if (existing.title !== void 0 && mergedData.title === void 0) mergedData.title = existing.title;
+				if (input.slug !== void 0) mergedData.slug = input.slug;
+				else if (existing.slug !== void 0 && mergedData.slug === void 0) mergedData.slug = existing.slug;
+				if (input.status !== void 0) mergedData.status = input.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) => {
+					const check = await self.storage.getContentBySlug(slug, s);
+					return check !== null && check.id !== id;
+				}, id);
+				const nextStatus = input.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,
+					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,
+					publishedAt,
+					authorId: authorId ?? existing.authorId,
+					data: normalizedData,
+					terms: input.terms !== void 0 ? input.terms : existing.terms
+				});
+				if (updated) {
+					if (input.terms) {
+						const allTermIds = Object.values(input.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 updated;
+			},
+			async delete(id) {
+				const item = await self.storage.getContent(slug, id);
+				if (!item) return false;
+				const deleted = await self.storage.deleteContent(slug, id);
+				if (deleted) {
+					await self.hooks.doAction("cms.content_deleted", item);
+					await self.hooks.doAction(`cms.${slug}_deleted`, item);
+				}
+				return deleted;
+			},
+			async publish(id, authorId = null) {
+				return this.update(id, { status: "published" }, authorId, "Published content");
+			},
+			async schedule(id, scheduledAt, authorId = null) {
+				const dateStr = scheduledAt instanceof Date ? scheduledAt.toISOString() : scheduledAt;
+				return this.update(id, {
+					status: "scheduled",
+					scheduledAt: dateStr
+				}, authorId, `Scheduled for publish at ${dateStr}`);
+			},
+			async getRevisions(id) {
+				return self.revisions.getRevisions(id);
+			},
+			async getRevision(revisionId) {
+				return self.revisions.getRevision(revisionId);
+			},
+			async restoreRevision(id, revisionId, authorId) {
+				return self.revisions.restoreRevision(slug, revisionId, authorId);
+			},
+			getDiff(oldVersion, newVersion) {
+				return self.revisions.computeDiff(oldVersion, newVersion);
+			}
+		};
+	}
+	/**
+	* Run scheduled content publisher for all registered collections.
+	*/
+	async processScheduledContent(now = /* @__PURE__ */ new Date()) {
+		const published = [];
+		for (const coll of this.collections.values()) {
+			const res = await this.lifecycle.processScheduledContent(coll.slug, now);
+			published.push(...res);
+		}
+		return published;
+	}
+};
+/**
+* Factory helper to create a configured CMSEngine instance.
+*/
+function createCMSEngine(config, storage, hooks) {
+	return new CMSEngine(config, storage, hooks);
+}
+//#endregion
+//#region src/api/router.ts
+function jsonResponse(data, status = 200, headers = {}) {
+	return new Response(JSON.stringify(data), {
+		status,
+		headers: {
+			"Content-Type": "application/json",
+			"Access-Control-Allow-Origin": "*",
+			"Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
+			"Access-Control-Allow-Headers": "Content-Type, Authorization",
+			...headers
+		}
+	});
+}
+var CMSRouter = class {
+	engine;
+	constructor(engine) {
+		this.engine = engine;
+	}
+	/**
+	* Universal Web Standards request handler.
+	*/
+	async handle(request) {
+		const url = new URL(request.url);
+		const pathname = url.pathname;
+		const method = request.method.toUpperCase();
+		if (method === "OPTIONS") return new Response(null, {
+			status: 204,
+			headers: {
+				"Access-Control-Allow-Origin": "*",
+				"Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
+				"Access-Control-Allow-Headers": "Content-Type, Authorization"
+			}
+		});
+		try {
+			if (pathname === "/api/cron/scheduled" && method === "POST") {
+				const published = await this.engine.processScheduledContent();
+				return jsonResponse({
+					success: true,
+					publishedCount: published.length,
+					items: published
+				});
+			}
+			if (pathname.startsWith("/api/options")) return this.handleOptions(pathname, method, url, request);
+			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);
+			return jsonResponse({
+				error: "Endpoint not found",
+				path: pathname
+			}, 404);
+		} catch (error) {
+			return jsonResponse({ error: error instanceof Error ? error.message : String(error) }, 500);
+		}
+	}
+	async handleContent(pathname, method, url, request) {
+		const parts = pathname.replace(/^\/api\/content\/?/, "").split("/").filter(Boolean);
+		const collectionSlug = parts[0];
+		if (!collectionSlug) return jsonResponse({ collections: this.engine.getCollections().map((c) => ({
+			slug: c.slug,
+			label: c.label,
+			hierarchical: c.hierarchical
+		})) }, 200);
+		const coll = this.engine.collection(collectionSlug);
+		if (parts.length === 1 && method === "GET") {
+			const status = url.searchParams.get("status") || void 0;
+			const search = url.searchParams.get("search") || void 0;
+			const limit = url.searchParams.has("limit") ? Number(url.searchParams.get("limit")) : void 0;
+			const offset = url.searchParams.has("offset") ? Number(url.searchParams.get("offset")) : void 0;
+			const termIds = url.searchParams.has("termIds") ? url.searchParams.get("termIds").split(",") : void 0;
+			return jsonResponse(await coll.find({
+				status,
+				search,
+				limit,
+				offset,
+				termIds
+			}));
+		}
+		if (parts.length === 1 && method === "POST") {
+			const body = await request.json();
+			return jsonResponse(await coll.create(body), 201);
+		}
+		const idOrSlug = parts[1];
+		if (parts.length === 3 && parts[2] === "revisions" && method === "GET") return jsonResponse(await coll.getRevisions(idOrSlug));
+		if (parts.length === 4 && parts[2] === "restore" && method === "POST") {
+			const revisionId = parts[3];
+			const restored = await coll.restoreRevision(idOrSlug, revisionId);
+			if (!restored) return jsonResponse({ error: "Revision or content item not found" }, 404);
+			return jsonResponse(restored);
+		}
+		if (parts.length === 2 && method === "GET") {
+			const bySlug = url.searchParams.get("by") === "slug";
+			let item = bySlug ? await coll.findBySlug(idOrSlug) : await coll.findById(idOrSlug);
+			if (!item && !bySlug) item = await coll.findBySlug(idOrSlug);
+			if (!item) return jsonResponse({ error: "Content item not found" }, 404);
+			return jsonResponse(item);
+		}
+		if (parts.length === 2 && method === "PUT") {
+			const body = await request.json();
+			const updated = await coll.update(idOrSlug, body);
+			if (!updated) return jsonResponse({ error: "Content item not found" }, 404);
+			return jsonResponse(updated);
+		}
+		if (parts.length === 2 && method === "DELETE") {
+			if (!await coll.delete(idOrSlug)) return jsonResponse({ error: "Content item not found" }, 404);
+			return jsonResponse({
+				success: true,
+				id: idOrSlug
+			});
+		}
+		return jsonResponse({ error: "Method not allowed" }, 405);
+	}
+	async handleTaxonomies(pathname, method, url, request) {
+		const parts = pathname.replace(/^\/api\/taxonomies\/?/, "").split("/").filter(Boolean);
+		if (parts.length === 0 && method === "GET") return jsonResponse(this.engine.taxonomies.getTaxonomies());
+		const taxonomySlug = parts[0];
+		if (parts.length === 2 && parts[1] === "terms" && method === "GET") {
+			if (url.searchParams.get("tree") === "true") return jsonResponse(await this.engine.taxonomies.getTermTree(taxonomySlug));
+			return jsonResponse(await this.engine.taxonomies.getTerms(taxonomySlug));
+		}
+		if (parts.length === 2 && parts[1] === "terms" && method === "POST") {
+			const body = await request.json();
+			return jsonResponse(await this.engine.taxonomies.createTerm(taxonomySlug, body), 201);
+		}
+		if (parts.length === 3 && parts[1] === "terms" && method === "GET") {
+			const term = await this.engine.taxonomies.getTermById(parts[2]);
+			if (!term) return jsonResponse({ error: "Term not found" }, 404);
+			return jsonResponse(term);
+		}
+		if (parts.length === 3 && parts[1] === "terms" && method === "PUT") {
+			const body = await request.json();
+			const updated = await this.engine.taxonomies.updateTerm(parts[2], body);
+			if (!updated) return jsonResponse({ error: "Term not found" }, 404);
+			return jsonResponse(updated);
+		}
+		if (parts.length === 3 && parts[1] === "terms" && method === "DELETE") {
+			if (!await this.engine.taxonomies.deleteTerm(parts[2])) return jsonResponse({ error: "Term not found" }, 404);
+			return jsonResponse({
+				success: true,
+				id: parts[2]
+			});
+		}
+		return jsonResponse({ error: "Endpoint not found" }, 404);
+	}
+	async handleMedia(pathname, method, url, request) {
+		const parts = pathname.replace(/^\/api\/media\/?/, "").split("/").filter(Boolean);
+		if (parts.length === 0 && method === "GET") {
+			const search = url.searchParams.get("search") || void 0;
+			const mimeType = url.searchParams.get("mimeType") || void 0;
+			const limit = url.searchParams.has("limit") ? Number(url.searchParams.get("limit")) : void 0;
+			const offset = url.searchParams.has("offset") ? Number(url.searchParams.get("offset")) : void 0;
+			return jsonResponse(await this.engine.media.find({
+				search,
+				mimeType,
+				limit,
+				offset
+			}));
+		}
+		if (parts.length === 0 && method === "POST") {
+			const body = await request.json();
+			return jsonResponse(await this.engine.media.upload(body), 201);
+		}
+		const id = parts[0];
+		if (parts.length === 1 && method === "GET") {
+			const media = await this.engine.media.get(id);
+			if (!media) return jsonResponse({ error: "Media not found" }, 404);
+			return jsonResponse(media);
+		}
+		if (parts.length === 1 && method === "PUT") {
+			const body = await request.json();
+			const updated = await this.engine.media.updateMetadata(id, body);
+			if (!updated) return jsonResponse({ error: "Media not found" }, 404);
+			return jsonResponse(updated);
+		}
+		if (parts.length === 1 && method === "DELETE") {
+			if (!await this.engine.media.delete(id)) return jsonResponse({ error: "Media not found" }, 404);
+			return jsonResponse({
+				success: true,
+				id
+			});
+		}
+		return jsonResponse({ error: "Method not allowed" }, 405);
+	}
+	async handleOptions(pathname, method, url, request) {
+		const key = pathname.replace(/^\/api\/options\/?/, "");
+		if (!key && method === "GET") {
+			const namespace = url.searchParams.get("namespace") || void 0;
+			return jsonResponse(await this.engine.options.getAll(namespace));
+		}
+		if (key && method === "GET") {
+			const val = await this.engine.options.get(key);
+			if (val === void 0) return jsonResponse({ error: "Option not found" }, 404);
+			return jsonResponse({
+				key,
+				value: val
+			});
+		}
+		if (key && method === "PUT") {
+			const body = await request.json();
+			return jsonResponse(await this.engine.options.set(key, body.value, {
+				autoload: body.autoload,
+				namespace: body.namespace
+			}));
+		}
+		if (key && method === "DELETE") {
+			if (!await this.engine.options.delete(key)) return jsonResponse({ error: "Option not found" }, 404);
+			return jsonResponse({
+				success: true,
+				key
+			});
+		}
+		return jsonResponse({ error: "Method not allowed" }, 405);
+	}
+};
+function createCMSRouter(engine) {
+	return new CMSRouter(engine);
+}
+//#endregion
+//#region src/client/cms-client.ts
+var CMSClient = class {
+	engine;
+	baseUrl;
+	fetchFn;
+	headers;
+	constructor(options) {
+		this.engine = options.engine;
+		this.baseUrl = options.baseUrl?.replace(/\/+$/, "");
+		this.fetchFn = options.fetch ?? globalThis.fetch?.bind(globalThis);
+		this.headers = {
+			"Content-Type": "application/json",
+			...options.headers || {}
+		};
+	}
+	collection(slug) {
+		const self = this;
+		if (this.engine) {
+			const coll = this.engine.collection(slug);
+			return {
+				find: (opts) => coll.find(opts),
+				findById: (id) => coll.findById(id),
+				findBySlug: (s) => coll.findBySlug(s),
+				create: (data) => coll.create(data),
+				update: (id, data) => coll.update(id, data),
+				delete: (id) => coll.delete(id)
+			};
+		}
+		return {
+			async find(options = {}) {
+				const params = new URLSearchParams();
+				if (options.status) {
+					const statuses = Array.isArray(options.status) ? options.status.join(",") : options.status;
+					params.set("status", statuses);
+				}
+				if (options.search) params.set("search", options.search);
+				if (options.limit !== void 0) params.set("limit", String(options.limit));
+				if (options.offset !== void 0) params.set("offset", String(options.offset));
+				if (options.termIds && options.termIds.length > 0) params.set("termIds", options.termIds.join(","));
+				const queryStr = params.toString() ? `?${params.toString()}` : "";
+				return self.request(`/api/content/${slug}${queryStr}`);
+			},
+			async findById(id) {
+				return self.request(`/api/content/${slug}/${id}`);
+			},
+			async findBySlug(contentSlug) {
+				return self.request(`/api/content/${slug}/${contentSlug}?by=slug`);
+			},
+			async create(data) {
+				return self.request(`/api/content/${slug}`, {
+					method: "POST",
+					body: JSON.stringify(data)
+				});
+			},
+			async update(id, data) {
+				return self.request(`/api/content/${slug}/${id}`, {
+					method: "PUT",
+					body: JSON.stringify(data)
+				});
+			},
+			async delete(id) {
+				const res = await self.request(`/api/content/${slug}/${id}`, { method: "DELETE" });
+				return Boolean(res?.success);
+			}
+		};
+	}
+	taxonomies = {
+		getTerms: async (taxonomy) => {
+			if (this.engine) return this.engine.taxonomies.getTerms(taxonomy);
+			return this.request(`/api/taxonomies/${taxonomy}/terms`);
+		},
+		getTree: async (taxonomy) => {
+			if (this.engine) return this.engine.taxonomies.getTermTree(taxonomy);
+			return this.request(`/api/taxonomies/${taxonomy}/terms?tree=true`);
+		}
+	};
+	media = {
+		find: async (options) => {
+			if (this.engine) return this.engine.media.find(options);
+			const params = new URLSearchParams();
+			if (options?.search) params.set("search", options.search);
+			if (options?.limit) params.set("limit", String(options.limit));
+			const q = params.toString() ? `?${params.toString()}` : "";
+			return this.request(`/api/media${q}`);
+		},
+		get: async (id) => {
+			if (this.engine) return this.engine.media.get(id);
+			return this.request(`/api/media/${id}`);
+		}
+	};
+	options = { get: async (key, defaultValue) => {
+		if (this.engine) return this.engine.options.get(key, defaultValue);
+		try {
+			return (await this.request(`/api/options/${key}`))?.value ?? defaultValue;
+		} catch {
+			return defaultValue;
+		}
+	} };
+	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}`;
+		const res = await this.fetchFn(url, {
+			...init,
+			headers: {
+				...this.headers,
+				...init?.headers || {}
+			}
+		});
+		if (!res.ok) {
+			if (res.status === 404) return null;
+			const body = await res.text();
+			throw new Error(`[CMSClient] HTTP ${res.status}: ${body}`);
+		}
+		return res.json();
+	}
+};
+function createCmsClient(options) {
+	return new CMSClient(options);
+}
+//#endregion
+export { CMSClient, CMSEngine, CMSRouter, ContentLifecycle, DEFAULT_COLLECTIONS, DEFAULT_ROLE_CAPABILITIES, HooksManager, MediaManager, MemoryStorageAdapter, OptionsManager, RBACManager, RevisionManager, TaxonomyManager, VALID_STATUS_TRANSITIONS, collection, createCMSEngine, createCMSRouter, createCmsClient, defaultHooks, defineConfig, fields, normalizeConfig, resolveUniqueSlug, slugify, validateAndNormalizeData };
+
+//# sourceMappingURL=index.mjs.map