dineway 0.1.48 → 0.2.0

package/dist/{plugins-C57YQi4l.mjs → plugins-BolVa-tl.mjs}

@@ -1,14 +1,75 @@
-import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-C5zp2xir.mjs";
-import { t as OptionsRepository } from "./options-BvJoSSJR.mjs";
-import { n as createPluginContext, t as PluginContextFactory } from "./context-CoYb_fvK.mjs";
-import { t as extractRequestMeta } from "./request-meta-DAb6xaP9.mjs";
-import { r as setCronTasksEnabled } from "./cron-DxCAU_Sn.mjs";
+import { r as validatePluginIdentifier, t as validateIdentifier } from "./validate-VPnKoIzW.mjs";
+import { i as encodeBase64url, n as decodeBase64url } from "./base64-F8-DUraK.mjs";
+import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-CxBt-GxR.mjs";
+import { t as OptionsRepository } from "./options-DQPTH5n0.mjs";
+import { n as createPluginContext, t as PluginContextFactory } from "./context-C5W3G18y.mjs";
+import { t as extractRequestMeta } from "./request-meta-CUypToDJ.mjs";
+import { r as setCronTasksEnabled } from "./cron-cKcNTix_.mjs";
+import { i as parseEncryptionKeys, t as DinewaySecretsError } from "./secrets-CDZo2k8L.mjs";
 import { sql } from "kysely";
-import { ulid } from "ulidx";
 import { AsyncLocalStorage } from "node:async_hooks";
+import { ulid } from "ulidx";
 import { z } from "astro/zod";
+import { Permissions } from "@dineway-ai/auth";
 import { Worker } from "node:worker_threads";
 
