dineway 0.1.14 → 0.1.16

package/dist/menus-CwI7DQJ5.mjs

@@ -0,0 +1,569 @@
+import { t as __exportAll } from "./chunk-ClPoSABd.mjs";
+import { n as getI18nConfig } from "./config-XW5tMrH8.mjs";
+import { t as withTransaction } from "./transaction-qfqpPVpu.mjs";
+import { ulid } from "ulidx";
+
+//#region src/api/handlers/menus.ts
+var menus_exports = /* @__PURE__ */ __exportAll({
+	handleMenuCreate: () => handleMenuCreate,
+	handleMenuDelete: () => handleMenuDelete,
+	handleMenuGet: () => handleMenuGet,
+	handleMenuItemCreate: () => handleMenuItemCreate,
+	handleMenuItemDelete: () => handleMenuItemDelete,
+	handleMenuItemReorder: () => handleMenuItemReorder,
+	handleMenuItemUpdate: () => handleMenuItemUpdate,
+	handleMenuList: () => handleMenuList,
+	handleMenuSetItems: () => handleMenuSetItems,
+	handleMenuTranslations: () => handleMenuTranslations,
+	handleMenuUpdate: () => handleMenuUpdate
+});
+/**
+* Error returned when a menu lookup by `name` matches multiple locale
+* variants and the caller did not pass `locale` to disambiguate. Maps to
+* HTTP 400 via `mapErrorStatus`. The available locales are surfaced in the
+* message so MCP/REST callers can recover by re-issuing with `locale`.
+*/
+function ambiguousMenuLocaleError(name, locales) {
+	return {
+		success: false,
+		error: {
+			code: "AMBIGUOUS_LOCALE",
+			message: `Menu '${name}' exists in multiple locales (${locales.toSorted().join(", ")}); pass 'locale' to disambiguate.`
+		}
+	};
+}
+/**
+* List menus with item counts. Filter by `locale` when provided; otherwise
+* return every menu row (each locale counts as its own menu for admin listing
+* purposes).
+*/
+async function handleMenuList(db, options = {}) {
+	try {
+		let query = db.selectFrom("_dineway_menus as m").leftJoin("_dineway_menu_items as i", "i.menu_id", "m.id").select(({ fn }) => [
+			"m.id",
+			"m.name",
+			"m.label",
+			"m.created_at",
+			"m.updated_at",
+			"m.locale",
+			"m.translation_group",
+			fn.count("i.id").as("itemCount")
+		]).groupBy([
+			"m.id",
+			"m.name",
+			"m.label",
+			"m.created_at",
+			"m.updated_at",
+			"m.locale",
+			"m.translation_group"
+		]).orderBy("m.name", "asc");
+		if (options.locale !== void 0) query = query.where("m.locale", "=", options.locale);
+		return {
+			success: true,
+			data: (await query.execute()).map((row) => ({
+				id: row.id,
+				name: row.name,
+				label: row.label,
+				created_at: row.created_at,
+				updated_at: row.updated_at,
+				locale: row.locale,
+				translation_group: row.translation_group,
+				itemCount: typeof row.itemCount === "string" ? Number(row.itemCount) : row.itemCount
+			}))
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "MENU_LIST_ERROR",
+				message: "Failed to fetch menus"
+			}
+		};
+	}
+}
+/**
+* Create a new menu. When `translationOf` is supplied the new menu joins the
+* source menu's translation_group (and gets the source's items cloned).
+*/
+async function handleMenuCreate(db, input) {
+	try {
+		if (input.translationOf && !input.locale) return {
+			success: false,
+			error: {
+				code: "VALIDATION_ERROR",
+				message: "`locale` is required when `translationOf` is provided"
+			}
+		};
+		let translationGroup = null;
+		let sourceMenu = null;
+		if (input.translationOf) {
+			const src = await db.selectFrom("_dineway_menus").selectAll().where("id", "=", input.translationOf).executeTakeFirst();
+			if (!src) return {
+				success: false,
+				error: {
+					code: "NOT_FOUND",
+					message: "Source menu for translation not found"
+				}
+			};
+			sourceMenu = src;
+			translationGroup = src.translation_group ?? src.id;
+		}
+		const effectiveLocale = input.locale ?? getI18nConfig()?.defaultLocale ?? "en";
+		if (await db.selectFrom("_dineway_menus").select("id").where("name", "=", input.name).where("locale", "=", effectiveLocale).executeTakeFirst()) return {
+			success: false,
+			error: {
+				code: "CONFLICT",
+				message: `Menu "${input.name}" already exists${input.locale ? ` in locale "${input.locale}"` : ""}`
+			}
+		};
+		const id = ulid();
+		await withTransaction(db, async (trx) => {
+			await trx.insertInto("_dineway_menus").values({
+				id,
+				name: input.name,
+				label: input.label,
+				...input.locale !== void 0 ? { locale: input.locale } : {},
+				translation_group: translationGroup ?? id
+			}).execute();
+			if (sourceMenu) {
+				const sourceItems = await trx.selectFrom("_dineway_menu_items").selectAll().where("menu_id", "=", sourceMenu.id).orderBy("sort_order", "asc").execute();
+				if (sourceItems.length > 0) {
+					const idMap = /* @__PURE__ */ new Map();
+					for (const item of sourceItems) idMap.set(item.id, ulid());
+					await trx.insertInto("_dineway_menu_items").values(sourceItems.map((item) => {
+						return {
+							id: idMap.get(item.id),
+							menu_id: id,
+							parent_id: item.parent_id ? idMap.get(item.parent_id) ?? null : null,
+							sort_order: item.sort_order,
+							type: item.type,
+							reference_collection: item.reference_collection,
+							reference_id: item.reference_id,
+							custom_url: item.custom_url,
+							label: item.label,
+							title_attr: item.title_attr,
+							target: item.target,
+							css_classes: item.css_classes,
+							...input.locale !== void 0 ? { locale: input.locale } : {},
+							translation_group: item.translation_group ?? item.id
+						};
+					})).execute();
+				}
+			}
+		});
+		return {
+			success: true,
+			data: await db.selectFrom("_dineway_menus").selectAll().where("id", "=", id).executeTakeFirstOrThrow()
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "MENU_CREATE_ERROR",
+				message: "Failed to create menu"
+			}
+		};
+	}
+}
+/**
+* Get a single menu by name. Honours an optional `locale` filter; when two
+* menus share a name across locales, the locale distinguishes them.
+*/
+async function handleMenuGet(db, name, options = {}) {
+	try {
+		let query = db.selectFrom("_dineway_menus").selectAll().where("name", "=", name);
+		if (options.locale !== void 0) query = query.where("locale", "=", options.locale);
+		const menu = await query.orderBy("locale", "asc").executeTakeFirst();
+		if (!menu) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Menu '${name}' not found`
+			}
+		};
+		const items = await db.selectFrom("_dineway_menu_items").selectAll().where("menu_id", "=", menu.id).orderBy("sort_order", "asc").execute();
+		return {
+			success: true,
+			data: {
+				...menu,
+				items
+			}
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "MENU_GET_ERROR",
+				message: "Failed to fetch menu"
+			}
+		};
+	}
+}
+/**
+* Update a menu's label. The name + locale are immutable.
+*/
+async function handleMenuUpdate(db, name, input) {
+	try {
+		let query = db.selectFrom("_dineway_menus").select(["id", "locale"]).where("name", "=", name);
+		if (input.locale !== void 0) query = query.where("locale", "=", input.locale);
+		const matches = await query.execute();
+		if (matches.length === 0) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Menu '${name}' not found${input.locale ? ` in locale '${input.locale}'` : ""}`
+			}
+		};
+		if (matches.length > 1) return ambiguousMenuLocaleError(name, matches.map((m) => m.locale));
+		const menu = matches[0];
+		if (input.label) await db.updateTable("_dineway_menus").set({ label: input.label }).where("id", "=", menu.id).execute();
+		return {
+			success: true,
+			data: await db.selectFrom("_dineway_menus").selectAll().where("id", "=", menu.id).executeTakeFirstOrThrow()
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "MENU_UPDATE_ERROR",
+				message: "Failed to update menu"
+			}
+		};
+	}
+}
+/**
+* Delete a menu (and items, via cascade).
+*/
+async function handleMenuDelete(db, name, options = {}) {
+	try {
+		let query = db.selectFrom("_dineway_menus").select(["id", "locale"]).where("name", "=", name);
+		if (options.locale !== void 0) query = query.where("locale", "=", options.locale);
+		const matches = await query.execute();
+		if (matches.length === 0) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Menu '${name}' not found${options.locale ? ` in locale '${options.locale}'` : ""}`
+			}
+		};
+		if (matches.length > 1) return ambiguousMenuLocaleError(name, matches.map((m) => m.locale));
+		const menu = matches[0];
+		await db.deleteFrom("_dineway_menu_items").where("menu_id", "=", menu.id).execute();
+		await db.deleteFrom("_dineway_menus").where("id", "=", menu.id).execute();
+		return {
+			success: true,
+			data: { deleted: true }
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "MENU_DELETE_ERROR",
+				message: "Failed to delete menu"
+			}
+		};
+	}
+}
+/**
+* List every translation of a menu (by id or translation_group).
+*/
+async function handleMenuTranslations(db, idOrGroup) {
+	try {
+		const anchor = await db.selectFrom("_dineway_menus").selectAll().where((eb) => eb.or([eb("id", "=", idOrGroup), eb("translation_group", "=", idOrGroup)])).executeTakeFirst();
+		if (!anchor) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: "Menu not found"
+			}
+		};
+		const group = anchor.translation_group ?? anchor.id;
+		return {
+			success: true,
+			data: {
+				translationGroup: group,
+				translations: (await db.selectFrom("_dineway_menus").selectAll().where("translation_group", "=", group).orderBy("locale", "asc").execute()).map((row) => ({
+					id: row.id,
+					name: row.name,
+					locale: row.locale,
+					label: row.label,
+					updatedAt: row.updated_at
+				}))
+			}
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "MENU_TRANSLATIONS_ERROR",
+				message: "Failed to list menu translations"
+			}
+		};
+	}
+}
+/**
+* Add an item to a menu. The item inherits the menu's locale (so listing
+* items by locale stays trivial).
+*/
+async function handleMenuItemCreate(db, menuName, input, options = {}) {
+	try {
+		let menuQuery = db.selectFrom("_dineway_menus").select(["id", "locale"]).where("name", "=", menuName);
+		if (options.locale !== void 0) menuQuery = menuQuery.where("locale", "=", options.locale);
+		const matches = await menuQuery.execute();
+		if (matches.length === 0) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: "Menu not found"
+			}
+		};
+		if (matches.length > 1) return ambiguousMenuLocaleError(menuName, matches.map((m) => m.locale));
+		const menu = matches[0];
+		let sortOrder = input.sortOrder ?? 0;
+		if (input.sortOrder === void 0) sortOrder = ((await db.selectFrom("_dineway_menu_items").select(({ fn }) => fn.max("sort_order").as("max")).where("menu_id", "=", menu.id).where("parent_id", "is", input.parentId ?? null).executeTakeFirst())?.max ?? -1) + 1;
+		const id = ulid();
+		await db.insertInto("_dineway_menu_items").values({
+			id,
+			menu_id: menu.id,
+			parent_id: input.parentId ?? null,
+			sort_order: sortOrder,
+			type: input.type,
+			reference_collection: input.referenceCollection ?? null,
+			reference_id: input.referenceId ?? null,
+			custom_url: input.customUrl ?? null,
+			label: input.label,
+			title_attr: input.titleAttr ?? null,
+			target: input.target ?? null,
+			css_classes: input.cssClasses ?? null,
+			locale: menu.locale,
+			translation_group: id
+		}).execute();
+		return {
+			success: true,
+			data: await db.selectFrom("_dineway_menu_items").selectAll().where("id", "=", id).executeTakeFirstOrThrow()
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "MENU_ITEM_CREATE_ERROR",
+				message: "Failed to create menu item"
+			}
+		};
+	}
+}
+/**
+* Update a menu item.
+*/
+async function handleMenuItemUpdate(db, menuName, itemId, input, options = {}) {
+	try {
+		let menuQuery = db.selectFrom("_dineway_menus").select(["id", "locale"]).where("name", "=", menuName);
+		if (options.locale !== void 0) menuQuery = menuQuery.where("locale", "=", options.locale);
+		const matches = await menuQuery.execute();
+		if (matches.length === 0) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: "Menu not found"
+			}
+		};
+		if (matches.length > 1) return ambiguousMenuLocaleError(menuName, matches.map((m) => m.locale));
+		const menu = matches[0];
+		if (!await db.selectFrom("_dineway_menu_items").select("id").where("id", "=", itemId).where("menu_id", "=", menu.id).executeTakeFirst()) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: "Menu item not found"
+			}
+		};
+		const updates = {};
+		if (input.label !== void 0) updates.label = input.label;
+		if (input.customUrl !== void 0) updates.custom_url = input.customUrl;
+		if (input.target !== void 0) updates.target = input.target;
+		if (input.titleAttr !== void 0) updates.title_attr = input.titleAttr;
+		if (input.cssClasses !== void 0) updates.css_classes = input.cssClasses;
+		if (input.parentId !== void 0) updates.parent_id = input.parentId;
+		if (input.sortOrder !== void 0) updates.sort_order = input.sortOrder;
+		if (Object.keys(updates).length > 0) await db.updateTable("_dineway_menu_items").set(updates).where("id", "=", itemId).execute();
+		return {
+			success: true,
+			data: await db.selectFrom("_dineway_menu_items").selectAll().where("id", "=", itemId).executeTakeFirstOrThrow()
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "MENU_ITEM_UPDATE_ERROR",
+				message: "Failed to update menu item"
+			}
+		};
+	}
+}
+/**
+* Delete a menu item.
+*/
+async function handleMenuItemDelete(db, menuName, itemId, options = {}) {
+	try {
+		let menuQuery = db.selectFrom("_dineway_menus").select(["id", "locale"]).where("name", "=", menuName);
+		if (options.locale !== void 0) menuQuery = menuQuery.where("locale", "=", options.locale);
+		const matches = await menuQuery.execute();
+		if (matches.length === 0) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: "Menu not found"
+			}
+		};
+		if (matches.length > 1) return ambiguousMenuLocaleError(menuName, matches.map((m) => m.locale));
+		const menu = matches[0];
+		if ((await db.deleteFrom("_dineway_menu_items").where("id", "=", itemId).where("menu_id", "=", menu.id).execute())[0]?.numDeletedRows === 0n) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: "Menu item not found"
+			}
+		};
+		return {
+			success: true,
+			data: { deleted: true }
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "MENU_ITEM_DELETE_ERROR",
+				message: "Failed to delete menu item"
+			}
+		};
+	}
+}
+/**
+* Replace the entire set of items for a menu in one atomic transaction.
+*
+* Existing items are deleted and the new list is inserted in the order
+* provided. `parentIndex` references resolve to actual parent IDs as the
+* insert proceeds.
+*/
+async function handleMenuSetItems(db, menuName, items, options = {}) {
+	for (let i = 0; i < items.length; i++) {
+		const item = items[i];
+		if (item?.parentIndex !== void 0) {
+			if (item.parentIndex < 0 || item.parentIndex >= i) return {
+				success: false,
+				error: {
+					code: "VALIDATION_ERROR",
+					message: `item[${i}].parentIndex (${item.parentIndex}) must reference an earlier item`
+				}
+			};
+		}
+	}
+	try {
+		const notFoundSentinel = Symbol("menu-not-found");
+		let ambiguousLocales = null;
+		const ambiguousSentinel = Symbol("menu-ambiguous-locale");
+		try {
+			await withTransaction(db, async (trx) => {
+				let menuQuery = trx.selectFrom("_dineway_menus").select(["id", "locale"]).where("name", "=", menuName);
+				if (options.locale !== void 0) menuQuery = menuQuery.where("locale", "=", options.locale);
+				const matches = await menuQuery.execute();
+				if (matches.length === 0) throw notFoundSentinel;
+				if (matches.length > 1) {
+					ambiguousLocales = matches.map((m) => m.locale);
+					throw ambiguousSentinel;
+				}
+				const menu = matches[0];
+				await trx.deleteFrom("_dineway_menu_items").where("menu_id", "=", menu.id).execute();
+				const insertedIds = [];
+				for (let i = 0; i < items.length; i++) {
+					const item = items[i];
+					if (!item) continue;
+					const id = ulid();
+					const parentId = item.parentIndex !== void 0 ? insertedIds[item.parentIndex] ?? null : null;
+					await trx.insertInto("_dineway_menu_items").values({
+						id,
+						menu_id: menu.id,
+						parent_id: parentId,
+						sort_order: i,
+						type: item.type,
+						reference_collection: item.referenceCollection ?? null,
+						reference_id: item.referenceId ?? null,
+						custom_url: item.customUrl ?? null,
+						label: item.label,
+						title_attr: item.titleAttr ?? null,
+						target: item.target ?? null,
+						css_classes: item.cssClasses ?? null,
+						locale: menu.locale
+					}).execute();
+					insertedIds.push(id);
+				}
+				await trx.updateTable("_dineway_menus").set({ updated_at: (/* @__PURE__ */ new Date()).toISOString() }).where("id", "=", menu.id).execute();
+			});
+		} catch (error) {
+			if (error === notFoundSentinel) return {
+				success: false,
+				error: {
+					code: "NOT_FOUND",
+					message: `Menu '${menuName}' not found${options.locale ? ` in locale '${options.locale}'` : ""}`
+				}
+			};
+			if (error === ambiguousSentinel && ambiguousLocales) return ambiguousMenuLocaleError(menuName, ambiguousLocales);
+			throw error;
+		}
+		return {
+			success: true,
+			data: {
+				name: menuName,
+				itemCount: items.length
+			}
+		};
+	} catch (error) {
+		console.error("[dineway] handleMenuSetItems failed:", error);
+		return {
+			success: false,
+			error: {
+				code: "MENU_SET_ITEMS_ERROR",
+				message: "Failed to set menu items"
+			}
+		};
+	}
+}
+/**
+* Batch reorder menu items.
+*/
+async function handleMenuItemReorder(db, menuName, items, options = {}) {
+	try {
+		let menuQuery = db.selectFrom("_dineway_menus").select(["id", "locale"]).where("name", "=", menuName);
+		if (options.locale !== void 0) menuQuery = menuQuery.where("locale", "=", options.locale);
+		const matches = await menuQuery.execute();
+		if (matches.length === 0) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: "Menu not found"
+			}
+		};
+		if (matches.length > 1) return ambiguousMenuLocaleError(menuName, matches.map((m) => m.locale));
+		const menu = matches[0];
+		return {
+			success: true,
+			data: await withTransaction(db, async (trx) => {
+				for (const item of items) await trx.updateTable("_dineway_menu_items").set({
+					parent_id: item.parentId,
+					sort_order: item.sortOrder
+				}).where("id", "=", item.id).where("menu_id", "=", menu.id).execute();
+				return trx.selectFrom("_dineway_menu_items").selectAll().where("menu_id", "=", menu.id).orderBy("sort_order", "asc").execute();
+			})
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "MENU_REORDER_ERROR",
+				message: "Failed to reorder menu items"
+			}
+		};
+	}
+}
+
+//#endregion
+export { handleMenuItemDelete as a, handleMenuList as c, menus_exports as d, handleMenuItemCreate as i, handleMenuTranslations as l, handleMenuDelete as n, handleMenuItemReorder as o, handleMenuGet as r, handleMenuItemUpdate as s, handleMenuCreate as t, handleMenuUpdate as u };

package/dist/mime-DJOFDGux.mjs

@@ -0,0 +1,35 @@
+//#region src/media/mime.ts
+function normalizeMime(mime) {
+	return mime.split(";")[0].trim().toLowerCase();
+}
+function matchesMimeAllowlist(mime, allowList) {
+	const normalized = normalizeMime(mime);
+	for (const entry of allowList) {
+		if (!entry || !entry.includes("/")) continue;
+		const normalizedEntry = normalizeMime(entry);
+		if (normalizedEntry.endsWith("/")) {
+			if (normalized.startsWith(normalizedEntry)) return true;
+		} else if (normalized === normalizedEntry) return true;
+	}
+	return false;
+}
+/**
+* Extract the `allowedMimeTypes` list from a `_dineway_fields.validation` row
+* (raw JSON string). Returns null when the value is missing, malformed, or the
+* list is empty; callers treat that as no field-specific constraint.
+*/
+function parseAllowedMimeTypes(rawValidation) {
+	if (!rawValidation) return null;
+	try {
+		const parsed = JSON.parse(rawValidation);
+		if (typeof parsed !== "object" || parsed === null) return null;
+		const list = parsed.allowedMimeTypes;
+		if (!Array.isArray(list) || list.length === 0) return null;
+		return list.filter((entry) => typeof entry === "string");
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+export { normalizeMime as n, parseAllowedMimeTypes as r, matchesMimeAllowlist as t };

package/dist/{oauth-authorization-DxGjiWKL.mjs → oauth-authorization-DcYRiDfi.mjs}

@@ -1,8 +1,8 @@
-import { t as withTransaction } from "./transaction-x2tJQ-A1.mjs";
-import { a as filterExperimentalSiteContextWorkflowScopes, i as experimentalSiteContextWorkflowsEnabled, o as getExperimentalSiteContextWorkflowScopesDisabledMessage, r as disabledExperimentalSiteContextWorkflowScopes } from "./experimental-workflows-C9X7yblQ.mjs";
-import { a as hashApiToken, n as TOKEN_PREFIXES, r as generatePrefixedToken, t as ALL_VALID_SCOPES } from "./api-tokens-CPjC3zf8.mjs";
-import { c as validateRedirectUri, o as lookupOAuthClient, s as validateClientRedirectUri } from "./oauth-clients-DxO_NO7k.mjs";
-import { t as lookupUserRoleAndStatus } from "./oauth-user-lookup-Bi0ek9eM.mjs";
+import { t as withTransaction } from "./transaction-qfqpPVpu.mjs";
+import { a as filterExperimentalSiteContextWorkflowScopes, i as experimentalSiteContextWorkflowsEnabled, o as getExperimentalSiteContextWorkflowScopesDisabledMessage, r as disabledExperimentalSiteContextWorkflowScopes } from "./experimental-workflows-CSRjuEwS.mjs";
+import { a as hashApiToken, n as TOKEN_PREFIXES, r as generatePrefixedToken, t as ALL_VALID_SCOPES } from "./api-tokens-B7fvbHM2.mjs";
+import { c as validateRedirectUri, o as lookupOAuthClient, s as validateClientRedirectUri } from "./oauth-clients-CgKFA-VH.mjs";
+import { t as lookupUserRoleAndStatus } from "./oauth-user-lookup-nyXQ2_6Q.mjs";
 import { clampScopes, computeS256Challenge, secureCompare } from "@dineway-ai/auth";
 import { generateCodeVerifier } from "arctic";
 

package/dist/{oauth-clients-DxO_NO7k.mjs → oauth-clients-CgKFA-VH.mjs}

@@ -1,5 +1,5 @@
-import { o as getExperimentalSiteContextWorkflowScopesDisabledMessage, r as disabledExperimentalSiteContextWorkflowScopes } from "./experimental-workflows-C9X7yblQ.mjs";
-import { o as validateScopes } from "./api-tokens-CPjC3zf8.mjs";
+import { o as getExperimentalSiteContextWorkflowScopesDisabledMessage, r as disabledExperimentalSiteContextWorkflowScopes } from "./experimental-workflows-CSRjuEwS.mjs";
+import { o as validateScopes } from "./api-tokens-B7fvbHM2.mjs";
 
 //#region src/api/oauth/redirect-uri.ts
 /**

package/dist/page/index.d.mts

@@ -1,5 +1,5 @@
-import { A as PageMetadataContribution, D as PageFragmentContribution, q as PublicPageContext } from "../types-Q616b2Hn.mjs";
-import { a as generateSiteSeoContributions, c as ResolvedPageMetadata, d as resolvePageMetadata, f as safeJsonLdSerialize, i as generateBaseSeoContributions, l as escapeHtmlAttr, m as createPublicPageContext, n as buildWebSiteJsonLd, o as renderFragments, p as CreatePublicPageContextInput, r as cleanJsonLd, s as resolveFragments, t as buildBlogPostingJsonLd, u as renderPageMetadata } from "../jsonld-D2gUY4kA.mjs";
+import { A as PageMetadataContribution, D as PageFragmentContribution, q as PublicPageContext } from "../types-DS5PYew4.mjs";
+import { a as generateSiteSeoContributions, c as ResolvedPageMetadata, d as resolvePageMetadata, f as safeJsonLdSerialize, i as generateBaseSeoContributions, l as escapeHtmlAttr, m as createPublicPageContext, n as buildWebSiteJsonLd, o as renderFragments, p as CreatePublicPageContextInput, r as cleanJsonLd, s as resolveFragments, t as buildBlogPostingJsonLd, u as renderPageMetadata } from "../jsonld-BjsoTL5m.mjs";
 
 //#region src/page/index.d.ts
 /**

package/dist/page/index.mjs

@@ -1,4 +1,4 @@
-import { a as cleanJsonLd, c as escapeHtmlAttr, d as safeJsonLdSerialize, f as createPublicPageContext, i as buildWebSiteJsonLd, l as renderPageMetadata, n as generateSiteSeoContributions, o as renderFragments, r as buildBlogPostingJsonLd, s as resolveFragments, t as generateBaseSeoContributions, u as resolvePageMetadata } from "../seo-contributions-B1fWCnqY.mjs";
+import { a as cleanJsonLd, c as escapeHtmlAttr, d as safeJsonLdSerialize, f as createPublicPageContext, i as buildWebSiteJsonLd, l as renderPageMetadata, n as generateSiteSeoContributions, o as renderFragments, r as buildBlogPostingJsonLd, s as resolveFragments, t as generateBaseSeoContributions, u as resolvePageMetadata } from "../seo-contributions-CQzUjJKY.mjs";
 
 //#region src/page/index.ts
 /**

package/dist/{parse-C9106ehs.mjs → parse-BBfZRZYb.mjs}

@@ -1,4 +1,4 @@
-import { t as apiError } from "./error-BMUPwxgx.mjs";
+import { t as apiError } from "./error-Dyf9fGZE.mjs";
 import { z } from "zod";
 
 //#region src/api/parse.ts

package/dist/{placeholder-Bh1dfUOd.d.mts → placeholder-DKMMLt42.d.mts}

@@ -1,4 +1,4 @@
-import { l as MediaProvider, m as MediaValue } from "./types-OPs5Q_sX.mjs";
+import { l as MediaProvider, m as MediaValue } from "./types-D_wGrwiY.mjs";
 
 //#region src/media/normalize.d.ts
 /**

package/dist/plugins/adapt-sandbox-entry.d.mts

@@ -1,13 +1,13 @@
-import { n as PluginDescriptor } from "../runtime-QuuFSlc6.mjs";
-import "../types-DZPw8Rru.mjs";
-import { X as ResolvedPlugin, tt as StandardPluginDefinition } from "../types-Q616b2Hn.mjs";
-import "../types-BFmjniC2.mjs";
-import "../runner-BU6Lo1ZS.mjs";
-import "../index-EUAWaIxW.mjs";
-import "../index-CYfhYgXd.mjs";
-import "../bylines-DxXzWML_.mjs";
-import "../types-0Vr68fc2.mjs";
-import "../validate-BwmQEbu8.mjs";
+import { n as PluginDescriptor } from "../runtime-DY_XmE9Y.mjs";
+import "../types-CYBaBvtm.mjs";
+import { X as ResolvedPlugin, tt as StandardPluginDefinition } from "../types-DS5PYew4.mjs";
+import "../types-B45uSz1j.mjs";
+import "../runner-CHR_W79l.mjs";
+import "../index-JzJUzE4o.mjs";
+import "../index-DpMWSamU.mjs";
+import "../bylines-DE9bfDur.mjs";
+import "../types-BeYn-Yf0.mjs";
+import "../validate-BQ24E8rK.mjs";
 
 //#region src/plugins/adapt-sandbox-entry.d.ts
 /**