dineway 0.1.8 → 0.1.11

package/LICENSE

@@ -0,0 +1,9 @@
+The MIT License
+
+Copyright 2026 Cloudflare Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,6 +1,8 @@
-# dineway
+# Dineway
 
-The Agentic Website builder for restaurants and local businesses. Dineway combines structured content modeling with the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) to create intelligent, AI-powered sites that understand your menu, manage your reputation, and act on your behalf.
+The Agentic Website builder for restaurants and local businesses. Dineway combines structured content modeling with the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) to create intelligent, AI-powered sites that don't just display information — they understand your menus, manage your reputation, execute marketing, and act on behalf of the restaurant owner.
+
+The core thesis: A restaurant's website should not be a brochure. It should be an employee — they understand it, act on it, and improve autonomously.
 
 ## Overview
 
@@ -29,16 +31,16 @@ Dineway is an [Astro](https://astro.build) integration that gives your site a fu
 
 ### Core Capabilities
 
-| Category | What It Does |
-|---|---|
-| **MCP Server** | 50+ tools for AI agents to interact with content, schema, media, search, taxonomies, menus, and site context |
-| **Site Context Engine** | Versioned operational knowledge (brand voice, seasonal strategy, policies) — agents consult before acting |
-| **Content Engine** | Structured collections with typed fields, revisions, drafts, scheduled publishing, and full-text search |
-| **Entity Resolution** | Natural-language references ("the spring lamb special") resolve to exact content items |
-| **Human-in-the-Loop** | Review requests ensure AI-generated changes get human approval before going live |
-| **Admin Panel** | Visual schema builder, rich text editor (TipTap/Portable Text), media library, menu builder |
-| **Plugin System** | Lifecycle hooks, KV storage, settings, admin pages, dashboard widgets, custom block types |
-| **CLI** | Programmatic site management for content, schema, media, deployment — designed for both humans and AI agents |
+| Category                | What It Does                                                                                                 |
+| ----------------------- | ------------------------------------------------------------------------------------------------------------ |
+| **MCP Server**          | 50+ tools for AI agents to interact with content, schema, media, search, taxonomies, menus, and site context |
+| **Site Context Engine** | Versioned operational knowledge (brand voice, seasonal strategy, policies) — agents consult before acting    |
+| **Content Engine**      | Structured collections with typed fields, revisions, drafts, scheduled publishing, and full-text search      |
+| **Entity Resolution**   | Natural-language references ("the spring lamb special") resolve to exact content items                       |
+| **Human-in-the-Loop**   | Review requests ensure AI-generated changes get human approval before going live                             |
+| **Admin Panel**         | Visual schema builder, rich text editor (TipTap/Portable Text), media library, menu builder                  |
+| **Plugin System**       | Lifecycle hooks, KV storage, settings, admin pages, dashboard widgets, custom block types                    |
+| **CLI**                 | Programmatic site management for content, schema, media, deployment — designed for both humans and AI agents |
 
 ## Installation
 
@@ -56,7 +58,7 @@ npm install dineway
 
 The Dineway CLI (`dineway`) manages projects and instances. Commands fall into three categories:
 
-- **Local commands** — work directly on local project files or a SQLite file, no running server needed: `init`, `dev`, `seed`, `export-seed`, `auth secret`
+- **Local commands** — work directly on local project files or a SQLite file, no running server needed: `init`, `dev`, `seed`, `export-seed`, `auth secret`, `secrets generate`, `secrets fingerprint`
 - **Deployment commands** — orchestrate platform CLIs or generate provider files: `deploy`
 - **Remote commands** — talk to a running Dineway instance via HTTP: `types`, `login`, `logout`, `whoami`, `content`, `schema`, `media`, `search`, `taxonomy`, `menu`
 
@@ -191,6 +193,37 @@ npx dineway content list posts --json | jq '.items[].slug'
 ID=$(npx dineway content create posts --data '{"title":"Hello"}' --json | jq -r '.id')
 ```
 
+## Astro Configuration
+
+```typescript
+// astro.config.mjs
+import { defineConfig } from "astro/config";
+import dineway, { local } from "dineway/astro";
+import { sqlite } from "dineway/db";
+
+export default defineConfig({
+	integrations: [
+		dineway({
+			database: sqlite({ url: "file:./data.db" }),
+			storage: local({
+				directory: "./uploads",
+				baseUrl: "/_dineway/api/media/file",
+			}),
+		}),
+	],
+});
+```
+
+```typescript
+// src/live.config.ts
+import { defineLiveCollection } from "astro:content";
+import { dinewayLoader } from "dineway/runtime";
+
+export const collections = {
+	_dineway: defineLiveCollection({ loader: dinewayLoader() }),
+};
+```
+
 ## Querying Content in Astro Pages
 
 Use Dineway's query functions in your Astro components:
@@ -202,17 +235,30 @@ import {
 	getSiteSettings,
 	getMenu,
 	getTaxonomyTerms,
+	getWidgetArea,
 	search,
 } from "dineway";
 
-const { entries: menuItems } = await getDinewayCollection("menu-items");
-const { entry: dish } = await getDinewayEntry("menu-items", "spring-lamb");
+// Content
+const { entries } = await getDinewayCollection("posts");
+const { entry } = await getDinewayEntry("posts", "hello-world");
+
+// Site settings
 const settings = await getSiteSettings();
+
+// Navigation
 const menu = await getMenu("primary");
+
+// Taxonomies
 const categories = await getTaxonomyTerms("categories");
-const results = await search("lamb", { collections: ["menu-items"] });
+
+// Widgets
+const sidebar = await getWidgetArea("sidebar");
+
+// Search
+const results = await search("hello world", { collections: ["posts"] });
 ```
 
 ## Documentation
 
-Full documentation, guides, and API reference: [docs](../../docs/src/content/docs/index.mdx)
+Full documentation, guides, and API reference: [docs](https://docs.dineway.ai)

package/dist/activity-events-BsMaXdJa.mjs

@@ -0,0 +1,540 @@
+import { t as SiteActivityRepository } from "./site-activity-B8FjLIVh.mjs";
+
+//#region src/site-context/actor.ts
+const SYSTEM_ACTOR_ID = "system";
+function resolveActorIdentity(locals) {
+	const userId = locals?.user?.id;
+	const token = locals?.authToken;
+	const authMetadata = buildAuthMetadata(locals);
+	if (token?.type === "api_token" && token.id) return {
+		actorType: "api_token",
+		actorId: token.id,
+		authMetadata
+	};
+	if (userId) return {
+		actorType: "user",
+		actorId: userId,
+		authMetadata
+	};
+	return {
+		actorType: "system",
+		actorId: SYSTEM_ACTOR_ID,
+		authMetadata
+	};
+}
+function buildAuthMetadata(locals) {
+	const token = locals?.authToken;
+	const userId = locals?.user?.id;
+	if (!token && userId) return { auth_method: "session" };
+	if (!token) return { auth_method: "system" };
+	return {
+		auth_method: token.type,
+		user_id: userId ?? null,
+		token_id_available: Boolean(token.id),
+		token_scopes: locals?.tokenScopes ?? []
+	};
+}
+
+//#endregion
+//#region src/site-context/activity.ts
+const REDACTED = "[redacted]";
+const TRUNCATED = "[truncated]";
+const MAX_DEPTH = 6;
+const MAX_OBJECT_KEYS = 100;
+const MAX_ARRAY_ITEMS = 50;
+const MAX_STRING_LENGTH = 2e3;
+const SECRET_KEY_PATTERN = /^(authorization|cookie|set-cookie|password|secret|token|token[_-]?hash|api[_-]?key|apikey|access[_-]?token|refresh[_-]?token|auth[_-]?token|private[_-]?key|privatekey|credential|credentials)$/i;
+var SiteActivityLogger = class {
+	repository;
+	constructor(db) {
+		this.repository = new SiteActivityRepository(db);
+	}
+	async log(locals, input) {
+		const actor = resolveActorIdentity(locals);
+		return this.repository.create({
+			actorType: actor.actorType,
+			actorId: actor.actorId,
+			authMetadata: redactActivityRecord(actor.authMetadata),
+			actionType: input.actionType,
+			subjectType: input.subjectType,
+			subjectId: input.subjectId ?? null,
+			relatedSubjectType: input.relatedSubjectType ?? null,
+			relatedSubjectId: input.relatedSubjectId ?? null,
+			sourceType: input.sourceType ?? null,
+			sourceName: input.sourceName ?? null,
+			resultStatus: input.resultStatus,
+			scope: input.scope,
+			summary: truncateString(input.summary),
+			detail: input.detail ? redactActivityRecord(input.detail) : null,
+			createdAt: input.createdAt
+		});
+	}
+};
+function redactActivityRecord(input) {
+	const redacted = redactActivityValue(input, 0);
+	if (isRecord$1(redacted)) return redacted;
+	return {};
+}
+function redactActivityValue(value, depth, key) {
+	if (key && isSecretKey(key)) return REDACTED;
+	if (value === null || value === void 0) return value;
+	if (typeof value === "string") return truncateString(value);
+	if (typeof value === "number" || typeof value === "boolean") return value;
+	if (typeof value === "bigint") return value.toString();
+	if (value instanceof Date) return value.toISOString();
+	if (depth >= MAX_DEPTH) return TRUNCATED;
+	if (Array.isArray(value)) {
+		const items = value.slice(0, MAX_ARRAY_ITEMS).map((item) => redactActivityValue(item, depth + 1));
+		if (value.length > MAX_ARRAY_ITEMS) items.push(TRUNCATED);
+		return items;
+	}
+	if (isRecord$1(value)) {
+		const entries = Object.entries(value);
+		const redacted = {};
+		for (const [entryKey, entryValue] of entries.slice(0, MAX_OBJECT_KEYS)) redacted[entryKey] = redactActivityValue(entryValue, depth + 1, entryKey);
+		if (entries.length > MAX_OBJECT_KEYS) redacted.__truncated_keys = entries.length - MAX_OBJECT_KEYS;
+		return redacted;
+	}
+	if (typeof value === "symbol") return value.description ? `Symbol(${value.description})` : "Symbol()";
+	if (typeof value === "function") return value.name ? `[function ${value.name}]` : "[function anonymous]";
+	return "[unsupported]";
+}
+function truncateString(value) {
+	if (value.length <= MAX_STRING_LENGTH) return value;
+	return `${value.slice(0, MAX_STRING_LENGTH)}...${TRUNCATED}`;
+}
+function isSecretKey(key) {
+	return SECRET_KEY_PATTERN.test(key);
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+//#endregion
+//#region src/site-context/activity-events.ts
+async function logSiteActivitySafely(db, locals, input) {
+	if (!db) return;
+	try {
+		await new SiteActivityLogger(db).log(locals, input);
+	} catch (error) {
+		console.error("[site-activity] Failed to write activity log:", error);
+	}
+}
+async function logContentActivity(db, locals, input) {
+	const entryId = input.entryId ?? null;
+	await logSiteActivitySafely(db, locals, {
+		actionType: `content.${input.action}`,
+		subjectType: "content",
+		subjectId: entryId,
+		relatedSubjectType: "collection",
+		relatedSubjectId: input.collection,
+		...activityProvenance(input),
+		scope: entryId ? contentScope(input.collection, entryId) : collectionScope(input.collection),
+		summary: input.summary ?? `${input.action} content in ${input.collection}`,
+		detail: {
+			collection: input.collection,
+			entryId,
+			...input.detail
+		}
+	});
+}
+async function logSchemaActivity(db, locals, input) {
+	const subjectId = input.field ? `${input.collection}.${input.field}` : input.collection;
+	await logSiteActivitySafely(db, locals, {
+		actionType: `schema.${input.action}`,
+		subjectType: "schema",
+		subjectId,
+		relatedSubjectType: "collection",
+		relatedSubjectId: input.collection,
+		...activityProvenance(input),
+		scope: collectionScope(input.collection),
+		summary: input.summary ?? `${input.action} schema for ${input.collection}`,
+		detail: {
+			collection: input.collection,
+			field: input.field ?? null,
+			...input.detail
+		}
+	});
+}
+async function logPluginActivity(db, locals, input) {
+	await logSiteActivitySafely(db, locals, {
+		actionType: `plugin.${input.action}`,
+		subjectType: "plugin",
+		subjectId: input.pluginId,
+		scope: pluginScope(input.pluginId),
+		...activityProvenance(input),
+		summary: input.summary ?? `${input.action} plugin ${input.pluginId}`,
+		detail: {
+			pluginId: input.pluginId,
+			...input.detail
+		}
+	});
+}
+async function logMenuActivity(db, locals, input) {
+	const itemId = input.itemId ?? null;
+	const subjectType = input.action.startsWith("item_") ? "menu_item" : "menu";
+	const subjectId = itemId ?? input.menuName;
+	await logSiteActivitySafely(db, locals, {
+		actionType: `menu.${input.action}`,
+		subjectType,
+		subjectId,
+		relatedSubjectType: subjectType === "menu_item" ? "menu" : null,
+		relatedSubjectId: subjectType === "menu_item" ? input.menuName : null,
+		...activityProvenance(input),
+		scope: menuScope(input.menuName),
+		summary: input.summary ?? defaultMenuSummary(input),
+		detail: {
+			menuName: input.menuName,
+			itemId,
+			...input.detail
+		}
+	});
+}
+async function logRedirectActivity(db, locals, input) {
+	await logSiteActivitySafely(db, locals, {
+		actionType: `redirect.${input.action}`,
+		subjectType: "redirect",
+		subjectId: input.redirectId,
+		scope: "site",
+		...activityProvenance(input),
+		summary: input.summary ?? defaultRedirectSummary(input),
+		detail: {
+			redirectId: input.redirectId,
+			source: input.source,
+			destination: input.destination,
+			...input.detail
+		}
+	});
+}
+async function logTaxonomyActivity(db, locals, input) {
+	const termId = input.termId ?? null;
+	const termSlug = input.termSlug ?? null;
+	const isTermAction = input.action.startsWith("term_");
+	await logSiteActivitySafely(db, locals, {
+		actionType: `taxonomy.${input.action}`,
+		subjectType: isTermAction ? "taxonomy_term" : "taxonomy",
+		subjectId: isTermAction ? termId ?? taxonomyTermFallbackId(input.taxonomyName, termSlug) : input.taxonomyId ?? input.taxonomyName,
+		relatedSubjectType: isTermAction ? "taxonomy" : null,
+		relatedSubjectId: isTermAction ? input.taxonomyId ?? input.taxonomyName : null,
+		...activityProvenance(input),
+		scope: taxonomyScope(input.taxonomyName),
+		summary: input.summary ?? defaultTaxonomySummary(input),
+		detail: {
+			taxonomyId: input.taxonomyId ?? null,
+			taxonomyName: input.taxonomyName,
+			termId,
+			termSlug,
+			...input.detail
+		}
+	});
+}
+async function logSectionActivity(db, locals, input) {
+	await logSiteActivitySafely(db, locals, {
+		actionType: `section.${input.action}`,
+		subjectType: "section",
+		subjectId: input.sectionId,
+		scope: "site",
+		...activityProvenance(input),
+		summary: input.summary ?? defaultSectionSummary(input),
+		detail: {
+			sectionId: input.sectionId,
+			sectionSlug: input.sectionSlug,
+			...input.detail
+		}
+	});
+}
+async function logWidgetActivity(db, locals, input) {
+	const widgetId = input.widgetId ?? null;
+	const isAreaAction = input.action === "area_created" || input.action === "area_deleted";
+	const isReorderAction = input.action === "reordered";
+	await logSiteActivitySafely(db, locals, {
+		actionType: isAreaAction || isReorderAction ? `widget_area.${input.action}` : `widget.${input.action}`,
+		subjectType: isAreaAction || isReorderAction ? "widget_area" : "widget",
+		subjectId: isAreaAction || isReorderAction ? input.areaId : widgetId ?? input.areaId,
+		relatedSubjectType: isAreaAction || isReorderAction ? null : "widget_area",
+		relatedSubjectId: isAreaAction || isReorderAction ? null : input.areaId,
+		...activityProvenance(input),
+		scope: "site",
+		summary: input.summary ?? defaultWidgetSummary(input),
+		detail: {
+			areaId: input.areaId,
+			areaName: input.areaName,
+			widgetId,
+			...input.detail
+		}
+	});
+}
+async function logExclusiveHookActivity(db, locals, input) {
+	await logSiteActivitySafely(db, locals, {
+		actionType: `exclusive_hook.${input.action}`,
+		subjectType: "exclusive_hook",
+		subjectId: input.hookName,
+		scope: "site",
+		...activityProvenance(input),
+		summary: input.summary ?? defaultExclusiveHookSummary(input),
+		detail: {
+			hookName: input.hookName,
+			previousPluginId: input.previousPluginId,
+			selectedPluginId: input.selectedPluginId,
+			...input.detail
+		}
+	});
+}
+function extractActivityItemId(data, fallback) {
+	const item = extractActivityItem(data);
+	if (typeof item?.id === "string") return item.id;
+	return fallback ?? null;
+}
+function activityChangedKeys(value) {
+	return value ? Object.keys(value).toSorted() : [];
+}
+function contentApiRouteSource(action) {
+	return {
+		sourceType: "api_route",
+		sourceName: `content.${contentRouteVerb(action)}`
+	};
+}
+function contentMcpToolSource(toolName) {
+	return {
+		sourceType: "mcp_tool",
+		sourceName: toolName
+	};
+}
+function schemaApiRouteSource(action) {
+	return {
+		sourceType: "api_route",
+		sourceName: `schema.${schemaRouteVerb(action)}`
+	};
+}
+function schemaMcpToolSource(action) {
+	return {
+		sourceType: "mcp_tool",
+		sourceName: schemaMcpToolName(action)
+	};
+}
+function pluginApiRouteSource(action) {
+	return {
+		sourceType: "api_route",
+		sourceName: `plugin.${pluginRouteVerb(action)}`
+	};
+}
+function menuApiRouteSource(action) {
+	return {
+		sourceType: "api_route",
+		sourceName: `menu.${menuRouteVerb(action)}`
+	};
+}
+function taxonomyApiRouteSource(action) {
+	return {
+		sourceType: "api_route",
+		sourceName: `taxonomy.${taxonomyRouteVerb(action)}`
+	};
+}
+function exclusiveHookApiRouteSource(action) {
+	return {
+		sourceType: "api_route",
+		sourceName: `exclusive_hook.${exclusiveHookRouteVerb(action)}`
+	};
+}
+function redirectApiRouteSource(action) {
+	return {
+		sourceType: "api_route",
+		sourceName: `redirect.${redirectRouteVerb(action)}`
+	};
+}
+function sectionApiRouteSource(action) {
+	return {
+		sourceType: "api_route",
+		sourceName: `section.${sectionRouteVerb(action)}`
+	};
+}
+function settingsApiRouteSource(action) {
+	return {
+		sourceType: "api_route",
+		sourceName: `settings.${settingsRouteVerb(action)}`
+	};
+}
+function widgetApiRouteSource(action) {
+	return {
+		sourceType: "api_route",
+		sourceName: widgetRouteSourceName(action)
+	};
+}
+function extractActivityItem(data) {
+	if (!isRecord(data)) return null;
+	const item = data.item;
+	return isRecord(item) ? item : data;
+}
+function collectionScope(collection) {
+	return `collection:${collection}`;
+}
+function contentScope(collection, entryId) {
+	return `content:${collection}:${entryId}`;
+}
+function pluginScope(pluginId) {
+	return `plugin:${pluginId}`;
+}
+function contentRouteVerb(action) {
+	switch (action) {
+		case "created": return "create";
+		case "updated": return "update";
+		case "deleted": return "delete";
+		case "published": return "publish";
+		case "unpublished": return "unpublish";
+		case "scheduled": return "schedule";
+		case "unscheduled": return "unschedule";
+		case "restored": return "restore";
+		case "permanently_deleted": return "permanent_delete";
+		case "duplicated": return "duplicate";
+		case "draft_discarded": return "discard_draft";
+	}
+}
+function schemaRouteVerb(action) {
+	switch (action) {
+		case "collection_created": return "collection.create";
+		case "collection_updated": return "collection.update";
+		case "collection_deleted": return "collection.delete";
+		case "field_created": return "field.create";
+		case "field_updated": return "field.update";
+		case "field_deleted": return "field.delete";
+		case "fields_reordered": return "fields.reorder";
+	}
+}
+function schemaMcpToolName(action) {
+	switch (action) {
+		case "collection_created": return "schema_create_collection";
+		case "collection_deleted": return "schema_delete_collection";
+		case "field_created": return "schema_create_field";
+		case "field_deleted": return "schema_delete_field";
+	}
+}
+function pluginRouteVerb(action) {
+	switch (action) {
+		case "installed": return "install";
+		case "enabled": return "enable";
+		case "disabled": return "disable";
+		case "updated": return "update";
+		case "uninstalled": return "uninstall";
+	}
+}
+function menuRouteVerb(action) {
+	switch (action) {
+		case "created": return "create";
+		case "updated": return "update";
+		case "deleted": return "delete";
+		case "item_created": return "item.create";
+		case "item_updated": return "item.update";
+		case "item_deleted": return "item.delete";
+		case "reordered": return "reorder";
+	}
+}
+function taxonomyRouteVerb(action) {
+	switch (action) {
+		case "created": return "create";
+		case "term_created": return "term.create";
+		case "term_updated": return "term.update";
+		case "term_deleted": return "term.delete";
+	}
+}
+function exclusiveHookRouteVerb(action) {
+	switch (action) {
+		case "updated": return "update";
+	}
+}
+function redirectRouteVerb(action) {
+	switch (action) {
+		case "created": return "create";
+		case "updated": return "update";
+		case "deleted": return "delete";
+	}
+}
+function sectionRouteVerb(action) {
+	switch (action) {
+		case "created": return "create";
+		case "updated": return "update";
+		case "deleted": return "delete";
+	}
+}
+function settingsRouteVerb(action) {
+	switch (action) {
+		case "updated": return "update";
+	}
+}
+function widgetRouteSourceName(action) {
+	switch (action) {
+		case "area_created": return "widget_area.create";
+		case "area_deleted": return "widget_area.delete";
+		case "created": return "widget.create";
+		case "updated": return "widget.update";
+		case "deleted": return "widget.delete";
+		case "reordered": return "widget_area.reorder";
+	}
+}
+function activityProvenance(input) {
+	return {
+		sourceType: input.sourceType ?? null,
+		sourceName: input.sourceName ?? null,
+		resultStatus: input.resultStatus ?? "succeeded"
+	};
+}
+function menuScope(menuName) {
+	return `menu:${menuName}`;
+}
+function taxonomyScope(taxonomyName) {
+	return `taxonomy:${taxonomyName}`;
+}
+function defaultMenuSummary(input) {
+	switch (input.action) {
+		case "created": return `Created menu ${input.menuName}`;
+		case "updated": return `Updated menu ${input.menuName}`;
+		case "deleted": return `Deleted menu ${input.menuName}`;
+		case "item_created": return `Created menu item in ${input.menuName}`;
+		case "item_updated": return `Updated menu item ${input.itemId ?? ""}`.trim();
+		case "item_deleted": return `Deleted menu item ${input.itemId ?? ""}`.trim();
+		case "reordered": return `Reordered menu ${input.menuName}`;
+	}
+}
+function defaultRedirectSummary(input) {
+	switch (input.action) {
+		case "created": return `Created redirect ${input.source}`;
+		case "updated": return `Updated redirect ${input.source}`;
+		case "deleted": return `Deleted redirect ${input.source}`;
+	}
+}
+function defaultTaxonomySummary(input) {
+	switch (input.action) {
+		case "created": return `Created taxonomy ${input.taxonomyName}`;
+		case "term_created": return `Created taxonomy term ${input.termSlug ?? ""}`.trim();
+		case "term_updated": return `Updated taxonomy term ${input.termSlug ?? ""}`.trim();
+		case "term_deleted": return `Deleted taxonomy term ${input.termSlug ?? ""}`.trim();
+	}
+}
+function taxonomyTermFallbackId(taxonomyName, termSlug) {
+	return termSlug ? `${taxonomyName}:${termSlug}` : taxonomyName;
+}
+function defaultSectionSummary(input) {
+	switch (input.action) {
+		case "created": return `Created section ${input.sectionSlug}`;
+		case "updated": return `Updated section ${input.sectionSlug}`;
+		case "deleted": return `Deleted section ${input.sectionSlug}`;
+	}
+}
+function defaultExclusiveHookSummary(input) {
+	return input.selectedPluginId ? `Selected ${input.selectedPluginId} for exclusive hook ${input.hookName}` : `Cleared the selected provider for exclusive hook ${input.hookName}`;
+}
+function defaultWidgetSummary(input) {
+	switch (input.action) {
+		case "area_created": return `Created widget area ${input.areaName}`;
+		case "area_deleted": return `Deleted widget area ${input.areaName}`;
+		case "created": return `Created widget in ${input.areaName}`;
+		case "updated": return `Updated widget ${input.widgetId ?? ""}`.trim();
+		case "deleted": return `Deleted widget ${input.widgetId ?? ""}`.trim();
+		case "reordered": return `Reordered widgets in ${input.areaName}`;
+	}
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+//#endregion
+export { taxonomyApiRouteSource as C, settingsApiRouteSource as S, resolveActorIdentity as T, pluginApiRouteSource as _, extractActivityItemId as a, schemaMcpToolSource as b, logMenuActivity as c, logSchemaActivity as d, logSectionActivity as f, menuApiRouteSource as g, logWidgetActivity as h, exclusiveHookApiRouteSource as i, logPluginActivity as l, logTaxonomyActivity as m, contentApiRouteSource as n, logContentActivity as o, logSiteActivitySafely as p, contentMcpToolSource as r, logExclusiveHookActivity as s, activityChangedKeys as t, logRedirectActivity as u, redirectApiRouteSource as v, widgetApiRouteSource as w, sectionApiRouteSource as x, schemaApiRouteSource as y };