+//#region src/database/repositories/plugin-secrets.ts
+var PluginSecretRepository = class {
+	constructor(db) {
+		this.db = db;
+	}
+	async put(input) {
+		const now = input.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+		const row = {
+			plugin_id: input.pluginId,
+			secret_name: input.name,
+			encryption_version: input.encryptionVersion,
+			key_id: input.keyId,
+			nonce: input.nonce,
+			ciphertext: input.ciphertext,
+			fingerprint: input.fingerprint,
+			created_at: now,
+			updated_at: now
+		};
+		await this.db.insertInto("_dineway_plugin_secrets").values(row).onConflict((conflict) => conflict.columns(["plugin_id", "secret_name"]).doUpdateSet({
+			encryption_version: row.encryption_version,
+			key_id: row.key_id,
+			nonce: row.nonce,
+			ciphertext: row.ciphertext,
+			fingerprint: row.fingerprint,
+			updated_at: now
+		})).execute();
+		const stored = await this.find(input.pluginId, input.name);
+		if (!stored) throw new Error("Plugin secret write did not persist.");
+		return stored;
+	}
+	async find(pluginId, name) {
+		const row = await this.db.selectFrom("_dineway_plugin_secrets").selectAll().where("plugin_id", "=", pluginId).where("secret_name", "=", name).executeTakeFirst();
+		return row ? rowToStoredPluginSecret(row) : null;
+	}
+	async list(pluginId) {
+		return (await this.db.selectFrom("_dineway_plugin_secrets").selectAll().where("plugin_id", "=", pluginId).orderBy("secret_name", "asc").execute()).map(rowToStoredPluginSecret);
+	}
+	async delete(pluginId, name) {
+		const result = await this.db.deleteFrom("_dineway_plugin_secrets").where("plugin_id", "=", pluginId).where("secret_name", "=", name).executeTakeFirst();
+		return Number(result.numDeletedRows ?? 0) > 0;
+	}
+};
+function rowToStoredPluginSecret(row) {
+	return {
+		pluginId: row.plugin_id,
+		name: row.secret_name,
+		encryptionVersion: row.encryption_version,
+		keyId: row.key_id,
+		nonce: row.nonce,
+		ciphertext: row.ciphertext,
+		fingerprint: row.fingerprint,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+
+//#endregion
 //#region src/database/repositories/relation.ts
 var RelationRepository = class {
 	constructor(db) {
@@ -267,6 +328,9 @@ function portableText(options) {
 function generateKey() {
 	return Math.random().toString(36).substring(2, 11);
 }
+function normalizeTextAlign(value) {
+	return value === "center" || value === "right" || value === "justify" ? value : void 0;
+}
 /**
 * Convert ProseMirror document to Portable Text
 */
@@ -311,13 +375,15 @@ function convertNode(node) {
 */
 function convertParagraph(node) {
 	const { children, markDefs } = convertInlineContent(node.content || []);
+	const textAlign = normalizeTextAlign(node.attrs?.textAlign);
 	if (children.length === 0) return null;
 	return {
 		_type: "block",
 		_key: generateKey(),
 		style: "normal",
 		children,
-		markDefs: markDefs.length > 0 ? markDefs : void 0
+		markDefs: markDefs.length > 0 ? markDefs : void 0,
+		...textAlign ? { textAlign } : {}
 	};
 }
 /** Map heading level number to Portable Text style */
@@ -338,13 +404,15 @@ function headingLevelToStyle(level) {
 function convertHeading(node) {
 	const { children, markDefs } = convertInlineContent(node.content || []);
 	const style = headingLevelToStyle(typeof node.attrs?.level === "number" ? node.attrs.level : 1);
+	const textAlign = normalizeTextAlign(node.attrs?.textAlign);
 	if (children.length === 0) return null;
 	return {
 		_type: "block",
 		_key: generateKey(),
 		style,
 		children,
-		markDefs: markDefs.length > 0 ? markDefs : void 0
+		markDefs: markDefs.length > 0 ? markDefs : void 0,
+		...textAlign ? { textAlign } : {}
 	};
 }
 /**
@@ -612,6 +680,7 @@ function convertBlock(block) {
 */
 function convertTextBlock(block) {
 	const { style = "normal", children, markDefs = [] } = block;
+	const textAlignAttrs = block.textAlign ? { textAlign: block.textAlign } : void 0;
 	const content = convertSpans(children, markDefs);
 	switch (style) {
 		case "h1":
@@ -621,7 +690,10 @@ function convertTextBlock(block) {
 		case "h5":
 		case "h6": return {
 			type: "heading",
-			attrs: { level: parseInt(style.substring(1), 10) },
+			attrs: {
+				level: parseInt(style.substring(1), 10),
+				...textAlignAttrs
+			},
 			content: content.length > 0 ? content : void 0
 		};
 		case "blockquote": return {
@@ -633,6 +705,7 @@ function convertTextBlock(block) {
 		};
 		default: return {
 			type: "paragraph",
+			attrs: textAlignAttrs,
 			content: content.length > 0 ? content : void 0
 		};
 	}
@@ -825,18 +898,343 @@ function convertHtmlBlock(block) {
 }
 
 //#endregion
-//#region src/after.ts
-function after(fn) {
-	Promise.resolve().then(fn).catch((error) => {
-		console.error("[dineway] deferred task failed:", error);
+//#region src/security/guest-access-tokens.ts
+const TOKEN_VERSION = 1;
+const DEFAULT_TTL_SECONDS = 720 * 60 * 60;
+const MAX_TTL_SECONDS = 3 * 366 * 24 * 60 * 60;
+const MAX_CLOCK_SKEW_SECONDS = 60;
+const MAX_TOKEN_LENGTH = 4096;
+const MIN_SECRET_BYTES = 32;
+const MAX_SECRET_BYTES$1 = 4096;
+const MAX_VERIFICATION_SECRETS = 8;
+const SIGNATURE_BYTES = 32;
+const DURATION_PATTERN = /^(\d+)([smhdw])$/;
+const BASE64URL_PATTERN = /^[A-Za-z0-9_-]+$/;
+const TOKEN_ID_PATTERN = /^gt_[A-Za-z0-9_-]{32}$/;
+const PURPOSE_PATTERN = /^[a-z][a-z0-9_.:-]{0,127}$/;
+const SUBJECT_TYPE_PATTERN = /^[a-z][a-z0-9_-]{0,63}$/;
+const OPAQUE_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/;
+const SIGNING_DOMAIN = "dineway-guest-access:v1";
+const HASH_DOMAIN = "dineway-guest-access-hash:v1";
+var GuestAccessTokenConfigurationError = class extends Error {
+	name = "GuestAccessTokenConfigurationError";
+	constructor(message, code) {
+		super(message);
+		this.code = code;
+	}
+};
+/**
+* Issues an expiring capability for one guest purpose and one restaurant target.
+* Persist only tokenHash/tokenId and revocation metadata; never persist or log token.
+*/
+async function issueGuestAccessToken(options) {
+	validateSecret(options.secret);
+	validateScope({
+		purpose: options.purpose,
+		subjectType: options.subjectType,
+		subjectId: options.subjectId,
+		locationId: options.locationId
 	});
+	if (options.tokenId !== void 0 && !TOKEN_ID_PATTERN.test(options.tokenId)) invalidInput("Guest access token identifier is invalid.");
+	const issuedAt = normalizeNow(options.now);
+	const ttl = parseDuration(options.expiresIn ?? DEFAULT_TTL_SECONDS);
+	const claims = {
+		version: TOKEN_VERSION,
+		tokenId: options.tokenId ?? randomTokenId(),
+		purpose: options.purpose,
+		subjectType: options.subjectType,
+		subjectId: options.subjectId,
+		locationId: options.locationId,
+		issuedAt,
+		expiresAt: issuedAt + ttl
+	};
+	const encodedPayload = encodeBase64url(new TextEncoder().encode(JSON.stringify(claims)));
+	const token = `${encodedPayload}.${encodeBase64url(await sign(encodedPayload, options.secret))}`;
+	return {
+		token,
+		tokenHash: await hashGuestAccessToken(token),
+		claims
+	};
+}
+/**
+* Verifies signature, expiry, and the caller-declared purpose/target scope.
+* A valid result still requires the plugin to check its revocation record by tokenHash.
+*/
+async function verifyGuestAccessToken(options) {
+	if (!options.token) return {
+		valid: false,
+		error: "none"
+	};
+	validateExpectedScope(options.expected);
+	const secrets = normalizeSecrets(options.secrets);
+	const token = options.token;
+	if (token.length > MAX_TOKEN_LENGTH) return {
+		valid: false,
+		error: "malformed"
+	};
+	const parts = token.split(".");
+	if (parts.length !== 2) return {
+		valid: false,
+		error: "malformed"
+	};
+	const encodedPayload = parts[0];
+	const encodedSignature = parts[1];
+	if (!encodedPayload || !encodedSignature) return {
+		valid: false,
+		error: "malformed"
+	};
+	const signature = decodeCanonicalBase64url(encodedSignature);
+	if (!signature || signature.byteLength !== SIGNATURE_BYTES) return {
+		valid: false,
+		error: "malformed"
+	};
+	let signatureValid = false;
+	for (const secret of secrets) if (await verifySignature(encodedPayload, signature, secret)) {
+		signatureValid = true;
+		break;
+	}
+	if (!signatureValid) return {
+		valid: false,
+		error: "invalid"
+	};
+	const claims = decodeClaims(encodedPayload);
+	if (!claims) return {
+		valid: false,
+		error: "malformed"
+	};
+	const now = normalizeNow(options.now);
+	if (claims.issuedAt > now + MAX_CLOCK_SKEW_SECONDS) return {
+		valid: false,
+		error: "invalid"
+	};
+	if (claims.expiresAt <= now) return {
+		valid: false,
+		error: "expired"
+	};
+	if (!matchesExpectedScope(claims, options.expected)) return {
+		valid: false,
+		error: "scope_mismatch"
+	};
+	return {
+		valid: true,
+		claims,
+		tokenHash: await hashGuestAccessToken(token)
+	};
+}
+/** Returns the non-reversible identifier stored for revocation and lookup. */
+async function hashGuestAccessToken(token) {
+	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(`${HASH_DOMAIN}.${token}`));
+	return encodeBase64url(new Uint8Array(digest));
+}
+async function sign(encodedPayload, secret) {
+	const key = await importHmacKey(secret, ["sign"]);
+	const signature = await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(`${SIGNING_DOMAIN}.${encodedPayload}`));
+	return new Uint8Array(signature);
+}
+async function verifySignature(encodedPayload, signature, secret) {
+	const key = await importHmacKey(secret, ["verify"]);
+	return crypto.subtle.verify("HMAC", key, toArrayBuffer$2(signature), new TextEncoder().encode(`${SIGNING_DOMAIN}.${encodedPayload}`));
+}
+async function importHmacKey(secret, usages) {
+	return crypto.subtle.importKey("raw", new TextEncoder().encode(secret), {
+		name: "HMAC",
+		hash: "SHA-256"
+	}, false, usages);
+}
+function decodeClaims(encodedPayload) {
+	const bytes = decodeCanonicalBase64url(encodedPayload);
+	if (!bytes) return null;
+	let value;
+	try {
+		value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+	} catch {
+		return null;
+	}
+	if (!isRecord$1(value) || !hasExactClaimKeys(value)) return null;
+	if (value.version !== TOKEN_VERSION || typeof value.tokenId !== "string" || typeof value.purpose !== "string" || typeof value.subjectType !== "string" || typeof value.subjectId !== "string" || typeof value.locationId !== "string" || typeof value.issuedAt !== "number" || typeof value.expiresAt !== "number") return null;
+	if (!TOKEN_ID_PATTERN.test(value.tokenId) || !PURPOSE_PATTERN.test(value.purpose) || !SUBJECT_TYPE_PATTERN.test(value.subjectType) || !OPAQUE_ID_PATTERN.test(value.subjectId) || !OPAQUE_ID_PATTERN.test(value.locationId) || !Number.isSafeInteger(value.issuedAt) || !Number.isSafeInteger(value.expiresAt) || value.expiresAt <= value.issuedAt || value.expiresAt - value.issuedAt > MAX_TTL_SECONDS) return null;
+	return {
+		version: TOKEN_VERSION,
+		tokenId: value.tokenId,
+		purpose: value.purpose,
+		subjectType: value.subjectType,
+		subjectId: value.subjectId,
+		locationId: value.locationId,
+		issuedAt: value.issuedAt,
+		expiresAt: value.expiresAt
+	};
+}
+function hasExactClaimKeys(value) {
+	const keys = Object.keys(value).toSorted();
+	return keys.length === 8 && keys.join(",") === "expiresAt,issuedAt,locationId,purpose,subjectId,subjectType,tokenId,version";
+}
+function matchesExpectedScope(claims, expected) {
+	return claims.purpose === expected.purpose && claims.subjectType === expected.subjectType && (expected.subjectId === void 0 || claims.subjectId === expected.subjectId) && (expected.locationId === void 0 || claims.locationId === expected.locationId);
+}
+function validateExpectedScope(expected) {
+	validatePurpose(expected.purpose);
+	validateSubjectType(expected.subjectType);
+	if (expected.subjectId !== void 0) validateOpaqueId(expected.subjectId, "subject id");
+	if (expected.locationId !== void 0) validateOpaqueId(expected.locationId, "location id");
+}
+function validateScope(scope) {
+	validatePurpose(scope.purpose);
+	validateSubjectType(scope.subjectType);
+	validateOpaqueId(scope.subjectId, "subject id");
+	validateOpaqueId(scope.locationId, "location id");
+}
+function validatePurpose(value) {
+	if (!PURPOSE_PATTERN.test(value)) invalidInput("Guest access purpose is invalid.");
+}
+function validateSubjectType(value) {
+	if (!SUBJECT_TYPE_PATTERN.test(value)) invalidInput("Guest access subject type is invalid.");
+}
+function validateOpaqueId(value, label) {
+	if (!OPAQUE_ID_PATTERN.test(value)) invalidInput(`Guest access ${label} is invalid.`);
+}
+function parseDuration(value) {
+	let seconds;
+	if (typeof value === "number") seconds = value;
+	else {
+		const match = DURATION_PATTERN.exec(value);
+		if (!match) invalidInput("Guest access expiry duration is invalid.");
+		seconds = Number(match[1]) * ({
+			s: 1,
+			m: 60,
+			h: 3600,
+			d: 1440 * 60,
+			w: 10080 * 60
+		}[match[2]] ?? 0);
+	}
+	if (!Number.isSafeInteger(seconds) || seconds <= 0 || seconds > MAX_TTL_SECONDS) invalidInput("Guest access expiry must be between one second and 366 days.");
+	return seconds;
+}
+function normalizeSecrets(value) {
+	const secrets = typeof value === "string" ? [value] : [...new Set(value)];
+	if (secrets.length === 0 || secrets.length > MAX_VERIFICATION_SECRETS) throw new GuestAccessTokenConfigurationError(`Guest access verification requires 1-${MAX_VERIFICATION_SECRETS} secrets.`, "INVALID_GUEST_TOKEN_SECRET");
+	for (const secret of secrets) validateSecret(secret);
+	return secrets;
+}
+function validateSecret(secret) {
+	const secretBytes = new TextEncoder().encode(secret).byteLength;
+	if (secretBytes < MIN_SECRET_BYTES || secretBytes > MAX_SECRET_BYTES$1) throw new GuestAccessTokenConfigurationError(`Guest access signing secrets must contain ${MIN_SECRET_BYTES}-${MAX_SECRET_BYTES$1} UTF-8 bytes.`, "INVALID_GUEST_TOKEN_SECRET");
+}
+function normalizeNow(value) {
+	const now = value ?? Math.floor(Date.now() / 1e3);
+	if (!Number.isSafeInteger(now) || now < 0) invalidInput("Guest access clock value is invalid.");
+	return now;
+}
+function randomTokenId() {
+	return `gt_${encodeBase64url(crypto.getRandomValues(new Uint8Array(24)))}`;
+}
+function decodeCanonicalBase64url(value) {
+	if (!BASE64URL_PATTERN.test(value)) return null;
+	try {
+		const decoded = decodeBase64url(value);
+		return encodeBase64url(decoded) === value ? decoded : null;
+	} catch {
+		return null;
+	}
+}
+function toArrayBuffer$2(bytes) {
+	const buffer = new ArrayBuffer(bytes.byteLength);
+	new Uint8Array(buffer).set(bytes);
+	return buffer;
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function invalidInput(message) {
+	throw new GuestAccessTokenConfigurationError(message, "INVALID_GUEST_TOKEN_INPUT");
+}
+
+//#endregion
+//#region src/plugins/route-body.ts
+const CONTENT_LENGTH_PATTERN = /^(?:0|[1-9][0-9]*)$/;
+const DEFAULT_PLUGIN_RAW_BODY_LIMIT_BYTES = 1024 * 1024;
+const MAX_PLUGIN_RAW_BODY_LIMIT_BYTES = 10 * 1024 * 1024;
+async function readBoundedPluginRouteBody(request, limit) {
+	const declaredLength = request.headers.get("content-length");
+	if (declaredLength && CONTENT_LENGTH_PATTERN.test(declaredLength) && Number(declaredLength) > limit) return {
+		ok: false,
+		limit
+	};
+	if (!request.body) return {
+		ok: true,
+		bytes: new Uint8Array()
+	};
+	const reader = request.body.getReader();
+	const chunks = [];
+	let total = 0;
+	try {
+		while (true) {
+			const chunk = await reader.read();
+			if (chunk.done) break;
+			if (total + chunk.value.byteLength > limit) {
+				await reader.cancel().catch(() => void 0);
+				return {
+					ok: false,
+					limit
+				};
+			}
+			chunks.push(chunk.value);
+			total += chunk.value.byteLength;
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	const bytes = new Uint8Array(total);
+	let offset = 0;
+	for (const chunk of chunks) {
+		bytes.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return {
+		ok: true,
+		bytes
+	};
 }
 
 //#endregion
 //#region src/plugins/define-plugin.ts
-const SIMPLE_ID = /^[a-z0-9-]+$/;
-const SCOPED_ID = /^@[a-z0-9-]+\/[a-z0-9-]+$/;
-const SEMVER_PATTERN = /^\d+\.\d+\.\d+/;
+/**
+* definePlugin() Helper
+*
+* Creates a properly typed and normalized plugin definition.
+* Supports two formats:
+*
+* 1. **Native format** -- full PluginDefinition with id, version, capabilities, etc.
+*    Returns a ResolvedPlugin.
+*
+* 2. **Standard format** -- just { hooks, routes }. No id/version/capabilities.
+*    Returns the same object (identity function for type inference).
+*    Metadata comes from the descriptor at config time.
+*
+*/
+const MCP_NAME_PATTERN = /^[a-z][a-z0-9_]{2,127}$/;
+const MCP_RISK_FACTORS = new Set([
+	"content",
+	"availability",
+	"time",
+	"money",
+	"allergen",
+	"pii",
+	"batch",
+	"payment",
+	"destructive",
+	"external_side_effect"
+]);
+const STRONG_RISK_FACTORS = new Set([
+	"availability",
+	"time",
+	"money",
+	"allergen",
+	"pii",
+	"batch",
+	"payment",
+	"destructive",
+	"external_side_effect"
+]);
 function definePlugin(definition) {
 	if (!("id" in definition) || !("version" in definition)) {
 		if (!("hooks" in definition) && !("routes" in definition)) throw new Error("Standard plugin format requires at least `hooks` or `routes`. For native format, provide `id` and `version`.");
@@ -848,7 +1246,11 @@ function definePlugin(definition) {
 * Internal: define a native-format plugin with full validation and normalization.
 */
 function defineNativePlugin(definition) {
+	const SIMPLE_ID = /^[a-z0-9-]+$/;
+	const SCOPED_ID = /^@[a-z0-9-]+\/[a-z0-9-]+$/;
+	const SEMVER_PATTERN = /^\d+\.\d+\.\d+/;
 	const { id, version, capabilities = [], allowedHosts = [], hooks = {}, routes = {}, admin = {} } = definition;
+	const mcp = resolveMcp(definition.mcp, id);
 	const storage = definition.storage ?? {};
 	if (!SIMPLE_ID.test(id) && !SCOPED_ID.test(id)) throw new Error(`Invalid plugin id "${id}". Must be lowercase alphanumeric with dashes (e.g., "my-plugin" or "@scope/my-plugin").`);
 	if (!SEMVER_PATTERN.test(version)) throw new Error(`Invalid plugin version "${version}". Must be semver format (e.g., "1.0.0").`);
@@ -870,6 +1272,17 @@ function defineNativePlugin(definition) {
 	if (capabilities.includes("content:write") && !capabilities.includes("content:read")) normalizedCapabilities.push("content:read");
 	if (capabilities.includes("media:write") && !capabilities.includes("media:read")) normalizedCapabilities.push("media:read");
 	if (capabilities.includes("network:request:unrestricted") && !capabilities.includes("network:request")) normalizedCapabilities.push("network:request");
+	for (const [routeName, route] of Object.entries(routes)) {
+		if (route.body !== void 0 && route.body !== "json" && route.body !== "raw") throw new Error(`Plugin "${id}" route "${routeName}" has an invalid body mode.`);
+		if (route.body === "raw" && route.input) throw new Error(`Plugin "${id}" raw-body route "${routeName}" cannot declare an input schema.`);
+		if (route.body !== "raw" && route.maxBodyBytes !== void 0) throw new Error(`Plugin "${id}" JSON route "${routeName}" cannot declare a raw body-size limit.`);
+		if (route.body === "raw" && route.maxBodyBytes !== void 0 && (!Number.isSafeInteger(route.maxBodyBytes) || route.maxBodyBytes < 1 || route.maxBodyBytes > MAX_PLUGIN_RAW_BODY_LIMIT_BYTES)) throw new Error(`Plugin "${id}" raw-body route "${routeName}" has an invalid body-size limit.`);
+		if (route.public === true && route.authorization) throw new Error(`Plugin "${id}" public route "${routeName}" cannot declare private authorization.`);
+		if (route.authorization && (route.authorization.anyOfTokenScopes.length === 0 || route.authorization.anyOfTokenScopes.some((scope) => scope.trim().length === 0))) throw new Error(`Plugin "${id}" route "${routeName}" requires at least one valid token scope.`);
+		const restaurantPermission = route.authorization?.restaurantPermission;
+		if (restaurantPermission !== void 0 && (restaurantPermission.trim().length === 0 || typeof route.resolveTarget !== "function" || typeof route.authorizeTarget !== "function")) throw new Error(`Plugin "${id}" route "${routeName}" requires a restaurant target resolver and authorizer.`);
+		if (!restaurantPermission && (route.resolveTarget || route.authorizeTarget)) throw new Error(`Plugin "${id}" route "${routeName}" cannot declare target authorization without a restaurant permission.`);
+	}
 	return {
 		id,
 		version,
@@ -878,9 +1291,85 @@ function defineNativePlugin(definition) {
 		storage,
 		hooks: resolveHooks(hooks, id),
 		routes,
+		mcp,
 		admin
 	};
 }
+function resolveMcp(mcp, pluginId) {
+	const tools = [...mcp?.tools ?? []];
+	const resources = [...mcp?.resources ?? []];
+	const namespace = `${pluginId.split("/").at(-1).replaceAll("-", "_")}_`;
+	const toolNames = /* @__PURE__ */ new Set();
+	const resourceNames = /* @__PURE__ */ new Set();
+	const resourceUris = /* @__PURE__ */ new Set();
+	const authorizeTarget = mcp?.authorizeTarget;
+	for (const tool of tools) {
+		validateMcpName(tool.name, "tool", pluginId, namespace, MCP_NAME_PATTERN);
+		if (toolNames.has(tool.name)) throw new Error(`Duplicate MCP tool "${tool.name}" in plugin "${pluginId}".`);
+		toolNames.add(tool.name);
+		validateMcpText(tool.title, "title", tool.name, pluginId);
+		validateMcpText(tool.description, "description", tool.name, pluginId);
+		validateMcpAuthorization(tool.authorization, tool.name, pluginId);
+		validateZodSchema(tool.inputSchema, "inputSchema", tool.name, pluginId);
+		if (tool.outputSchema) validateZodSchema(tool.outputSchema, "outputSchema", tool.name, pluginId);
+		if (typeof tool.handler !== "function") throw new Error(`MCP tool "${tool.name}" in plugin "${pluginId}" requires a handler.`);
+		if (tool.authorization.restaurantPermission && !tool.resolveTarget) throw new Error(`MCP tool "${tool.name}" in plugin "${pluginId}" declares a restaurant permission but no resolveTarget function.`);
+		if (tool.authorization.restaurantPermission && typeof authorizeTarget !== "function") throw new Error(`MCP tool "${tool.name}" in plugin "${pluginId}" requires an MCP target authorizer.`);
+		if (tool.kind === "command") {
+			if (typeof tool.preview !== "function") throw new Error(`MCP command "${tool.name}" in plugin "${pluginId}" requires preview.`);
+			if (typeof tool.actionFingerprint !== "function" || tool.idempotency?.required !== true) throw new Error(`MCP command "${tool.name}" in plugin "${pluginId}" requires actionFingerprint and required idempotency.`);
+			if ((tool.pii.input === "sensitive" || tool.pii.output === "sensitive") && typeof tool.redactPreview !== "function") throw new Error(`Sensitive MCP command "${tool.name}" in plugin "${pluginId}" requires redactPreview.`);
+			validateMcpText(tool.risk.reason, "risk reason", tool.name, pluginId);
+			validateCommandRisk(tool, pluginId);
+		}
+	}
+	for (const resource of resources) {
+		validateMcpName(resource.name, "resource", pluginId, namespace, MCP_NAME_PATTERN);
+		if (resourceNames.has(resource.name)) throw new Error(`Duplicate MCP resource "${resource.name}" in plugin "${pluginId}".`);
+		resourceNames.add(resource.name);
+		validateMcpText(resource.title, "title", resource.name, pluginId);
+		validateMcpText(resource.description, "description", resource.name, pluginId);
+		validateMcpAuthorization(resource.authorization, resource.name, pluginId);
+		if (resource.authorization.restaurantPermission && !resource.target) throw new Error(`MCP resource "${resource.name}" in plugin "${pluginId}" declares a restaurant permission but no target.`);
+		if (resource.authorization.restaurantPermission && typeof authorizeTarget !== "function") throw new Error(`MCP resource "${resource.name}" in plugin "${pluginId}" requires an MCP target authorizer.`);
+		try {
+			if (!new URL(resource.uri).protocol) throw new Error("Missing URI protocol");
+		} catch {
+			throw new Error(`Invalid MCP resource URI "${resource.uri}" in plugin "${pluginId}".`);
+		}
+		if (resourceUris.has(resource.uri)) throw new Error(`Duplicate MCP resource URI "${resource.uri}" in plugin "${pluginId}".`);
+		resourceUris.add(resource.uri);
+		if (typeof resource.handler !== "function") throw new Error(`MCP resource "${resource.name}" in plugin "${pluginId}" requires a handler.`);
+	}
+	return authorizeTarget ? {
+		tools,
+		resources,
+		authorizeTarget
+	} : {
+		tools,
+		resources
+	};
+}
+function validateCommandRisk(tool, pluginId) {
+	if (tool.risk.mandatory !== true) throw new Error(`MCP command "${tool.name}" in plugin "${pluginId}" must declare a mandatory risk floor.`);
+	if (!Array.isArray(tool.risk.factors) || tool.risk.factors.length === 0 || tool.risk.factors.some((factor) => !MCP_RISK_FACTORS.has(factor))) throw new Error(`MCP command "${tool.name}" in plugin "${pluginId}" requires valid risk factors.`);
+	if (tool.risk.factors.some((factor) => STRONG_RISK_FACTORS.has(factor)) && tool.risk.level !== "strong_confirmation") throw new Error(`MCP command "${tool.name}" in plugin "${pluginId}" requires strong confirmation for its declared risk factors.`);
+	if (tool.risk.level === "strong_confirmation" && tool.audit !== "strict") throw new Error(`Strong-confirmation MCP command "${tool.name}" in plugin "${pluginId}" requires strict audit.`);
+	if ((tool.pii.input === "sensitive" || tool.pii.output === "sensitive" || tool.reversibility !== "reversible") && (tool.risk.level !== "strong_confirmation" || tool.audit !== "strict")) throw new Error(`Sensitive or externally compensating MCP command "${tool.name}" in plugin "${pluginId}" requires strong confirmation and strict audit.`);
+}
+function validateMcpName(name, kind, pluginId, namespace, pattern) {
+	if (!pattern.test(name) || !name.startsWith(namespace)) throw new Error(`Invalid MCP ${kind} name "${name}" in plugin "${pluginId}". Names must match ${pattern} and start with "${namespace}".`);
+}
+function validateMcpText(value, field, name, pluginId) {
+	if (typeof value !== "string" || value.trim().length === 0) throw new Error(`MCP contribution "${name}" in plugin "${pluginId}" requires ${field}.`);
+}
+function validateMcpAuthorization(authorization, name, pluginId) {
+	if (!authorization || !Object.hasOwn(Permissions, authorization.permission)) throw new Error(`MCP contribution "${name}" in plugin "${pluginId}" declares an invalid permission.`);
+	if (!Array.isArray(authorization.anyOfTokenScopes) || authorization.anyOfTokenScopes.length === 0 || authorization.anyOfTokenScopes.some((scope) => typeof scope !== "string" || scope.trim().length === 0)) throw new Error(`MCP contribution "${name}" in plugin "${pluginId}" requires at least one token scope.`);
+}
+function validateZodSchema(schema, field, name, pluginId) {
+	if (typeof schema !== "object" || schema === null || !("safeParse" in schema) || typeof schema.safeParse !== "function") throw new Error(`MCP tool "${name}" in plugin "${pluginId}" requires a Zod ${field}.`);
+}
 /**
 * Resolve hooks to normalized format with defaults.
 *
@@ -1023,6 +1512,9 @@ var HookPipeline = class HookPipeline {
 			this.registerPluginHook(plugin, "content:afterDelete");
 			this.registerPluginHook(plugin, "content:afterPublish");
 			this.registerPluginHook(plugin, "content:afterUnpublish");
+			this.registerPluginHook(plugin, "content:afterRestore");
+			this.registerPluginHook(plugin, "content:afterSchedule");
+			this.registerPluginHook(plugin, "content:afterUnschedule");
 			this.registerPluginHook(plugin, "media:beforeUpload");
 			this.registerPluginHook(plugin, "media:afterUpload");
 			this.registerPluginHook(plugin, "cron");
@@ -1055,6 +1547,9 @@ var HookPipeline = class HookPipeline {
 		["content:afterDelete", "content:read"],
 		["content:afterPublish", "content:read"],
 		["content:afterUnpublish", "content:read"],
+		["content:afterRestore", "content:read"],
+		["content:afterSchedule", "content:read"],
+		["content:afterUnschedule", "content:read"],
 		["media:beforeUpload", "media:write"],
 		["media:afterUpload", "media:read"],
 		["comment:beforeCreate", "users:read"],
@@ -1348,40 +1843,34 @@ var HookPipeline = class HookPipeline {
 	* Run content:afterPublish hooks (fire-and-forget).
 	*/
 	async runContentAfterPublish(content, collection) {
-		const hooks = this.getTypedHooks("content:afterPublish");
-		const results = [];
-		for (const hook of hooks) {
-			const { handler } = hook;
-			const event = {
-				content,
-				collection
-			};
-			const ctx = this.getContext(hook.pluginId);
-			const start = Date.now();
-			try {
-				await this.executeWithTimeout(() => handler(event, ctx), hook.timeout);
-				results.push({
-					success: true,
-					pluginId: hook.pluginId,
-					duration: Date.now() - start
-				});
-			} catch (error) {
-				results.push({
-					success: false,
-					error: error instanceof Error ? error : new Error(String(error)),
-					pluginId: hook.pluginId,
-					duration: Date.now() - start
-				});
-				if (hook.errorPolicy === "abort") throw error;
-			}
-		}
-		return results;
+		return this.runContentStateChangeHook("content:afterPublish", content, collection);
 	}
 	/**
 	* Run content:afterUnpublish hooks (fire-and-forget).
 	*/
 	async runContentAfterUnpublish(content, collection) {
-		const hooks = this.getTypedHooks("content:afterUnpublish");
+		return this.runContentStateChangeHook("content:afterUnpublish", content, collection);
+	}
+	/**
+	* Run content:afterRestore hooks (fire-and-forget).
+	*/
+	async runContentAfterRestore(content, collection) {
+		return this.runContentStateChangeHook("content:afterRestore", content, collection);
+	}
+	/**
+	* Run content:afterSchedule hooks (fire-and-forget).
+	*/
+	async runContentAfterSchedule(content, collection) {
+		return this.runContentStateChangeHook("content:afterSchedule", content, collection);
+	}
+	/**
+	* Run content:afterUnschedule hooks (fire-and-forget).
+	*/
+	async runContentAfterUnschedule(content, collection) {
+		return this.runContentStateChangeHook("content:afterUnschedule", content, collection);
+	}
+	async runContentStateChangeHook(name, content, collection) {
+		const hooks = this.getTypedHooks(name);
 		const results = [];
 		for (const hook of hooks) {
 			const { handler } = hook;
@@ -2022,6 +2511,23 @@ var EmailPipeline = class {
 * - Error handling
 *
 */
+const CONSUMED_BODY_METHODS = new Set([
+	"json",
+	"text",
+	"arrayBuffer",
+	"blob",
+	"formData",
+	"bytes"
+]);
+function guardConsumedRequestBody(request, bodyField) {
+	return new Proxy(request, { get(target, prop) {
+		if (typeof prop === "string" && CONSUMED_BODY_METHODS.has(prop)) return () => {
+			throw new Error(`[dineway] ctx.request.${prop}() is not available inside a plugin route handler: Dineway has already consumed the request body and exposes it as ${bodyField}. Read ${bodyField} instead of ctx.request.${prop}().`);
+		};
+		const value = Reflect.get(target, prop, target);
+		return typeof value === "function" ? value.bind(target) : value;
+	} });
+}
 /**
 * Route handler for a plugin
 */
@@ -2047,8 +2553,20 @@ var PluginRouteHandler = class {
 			},
 			status: 404
 		};
+		const requestMethod = options.request.method.toUpperCase();
+		const allowedMethods = route.methods;
+		if (allowedMethods && !allowedMethods.includes(requestMethod)) return {
+			success: false,
+			error: {
+				code: "METHOD_NOT_ALLOWED",
+				message: `Method ${requestMethod} is not allowed for this plugin route`
+			},
+			status: 405
+		};
+		const bodyMode = route.body ?? "json";
 		let validatedInput;
-		if (route.input) {
+		if (bodyMode === "raw") validatedInput = void 0;
+		else if (route.input) {
 			const parseResult = route.input.safeParse(options.body);
 			if (!parseResult.success) return {
 				success: false,
@@ -2061,11 +2579,72 @@ var PluginRouteHandler = class {
 			};
 			validatedInput = parseResult.data;
 		} else validatedInput = options.body;
+		const baseContext = this.contextFactory.createContext(this.plugin);
+		const actor = options.actor ?? null;
+		const rawBody = bodyMode === "raw" ? options.rawBody?.slice() ?? new Uint8Array() : null;
+		const request = guardConsumedRequestBody(options.request, bodyMode === "raw" ? "ctx.rawBody" : "ctx.input");
+		const requestMeta = extractRequestMeta(options.request, this.trustedProxyHeaders);
+		let target = null;
+		if (route.authorization && !actor) return {
+			success: false,
+			error: {
+				code: "UNAUTHORIZED",
+				message: "Authentication required"
+			},
+			status: 401
+		};
+		const restaurantPermission = route.authorization?.restaurantPermission;
+		if (restaurantPermission) {
+			if (!actor) return {
+				success: false,
+				error: {
+					code: "UNAUTHORIZED",
+					message: "Authentication required"
+				},
+				status: 401
+			};
+			try {
+				const resolvedTarget = await route.resolveTarget(validatedInput, {
+					...baseContext,
+					actor,
+					request,
+					requestMeta
+				});
+				validateTarget(resolvedTarget);
+				target = Object.freeze({ ...resolvedTarget });
+				const authorizationContext = {
+					...baseContext,
+					input: validatedInput,
+					rawBody,
+					actor,
+					target,
+					request,
+					requestMeta
+				};
+				await route.authorizeTarget({
+					restaurantPermission,
+					target,
+					context: authorizationContext
+				});
+			} catch {
+				return {
+					success: false,
+					error: {
+						code: "FORBIDDEN",
+						message: "Restaurant target authorization denied for this operation"
+					},
+					status: 403
+				};
+			}
+		}
 		const routeContext = {
-			...this.contextFactory.createContext(this.plugin),
+			...baseContext,
 			input: validatedInput,
-			request: options.request,
-			requestMeta: extractRequestMeta(options.request, this.trustedProxyHeaders)
+			rawBody,
+			actor,
+			target,
+			request,
+			requestMeta
 		};
 		try {
 			return {
@@ -2113,9 +2692,21 @@ var PluginRouteHandler = class {
 	getRouteMeta(name) {
 		const route = this.plugin.routes[name];
 		if (!route) return null;
-		return { public: route.public === true };
+		return {
+			public: route.public === true,
+			body: route.body ?? "json",
+			...route.body === "raw" ? { maxBodyBytes: route.maxBodyBytes ?? DEFAULT_PLUGIN_RAW_BODY_LIMIT_BYTES } : {},
+			authorization: route.authorization
+		};
 	}
 };
+function validateTarget(target) {
+	if (![
+		"plugin",
+		"location",
+		"entity"
+	].includes(target.type) || typeof target.id !== "string" || target.id.trim().length === 0 || typeof target.scope !== "string" || target.scope.trim().length === 0 || target.locationId !== void 0 && (typeof target.locationId !== "string" || target.locationId.trim().length === 0)) throw new Error("Invalid plugin route target");
+}
 /**
 * Error class for plugin routes
 * Allows plugins to return structured errors with specific HTTP status codes
@@ -2224,6 +2815,164 @@ var PluginRouteRegistry = class {
 	}
 };
 
+//#endregion
+//#region src/plugins/secrets.ts
+const ENCRYPTION_VERSION = 1;
+const AES_GCM_NONCE_BYTES = 12;
+const MAX_SECRET_BYTES = 65536;
+/**
+* Encrypted storage for trusted plugin credentials.
+*
+* Management surfaces must use set/status/list/delete and never echo the value
+* passed to set. resolveForRuntime is reserved for trusted server-side provider
+* calls and must not be exposed through plugin routes, MCP, logs, or audit data.
+*/
+var PluginSecretStore = class {
+	repository;
+	keysPromise;
+	constructor(db, options = {}) {
+		this.repository = new PluginSecretRepository(db);
+		this.keysPromise = options.keys ? Promise.resolve(options.keys) : parseEncryptionKeys(readEncryptionKey(options.env));
+	}
+	async set(pluginId, name, value) {
+		validateSecretIdentity(pluginId, name);
+		validateSecretValue(value);
+		const primaryKey = (await this.requireKeys())[0];
+		if (!primaryKey) throw encryptionKeyRequired();
+		const encrypted = await encryptSecret(primaryKey, pluginId, name, value);
+		return toStatus(await this.repository.put({
+			pluginId,
+			name,
+			encryptionVersion: ENCRYPTION_VERSION,
+			keyId: primaryKey.kid,
+			nonce: encrypted.nonce,
+			ciphertext: encrypted.ciphertext,
+			fingerprint: await fingerprintSecret(primaryKey, value)
+		}));
+	}
+	async status(pluginId, name) {
+		validateSecretIdentity(pluginId, name);
+		const stored = await this.repository.find(pluginId, name);
+		return stored ? toStatus(stored) : null;
+	}
+	async list(pluginId) {
+		validatePluginIdentifier(pluginId, "plugin id");
+		return (await this.repository.list(pluginId)).map(toStatus);
+	}
+	async delete(pluginId, name) {
+		validateSecretIdentity(pluginId, name);
+		return this.repository.delete(pluginId, name);
+	}
+	async resolveForRuntime(pluginId, name) {
+		validateSecretIdentity(pluginId, name);
+		const stored = await this.repository.find(pluginId, name);
+		if (!stored) return null;
+		if (stored.encryptionVersion !== ENCRYPTION_VERSION) throw new DinewaySecretsError("The stored plugin secret uses an unsupported encryption version.", "PLUGIN_SECRET_VERSION_UNSUPPORTED");
+		const keys = await this.requireKeys();
+		const decryptionKey = keys.find((key) => key.kid === stored.keyId);
+		if (!decryptionKey) throw new DinewaySecretsError("The stored plugin secret cannot be decrypted by the configured key ring.", "PLUGIN_SECRET_KEY_UNAVAILABLE");
+		let value;
+		try {
+			value = await decryptSecret(decryptionKey, stored);
+		} catch {
+			throw new DinewaySecretsError("The stored plugin secret failed authenticated decryption.", "PLUGIN_SECRET_DECRYPT_FAILED");
+		}
+		const primaryKey = keys[0];
+		if (primaryKey && primaryKey.kid !== stored.keyId) {
+			const encrypted = await encryptSecret(primaryKey, pluginId, name, value);
+			await this.repository.put({
+				pluginId,
+				name,
+				encryptionVersion: ENCRYPTION_VERSION,
+				keyId: primaryKey.kid,
+				nonce: encrypted.nonce,
+				ciphertext: encrypted.ciphertext,
+				fingerprint: await fingerprintSecret(primaryKey, value)
+			});
+		}
+		return value;
+	}
+	async requireKeys() {
+		const keys = await this.keysPromise;
+		if (!keys || keys.length === 0) throw encryptionKeyRequired();
+		return keys;
+	}
+};
+async function encryptSecret(key, pluginId, name, value) {
+	const nonce = crypto.getRandomValues(new Uint8Array(AES_GCM_NONCE_BYTES));
+	const cryptoKey = await importAesKey(key, ["encrypt"]);
+	const ciphertext = await crypto.subtle.encrypt({
+		name: "AES-GCM",
+		iv: toArrayBuffer$1(nonce),
+		additionalData: aad(pluginId, name, ENCRYPTION_VERSION)
+	}, cryptoKey, new TextEncoder().encode(value));
+	return {
+		nonce: encodeBase64url(nonce),
+		ciphertext: encodeBase64url(new Uint8Array(ciphertext))
+	};
+}
+async function decryptSecret(key, stored) {
+	const cryptoKey = await importAesKey(key, ["decrypt"]);
+	const plaintext = await crypto.subtle.decrypt({
+		name: "AES-GCM",
+		iv: toArrayBuffer$1(decodeBase64url(stored.nonce)),
+		additionalData: aad(stored.pluginId, stored.name, stored.encryptionVersion)
+	}, cryptoKey, toArrayBuffer$1(decodeBase64url(stored.ciphertext)));
+	return new TextDecoder("utf-8", { fatal: true }).decode(plaintext);
+}
+async function importAesKey(key, usages) {
+	return crypto.subtle.importKey("raw", toArrayBuffer$1(key.key), { name: "AES-GCM" }, false, usages);
+}
+function aad(pluginId, name, encryptionVersion) {
+	return toArrayBuffer$1(new TextEncoder().encode(JSON.stringify([
+		"dineway-plugin-secret",
+		encryptionVersion,
+		pluginId,
+		name
+	])));
+}
+async function fingerprintSecret(key, value) {
+	const hmacKey = await crypto.subtle.importKey("raw", toArrayBuffer$1(key.key), {
+		name: "HMAC",
+		hash: "SHA-256"
+	}, false, ["sign"]);
+	const digest = await crypto.subtle.sign("HMAC", hmacKey, new TextEncoder().encode(`dineway-plugin-secret-fingerprint:v1:${value}`));
+	return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("").slice(0, 12);
+}
+function toArrayBuffer$1(bytes) {
+	const buffer = new ArrayBuffer(bytes.byteLength);
+	new Uint8Array(buffer).set(bytes);
+	return buffer;
+}
+function validateSecretIdentity(pluginId, name) {
+	validatePluginIdentifier(pluginId, "plugin id");
+	validateIdentifier(name, "plugin secret name");
+}
+function validateSecretValue(value) {
+	const byteLength = new TextEncoder().encode(value).byteLength;
+	if (byteLength === 0 || byteLength > MAX_SECRET_BYTES) throw new DinewaySecretsError(`Plugin secret values must contain between 1 and ${MAX_SECRET_BYTES} UTF-8 bytes.`, "INVALID_PLUGIN_SECRET_VALUE");
+}
+function encryptionKeyRequired() {
+	return new DinewaySecretsError("DINEWAY_ENCRYPTION_KEY is required before plugin secrets can be written or decrypted.", "ENCRYPTION_KEY_REQUIRED");
+}
+function readEncryptionKey(env) {
+	if (env) return env.DINEWAY_ENCRYPTION_KEY;
+	const meta = import.meta.env ?? {};
+	const proc = typeof process !== "undefined" && process.env ? process.env : {};
+	return meta.DINEWAY_ENCRYPTION_KEY ?? proc.DINEWAY_ENCRYPTION_KEY;
+}
+function toStatus(stored) {
+	return {
+		pluginId: stored.pluginId,
+		name: stored.name,
+		present: true,
+		fingerprint: stored.fingerprint,
+		keyId: stored.keyId,
+		createdAt: stored.createdAt,
+		updatedAt: stored.updatedAt
+	};
+}
+
 //#endregion
 //#region src/plugins/manager.ts
 /** Options table key prefix for exclusive hook DB reads via PluginManager */
@@ -2393,6 +3142,27 @@ var PluginManager = class {
 		return this.hookPipeline.runContentAfterUnpublish(content, collection);
 	}
 	/**
+	* Run content:afterRestore hooks across all active plugins
+	*/
+	async runContentAfterRestore(content, collection) {
+		this.ensureInitialized();
+		return this.hookPipeline.runContentAfterRestore(content, collection);
+	}
+	/**
+	* Run content:afterSchedule hooks across all active plugins
+	*/
+	async runContentAfterSchedule(content, collection) {
+		this.ensureInitialized();
+		return this.hookPipeline.runContentAfterSchedule(content, collection);
+	}
+	/**
+	* Run content:afterUnschedule hooks across all active plugins
+	*/
+	async runContentAfterUnschedule(content, collection) {
+		this.ensureInitialized();
+		return this.hookPipeline.runContentAfterUnschedule(content, collection);
+	}
+	/**
 	* Run media:beforeUpload hooks across all active plugins
 	*/
 	async runMediaBeforeUpload(file) {
@@ -2859,7 +3629,13 @@ export async function invokeRoute(routeName, input, serializedRequest) {
 		throw new Error(\`Route \${routeName} handler is not a function\`);
 	}
 	return handler(
-		{ input, request: serializedRequest, requestMeta: serializedRequest.meta },
+		{
+			input,
+			actor: serializedRequest.actor ?? null,
+			target: null,
+			request: serializedRequest,
+			requestMeta: serializedRequest.meta,
+		},
 		ctx,
 	);
 }
@@ -3041,6 +3817,10 @@ function createResolvedPluginFromManifest(manifest) {
 		storage: manifest.storage,
 		hooks: {},
 		routes: {},
+		mcp: {
+			tools: [],
+			resources: []
+		},
 		admin: manifest.admin
 	};
 }
@@ -3455,16 +4235,4 @@ function createNodeSandboxRunner(options) {
 }
 
 //#endregion
-//#region src/plugins/types.ts
-/**
-* Check if a value is a StandardPluginDefinition (has hooks/routes but no id/version).
-*/
-function isStandardPluginDefinition(value) {
-	if (typeof value !== "object" || value === null) return false;
-	const hasPluginShape = "hooks" in value || "routes" in value;
-	const hasNativeShape = "id" in value && "version" in value;
-	return hasPluginShape && !hasNativeShape;
-}
-
-//#endregion
-export { RelationRepository as S, portableTextToProsemirror as _, SandboxNotAvailableError as a, reference as b, createPluginManager as c, EmailPipeline as d, HookPipeline as f, after as g, definePlugin as h, NoopSandboxRunner as i, PluginRouteError as l, resolveExclusiveHooks as m, NodeSandboxRunner as n, createNoopSandboxRunner as o, createHookPipeline as p, createNodeSandboxRunner as r, PluginManager as s, isStandardPluginDefinition as t, PluginRouteRegistry as u, prosemirrorToPortableText as v, image as x, portableText as y };
+export { prosemirrorToPortableText as C, RelationRepository as D, image as E, portableTextToProsemirror as S, reference as T, readBoundedPluginRouteBody as _, createNoopSandboxRunner as a, issueGuestAccessToken as b, PluginSecretStore as c, EmailPipeline as d, HookPipeline as f, DEFAULT_PLUGIN_RAW_BODY_LIMIT_BYTES as g, definePlugin as h, SandboxNotAvailableError as i, PluginRouteError as l, resolveExclusiveHooks as m, createNodeSandboxRunner as n, PluginManager as o, createHookPipeline as p, NoopSandboxRunner as r, createPluginManager as s, NodeSandboxRunner as t, PluginRouteRegistry as u, GuestAccessTokenConfigurationError as v, portableText as w, verifyGuestAccessToken as x, hashGuestAccessToken as y };