dineway 0.1.49 → 0.2.0

package/dist/{taxonomy-B169Nm6B.mjs → taxonomy-Dvsw6BOs.mjs}

@@ -1,4 +1,5 @@
-import { a as __exportAll } from "./runner-DzIpHGND.mjs";
+import { a as __exportAll } from "./runner-DB7CRfOF.mjs";
+import { d as invalidateTaxonomyObjectCache } from "./object-cache-D51qOseS.mjs";
 import { ulid } from "ulidx";
 
 //#region src/database/repositories/taxonomy.ts
@@ -25,7 +26,8 @@ var TaxonomyRepository = class {
 	*/
 	async create(input) {
 		const id = ulid();
-		const parentId = input.parentId === void 0 || input.parentId === "" ? null : input.parentId;
+		const parentInput = input.parentId === void 0 || input.parentId === "" ? null : input.parentId;
+		const parentId = parentInput ? await this.resolveParentRef(parentInput) : null;
 		let translationGroup = id;
 		if (input.translationOf) {
 			const source = await this.findById(input.translationOf);
@@ -41,6 +43,7 @@ var TaxonomyRepository = class {
 			...input.locale !== void 0 ? { locale: input.locale } : {},
 			translation_group: translationGroup
 		}).execute();
+		invalidateTaxonomyObjectCache();
 		const taxonomy = await this.findById(id);
 		if (!taxonomy) throw new Error("Failed to create taxonomy");
 		return taxonomy;
@@ -74,8 +77,18 @@ var TaxonomyRepository = class {
 		else query = query.where("parent_id", "=", options.parentId);
 		return (await query.execute()).map((row) => this.rowToTaxonomy(row));
 	}
-	async findChildren(parentId) {
-		return (await this.db.selectFrom("taxonomies").selectAll().where("parent_id", "=", parentId).orderBy("label", "asc").orderBy("id", "asc").execute()).map((row) => this.rowToTaxonomy(row));
+	/**
+	* Children of a term. Accepts a term id OR a translation_group and resolves
+	* to the group, since `parent_id` stores the parent's translation_group.
+	* Pass `locale` to scope to one locale's tree; omit it to find children in
+	* every locale, which is used to block deletes that would orphan a subtree.
+	*/
+	async findChildren(parentIdOrGroup, locale) {
+		const group = await this.resolveTranslationGroup(parentIdOrGroup);
+		if (!group) return [];
+		let query = this.db.selectFrom("taxonomies").selectAll().where("parent_id", "=", group).orderBy("label", "asc").orderBy("id", "asc");
+		if (locale !== void 0) query = query.where("locale", "=", locale);
+		return (await query.execute()).map((row) => this.rowToTaxonomy(row));
 	}
 	/**
 	* Every translation sibling of a term (including itself), identified by
@@ -89,9 +102,12 @@ var TaxonomyRepository = class {
 		const updates = {};
 		if (input.slug !== void 0) updates.slug = input.slug;
 		if (input.label !== void 0) updates.label = input.label;
-		if (input.parentId !== void 0) updates.parent_id = input.parentId === "" ? null : input.parentId;
+		if (input.parentId !== void 0) updates.parent_id = input.parentId === "" || input.parentId === null ? null : await this.resolveParentRef(input.parentId);
 		if (input.data !== void 0) updates.data = JSON.stringify(input.data);
-		if (Object.keys(updates).length > 0) await this.db.updateTable("taxonomies").set(updates).where("id", "=", id).execute();
+		if (Object.keys(updates).length > 0) {
+			await this.db.updateTable("taxonomies").set(updates).where("id", "=", id).execute();
+			invalidateTaxonomyObjectCache();
+		}
 		return this.findById(id);
 	}
 	async delete(id) {
@@ -100,7 +116,9 @@ var TaxonomyRepository = class {
 		if (term.translationGroup) {
 			if ((await this.db.selectFrom("taxonomies").select("id").where("translation_group", "=", term.translationGroup).where("id", "!=", id).execute()).length === 0) await this.db.deleteFrom("content_taxonomies").where("taxonomy_id", "=", term.translationGroup).execute();
 		}
-		return ((await this.db.deleteFrom("taxonomies").where("id", "=", id).executeTakeFirst()).numDeletedRows ?? 0n) > 0n;
+		const deleted = ((await this.db.deleteFrom("taxonomies").where("id", "=", id).executeTakeFirst()).numDeletedRows ?? 0n) > 0n;
+		if (deleted) invalidateTaxonomyObjectCache();
+		return deleted;
 	}
 	async attachToEntry(collection, entryId, taxonomyId) {
 		const group = await this.resolveTranslationGroup(taxonomyId);
@@ -111,11 +129,13 @@ var TaxonomyRepository = class {
 			taxonomy_id: group
 		};
 		await this.db.insertInto("content_taxonomies").values(row).onConflict((oc) => oc.doNothing()).execute();
+		invalidateTaxonomyObjectCache();
 	}
 	async detachFromEntry(collection, entryId, taxonomyId) {
 		const group = await this.resolveTranslationGroup(taxonomyId);
 		if (!group) return;
 		await this.db.deleteFrom("content_taxonomies").where("collection", "=", collection).where("entry_id", "=", entryId).where("taxonomy_id", "=", group).execute();
+		invalidateTaxonomyObjectCache();
 	}
 	/**
 	* Taxonomy terms assigned to a content entry, resolved into a specific locale.
@@ -149,10 +169,13 @@ var TaxonomyRepository = class {
 			entry_id: entryId,
 			taxonomy_id
 		}))).onConflict((oc) => oc.doNothing()).execute();
+		if (toRemove.length > 0 || toAdd.length > 0) invalidateTaxonomyObjectCache();
 	}
 	async clearEntryTerms(collection, entryId) {
 		const result = await this.db.deleteFrom("content_taxonomies").where("collection", "=", collection).where("entry_id", "=", entryId).executeTakeFirst();
-		return Number(result.numDeletedRows ?? 0);
+		const removed = Number(result.numDeletedRows ?? 0);
+		if (removed > 0) invalidateTaxonomyObjectCache();
+		return removed;
 	}
 	/**
 	* Copy every term assignment from one content entry to another. Used when
@@ -167,6 +190,7 @@ var TaxonomyRepository = class {
 			entry_id: targetEntryId,
 			taxonomy_id: r.taxonomy_id
 		}))).onConflict((oc) => oc.doNothing()).execute();
+		invalidateTaxonomyObjectCache();
 	}
 	/**
 	* Count content entries that use any translation of this term. Accepts
@@ -178,6 +202,17 @@ var TaxonomyRepository = class {
 		const result = await this.db.selectFrom("content_taxonomies").select((eb) => eb.fn.count("entry_id").as("count")).where("taxonomy_id", "=", group).executeTakeFirst();
 		return Number(result?.count ?? 0);
 	}
+	/**
+	* Resolve a parent reference to the value stored in `parent_id`: the parent's
+	* translation_group. A translation_group normally equals its anchor row's id,
+	* which satisfies the self-FK on parent_id. If the anchor row is missing,
+	* fall back to the input so we never write a dangling FK value.
+	*/
+	async resolveParentRef(idOrGroup) {
+		const group = await this.resolveTranslationGroup(idOrGroup);
+		if (!group) return idOrGroup;
+		return await this.db.selectFrom("taxonomies").select("id").where("id", "=", group).executeTakeFirst() ? group : idOrGroup;
+	}
 	async resolveTranslationGroup(idOrGroup) {
 		return (await this.db.selectFrom("taxonomies").select(["translation_group"]).where((eb) => eb.or([eb("id", "=", idOrGroup), eb("translation_group", "=", idOrGroup)])).executeTakeFirst())?.translation_group ?? null;
 	}
@@ -191,7 +226,7 @@ var TaxonomyRepository = class {
 	*/
 	async countEntriesForTerms(translationGroups) {
 		if (translationGroups.length === 0) return /* @__PURE__ */ new Map();
-		const { chunks, SQL_BATCH_SIZE } = await import("./chunks-CuUt7K50.mjs").then((n) => n.r);
+		const { chunks, SQL_BATCH_SIZE } = await import("./chunks-CxBt-GxR.mjs").then((n) => n.r);
 		const counts = /* @__PURE__ */ new Map();
 		for (const chunk of chunks(translationGroups, SQL_BATCH_SIZE)) {
 			const rows = await this.db.selectFrom("content_taxonomies").select(["taxonomy_id", (eb) => eb.fn.count("entry_id").as("count")]).where("taxonomy_id", "in", chunk).groupBy("taxonomy_id").execute();

package/dist/transport-BNmCqLu7.mjs

@@ -0,0 +1,134 @@
+//#region src/client/transport.ts
+/**
+* Transport layer for the Dineway client.
+*
+* Implements a composable interceptor pipeline that modifies requests
+* and responses. The client calls `transport.fetch(request)` — everything
+* else (auth, CSRF, retry) is handled by interceptors.
+*/
+const COOKIE_NAME_VALUE_PATTERN = /^([^;]+)/;
+function baseFetch(request) {
+	return globalThis.fetch(request);
+}
+/**
+* Creates a fetch function that runs requests through an interceptor pipeline.
+*/
+function createTransport(options = {}) {
+	const interceptors = options.interceptors ?? [];
+	let chain = baseFetch;
+	for (let i = interceptors.length - 1; i >= 0; i--) {
+		const interceptor = interceptors[i];
+		const next = chain;
+		chain = (req) => interceptor(req, next);
+	}
+	return { fetch: chain };
+}
+/**
+* Adds X-Dineway-Request: 1 and Origin headers to mutation requests
+* (POST, PUT, DELETE). The custom header satisfies Dineway's CSRF check;
+* the Origin header satisfies Astro's built-in origin verification which
+* rejects server-side POST requests that lack a matching Origin.
+*/
+function csrfInterceptor() {
+	const MUTATION_METHODS = new Set([
+		"POST",
+		"PUT",
+		"DELETE",
+		"PATCH"
+	]);
+	return (request, next) => {
+		if (MUTATION_METHODS.has(request.method)) {
+			const headers = new Headers(request.headers);
+			headers.set("X-Dineway-Request", "1");
+			if (!headers.has("Origin")) {
+				const url = new URL(request.url);
+				headers.set("Origin", url.origin);
+			}
+			return next(new Request(request, { headers }));
+		}
+		return next(request);
+	};
+}
+/**
+* Adds Authorization: Bearer header from a static token.
+*/
+function tokenInterceptor(token) {
+	return (request, next) => {
+		const headers = new Headers(request.headers);
+		headers.set("Authorization", `Bearer ${token}`);
+		return next(new Request(request, { headers }));
+	};
+}
+/**
+* Dev bypass interceptor. Calls the dev-bypass endpoint on first request
+* to establish a session, then forwards the session cookie on subsequent
+* requests.
+*/
+function devBypassInterceptor(baseUrl) {
+	let sessionCookie = null;
+	let initializing = null;
+	async function init() {
+		const bypassUrl = new URL("/_dineway/api/auth/dev-bypass", baseUrl);
+		const res = await globalThis.fetch(bypassUrl, { redirect: "manual" });
+		const setCookie = res.headers.get("set-cookie");
+		if (setCookie) {
+			const match = setCookie.match(COOKIE_NAME_VALUE_PATTERN);
+			if (match) sessionCookie = match[1];
+		}
+		if (res.body) await res.text().catch(() => {});
+	}
+	return async (request, next) => {
+		if (!sessionCookie) {
+			if (!initializing) initializing = init();
+			await initializing;
+		}
+		if (sessionCookie) {
+			const headers = new Headers(request.headers);
+			const existing = headers.get("cookie");
+			headers.set("cookie", existing ? `${existing}; ${sessionCookie}` : sessionCookie);
+			return next(new Request(request, { headers }));
+		}
+		return next(request);
+	};
+}
+/**
+* Auto-refreshes expired OAuth tokens on 401 responses.
+* Requires a refresh token and the token endpoint URL.
+*/
+function refreshInterceptor(options) {
+	let refreshing = null;
+	async function refresh() {
+		const res = await globalThis.fetch(options.tokenEndpoint, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				grant_type: "refresh_token",
+				refresh_token: options.refreshToken
+			})
+		});
+		if (!res.ok) return null;
+		const json = await res.json();
+		const tokenData = json.data && typeof json.data === "object" && "access_token" in json.data ? json.data : json;
+		const expiresAt = tokenData.expires_in ? new Date(Date.now() + tokenData.expires_in * 1e3).toISOString() : new Date(Date.now() + 36e5).toISOString();
+		if (options.onTokenRefreshed) options.onTokenRefreshed(tokenData.access_token, tokenData.refresh_token ?? options.refreshToken, expiresAt);
+		return tokenData.access_token;
+	}
+	return async (request, next) => {
+		const response = await next(request);
+		if (response.status === 401) {
+			if (!refreshing) refreshing = refresh().finally(() => {
+				refreshing = null;
+			});
+			const newToken = await refreshing;
+			if (newToken) {
+				const headers = new Headers(request.headers);
+				headers.set("Authorization", `Bearer ${newToken}`);
+				return next(new Request(request, { headers }));
+			}
+		}
+		return response;
+	};
+}
+
+//#endregion
+export { tokenInterceptor as a, refreshInterceptor as i, csrfInterceptor as n, devBypassInterceptor as r, createTransport as t };

package/dist/types-4garmdWa.mjs

@@ -0,0 +1,66 @@
+//#region src/plugins/types.ts
+function capabilitiesToDeclaredAccess(capabilities, allowedHosts) {
+	const caps = new Set(capabilities);
+	const out = {};
+	if (caps.has("content:read") || caps.has("content:write")) {
+		out.content = { read: {} };
+		if (caps.has("content:write")) out.content.write = {};
+	}
+	if (caps.has("media:read") || caps.has("media:write")) {
+		out.media = { read: {} };
+		if (caps.has("media:write")) out.media.write = {};
+	}
+	if (caps.has("network:request:unrestricted")) out.network = { request: {} };
+	else if (caps.has("network:request")) out.network = { request: { allowedHosts: [...allowedHosts] } };
+	if (caps.has("email:send")) (out.email ??= {}).send = {};
+	if (caps.has("hooks.email-events:register")) (out.email ??= {}).events = {};
+	if (caps.has("hooks.email-transport:register")) (out.email ??= {}).transport = {};
+	if (caps.has("hooks.page-fragments:register")) out.page = { fragments: {} };
+	if (caps.has("users:read")) out.users = { read: {} };
+	return out;
+}
+function declaredAccessToCapabilities(declaredAccess) {
+	const caps = /* @__PURE__ */ new Set();
+	let allowedHosts = [];
+	if (declaredAccess.content?.read) caps.add("content:read");
+	if (declaredAccess.content?.write) {
+		caps.add("content:write");
+		caps.add("content:read");
+	}
+	if (declaredAccess.media?.read) caps.add("media:read");
+	if (declaredAccess.media?.write) {
+		caps.add("media:write");
+		caps.add("media:read");
+	}
+	if (declaredAccess.network?.request) {
+		const hosts = declaredAccess.network.request.allowedHosts;
+		if (hosts === void 0) {
+			caps.add("network:request:unrestricted");
+			caps.add("network:request");
+		} else {
+			caps.add("network:request");
+			allowedHosts = [...hosts];
+		}
+	}
+	if (declaredAccess.email?.send) caps.add("email:send");
+	if (declaredAccess.email?.events) caps.add("hooks.email-events:register");
+	if (declaredAccess.email?.transport) caps.add("hooks.email-transport:register");
+	if (declaredAccess.page?.fragments) caps.add("hooks.page-fragments:register");
+	if (declaredAccess.users?.read) caps.add("users:read");
+	return {
+		capabilities: [...caps],
+		allowedHosts
+	};
+}
+/**
+* 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 { declaredAccessToCapabilities as n, isStandardPluginDefinition as r, capabilitiesToDeclaredAccess as t };

package/dist/{types-DSPGWjxO.d.mts → types-C8XW6L19.d.mts}

@@ -1,6 +1,11 @@
-import { d as FieldType } from "./types-CwawBUTa.mjs";
+import { d as FieldType } from "./types-DW_-sFyz.mjs";
+import { t as Database } from "./types-DU0bU2Wu.mjs";
+import { d as Storage } from "./types-POH8PQZh.mjs";
+import { Kysely } from "kysely";
 import { z } from "astro/zod";
+import { Permission, RoleLevel } from "@dineway-ai/auth";
 import "react/jsx-runtime";
+import { AnySchema } from "@modelcontextprotocol/sdk/server/zod-compat.js";
 import { JSX } from "astro/jsx-runtime";
 
 //#region ../blocks/dist/validation-b1zbwCOE.d.ts
@@ -126,6 +131,40 @@ type Element = ButtonElement | TextInputElement | NumberInputElement | SelectEle
  * Plugin capabilities determine what APIs are available in context
  */
 type PluginCapability = "network:request" | "network:request:unrestricted" | "content:read" | "content:write" | "media:read" | "media:write" | "users:read" | "email:send" | "hooks.email-transport:register" | "hooks.email-events:register" | "hooks.page-fragments:register";
+type AccessConstraints = Record<string, unknown>;
+/**
+ * Structured plugin trust contract.
+ *
+ * This is the manifest-facing access shape. `capabilities` and `allowedHosts`
+ * remain the runtime enforcement currency and are derived from this at bundle
+ * parse boundaries when `declaredAccess` is present.
+ */
+interface DeclaredAccess {
+  content?: {
+    read?: AccessConstraints;
+    write?: AccessConstraints;
+  };
+  media?: {
+    read?: AccessConstraints;
+    write?: AccessConstraints;
+  };
+  network?: {
+    request?: {
+      allowedHosts?: string[];
+    };
+  };
+  email?: {
+    send?: AccessConstraints;
+    events?: AccessConstraints;
+    transport?: AccessConstraints;
+  };
+  page?: {
+    fragments?: AccessConstraints;
+  };
+  users?: {
+    read?: AccessConstraints;
+  };
+}
 /**
  * Storage collection declaration in plugin definition
  */
@@ -701,12 +740,15 @@ interface ContentDeleteEvent {
   permanent: boolean;
 }
 /**
- * Content publish state change hook event (fired after publish or unpublish)
+ * Content state change hook event.
  */
-interface ContentPublishStateChangeEvent {
+interface ContentStateChangeEvent {
   content: Record<string, unknown>;
   collection: string;
 }
+type ContentPublishStateChangeEvent = ContentStateChangeEvent;
+type ContentRestoreStateChangeEvent = ContentStateChangeEvent;
+type ContentScheduleStateChangeEvent = ContentStateChangeEvent;
 /**
  * Media hook event
  */
@@ -739,6 +781,9 @@ type ContentBeforeDeleteHandler = (event: ContentDeleteEvent, ctx: PluginContext
 type ContentAfterDeleteHandler = (event: ContentDeleteEvent, ctx: PluginContext) => Promise<void>;
 type ContentAfterPublishHandler = (event: ContentPublishStateChangeEvent, ctx: PluginContext) => Promise<void>;
 type ContentAfterUnpublishHandler = (event: ContentPublishStateChangeEvent, ctx: PluginContext) => Promise<void>;
+type ContentAfterRestoreHandler = (event: ContentRestoreStateChangeEvent, ctx: PluginContext) => Promise<void>;
+type ContentAfterScheduleHandler = (event: ContentScheduleStateChangeEvent, ctx: PluginContext) => Promise<void>;
+type ContentAfterUnscheduleHandler = (event: ContentScheduleStateChangeEvent, ctx: PluginContext) => Promise<void>;
 type MediaBeforeUploadHandler = (event: MediaUploadEvent, ctx: PluginContext) => Promise<{
   name: string;
   type: string;
@@ -884,6 +929,9 @@ interface PluginHooks {
   "content:afterDelete"?: HookConfig<ContentAfterDeleteHandler> | ContentAfterDeleteHandler;
   "content:afterPublish"?: HookConfig<ContentAfterPublishHandler> | ContentAfterPublishHandler;
   "content:afterUnpublish"?: HookConfig<ContentAfterUnpublishHandler> | ContentAfterUnpublishHandler;
+  "content:afterRestore"?: HookConfig<ContentAfterRestoreHandler> | ContentAfterRestoreHandler;
+  "content:afterSchedule"?: HookConfig<ContentAfterScheduleHandler> | ContentAfterScheduleHandler;
+  "content:afterUnschedule"?: HookConfig<ContentAfterUnscheduleHandler> | ContentAfterUnscheduleHandler;
   "media:beforeUpload"?: HookConfig<MediaBeforeUploadHandler> | MediaBeforeUploadHandler;
   "media:afterUpload"?: HookConfig<MediaAfterUploadHandler> | MediaAfterUploadHandler;
   cron?: HookConfig<CronHandler> | CronHandler;
@@ -952,12 +1000,59 @@ interface RequestMeta {
   referer: string | null;
   geo: GeoInfo | null;
 }
+type PluginRouteBodyMode = "json" | "raw";
+type PluginRouteMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+type PluginActorType = "user" | "api_token" | "system";
+type PluginAuthMethod = "session" | "api_token" | "oauth_token" | "system";
+interface PluginActor {
+  type: PluginActorType;
+  id: string;
+  userId: string | null;
+  role: RoleLevel;
+  authMethod: PluginAuthMethod;
+  tokenScopes?: readonly string[];
+}
+interface PluginTargetScope {
+  type: "plugin" | "location" | "entity";
+  id: string;
+  /** Canonical Site Context scope used for HITL and activity inheritance. */
+  scope: string;
+  locationId?: string;
+}
+interface PluginRouteAuthorization {
+  /** Core RBAC permission checked before route dispatch. */
+  permission: Permission;
+  /** API/OAuth tokens must hold at least one listed scope. */
+  anyOfTokenScopes: string[];
+  /** First-party domain permission checked against the resolved target. */
+  restaurantPermission?: string;
+}
+interface PluginRouteTargetContext extends PluginContext {
+  actor: PluginActor;
+  request: Request;
+  requestMeta: RequestMeta;
+}
+interface PluginRouteTargetAuthorizationRequest<TInput = unknown> {
+  restaurantPermission: string;
+  target: PluginTargetScope;
+  context: RouteContext<TInput> & {
+    readonly actor: PluginActor;
+    readonly target: PluginTargetScope;
+  };
+}
+type PluginRouteTargetAuthorizer<TInput = unknown> = (request: PluginRouteTargetAuthorizationRequest<TInput>) => Promise<void>;
 /**
  * Route handler context extends plugin context with request-specific data
  */
 interface RouteContext<TInput = unknown> extends PluginContext {
   /** Validated input from request body */
   input: TInput;
+  /** Exact request bytes for raw-body routes; null for ordinary JSON routes. */
+  readonly rawBody: Uint8Array | null;
+  /** Normalized authenticated actor; null for unauthenticated public routes. */
+  readonly actor: PluginActor | null;
+  /** Server-resolved authorization target when the route declares one. */
+  readonly target: PluginTargetScope | null;
   /** Original request */
   request: Request;
   /** Normalized request metadata (IP, user agent, geo) */
@@ -967,8 +1062,20 @@ interface RouteContext<TInput = unknown> extends PluginContext {
  * Route definition
  */
 interface PluginRoute<TInput = unknown> {
+  /** Restrict trusted route invocation to these HTTP methods. Omit for legacy all-method behavior. */
+  methods?: readonly PluginRouteMethod[];
   /** Zod schema for input validation */
   input?: z.ZodType<TInput>;
+  /** Request-body handling mode. Defaults to JSON. */
+  body?: PluginRouteBodyMode;
+  /** Maximum bytes accepted by a raw-body route. JSON routes cannot set this field. */
+  maxBodyBytes?: number;
+  /** Declarative private-route authorization. */
+  authorization?: PluginRouteAuthorization;
+  /** Resolve the authoritative restaurant target before the handler runs. */
+  resolveTarget?: (input: TInput, context: PluginRouteTargetContext) => PluginTargetScope | Promise<PluginTargetScope>;
+  /** Enforce the declared restaurant permission against the resolved target. */
+  authorizeTarget?: PluginRouteTargetAuthorizer<TInput>;
   /**
    * Mark this route as publicly accessible (no authentication required).
    * Public routes skip session/token auth and CSRF checks.
@@ -977,6 +1084,113 @@ interface PluginRoute<TInput = unknown> {
   /** Route handler */
   handler: (ctx: RouteContext<TInput>) => Promise<unknown>;
 }
+type PluginMcpPiiClass = "none" | "redacted" | "sensitive";
+type PluginMcpRiskLevel = "quick_confirmation" | "strong_confirmation";
+type PluginMcpRiskFactor = "content" | "availability" | "time" | "money" | "allergen" | "pii" | "batch" | "payment" | "destructive" | "external_side_effect";
+type PluginMcpReversibility = "reversible" | "compensating" | "irreversible";
+interface PluginMcpExecutionContext {
+  plugin: {
+    id: string;
+    version: string;
+  };
+  actor: PluginActor;
+  db: Kysely<Database>;
+  storage: Storage | null;
+  /** Plugin-scoped outbound HTTP with the plugin's SSRF and capability policy. */
+  http?: HttpAccess;
+  reviewedExecution?: {
+    id: string;
+    hitlRequestId: string | null;
+    actionHash: string;
+    idempotencyKey: string;
+  };
+}
+interface PluginMcpTargetAuthorizationRequest {
+  restaurantPermission: string;
+  target: PluginTargetScope;
+  context: PluginMcpExecutionContext;
+}
+type PluginMcpTargetAuthorizer = (request: PluginMcpTargetAuthorizationRequest) => Promise<void>;
+interface PluginMcpAuthorization {
+  /** Core RBAC permission checked for every request. */
+  permission: Permission;
+  /** Any listed token scope permits the request; `admin` remains a universal scope. */
+  anyOfTokenScopes: string[];
+  /** Optional first-party domain permission checked by the core target authorizer. */
+  restaurantPermission?: string;
+}
+interface PluginMcpPiiPolicy {
+  input: PluginMcpPiiClass;
+  output: PluginMcpPiiClass;
+}
+interface PluginMcpCommandPreview {
+  summary: string;
+  target: PluginTargetScope;
+  before?: Record<string, unknown>;
+  after?: Record<string, unknown>;
+  metadata?: Record<string, unknown>;
+}
+interface PluginMcpToolBase {
+  name: string;
+  title: string;
+  description: string;
+  inputSchema: AnySchema;
+  outputSchema?: AnySchema;
+  authorization: PluginMcpAuthorization;
+  pii: PluginMcpPiiPolicy;
+  resolveTarget?: (input: Record<string, unknown>, context: PluginMcpExecutionContext) => Promise<PluginTargetScope> | PluginTargetScope;
+  handler: (input: Record<string, unknown>, context: PluginMcpExecutionContext) => Promise<Record<string, unknown>>;
+}
+interface PluginMcpQueryTool extends PluginMcpToolBase {
+  kind: "query";
+}
+interface PluginMcpCommandTool extends PluginMcpToolBase {
+  kind: "command";
+  risk: {
+    level: PluginMcpRiskLevel;
+    mandatory: boolean;
+    reason: string;
+    factors: PluginMcpRiskFactor[];
+  };
+  audit: "best_effort" | "strict";
+  reversibility: PluginMcpReversibility;
+  preview: (input: Record<string, unknown>, context: PluginMcpExecutionContext) => Promise<PluginMcpCommandPreview>;
+  actionFingerprint: (input: Record<string, unknown>, preview: PluginMcpCommandPreview, context: PluginMcpExecutionContext) => Promise<Record<string, unknown>> | Record<string, unknown>;
+  idempotency: {
+    required: true;
+    namespace?: string;
+  };
+  redactPreview?: (preview: PluginMcpCommandPreview, context: PluginMcpExecutionContext) => Promise<PluginMcpCommandPreview> | PluginMcpCommandPreview;
+}
+type PluginMcpTool = PluginMcpQueryTool | PluginMcpCommandTool;
+interface PluginMcpResourceContent {
+  text: string;
+  mimeType?: string;
+}
+interface PluginMcpResource {
+  name: string;
+  title: string;
+  description: string;
+  uri: string;
+  mimeType?: string;
+  authorization: PluginMcpAuthorization;
+  pii: {
+    output: PluginMcpPiiClass;
+  };
+  target?: PluginTargetScope;
+  handler: (uri: URL, context: PluginMcpExecutionContext) => Promise<PluginMcpResourceContent>;
+}
+interface PluginMcpConfig {
+  tools?: PluginMcpTool[];
+  resources?: PluginMcpResource[];
+  /** Trusted first-party domain authorization invoked by the core wrapper. */
+  authorizeTarget?: PluginMcpTargetAuthorizer;
+}
+interface ResolvedPluginMcpConfig {
+  tools: PluginMcpTool[];
+  resources: PluginMcpResource[];
+  authorizeTarget?: PluginMcpTargetAuthorizer;
+}
 /**
  * Admin page definition
  */
@@ -1120,6 +1334,8 @@ interface PluginDefinition<TStorage extends PluginStorageConfig = PluginStorageC
   hooks?: PluginHooks;
   /** API routes */
   routes?: Record<string, PluginRoute>;
+  /** Native first-party MCP tools and read-only resources. */
+  mcp?: PluginMcpConfig;
   /** Admin UI configuration */
   admin?: PluginAdminConfig;
 }
@@ -1134,6 +1350,7 @@ interface ResolvedPlugin<TStorage extends PluginStorageConfig = PluginStorageCon
   storage: TStorage;
   hooks: ResolvedPluginHooks;
   routes: Record<string, PluginRoute>;
+  mcp: ResolvedPluginMcpConfig;
   admin: PluginAdminConfig;
 }
 /**
@@ -1150,6 +1367,9 @@ interface ResolvedPluginHooks {
   "content:afterDelete"?: ResolvedHook<ContentAfterDeleteHandler>;
   "content:afterPublish"?: ResolvedHook<ContentAfterPublishHandler>;
   "content:afterUnpublish"?: ResolvedHook<ContentAfterUnpublishHandler>;
+  "content:afterRestore"?: ResolvedHook<ContentAfterRestoreHandler>;
+  "content:afterSchedule"?: ResolvedHook<ContentAfterScheduleHandler>;
+  "content:afterUnschedule"?: ResolvedHook<ContentAfterUnscheduleHandler>;
   "media:beforeUpload"?: ResolvedHook<MediaBeforeUploadHandler>;
   "media:afterUpload"?: ResolvedHook<MediaAfterUploadHandler>;
   cron?: ResolvedHook<CronHandler>;
@@ -1234,6 +1454,7 @@ interface PluginAdminExports {
 interface PluginManifest {
   id: string;
   version: string;
+  declaredAccess?: DeclaredAccess;
   capabilities: PluginCapability[];
   allowedHosts: string[];
   storage: PluginStorageConfig;
@@ -1244,4 +1465,4 @@ interface PluginManifest {
   admin: PluginAdminConfig;
 }
 //#endregion
-export { StandardHookEntry as $, PageMetadataContribution as A, PluginDefinition as B, MediaAccess as C, PageFragmentContribution as D, ModerationDecision as E, PluginAdminConfig as F, PortableTextBlockConfig as G, PluginManifest as H, PluginAdminExports as I, RequestMeta as J, PortableTextBlockField as K, PluginAdminPage as L, PageMetadataHandler as M, PageMetadataLinkRel as N, PageFragmentEvent as O, PagePlacement as P, RouteContext as Q, PluginCapability as R, LogAccess as S, MediaUploadEvent as T, PluginRoute as U, PluginHooks as V, PluginStorageConfig as W, ResolvedPlugin as X, ResolvedHook as Y, ResolvedPluginHooks as Z, FieldWidgetConfig as _, CommentAfterModerateEvent as a, StorageCollectionConfig as at, HttpAccess as b, CommentBeforeCreateHandler as c, Element as ct, ContentAccess as d, StandardHookHandler as et, ContentDeleteEvent as f, EmailMessage as g, CronEvent as h, CommentAfterCreateHandler as i, StorageCollection as it, PageMetadataEvent as j, PageFragmentHandler as k, CommentModerateEvent as l, ContentPublishStateChangeEvent as m, CollectionCommentSettings as n, StandardRouteEntry as nt, CommentAfterModerateHandler as o, StoredComment as ot, ContentHookEvent as p, PublicPageContext as q, CommentAfterCreateEvent as r, StandardRouteHandler as rt, CommentBeforeCreateEvent as s, isStandardPluginDefinition as st, BreadcrumbItem as t, StandardPluginDefinition as tt, CommentModerateHandler as u, HookConfig as v, MediaItem as w, KVAccess as x, HookName as y, PluginContext as z };
+export { PluginMcpQueryTool as $, PageMetadataContribution as A, StorageCollection as At, PluginAuthMethod as B, MediaAccess as C, ResolvedPluginMcpConfig as Ct, PageFragmentContribution as D, StandardPluginDefinition as Dt, ModerationDecision as E, StandardHookHandler as Et, PluginActor as F, PluginManifest as G, PluginContext as H, PluginActorType as I, PluginMcpCommandTool as J, PluginMcpAuthorization as K, PluginAdminConfig as L, PageMetadataHandler as M, StoredComment as Mt, PageMetadataLinkRel as N, isStandardPluginDefinition as Nt, PageFragmentEvent as O, StandardRouteEntry as Ot, PagePlacement as P, Element as Pt, PluginMcpPiiPolicy as Q, PluginAdminExports as R, LogAccess as S, ResolvedPluginHooks as St, MediaUploadEvent as T, StandardHookEntry as Tt, PluginDefinition as U, PluginCapability as V, PluginHooks as W, PluginMcpExecutionContext as X, PluginMcpConfig as Y, PluginMcpPiiClass as Z, FieldWidgetConfig as _, PortableTextBlockField as _t, CommentAfterModerateEvent as a, PluginMcpTargetAuthorizer as at, HttpAccess as b, ResolvedHook as bt, CommentBeforeCreateHandler as c, PluginRouteAuthorization as ct, ContentAccess as d, PluginRouteTargetAuthorizationRequest as dt, PluginMcpResource as et, ContentDeleteEvent as f, PluginRouteTargetAuthorizer as ft, EmailMessage as g, PortableTextBlockConfig as gt, CronEvent as h, PluginTargetScope as ht, CommentAfterCreateHandler as i, PluginMcpRiskLevel as it, PageMetadataEvent as j, StorageCollectionConfig as jt, PageFragmentHandler as k, StandardRouteHandler as kt, CommentModerateEvent as l, PluginRouteBodyMode as lt, ContentPublishStateChangeEvent as m, PluginStorageConfig as mt, CollectionCommentSettings as n, PluginMcpReversibility as nt, CommentAfterModerateHandler as o, PluginMcpTool as ot, ContentHookEvent as p, PluginRouteTargetContext as pt, PluginMcpCommandPreview as q, CommentAfterCreateEvent as r, PluginMcpRiskFactor as rt, CommentBeforeCreateEvent as s, PluginRoute as st, BreadcrumbItem as t, PluginMcpResourceContent as tt, CommentModerateHandler as u, PluginRouteMethod as ut, HookConfig as v, PublicPageContext as vt, MediaItem as w, RouteContext as wt, KVAccess as x, ResolvedPlugin as xt, HookName as y, RequestMeta as yt, PluginAdminPage as z };